@wyw-in-js/transform 2.0.0-alpha.0 → 2.0.0

package/types/utils/oxcPreevalTransforms.js

@@ -1,6 +1,7 @@
 /* eslint-disable no-restricted-syntax,no-continue */
 import { collectOxcExportsAndImports } from './collectOxcExportsAndImports';
 import { EventEmitter } from './EventEmitter';
+import { getOxcNodeChildren } from './oxc/ast';
 import { parseOxcProgramCached } from './parseOxc';
 const ssrCheckFields = new Set([
     'document',
@@ -40,6 +41,7 @@ const defaultReactComponentTypes = [
     'MemoExoticComponent',
     'NamedExoticComponent',
 ];
+const defaultReactHocs = ['forwardRef', 'memo'];
 const generatedProcessorHelperNameRe = /^_exp\d*$/;
 const requireCallRe = /\brequire\s*\(/;
 const windowTokenRe = /\bwindow\b/;
@@ -103,28 +105,11 @@ const isNode = (value) => !!value &&
     typeof value === 'object' &&
     'type' in value &&
     typeof value.type === 'string';
-const getChildren = (node) => {
-    const result = [];
-    const record = node;
-    Object.keys(record).forEach((key) => {
-        if (key === 'type' || key === 'start' || key === 'end' || key === 'range') {
-            return;
-        }
-        const value = record[key];
-        if (isNode(value)) {
-            result.push(value);
-            return;
-        }
-        if (Array.isArray(value)) {
-            value.forEach((item) => {
-                if (isNode(item)) {
-                    result.push(item);
-                }
-            });
-        }
-    });
-    return result;
-};
+// Reuses the per-node.type visitor-key cache in utils/oxc/ast.ts. This file's
+// getChildren shape historically diverged from the canonical one (a smaller
+// metadata-key skip set), but the produced children list is identical in
+// practice because oxc-parser nodes don't carry the extra metadata fields.
+const getChildren = getOxcNodeChildren;
 const parseOxc = (code, filename) => {
     return parseOxcProgramCached(filename, code, 'unambiguous');
 };
@@ -347,66 +332,95 @@ const predeclareScopeNames = (node, scope) => {
         });
     }
     const visitScopeDescendants = (child) => {
-        if (child.type === 'VariableDeclarator') {
-            collectBindingNames(child.id).forEach((name) => {
-                scope.names.add(name);
-            });
-        }
-        else if (child.type === 'FunctionDeclaration' && child.id) {
-            scope.names.add(child.id.name);
-        }
-        else if (child.type === 'ClassDeclaration' && child.id) {
-            scope.names.add(child.id.name);
-        }
-        else if (child.type === 'ImportDefaultSpecifier' ||
-            child.type === 'ImportNamespaceSpecifier' ||
-            child.type === 'ImportSpecifier') {
-            scope.names.add(child.local.name);
+        switch (child.type) {
+            case 'VariableDeclarator': {
+                const names = collectBindingNames(child.id);
+                for (let i = 0; i < names.length; i += 1) {
+                    scope.names.add(names[i]);
+                }
+                break;
+            }
+            case 'FunctionDeclaration':
+            case 'ClassDeclaration':
+                if (child.id) {
+                    scope.names.add(child.id.name);
+                }
+                break;
+            case 'ImportDefaultSpecifier':
+            case 'ImportNamespaceSpecifier':
+            case 'ImportSpecifier':
+                scope.names.add(child.local.name);
+                break;
+            default:
+                break;
         }
         if (createsScope(child)) {
             return;
         }
-        getChildren(child).forEach(visitScopeDescendants);
+        const children = getChildren(child);
+        for (let i = 0; i < children.length; i += 1) {
+            visitScopeDescendants(children[i]);
+        }
     };
-    getChildren(node).forEach(visitScopeDescendants);
+    const rootChildren = getChildren(node);
+    for (let i = 0; i < rootChildren.length; i += 1) {
+        visitScopeDescendants(rootChildren[i]);
+    }
 };
 const declareBindings = (node, scope) => {
-    if (node.type === 'VariableDeclarator') {
-        const names = collectBindingNames(node.id);
-        names.forEach((name) => {
-            scope.names.add(name);
-            scope.bindings.set(name, null);
-        });
-        if (node.id.type === 'Identifier' && node.init) {
-            scope.bindings.set(node.id.name, node.init);
-        }
-        return;
-    }
-    if (node.type === 'FunctionDeclaration' && node.id) {
-        scope.names.add(node.id.name);
-        scope.bindings.set(node.id.name, null);
-    }
-    if (node.type === 'ClassDeclaration' && node.id) {
-        scope.names.add(node.id.name);
-        scope.bindings.set(node.id.name, null);
-        return;
-    }
-    if (node.type === 'ImportDefaultSpecifier' ||
-        node.type === 'ImportNamespaceSpecifier' ||
-        node.type === 'ImportSpecifier') {
-        scope.names.add(node.local.name);
-        scope.bindings.set(node.local.name, null);
-        return;
-    }
-    if (node.type === 'FunctionDeclaration' ||
-        node.type === 'FunctionExpression' ||
-        node.type === 'ArrowFunctionExpression') {
-        node.params.forEach((param) => {
-            collectBindingNames(param).forEach((name) => {
+    // Called for every visited AST node, so the dispatch is hot. A switch lets
+    // V8 generate a jump table on node.type; the previous chained `if`s walked
+    // each branch's string-compare for every non-matching node.
+    switch (node.type) {
+        case 'VariableDeclarator': {
+            const names = collectBindingNames(node.id);
+            for (let i = 0; i < names.length; i += 1) {
+                const name = names[i];
                 scope.names.add(name);
                 scope.bindings.set(name, null);
-            });
-        });
+            }
+            if (node.id.type === 'Identifier' && node.init) {
+                scope.bindings.set(node.id.name, node.init);
+            }
+            return;
+        }
+        case 'ClassDeclaration': {
+            if (node.id) {
+                scope.names.add(node.id.name);
+                scope.bindings.set(node.id.name, null);
+            }
+            return;
+        }
+        case 'ImportDefaultSpecifier':
+        case 'ImportNamespaceSpecifier':
+        case 'ImportSpecifier': {
+            scope.names.add(node.local.name);
+            scope.bindings.set(node.local.name, null);
+            return;
+        }
+        case 'FunctionDeclaration': {
+            if (node.id) {
+                scope.names.add(node.id.name);
+                scope.bindings.set(node.id.name, null);
+            }
+            // Fall through to declare params.
+        }
+        // eslint-disable-next-line no-fallthrough
+        case 'FunctionExpression':
+        case 'ArrowFunctionExpression': {
+            const { params } = node;
+            for (let i = 0; i < params.length; i += 1) {
+                const names = collectBindingNames(params[i]);
+                for (let j = 0; j < names.length; j += 1) {
+                    const name = names[j];
+                    scope.names.add(name);
+                    scope.bindings.set(name, null);
+                }
+            }
+            break;
+        }
+        default:
+            break;
     }
 };
 const visit = (node, scope, enter, parent = null, ancestors = []) => {
@@ -417,7 +431,17 @@ const visit = (node, scope, enter, parent = null, ancestors = []) => {
     }
     declareBindings(node, currentScope);
     enter(node, currentScope, parent, ancestors);
-    getChildren(node).forEach((child) => visit(child, currentScope, enter, node, [...ancestors, node]));
+    // Push onto a shared ancestors stack instead of allocating `[...ancestors,
+    // node]` per child step (O(n × depth) extra allocation on deep ASTs).
+    // Every consumer of `ancestors` in this file reads it synchronously inside
+    // the enter callback; future callers that need to retain the reference
+    // must .slice() it themselves.
+    ancestors.push(node);
+    const children = getChildren(node);
+    for (let i = 0; i < children.length; i += 1) {
+        visit(children[i], currentScope, enter, node, ancestors);
+    }
+    ancestors.pop();
 };
 export const replaceImportMetaEnvWithOxc = (code, filename) => {
     if (!importMetaEnvRe.test(code)) {
@@ -876,6 +900,7 @@ const isHocCall = (call, hocs, imports) => {
     const matched = getImportForExpression(getInnermostCallee(call), imports);
     return !!matched && hocs[matched[0]]?.includes(matched[1]);
 };
+const isInsideHocCall = (ancestors, hocs, imports) => ancestors.some((ancestor) => ancestor.type === 'CallExpression' && isHocCall(ancestor, hocs, imports));
 const getComponentTypes = (options) => {
     const componentTypes = {
         ...(options?.componentTypes ?? { react: [defaultPlaceholder] }),
@@ -888,6 +913,14 @@ const getComponentTypes = (options) => {
     }
     return componentTypes;
 };
+const getHocs = (options) => {
+    const hocs = {
+        ...(options?.hocs ?? {}),
+    };
+    const reactHocs = new Set([...defaultReactHocs, ...(hocs.react ?? [])]);
+    hocs.react = [...reactHocs];
+    return hocs;
+};
 const getTypeImport = (node, imports) => {
     if (node.type === 'Identifier') {
         const matched = getImportBinding(imports, node.name);
@@ -1019,7 +1052,7 @@ export const removeDangerousCodeWithOxc = (code, filename, options) => {
     const program = parseOxc(code, filename);
     const imports = collectImportBindings(code, filename, program);
     const componentTypes = getComponentTypes(options);
-    const hocs = options?.hocs ?? {};
+    const hocs = getHocs(options);
     const hasHocs = Object.keys(hocs).length > 0;
     const windowScopedNames = windowTokenRe.test(code)
         ? collectWindowScopedNames(program)
@@ -1122,6 +1155,9 @@ export const removeDangerousCodeWithOxc = (code, filename, options) => {
         if (!isAlwaysForbidden && isInDeferredFunctionScope(ancestors)) {
             return;
         }
+        if (hasHocs && isInsideHocCall(ancestors, hocs, imports)) {
+            return;
+        }
         if (isBindingPosition(node, parent) && !isAlwaysForbidden) {
             return;
         }

package/types/utils/parseOxc.js

@@ -1,5 +1,10 @@
 import { parseSync } from 'oxc-parser';
-const MAX_PARSE_CACHE_ENTRIES = 200;
+// 200 evicts under sustained pressure on large monorepos — the
+// removeUnusedAfterReplacement cleanup loop reparses on every iteration
+// (new content -> new key) and applyOxcProcessors reparses after extraction.
+// 1000 is still bounded (~50-100 MB worst case for an enormous build) and
+// keeps every entry hot across the actions for a single file.
+const MAX_PARSE_CACHE_ENTRIES = 1000;
 const parseCache = new Map();
 const getAstType = (filename) => filename.endsWith('.ts') || filename.endsWith('.tsx') ? 'ts' : 'js';
 const makeCacheKey = (filename, code, sourceType) => `${sourceType}\0${filename}\0${code}`;

package/types/utils/processorStaticSemantics.d.ts

@@ -0,0 +1,13 @@
+import type { BaseProcessor, Expression as ProcessorExpression, ProcessorStaticContext, ProcessorStaticValue } from '@wyw-in-js/processor-utils';
+export declare const unknownProcessorStaticValue: unique symbol;
+export type UnknownProcessorStaticValue = typeof unknownProcessorStaticValue;
+export declare const createProcessorStaticContext: (processor: BaseProcessor) => ProcessorStaticContext;
+export declare const isProcessorStaticValue: (value: unknown) => value is ProcessorStaticValue;
+export declare const getProcessorStaticValue: (processor: BaseProcessor) => ProcessorStaticValue | null;
+export declare const processorStaticValueToRuntimeValue: (value: ProcessorStaticValue) => unknown | UnknownProcessorStaticValue;
+export declare const resolveProcessorStaticRuntimeValue: (processor: BaseProcessor) => unknown | UnknownProcessorStaticValue;
+export declare const resolveProcessorStaticClassName: (processor: BaseProcessor) => string | null;
+export declare const processorLiteralValue: (expression: ProcessorExpression) => unknown | UnknownProcessorStaticValue;
+export declare const processorPropertyKeyName: (key: ProcessorExpression) => string | null;
+export declare const processorObjectPropertyValue: (expression: ProcessorExpression, name: string) => ProcessorExpression | null;
+export declare const processorExpressionToStaticValue: (expression: ProcessorExpression, resolveHelperCall: (name: string) => unknown | UnknownProcessorStaticValue) => unknown | UnknownProcessorStaticValue;

package/types/utils/processorStaticSemantics.js

@@ -0,0 +1,191 @@
+export const unknownProcessorStaticValue = Symbol('unknownProcessorStaticValue');
+export const createProcessorStaticContext = (processor) => {
+    const processorWithInternals = processor;
+    return {
+        addDependency: () => { },
+        debug: () => { },
+        fileContext: processorWithInternals.context ??
+            {},
+        metadata: {
+            className: processor.className,
+            displayName: processor.displayName,
+            isReferenced: processor.isReferenced,
+            location: processor.location,
+            slug: processor.slug,
+            tagSource: processor.tagSource,
+        },
+        options: processorWithInternals.options ??
+            {},
+        unresolved: (reason, details) => ({
+            ...(details ? { details } : {}),
+            kind: 'unresolved',
+            reason,
+        }),
+    };
+};
+export const isProcessorStaticValue = (value) => {
+    if (typeof value !== 'object' || value === null || !('kind' in value)) {
+        return false;
+    }
+    const candidate = value;
+    switch (candidate.kind) {
+        case 'class-name':
+            return typeof candidate.className === 'string';
+        case 'opaque-component':
+            return (candidate.className === undefined ||
+                typeof candidate.className === 'string');
+        case 'runtime-callback':
+        case 'serializable':
+            return true;
+        case 'selector-chain':
+            return (typeof candidate.className === 'string' &&
+                Array.isArray(candidate.selectors) &&
+                candidate.selectors.every((selector) => typeof selector === 'string'));
+        case 'unresolved':
+            return typeof candidate.reason === 'string';
+        default:
+            return false;
+    }
+};
+export const getProcessorStaticValue = (processor) => {
+    if (!processor.getStaticValue) {
+        return null;
+    }
+    try {
+        const value = processor.getStaticValue(createProcessorStaticContext(processor));
+        return isProcessorStaticValue(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+};
+export const processorStaticValueToRuntimeValue = (value) => {
+    switch (value.kind) {
+        case 'class-name':
+            return value.value === undefined ? value.className : value.value;
+        case 'opaque-component':
+        case 'runtime-callback':
+            return value.value === undefined
+                ? unknownProcessorStaticValue
+                : value.value;
+        case 'selector-chain':
+        case 'serializable':
+            return value.value;
+        case 'unresolved':
+            return unknownProcessorStaticValue;
+        default:
+            return unknownProcessorStaticValue;
+    }
+};
+export const resolveProcessorStaticRuntimeValue = (processor) => {
+    const staticValue = getProcessorStaticValue(processor);
+    return staticValue
+        ? processorStaticValueToRuntimeValue(staticValue)
+        : unknownProcessorStaticValue;
+};
+export const resolveProcessorStaticClassName = (processor) => {
+    const staticValue = getProcessorStaticValue(processor);
+    if (staticValue?.kind !== 'class-name') {
+        return null;
+    }
+    const runtimeValue = processorStaticValueToRuntimeValue(staticValue);
+    return typeof runtimeValue === 'string'
+        ? runtimeValue
+        : staticValue.className;
+};
+export const processorLiteralValue = (expression) => {
+    const expressionWithValue = expression;
+    if (expression.type === 'StringLiteral' ||
+        expression.type === 'NumericLiteral' ||
+        expression.type === 'BooleanLiteral' ||
+        expression.type === 'Literal') {
+        return expressionWithValue.value;
+    }
+    if (expression.type === 'NullLiteral') {
+        return null;
+    }
+    return unknownProcessorStaticValue;
+};
+export const processorPropertyKeyName = (key) => {
+    if (key.type === 'Identifier') {
+        return key.name;
+    }
+    const value = processorLiteralValue(key);
+    return typeof value === 'string' ? value : null;
+};
+export const processorObjectPropertyValue = (expression, name) => {
+    if (expression.type !== 'ObjectExpression') {
+        return null;
+    }
+    const { properties } = expression;
+    if (!properties) {
+        return null;
+    }
+    for (const property of properties) {
+        if ((property.type === 'ObjectProperty' || property.type === 'Property') &&
+            property.key &&
+            processorPropertyKeyName(property.key) === name) {
+            return property.value ?? null;
+        }
+    }
+    return null;
+};
+export const processorExpressionToStaticValue = (expression, resolveHelperCall) => {
+    const literal = processorLiteralValue(expression);
+    if (literal !== unknownProcessorStaticValue) {
+        return literal;
+    }
+    if (expression.type === 'ArrayExpression') {
+        const { elements } = expression;
+        if (!elements) {
+            return unknownProcessorStaticValue;
+        }
+        const result = [];
+        for (const element of elements) {
+            if (element === null) {
+                result.push(null);
+            }
+            else {
+                const value = processorExpressionToStaticValue(element, resolveHelperCall);
+                if (value === unknownProcessorStaticValue) {
+                    return unknownProcessorStaticValue;
+                }
+                result.push(value);
+            }
+        }
+        return result;
+    }
+    if (expression.type === 'ObjectExpression') {
+        const metaExpression = processorObjectPropertyValue(expression, '__wyw_meta');
+        if (!metaExpression || metaExpression.type !== 'ObjectExpression') {
+            return unknownProcessorStaticValue;
+        }
+        const classNameExpression = processorObjectPropertyValue(metaExpression, 'className');
+        const className = classNameExpression
+            ? processorLiteralValue(classNameExpression)
+            : unknownProcessorStaticValue;
+        if (typeof className !== 'string') {
+            return unknownProcessorStaticValue;
+        }
+        const extendsExpression = processorObjectPropertyValue(metaExpression, 'extends');
+        const extended = extendsExpression
+            ? processorExpressionToStaticValue(extendsExpression, resolveHelperCall)
+            : null;
+        if (extended === unknownProcessorStaticValue) {
+            return unknownProcessorStaticValue;
+        }
+        return {
+            __wyw_meta: {
+                className,
+                extends: extended,
+            },
+        };
+    }
+    if (expression.type === 'CallExpression') {
+        const call = expression;
+        if (call.arguments?.length === 0 && call.callee?.type === 'Identifier') {
+            return resolveHelperCall(call.callee.name);
+        }
+    }
+    return unknownProcessorStaticValue;
+};

package/types/utils/resolveWithConditions.js

@@ -54,7 +54,7 @@ const resolveWithNodeProcess = (id, parent, conditions) => {
         }
         catch {
             throw new Error([
-                '[wyw-in-js] Failed to parse Node resolver fallback output.',
+                '[wyw-in-js] Failed to parse custom module resolver output.',
                 `stdout: ${stdout}`,
                 result.stderr ? `stderr: ${result.stderr.trim()}` : '',
             ]
@@ -69,7 +69,7 @@ const resolveWithNodeProcess = (id, parent, conditions) => {
     }
     if (result.status !== 0 || !parsed?.resolved) {
         throw new Error([
-            '[wyw-in-js] Node resolver fallback failed.',
+            '[wyw-in-js] Custom module resolver fallback failed.',
             `status: ${result.status ?? 'null'}`,
             result.stderr ? `stderr: ${result.stderr.trim()}` : '',
         ]
@@ -87,7 +87,7 @@ export const resolveFilenameWithConditions = (moduleImpl, id, parent, conditions
     // Bun crashes on macOS/Silicon in this exact path:
     //   Module._resolveFilename(specifier, parent, false, { conditions })
     // We reproduced it both with a tiny standalone script and through the
-    // `EvalBroker > passes conditionNames to node fallback resolution` test,
+    // `EvalBroker > passes conditionNames to native fallback resolution` test,
     // including on Bun 1.3.13. Keep this fallback narrow: only conditioned
     // resolution under Bun goes through a short-lived Node subprocess.
     //

package/esm/eval/resolverStrategy.js

@@ -1,51 +0,0 @@
-export const defaultBundlerOwnedSpecifierPrefixes = [
-	"\0",
-	"/@",
-	"virtual:"
-];
-export const getResolverPrecedence = (mode) => {
-	if (mode === "hybrid") {
-		return [
-			"customResolver",
-			"safeOxcResolver",
-			"bundlerResolver",
-			"nodeFallback"
-		];
-	}
-	if (mode === "bundler") {
-		return [
-			"customResolver",
-			"bundlerResolver",
-			"nodeFallback"
-		];
-	}
-	if (mode === "custom") {
-		return ["customResolver"];
-	}
-	return ["nodeFallback"];
-};
-export const classifyHybridResolverSpecifier = (specifier, { bundlerOwnedPrefixes = defaultBundlerOwnedSpecifierPrefixes } = {}) => {
-	if (bundlerOwnedPrefixes.some((prefix) => specifier.startsWith(prefix))) {
-		return {
-			reason: "bundler-owned-prefix",
-			route: "bundler"
-		};
-	}
-	if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
-		return {
-			reason: "ambiguous-specifier",
-			route: "bundler"
-		};
-	}
-	if (/[?#]/.test(specifier)) {
-		return {
-			reason: "query-or-hash",
-			route: "bundler"
-		};
-	}
-	return {
-		reason: "safe-relative-specifier",
-		route: "oxc"
-	};
-};
-//# sourceMappingURL=resolverStrategy.js.map

package/esm/eval/resolverStrategy.js.map

@@ -1 +0,0 @@
-{"mappings":"AAmBA,OAAO,MAAM,uCAAuC;CAClD;CACA;CACA;CACD;AAED,OAAO,MAAM,yBACX,SACsB;AACtB,KAAI,SAAS,UAAU;AACrB,SAAO;GACL;GACA;GACA;GACA;GACD;;AAGH,KAAI,SAAS,WAAW;AACtB,SAAO;GAAC;GAAkB;GAAmB;GAAe;;AAG9D,KAAI,SAAS,UAAU;AACrB,SAAO,CAAC,iBAAiB;;AAG3B,QAAO,CAAC,eAAe;;AAGzB,OAAO,MAAM,mCACX,WACA,EACE,uBAAuB,yCACY,EAAE,KACZ;AAC3B,KAAI,qBAAqB,MAAM,WAAW,UAAU,WAAW,OAAO,CAAC,EAAE;AACvE,SAAO;GACL,QAAQ;GACR,OAAO;GACR;;AAGH,KAAI,CAAC,UAAU,WAAW,KAAK,IAAI,CAAC,UAAU,WAAW,MAAM,EAAE;AAC/D,SAAO;GACL,QAAQ;GACR,OAAO;GACR;;AAGH,KAAI,OAAO,KAAK,UAAU,EAAE;AAC1B,SAAO;GACL,QAAQ;GACR,OAAO;GACR;;AAGH,QAAO;EACL,QAAQ;EACR,OAAO;EACR","names":[],"sources":["../../src/eval/resolverStrategy.ts"],"version":3,"sourcesContent":["import type { EvalResolverMode } from '@wyw-in-js/shared';\n\nexport type HybridResolverRoute = 'bundler' | 'oxc';\n\nexport type HybridResolverReason =\n  | 'ambiguous-specifier'\n  | 'bundler-owned-prefix'\n  | 'query-or-hash'\n  | 'safe-relative-specifier';\n\nexport type HybridResolverDecision = {\n  reason: HybridResolverReason;\n  route: HybridResolverRoute;\n};\n\nexport type HybridResolverClassifierOptions = {\n  bundlerOwnedPrefixes?: readonly string[];\n};\n\nexport const defaultBundlerOwnedSpecifierPrefixes = [\n  '\\0',\n  '/@',\n  'virtual:',\n] as const;\n\nexport const getResolverPrecedence = (\n  mode: EvalResolverMode\n): readonly string[] => {\n  if (mode === 'hybrid') {\n    return [\n      'customResolver',\n      'safeOxcResolver',\n      'bundlerResolver',\n      'nodeFallback',\n    ];\n  }\n\n  if (mode === 'bundler') {\n    return ['customResolver', 'bundlerResolver', 'nodeFallback'];\n  }\n\n  if (mode === 'custom') {\n    return ['customResolver'];\n  }\n\n  return ['nodeFallback'];\n};\n\nexport const classifyHybridResolverSpecifier = (\n  specifier: string,\n  {\n    bundlerOwnedPrefixes = defaultBundlerOwnedSpecifierPrefixes,\n  }: HybridResolverClassifierOptions = {}\n): HybridResolverDecision => {\n  if (bundlerOwnedPrefixes.some((prefix) => specifier.startsWith(prefix))) {\n    return {\n      reason: 'bundler-owned-prefix',\n      route: 'bundler',\n    };\n  }\n\n  if (!specifier.startsWith('./') && !specifier.startsWith('../')) {\n    return {\n      reason: 'ambiguous-specifier',\n      route: 'bundler',\n    };\n  }\n\n  if (/[?#]/.test(specifier)) {\n    return {\n      reason: 'query-or-hash',\n      route: 'bundler',\n    };\n  }\n\n  return {\n    reason: 'safe-relative-specifier',\n    route: 'oxc',\n  };\n};\n"],"file":"resolverStrategy.js"}

package/types/eval/resolverStrategy.d.ts

@@ -1,13 +0,0 @@
-import type { EvalResolverMode } from '@wyw-in-js/shared';
-export type HybridResolverRoute = 'bundler' | 'oxc';
-export type HybridResolverReason = 'ambiguous-specifier' | 'bundler-owned-prefix' | 'query-or-hash' | 'safe-relative-specifier';
-export type HybridResolverDecision = {
-    reason: HybridResolverReason;
-    route: HybridResolverRoute;
-};
-export type HybridResolverClassifierOptions = {
-    bundlerOwnedPrefixes?: readonly string[];
-};
-export declare const defaultBundlerOwnedSpecifierPrefixes: readonly ["\0", "/@", "virtual:"];
-export declare const getResolverPrecedence: (mode: EvalResolverMode) => readonly string[];
-export declare const classifyHybridResolverSpecifier: (specifier: string, { bundlerOwnedPrefixes, }?: HybridResolverClassifierOptions) => HybridResolverDecision;

package/types/eval/resolverStrategy.js

@@ -1,46 +0,0 @@
-export const defaultBundlerOwnedSpecifierPrefixes = [
-    '\0',
-    '/@',
-    'virtual:',
-];
-export const getResolverPrecedence = (mode) => {
-    if (mode === 'hybrid') {
-        return [
-            'customResolver',
-            'safeOxcResolver',
-            'bundlerResolver',
-            'nodeFallback',
-        ];
-    }
-    if (mode === 'bundler') {
-        return ['customResolver', 'bundlerResolver', 'nodeFallback'];
-    }
-    if (mode === 'custom') {
-        return ['customResolver'];
-    }
-    return ['nodeFallback'];
-};
-export const classifyHybridResolverSpecifier = (specifier, { bundlerOwnedPrefixes = defaultBundlerOwnedSpecifierPrefixes, } = {}) => {
-    if (bundlerOwnedPrefixes.some((prefix) => specifier.startsWith(prefix))) {
-        return {
-            reason: 'bundler-owned-prefix',
-            route: 'bundler',
-        };
-    }
-    if (!specifier.startsWith('./') && !specifier.startsWith('../')) {
-        return {
-            reason: 'ambiguous-specifier',
-            route: 'bundler',
-        };
-    }
-    if (/[?#]/.test(specifier)) {
-        return {
-            reason: 'query-or-hash',
-            route: 'bundler',
-        };
-    }
-    return {
-        reason: 'safe-relative-specifier',
-        route: 'oxc',
-    };
-};