@navita/core 1.0.1 → 3.0.0-next.0

package/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/createRenderer.cjs

@@ -1,50 +1,51 @@
-'use strict';
-
-var engine = require('@navita/engine');
-var MagicString = require('magic-string');
-var evaluateAndProcess = require('./evaluateAndProcess.cjs');
-
-const resultCache = {};
-function createRenderer({ resolver , readFile , importMap =[] , engineOptions , context  }) {
-    const engine$1 = new engine.Engine({
-        context,
-        ...engineOptions || {}
-    });
-    const clearCache = (filePath)=>{
-        engine$1.clearCache(filePath);
-        resultCache[filePath] = [];
-    };
-    return {
-        engine: engine$1,
-        clearCache,
-        async transformAndProcess ({ content , filePath  }) {
-            clearCache(filePath);
-            const { result , dependencies  } = await evaluateAndProcess.evaluateAndProcess({
-                type: 'entryPoint',
-                source: content,
-                filePath,
-                resolver,
-                readFile,
-                importMap,
-                engine: engine$1,
-                resultCache
-            });
-            const newSource = new MagicString(content, {
-                filename: filePath
-            });
-            for (const { start , end , value  } of result.reverse()){
-                newSource.update(start, end, value);
-            }
-            return {
-                result: newSource.toString(),
-                dependencies,
-                usedIds: engine$1.getCacheIds([
-                    filePath
-                ]),
-                sourceMap: newSource.generateMap()
-            };
-        }
-    };
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_evaluateAndProcess = require("./evaluateAndProcess.cjs");
+let _navita_engine = require("@navita/engine");
+let magic_string = require("magic-string");
+magic_string = require_runtime.__toESM(magic_string);
+//#region src/createRenderer.ts
+function createRenderer({ resolver, readFile, importMap = [], engineOptions, context }) {
+	const engine = new _navita_engine.Engine({
+		context,
+		...engineOptions || {}
+	});
+	const resultCache = {};
+	const moduleCache = /* @__PURE__ */ new Map();
+	const nodeModuleCache = {};
+	const resolverCache = {};
+	const clearCache = (filePath) => {
+		engine.clearCache(filePath);
+		resultCache[filePath] = [];
+	};
+	return {
+		engine,
+		clearCache,
+		async transformAndProcess({ content, filePath }) {
+			clearCache(filePath);
+			const { result, dependencies } = await require_evaluateAndProcess.evaluateAndProcess({
+				type: "entryPoint",
+				source: content,
+				filePath,
+				resolver,
+				readFile,
+				importMap,
+				engine,
+				resultCache,
+				moduleCache,
+				nodeModuleCache,
+				resolverCache
+			});
+			const newSource = new magic_string.default(content, { filename: filePath });
+			for (const { start, end, value } of result.reverse()) newSource.update(start, end, value);
+			return {
+				result: newSource.toString(),
+				dependencies,
+				usedIds: engine.getCacheIds([filePath]),
+				sourceMap: newSource.generateMap()
+			};
+		}
+	};
 }
-
+//#endregion
 exports.createRenderer = createRenderer;

package/createRenderer.d.ts

@@ -1,29 +1,36 @@
-import * as magic_string from 'magic-string';
-import { Options as Options$1, Engine, UsedIdCache } from '@navita/engine';
-export { Engine, Options as EngineOptions, UsedIdCache } from '@navita/engine';
-import { ImportMap } from '@navita/types';
-export { ImportMap } from '@navita/types';
+import { Engine, Options as EngineOptions, UsedIdCache } from "@navita/engine";
+import { ImportMap } from "@navita/types";
 
+//#region src/createRenderer.d.ts
 interface Options {
-    resolver: (filepath: string, request: string) => Promise<string>;
-    readFile: (filepath: string) => Promise<string>;
-    importMap: ImportMap;
-    engineOptions?: Options$1;
-    context?: string;
+  resolver: (filepath: string, request: string) => Promise<string>;
+  readFile: (filepath: string) => Promise<string>;
+  importMap: ImportMap;
+  engineOptions?: EngineOptions;
+  context?: string;
 }
-declare function createRenderer({ resolver, readFile, importMap, engineOptions, context, }: Options): {
-    engine: Engine;
-    clearCache: (filePath: string) => void;
-    transformAndProcess({ content, filePath, }: {
-        content: string;
-        filePath: string;
-    }): Promise<{
-        result: string;
-        dependencies: string[];
-        usedIds: UsedIdCache;
-        sourceMap: magic_string.SourceMap;
-    }>;
+declare function createRenderer({
+  resolver,
+  readFile,
+  importMap,
+  engineOptions,
+  context
+}: Options): {
+  engine: Engine;
+  clearCache: (filePath: string) => void;
+  transformAndProcess({
+    content,
+    filePath
+  }: {
+    content: string;
+    filePath: string;
+  }): Promise<{
+    result: string;
+    dependencies: string[];
+    usedIds: UsedIdCache;
+    sourceMap: import("magic-string").SourceMap;
+  }>;
 };
 type Renderer = ReturnType<typeof createRenderer>;
-
-export { Options, Renderer, createRenderer };
+//#endregion
+export { type Engine, type EngineOptions, type ImportMap, Options, Renderer, type UsedIdCache, createRenderer };

package/createRenderer.mjs

@@ -1,48 +1,51 @@
-import { Engine } from '@navita/engine';
-import MagicString from 'magic-string';
-import { evaluateAndProcess } from './evaluateAndProcess.mjs';
-
-const resultCache = {};
-function createRenderer({ resolver , readFile , importMap =[] , engineOptions , context  }) {
-    const engine = new Engine({
-        context,
-        ...engineOptions || {}
-    });
-    const clearCache = (filePath)=>{
-        engine.clearCache(filePath);
-        resultCache[filePath] = [];
-    };
-    return {
-        engine,
-        clearCache,
-        async transformAndProcess ({ content , filePath  }) {
-            clearCache(filePath);
-            const { result , dependencies  } = await evaluateAndProcess({
-                type: 'entryPoint',
-                source: content,
-                filePath,
-                resolver,
-                readFile,
-                importMap,
-                engine,
-                resultCache
-            });
-            const newSource = new MagicString(content, {
-                filename: filePath
-            });
-            for (const { start , end , value  } of result.reverse()){
-                newSource.update(start, end, value);
-            }
-            return {
-                result: newSource.toString(),
-                dependencies,
-                usedIds: engine.getCacheIds([
-                    filePath
-                ]),
-                sourceMap: newSource.generateMap()
-            };
-        }
-    };
+import "node:path";
+import "node:url";
+import.meta.url;
+import { evaluateAndProcess } from "./evaluateAndProcess.mjs";
+import { Engine } from "@navita/engine";
+import MagicString from "magic-string";
+//#region src/createRenderer.ts
+function createRenderer({ resolver, readFile, importMap = [], engineOptions, context }) {
+	const engine = new Engine({
+		context,
+		...engineOptions || {}
+	});
+	const resultCache = {};
+	const moduleCache = /* @__PURE__ */ new Map();
+	const nodeModuleCache = {};
+	const resolverCache = {};
+	const clearCache = (filePath) => {
+		engine.clearCache(filePath);
+		resultCache[filePath] = [];
+	};
+	return {
+		engine,
+		clearCache,
+		async transformAndProcess({ content, filePath }) {
+			clearCache(filePath);
+			const { result, dependencies } = await evaluateAndProcess({
+				type: "entryPoint",
+				source: content,
+				filePath,
+				resolver,
+				readFile,
+				importMap,
+				engine,
+				resultCache,
+				moduleCache,
+				nodeModuleCache,
+				resolverCache
+			});
+			const newSource = new MagicString(content, { filename: filePath });
+			for (const { start, end, value } of result.reverse()) newSource.update(start, end, value);
+			return {
+				result: newSource.toString(),
+				dependencies,
+				usedIds: engine.getCacheIds([filePath]),
+				sourceMap: newSource.generateMap()
+			};
+		}
+	};
 }
-
+//#endregion
 export { createRenderer };

package/evaluateAndProcess.cjs

@@ -1,72 +1,68 @@
-'use strict';
-
-var path = require('node:path');
-var swc = require('@navita/swc');
-var createCompiledFunction = require('./helpers/createCompiledFunction.cjs');
-var createDefineFunction = require('./helpers/createDefineFunction.cjs');
-var setAdapter = require('./helpers/setAdapter.cjs');
-
-const rootDir = path.resolve(__dirname, "../../");
-const isExternal = (dependency)=>dependency.startsWith(rootDir) || dependency.includes('node_modules');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_helpers_createCompiledFunction = require("./helpers/createCompiledFunction.cjs");
+const require_helpers_createDefineFunction = require("./helpers/createDefineFunction.cjs");
+const require_helpers_setAdapter = require("./helpers/setAdapter.cjs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let _navita_extraction = require("@navita/extraction");
+//#region src/evaluateAndProcess.ts
+const rootDir = node_path.default.resolve(__dirname, "../../");
+const isExternal = (dependency) => dependency.startsWith(rootDir) || dependency.includes("node_modules");
 const defaultNodeModuleCache = {};
 const defaultResolverCache = {};
-const defaultModuleCache = new Map();
+const defaultModuleCache = /* @__PURE__ */ new Map();
 const defaultResultCache = {};
-async function evaluateAndProcess({ type , filePath , source , engine , resolver , readFile , importMap , nodeModuleCache =defaultNodeModuleCache , resolverCache =defaultResolverCache , moduleCache =defaultModuleCache , resultCache =defaultResultCache  }) {
-    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.createDefineFunction({
-            filePath,
-            resolver,
-            isExternal,
-            resolverCache,
-            nodeModuleCache,
-            setAdapter: ()=>setAdapter.setAdapter({
-                    engine,
-                    resultCache: resultCache
-                })
-        }, (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.createCompiledFunction(`return ${newSource}`, define);
-        moduleCache.set(cacheKey, {
-            source,
-            compiledFn
-        });
-        return compiledFn;
-    })();
-    return compiledFn().then(({ dependencies , exports  })=>{
-        if (type === 'entryPoint') {
-            return {
-                result: resultCache[filePath] || [],
-                dependencies
-            };
-        }
-        return {
-            result: exports,
-            dependencies
-        };
-    });
+async function evaluateAndProcess({ type, filePath, source, engine, resolver, readFile, importMap, nodeModuleCache = defaultNodeModuleCache, resolverCache = defaultResolverCache, moduleCache = defaultModuleCache, resultCache = defaultResultCache }) {
+	const cacheKey = `${filePath}:${type}`;
+	return (await (async () => {
+		if (moduleCache.has(cacheKey)) {
+			const cache = moduleCache.get(cacheKey);
+			if (cache.source === source) return cache.compiledFn;
+		}
+		const newSource = await (0, _navita_extraction.extraction)(source, {
+			filename: filePath,
+			entryPoint: type === "entryPoint",
+			importMap
+		});
+		const define = require_helpers_createDefineFunction.createDefineFunction({
+			filePath,
+			resolver,
+			isExternal,
+			resolverCache,
+			nodeModuleCache,
+			setAdapter: () => require_helpers_setAdapter.setAdapter({
+				engine,
+				resultCache
+			})
+		}, (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 = require_helpers_createCompiledFunction.createCompiledFunction(`return ${newSource}`, define);
+		moduleCache.set(cacheKey, {
+			source,
+			compiledFn
+		});
+		return compiledFn;
+	})())().then(({ dependencies, exports }) => {
+		if (type === "entryPoint") return {
+			result: resultCache[filePath] || [],
+			dependencies
+		};
+		return {
+			result: exports,
+			dependencies
+		};
+	});
 }
-
+//#endregion
 exports.evaluateAndProcess = evaluateAndProcess;

package/evaluateAndProcess.d.ts

@@ -1,44 +1,59 @@
-import { Engine } from '@navita/engine';
-import { ImportMap } from '@navita/types';
+import { Engine } from "@navita/engine";
+import { ImportMap } from "@navita/types";
 
+//#region src/helpers/createDefineFunction.d.ts
 type FilePath$1 = string;
 type ResolverCache = Record<FilePath$1, unknown>;
 type NodeModuleCache = Record<FilePath$1, unknown>;
-
+//#endregion
+//#region src/helpers/setAdapter.d.ts
 type FilePath = string;
 type ResultCache = Record<FilePath, {
-    start: number;
-    end: number;
-    value: string;
+  start: number;
+  end: number;
+  value: string;
 }[]>;
-
+//#endregion
+//#region src/evaluateAndProcess.d.ts
 type FilePathWithType = string;
 type ModuleCache = Map<FilePathWithType, {
-    source: string;
-    compiledFn: () => Promise<{
-        dependencies: string[];
-        exports: Record<string, unknown>;
-    }>;
+  source: string;
+  compiledFn: () => Promise<{
+    dependencies: string[];
+    exports: Record<string, unknown>;
+  }>;
 }>;
 interface Caches {
-    nodeModuleCache?: NodeModuleCache;
-    resolverCache?: ResolverCache;
-    moduleCache?: ModuleCache;
-    resultCache?: ResultCache;
+  nodeModuleCache?: NodeModuleCache;
+  resolverCache?: ResolverCache;
+  moduleCache?: ModuleCache;
+  resultCache?: ResultCache;
 }
-type Types = 'entryPoint' | 'dependency';
+type Types = "entryPoint" | "dependency";
 interface Output<Type extends Types> {
-    result: Type extends 'entryPoint' ? ResultCache[number] : Record<string, unknown>;
-    dependencies: string[];
+  result: Type extends "entryPoint" ? ResultCache[number] : Record<string, unknown>;
+  dependencies: string[];
 }
-declare function evaluateAndProcess<Type extends 'entryPoint' | 'dependency'>({ type, filePath, source, engine, resolver, readFile, importMap, nodeModuleCache, resolverCache, moduleCache, resultCache, }: {
-    source: string;
-    filePath: string;
-    type: Type;
-    engine: Engine;
-    resolver: (filePath: string, request: string) => Promise<string>;
-    readFile: (filePath: string) => Promise<string>;
-    importMap: ImportMap;
+declare function evaluateAndProcess<Type extends "entryPoint" | "dependency">({
+  type,
+  filePath,
+  source,
+  engine,
+  resolver,
+  readFile,
+  importMap,
+  nodeModuleCache,
+  resolverCache,
+  moduleCache,
+  resultCache
+}: {
+  source: string;
+  filePath: string;
+  type: Type;
+  engine: Engine;
+  resolver: (filePath: string, request: string) => Promise<string>;
+  readFile: (filePath: string) => Promise<string>;
+  importMap: ImportMap;
 } & Caches): Promise<Output<Type>>;
-
-export { Caches, evaluateAndProcess };
+//#endregion
+export { Caches, evaluateAndProcess };

package/evaluateAndProcess.mjs

@@ -1,74 +1,69 @@
-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 path from 'node:path';
-import { extraction } from '@navita/swc';
-import { createCompiledFunction } from './helpers/createCompiledFunction.mjs';
-import { createDefineFunction } from './helpers/createDefineFunction.mjs';
-import { setAdapter } from './helpers/setAdapter.mjs';
-
-const rootDir = path.resolve(__dirname, "../../");
-const isExternal = (dependency)=>dependency.startsWith(rootDir) || dependency.includes('node_modules');
+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 { createCompiledFunction } from "./helpers/createCompiledFunction.mjs";
+import { createDefineFunction } from "./helpers/createDefineFunction.mjs";
+import { setAdapter } from "./helpers/setAdapter.mjs";
+import path from "node:path";
+import { extraction } from "@navita/extraction";
+//#region src/evaluateAndProcess.ts
+const rootDir = path.resolve(__TSDOWN_SHIM_DIRNAME__, "../../");
+const isExternal = (dependency) => dependency.startsWith(rootDir) || dependency.includes("node_modules");
 const defaultNodeModuleCache = {};
 const defaultResolverCache = {};
-const defaultModuleCache = new Map();
+const defaultModuleCache = /* @__PURE__ */ new Map();
 const defaultResultCache = {};
-async function evaluateAndProcess({ type , filePath , source , engine , resolver , readFile , importMap , nodeModuleCache =defaultNodeModuleCache , resolverCache =defaultResolverCache , moduleCache =defaultModuleCache , resultCache =defaultResultCache  }) {
-    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,
-                    resultCache: resultCache
-                })
-        }, (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: resultCache[filePath] || [],
-                dependencies
-            };
-        }
-        return {
-            result: exports,
-            dependencies
-        };
-    });
+async function evaluateAndProcess({ type, filePath, source, engine, resolver, readFile, importMap, nodeModuleCache = defaultNodeModuleCache, resolverCache = defaultResolverCache, moduleCache = defaultModuleCache, resultCache = defaultResultCache }) {
+	const cacheKey = `${filePath}:${type}`;
+	return (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,
+				resultCache
+			})
+		}, (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;
+	})())().then(({ dependencies, exports }) => {
+		if (type === "entryPoint") return {
+			result: resultCache[filePath] || [],
+			dependencies
+		};
+		return {
+			result: exports,
+			dependencies
+		};
+	});
 }
-
+//#endregion
 export { evaluateAndProcess };