@navita/vite-plugin 0.0.1 → 0.0.4

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Alexander Liljengård
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/index.d.ts

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

package/index.js

@@ -1,11 +1,8 @@
 '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);
@@ -25,69 +22,17 @@ function _interopNamespaceDefault(e) {
 }
 
 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();
+    let renderer;
     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",
@@ -95,20 +40,25 @@ function navita(options) {
             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);
+        async buildStart () {
+            const defaultEngineOptions = {
+                enableSourceMaps: !!server,
+                enableDebugIdentifiers: !!server,
+                ...options?.engineOptions || {}
+            };
+            renderer = createRenderer.createRenderer({
+                importMap,
+                engineOptions: defaultEngineOptions,
+                resolver: async (filepath, request)=>{
+                    const resolved = await this.resolve(request, filepath);
+                    return resolved?.id || null;
+                },
+                readFile: (path)=>{
+                    return fs__namespace.promises.readFile(path, 'utf-8');
                 }
-            }
+            });
+        },
+        async resolveId (source) {
             if (source === VIRTUAL_MODULE_NAME) {
                 return VIRTUAL_CSS_NAME;
             }
@@ -120,21 +70,16 @@ function navita(options) {
             }
             return null;
         },
-        async transform (code, id, options) {
+        async transform (code, id) {
             // 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();
+            const { result  } = await renderer.transformAndProcess({
+                content: code,
+                filePath: id
+            });
+            const newCssContent = renderer.engine.renderCssToString();
             if (lastCssContent !== newCssContent) {
                 if (server) {
                     const { moduleGraph  } = server;
@@ -147,10 +92,21 @@ function navita(options) {
                 lastCssContent = newCssContent;
             }
             return `
-        ${evaluatedResult}
         ${result}
         import "${VIRTUAL_MODULE_NAME}";
       `;
+        },
+        renderChunk (_, chunk) {
+            for (const id of Object.keys(chunk.modules)){
+                if (id.startsWith(VIRTUAL_CSS_NAME)) {
+                    delete chunk.modules[id];
+                }
+            }
+            chunk.viteMetadata.importedCss.add(this.getFileName(this.emitFile({
+                name: "navita.css",
+                type: "asset",
+                source: renderer.engine.renderCssToString()
+            })));
         }
     };
 }

package/index.mjs

@@ -1,75 +1,17 @@
-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();
+    let renderer;
     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",
@@ -77,20 +19,25 @@ function navita(options) {
             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);
+        async buildStart () {
+            const defaultEngineOptions = {
+                enableSourceMaps: !!server,
+                enableDebugIdentifiers: !!server,
+                ...options?.engineOptions || {}
+            };
+            renderer = createRenderer({
+                importMap: importMap$1,
+                engineOptions: defaultEngineOptions,
+                resolver: async (filepath, request)=>{
+                    const resolved = await this.resolve(request, filepath);
+                    return resolved?.id || null;
+                },
+                readFile: (path)=>{
+                    return fs.promises.readFile(path, 'utf-8');
                 }
-            }
+            });
+        },
+        async resolveId (source) {
             if (source === VIRTUAL_MODULE_NAME) {
                 return VIRTUAL_CSS_NAME;
             }
@@ -102,21 +49,16 @@ function navita(options) {
             }
             return null;
         },
-        async transform (code, id, options) {
+        async transform (code, id) {
             // 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();
+            const { result  } = await renderer.transformAndProcess({
+                content: code,
+                filePath: id
+            });
+            const newCssContent = renderer.engine.renderCssToString();
             if (lastCssContent !== newCssContent) {
                 if (server) {
                     const { moduleGraph  } = server;
@@ -129,10 +71,21 @@ function navita(options) {
                 lastCssContent = newCssContent;
             }
             return `
-        ${evaluatedResult}
         ${result}
         import "${VIRTUAL_MODULE_NAME}";
       `;
+        },
+        renderChunk (_, chunk) {
+            for (const id of Object.keys(chunk.modules)){
+                if (id.startsWith(VIRTUAL_CSS_NAME)) {
+                    delete chunk.modules[id];
+                }
+            }
+            chunk.viteMetadata.importedCss.add(this.getFileName(this.emitFile({
+                name: "navita.css",
+                type: "asset",
+                source: renderer.engine.renderCssToString()
+            })));
         }
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navita/vite-plugin",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "license": "MIT",
   "private": false,
   "sideEffects": false,
@@ -12,9 +12,7 @@
     }
   },
   "dependencies": {
-    "@navita/core": "0.0.0",
-    "@navita/swc": "0.0.0",
-    "@navita/css": "0.0.0",
-    "@navita/compiler": "0.0.1"
+    "@navita/core": "0.0.4",
+    "@navita/css": "0.0.4"
   }
 }