@wyw-in-js/transform 1.1.0 → 2.0.0-alpha.1

package/types/transform/helpers/loadWywOptions.js

@@ -1,63 +1,136 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadWywOptions = loadWywOptions;
-const cosmiconfig_1 = require("cosmiconfig");
-const shaker_1 = require("../../shaker");
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+import path from 'path';
+import { cosmiconfigSync } from 'cosmiconfig';
+import { shaker } from '../../shaker';
 const searchPlaces = [
     `.wyw-in-jsrc`,
     `.wyw-in-jsrc.json`,
     `.wyw-in-jsrc.yaml`,
     `.wyw-in-jsrc.yml`,
+    `.wyw-in-jsrc.mjs`,
     `.wyw-in-jsrc.js`,
     `.wyw-in-jsrc.cjs`,
     `.config/wyw-in-jsrc`,
     `.config/wyw-in-jsrc.json`,
     `.config/wyw-in-jsrc.yaml`,
     `.config/wyw-in-jsrc.yml`,
+    `.config/wyw-in-jsrc.mjs`,
     `.config/wyw-in-jsrc.js`,
     `.config/wyw-in-jsrc.cjs`,
+    `wyw-in-js.config.mjs`,
     `wyw-in-js.config.js`,
     `wyw-in-js.config.cjs`,
 ];
-const explorerSync = (0, cosmiconfig_1.cosmiconfigSync)('wyw-in-js', { searchPlaces });
+const explorerSync = cosmiconfigSync('wyw-in-js', {
+    searchPlaces: searchPlaces.filter((searchPlace) => !searchPlace.endsWith('.mjs')),
+});
 const cache = new WeakMap();
 const defaultOverrides = {};
 const nodeModulesRegExp = /[\\/]node_modules[\\/]/;
+const evalResolverModes = new Set(['bundler', 'hybrid', 'native', 'custom']);
+const evalStrategies = new Set(['execute', 'hybrid', 'static']);
+const evalRuntimes = new Set(['nodejs']);
+const evalErrorModes = new Set(['strict', 'loose']);
 const defaultImportLoaders = {
     raw: 'raw',
     url: 'url',
 };
-function loadWywOptions(overrides = defaultOverrides) {
+const resolveConfigFilePath = (configFile) => path.isAbsolute(configFile)
+    ? configFile
+    : path.resolve(process.cwd(), configFile);
+const normalizeLoadedConfig = (loadedConfig) => (loadedConfig && typeof loadedConfig === 'object' && 'default' in loadedConfig
+    ? loadedConfig.default
+    : loadedConfig);
+const loadMjsConfig = (configFile) => {
+    const resolvedConfigFile = resolveConfigFilePath(configFile);
+    const configRequire = createRequire(resolvedConfigFile);
+    try {
+        const cacheKey = configRequire.resolve(resolvedConfigFile);
+        delete configRequire.cache[cacheKey];
+    }
+    catch {
+        // Ignore cache cleanup failures and let the require call surface the real error.
+    }
+    try {
+        return normalizeLoadedConfig(configRequire(resolvedConfigFile));
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error
+            ? error.code
+            : undefined;
+        const message = error instanceof Error ? error.message : String(error);
+        if (code === 'ERR_REQUIRE_ASYNC_MODULE' ||
+            message.includes('require() async module') ||
+            message.includes('top-level await')) {
+            throw new Error(`[wyw-in-js] Failed to load ${resolvedConfigFile}. ` +
+                'WyW config loading is synchronous, so .mjs config files must not use top-level await ' +
+                'or depend on async ESM modules. Remove top-level await or switch to a synchronous config.');
+        }
+        throw error;
+    }
+};
+const loadConfigFromFile = (configFile) => {
+    const resolvedConfigFile = resolveConfigFilePath(configFile);
+    if (path.extname(resolvedConfigFile) === '.mjs') {
+        return loadMjsConfig(resolvedConfigFile);
+    }
+    return (explorerSync.load(resolvedConfigFile)?.config ??
+        {});
+};
+const searchConfig = () => {
+    let currentDir = process.cwd();
+    while (currentDir) {
+        for (const searchPlace of searchPlaces) {
+            const candidate = path.join(currentDir, searchPlace);
+            if (existsSync(candidate)) {
+                return loadConfigFromFile(candidate);
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        currentDir = parentDir === currentDir ? null : parentDir;
+    }
+    return {};
+};
+export function loadWywOptions(overrides = defaultOverrides) {
     if (cache.has(overrides)) {
         return cache.get(overrides);
     }
-    const { configFile, ignore, rules, babelOptions = {}, importLoaders: overridesImportLoaders, ...rest } = overrides;
-    const result = 
-    // eslint-disable-next-line no-nested-ternary
-    configFile === false
-        ? undefined
-        : configFile !== undefined
-            ? explorerSync.load(configFile)
-            : explorerSync.search();
+    const { configFile, ignore, rules, oxcOptions = {}, importLoaders: overridesImportLoaders, ...rest } = overrides;
     const defaultFeatures = {
         dangerousCodeRemover: true,
         globalCache: true,
         happyDOM: true,
         softErrors: false,
-        useBabelConfigs: true,
         useWeakRefInEval: true,
     };
-    const config = (result?.config ?? {});
+    const defaultEval = {
+        errors: 'strict',
+        require: 'warn-and-run',
+        resolver: 'bundler',
+        runtime: 'nodejs',
+        strategy: 'hybrid',
+    };
+    const config = (() => {
+        if (configFile === false) {
+            return {};
+        }
+        if (configFile !== undefined) {
+            return loadConfigFromFile(configFile);
+        }
+        return searchConfig();
+    })();
     const configImportLoaders = config.importLoaders;
     const configFeatures = config.features;
+    const configEval = config.eval;
     const options = {
         displayName: false,
-        evaluate: true,
+        evalConsole: 'pipe',
         extensions: ['.cjs', '.cts', '.js', '.jsx', '.mjs', '.mts', '.ts', '.tsx'],
         outputMetadata: false,
         rules: rules ?? [
             {
-                action: shaker_1.shaker,
+                action: shaker,
             },
             {
                 // The old `ignore` option is used as a default value for `ignore` rule.
@@ -73,13 +146,18 @@ function loadWywOptions(overrides = defaultOverrides) {
                     // If a file contains `export` or `import` keywords, we assume it's an ES-module
                     return /(?:^|\*\/|;|})\s*(?:export|import)[\s{]/m.test(code);
                 },
-                action: shaker_1.shaker,
+                action: shaker,
             },
         ],
-        babelOptions,
         highPriorityPlugins: ['module-resolver'],
+        oxcOptions,
         ...config,
         ...rest,
+        eval: {
+            ...defaultEval,
+            ...(configEval ?? {}),
+            ...(rest.eval ?? {}),
+        },
         importLoaders: {
             ...defaultImportLoaders,
             ...(configImportLoaders ?? {}),
@@ -91,6 +169,22 @@ function loadWywOptions(overrides = defaultOverrides) {
             ...rest.features,
         },
     };
+    const evalResolver = options.eval?.resolver;
+    if (evalResolver && !evalResolverModes.has(evalResolver)) {
+        throw new Error(`[wyw-in-js] Unsupported eval.resolver "${evalResolver}". Use "bundler", "hybrid", "native", or "custom".`);
+    }
+    const evalStrategy = options.eval?.strategy;
+    if (evalStrategy && !evalStrategies.has(evalStrategy)) {
+        throw new Error(`[wyw-in-js] Unsupported eval.strategy "${evalStrategy}". Use "execute", "hybrid", or "static".`);
+    }
+    const evalRuntime = options.eval?.runtime;
+    if (evalRuntime && !evalRuntimes.has(evalRuntime)) {
+        throw new Error(`[wyw-in-js] Unsupported eval.runtime "${evalRuntime}". Use "nodejs".`);
+    }
+    const evalErrors = options.eval?.errors;
+    if (evalErrors && !evalErrorModes.has(evalErrors)) {
+        throw new Error(`[wyw-in-js] Unsupported eval.errors "${evalErrors}". Use "strict" or "loose".`);
+    }
     cache.set(overrides, options);
     return options;
 }

package/types/transform/helpers/withDefaultServices.d.ts

@@ -1,5 +1,5 @@
 import type { Services } from '../types';
 type RequiredServices = 'options';
 export type PartialServices = Partial<Omit<Services, RequiredServices>> & Pick<Services, RequiredServices>;
-export declare const withDefaultServices: ({ babel, cache, emitWarning, eventEmitter, loadAndParseFn, log, options, }: PartialServices) => Services;
+export declare const withDefaultServices: ({ cache, emitWarning, eventEmitter, loadAndParseFn, log, options, asyncResolveKey, }: PartialServices) => Services;
 export {};

package/types/transform/helpers/withDefaultServices.js

@@ -1,51 +1,13 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withDefaultServices = void 0;
-const babelCore = __importStar(require("@babel/core"));
-const cache_1 = require("../../cache");
-const EventEmitter_1 = require("../../utils/EventEmitter");
-const Entrypoint_helpers_1 = require("../Entrypoint.helpers");
-const rootLog_1 = require("../rootLog");
-const withDefaultServices = ({ babel = babelCore, cache = new cache_1.TransformCacheCollection(), emitWarning, eventEmitter = EventEmitter_1.EventEmitter.dummy, loadAndParseFn = Entrypoint_helpers_1.loadAndParse, log = rootLog_1.rootLog, options, }) => ({
-    babel,
+import { TransformCacheCollection } from '../../cache';
+import { EventEmitter } from '../../utils/EventEmitter';
+import { loadAndParse } from '../Entrypoint.helpers';
+import { rootLog } from '../rootLog';
+export const withDefaultServices = ({ cache = new TransformCacheCollection(), emitWarning, eventEmitter = EventEmitter.dummy, loadAndParseFn = loadAndParse, log = rootLog, options, asyncResolveKey, }) => ({
     cache,
     emitWarning,
     eventEmitter,
     loadAndParseFn,
     log,
     options,
+    asyncResolveKey,
 });
-exports.withDefaultServices = withDefaultServices;

package/types/transform/isStaticallyEvaluatableModule.d.ts

@@ -1,2 +1 @@
-import type { File } from '@babel/types';
-export declare function isStaticallyEvaluatableModule(ast: File): boolean;
+export declare function isStaticallyEvaluatableModule(code: string, filename: string): boolean;

package/types/transform/isStaticallyEvaluatableModule.js

@@ -1,177 +1,176 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStaticallyEvaluatableModule = isStaticallyEvaluatableModule;
-const types_1 = require("@babel/types");
-function isTypeOnlyImport(statement) {
+import { parseSync } from 'oxc-parser';
+const isNode = (value) => !!value &&
+    typeof value === 'object' &&
+    'type' in value &&
+    typeof value.type === 'string';
+const getNodeType = (node) => node.type;
+const parseOxc = (code, filename) => {
+    const parsed = parseSync(filename, code, {
+        astType: filename.endsWith('.ts') || filename.endsWith('.tsx') ? 'ts' : 'js',
+        range: true,
+        sourceType: 'unambiguous',
+    });
+    const fatalError = parsed.errors.find((error) => error.severity === 'Error');
+    if (fatalError) {
+        throw new Error(fatalError.message);
+    }
+    return parsed.program;
+};
+const isTypeOnlyImport = (statement) => {
     if (statement.importKind === 'type') {
         return true;
     }
-    return statement.specifiers.every((specifier) => (0, types_1.isImportSpecifier)(specifier) && specifier.importKind === 'type');
-}
-function isTypeOnlyReExport(statement) {
-    if (!statement.source) {
-        return false;
-    }
-    return statement.exportKind === 'type';
-}
-function unwrapExpression(expr) {
+    return Array.isArray(statement.specifiers)
+        ? statement.specifiers.every((specifier) => isNode(specifier) &&
+            specifier.type === 'ImportSpecifier' &&
+            specifier.importKind === 'type')
+        : false;
+};
+const isTypeOnlyReExport = (statement) => !!statement.source && statement.exportKind === 'type';
+const isWrapperExpression = (node) => node.type === 'TSAsExpression' ||
+    node.type === 'TSSatisfiesExpression' ||
+    node.type === 'TSNonNullExpression' ||
+    node.type === 'TSInstantiationExpression' ||
+    node.type === 'TSTypeAssertion' ||
+    node.type === 'ParenthesizedExpression';
+const unwrapExpression = (expr) => {
     let current = expr;
-    for (;;) {
-        if ((0, types_1.isTSAsExpression)(current)) {
-            current = current.expression;
-            // eslint-disable-next-line no-continue
-            continue;
-        }
-        if ((0, types_1.isTSSatisfiesExpression)(current)) {
-            current = current.expression;
-            // eslint-disable-next-line no-continue
-            continue;
-        }
-        if ((0, types_1.isTSNonNullExpression)(current)) {
-            current = current.expression;
-            // eslint-disable-next-line no-continue
-            continue;
-        }
-        if ((0, types_1.isTSInstantiationExpression)(current)) {
-            current = current.expression;
-            // eslint-disable-next-line no-continue
-            continue;
-        }
-        if ((0, types_1.isParenthesizedExpression)(current)) {
-            current = current.expression;
-            // eslint-disable-next-line no-continue
-            continue;
-        }
-        return current;
-    }
-}
-function isSafeExpression(expr) {
+    while (isWrapperExpression(current)) {
+        current = current.expression;
+    }
+    return current;
+};
+const isSafeLiteral = (expr) => getNodeType(expr) === 'Literal' &&
+    (() => {
+        const { value } = expr;
+        return (value === null ||
+            typeof value === 'string' ||
+            typeof value === 'number' ||
+            typeof value === 'boolean' ||
+            typeof value === 'bigint');
+    })();
+const isSafeExpression = (expr) => {
     const unwrapped = unwrapExpression(expr);
-    if ((0, types_1.isStringLiteral)(unwrapped) ||
-        (0, types_1.isNumericLiteral)(unwrapped) ||
-        (0, types_1.isBooleanLiteral)(unwrapped) ||
-        (0, types_1.isNullLiteral)(unwrapped) ||
-        (0, types_1.isBigIntLiteral)(unwrapped)) {
+    const type = unwrapped.type;
+    if (isSafeLiteral(unwrapped)) {
         return true;
     }
-    if ((0, types_1.isArrowFunctionExpression)(unwrapped) || (0, types_1.isFunctionExpression)(unwrapped)) {
+    if (type === 'ArrowFunctionExpression' || type === 'FunctionExpression') {
         return true;
     }
-    if ((0, types_1.isIdentifier)(unwrapped)) {
-        return (unwrapped.name === 'undefined' ||
-            unwrapped.name === 'NaN' ||
-            unwrapped.name === 'Infinity');
+    if (type === 'Identifier') {
+        const identifier = unwrapped;
+        return (identifier.name === 'undefined' ||
+            identifier.name === 'NaN' ||
+            identifier.name === 'Infinity');
     }
-    if ((0, types_1.isTemplateLiteral)(unwrapped)) {
-        return unwrapped.expressions.every((item) => (0, types_1.isExpression)(item) && isSafeExpression(item));
+    if (type === 'TemplateLiteral') {
+        return unwrapped.expressions.every((item) => isSafeExpression(item));
     }
-    if ((0, types_1.isUnaryExpression)(unwrapped)) {
+    if (type === 'UnaryExpression') {
         return isSafeExpression(unwrapped.argument);
     }
-    if ((0, types_1.isBinaryExpression)(unwrapped) || (0, types_1.isLogicalExpression)(unwrapped)) {
-        return (isSafeExpression(unwrapped.left) &&
-            isSafeExpression(unwrapped.right));
+    if (type === 'BinaryExpression' || type === 'LogicalExpression') {
+        const binaryLike = unwrapped;
+        return (isSafeExpression(binaryLike.left) && isSafeExpression(binaryLike.right));
     }
-    if ((0, types_1.isConditionalExpression)(unwrapped)) {
-        return (isSafeExpression(unwrapped.test) &&
-            isSafeExpression(unwrapped.consequent) &&
-            isSafeExpression(unwrapped.alternate));
+    if (type === 'ConditionalExpression') {
+        const conditional = unwrapped;
+        return (isSafeExpression(conditional.test) &&
+            isSafeExpression(conditional.consequent) &&
+            isSafeExpression(conditional.alternate));
     }
-    if ((0, types_1.isArrayExpression)(unwrapped)) {
+    if (type === 'ArrayExpression') {
         return unwrapped.elements.every((item) => {
-            if (item === null)
+            if (!item) {
                 return true;
-            if ((0, types_1.isSpreadElement)(item))
+            }
+            if (item.type === 'SpreadElement') {
                 return false;
+            }
             return isSafeExpression(item);
         });
     }
-    if ((0, types_1.isObjectExpression)(unwrapped)) {
-        return unwrapped.properties.every((prop) => {
-            if ((0, types_1.isSpreadElement)(prop)) {
+    if (type === 'ObjectExpression') {
+        return unwrapped.properties.every((property) => {
+            if (property.type === 'SpreadElement') {
                 return false;
             }
-            if ((0, types_1.isObjectMethod)(prop)) {
-                return !prop.computed;
+            const propertyNode = property;
+            if (propertyNode.computed) {
+                return false;
             }
-            if ((0, types_1.isObjectProperty)(prop)) {
-                if (prop.computed) {
-                    return false;
-                }
-                return (0, types_1.isExpression)(prop.value) && isSafeExpression(prop.value);
+            if (propertyNode.method) {
+                return true;
             }
-            return false;
+            return (isNode(propertyNode.value) && isSafeExpression(propertyNode.value));
         });
     }
-    if ((0, types_1.isCallExpression)(unwrapped) ||
-        (0, types_1.isNewExpression)(unwrapped) ||
-        (0, types_1.isTaggedTemplateExpression)(unwrapped) ||
-        (0, types_1.isAwaitExpression)(unwrapped) ||
-        (0, types_1.isYieldExpression)(unwrapped) ||
-        (0, types_1.isUpdateExpression)(unwrapped) ||
-        (0, types_1.isAssignmentExpression)(unwrapped) ||
-        (0, types_1.isSequenceExpression)(unwrapped)) {
+    if (type === 'CallExpression' ||
+        type === 'NewExpression' ||
+        type === 'TaggedTemplateExpression' ||
+        type === 'AwaitExpression' ||
+        type === 'YieldExpression' ||
+        type === 'UpdateExpression' ||
+        type === 'AssignmentExpression' ||
+        type === 'SequenceExpression' ||
+        type === 'ClassExpression' ||
+        type === 'ClassDeclaration') {
         return false;
     }
     return false;
-}
-function isSafeDeclarator(declarator) {
-    if (!declarator.init) {
-        return true;
-    }
-    return isSafeExpression(declarator.init);
-}
-function isSafeVariableDeclaration(decl) {
-    return decl.declarations.every(isSafeDeclarator);
-}
-function isSafeStatement(statement) {
-    if ((0, types_1.isImportDeclaration)(statement)) {
+};
+const isSafeDeclarator = (declarator) => !isNode(declarator.init) || isSafeExpression(declarator.init);
+const isSafeVariableDeclaration = (statement) => statement.declarations.every((declarator) => isSafeDeclarator(declarator));
+const isSafeStatement = (statement) => {
+    if (statement.type.startsWith('TS') || statement.type.startsWith('JSDoc')) {
+        return statement.type !== 'TSEnumDeclaration';
+    }
+    if (statement.type === 'ImportDeclaration') {
         return isTypeOnlyImport(statement);
     }
-    if ((0, types_1.isExportAllDeclaration)(statement)) {
+    if (statement.type === 'ExportAllDeclaration') {
         return false;
     }
-    if ((0, types_1.isExportNamedDeclaration)(statement)) {
-        if (!statement.declaration) {
-            return !statement.source || isTypeOnlyReExport(statement);
+    if (statement.type === 'ExportNamedDeclaration') {
+        if (!isNode(statement.declaration)) {
+            return !isNode(statement.source) || isTypeOnlyReExport(statement);
         }
-        if ((0, types_1.isFunctionDeclaration)(statement.declaration)) {
+        if (statement.declaration.type === 'FunctionDeclaration') {
             return true;
         }
-        if ((0, types_1.isClassDeclaration)(statement.declaration)) {
+        if (statement.declaration.type === 'ClassDeclaration') {
             return false;
         }
-        if (statement.declaration.type === 'VariableDeclaration') {
-            return isSafeVariableDeclaration(statement.declaration);
-        }
-        return false;
+        return (statement.declaration.type === 'VariableDeclaration' &&
+            isSafeVariableDeclaration(statement.declaration));
     }
-    if ((0, types_1.isExportDefaultDeclaration)(statement)) {
-        const decl = statement.declaration;
-        if ((0, types_1.isFunctionDeclaration)(decl) ||
-            (0, types_1.isFunctionExpression)(decl) ||
-            (0, types_1.isArrowFunctionExpression)(decl) ||
-            (0, types_1.isClassExpression)(decl) ||
-            (0, types_1.isClassDeclaration)(decl)) {
+    if (statement.type === 'ExportDefaultDeclaration') {
+        const { declaration } = statement;
+        if (!isNode(declaration)) {
+            return false;
+        }
+        if (declaration.type === 'FunctionDeclaration' ||
+            declaration.type === 'FunctionExpression' ||
+            declaration.type === 'ArrowFunctionExpression' ||
+            declaration.type === 'ClassExpression' ||
+            declaration.type === 'ClassDeclaration') {
             return false;
         }
-        return isSafeExpression(decl);
+        return isSafeExpression(declaration);
     }
     if (statement.type === 'VariableDeclaration') {
         return isSafeVariableDeclaration(statement);
     }
-    if ((0, types_1.isFunctionDeclaration)(statement)) {
+    if (statement.type === 'FunctionDeclaration' ||
+        statement.type === 'EmptyStatement') {
         return true;
     }
-    if ((0, types_1.isEmptyStatement)(statement)) {
-        return true;
-    }
-    if ((0, types_1.isExpressionStatement)(statement)) {
-        // Directives (like "use strict") are safe.
-        return (0, types_1.isStringLiteral)(statement.expression);
+    if (statement.type === 'ExpressionStatement') {
+        return isNode(statement.expression) && isSafeLiteral(statement.expression);
     }
     return false;
-}
-function isStaticallyEvaluatableModule(ast) {
-    return ast.program.body.every(isSafeStatement);
+};
+export function isStaticallyEvaluatableModule(code, filename) {
+    return parseOxc(code, filename).body.every((statement) => isSafeStatement(statement));
 }

package/types/transform/oxcBarrelManifest.d.ts

@@ -0,0 +1,2 @@
+import type { BarrelManifestCacheEntry, RawBarrelManifest } from './barrelManifest.types';
+export declare function analyzeOxcBarrelFile(code: string, filename: string): BarrelManifestCacheEntry | RawBarrelManifest;