Tracking de l'application VApp (IHM du jeu)

VApp/node_modules/@vuetify/loader-shared/dist/index.mjs

@@ -0,0 +1,132 @@
+import { createRequire } from 'node:module';
+import path from 'upath';
+import { capitalize, camelize } from 'vue';
+import importMap from 'vuetify/dist/json/importMap.json' assert { type: 'json' };
+import importMapLabs from 'vuetify/dist/json/importMap-labs.json' assert { type: 'json' };
+
+function parseTemplate(source) {
+  const components = createSet(source.matchAll(/(?:var|const) (\w+) = _resolveComponent\("([\w-.]+)"\);?/gm));
+  const directives = createSet(source.matchAll(/(?:var|const) (\w+) = _resolveDirective\("([\w-.]+)"\);?/gm));
+  return { components, directives };
+}
+function createSet(matches) {
+  return new Set(Array.from(matches, (i) => ({
+    symbol: i[1],
+    name: capitalize(camelize(i[2])),
+    index: i.index,
+    length: i[0].length
+  })));
+}
+
+function getImports(source, options) {
+  const { components, directives } = parseTemplate(source);
+  const resolvedComponents = [];
+  const resolvedDirectives = [];
+  const imports = /* @__PURE__ */ new Map();
+  const ignore = isObject(options.autoImport) && options.autoImport.ignore || null;
+  const includeLabs = isObject(options.autoImport) && options.autoImport.labs;
+  const map = includeLabs ? {
+    components: { ...importMap.components, ...importMapLabs.components },
+    directives: importMap.directives
+  } : importMap;
+  if (components.size || directives.size) {
+    components.forEach((component) => {
+      if (ignore?.includes(component.name))
+        return;
+      if (component.name in importMap.components) {
+        resolvedComponents.push(component);
+      } else if (includeLabs && component.name in importMapLabs.components) {
+        resolvedComponents.push(component);
+      }
+    });
+    directives.forEach((directive) => {
+      if (importMap.directives.includes(directive.name) && !ignore?.includes(directive.name)) {
+        resolvedDirectives.push(directive);
+      }
+    });
+  }
+  resolvedComponents.forEach((component) => {
+    addImport(imports, component.name, component.symbol, "vuetify/lib/" + map.components[component.name].from);
+  });
+  resolvedDirectives.forEach((directive) => {
+    addImport(imports, directive.name, directive.symbol, "vuetify/lib/directives/index.mjs");
+  });
+  return {
+    imports,
+    components: resolvedComponents,
+    directives: resolvedDirectives
+  };
+}
+function addImport(imports, name, as, from) {
+  if (!imports.has(from)) {
+    imports.set(from, []);
+  }
+  imports.get(from).push(`${name} as ${as}`);
+}
+
+function generateImports(source, options) {
+  const { imports, components, directives } = getImports(source, options);
+  let code = "";
+  if (components.length || directives.length) {
+    code += "\n\n/* Vuetify */\n";
+    Array.from(imports).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0).forEach(([from, names]) => {
+      code += `import { ${names.join(", ")} } from "${from}"
+`;
+    });
+    code += "\n";
+    source = [...components, ...directives].reduce((acc, v) => {
+      return acc.slice(0, v.index) + " ".repeat(v.length) + acc.slice(v.index + v.length);
+    }, source);
+  }
+  return { code, source };
+}
+
+const require = createRequire(import.meta.url);
+function resolveVuetifyBase() {
+  return path.dirname(require.resolve("vuetify/package.json", { paths: [process.cwd()] }));
+}
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function includes(arr, val) {
+  return arr.includes(val);
+}
+function normalizePath(p) {
+  p = path.normalize(p);
+  return /^[a-z]:\//i.test(p) ? "/" + p : p;
+}
+function toKebabCase(str = "") {
+  return str.replace(/[^a-z]/gi, "-").replace(/\B([A-Z])/g, "-$1").toLowerCase();
+}
+const defaultTags = {
+  video: ["src", "poster"],
+  source: ["src"],
+  img: ["src"],
+  image: ["xlink:href", "href"],
+  use: ["xlink:href", "href"]
+};
+const transformAssetUrls = {
+  VAppBar: ["image"],
+  VAvatar: ["image"],
+  VBanner: ["avatar"],
+  VCard: ["image", "prependAvatar", "appendAvatar"],
+  VCardItem: ["prependAvatar", "appendAvatar"],
+  VCarouselItem: ["src", "lazySrc", "srcset"],
+  VChip: ["prependAvatar", "appendAvatar"],
+  VImg: ["src", "lazySrc", "srcset"],
+  VListItem: ["prependAvatar", "appendAvatar"],
+  VNavigationDrawer: ["image"],
+  VParallax: ["src", "lazySrc", "srcset"],
+  VToolbar: ["image"]
+};
+for (const [tag, attrs] of Object.entries(transformAssetUrls)) {
+  attrs.forEach((attr) => {
+    if (/[A-Z]/.test(attr)) {
+      attrs.push(toKebabCase(attr));
+    }
+  });
+  transformAssetUrls[toKebabCase(tag)] = attrs;
+}
+Object.assign(transformAssetUrls, defaultTags);
+
+export { generateImports, includes, isObject, normalizePath, resolveVuetifyBase, toKebabCase, transformAssetUrls };