@wyw-in-js/transform 0.1.0

package/types/options/buildOptions.js

@@ -0,0 +1,35 @@
+"use strict";
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="./babel-merge.d.ts" />
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOptions = void 0;
+const babel_merge_1 = __importDefault(require("babel-merge"));
+const isNotNull_1 = require("../utils/isNotNull");
+const cache = new WeakMap();
+const merge = (a, b) => {
+    if (!cache.has(a)) {
+        cache.set(a, new WeakMap());
+    }
+    const cacheForA = cache.get(a);
+    if (cacheForA.has(b)) {
+        return cacheForA.get(b);
+    }
+    const result = (0, babel_merge_1.default)(a, b);
+    cacheForA.set(b, result);
+    return result;
+};
+/**
+ * Merges babel configs together. If a pair of configs were merged before,
+ * it will return the cached result.
+ */
+function buildOptions(...configs) {
+    // Merge all configs together
+    return configs
+        .map((i) => i ?? null)
+        .filter(isNotNull_1.isNotNull)
+        .reduce(merge);
+}
+exports.buildOptions = buildOptions;

package/types/options/loadBabelOptions.d.ts

@@ -0,0 +1,3 @@
+import type { TransformOptions } from '@babel/core';
+import type { Core } from '../babel';
+export declare function loadBabelOptions(babel: Core, filename: string, overrides?: TransformOptions): TransformOptions;

package/types/options/loadBabelOptions.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBabelOptions = void 0;
+const cache = new WeakMap();
+const empty = {};
+function loadBabelOptions(babel, filename, overrides = empty) {
+    const fileCache = cache.get(overrides) ?? new Map();
+    if (fileCache.has(filename)) {
+        return fileCache.get(filename);
+    }
+    const babelOptions = babel.loadOptions({
+        ...overrides,
+        filename,
+        caller: {
+            name: 'linaria',
+            // Indicates for @babel/preset-env to support all ESM syntax and avoid transforms before it's needed
+            supportsStaticESM: true,
+            supportsDynamicImport: true,
+            supportsTopLevelAwait: true,
+            supportsExportNamespaceFrom: true,
+        },
+    }) ?? {};
+    fileCache.set(filename, babelOptions);
+    cache.set(overrides, fileCache);
+    return babelOptions;
+}
+exports.loadBabelOptions = loadBabelOptions;

package/types/plugins/babel-transform.d.ts

@@ -0,0 +1,4 @@
+import type { PluginObj } from '@babel/core';
+import type { Core } from '../babel';
+import type { IPluginState, PluginOptions } from '../types';
+export default function babelTransform(babel: Core, options: Partial<PluginOptions>): PluginObj<IPluginState>;

package/types/plugins/babel-transform.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_1 = require("@wyw-in-js/shared");
+const cache_1 = require("../cache");
+const transform_1 = require("../transform");
+const loadLinariaOptions_1 = require("../transform/helpers/loadLinariaOptions");
+const collector_1 = require("./collector");
+function babelTransform(babel, options) {
+    const cache = new cache_1.TransformCacheCollection();
+    const debug = shared_1.logger.extend('babel-transform');
+    return {
+        name: '@wyw-in-js/transform/babel-transform',
+        pre(file) {
+            // eslint-disable-next-line require-yield
+            function* collect() {
+                const { valueCache } = this.data;
+                const { loadedAndParsed } = this.entrypoint;
+                const { pluginOptions } = this.services.options;
+                if (loadedAndParsed.evaluator === 'ignored') {
+                    throw new Error('entrypoint was ignored');
+                }
+                (0, collector_1.collector)(file, pluginOptions, valueCache);
+                return {
+                    ast: loadedAndParsed.ast,
+                    code: loadedAndParsed.code,
+                };
+            }
+            debug('start %s', file.opts.filename);
+            const pluginOptions = (0, loadLinariaOptions_1.loadLinariaOptions)(options);
+            (0, transform_1.transformSync)({
+                babel,
+                cache,
+                options: {
+                    filename: file.opts.filename,
+                    root: file.opts.root ?? undefined,
+                    inputSourceMap: file.opts.inputSourceMap ?? undefined,
+                    pluginOptions,
+                },
+            }, file.code, shared_1.syncResolve, {
+                collect,
+            });
+        },
+        visitor: {},
+        post(file) {
+            debug('end %s', file.opts.filename);
+        },
+    };
+}
+exports.default = babelTransform;

package/types/plugins/collector.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Collector traverses the AST and collects information about imports and
+ * all usages of WYW-processors.
+ */
+import type { BabelFile, PluginObj } from '@babel/core';
+import type { ValueCache } from '@wyw-in-js/processor-utils';
+import type { StrictOptions } from '@wyw-in-js/shared';
+import type { Core } from '../babel';
+import type { IPluginState } from '../types';
+export declare const filename: string;
+export declare function collector(file: BabelFile, options: Pick<StrictOptions, 'classNameSlug' | 'displayName' | 'evaluate' | 'tagResolver'>, values: ValueCache): {
+    artifacts: import("@wyw-in-js/shared").Artifact[];
+}[];
+export default function collectorPlugin(babel: Core, options: StrictOptions & {
+    values?: ValueCache;
+}): PluginObj<IPluginState>;

package/types/plugins/collector.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Collector traverses the AST and collects information about imports and
+ * all usages of WYW-processors.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collector = exports.filename = void 0;
+const shared_1 = require("@wyw-in-js/shared");
+const processTemplateExpression_1 = require("../utils/processTemplateExpression");
+const scopeHelpers_1 = require("../utils/scopeHelpers");
+const traversalCache_1 = require("../utils/traversalCache");
+exports.filename = __filename;
+function collector(file, options, values) {
+    const processors = [];
+    const identifiers = [];
+    file.path.traverse({
+        Identifier: (p) => {
+            identifiers.push(p);
+        },
+    });
+    // TODO: process transformed literals
+    identifiers.forEach((p) => {
+        (0, processTemplateExpression_1.processTemplateExpression)(p, file.opts, options, (processor) => {
+            processor.build(values);
+            processor.doRuntimeReplacement();
+            processors.push(processor);
+        });
+    });
+    if (processors.length === 0) {
+        // We didn't find any processors.
+        return processors;
+    }
+    // We can remove __linariaPreval export and all related code
+    const prevalExport = file.path.scope.getData('__linariaPreval')?.findParent((p) => p.isExpressionStatement());
+    if (prevalExport) {
+        (0, scopeHelpers_1.removeWithRelated)([prevalExport]);
+    }
+    return processors;
+}
+exports.collector = collector;
+function collectorPlugin(babel, options) {
+    const values = options.values ?? new Map();
+    const debug = shared_1.logger.extend('collector');
+    return {
+        name: '@wyw-in-js/transform/collector',
+        pre(file) {
+            debug('start %s', file.opts.filename);
+            const processors = collector(file, options, values);
+            if (processors.length === 0) {
+                // We didn't find any Linaria template literals.
+                return;
+            }
+            this.file.metadata.linaria = {
+                processors,
+                replacements: [],
+                rules: {},
+                dependencies: [],
+            };
+            debug('end %s', file.opts.filename);
+        },
+        visitor: {},
+        post(file) {
+            (0, traversalCache_1.invalidateTraversalCache)(file.path);
+        },
+    };
+}
+exports.default = collectorPlugin;

package/types/plugins/dynamic-import.d.ts

@@ -0,0 +1,6 @@
+import type { PluginObj } from '@babel/core';
+import type { Core } from '../babel';
+/**
+ * The plugin that replaces `import()` with `__wyw_dynamic_import` as Node VM does not support dynamic imports yet.
+ */
+export default function dynamicImport(babel: Core): PluginObj;

package/types/plugins/dynamic-import.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * The plugin that replaces `import()` with `__wyw_dynamic_import` as Node VM does not support dynamic imports yet.
+ */
+function dynamicImport(babel) {
+    const { types: t } = babel;
+    return {
+        name: '@wyw-in-js/transform/dynamic-import',
+        visitor: {
+            CallExpression(path) {
+                if (path.get('callee').isImport()) {
+                    const moduleName = path.get('arguments.0');
+                    if (moduleName.isStringLiteral()) {
+                        path.replaceWith(t.callExpression(t.identifier('__wyw_dynamic_import'), [
+                            t.stringLiteral(moduleName.node.value),
+                        ]));
+                        return;
+                    }
+                    if (moduleName.isTemplateLiteral()) {
+                        path.replaceWith(t.callExpression(t.identifier('__wyw_dynamic_import'), [
+                            t.cloneNode(moduleName.node, true, true),
+                        ]));
+                        return;
+                    }
+                    throw new Error('Dynamic import argument must be a string or a template literal');
+                }
+            },
+        },
+    };
+}
+exports.default = dynamicImport;

package/types/plugins/preeval.d.ts

@@ -0,0 +1,16 @@
+/**
+ * This file is a babel preset used to transform files inside evaluators.
+ * It works the same as main `babel/extract` preset, but do not evaluate lazy dependencies.
+ */
+import type { PluginObj } from '@babel/core';
+import type { StrictOptions } from '@wyw-in-js/shared';
+import type { Core } from '../babel';
+import type { IPluginState } from '../types';
+import { EventEmitter } from '../utils/EventEmitter';
+export type PreevalOptions = Pick<StrictOptions, 'classNameSlug' | 'displayName' | 'evaluate' | 'features'> & {
+    eventEmitter: EventEmitter;
+};
+export declare function preeval(babel: Core, { eventEmitter, ...options }: PreevalOptions): PluginObj<IPluginState & {
+    onFinish: () => void;
+}>;
+export default preeval;

package/types/plugins/preeval.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preeval = void 0;
+const shared_1 = require("@wyw-in-js/shared");
+const EventEmitter_1 = require("../utils/EventEmitter");
+const addIdentifierToLinariaPreval_1 = require("../utils/addIdentifierToLinariaPreval");
+const getFileIdx_1 = require("../utils/getFileIdx");
+const processTemplateExpression_1 = require("../utils/processTemplateExpression");
+const removeDangerousCode_1 = require("../utils/removeDangerousCode");
+const traversalCache_1 = require("../utils/traversalCache");
+function preeval(babel, { eventEmitter = EventEmitter_1.EventEmitter.dummy, ...options }) {
+    const { types: t } = babel;
+    return {
+        name: '@wyw-in-js/transform/preeval',
+        pre(file) {
+            const filename = file.opts.filename;
+            const log = shared_1.logger.extend('preeval').extend((0, getFileIdx_1.getFileIdx)(filename));
+            log('start', 'Looking for template literals…');
+            const rootScope = file.scope;
+            this.processors = [];
+            eventEmitter.perf('transform:preeval:processTemplate', () => {
+                file.path.traverse({
+                    Identifier: (p) => {
+                        (0, processTemplateExpression_1.processTemplateExpression)(p, file.opts, options, (processor) => {
+                            processor.dependencies.forEach((dependency) => {
+                                if (dependency.ex.type === 'Identifier') {
+                                    (0, addIdentifierToLinariaPreval_1.addIdentifierToLinariaPreval)(rootScope, dependency.ex.name);
+                                }
+                            });
+                            processor.doEvaltimeReplacement();
+                            this.processors.push(processor);
+                        });
+                    },
+                });
+            });
+            if ((0, shared_1.isFeatureEnabled)(options.features, 'dangerousCodeRemover', filename)) {
+                log('start', 'Strip all JSX and browser related stuff');
+                eventEmitter.perf('transform:preeval:removeDangerousCode', () => (0, removeDangerousCode_1.removeDangerousCode)(file.path));
+            }
+        },
+        visitor: {},
+        post(file) {
+            const log = shared_1.logger
+                .extend('preeval')
+                .extend((0, getFileIdx_1.getFileIdx)(file.opts.filename));
+            (0, traversalCache_1.invalidateTraversalCache)(file.path);
+            if (this.processors.length === 0) {
+                log('end', "We didn't find any Linaria template literals");
+                // We didn't find any Linaria template literals.
+                return;
+            }
+            this.file.metadata.linaria = {
+                processors: this.processors,
+                replacements: [],
+                rules: {},
+                dependencies: [],
+            };
+            const linariaPreval = file.path.getData('__linariaPreval');
+            if (!linariaPreval) {
+                // Event if there is no dependencies, we still need to add __linariaPreval
+                const linariaExport = t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier('exports'), t.identifier('__linariaPreval')), t.objectExpression([])));
+                file.path.pushContainer('body', linariaExport);
+            }
+            log('end', '__linariaPreval has been added');
+        },
+    };
+}
+exports.preeval = preeval;
+exports.default = preeval;

package/types/plugins/shaker.d.ts

@@ -0,0 +1,11 @@
+import type { PluginObj } from '@babel/core';
+import type { Core } from '../babel';
+import type { IState } from '../utils/collectExportsAndImports';
+export interface IShakerOptions {
+    ifUnknownExport?: 'error' | 'ignore' | 'reexport-all' | 'skip-shaking';
+    keepSideEffects?: boolean;
+    onlyExports: string[];
+}
+export default function shakerPlugin(babel: Core, { keepSideEffects, ifUnknownExport, onlyExports, }: IShakerOptions): PluginObj<IState & {
+    filename: string;
+}>;

package/types/plugins/shaker.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 EXT_REGEX = /\.[0-9a-z]+$/;
+const ALLOWED_EXTENSIONS = ['.js', '.cjs', '.mjs'];
+function shouldKeepSideEffect(importPath) {
+    const [ext] = importPath.match(EXT_REGEX) || [''];
+    return ext === '' || ALLOWED_EXTENSIONS.includes(ext);
+}
+function getBindingForExport(exportPath) {
+    if (exportPath.isIdentifier()) {
+        return exportPath.scope.getBinding(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 exportPath.scope.getBinding(left.node.name);
+        }
+    }
+    if (exportPath.isFunctionDeclaration() || exportPath.isClassDeclaration()) {
+        return exportPath.scope.getBinding(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);
+        // Replace every reference with defined variable
+        refs.forEach((ref) => {
+            const [replaced] = ref.replaceWith(t.identifier(uid));
+            if (replaced.isBindingIdentifier()) {
+                rootScope.registerConstantViolation(replaced);
+                if (replaced.parentPath?.parentPath?.isVariableDeclarator()) {
+                    // This is `const foo = exports.foo = "value"` case
+                    (0, scopeHelpers_1.reference)(replaced, replaced, true);
+                }
+            }
+            else {
+                (0, scopeHelpers_1.reference)(replaced);
+            }
+        });
+        // Assign defined variable to the export
+        const [pushed] = root.pushContainer('body', [
+            t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier('exports'), t.identifier(name)), t.identifier(uid))),
+        ]);
+        const local = pushed.get('expression.right');
+        (0, scopeHelpers_1.reference)(local);
+        rearranged[name] = local;
+    });
+    return rearranged;
+}
+function shakerPlugin(babel, { keepSideEffects = false, ifUnknownExport = 'skip-shaking', onlyExports, }) {
+    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 collected = (0, collectExportsAndImports_1.collectExportsAndImports)(file.path);
+            const sideEffectImports = collected.imports.filter(collectExportsAndImports_1.sideEffectImport);
+            log('import-and-exports', [
+                `imports: ${collected.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 hasLinariaPreval = exports.__linariaPreval !== undefined;
+            const hasDefault = exports.default !== undefined;
+            // If __linariaPreval is not exported, we can remove it from onlyExports
+            if (onlyExportsSet.has('__linariaPreval') && !hasLinariaPreval) {
+                onlyExportsSet.delete('__linariaPreval');
+            }
+            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 = collected.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 = collected.imports.map(({ imported }) => imported);
+                Object.entries(exports).forEach(([exported, local]) => {
+                    if (onlyExportsSet.has(exported)) {
+                        aliveExports.add(local);
+                    }
+                    else if (importNames.includes(local.node.name || '')) {
+                        aliveExports.add(local);
+                    }
+                    else 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 = collected.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));
+                if (!keepSideEffects && !importedAsSideEffect) {
+                    // Remove all imports that don't import something explicitly and should not be kept
+                    sideEffectImports.forEach((i) => {
+                        if (!shouldKeepSideEffect(i.source)) {
+                            forDeleting.push(i.local);
+                        }
+                    });
+                }
+                const deleted = new Set();
+                let dereferenced = [];
+                let changed = true;
+                while (changed && deleted.size < forDeleting.length) {
+                    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) => ref !== parent && !parent?.isAncestor(ref));
+                        if (outerReferences.length > 0 && path.isIdentifier()) {
+                            // Temporary deref it in order to simplify further checks.
+                            (0, scopeHelpers_1.dereference)(path);
+                            dereferenced.push(path);
+                        }
+                        if (!deleted.has(path) &&
+                            (!binding || outerReferences.length === 0)) {
+                            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 = [];
+                }
+            }
+            this.imports = withoutRemoved(collected.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 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.linariaEvaluator = {
+                imports,
+            };
+            (0, traversalCache_1.invalidateTraversalCache)(file.path);
+        },
+    };
+}
+exports.default = shakerPlugin;

package/types/shaker.d.ts

@@ -0,0 +1,3 @@
+import type { Evaluator } from '@wyw-in-js/shared';
+declare const shaker: Evaluator;
+export default shaker;