@navita/core 0.0.9 → 0.0.11

package/{createRenderer.js → createRenderer.cjs}

@@ -2,12 +2,16 @@
 
 var engine = require('@navita/engine');
 var MagicString = require('magic-string');
-var evaluateAndProcess = require('./evaluateAndProcess.js');
+var evaluateAndProcess = require('./evaluateAndProcess.cjs');
 require('node:path');
 require('@navita/swc');
+require('./helpers/createCompiledFunction.cjs');
 require('node:vm');
+require('./helpers/magicProxy.cjs');
+require('./helpers/createDefineFunction.cjs');
 require('node:fs');
 require('enhanced-resolve');
+require('./helpers/setAdapter.cjs');
 require('@navita/adapter');
 
 function createRenderer({ resolver , readFile , importMap =[] , engineOptions , context  }) {

package/createRenderer.mjs

@@ -3,9 +3,13 @@ import MagicString from 'magic-string';
 import { evaluateAndProcess } from './evaluateAndProcess.mjs';
 import 'node:path';
 import '@navita/swc';
+import './helpers/createCompiledFunction.mjs';
 import 'node:vm';
+import './helpers/magicProxy.mjs';
+import './helpers/createDefineFunction.mjs';
 import 'node:fs';
 import 'enhanced-resolve';
+import './helpers/setAdapter.mjs';
 import '@navita/adapter';
 
 function createRenderer({ resolver , readFile , importMap =[] , engineOptions , context  }) {

package/evaluateAndProcess.cjs

@@ -0,0 +1,78 @@
+'use strict';
+
+var path = require('node:path');
+var swc = require('@navita/swc');
+var helpers_createCompiledFunction = require('./helpers/createCompiledFunction.cjs');
+var helpers_createDefineFunction = require('./helpers/createDefineFunction.cjs');
+var helpers_setAdapter = require('./helpers/setAdapter.cjs');
+require('node:vm');
+require('./helpers/magicProxy.cjs');
+require('node:fs');
+require('enhanced-resolve');
+require('@navita/adapter');
+require('@navita/engine');
+
+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 = helpers_createDefineFunction.createDefineFunction({
+            filePath,
+            resolver,
+            isExternal,
+            resolverCache,
+            nodeModuleCache,
+            setAdapter: ()=>helpers_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 = helpers_createCompiledFunction.createCompiledFunction(`return ${newSource}`, define);
+        moduleCache.set(cacheKey, {
+            source,
+            compiledFn
+        });
+        return compiledFn;
+    })();
+    return compiledFn().then(({ dependencies , exports  })=>{
+        if (type === 'entryPoint') {
+            return {
+                result: collectedResults[filePath] || [],
+                dependencies
+            };
+        }
+        return {
+            result: exports,
+            dependencies
+        };
+    });
+}
+
+exports.evaluateAndProcess = evaluateAndProcess;

package/evaluateAndProcess.mjs

@@ -4,203 +4,15 @@ import { dirname as dirname$1 } from 'path';
 const __dirname = dirname$1(__filename);
 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 { setAdapter as setAdapter$1 } from '@navita/adapter';
-import { ClassList } from '@navita/engine';
-
-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 || isExternal(resolvedDependency)) {
-                    return requireResolveLike(dependency, [
-                        filepathDirectory,
-                        __dirname
-                    ]).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;
-            }
-            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
-        };
-    };
-}
-
-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 , sourceMap: { line , column  } , position ,  }) {
-            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) {
-                const [start, end] = position;
-                collectResults[filePath][index] = {
-                    start,
-                    end,
-                    value: result === undefined ? "undefined" : JSON.stringify(result)
-                };
-            }
-            return result;
-        }
-    });
-}
+import { createCompiledFunction } from './helpers/createCompiledFunction.mjs';
+import { createDefineFunction } from './helpers/createDefineFunction.mjs';
+import { setAdapter } from './helpers/setAdapter.mjs';
+import 'node:vm';
+import './helpers/magicProxy.mjs';
+import 'node:fs';
+import 'enhanced-resolve';
+import '@navita/adapter';
+import '@navita/engine';
 
 const rootDir = path.resolve(__dirname, "../../");
 const isExternal = (dependency)=>dependency.startsWith(rootDir) || dependency.includes('node_modules');
@@ -254,7 +66,7 @@ async function evaluateAndProcess({ type , filePath , source , engine , resolver
     return compiledFn().then(({ dependencies , exports  })=>{
         if (type === 'entryPoint') {
             return {
-                result: collectedResults[filePath],
+                result: collectedResults[filePath] || [],
                 dependencies
             };
         }

package/helpers/createCompiledFunction.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+var vm = require('node:vm');
+var helpers_magicProxy = require('./magicProxy.cjs');
+
+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: helpers_magicProxy.createMagicProxy(),
+        document: helpers_magicProxy.createMagicProxy(),
+        navigator: helpers_magicProxy.createMagicProxy(),
+        console
+    };
+    const params = Object.keys(sandbox);
+    const implementations = Object.values(sandbox);
+    const compiledFunction = vm.compileFunction(source, params, {
+        parsingContext: context
+    });
+    return ()=>compiledFunction(...implementations);
+}
+
+exports.createCompiledFunction = createCompiledFunction;

package/helpers/createCompiledFunction.mjs

@@ -0,0 +1,44 @@
+import vm from 'node:vm';
+import { createMagicProxy } from './magicProxy.mjs';
+
+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);
+}
+
+export { createCompiledFunction };

package/helpers/createDefineFunction.cjs

@@ -0,0 +1,97 @@
+'use strict';
+
+var fs = require('node:fs');
+var path = require('node:path');
+var enhancedResolve = require('enhanced-resolve');
+
+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 || isExternal(resolvedDependency)) {
+                    return requireResolveLike(dependency, [
+                        filepathDirectory,
+                        __dirname
+                    ]).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;
+            }
+            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
+        };
+    };
+}
+
+exports.createDefineFunction = createDefineFunction;

package/helpers/createDefineFunction.mjs

@@ -0,0 +1,99 @@
+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 fs from 'node:fs';
+import path from 'node:path';
+import enhancedResolve from 'enhanced-resolve';
+
+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 || isExternal(resolvedDependency)) {
+                    return requireResolveLike(dependency, [
+                        filepathDirectory,
+                        __dirname
+                    ]).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;
+            }
+            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
+        };
+    };
+}
+
+export { createDefineFunction };

package/helpers/magicProxy.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+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()
+    });
+}
+
+exports.createMagicProxy = createMagicProxy;

package/helpers/magicProxy.mjs

@@ -0,0 +1,9 @@
+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()
+    });
+}
+
+export { createMagicProxy };

package/helpers/setAdapter.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+var adapter = require('@navita/adapter');
+var engine = require('@navita/engine');
+
+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 , sourceMap: { line , column  } , position ,  }) {
+            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) {
+                const [start, end] = position;
+                collectResults[filePath][index] = {
+                    start,
+                    end,
+                    value: result === undefined ? "undefined" : JSON.stringify(result)
+                };
+            }
+            return result;
+        }
+    });
+}
+
+exports.setAdapter = setAdapter;

package/helpers/setAdapter.mjs

@@ -0,0 +1,58 @@
+import { setAdapter as setAdapter$1 } from '@navita/adapter';
+import { ClassList } from '@navita/engine';
+
+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 , sourceMap: { line , column  } , position ,  }) {
+            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) {
+                const [start, end] = position;
+                collectResults[filePath][index] = {
+                    start,
+                    end,
+                    value: result === undefined ? "undefined" : JSON.stringify(result)
+                };
+            }
+            return result;
+        }
+    });
+}
+
+export { setAdapter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navita/core",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Core package for Navita. Used for creating integrations.",
   "keywords": [
     "core",
@@ -12,20 +12,15 @@
   "sideEffects": false,
   "types": "./src/index.ts",
   "exports": {
-    ".": {
-      "import": "./index.mjs",
-      "require": "./index.js",
-      "types": "./index.d.ts"
-    },
     "./package.json": "./package.json",
     "./createRenderer": {
       "import": "./createRenderer.mjs",
-      "require": "./createRenderer.js",
+      "require": "./createRenderer.cjs",
       "types": "./createRenderer.d.ts"
     },
     "./evaluateAndProcess": {
       "import": "./evaluateAndProcess.mjs",
-      "require": "./evaluateAndProcess.js",
+      "require": "./evaluateAndProcess.cjs",
       "types": "./evaluateAndProcess.d.ts"
     }
   },
@@ -33,10 +28,10 @@
     "enhanced-resolve": "^5.15.0",
     "outdent": "^0.8.0",
     "magic-string": "^0.30.3",
-    "@navita/types": "0.0.8",
-    "@navita/adapter": "0.0.9",
-    "@navita/swc": "0.0.9",
-    "@navita/engine": "0.0.9"
+    "@navita/types": "0.0.9",
+    "@navita/adapter": "0.0.10",
+    "@navita/swc": "0.0.10",
+    "@navita/engine": "0.0.11"
   },
   "license": "MIT",
   "author": "Eagerpatch",

package/evaluateAndProcess.js

@@ -1,266 +0,0 @@
-'use strict';
-
-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 adapter = require('@navita/adapter');
-var engine = require('@navita/engine');
-
-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 || isExternal(resolvedDependency)) {
-                    return requireResolveLike(dependency, [
-                        filepathDirectory,
-                        __dirname
-                    ]).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;
-            }
-            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
-        };
-    };
-}
-
-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 , sourceMap: { line , column  } , position ,  }) {
-            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) {
-                const [start, end] = position;
-                collectResults[filePath][index] = {
-                    start,
-                    end,
-                    value: result === undefined ? "undefined" : JSON.stringify(result)
-                };
-            }
-            return result;
-        }
-    });
-}
-
-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: collectedResults[filePath],
-                dependencies
-            };
-        }
-        return {
-            result: exports,
-            dependencies
-        };
-    });
-}
-
-exports.evaluateAndProcess = evaluateAndProcess;

package/index.d.ts

@@ -1,2 +0,0 @@
-
-export { }

package/index.js

@@ -1,2 +0,0 @@
-'use strict';
-

package/index.mjs

@@ -1 +0,0 @@
-