@navita/core 3.0.0-next.1 → 3.0.0-next.3

package/createRenderer.cjs

@@ -5,7 +5,7 @@ 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 }) {
+function createRenderer({ resolver, readFile, importMap = [], engineOptions, context, transformNodeModules = [] }) {
 	const engine = new _navita_engine.Engine({
 		context,
 		...engineOptions || {}
@@ -30,6 +30,7 @@ function createRenderer({ resolver, readFile, importMap = [], engineOptions, con
 				resolver,
 				readFile,
 				importMap,
+				transformNodeModules,
 				engine,
 				resultCache,
 				moduleCache,

package/createRenderer.d.ts

@@ -1,3 +1,4 @@
+import { n as NodeModuleMatcher } from "./evaluateAndProcess-Bd56H_hx.js";
 import { Engine, Options as EngineOptions, UsedIdCache } from "@navita/engine";
 import { ImportMap } from "@navita/types";
 
@@ -8,13 +9,20 @@ interface Options {
   importMap: ImportMap;
   engineOptions?: EngineOptions;
   context?: string;
+  /**
+   * `node_modules` paths that should be recursively evaluated instead of
+   * imported as opaque modules — a library authored WITH navita. Each matcher
+   * is a substring (`id.includes(...)`) or a `RegExp` tested against the id.
+   */
+  transformNodeModules?: NodeModuleMatcher[];
 }
 declare function createRenderer({
   resolver,
   readFile,
   importMap,
   engineOptions,
-  context
+  context,
+  transformNodeModules
 }: Options): {
   engine: Engine;
   clearCache: (filePath: string) => void;
@@ -33,4 +41,4 @@ declare function createRenderer({
 };
 type Renderer = ReturnType<typeof createRenderer>;
 //#endregion
-export { type Engine, type EngineOptions, type ImportMap, Options, Renderer, type UsedIdCache, createRenderer };
+export { type Engine, type EngineOptions, type ImportMap, type NodeModuleMatcher, Options, Renderer, type UsedIdCache, createRenderer };

package/createRenderer.mjs

@@ -5,7 +5,7 @@ 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 }) {
+function createRenderer({ resolver, readFile, importMap = [], engineOptions, context, transformNodeModules = [] }) {
 	const engine = new Engine({
 		context,
 		...engineOptions || {}
@@ -30,6 +30,7 @@ function createRenderer({ resolver, readFile, importMap = [], engineOptions, con
 				resolver,
 				readFile,
 				importMap,
+				transformNodeModules,
 				engine,
 				resultCache,
 				moduleCache,

package/evaluateAndProcess-Bd56H_hx.d.ts

@@ -0,0 +1,74 @@
+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;
+}[]>;
+//#endregion
+//#region src/evaluateAndProcess.d.ts
+/**
+ * A dependency is "external" when navita imports it as an opaque module (native
+ * `import()`, exports used as-is) instead of recursively evaluating its source
+ * to extract navita styles from it. By default that's navita's own packages
+ * (`rootDir`) and everything under `node_modules`.
+ *
+ * `transformNodeModules` carves specific `node_modules` paths back OUT of that
+ * set — a component library authored WITH navita ships un-compiled `style()`/
+ * theme calls in files that DO need recursive evaluation (and dependency
+ * tracking for HMR). navita's own packages stay external regardless, so a broad
+ * matcher can never make navita try to evaluate `@navita/css` itself.
+ */
+type NodeModuleMatcher = string | RegExp;
+type FilePathWithType = string;
+type ModuleCache = Map<FilePathWithType, {
+  source: string;
+  compiledFn: () => Promise<{
+    dependencies: string[];
+    exports: Record<string, unknown>;
+  }>;
+}>;
+interface Caches {
+  nodeModuleCache?: NodeModuleCache;
+  resolverCache?: ResolverCache;
+  moduleCache?: ModuleCache;
+  resultCache?: ResultCache;
+}
+type Types = "entryPoint" | "dependency";
+interface Output<Type extends Types> {
+  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,
+  transformNodeModules,
+  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;
+  transformNodeModules?: NodeModuleMatcher[];
+} & Caches): Promise<Output<Type>>;
+//#endregion
+export { NodeModuleMatcher as n, evaluateAndProcess as r, Caches as t };

package/evaluateAndProcess.cjs

@@ -8,13 +8,15 @@ 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 matches = (matchers, dependency) => matchers.some((matcher) => matcher instanceof RegExp ? matcher.test(dependency) : dependency.includes(matcher));
+const createIsExternal = (transformNodeModules) => (dependency) => dependency.startsWith(rootDir) || dependency.includes("node_modules") && !matches(transformNodeModules, dependency);
 const defaultNodeModuleCache = {};
 const defaultResolverCache = {};
 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 }) {
+async function evaluateAndProcess({ type, filePath, source, engine, resolver, readFile, importMap, transformNodeModules = [], nodeModuleCache = defaultNodeModuleCache, resolverCache = defaultResolverCache, moduleCache = defaultModuleCache, resultCache = defaultResultCache }) {
 	const cacheKey = `${filePath}:${type}`;
+	const isExternal = createIsExternal(transformNodeModules);
 	return (await (async () => {
 		if (moduleCache.has(cacheKey)) {
 			const cache = moduleCache.get(cacheKey);
@@ -43,6 +45,7 @@ async function evaluateAndProcess({ type, filePath, source, engine, resolver, re
 			resolver,
 			readFile,
 			importMap,
+			transformNodeModules,
 			nodeModuleCache,
 			resolverCache,
 			moduleCache

package/evaluateAndProcess.d.ts

@@ -1,59 +1,2 @@
-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;
-}[]>;
-//#endregion
-//#region src/evaluateAndProcess.d.ts
-type FilePathWithType = string;
-type ModuleCache = Map<FilePathWithType, {
-  source: string;
-  compiledFn: () => Promise<{
-    dependencies: string[];
-    exports: Record<string, unknown>;
-  }>;
-}>;
-interface Caches {
-  nodeModuleCache?: NodeModuleCache;
-  resolverCache?: ResolverCache;
-  moduleCache?: ModuleCache;
-  resultCache?: ResultCache;
-}
-type Types = "entryPoint" | "dependency";
-interface Output<Type extends Types> {
-  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;
-} & Caches): Promise<Output<Type>>;
-//#endregion
-export { Caches, evaluateAndProcess };
+import { n as NodeModuleMatcher, r as evaluateAndProcess, t as Caches } from "./evaluateAndProcess-Bd56H_hx.js";
+export { Caches, NodeModuleMatcher, evaluateAndProcess };

package/evaluateAndProcess.mjs

@@ -9,13 +9,15 @@ 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 matches = (matchers, dependency) => matchers.some((matcher) => matcher instanceof RegExp ? matcher.test(dependency) : dependency.includes(matcher));
+const createIsExternal = (transformNodeModules) => (dependency) => dependency.startsWith(rootDir) || dependency.includes("node_modules") && !matches(transformNodeModules, dependency);
 const defaultNodeModuleCache = {};
 const defaultResolverCache = {};
 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 }) {
+async function evaluateAndProcess({ type, filePath, source, engine, resolver, readFile, importMap, transformNodeModules = [], nodeModuleCache = defaultNodeModuleCache, resolverCache = defaultResolverCache, moduleCache = defaultModuleCache, resultCache = defaultResultCache }) {
 	const cacheKey = `${filePath}:${type}`;
+	const isExternal = createIsExternal(transformNodeModules);
 	return (await (async () => {
 		if (moduleCache.has(cacheKey)) {
 			const cache = moduleCache.get(cacheKey);
@@ -44,6 +46,7 @@ async function evaluateAndProcess({ type, filePath, source, engine, resolver, re
 			resolver,
 			readFile,
 			importMap,
+			transformNodeModules,
 			nodeModuleCache,
 			resolverCache,
 			moduleCache

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navita/core",
-  "version": "3.0.0-next.1",
+  "version": "3.0.0-next.3",
   "description": "Core package for Navita. Used for creating integrations.",
   "keywords": [
     "core",
@@ -28,10 +28,10 @@
     "enhanced-resolve": "5.15.0",
     "magic-string": "^0.30.3",
     "outdent": "^0.8.0",
-    "@navita/adapter": "3.0.0-next.1",
-    "@navita/engine": "3.0.0-next.1",
-    "@navita/extraction": "3.0.0-next.1",
-    "@navita/types": "3.0.0-next.1"
+    "@navita/adapter": "3.0.0-next.3",
+    "@navita/engine": "3.0.0-next.3",
+    "@navita/extraction": "3.0.0-next.3",
+    "@navita/types": "3.0.0-next.3"
   },
   "license": "MIT",
   "author": "Eagerpatch",