@dative-gpi/foundation-shared-loader 0.0.2

package/dist/generateImports.d.ts

@@ -0,0 +1,4 @@
+export declare function generateImports(source: string): {
+    code: string;
+    source: string;
+};

package/dist/generateImports.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImports = void 0;
+const getImports_1 = require("./getImports");
+function generateImports(source) {
+    const { imports, components, directives } = (0, getImports_1.getImports)(source);
+    let code = '';
+    if (components.length || directives.length) {
+        code += '\n\n/* Foundation */\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}"\n`;
+        });
+        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 };
+}
+exports.generateImports = generateImports;

package/dist/getImports.d.ts

@@ -0,0 +1,6 @@
+import { type TemplateMatch } from './parseTemplate';
+export declare function getImports(source: string): {
+    imports: Map<string, string[]>;
+    components: TemplateMatch[];
+    directives: TemplateMatch[];
+};

package/dist/getImports.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImports = void 0;
+const parseTemplate_1 = require("./parseTemplate");
+const sharedImportMap = __importStar(require("@dative-gpi/foundation-shared-components/importMap.json"));
+const coreImportMap = __importStar(require("@dative-gpi/foundation-core-components/importMap.json"));
+const adminImportMap = __importStar(require("@dative-gpi/foundation-admin-components/importMap.json"));
+function getImports(source) {
+    const { components, directives } = (0, parseTemplate_1.parseTemplate)(source);
+    const resolvedComponents = [];
+    const resolvedDirectives = [];
+    const imports = new Map();
+    if (components.size || directives.size) {
+        components.forEach(component => {
+            if (component.name in sharedImportMap.components) {
+                resolvedComponents.push(component);
+                addImport(imports, component.name, component.symbol, sharedImportMap.components[component.name].from);
+            }
+            else if (component.name in coreImportMap.components) {
+                resolvedComponents.push(component);
+                addImport(imports, component.name, component.symbol, coreImportMap.components[component.name].from);
+            }
+            else if (component.name in adminImportMap.components) {
+                resolvedComponents.push(component);
+                addImport(imports, component.name, component.symbol, adminImportMap.components[component.name].from);
+            }
+        });
+        // directives.forEach(directive => {
+        //   if (importMap.directives.includes(directive.name)) {
+        //     resolvedDirectives.push(directive)
+        //   }
+        // })
+    }
+    // resolvedComponents.forEach(component => {
+    //   addImport(imports, component.name, component.symbol, (sharedImportMap.components as any)[component.name].from)
+    // })
+    // resolvedDirectives.forEach(directive => {
+    //   addImport(imports, directive.name, directive.symbol, 'foundation/lib/directives/index.mjs')
+    // })
+    return {
+        imports,
+        components: resolvedComponents,
+        directives: resolvedDirectives,
+    };
+}
+exports.getImports = getImports;
+function addImport(imports, name, as, from) {
+    if (!imports.has(from)) {
+        imports.set(from, []);
+    }
+    imports.get(from).push(`${as}`);
+}

package/dist/importPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'vite';
+export declare function importPlugin(): Plugin;

package/dist/importPlugin.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importPlugin = void 0;
+const path_1 = require("path");
+const generateImports_1 = require("./generateImports");
+const url_1 = require("url");
+function parseId(id) {
+    const { query, pathname } = (0, url_1.parse)(id);
+    return {
+        query: query ? Object.fromEntries(new url_1.URLSearchParams(query)) : null,
+        path: pathname ?? id
+    };
+}
+function importPlugin() {
+    return {
+        name: 'foundation:import',
+        configResolved(config) {
+            if (config.plugins.findIndex(plugin => plugin.name === 'foundation:import') < config.plugins.findIndex(plugin => plugin.name === 'vite:vue')) {
+                throw new Error('Foundation plugin must be loaded after the vue plugin');
+            }
+        },
+        async transform(code, id) {
+            const { query, path } = parseId(id);
+            if (((!query || !('vue' in query)) && (0, path_1.extname)(path) === '.vue' && !/^import { render as _sfc_render } from ".*"$/m.test(code)) ||
+                (query && 'vue' in query && (query.type === 'template' || (query.type === 'script' && query.setup === 'true')))) {
+                const { code: imports, source } = (0, generateImports_1.generateImports)(code);
+                return {
+                    code: source + imports,
+                    map: null,
+                };
+            }
+            return null;
+        }
+    };
+}
+exports.importPlugin = importPlugin;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'vite';
+declare function FoundationSharedAutoImport(): Plugin[];
+export default FoundationSharedAutoImport;

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const importPlugin_1 = require("./importPlugin");
+function FoundationSharedAutoImport() {
+    const plugins = [];
+    plugins.push((0, importPlugin_1.importPlugin)());
+    return plugins;
+}
+module.exports = FoundationSharedAutoImport;
+exports.default = FoundationSharedAutoImport;

package/dist/parseTemplate.d.ts

@@ -0,0 +1,10 @@
+export declare function parseTemplate(source: string): {
+    components: Set<TemplateMatch>;
+    directives: Set<TemplateMatch>;
+};
+export interface TemplateMatch {
+    symbol: string;
+    name: string;
+    index: number;
+    length: number;
+}

package/dist/parseTemplate.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTemplate = void 0;
+const vue_1 = require("vue");
+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 };
+}
+exports.parseTemplate = parseTemplate;
+function createSet(matches) {
+    return new Set(Array.from(matches, i => ({
+        symbol: i[1],
+        name: (0, vue_1.capitalize)((0, vue_1.camelize)(i[2])),
+        index: i.index,
+        length: i[0].length,
+    })));
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@dative-gpi/foundation-shared-loader",
+  "version": "0.0.2",
+  "main": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "npx tsc --resolveJsonModule"
+  },
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "vite-plugin"
+  ],
+  "description": "",
+  "devDependencies": {
+    "@babel/types": "^7.23.0",
+    "@dative-gpi/foundation-admin-components": "0.0.2",
+    "@dative-gpi/foundation-core-components": "0.0.2",
+    "@dative-gpi/foundation-shared-components": "0.0.2",
+    "@types/node": "^20.8.9",
+    "typescript": "^5.2.2",
+    "vite": "^4.5.0"
+  },
+  "gitHead": "44e9629c836e0cd06289b208b53120f07775ea5e"
+}

package/plugin/generateImports.ts

@@ -0,0 +1,22 @@
+import { getImports } from './getImports'
+
+export function generateImports (source: string) {
+  const { imports, components, directives } = getImports(source)
+
+  let code = ''
+
+  if (components.length || directives.length) {
+    code += '\n\n/* Foundation */\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}"\n`
+      })
+    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 }
+}

package/plugin/getImports.ts

@@ -0,0 +1,53 @@
+import { parseTemplate, type TemplateMatch } from './parseTemplate'
+import * as sharedImportMap from '@dative-gpi/foundation-shared-components/importMap.json'
+import * as coreImportMap from '@dative-gpi/foundation-core-components/importMap.json'
+import * as adminImportMap from '@dative-gpi/foundation-admin-components/importMap.json'
+
+export function getImports (source: string) {
+  const { components, directives } = parseTemplate(source)
+  const resolvedComponents: TemplateMatch[] = []
+  const resolvedDirectives: TemplateMatch[] = []
+  const imports = new Map<string, string[]>()
+
+  if (components.size || directives.size) {
+    components.forEach(component => {
+      if (component.name in sharedImportMap.components) {
+        resolvedComponents.push(component)
+        addImport(imports, component.name, component.symbol, (sharedImportMap.components as any)[component.name].from)
+      }
+      else if (component.name in coreImportMap.components) {
+        resolvedComponents.push(component)
+        addImport(imports, component.name, component.symbol, (coreImportMap.components as any)[component.name].from)
+      }
+      else if (component.name in adminImportMap.components) {
+        resolvedComponents.push(component)
+        addImport(imports, component.name, component.symbol, (adminImportMap.components as any)[component.name].from)
+      }
+    })
+    // directives.forEach(directive => {
+    //   if (importMap.directives.includes(directive.name)) {
+    //     resolvedDirectives.push(directive)
+    //   }
+    // })
+  }
+
+  // resolvedComponents.forEach(component => {
+  //   addImport(imports, component.name, component.symbol, (sharedImportMap.components as any)[component.name].from)
+  // })
+  // resolvedDirectives.forEach(directive => {
+  //   addImport(imports, directive.name, directive.symbol, 'foundation/lib/directives/index.mjs')
+  // })
+
+  return {
+    imports,
+    components: resolvedComponents,
+    directives: resolvedDirectives,
+  }
+}
+
+function addImport (imports: Map<string, string[]>, name: string, as: string, from: string) {
+  if (!imports.has(from)) {
+    imports.set(from, [])
+  }
+  imports.get(from)!.push(`${as}`)
+}

package/plugin/importPlugin.ts

@@ -0,0 +1,40 @@
+import { extname } from 'path'
+import type { Plugin } from 'vite'
+import { generateImports } from './generateImports'
+import { parse as parseUrl, URLSearchParams } from 'url'
+
+function parseId(id: string) {
+  const { query, pathname } = parseUrl(id)
+
+  return {
+    query: query ? Object.fromEntries(new URLSearchParams(query)) : null,
+    path: pathname ?? id
+  }
+}
+
+export function importPlugin(): Plugin {
+  return {
+    name: 'foundation:import',
+    configResolved(config) {
+      if (config.plugins.findIndex(plugin => plugin.name === 'foundation:import') < config.plugins.findIndex(plugin => plugin.name === 'vite:vue')) {
+        throw new Error('Foundation plugin must be loaded after the vue plugin')
+      }
+    },
+    async transform(code, id) {
+      const { query, path } = parseId(id)
+
+      if (
+        ((!query || !('vue' in query)) && extname(path) === '.vue' && !/^import { render as _sfc_render } from ".*"$/m.test(code)) ||
+        (query && 'vue' in query && (query.type === 'template' || (query.type === 'script' && query.setup === 'true')))
+      ) {
+        const { code: imports, source } = generateImports(code)
+        return {
+          code: source + imports,
+          map: null,
+        }
+      }
+      return null
+    }
+
+  }
+}

package/plugin/index.ts

@@ -0,0 +1,13 @@
+import { Plugin } from 'vite'
+
+import { importPlugin } from './importPlugin'
+
+function FoundationSharedAutoImport ( ): Plugin[] {
+  const plugins: Plugin[] = []
+    plugins.push(importPlugin())
+
+  return plugins
+}
+
+module.exports = FoundationSharedAutoImport
+export default FoundationSharedAutoImport

package/plugin/parseTemplate.ts

@@ -0,0 +1,24 @@
+import { camelize, capitalize } from 'vue'
+
+export function parseTemplate (source: string) {
+  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 }
+}
+
+export interface TemplateMatch {
+  symbol: string,
+  name: string,
+  index: number,
+  length: number,
+}
+
+function createSet (matches: IterableIterator<RegExpMatchArray>): Set<TemplateMatch> {
+  return new Set(Array.from(matches, i => ({
+    symbol: i[1],
+    name: capitalize(camelize(i[2])),
+    index: i.index!,
+    length: i[0].length,
+  })))
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+    "compilerOptions": {
+      "target": "ES2020",
+      "module": "CommonJS",
+      "outDir": "./dist",
+      "rootDir": "./plugin",
+      "strict": false,
+      "declaration": true,
+      "esModuleInterop": true,
+      "skipLibCheck": true
+    },
+    "include": ["plugin/**/*.ts", "plugin/importMap.json"]
+  }
+