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

package/types/plugins/shaker.js

@@ -1,724 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = shakerPlugin;
-const path_1 = __importDefault(require("path"));
-const shared_1 = require("@wyw-in-js/shared");
-const collectExportsAndImports_1 = require("../utils/collectExportsAndImports");
-const getFileIdx_1 = require("../utils/getFileIdx");
-const isRemoved_1 = require("../utils/isRemoved");
-const scopeHelpers_1 = require("../utils/scopeHelpers");
-const traversalCache_1 = require("../utils/traversalCache");
-const parseRequest_1 = require("../utils/parseRequest");
-const importOverrides_1 = require("../utils/importOverrides");
-const warnedDynamicImportFiles = new Set();
-function getNonParamBinding(exportPath, name) {
-    const binding = exportPath.scope.getBinding(name);
-    if (binding && binding.kind !== 'param') {
-        return binding;
-    }
-    // When `exportPath` is inside a function scope, a parameter can shadow
-    // the actual export binding (e.g. `export function fallback(fallback) {}`).
-    // In such cases we need the binding from the declaration scope.
-    return exportPath.scope.parent?.getBinding(name) ?? binding;
-}
-function getBindingForExport(exportPath) {
-    if (exportPath.isIdentifier()) {
-        return getNonParamBinding(exportPath, exportPath.node.name);
-    }
-    const variableDeclarator = exportPath.findParent((p) => p.isVariableDeclarator());
-    if (variableDeclarator) {
-        const id = variableDeclarator.get('id');
-        if (id.isIdentifier()) {
-            return variableDeclarator.scope.getBinding(id.node.name);
-        }
-    }
-    if (exportPath.isAssignmentExpression()) {
-        const left = exportPath.get('left');
-        if (left.isIdentifier()) {
-            return getNonParamBinding(exportPath, left.node.name);
-        }
-    }
-    if (exportPath.isFunctionDeclaration() || exportPath.isClassDeclaration()) {
-        const { id } = exportPath.node;
-        if (!id) {
-            // `export default function() {}` / `export default class {}` (anonymous)
-            return undefined;
-        }
-        return getNonParamBinding(exportPath, id.name);
-    }
-    if (exportPath.isTSEnumDeclaration()) {
-        return getNonParamBinding(exportPath, exportPath.node.id.name);
-    }
-    return undefined;
-}
-const withoutRemoved = (items) => items.filter(({ local }) => !(0, isRemoved_1.isRemoved)(local));
-function rearrangeExports({ types: t }, root, exportRefs, exports) {
-    const rearranged = {
-        ...exports,
-    };
-    const rootScope = root.scope;
-    exportRefs.forEach((refs, name) => {
-        if (refs.length <= 1) {
-            if (refs.length === 1) {
-                // Maybe exports is assigned to another variable?
-                const declarator = refs[0].findParent((p) => p.isVariableDeclarator());
-                if (!declarator) {
-                    return;
-                }
-            }
-            else {
-                return;
-            }
-        }
-        const uid = rootScope.generateUid(name);
-        // Define variable in the beginning
-        const [declaration] = root.unshiftContainer('body', [
-            t.variableDeclaration('var', [t.variableDeclarator(t.identifier(uid))]),
-        ]);
-        rootScope.registerDeclaration(declaration);
-        const constantViolations = [];
-        // Replace every reference with defined variable
-        refs.forEach((ref) => {
-            const [replaced] = ref.replaceWith(t.identifier(uid));
-            if (replaced.isBindingIdentifier()) {
-                constantViolations.push(replaced);
-            }
-            else {
-                (0, scopeHelpers_1.reference)(replaced);
-            }
-        });
-        constantViolations.forEach((id) => {
-            rootScope.registerConstantViolation(id);
-        });
-        const assigmentToExport = t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier('exports'), t.identifier(name)), t.identifier(uid)));
-        // export.foo = _foo will be inserted either after the last _foo assigment or in the end of the file
-        const body = root.get('body');
-        const lastViolation = constantViolations[constantViolations.length - 1] ??
-            body[body.length - 1];
-        const pathInRoot = root
-            .get('body')
-            .find((n) => lastViolation.isDescendant(n));
-        const [pushed] = pathInRoot.insertAfter(assigmentToExport);
-        const local = pushed.get('expression.right');
-        (0, scopeHelpers_1.reference)(local);
-        rearranged[name] = local;
-    });
-    return rearranged;
-}
-const getPropertyAssignmentStatement = (ref, bindingName) => {
-    const assignment = ref.findParent((parent) => parent.isAssignmentExpression());
-    if (!assignment?.isAssignmentExpression())
-        return null;
-    const left = assignment.get('left');
-    if (!left.isMemberExpression())
-        return null;
-    const object = left.get('object');
-    if (!object.isIdentifier({ name: bindingName }))
-        return null;
-    const statement = assignment.parentPath;
-    return statement?.isExpressionStatement() ? statement : null;
-};
-const isWithinAliveExport = (ref, aliveExports) => [...aliveExports].some((alive) => alive === ref || alive.isAncestor(ref));
-function getExportPathsForVariableDeclaration(declaration, exports) {
-    const exportPaths = [];
-    declaration.get('declarations').forEach((declarator) => {
-        Object.keys(declarator.getOuterBindingIdentifiers()).forEach((name) => {
-            const exportPath = exports[name];
-            if (exportPath && !exportPaths.includes(exportPath)) {
-                exportPaths.push(exportPath);
-            }
-        });
-    });
-    return exportPaths;
-}
-function getDeclaratorExportLiveness(declarator, exports, aliveExports) {
-    const bindingNames = Object.keys(declarator.getOuterBindingIdentifiers());
-    if (bindingNames.length === 0) {
-        return null;
-    }
-    let liveness = null;
-    for (const name of bindingNames) {
-        const exportPath = exports[name];
-        if (!exportPath) {
-            return null;
-        }
-        const isAlive = aliveExports.has(exportPath);
-        if (liveness === null) {
-            liveness = isAlive;
-        }
-        else if (liveness !== isAlive) {
-            return null;
-        }
-    }
-    return liveness;
-}
-function hasRuntimeReferencesToEnum(path) {
-    if (!path.isTSEnumDeclaration()) {
-        return false;
-    }
-    const enumId = path.get('id');
-    const bindingName = enumId.node.name;
-    const program = path.scope.getProgramParent().path;
-    let hasReference = false;
-    program.traverse({
-        Identifier(identifier) {
-            if (hasReference || identifier.node.name !== bindingName) {
-                return;
-            }
-            if (identifier.findParent((ancestor) => ancestor === path)) {
-                return;
-            }
-            if (identifier.find((ancestor) => ancestor.isTSType() || ancestor.isFlowType())) {
-                return;
-            }
-            if (!identifier.isReferencedIdentifier()) {
-                return;
-            }
-            const localBinding = identifier.scope.getBinding(bindingName);
-            if (localBinding && localBinding.path !== enumId) {
-                return;
-            }
-            hasReference = true;
-            identifier.stop();
-        },
-    });
-    return hasReference;
-}
-function stripExportKeepDeclaration(path, exports, aliveExports, t) {
-    const exportDeclaration = path.findParent((p) => p.isExportNamedDeclaration());
-    if (!exportDeclaration)
-        return null;
-    const declaration = exportDeclaration.get('declaration');
-    if (!declaration.node)
-        return null;
-    if (declaration.isFunctionDeclaration() ||
-        declaration.isClassDeclaration() ||
-        declaration.isTSEnumDeclaration()) {
-        exportDeclaration.replaceWith(t.cloneNode(declaration.node, true));
-        return [path];
-    }
-    if (declaration.isVariableDeclaration()) {
-        const declarators = declaration.get('declarations');
-        const staleExportPaths = getExportPathsForVariableDeclaration(declaration, exports);
-        if (declarators.length === 1) {
-            exportDeclaration.replaceWith(t.cloneNode(declaration.node, true));
-            return staleExportPaths.length > 0 ? staleExportPaths : [path];
-        }
-        const segments = [];
-        for (const declarator of declarators) {
-            const isAlive = getDeclaratorExportLiveness(declarator, exports, aliveExports);
-            if (isAlive === null) {
-                return null;
-            }
-            const clonedDeclarator = t.cloneNode(declarator.node, true);
-            const currentSegment = segments[segments.length - 1];
-            if (currentSegment && currentSegment.alive === isAlive) {
-                currentSegment.declarators.push(clonedDeclarator);
-            }
-            else {
-                segments.push({
-                    alive: isAlive,
-                    declarators: [clonedDeclarator],
-                });
-            }
-        }
-        exportDeclaration.replaceWithMultiple(segments.map(({ alive, declarators: groupedDeclarators }) => {
-            const groupedDeclaration = t.variableDeclaration(declaration.node.kind, groupedDeclarators);
-            return alive
-                ? t.exportNamedDeclaration(groupedDeclaration, [])
-                : groupedDeclaration;
-        }));
-        return staleExportPaths.length > 0 ? staleExportPaths : [path];
-    }
-    return null;
-}
-function shakerPlugin(babel, { keepSideEffects = false, ifUnknownExport = 'skip-shaking', importOverrides, onlyExports, root, }) {
-    const shakerLogger = shared_1.logger.extend('shaker');
-    return {
-        name: '@wyw-in-js/transform/shaker',
-        pre(file) {
-            this.filename = file.opts.filename;
-            const log = shakerLogger.extend((0, getFileIdx_1.getFileIdx)(this.filename));
-            log('start', `${this.filename}, onlyExports: ${onlyExports.join(',')}`);
-            const onlyExportsSet = new Set(onlyExports);
-            const shouldKeepOverride = (override) => !!override && ('mock' in override || 'noShake' in override);
-            const hasImportOverride = (() => {
-                if (!importOverrides || Object.keys(importOverrides).length === 0) {
-                    return () => false;
-                }
-                const cache = new Map();
-                return (source) => {
-                    const cached = cache.get(source);
-                    if (cached !== undefined) {
-                        return cached;
-                    }
-                    const strippedSource = (0, parseRequest_1.stripQueryAndHash)(source);
-                    const direct = (0, importOverrides_1.getImportOverride)(importOverrides, source) ??
-                        (strippedSource !== source
-                            ? (0, importOverrides_1.getImportOverride)(importOverrides, strippedSource)
-                            : null);
-                    if (direct) {
-                        const result = shouldKeepOverride(direct);
-                        cache.set(source, result);
-                        return result;
-                    }
-                    const isFileImport = strippedSource.startsWith('.') ||
-                        path_1.default.isAbsolute(strippedSource);
-                    if (!isFileImport) {
-                        cache.set(source, false);
-                        return false;
-                    }
-                    try {
-                        const resolved = (0, shared_1.syncResolve)(strippedSource, this.filename, []);
-                        const { key } = (0, importOverrides_1.toImportKey)({
-                            source: strippedSource,
-                            resolved,
-                            root,
-                        });
-                        const override = (0, importOverrides_1.getImportOverride)(importOverrides, key);
-                        const result = shouldKeepOverride(override);
-                        cache.set(source, result);
-                        return result;
-                    }
-                    catch {
-                        cache.set(source, false);
-                        return false;
-                    }
-                };
-            })();
-            const collected = (0, collectExportsAndImports_1.collectExportsAndImports)(file.path);
-            const { imports } = collected;
-            const sideEffectImports = imports.filter(collectExportsAndImports_1.sideEffectImport);
-            log('import-and-exports', [
-                `imports: ${imports.length} (side-effects: ${sideEffectImports.length})`,
-                `exports: ${Object.values(collected.exports).length}`,
-                `reexports: ${collected.reexports.length}`,
-            ].join(', '));
-            // We cannot just throw out exports if they are referred in the code
-            // Let's dome some replacements
-            const exports = rearrangeExports(babel, file.path, collected.exportRefs, collected.exports);
-            Object.values(exports).forEach((local) => {
-                if (local.isAssignmentExpression()) {
-                    const left = local.get('left');
-                    if (left.isIdentifier()) {
-                        // For some reason babel does not mark id in AssignmentExpression as a reference
-                        // So we need to do it manually
-                        (0, scopeHelpers_1.reference)(left, left, true);
-                    }
-                }
-            });
-            const hasWywPreval = exports.__wywPreval !== undefined;
-            const hasDefault = exports.default !== undefined;
-            // If __wywPreval is not exported, we can remove it from onlyExports
-            if (onlyExportsSet.has('__wywPreval') && !hasWywPreval) {
-                onlyExportsSet.delete('__wywPreval');
-            }
-            if (onlyExportsSet.size === 0) {
-                // Fast-lane: if there are no exports to keep, we can just shake out the whole file
-                this.imports = [];
-                this.exports = {};
-                this.reexports = [];
-                this.deadExports = Object.keys(exports);
-                file.path.get('body').forEach((p) => {
-                    p.remove();
-                });
-                return;
-            }
-            const importedAsSideEffect = onlyExportsSet.has('side-effect');
-            onlyExportsSet.delete('side-effect');
-            // Hackaround for packages which include a 'default' export without specifying __esModule; such packages cannot be
-            // shaken as they will break interopRequireDefault babel helper
-            // See example in shaker-plugin.test.ts
-            // Real-world example was found in preact/compat npm package
-            if (onlyExportsSet.has('default') &&
-                hasDefault &&
-                !collected.isEsModule) {
-                this.imports = imports;
-                this.exports = exports;
-                this.reexports = collected.reexports;
-                this.deadExports = [];
-                return;
-            }
-            if (!onlyExportsSet.has('*')) {
-                // __esModule should be kept alive
-                onlyExportsSet.add('__esModule');
-                const aliveExports = new Set();
-                const importNames = imports.map(({ imported }) => imported);
-                Object.entries(exports).forEach(([exported, local]) => {
-                    if (onlyExportsSet.has(exported)) {
-                        aliveExports.add(local);
-                        return;
-                    }
-                    const binding = local.isIdentifier() && local.scope.getBinding(local.node.name);
-                    if (binding &&
-                        (binding.path.isImportSpecifier() ||
-                            binding.path.isImportDefaultSpecifier() ||
-                            binding.path.isImportNamespaceSpecifier()) &&
-                        importNames.includes(local.node.name || '')) {
-                        aliveExports.add(local);
-                        return;
-                    }
-                    if ([...aliveExports].some((alive) => alive === local)) {
-                        // It's possible to export multiple values from a single variable initializer, e.g
-                        // export const { foo, bar } = baz();
-                        // We need to treat all of them as used if any of them are used, since otherwise
-                        // we'll attempt to delete the baz() call
-                        aliveExports.add(local);
-                    }
-                });
-                collected.reexports.forEach((exp) => {
-                    if (onlyExportsSet.has(exp.exported)) {
-                        aliveExports.add(exp.local);
-                    }
-                });
-                const exportToPath = new Map();
-                Object.entries(exports).forEach(([exported, local]) => {
-                    exportToPath.set(exported, local);
-                });
-                collected.reexports.forEach((exp) => {
-                    exportToPath.set(exp.exported, exp.local);
-                });
-                const notFoundExports = [...onlyExportsSet].filter((exp) => exp !== '__esModule' && !aliveExports.has(exportToPath.get(exp)));
-                exportToPath.clear();
-                const isAllExportsFound = notFoundExports.length === 0;
-                if (!isAllExportsFound && ifUnknownExport !== 'ignore') {
-                    if (ifUnknownExport === 'error') {
-                        throw new Error(`Unknown export(s) requested: ${onlyExports.join(',')}`);
-                    }
-                    if (ifUnknownExport === 'reexport-all') {
-                        // If there are unknown exports, we have keep alive all re-exports.
-                        if (exports['*'] !== undefined) {
-                            aliveExports.add(exports['*']);
-                        }
-                        collected.reexports.forEach((exp) => {
-                            if (exp.exported === '*') {
-                                aliveExports.add(exp.local);
-                            }
-                        });
-                    }
-                    if (ifUnknownExport === 'skip-shaking') {
-                        this.imports = imports;
-                        this.exports = exports;
-                        this.reexports = collected.reexports;
-                        this.deadExports = [];
-                        return;
-                    }
-                }
-                const forDeleting = [
-                    ...Object.values(exports),
-                    ...collected.reexports.map((i) => i.local),
-                ].filter((exp) => !aliveExports.has(exp));
-                const forDeletingSet = new Set(forDeleting);
-                const queueForDeleting = (path) => {
-                    if ((0, isRemoved_1.isRemoved)(path) || forDeletingSet.has(path)) {
-                        return false;
-                    }
-                    forDeletingSet.add(path);
-                    forDeleting.push(path);
-                    return true;
-                };
-                if (!keepSideEffects && !importedAsSideEffect) {
-                    // Drop side-effect imports for eval-only builds unless they were explicitly requested.
-                    // This prevents evaluating unrelated runtime code (e.g. Radix) during __wywPreval eval.
-                    sideEffectImports.forEach((i) => {
-                        if (hasImportOverride(i.source)) {
-                            return;
-                        }
-                        queueForDeleting(i.local);
-                    });
-                }
-                const deleted = new Set();
-                let dereferenced = [];
-                let changed = true;
-                while (changed) {
-                    changed = false;
-                    // eslint-disable-next-line no-restricted-syntax
-                    for (const path of forDeleting) {
-                        if (deleted.has(path)) {
-                            // eslint-disable-next-line no-continue
-                            continue;
-                        }
-                        const binding = getBindingForExport(path);
-                        const action = (0, scopeHelpers_1.findActionForNode)(path);
-                        const parent = action?.[1];
-                        const outerReferences = (binding?.referencePaths || []).filter((ref) => {
-                            if (ref === parent || parent?.isAncestor(ref)) {
-                                return false;
-                            }
-                            return !forDeleting.some((candidate) => candidate !== path &&
-                                !(0, isRemoved_1.isRemoved)(candidate) &&
-                                (candidate === ref || candidate.isAncestor(ref)));
-                        });
-                        const bindingName = binding?.identifier.name;
-                        const removableAssignmentStatements = new Set();
-                        const removableOuterReferences = outerReferences.filter((ref) => {
-                            if (!bindingName)
-                                return false;
-                            const statement = getPropertyAssignmentStatement(ref, bindingName);
-                            if (!statement || isWithinAliveExport(statement, aliveExports)) {
-                                return false;
-                            }
-                            removableAssignmentStatements.add(statement);
-                            return true;
-                        });
-                        const blockingReferences = outerReferences.filter((ref) => !removableOuterReferences.includes(ref));
-                        if (blockingReferences.length > 0 && path.isIdentifier()) {
-                            // Temporary deref it in order to simplify further checks.
-                            (0, scopeHelpers_1.dereference)(path);
-                            dereferenced.push(path);
-                        }
-                        const strippedEnum = !deleted.has(path) && hasRuntimeReferencesToEnum(path)
-                            ? stripExportKeepDeclaration(path, exports, aliveExports, babel.types)
-                            : null;
-                        if (strippedEnum) {
-                            strippedEnum.forEach((stalePath) => {
-                                deleted.add(stalePath);
-                            });
-                            changed = true;
-                            // eslint-disable-next-line no-continue
-                            continue;
-                        }
-                        const strippedWithBlocking = !deleted.has(path) && binding && blockingReferences.length > 0
-                            ? stripExportKeepDeclaration(path, exports, aliveExports, babel.types)
-                            : null;
-                        if (strippedWithBlocking) {
-                            strippedWithBlocking.forEach((stalePath) => {
-                                deleted.add(stalePath);
-                            });
-                            changed = true;
-                            // eslint-disable-next-line no-continue
-                            continue;
-                        }
-                        if (!deleted.has(path) &&
-                            (!binding || blockingReferences.length === 0)) {
-                            // For variable declaration exports, `path` is the init expression
-                            // (not the Identifier). Other forDeleting candidates whose init
-                            // expressions are ancestors of references to this binding can
-                            // incorrectly filter them out of outerReferences. Those candidates
-                            // may later survive via stripExportKeepDeclaration, leaving a
-                            // dangling reference. Strip the export keyword but keep the
-                            // declaration so the unreferenced sweep removes it only when dead.
-                            // This only applies to expression paths (variable init), not
-                            // Identifiers (function/class declarations) which can't be
-                            // ancestors of external references.
-                            const strippedWithoutBlocking = binding && !path.isIdentifier()
-                                ? stripExportKeepDeclaration(path, exports, aliveExports, babel.types)
-                                : null;
-                            if (strippedWithoutBlocking) {
-                                strippedWithoutBlocking.forEach((stalePath) => {
-                                    deleted.add(stalePath);
-                                });
-                                if (removableAssignmentStatements.size > 0) {
-                                    for (const statement of removableAssignmentStatements) {
-                                        if (queueForDeleting(statement)) {
-                                            changed = true;
-                                        }
-                                    }
-                                }
-                                changed = true;
-                                // eslint-disable-next-line no-continue
-                                continue;
-                            }
-                            if (removableAssignmentStatements.size > 0) {
-                                for (const statement of removableAssignmentStatements) {
-                                    if (queueForDeleting(statement)) {
-                                        changed = true;
-                                    }
-                                }
-                            }
-                            if (action) {
-                                (0, scopeHelpers_1.applyAction)(action);
-                            }
-                            else {
-                                (0, scopeHelpers_1.removeWithRelated)([path]);
-                            }
-                            deleted.add(path);
-                            changed = true;
-                        }
-                    }
-                    dereferenced.forEach((path) => {
-                        // If path is still alive, we need to reference it back
-                        if (!(0, isRemoved_1.isRemoved)(path)) {
-                            (0, scopeHelpers_1.reference)(path);
-                        }
-                    });
-                    dereferenced = [];
-                    // stripExportKeepDeclaration replaces ExportNamedDeclaration with
-                    // its declaration, creating new AST nodes. The old scope bindings
-                    // become stale (pointing at disconnected paths). Recrawl so
-                    // getAllBindings() returns fresh bindings with correct .referenced.
-                    file.scope.crawl();
-                    // Find and mark for deleting all unreferenced variables
-                    const unreferenced = Object.values(file.scope.getAllBindings()).filter((i) => !i.referenced);
-                    for (const binding of unreferenced) {
-                        if (binding.path.isVariableDeclarator()) {
-                            const id = binding.path.get('id');
-                            // Skip destructured patterns — removing the declarator would kill
-                            // sibling bindings that may still be referenced (e.g. export {B}
-                            // from `const [A, B] = createContext(...)` when only A is dead).
-                            if (!id.isArrayPattern() &&
-                                !id.isObjectPattern() &&
-                                !(0, isRemoved_1.isRemoved)(id) &&
-                                !forDeletingSet.has(id)) {
-                                // Drop dead variable declarations, e.g. `const foo = make();` when `foo` is no longer referenced.
-                                for (const violation of binding.constantViolations) {
-                                    if (queueForDeleting(violation)) {
-                                        changed = true;
-                                    }
-                                }
-                                if (queueForDeleting(id)) {
-                                    changed = true;
-                                }
-                            }
-                        }
-                        // Drop import specifiers whose bindings lost all references during shaking
-                        // (e.g. when we keep only __wywPreval and the rest of the module is removed).
-                        if ((binding.path.isImportSpecifier() ||
-                            binding.path.isImportDefaultSpecifier() ||
-                            binding.path.isImportNamespaceSpecifier()) &&
-                            !(0, isRemoved_1.isRemoved)(binding.path) &&
-                            !forDeletingSet.has(binding.path)) {
-                            if (queueForDeleting(binding.path)) {
-                                changed = true;
-                            }
-                        }
-                    }
-                }
-            }
-            this.imports = withoutRemoved(imports);
-            this.exports = {};
-            this.deadExports = [];
-            Object.entries(exports).forEach(([exported, local]) => {
-                if ((0, isRemoved_1.isRemoved)(local)) {
-                    this.deadExports.push(exported);
-                }
-                else {
-                    this.exports[exported] = local;
-                }
-            });
-            this.reexports = withoutRemoved(collected.reexports);
-        },
-        visitor: {},
-        post(file) {
-            const log = shakerLogger.extend((0, getFileIdx_1.getFileIdx)(file.opts.filename));
-            const dynamicImportWarningsEnabled = Boolean(process.env.WYW_WARN_DYNAMIC_IMPORTS) &&
-                process.env.WYW_WARN_DYNAMIC_IMPORTS !== '0' &&
-                process.env.WYW_WARN_DYNAMIC_IMPORTS !== 'false';
-            const filename = file.opts.filename;
-            if (dynamicImportWarningsEnabled &&
-                !warnedDynamicImportFiles.has(filename)) {
-                const dynamicImports = this.imports.filter((imp) => !(0, collectExportsAndImports_1.sideEffectImport)(imp) && imp.type === 'dynamic');
-                if (dynamicImports.length > 0) {
-                    const sources = Array.from(new Set(dynamicImports.map((imp) => imp.source))).sort();
-                    const sourcesToWarn = (() => {
-                        if (!importOverrides || Object.keys(importOverrides).length === 0) {
-                            return sources;
-                        }
-                        const shouldWarn = (source) => {
-                            const strippedSource = (0, parseRequest_1.stripQueryAndHash)(source);
-                            const direct = (0, importOverrides_1.getImportOverride)(importOverrides, source) ??
-                                (strippedSource !== source
-                                    ? (0, importOverrides_1.getImportOverride)(importOverrides, strippedSource)
-                                    : undefined);
-                            if (direct !== undefined) {
-                                return false;
-                            }
-                            const isFileImport = strippedSource.startsWith('.') ||
-                                path_1.default.isAbsolute(strippedSource);
-                            if (!isFileImport) {
-                                return true;
-                            }
-                            try {
-                                const resolved = (0, shared_1.syncResolve)(strippedSource, filename, []);
-                                const importKey = (0, importOverrides_1.toImportKey)({
-                                    source: strippedSource,
-                                    resolved,
-                                    root,
-                                }).key;
-                                return ((0, importOverrides_1.getImportOverride)(importOverrides, importKey) === undefined);
-                            }
-                            catch {
-                                return true;
-                            }
-                        };
-                        return sources.filter(shouldWarn);
-                    })();
-                    if (sourcesToWarn.length > 0) {
-                        warnedDynamicImportFiles.add(filename);
-                        const overrideKeys = sourcesToWarn
-                            .map((source) => {
-                            const strippedSource = (0, parseRequest_1.stripQueryAndHash)(source);
-                            const isFileImport = strippedSource.startsWith('.') ||
-                                path_1.default.isAbsolute(strippedSource);
-                            if (!isFileImport) {
-                                return { source, key: source };
-                            }
-                            try {
-                                const resolved = (0, shared_1.syncResolve)(strippedSource, filename, []);
-                                return {
-                                    source,
-                                    key: (0, importOverrides_1.toImportKey)({
-                                        source: strippedSource,
-                                        resolved,
-                                        root,
-                                    }).key,
-                                };
-                            }
-                            catch {
-                                return { source, key: strippedSource };
-                            }
-                        })
-                            .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 processedImports = new Set();
-            const imports = new Map();
-            const addImport = ({ imported, source, }) => {
-                if (processedImports.has(`${source}:${imported}`)) {
-                    return;
-                }
-                if (!imports.has(source)) {
-                    imports.set(source, []);
-                }
-                if (imported) {
-                    imports.get(source).push(imported);
-                }
-                processedImports.add(`${source}:${imported}`);
-            };
-            this.imports.forEach(addImport);
-            this.reexports.forEach(addImport);
-            log('end', `remaining imports: %O`, imports);
-            // eslint-disable-next-line no-param-reassign
-            file.metadata.wywEvaluator = {
-                imports,
-            };
-            (0, traversalCache_1.invalidateTraversalCache)(file.path);
-        },
-    };
-}