@navita/core 1.0.1 → 3.0.0-next.0

package/helpers/createCompiledFunction.cjs

@@ -1,12 +1,11 @@
-'use strict';
-
-var vm = require('node:vm');
-var magicProxy = require('./magicProxy.cjs');
-
-const context = vm.createContext({
-    global
-});
-const vmGlobalsRecord = new vm.Script(`
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_helpers_magicProxy = require("./magicProxy.cjs");
+let node_vm = require("node:vm");
+node_vm = require_runtime.__toESM(node_vm);
+//#region src/helpers/createCompiledFunction.ts
+const context = node_vm.default.createContext({ global });
+const vmGlobalsRecord = new node_vm.default.Script(`
 Object
   .getOwnPropertyNames(globalThis)
   .reduce((acc, name) => ({
@@ -15,23 +14,18 @@ Object
   }), {});
 `).runInContext(context);
 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,
-        window: magicProxy.createMagicProxy(),
-        document: magicProxy.createMagicProxy(),
-        navigator: magicProxy.createMagicProxy(),
-        console
-    };
-    const params = Object.keys(sandbox);
-    const implementations = Object.values(sandbox);
-    const compiledFunction = vm.compileFunction(source, params, {
-        parsingContext: context
-    });
-    return ()=>compiledFunction(...implementations);
+	const sandbox = {
+		define,
+		...vmGlobalsRecord,
+		window: require_helpers_magicProxy.createMagicProxy(),
+		document: require_helpers_magicProxy.createMagicProxy(),
+		navigator: require_helpers_magicProxy.createMagicProxy(),
+		console
+	};
+	const params = Object.keys(sandbox);
+	const implementations = Object.values(sandbox);
+	const compiledFunction = node_vm.default.compileFunction(source, params, { parsingContext: context });
+	return () => compiledFunction(...implementations);
 }
-
+//#endregion
 exports.createCompiledFunction = createCompiledFunction;

package/helpers/createCompiledFunction.mjs

@@ -1,9 +1,10 @@
-import vm from 'node:vm';
-import { createMagicProxy } from './magicProxy.mjs';
-
-const context = vm.createContext({
-    global
-});
+import "node:path";
+import "node:url";
+import.meta.url;
+import { createMagicProxy } from "./magicProxy.mjs";
+import vm from "node:vm";
+//#region src/helpers/createCompiledFunction.ts
+const context = vm.createContext({ global });
 const vmGlobalsRecord = new vm.Script(`
 Object
   .getOwnPropertyNames(globalThis)
@@ -13,23 +14,18 @@ Object
   }), {});
 `).runInContext(context);
 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,
-        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 sandbox = {
+		define,
+		...vmGlobalsRecord,
+		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);
 }
-
+//#endregion
 export { createCompiledFunction };

package/helpers/createDefineFunction.cjs

@@ -1,97 +1,80 @@
-'use strict';
-
-var fs = require('node:fs');
-var path = require('node:path');
-var enhancedResolve = require('enhanced-resolve');
-
-const { ResolverFactory , CachedInputFileSystem  } = enhancedResolve;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs);
+let enhanced_resolve = require("enhanced-resolve");
+enhanced_resolve = require_runtime.__toESM(enhanced_resolve);
+//#region src/helpers/createDefineFunction.ts
+const { ResolverFactory, CachedInputFileSystem } = enhanced_resolve.default;
 const resolver = ResolverFactory.createResolver({
-    fileSystem: new CachedInputFileSystem(fs, 4000),
-    extensions: [
-        ".js",
-        ".cjs",
-        ".mjs"
-    ],
-    conditionNames: [
-        "import",
-        "require"
-    ]
+	fileSystem: new CachedInputFileSystem(node_fs.default, 4e3),
+	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);
+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 createDefineFunction({ filePath, resolver, isExternal, resolverCache, nodeModuleCache, setAdapter }, resolveDependency) {
+	const filepathDirectory = node_path.default.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(() => void 0).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;
+		}));
+		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));
+		setAdapter();
+		factoryFn(...dependencyValues);
+		return {
+			dependencies: resolvedDependencies.filter((x) => !isExternal(x)),
+			exports
+		};
+	};
 }
-
+//#endregion
 exports.createDefineFunction = createDefineFunction;

package/helpers/createDefineFunction.mjs

@@ -1,99 +1,79 @@
-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;
+import __tsdown_shims_path from "node:path";
+import __tsdown_shims_url from "node:url";
+const __TSDOWN_SHIM_FILENAME__ = /* @__PURE__ */ __tsdown_shims_url.fileURLToPath(import.meta.url);
+const __TSDOWN_SHIM_DIRNAME__ = /* @__PURE__ */ __tsdown_shims_path.dirname(__TSDOWN_SHIM_FILENAME__);
+import path from "node:path";
+import fs from "node:fs";
+import enhancedResolve from "enhanced-resolve";
+//#region src/helpers/createDefineFunction.ts
+const { ResolverFactory, CachedInputFileSystem } = enhancedResolve;
 const resolver = ResolverFactory.createResolver({
-    fileSystem: new CachedInputFileSystem(fs, 4000),
-    extensions: [
-        ".js",
-        ".cjs",
-        ".mjs"
-    ],
-    conditionNames: [
-        "import",
-        "require"
-    ]
+	fileSystem: new CachedInputFileSystem(fs, 4e3),
+	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);
+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 = __TSDOWN_SHIM_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 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(() => void 0).then((resolvedDependency) => {
+				if (!resolvedDependency || isExternal(resolvedDependency)) return requireResolveLike(dependency, [filepathDirectory, __TSDOWN_SHIM_DIRNAME__]).catch(() => {
+					throw new Error(`Failed to resolve dependency "${dependency}" in ${filePath}`);
+				});
+				return resolvedDependency;
+			});
+			resolverCache[filepathDirectory][dependency] = resolved;
+			return resolved;
+		}));
+		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));
+		setAdapter();
+		factoryFn(...dependencyValues);
+		return {
+			dependencies: resolvedDependencies.filter((x) => !isExternal(x)),
+			exports
+		};
+	};
 }
-
+//#endregion
 export { createDefineFunction };

package/helpers/magicProxy.cjs

@@ -1,11 +1,7 @@
-'use strict';
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/helpers/magicProxy.ts
 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()
-    });
+	return new Proxy({}, { get: () => createMagicProxy() });
 }
-
+//#endregion
 exports.createMagicProxy = createMagicProxy;

package/helpers/magicProxy.mjs

@@ -1,9 +1,9 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/helpers/magicProxy.ts
 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()
-    });
+	return new Proxy({}, { get: () => createMagicProxy() });
 }
-
+//#endregion
 export { createMagicProxy };

package/helpers/setAdapter.cjs

@@ -1,57 +1,44 @@
-'use strict';
-
-var adapter = require('@navita/adapter');
-var engine = require('@navita/engine');
-
-function setAdapter({ engine: engine$1 , resultCache ,  }) {
-    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 ,  }) {
-            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 (resultCache) {
-                if (!resultCache[filePath]) {
-                    resultCache[filePath] = [];
-                }
-                const [start, end] = position;
-                resultCache[filePath][index] = {
-                    start,
-                    end,
-                    value: result === undefined ? "undefined" : JSON.stringify(result)
-                };
-            }
-            return result;
-        }
-    });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _navita_engine = require("@navita/engine");
+let _navita_adapter = require("@navita/adapter");
+//#region src/helpers/setAdapter.ts
+function setAdapter({ engine, resultCache }) {
+	(0, _navita_adapter.setAdapter)({
+		generateIdentifier: (value) => engine.generateIdentifier(value),
+		addStaticCss: (selector, css) => engine.addStatic(selector, css),
+		addCss: (css) => engine.addStyle(css),
+		addKeyframe: (keyframe) => engine.addKeyframes(keyframe),
+		addFontFace: (fontFace) => {
+			if ((Array.isArray(fontFace) ? fontFace : [fontFace]).some((fontFace) => "fontFamily" in fontFace)) 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 }) {
+			engine.setFilePath(filePath);
+			let result = resultFactory();
+			engine.setFilePath(void 0);
+			if (result instanceof _navita_engine.ClassList) {
+				const extraClass = engine.addSourceMapReference({
+					index,
+					identifier,
+					classList: result,
+					filePath,
+					line,
+					column
+				});
+				if (extraClass) result = new _navita_engine.ClassList([result.toString(), extraClass].join(" "));
+			}
+			if (resultCache) {
+				if (!resultCache[filePath]) resultCache[filePath] = [];
+				const [start, end] = position;
+				resultCache[filePath][index] = {
+					start,
+					end,
+					value: result === void 0 ? "undefined" : JSON.stringify(result)
+				};
+			}
+			return result;
+		}
+	});
 }
-
+//#endregion
 exports.setAdapter = setAdapter;