@navita/core 0.0.0 → 0.0.2

package/evaluateAndProcess.js

@@ -1,66 +1,271 @@
 'use strict';
 
-var node_path = require('node:path');
+var path = require('node:path');
+var swc = require('@navita/swc');
 var vm = require('node:vm');
+var fs = require('node:fs');
+var enhancedResolve = require('enhanced-resolve');
+var engine = require('@navita/engine');
+var adapter = require('@navita/adapter');
 
-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]; }
-        });
-      }
+function createMagicProxy() {
+    // Todo: at some point, the magic proxy should notify the user
+    //  that they are using a browser API in a node environment
+    return new Proxy({}, {
+        get: ()=>createMagicProxy()
     });
-  }
-  n.default = e;
-  return Object.freeze(n);
 }
 
-var vm__namespace = /*#__PURE__*/_interopNamespaceDefault(vm);
+const context = vm.createContext({
+    global
+});
+const vmGlobalsRecord = new vm.Script(`
+Object
+  .getOwnPropertyNames(globalThis)
+  .reduce((acc, name) => ({
+    ...acc,
+    [name]: globalThis[name],
+  }), {});
+`).runInContext(context);
+const vmGlobalsNonEnumerableRecord = {};
+Object.getOwnPropertyNames(global).forEach((name)=>{
+    // The second condition here is to prevent jest's Symbol polyfill from being added.
+    // https://github.com/jestjs/jest/blob/25a8785584c9d54a05887001ee7f498d489a5441/packages/jest-util/src/installCommonGlobals.ts#L49
+    if (!vmGlobalsRecord[name] && global[name] !== globalThis.Symbol) {
+        vmGlobalsNonEnumerableRecord[name] = global[name];
+    }
+});
+function createCompiledFunction(source, define) {
+    // This looks a bit weird, but it's much quicker to do it this way than to
+    // run vm.runInContext. There's a bit more information in this issue:
+    // https://github.com/nodejs/node/issues/31658
+    const sandbox = {
+        define,
+        ...vmGlobalsRecord,
+        ...vmGlobalsNonEnumerableRecord,
+        window: createMagicProxy(),
+        document: createMagicProxy(),
+        navigator: createMagicProxy(),
+        console
+    };
+    const params = Object.keys(sandbox);
+    const implementations = Object.values(sandbox);
+    const compiledFunction = vm.compileFunction(source, params, {
+        parsingContext: context
+    });
+    return ()=>compiledFunction(...implementations);
+}
 
-async function evaluateAndProcess({ source , renderer , filepath  }) {
-    /**
-   * This needs to be loaded via require. The resolving logic in vm.Script is using
-   * cjs to populate the renderer. We need to point to the same instance.
-   */ require('./').setAdapter(renderer);
-    const requireLike = (request)=>{
-        const resolved = (()=>{
-            try {
-                return require.resolve(request, {
-                    paths: [
-                        node_path.dirname(filepath),
-                        // This allows us to use modules in this package.
+const { ResolverFactory , CachedInputFileSystem  } = enhancedResolve;
+const resolver = ResolverFactory.createResolver({
+    fileSystem: new CachedInputFileSystem(fs, 4000),
+    extensions: [
+        ".js",
+        ".cjs",
+        ".mjs"
+    ],
+    conditionNames: [
+        "import",
+        "require"
+    ]
+});
+const requireResolveLike = (request, paths = [])=>Promise.any(paths.map((path)=>new Promise((resolve, reject)=>{
+            resolver.resolve({}, path, request, {}, (err, result)=>{
+                if (err || !result) {
+                    return reject(err);
+                }
+                resolve(result);
+            });
+        })));
+const importWithRequireResolution = async (request, startPath = __dirname)=>{
+    return import(await requireResolveLike(request, [
+        startPath
+    ]) || request);
+};
+function createDefineFunction({ filePath , resolver , isExternal , resolverCache , nodeModuleCache , setAdapter  }, resolveDependency) {
+    const filepathDirectory = path.dirname(filePath);
+    return async function define(dependencies, factoryFn) {
+        const exports = {};
+        const dependencyMap = {
+            require: importWithRequireResolution,
+            exports
+        };
+        const resolvedDependencies = await Promise.all(dependencies.filter((dependency)=>!(dependency in dependencyMap)).map((dependency)=>{
+            if (!resolverCache[filepathDirectory]) {
+                resolverCache[filepathDirectory] = {};
+            }
+            if (resolverCache[filepathDirectory][dependency]) {
+                return resolverCache[filepathDirectory][dependency];
+            }
+            const resolved = resolver(filePath, dependency).catch(()=>undefined).then((resolvedDependency)=>{
+                if (!resolvedDependency) {
+                    return requireResolveLike(dependency, [
+                        filepathDirectory,
                         __dirname
-                    ]
-                });
-            } catch (e) {
-                return undefined;
+                    ]).catch(()=>{
+                        throw new Error(`Failed to resolve dependency "${dependency}" in ${filePath}`);
+                    });
+                }
+                return resolvedDependency;
+            });
+            resolverCache[filepathDirectory][dependency] = resolved;
+            return resolved;
+        })).catch((error)=>{
+            throw error;
+        });
+        for (const dependency of resolvedDependencies){
+            if (nodeModuleCache[dependency]) {
+                dependencyMap[dependency] = nodeModuleCache[dependency];
+                continue;
+            }
+            /**
+       * Ignore everything that's not:
+       * .js, .ts, .jsx, .tsx, .mts, .mjs, .cjs, .cts
+       */ if (/\.(?![mc]?[tj]sx?$)[^.]+$/.test(dependency)) {
+                dependencyMap[dependency] = {};
+                continue;
             }
-        })();
-        // If we couldn't find the module, try with the request,
-        // so we'll get correct error messages.
-        return require(resolved || request);
+            if (isExternal(dependency)) {
+                const module = importWithRequireResolution(dependency, filepathDirectory);
+                if (!nodeModuleCache[dependency]) {
+                    nodeModuleCache[dependency] = module;
+                }
+                dependencyMap[dependency] = nodeModuleCache[dependency];
+                continue;
+            }
+            dependencyMap[dependency] = resolveDependency(dependency);
+        }
+        const dependencyValues = await Promise.all(Object.values(dependencyMap));
+        // The adapter needs to be set before factoryFn is called.
+        setAdapter();
+        factoryFn(...dependencyValues);
+        return {
+            dependencies: resolvedDependencies.filter((x)=>!isExternal(x)),
+            exports
+        };
     };
-    const context = {};
-    const globalProperties = Object.getOwnPropertyNames(global);
-    globalProperties.forEach((key)=>{
-        context[key] = global[key];
+}
+
+function formatResults(results = []) {
+    const result = results.map((item)=>{
+        if (item instanceof engine.Static) {
+            return '';
+        }
+        return JSON.stringify(item);
     });
-    const vmGlobals = new vm__namespace.Script('Object.getOwnPropertyNames(globalThis)').runInNewContext();
-    Object.keys(vmGlobals).forEach((key)=>{
-        context[key] = vmGlobals[key];
+    return `const $$evaluatedValues = [${result.join(',')}];`;
+}
+
+function setAdapter({ engine: engine$1 , collectResults ,  }) {
+    adapter.setAdapter({
+        generateIdentifier: (value)=>engine$1.generateIdentifier(value),
+        addStaticCss: (selector, css)=>engine$1.addStatic(selector, css),
+        addCss: (css)=>engine$1.addStyle(css),
+        addKeyframe: (keyframe)=>engine$1.addKeyframes(keyframe),
+        addFontFace: (fontFace)=>{
+            const hasFontFamily = (Array.isArray(fontFace) ? fontFace : [
+                fontFace
+            ]).some((fontFace)=>'fontFamily' in fontFace);
+            if (hasFontFamily) {
+                throw new Error('This function creates and returns a font-family name, so the "fontFamily" property should not be provided.');
+            }
+            return engine$1.addFontFace(fontFace);
+        },
+        collectResult ({ index , filePath , identifier , result: resultFactory , line , column ,  }) {
+            if (index === 0) {
+                if (collectResults) {
+                    collectResults[filePath] = [];
+                }
+                engine$1.clearUsedIds(filePath);
+            }
+            engine$1.setFilePath(filePath);
+            let result = resultFactory();
+            engine$1.setFilePath(undefined);
+            if (result instanceof engine.ClassList) {
+                const extraClass = engine$1.addSourceMapReference({
+                    index,
+                    identifier,
+                    classList: result,
+                    filePath,
+                    line,
+                    column
+                });
+                if (extraClass) {
+                    result = new engine.ClassList([
+                        result.toString(),
+                        extraClass
+                    ].join(' '));
+                }
+            }
+            if (collectResults) {
+                collectResults[filePath][index] = result;
+            }
+            return result;
+        }
     });
-    context['require'] = requireLike;
-    context['console'] = console;
-    const script = new vm__namespace.Script(source, {
-        filename: filepath
+}
+
+const rootDir = path.resolve(__dirname, "../../");
+const isExternal = (dependency)=>dependency.startsWith(rootDir) || dependency.includes('node_modules');
+const defaultNodeModuleCache = {};
+const defaultResolverCache = {};
+const defaultModuleCache = new Map();
+const collectedResults = {};
+async function evaluateAndProcess({ type , filePath , source , engine , resolver , readFile , importMap , nodeModuleCache =defaultNodeModuleCache , resolverCache =defaultResolverCache , moduleCache =defaultModuleCache  }) {
+    const cacheKey = `${filePath}:${type}`;
+    const compiledFn = await (async ()=>{
+        if (moduleCache.has(cacheKey)) {
+            const cache = moduleCache.get(cacheKey);
+            if (cache.source === source) {
+                return cache.compiledFn;
+            }
+        }
+        const newSource = await swc.extraction(source, {
+            filename: filePath,
+            entryPoint: type === 'entryPoint',
+            importMap
+        });
+        const define = createDefineFunction({
+            filePath,
+            resolver,
+            isExternal,
+            resolverCache,
+            nodeModuleCache,
+            setAdapter: ()=>setAdapter({
+                    engine,
+                    collectResults: collectedResults
+                })
+        }, (dependency)=>readFile(dependency).then((source)=>evaluateAndProcess({
+                    type: 'dependency',
+                    source: source.toString(),
+                    filePath: dependency,
+                    engine,
+                    resolver,
+                    readFile,
+                    importMap,
+                    nodeModuleCache,
+                    resolverCache,
+                    moduleCache
+                })).then(({ result  })=>result));
+        const compiledFn = createCompiledFunction(`return ${newSource}`, define);
+        moduleCache.set(cacheKey, {
+            source,
+            compiledFn
+        });
+        return compiledFn;
+    })();
+    return compiledFn().then(({ dependencies , exports  })=>{
+        if (type === 'entryPoint') {
+            return {
+                result: formatResults(collectedResults[filePath]),
+                dependencies
+            };
+        }
+        return {
+            result: exports,
+            dependencies
+        };
     });
-    script.runInContext(vm__namespace.createContext(context));
-    renderer.setFilePath(undefined);
 }
 
 exports.evaluateAndProcess = evaluateAndProcess;

package/evaluateAndProcess.mjs

@@ -2,50 +2,272 @@ 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 { createRequire as createRequire$1 } from 'module';
-const require = createRequire$1(import.meta.url);
-import { dirname } from 'node:path';
-import * as vm from 'node:vm';
+import path from 'node:path';
+import { extraction } from '@navita/swc';
+import vm from 'node:vm';
+import fs from 'node:fs';
+import enhancedResolve from 'enhanced-resolve';
+import { Static, ClassList } from '@navita/engine';
+import { setAdapter as setAdapter$1 } from '@navita/adapter';
 
-async function evaluateAndProcess({ source , renderer , filepath  }) {
-    /**
-   * This needs to be loaded via require. The resolving logic in vm.Script is using
-   * cjs to populate the renderer. We need to point to the same instance.
-   */ require('./').setAdapter(renderer);
-    const requireLike = (request)=>{
-        const resolved = (()=>{
-            try {
-                return require.resolve(request, {
-                    paths: [
-                        dirname(filepath),
-                        // This allows us to use modules in this package.
+function createMagicProxy() {
+    // Todo: at some point, the magic proxy should notify the user
+    //  that they are using a browser API in a node environment
+    return new Proxy({}, {
+        get: ()=>createMagicProxy()
+    });
+}
+
+const context = vm.createContext({
+    global
+});
+const vmGlobalsRecord = new vm.Script(`
+Object
+  .getOwnPropertyNames(globalThis)
+  .reduce((acc, name) => ({
+    ...acc,
+    [name]: globalThis[name],
+  }), {});
+`).runInContext(context);
+const vmGlobalsNonEnumerableRecord = {};
+Object.getOwnPropertyNames(global).forEach((name)=>{
+    // The second condition here is to prevent jest's Symbol polyfill from being added.
+    // https://github.com/jestjs/jest/blob/25a8785584c9d54a05887001ee7f498d489a5441/packages/jest-util/src/installCommonGlobals.ts#L49
+    if (!vmGlobalsRecord[name] && global[name] !== globalThis.Symbol) {
+        vmGlobalsNonEnumerableRecord[name] = global[name];
+    }
+});
+function createCompiledFunction(source, define) {
+    // This looks a bit weird, but it's much quicker to do it this way than to
+    // run vm.runInContext. There's a bit more information in this issue:
+    // https://github.com/nodejs/node/issues/31658
+    const sandbox = {
+        define,
+        ...vmGlobalsRecord,
+        ...vmGlobalsNonEnumerableRecord,
+        window: createMagicProxy(),
+        document: createMagicProxy(),
+        navigator: createMagicProxy(),
+        console
+    };
+    const params = Object.keys(sandbox);
+    const implementations = Object.values(sandbox);
+    const compiledFunction = vm.compileFunction(source, params, {
+        parsingContext: context
+    });
+    return ()=>compiledFunction(...implementations);
+}
+
+const { ResolverFactory , CachedInputFileSystem  } = enhancedResolve;
+const resolver = ResolverFactory.createResolver({
+    fileSystem: new CachedInputFileSystem(fs, 4000),
+    extensions: [
+        ".js",
+        ".cjs",
+        ".mjs"
+    ],
+    conditionNames: [
+        "import",
+        "require"
+    ]
+});
+const requireResolveLike = (request, paths = [])=>Promise.any(paths.map((path)=>new Promise((resolve, reject)=>{
+            resolver.resolve({}, path, request, {}, (err, result)=>{
+                if (err || !result) {
+                    return reject(err);
+                }
+                resolve(result);
+            });
+        })));
+const importWithRequireResolution = async (request, startPath = __dirname)=>{
+    return import(await requireResolveLike(request, [
+        startPath
+    ]) || request);
+};
+function createDefineFunction({ filePath , resolver , isExternal , resolverCache , nodeModuleCache , setAdapter  }, resolveDependency) {
+    const filepathDirectory = path.dirname(filePath);
+    return async function define(dependencies, factoryFn) {
+        const exports = {};
+        const dependencyMap = {
+            require: importWithRequireResolution,
+            exports
+        };
+        const resolvedDependencies = await Promise.all(dependencies.filter((dependency)=>!(dependency in dependencyMap)).map((dependency)=>{
+            if (!resolverCache[filepathDirectory]) {
+                resolverCache[filepathDirectory] = {};
+            }
+            if (resolverCache[filepathDirectory][dependency]) {
+                return resolverCache[filepathDirectory][dependency];
+            }
+            const resolved = resolver(filePath, dependency).catch(()=>undefined).then((resolvedDependency)=>{
+                if (!resolvedDependency) {
+                    return requireResolveLike(dependency, [
+                        filepathDirectory,
                         __dirname
-                    ]
-                });
-            } catch (e) {
-                return undefined;
+                    ]).catch(()=>{
+                        throw new Error(`Failed to resolve dependency "${dependency}" in ${filePath}`);
+                    });
+                }
+                return resolvedDependency;
+            });
+            resolverCache[filepathDirectory][dependency] = resolved;
+            return resolved;
+        })).catch((error)=>{
+            throw error;
+        });
+        for (const dependency of resolvedDependencies){
+            if (nodeModuleCache[dependency]) {
+                dependencyMap[dependency] = nodeModuleCache[dependency];
+                continue;
+            }
+            /**
+       * Ignore everything that's not:
+       * .js, .ts, .jsx, .tsx, .mts, .mjs, .cjs, .cts
+       */ if (/\.(?![mc]?[tj]sx?$)[^.]+$/.test(dependency)) {
+                dependencyMap[dependency] = {};
+                continue;
+            }
+            if (isExternal(dependency)) {
+                const module = importWithRequireResolution(dependency, filepathDirectory);
+                if (!nodeModuleCache[dependency]) {
+                    nodeModuleCache[dependency] = module;
+                }
+                dependencyMap[dependency] = nodeModuleCache[dependency];
+                continue;
             }
-        })();
-        // If we couldn't find the module, try with the request,
-        // so we'll get correct error messages.
-        return require(resolved || request);
+            dependencyMap[dependency] = resolveDependency(dependency);
+        }
+        const dependencyValues = await Promise.all(Object.values(dependencyMap));
+        // The adapter needs to be set before factoryFn is called.
+        setAdapter();
+        factoryFn(...dependencyValues);
+        return {
+            dependencies: resolvedDependencies.filter((x)=>!isExternal(x)),
+            exports
+        };
     };
-    const context = {};
-    const globalProperties = Object.getOwnPropertyNames(global);
-    globalProperties.forEach((key)=>{
-        context[key] = global[key];
+}
+
+function formatResults(results = []) {
+    const result = results.map((item)=>{
+        if (item instanceof Static) {
+            return '';
+        }
+        return JSON.stringify(item);
     });
-    const vmGlobals = new vm.Script('Object.getOwnPropertyNames(globalThis)').runInNewContext();
-    Object.keys(vmGlobals).forEach((key)=>{
-        context[key] = vmGlobals[key];
+    return `const $$evaluatedValues = [${result.join(',')}];`;
+}
+
+function setAdapter({ engine , collectResults ,  }) {
+    setAdapter$1({
+        generateIdentifier: (value)=>engine.generateIdentifier(value),
+        addStaticCss: (selector, css)=>engine.addStatic(selector, css),
+        addCss: (css)=>engine.addStyle(css),
+        addKeyframe: (keyframe)=>engine.addKeyframes(keyframe),
+        addFontFace: (fontFace)=>{
+            const hasFontFamily = (Array.isArray(fontFace) ? fontFace : [
+                fontFace
+            ]).some((fontFace)=>'fontFamily' in fontFace);
+            if (hasFontFamily) {
+                throw new Error('This function creates and returns a font-family name, so the "fontFamily" property should not be provided.');
+            }
+            return engine.addFontFace(fontFace);
+        },
+        collectResult ({ index , filePath , identifier , result: resultFactory , line , column ,  }) {
+            if (index === 0) {
+                if (collectResults) {
+                    collectResults[filePath] = [];
+                }
+                engine.clearUsedIds(filePath);
+            }
+            engine.setFilePath(filePath);
+            let result = resultFactory();
+            engine.setFilePath(undefined);
+            if (result instanceof ClassList) {
+                const extraClass = engine.addSourceMapReference({
+                    index,
+                    identifier,
+                    classList: result,
+                    filePath,
+                    line,
+                    column
+                });
+                if (extraClass) {
+                    result = new ClassList([
+                        result.toString(),
+                        extraClass
+                    ].join(' '));
+                }
+            }
+            if (collectResults) {
+                collectResults[filePath][index] = result;
+            }
+            return result;
+        }
     });
-    context['require'] = requireLike;
-    context['console'] = console;
-    const script = new vm.Script(source, {
-        filename: filepath
+}
+
+const rootDir = path.resolve(__dirname, "../../");
+const isExternal = (dependency)=>dependency.startsWith(rootDir) || dependency.includes('node_modules');
+const defaultNodeModuleCache = {};
+const defaultResolverCache = {};
+const defaultModuleCache = new Map();
+const collectedResults = {};
+async function evaluateAndProcess({ type , filePath , source , engine , resolver , readFile , importMap , nodeModuleCache =defaultNodeModuleCache , resolverCache =defaultResolverCache , moduleCache =defaultModuleCache  }) {
+    const cacheKey = `${filePath}:${type}`;
+    const compiledFn = await (async ()=>{
+        if (moduleCache.has(cacheKey)) {
+            const cache = moduleCache.get(cacheKey);
+            if (cache.source === source) {
+                return cache.compiledFn;
+            }
+        }
+        const newSource = await extraction(source, {
+            filename: filePath,
+            entryPoint: type === 'entryPoint',
+            importMap
+        });
+        const define = createDefineFunction({
+            filePath,
+            resolver,
+            isExternal,
+            resolverCache,
+            nodeModuleCache,
+            setAdapter: ()=>setAdapter({
+                    engine,
+                    collectResults: collectedResults
+                })
+        }, (dependency)=>readFile(dependency).then((source)=>evaluateAndProcess({
+                    type: 'dependency',
+                    source: source.toString(),
+                    filePath: dependency,
+                    engine,
+                    resolver,
+                    readFile,
+                    importMap,
+                    nodeModuleCache,
+                    resolverCache,
+                    moduleCache
+                })).then(({ result  })=>result));
+        const compiledFn = createCompiledFunction(`return ${newSource}`, define);
+        moduleCache.set(cacheKey, {
+            source,
+            compiledFn
+        });
+        return compiledFn;
+    })();
+    return compiledFn().then(({ dependencies , exports  })=>{
+        if (type === 'entryPoint') {
+            return {
+                result: formatResults(collectedResults[filePath]),
+                dependencies
+            };
+        }
+        return {
+            result: exports,
+            dependencies
+        };
     });
-    script.runInContext(vm.createContext(context));
-    renderer.setFilePath(undefined);
 }
 
 export { evaluateAndProcess };

package/index.d.ts

@@ -1,23 +1,2 @@
-import { StyleRule, GlobalStyleRule, CSSKeyframes } from '@navita/types';
-import { Renderer } from './createRenderer.js';
-import 'fela';
 
-type Adapter = {
-    generateIdentifier: typeof generateIdentifier;
-    setCss: typeof setCss;
-    setStaticCss: typeof setStaticCss;
-    setKeyFrame: typeof setKeyFrame;
-    collectResult?: typeof collectResult;
-};
-declare const setAdapter: (renderer: Renderer) => void;
-declare function generateIdentifier(value: unknown): string;
-declare function setCss(css: StyleRule): string;
-declare function setStaticCss(selector: string, css: GlobalStyleRule): void;
-declare function setKeyFrame(keyframe: CSSKeyframes): string;
-declare function collectResult<T>(input: {
-    filePath: string;
-    index: number;
-    result: () => T;
-}): T;
-
-export { Adapter, collectResult, generateIdentifier, setAdapter, setCss, setKeyFrame, setStaticCss };
+export { }