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

package/types/utils/oxcShaker.js

@@ -0,0 +1,751 @@
+/* eslint-disable no-restricted-syntax */
+import fs from 'fs';
+import path from 'path';
+import { syncResolve } from '@wyw-in-js/shared';
+import { collectOxcExportsAndImportsFromProgram } from './collectOxcExportsAndImports';
+import { getImportOverride, toImportKey } from './importOverrides';
+import { parseOxcCached } from './parseOxc';
+import { stripQueryAndHash } from './parseRequest';
+const warnedDynamicImportFiles = new Set();
+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;
+};
+const parseOxc = (code, filename) => {
+    try {
+        const parsed = parseOxcCached(filename, code, 'unambiguous');
+        return {
+            isEsModule: parsed.module.hasModuleSyntax,
+            program: parsed.program,
+        };
+    }
+    catch (error) {
+        if (process.env.WYW_DEBUG_SHAKER_DUMP) {
+            const dumpFile = path.join('/tmp', `wyw-oxc-shaker-${path
+                .basename(filename)
+                .replace(/[^a-z0-9_.-]/gi, '_')}-${Date.now()}.js`);
+            fs.writeFileSync(dumpFile, code);
+            const message = error instanceof Error
+                ? error.message
+                : 'Unknown Oxc shaker parse error';
+            throw new Error(`${message} [${filename}] [dump: ${dumpFile}]`);
+        }
+        throw error;
+    }
+};
+const applyReplacements = (code, replacements) => {
+    let result = code;
+    replacements
+        .sort((a, b) => b.start - a.start)
+        .forEach((replacement) => {
+        result =
+            result.slice(0, replacement.start) +
+                replacement.value +
+                result.slice(replacement.end);
+    });
+    return result;
+};
+const collectBindingNames = (node) => {
+    if (!node) {
+        return [];
+    }
+    if (node.type === 'Identifier') {
+        return [node.name];
+    }
+    if (node.type === 'RestElement') {
+        return collectBindingNames(node.argument);
+    }
+    if (node.type === 'AssignmentPattern') {
+        return collectBindingNames(node.left);
+    }
+    if (node.type === 'ObjectPattern') {
+        return node.properties.flatMap((property) => property.type === 'RestElement'
+            ? collectBindingNames(property.argument)
+            : collectBindingNames(property.value));
+    }
+    if (node.type === 'ArrayPattern') {
+        return node.elements.flatMap((element) => collectBindingNames(element));
+    }
+    return [];
+};
+const declarationBindings = (declaration) => {
+    if (!declaration) {
+        return [];
+    }
+    if (declaration.type === 'VariableDeclaration') {
+        return declaration.declarations.flatMap((item) => collectBindingNames(item.id));
+    }
+    if ((declaration.type === 'FunctionDeclaration' ||
+        declaration.type === 'ClassDeclaration' ||
+        declaration.type === 'TSEnumDeclaration') &&
+        declaration.id) {
+        return [declaration.id.name];
+    }
+    return [];
+};
+const moduleExportName = (node) => {
+    if (node.type === 'Identifier' || node.type === 'Literal') {
+        return String(node.name ?? node.value);
+    }
+    return null;
+};
+const isBindingIdentifier = (node, parent) => {
+    if (node.type !== 'Identifier' || !parent) {
+        return false;
+    }
+    const parentNode = parent;
+    if (parent.type === 'VariableDeclarator' && parentNode.id === node) {
+        return true;
+    }
+    if ((parent.type === 'FunctionDeclaration' ||
+        parent.type === 'FunctionExpression' ||
+        parent.type === 'ClassDeclaration' ||
+        parent.type === 'ClassExpression' ||
+        parent.type === 'TSEnumDeclaration') &&
+        parentNode.id === node) {
+        return true;
+    }
+    if ((parent.type === 'ImportSpecifier' ||
+        parent.type === 'ImportDefaultSpecifier' ||
+        parent.type === 'ImportNamespaceSpecifier') &&
+        parentNode.local === node) {
+        return true;
+    }
+    return false;
+};
+const isIdentifierReference = (node, parent, grandparent) => {
+    if (node.type !== 'Identifier') {
+        return false;
+    }
+    if (isBindingIdentifier(node, parent)) {
+        return false;
+    }
+    if (!parent) {
+        return true;
+    }
+    const parentNode = parent;
+    if (parent.type === 'Property' &&
+        parentNode.key === node &&
+        !parentNode.computed) {
+        return false;
+    }
+    if (parent.type === 'MemberExpression' &&
+        parentNode.property === node &&
+        !parentNode.computed) {
+        return false;
+    }
+    if (parent.type === 'ExportSpecifier' && parentNode.exported === node) {
+        return false;
+    }
+    if (parent.type === 'ExportSpecifier' && parentNode.local === node) {
+        return grandparent?.type === 'ExportNamedDeclaration'
+            ? !grandparent.source
+            : true;
+    }
+    // The `imported` name of `import { X as Y }` is what to take from the source
+    // module — it does not reference a local binding `X` in the current module.
+    if (parent.type === 'ImportSpecifier' && parentNode.imported === node) {
+        return false;
+    }
+    return true;
+};
+const TS_EXPRESSION_WRAPPER_TYPES = new Set([
+    'TSAsExpression',
+    'TSSatisfiesExpression',
+    'TSTypeAssertion',
+    'TSNonNullExpression',
+    'TSInstantiationExpression',
+]);
+const collectReferences = (node) => {
+    const references = new Set();
+    const visit = (current, parent = null, grandparent = null) => {
+        if (TS_EXPRESSION_WRAPPER_TYPES.has(current.type)) {
+            const expression = current.expression;
+            if (expression) {
+                visit(expression, current, parent);
+            }
+            return;
+        }
+        if (current.type.startsWith('TS') && current.type !== 'TSEnumDeclaration') {
+            return;
+        }
+        if (isIdentifierReference(current, parent, grandparent)) {
+            references.add(current.name);
+        }
+        getChildren(current).forEach((child) => visit(child, current, parent));
+    };
+    visit(node);
+    return references;
+};
+const getMutatedBinding = (node) => {
+    if (node.type === 'Identifier') {
+        return node.name;
+    }
+    if (node.type === 'MemberExpression' && node.object.type === 'Identifier') {
+        return node.object.name;
+    }
+    return null;
+};
+const getMutationCallTarget = (node) => {
+    if (node.type !== 'CallExpression') {
+        return null;
+    }
+    const { callee } = node;
+    if (callee.type !== 'MemberExpression' ||
+        callee.object.type !== 'Identifier' ||
+        callee.object.name !== 'Object' ||
+        callee.computed ||
+        callee.property.type !== 'Identifier') {
+        return null;
+    }
+    if (callee.property.name !== 'assign' &&
+        callee.property.name !== 'defineProperty' &&
+        callee.property.name !== 'defineProperties') {
+        return null;
+    }
+    const [target] = node.arguments;
+    if (!target || target.type === 'SpreadElement') {
+        return null;
+    }
+    return getMutatedBinding(target);
+};
+const collectMutations = (node) => {
+    const mutations = new Set();
+    const visit = (current) => {
+        if (current.type === 'AssignmentExpression') {
+            const mutated = getMutatedBinding(current.left);
+            if (mutated) {
+                mutations.add(mutated);
+            }
+        }
+        else if (current.type === 'UpdateExpression') {
+            const mutated = getMutatedBinding(current.argument);
+            if (mutated) {
+                mutations.add(mutated);
+            }
+        }
+        else {
+            const mutated = getMutationCallTarget(current);
+            if (mutated) {
+                mutations.add(mutated);
+            }
+        }
+        getChildren(current).forEach(visit);
+    };
+    visit(node);
+    return mutations;
+};
+const buildStatementInfo = (program, collected) => {
+    const { exports: collectedExports, imports: collectedImports } = collected;
+    const importsByStart = new Map();
+    collectedImports.forEach((item) => {
+        const bucket = importsByStart.get(item.local.start) ?? [];
+        bucket.push(item);
+        importsByStart.set(item.local.start, bucket);
+    });
+    return program.body.map((statement) => {
+        const node = statement;
+        const exportNames = new Set();
+        const bindings = new Set();
+        const imports = [];
+        const references = collectReferences(node);
+        let sideEffectImport = false;
+        if (node.type === 'ImportDeclaration') {
+            sideEffectImport = node.specifiers.length === 0;
+            node.specifiers.forEach((specifier) => {
+                bindings.add(specifier.local.name);
+                const matched = importsByStart.get(specifier.local.start) ?? [];
+                imports.push(...matched);
+            });
+            if (sideEffectImport) {
+                const matched = collectedImports.filter((item) => item.imported === 'side-effect' &&
+                    item.local.start === node.start &&
+                    item.local.end === node.end);
+                imports.push(...matched);
+            }
+        }
+        else if (node.type === 'ExportNamedDeclaration') {
+            declarationBindings(node.declaration).forEach((name) => bindings.add(name));
+            if (node.declaration) {
+                declarationBindings(node.declaration).forEach((name) => exportNames.add(name));
+            }
+            node.specifiers.forEach((specifier) => {
+                const local = moduleExportName(specifier.local);
+                const exported = moduleExportName(specifier.exported);
+                if (local && !node.source)
+                    references.add(local);
+                if (exported)
+                    exportNames.add(exported);
+            });
+        }
+        else if (node.type === 'ExportDefaultDeclaration') {
+            exportNames.add('default');
+            declarationBindings(node.declaration).forEach((name) => bindings.add(name));
+        }
+        else if (node.type === 'ExportAllDeclaration') {
+            if (node.exported) {
+                const exported = moduleExportName(node.exported);
+                if (exported) {
+                    exportNames.add(exported);
+                }
+            }
+            else {
+                exportNames.add('*');
+            }
+        }
+        else {
+            Object.entries(collectedExports).forEach(([exported, local]) => {
+                if (local.start >= node.start && local.end <= node.end) {
+                    exportNames.add(exported);
+                }
+            });
+            declarationBindings(node).forEach((name) => bindings.add(name));
+        }
+        return {
+            bindings,
+            exportNames,
+            imports,
+            mutations: collectMutations(node),
+            node,
+            references,
+            sideEffectImport,
+        };
+    });
+};
+const collectImportLocalNames = (node) => {
+    if (node.type !== 'ImportDeclaration') {
+        return [];
+    }
+    return node.specifiers.map((specifier) => specifier.local.name);
+};
+const getImportSpecifierLocalName = (node) => {
+    const { local } = node;
+    return isNode(local) && 'name' in local && typeof local.name === 'string'
+        ? local.name
+        : null;
+};
+const expandImportRemovalRange = (code, start, end) => {
+    let removalStart = start;
+    while (removalStart > 0 &&
+        (code[removalStart - 1] === ' ' || code[removalStart - 1] === '\t')) {
+        removalStart -= 1;
+    }
+    let removalEnd = end;
+    if (code[removalEnd] === ';') {
+        removalEnd += 1;
+    }
+    while (removalEnd < code.length &&
+        (code[removalEnd] === ' ' || code[removalEnd] === '\t')) {
+        removalEnd += 1;
+    }
+    if (code[removalEnd] === '\r' && code[removalEnd + 1] === '\n') {
+        removalEnd += 2;
+    }
+    else if (code[removalEnd] === '\n') {
+        removalEnd += 1;
+    }
+    return {
+        end: removalEnd,
+        start: removalStart,
+        value: '',
+    };
+};
+const expandImportSpecifierRemovalRange = (code, start, end) => {
+    let removalStart = start;
+    let removalEnd = end;
+    let whitespaceStart = removalStart;
+    while (whitespaceStart > 0 &&
+        (code[whitespaceStart - 1] === ' ' || code[whitespaceStart - 1] === '\t')) {
+        whitespaceStart -= 1;
+    }
+    if (code[whitespaceStart - 1] !== '{') {
+        removalStart = whitespaceStart;
+    }
+    while (removalEnd < code.length &&
+        (code[removalEnd] === ' ' || code[removalEnd] === '\t')) {
+        removalEnd += 1;
+    }
+    if (code[removalEnd] === ',') {
+        removalEnd += 1;
+        while (removalEnd < code.length &&
+            (code[removalEnd] === ' ' || code[removalEnd] === '\t')) {
+            removalEnd += 1;
+        }
+    }
+    else {
+        while (removalStart > 0 &&
+            (code[removalStart - 1] === ' ' || code[removalStart - 1] === '\t')) {
+            removalStart -= 1;
+        }
+        if (code[removalStart - 1] === ',') {
+            removalStart -= 1;
+            while (removalStart > 0 &&
+                (code[removalStart - 1] === ' ' || code[removalStart - 1] === '\t')) {
+                removalStart -= 1;
+            }
+        }
+    }
+    return {
+        end: removalEnd,
+        start: removalStart,
+        value: '',
+    };
+};
+const mergeEmptyRemovalRanges = (removals) => {
+    if (removals.length <= 1) {
+        return removals;
+    }
+    const sorted = [...removals].sort((a, b) => a.start - b.start);
+    const merged = [];
+    sorted.forEach((removal) => {
+        const previous = merged[merged.length - 1];
+        if (previous &&
+            previous.value === '' &&
+            removal.value === '' &&
+            removal.start <= previous.end) {
+            previous.end = Math.max(previous.end, removal.end);
+            return;
+        }
+        merged.push({ ...removal });
+    });
+    return merged;
+};
+const removeUnusedImportSpecifiers = (code, filename) => {
+    const parsed = parseOxc(code, filename);
+    const { program } = parsed;
+    const referencedNames = new Set();
+    program.body.forEach((statement) => {
+        if (statement.type === 'ImportDeclaration') {
+            return;
+        }
+        collectReferences(statement).forEach((name) => referencedNames.add(name));
+    });
+    const removals = [];
+    program.body.forEach((statement) => {
+        if (statement.type !== 'ImportDeclaration') {
+            return;
+        }
+        if (statement.specifiers.length === 0) {
+            return;
+        }
+        const localNames = collectImportLocalNames(statement);
+        if (localNames.every((localName) => !referencedNames.has(localName))) {
+            removals.push(expandImportRemovalRange(code, statement.start, statement.end));
+            return;
+        }
+        if (statement.specifiers.length <= 1) {
+            return;
+        }
+        statement.specifiers.forEach((specifier) => {
+            const localName = getImportSpecifierLocalName(specifier);
+            if (localName && !referencedNames.has(localName)) {
+                removals.push(expandImportSpecifierRemovalRange(code, specifier.start, specifier.end));
+            }
+        });
+    });
+    if (removals.length === 0) {
+        return {
+            code,
+            parsed,
+        };
+    }
+    const mergedRemovals = mergeEmptyRemovalRanges(removals);
+    const nextCode = applyReplacements(code, mergedRemovals);
+    try {
+        return {
+            code: nextCode,
+            parsed: parseOxc(nextCode, filename),
+        };
+    }
+    catch {
+        return {
+            code,
+            parsed,
+        };
+    }
+};
+const hasImportOverride = (source, options) => {
+    const { importOverrides } = options;
+    if (!importOverrides || Object.keys(importOverrides).length === 0) {
+        return false;
+    }
+    const stripped = stripQueryAndHash(source);
+    const direct = getImportOverride(importOverrides, source) ??
+        (stripped !== source ? getImportOverride(importOverrides, stripped) : null);
+    if (direct && ('mock' in direct || 'noShake' in direct)) {
+        return true;
+    }
+    if (!stripped.startsWith('.') && !path.isAbsolute(stripped)) {
+        return false;
+    }
+    return false;
+};
+const importsToMap = (collected) => {
+    const result = new Map();
+    const add = (source, imported) => {
+        const bucket = result.get(source) ?? [];
+        if (!bucket.includes(imported)) {
+            bucket.push(imported);
+        }
+        result.set(source, bucket);
+    };
+    collected.imports.forEach((item) => {
+        const imported = item.imported || 'side-effect';
+        add(item.source, imported);
+    });
+    collected.reexports.forEach((item) => {
+        add(item.source, item.imported || 'side-effect');
+    });
+    return result;
+};
+const dynamicImportWarningsEnabled = () => Boolean(process.env.WYW_WARN_DYNAMIC_IMPORTS) &&
+    process.env.WYW_WARN_DYNAMIC_IMPORTS !== '0' &&
+    process.env.WYW_WARN_DYNAMIC_IMPORTS !== 'false';
+const filterDynamicImportsForWarning = (imports, filename, options) => {
+    const sources = Array.from(new Set(imports
+        .filter((item) => item.type === 'dynamic')
+        .map((item) => item.source))).sort();
+    if (!options.importOverrides ||
+        Object.keys(options.importOverrides).length === 0) {
+        return sources;
+    }
+    const shouldWarn = (source) => {
+        const strippedSource = stripQueryAndHash(source);
+        const direct = getImportOverride(options.importOverrides, source) ??
+            (strippedSource !== source
+                ? getImportOverride(options.importOverrides, strippedSource)
+                : undefined);
+        if (direct !== undefined) {
+            return false;
+        }
+        const isFileImport = strippedSource.startsWith('.') || path.isAbsolute(strippedSource);
+        if (!isFileImport) {
+            return true;
+        }
+        try {
+            const resolved = syncResolve(strippedSource, filename, []);
+            const importKey = toImportKey({
+                resolved,
+                root: options.root,
+                source: strippedSource,
+            }).key;
+            return (getImportOverride(options.importOverrides, importKey) === undefined);
+        }
+        catch {
+            return true;
+        }
+    };
+    return sources.filter(shouldWarn);
+};
+const warnDynamicImports = (imports, filename, options) => {
+    if (!dynamicImportWarningsEnabled() ||
+        warnedDynamicImportFiles.has(filename)) {
+        return;
+    }
+    const sourcesToWarn = filterDynamicImportsForWarning(imports, filename, options);
+    if (sourcesToWarn.length === 0) {
+        return;
+    }
+    warnedDynamicImportFiles.add(filename);
+    const overrideKeys = sourcesToWarn
+        .map((source) => {
+        const strippedSource = stripQueryAndHash(source);
+        const isFileImport = strippedSource.startsWith('.') || path.isAbsolute(strippedSource);
+        if (!isFileImport) {
+            return { key: source, source };
+        }
+        try {
+            const resolved = syncResolve(strippedSource, filename, []);
+            return {
+                key: toImportKey({
+                    resolved,
+                    root: options.root,
+                    source: strippedSource,
+                }).key,
+                source,
+            };
+        }
+        catch {
+            return { key: strippedSource, source };
+        }
+    })
+        .filter((item, index, array) => {
+        const firstIndexForKey = array.findIndex((i) => i.key === item.key);
+        return firstIndexForKey === index;
+    });
+    const warning = [
+        `[wyw-in-js] Dynamic imports reached prepare stage`,
+        ``,
+        `file: ${filename}`,
+        `count: ${sourcesToWarn.length}`,
+        `sources:`,
+        ...sourcesToWarn.map((source) => `  - ${source}`),
+        ``,
+        `note: these imports will be resolved/processed even if they are lazy (e.g. React.lazy(() => import(...)))`,
+        ``,
+        `tip: if the imported module is runtime-only or heavy, mock it during evaluation via importOverrides:`,
+        `  importOverrides: {`,
+        ...overrideKeys.map(({ key, source }) => `    '${key}': { mock: './path/to/mock' }, // from ${source}`),
+        `  }`,
+        ``,
+        `note: importOverrides affects only build-time evaluation (it does not change your bundler runtime behavior)`,
+    ].join('\n');
+    // eslint-disable-next-line no-console
+    console.warn(warning);
+};
+const removeExportKeyword = (code, node) => {
+    if (node.type !== 'ExportNamedDeclaration' ||
+        !node.declaration ||
+        node.start === node.declaration.start) {
+        return null;
+    }
+    return {
+        end: node.declaration.start,
+        start: node.start,
+        value: '',
+    };
+};
+const splitExportedVariableDeclaration = (code, node, requested) => {
+    if (node.type !== 'ExportNamedDeclaration' ||
+        !node.declaration ||
+        node.declaration.type !== 'VariableDeclaration' ||
+        node.declaration.declarations.length <= 1) {
+        return null;
+    }
+    const declarators = node.declaration.declarations;
+    const declaratorNames = declarators.map((declarator) => collectBindingNames(declarator.id));
+    const requestedNames = declaratorNames
+        .flat()
+        .filter((name) => requested.has(name));
+    if (requestedNames.length === 0 ||
+        requestedNames.length === declaratorNames.flat().length) {
+        return null;
+    }
+    const declarationCode = `${node.declaration.kind} ${declarators
+        .map((declarator) => code.slice(declarator.start, declarator.end))
+        .join(', ')};`;
+    return {
+        end: node.end,
+        start: node.start,
+        value: `${declarationCode}\nexport { ${requestedNames.join(', ')} };`,
+    };
+};
+export const shakeOxcToESM = (code, filename, options) => {
+    const parsed = parseOxc(code, filename);
+    const { program } = parsed;
+    const collected = collectOxcExportsAndImportsFromProgram(program, code, parsed.isEsModule);
+    const statements = buildStatementInfo(program, collected);
+    const bindingOwners = new Map();
+    statements.forEach((statement) => {
+        statement.bindings.forEach((binding) => {
+            if (!bindingOwners.has(binding)) {
+                bindingOwners.set(binding, statement);
+            }
+        });
+    });
+    const requested = new Set(options.onlyExports);
+    const keepAllExports = requested.has('*');
+    const liveStatements = new Set();
+    const liveExportStatements = new Set();
+    const queue = [];
+    const mutationsByBinding = new Map();
+    statements.forEach((statement) => {
+        statement.mutations.forEach((binding) => {
+            const bucket = mutationsByBinding.get(binding) ?? [];
+            bucket.push(statement);
+            mutationsByBinding.set(binding, bucket);
+        });
+    });
+    const mark = (statement, exported = false) => {
+        if (!liveStatements.has(statement)) {
+            liveStatements.add(statement);
+            queue.push(statement);
+        }
+        if (exported) {
+            liveExportStatements.add(statement);
+        }
+    };
+    statements.forEach((statement) => {
+        const hasWildcardReexport = statement.exportNames.has('*');
+        if (statement.exportNames.size > 0 &&
+            (keepAllExports ||
+                (hasWildcardReexport &&
+                    requested.size > 0 &&
+                    !requested.has('side-effect')) ||
+                [...statement.exportNames].some((name) => requested.has(name)))) {
+            mark(statement, true);
+        }
+        if (statement.sideEffectImport &&
+            (requested.has('side-effect') ||
+                options.keepSideEffects ||
+                statement.imports.some((item) => hasImportOverride(item.source, options)))) {
+            mark(statement);
+        }
+    });
+    while (queue.length > 0) {
+        const current = queue.shift();
+        current.references.forEach((name) => {
+            const owner = bindingOwners.get(name);
+            if (owner) {
+                mark(owner);
+            }
+        });
+        current.bindings.forEach((binding) => {
+            mutationsByBinding.get(binding)?.forEach((mutation) => {
+                mark(mutation);
+            });
+        });
+    }
+    const replacements = [];
+    statements.forEach((statement) => {
+        if (!liveStatements.has(statement)) {
+            replacements.push({
+                end: statement.node.end,
+                start: statement.node.start,
+                value: '',
+            });
+            return;
+        }
+        if (!liveExportStatements.has(statement)) {
+            const replacement = removeExportKeyword(code, statement.node);
+            if (replacement) {
+                replacements.push(replacement);
+            }
+            return;
+        }
+        const splitReplacement = splitExportedVariableDeclaration(code, statement.node, requested);
+        if (splitReplacement) {
+            replacements.push(splitReplacement);
+        }
+    });
+    const cleaned = removeUnusedImportSpecifiers(applyReplacements(code, replacements), filename);
+    const nextCode = cleaned.code;
+    const nextCollected = collectOxcExportsAndImportsFromProgram(cleaned.parsed.program, nextCode, cleaned.parsed.isEsModule);
+    warnDynamicImports(nextCollected.imports, filename, options);
+    return {
+        code: nextCode,
+        imports: importsToMap(nextCollected),
+    };
+};