@navita/vite-plugin 0.0.0

package/index.d.ts

@@ -0,0 +1,9 @@
+import { ImportMap } from '@navita/swc';
+import { Plugin } from 'vite';
+
+interface Options {
+    importMap?: ImportMap;
+}
+declare function navita(options?: Options): Plugin;
+
+export { navita };

package/index.js

@@ -0,0 +1,158 @@
+'use strict';
+
+var fs = require('node:fs');
+var path = require('node:path');
+var compiler = require('@navita/compiler');
+var createRenderer = require('@navita/core/createRenderer');
+var css = require('@navita/css');
+var swc = require('@navita/swc');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
+const isExternal = (id)=>id.includes('node_modules') || id.startsWith(path__namespace.resolve(__dirname, '../../'));
+const ENTRY_EXTENSIONS = /\.[tj]sx?$/;
+const VIRTUAL_MODULE_NAME = 'virtual:navita';
+const VIRTUAL_CSS_NAME = 'virtual:navita.css';
+async function navitaCompiler(entryPoint, resolver, renderer, onDisposePromise) {
+    const compiler$1 = await compiler.createCompiler({
+        entryPoint,
+        renderer,
+        async resolver (args) {
+            const result = await resolver(args.path, args.importer);
+            if (!result) {
+                throw new Error(`Failed to resolve ${args.path}`);
+            }
+            const external = isExternal(result.id);
+            if (external) {
+                return {
+                    path: args.path,
+                    sideEffects: false,
+                    external: true
+                };
+            }
+            return {
+                path: result.id,
+                sideEffects: undefined,
+                external: false
+            };
+        },
+        readFile: fs__namespace.promises.readFile
+    }, onDisposePromise);
+    return compiler$1.rebuild();
+}
+function navita(options) {
+    const renderer = createRenderer.createRenderer();
+    const importMap = [
+        ...css.importMap,
+        ...options?.importMap || []
+    ];
+    let server;
+    let lastCssContent;
+    const dependencyGraph = new Map();
+    const addToGraph = (importer, source)=>{
+        if (!importer) {
+            return;
+        }
+        const dependencies = dependencyGraph.get(importer) || new Set();
+        dependencies.add(source);
+        dependencyGraph.set(importer, dependencies);
+    };
+    const findEntryPoints = (id)=>{
+        const result = [];
+        for (const [importer, dependencies] of dependencyGraph.entries()){
+            if (dependencies.has(id)) {
+                result.push(...findEntryPoints(importer), importer);
+            }
+        }
+        return result;
+    };
+    let dispose;
+    const buildEndPromise = new Promise((resolve)=>{
+        dispose = resolve;
+    });
+    return {
+        name: "navita",
+        enforce: "pre",
+        configureServer (_server) {
+            lastCssContent = undefined;
+            server = _server;
+        },
+        async buildEnd () {
+            await dispose();
+        },
+        async resolveId (source, importer, options) {
+            const resolved = await this.resolve(source, importer, {
+                ...options,
+                skipSelf: true
+            });
+            if (resolved) {
+                const { id  } = resolved;
+                if (!isExternal(id) && importer) {
+                    addToGraph(importer, id);
+                }
+            }
+            if (source === VIRTUAL_MODULE_NAME) {
+                return VIRTUAL_CSS_NAME;
+            }
+            return null;
+        },
+        async load (id) {
+            if (id === VIRTUAL_CSS_NAME) {
+                return lastCssContent;
+            }
+            return null;
+        },
+        async transform (code, id, options) {
+            // Bail as early as we can
+            if (!importMap.map((x)=>x.source).some((value)=>code.indexOf(value) !== -1)) {
+                return null;
+            }
+            const entryPoint = findEntryPoints(id).find((entryPoint)=>ENTRY_EXTENSIONS.test(entryPoint)) || id;
+            const [result] = await Promise.all([
+                swc.transformer(code, {
+                    filename: id,
+                    importMap: []
+                }),
+                navitaCompiler(entryPoint, this.resolve.bind(this), renderer, buildEndPromise)
+            ]);
+            const { result: evaluatedResult  } = renderer.getResult(id, options?.ssr);
+            const newCssContent = renderer.renderToString();
+            if (lastCssContent !== newCssContent) {
+                if (server) {
+                    const { moduleGraph  } = server;
+                    const virtualModule = moduleGraph.getModuleById(VIRTUAL_CSS_NAME);
+                    if (virtualModule) {
+                        moduleGraph.invalidateModule(virtualModule);
+                        virtualModule.lastHMRTimestamp = Date.now();
+                    }
+                }
+                lastCssContent = newCssContent;
+            }
+            return `
+        ${evaluatedResult}
+        ${result}
+        import "${VIRTUAL_MODULE_NAME}";
+      `;
+        }
+    };
+}
+
+exports.navita = navita;

package/index.mjs

@@ -0,0 +1,140 @@
+import { fileURLToPath as fileURLToPath$1 } from 'url';
+const __filename = fileURLToPath$1(import.meta.url);
+import { dirname as dirname$1 } from 'path';
+const __dirname = dirname$1(__filename);
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createCompiler } from '@navita/compiler';
+import { createRenderer } from '@navita/core/createRenderer';
+import { importMap } from '@navita/css';
+import { transformer } from '@navita/swc';
+
+const isExternal = (id)=>id.includes('node_modules') || id.startsWith(path.resolve(__dirname, '../../'));
+const ENTRY_EXTENSIONS = /\.[tj]sx?$/;
+const VIRTUAL_MODULE_NAME = 'virtual:navita';
+const VIRTUAL_CSS_NAME = 'virtual:navita.css';
+async function navitaCompiler(entryPoint, resolver, renderer, onDisposePromise) {
+    const compiler = await createCompiler({
+        entryPoint,
+        renderer,
+        async resolver (args) {
+            const result = await resolver(args.path, args.importer);
+            if (!result) {
+                throw new Error(`Failed to resolve ${args.path}`);
+            }
+            const external = isExternal(result.id);
+            if (external) {
+                return {
+                    path: args.path,
+                    sideEffects: false,
+                    external: true
+                };
+            }
+            return {
+                path: result.id,
+                sideEffects: undefined,
+                external: false
+            };
+        },
+        readFile: fs.promises.readFile
+    }, onDisposePromise);
+    return compiler.rebuild();
+}
+function navita(options) {
+    const renderer = createRenderer();
+    const importMap$1 = [
+        ...importMap,
+        ...options?.importMap || []
+    ];
+    let server;
+    let lastCssContent;
+    const dependencyGraph = new Map();
+    const addToGraph = (importer, source)=>{
+        if (!importer) {
+            return;
+        }
+        const dependencies = dependencyGraph.get(importer) || new Set();
+        dependencies.add(source);
+        dependencyGraph.set(importer, dependencies);
+    };
+    const findEntryPoints = (id)=>{
+        const result = [];
+        for (const [importer, dependencies] of dependencyGraph.entries()){
+            if (dependencies.has(id)) {
+                result.push(...findEntryPoints(importer), importer);
+            }
+        }
+        return result;
+    };
+    let dispose;
+    const buildEndPromise = new Promise((resolve)=>{
+        dispose = resolve;
+    });
+    return {
+        name: "navita",
+        enforce: "pre",
+        configureServer (_server) {
+            lastCssContent = undefined;
+            server = _server;
+        },
+        async buildEnd () {
+            await dispose();
+        },
+        async resolveId (source, importer, options) {
+            const resolved = await this.resolve(source, importer, {
+                ...options,
+                skipSelf: true
+            });
+            if (resolved) {
+                const { id  } = resolved;
+                if (!isExternal(id) && importer) {
+                    addToGraph(importer, id);
+                }
+            }
+            if (source === VIRTUAL_MODULE_NAME) {
+                return VIRTUAL_CSS_NAME;
+            }
+            return null;
+        },
+        async load (id) {
+            if (id === VIRTUAL_CSS_NAME) {
+                return lastCssContent;
+            }
+            return null;
+        },
+        async transform (code, id, options) {
+            // Bail as early as we can
+            if (!importMap$1.map((x)=>x.source).some((value)=>code.indexOf(value) !== -1)) {
+                return null;
+            }
+            const entryPoint = findEntryPoints(id).find((entryPoint)=>ENTRY_EXTENSIONS.test(entryPoint)) || id;
+            const [result] = await Promise.all([
+                transformer(code, {
+                    filename: id,
+                    importMap: []
+                }),
+                navitaCompiler(entryPoint, this.resolve.bind(this), renderer, buildEndPromise)
+            ]);
+            const { result: evaluatedResult  } = renderer.getResult(id, options?.ssr);
+            const newCssContent = renderer.renderToString();
+            if (lastCssContent !== newCssContent) {
+                if (server) {
+                    const { moduleGraph  } = server;
+                    const virtualModule = moduleGraph.getModuleById(VIRTUAL_CSS_NAME);
+                    if (virtualModule) {
+                        moduleGraph.invalidateModule(virtualModule);
+                        virtualModule.lastHMRTimestamp = Date.now();
+                    }
+                }
+                lastCssContent = newCssContent;
+            }
+            return `
+        ${evaluatedResult}
+        ${result}
+        import "${VIRTUAL_MODULE_NAME}";
+      `;
+        }
+    };
+}
+
+export { navita };

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@navita/vite-plugin",
+  "version": "0.0.0",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "types": "./index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@navita/core": "0.0.0",
+    "@navita/css": "0.0.0",
+    "@navita/swc": "0.0.0",
+    "@navita/compiler": "0.0.0"
+  }
+}