@wyw-in-js/transform 1.0.6 → 1.0.8

package/types/transform/actions/BaseAction.d.ts

@@ -13,13 +13,14 @@ export declare class BaseAction<TAction extends ActionQueueItem> implements GetB
     readonly entrypoint: Entrypoint;
     readonly data: TAction['data'];
     readonly abortSignal: AbortSignal | null;
+    readonly actionContext: unknown;
     readonly idx: string;
     result: TypeOfResult<TAction> | typeof Pending;
     private activeScenario;
     private activeScenarioError?;
     private activeScenarioNextResults;
     private handler;
-    constructor(type: TAction['type'], services: Services, entrypoint: Entrypoint, data: TAction['data'], abortSignal: AbortSignal | null);
+    constructor(type: TAction['type'], services: Services, entrypoint: Entrypoint, data: TAction['data'], abortSignal: AbortSignal | null, actionContext: unknown);
     get log(): Debugger;
     get ref(): string;
     createAbortSignal(): AbortSignal & Disposable;

package/types/transform/actions/BaseAction.js

@@ -11,18 +11,20 @@ class BaseAction {
     entrypoint;
     data;
     abortSignal;
+    actionContext;
     idx;
     result = types_1.Pending;
     activeScenario = null;
     activeScenarioError;
     activeScenarioNextResults = [];
     handler = null;
-    constructor(type, services, entrypoint, data, abortSignal) {
+    constructor(type, services, entrypoint, data, abortSignal, actionContext) {
         this.type = type;
         this.services = services;
         this.entrypoint = entrypoint;
         this.data = data;
         this.abortSignal = abortSignal;
+        this.actionContext = actionContext;
         actionIdx += 1;
         this.idx = actionIdx.toString(16).padStart(6, '0');
     }

package/types/transform/actions/actionRunner.js

@@ -36,7 +36,7 @@ async function asyncActionRunner(action, actionHandlers, stack = [getActionRef(a
             return result.value;
         }
         const [type, entrypoint, data, abortSignal] = result.value;
-        const nextAction = entrypoint.createAction(type, data, abortSignal);
+        const nextAction = entrypoint.createAction(type, data, abortSignal, action.actionContext);
         try {
             actionResult = await asyncActionRunner(nextAction, actionHandlers, [
                 ...stack,
@@ -70,7 +70,7 @@ function syncActionRunner(action, actionHandlers, stack = [getActionRef(action.t
             return result.value;
         }
         const [type, entrypoint, data, abortSignal] = result.value;
-        const nextAction = entrypoint.createAction(type, data, abortSignal);
+        const nextAction = entrypoint.createAction(type, data, abortSignal, action.actionContext);
         try {
             actionResult = syncActionRunner(nextAction, actionHandlers, [
                 ...stack,

package/types/transform/barrelManifest.d.ts

@@ -0,0 +1,42 @@
+import type { File } from '@babel/types';
+export type BarrelSkipReason = 'custom-evaluator' | 'empty' | 'ignored' | 'impure' | 'namespace-barrel' | 'unknown-star';
+export type BarrelBlockedReason = 'ambiguous' | 'cycle' | 'namespace-barrel' | 'unknown-star' | 'unresolved';
+export type BarrelResolvedBinding = {
+    imported: string;
+    kind: 'named';
+    source: string;
+} | {
+    kind: 'namespace';
+    source: string;
+};
+export type BarrelManifestExport = BarrelResolvedBinding | {
+    kind: 'blocked';
+    reason: BarrelBlockedReason;
+};
+export type BarrelManifest = {
+    complete: boolean;
+    exports: Record<string, BarrelManifestExport>;
+    kind: 'barrel';
+};
+export type BarrelManifestCacheEntry = BarrelManifest | {
+    kind: 'ineligible';
+    reason: BarrelSkipReason;
+};
+export type RawBarrelReexport = {
+    exported: string;
+    imported: string;
+    kind: 'named';
+    source: string;
+} | {
+    exported: string;
+    kind: 'namespace';
+    source: string;
+};
+export type RawBarrelManifest = {
+    complete: boolean;
+    explicitExports: string[];
+    exportAll: string[];
+    kind: 'barrel';
+    reexports: RawBarrelReexport[];
+};
+export declare function analyzeBarrelFile(ast: File): BarrelManifestCacheEntry | RawBarrelManifest;

package/types/transform/barrelManifest.js

@@ -0,0 +1,300 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeBarrelFile = analyzeBarrelFile;
+/* eslint-disable no-continue, @typescript-eslint/no-use-before-define */
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const types_1 = require("@babel/types");
+const isTypeOnlyImport = (statement) => {
+    if (statement.importKind === 'type') {
+        return true;
+    }
+    if (statement.specifiers.length === 0) {
+        return false;
+    }
+    return statement.specifiers.every((specifier) => specifier.type === 'ImportSpecifier' && specifier.importKind === 'type');
+};
+const isTypeOnlyExport = (statement) => statement.exportKind === 'type';
+const getModuleExportName = (node) => node.type === 'Identifier' ? node.name : node.value;
+const isTypeOnlyStatement = (statement) => {
+    switch (statement.type) {
+        case 'EmptyStatement':
+        case 'TSDeclareFunction':
+        case 'TSInterfaceDeclaration':
+        case 'TSTypeAliasDeclaration':
+            return true;
+        default:
+            return false;
+    }
+};
+function collectExportNamedDeclaration(statement, reexports, explicitExports) {
+    if (!statement.source) {
+        return isTypeOnlyExport(statement);
+    }
+    if (isTypeOnlyExport(statement)) {
+        return true;
+    }
+    const source = statement.source.value;
+    for (const specifier of statement.specifiers) {
+        if (specifier.type === 'ExportSpecifier') {
+            if (specifier.exportKind === 'type') {
+                continue;
+            }
+            explicitExports.add(getModuleExportName(specifier.exported));
+            reexports.push(getNamedReexport(specifier, source));
+            continue;
+        }
+        if (specifier.type === 'ExportDefaultSpecifier') {
+            explicitExports.add(getModuleExportName(specifier.exported));
+            reexports.push(getDefaultReexport(specifier, source));
+            continue;
+        }
+        if (specifier.type === 'ExportNamespaceSpecifier') {
+            explicitExports.add(getModuleExportName(specifier.exported));
+            reexports.push(getNamespaceReexport(specifier, source));
+            continue;
+        }
+        return false;
+    }
+    return statement.specifiers.length > 0;
+}
+function getNamedReexport(specifier, source) {
+    return {
+        exported: getModuleExportName(specifier.exported),
+        imported: getModuleExportName(specifier.local),
+        kind: 'named',
+        source,
+    };
+}
+function getDefaultReexport(specifier, source) {
+    return {
+        exported: getModuleExportName(specifier.exported),
+        imported: 'default',
+        kind: 'named',
+        source,
+    };
+}
+function getNamespaceReexport(specifier, source) {
+    return {
+        exported: getModuleExportName(specifier.exported),
+        kind: 'namespace',
+        source,
+    };
+}
+const collectImportBinding = (statement, imports) => {
+    if (statement.importKind === 'type') {
+        return true;
+    }
+    if (statement.specifiers.length === 0) {
+        return false;
+    }
+    let sawValueImport = false;
+    for (const specifier of statement.specifiers) {
+        if (specifier.type === 'ImportSpecifier' &&
+            specifier.importKind === 'type') {
+            continue;
+        }
+        sawValueImport = true;
+        if (specifier.type === 'ImportSpecifier') {
+            imports.set(specifier.local.name, {
+                imported: getImportSpecifierName(specifier),
+                kind: 'named',
+                source: statement.source.value,
+            });
+            continue;
+        }
+        if (specifier.type === 'ImportDefaultSpecifier') {
+            imports.set(specifier.local.name, {
+                imported: 'default',
+                kind: 'named',
+                source: statement.source.value,
+            });
+            continue;
+        }
+        imports.set(specifier.local.name, {
+            kind: 'namespace',
+            source: statement.source.value,
+        });
+    }
+    return sawValueImport || isTypeOnlyImport(statement);
+};
+const getImportSpecifierName = (specifier) => getModuleExportName(specifier.imported);
+const getLocalDeclarationNames = (declaration) => {
+    if (declaration.type === 'VariableDeclaration' ||
+        declaration.type === 'FunctionDeclaration' ||
+        declaration.type === 'ClassDeclaration') {
+        return Object.keys((0, types_1.getBindingIdentifiers)(declaration));
+    }
+    if (declaration.type === 'TSEnumDeclaration' ||
+        declaration.type === 'TSModuleDeclaration') {
+        return null;
+    }
+    return [];
+};
+const collectLocalExportNamedDeclaration = (statement, importedBindings, passthroughCandidates, explicitExports) => {
+    let complete = true;
+    if (isTypeOnlyExport(statement)) {
+        return {
+            complete: true,
+            ok: true,
+        };
+    }
+    if (statement.declaration) {
+        const names = getLocalDeclarationNames(statement.declaration);
+        if (names === null) {
+            return {
+                complete: false,
+                ok: false,
+            };
+        }
+        for (const name of names) {
+            explicitExports.add(name);
+        }
+        return {
+            complete: names.length === 0,
+            ok: true,
+        };
+    }
+    for (const specifier of statement.specifiers) {
+        if (specifier.type !== 'ExportSpecifier') {
+            return {
+                complete: false,
+                ok: false,
+            };
+        }
+        if (specifier.exportKind === 'type') {
+            continue;
+        }
+        const exported = getModuleExportName(specifier.exported);
+        explicitExports.add(exported);
+        if (specifier.local.type !== 'Identifier') {
+            complete = false;
+            continue;
+        }
+        if (!importedBindings.has(specifier.local.name)) {
+            complete = false;
+            continue;
+        }
+        if (!passthroughCandidates.has(specifier.local.name)) {
+            passthroughCandidates.set(specifier.local.name, []);
+        }
+        passthroughCandidates.get(specifier.local.name).push(exported);
+    }
+    return {
+        complete: complete && statement.specifiers.length > 0,
+        ok: true,
+    };
+};
+const collectPassthroughReexports = (ast, importedBindings, passthroughCandidates, reexports) => {
+    let complete = true;
+    const bindingReferenceCounts = new Map();
+    (0, traverse_1.default)(ast, {
+        Program(path) {
+            for (const localName of passthroughCandidates.keys()) {
+                bindingReferenceCounts.set(localName, path.scope.getBinding(localName)?.referencePaths.length ?? -1);
+            }
+            path.stop();
+        },
+    });
+    for (const [localName, exportedNames] of passthroughCandidates) {
+        if (bindingReferenceCounts.get(localName) !== exportedNames.length) {
+            complete = false;
+            continue;
+        }
+        const imported = importedBindings.get(localName);
+        for (const exported of exportedNames) {
+            if (imported.kind === 'namespace') {
+                reexports.push({
+                    exported,
+                    kind: 'namespace',
+                    source: imported.source,
+                });
+                continue;
+            }
+            reexports.push({
+                exported,
+                imported: imported.imported,
+                kind: 'named',
+                source: imported.source,
+            });
+        }
+    }
+    return {
+        complete,
+        ok: true,
+    };
+};
+function analyzeBarrelProgram(ast) {
+    const reexports = [];
+    const explicitExports = new Set();
+    const exportAll = [];
+    const importedBindings = new Map();
+    const passthroughCandidates = new Map();
+    let complete = true;
+    for (const statement of ast.program.body) {
+        if (statement.type === 'ImportDeclaration') {
+            if (!collectImportBinding(statement, importedBindings)) {
+                return null;
+            }
+            continue;
+        }
+        if (statement.type === 'ExportNamedDeclaration') {
+            if (statement.source) {
+                if (!collectExportNamedDeclaration(statement, reexports, explicitExports)) {
+                    return null;
+                }
+                continue;
+            }
+            const localResult = collectLocalExportNamedDeclaration(statement, importedBindings, passthroughCandidates, explicitExports);
+            if (!localResult.ok) {
+                return null;
+            }
+            complete = complete && localResult.complete;
+            continue;
+        }
+        if (statement.type === 'ExportAllDeclaration') {
+            if (statement.exportKind === 'type') {
+                continue;
+            }
+            if (!statement.source) {
+                return null;
+            }
+            exportAll.push(getExportAllSource(statement));
+            continue;
+        }
+        if (statement.type === 'ExportDefaultDeclaration') {
+            return null;
+        }
+        if (!isTypeOnlyStatement(statement)) {
+            return null;
+        }
+    }
+    const passthroughResult = collectPassthroughReexports(ast, importedBindings, passthroughCandidates, reexports);
+    if (!passthroughResult.ok) {
+        return null;
+    }
+    complete = complete && passthroughResult.complete;
+    if (reexports.length === 0 && exportAll.length === 0) {
+        return null;
+    }
+    return {
+        complete,
+        explicitExports: [...explicitExports],
+        exportAll,
+        kind: 'barrel',
+        reexports,
+    };
+}
+const getExportAllSource = (statement) => statement.source.value;
+function analyzeBarrelFile(ast) {
+    const result = analyzeBarrelProgram(ast);
+    if (!result) {
+        return {
+            kind: 'ineligible',
+            reason: 'impure',
+        };
+    }
+    return result;
+}

package/types/transform/generators/getExports.js

@@ -52,11 +52,16 @@ function* getExports() {
         const resolvedImports = yield* this.getNext('resolveImports', entrypoint, {
             imports: new Map(withWildcardReexport.map((i) => [i.source, []])),
         });
+        const dependencyFilenames = resolvedImports.flatMap((dependency) => dependency.resolved ? [dependency.resolved] : []);
         const importedEntrypoints = findExportsInImports(entrypoint, resolvedImports);
         for (const importedEntrypoint of importedEntrypoints) {
             const exports = yield* this.getNext('getExports', importedEntrypoint.entrypoint, undefined);
             result.push(...exports);
         }
+        cache.add('exports', entrypoint.name, result);
+        cache.setCacheDependencies('exports', entrypoint.name, dependencyFilenames);
+        entrypoint.log(`exports: %o`, result);
+        return result;
     }
     entrypoint.log(`exports: %o`, result);
     cache.add('exports', entrypoint.name, result);

package/types/transform/generators/processEntrypoint.js

@@ -53,7 +53,20 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processEntrypoint = processEntrypoint;
+const shaker_1 = require("../../shaker");
 const AbortError_1 = require("../actions/AbortError");
+const barrelManifest_1 = require("../barrelManifest");
+const shouldSkipExplodeReexports = (action) => {
+    const { loadedAndParsed, only } = action.entrypoint;
+    if (only.length === 1 && only[0] === '__wywPreval') {
+        return true;
+    }
+    if (loadedAndParsed.evaluator !== shaker_1.shaker || !loadedAndParsed.ast) {
+        return false;
+    }
+    const barrelAnalysis = (0, barrelManifest_1.analyzeBarrelFile)(loadedAndParsed.ast);
+    return barrelAnalysis.kind === 'barrel' && barrelAnalysis.complete;
+};
 /**
  * The first stage of processing an entrypoint.
  * This stage is responsible for:
@@ -64,14 +77,26 @@ const AbortError_1 = require("../actions/AbortError");
 function* processEntrypoint() {
     const { only, log } = this.entrypoint;
     log('start processing (only: %o)', only);
+    this.entrypoint.beginProcessing();
     try {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
             const abortSignal = __addDisposableResource(env_1, this.createAbortSignal(), false);
-            yield ['explodeReexports', this.entrypoint, undefined, abortSignal];
+            if (shouldSkipExplodeReexports(this)) {
+                log('skip explodeReexports for pure barrel');
+            }
+            else {
+                yield ['explodeReexports', this.entrypoint, undefined, abortSignal];
+            }
             const result = yield* this.getNext('transform', this.entrypoint, undefined, abortSignal);
             this.entrypoint.assertNotSuperseded();
             this.entrypoint.setTransformResult(result);
+            const supersededWith = this.entrypoint.applyDeferredSupersede();
+            if (supersededWith) {
+                log('processing finished, deferred only detected; schedule next attempt');
+                yield* this.getNext('processEntrypoint', supersededWith, undefined, null);
+                return;
+            }
             log('entrypoint processing finished');
         }
         catch (e_1) {
@@ -91,4 +116,7 @@ function* processEntrypoint() {
         log(`Unhandled error: %O`, e);
         throw e;
     }
+    finally {
+        this.entrypoint.endProcessing();
+    }
 }

package/types/transform/generators/resolveImports.js

@@ -40,11 +40,12 @@ function applyImportOverrides(services, entrypoint, resolvedImports) {
         };
     });
 }
-function emitDependency(emitter, entrypoint, imports) {
+function emitDependency(emitter, entrypoint, imports, phase) {
     emitter.single({
         type: 'dependency',
         file: entrypoint.name,
         only: entrypoint.only,
+        phase,
         imports: imports.map(({ resolved, only }) => ({
             from: resolved,
             what: only,
@@ -61,19 +62,32 @@ function filterUnresolved(entrypoint, resolvedImports) {
         return true;
     });
 }
+function getPreResolvedImports(preResolved) {
+    return new Map((preResolved ?? []).map((dependency) => [dependency.source, dependency]));
+}
 /**
  * Synchronously resolves specified imports with a provided resolver.
  */
 function* syncResolveImports(resolve) {
     const { data: { imports }, entrypoint, services: { eventEmitter }, } = this;
     const listOfImports = Array.from(imports?.entries() ?? []);
+    const preResolvedImports = getPreResolvedImports(this.data.preResolved);
     const { log } = entrypoint;
     if (listOfImports.length === 0) {
-        emitDependency(eventEmitter, entrypoint, []);
+        emitDependency(eventEmitter, entrypoint, [], this.data.phase);
         log('%s has no imports', entrypoint.name);
         return [];
     }
     const resolvedImports = listOfImports.map(([source, only]) => {
+        const preResolved = preResolvedImports.get(source);
+        if (preResolved) {
+            const mergedOnly = (0, Entrypoint_helpers_1.mergeOnly)(preResolved.only, only);
+            log('[sync-resolve] ♻️ %s -> %s (only: %o)', source, preResolved.resolved, mergedOnly);
+            return {
+                ...preResolved,
+                only: mergedOnly,
+            };
+        }
         let resolved = null;
         try {
             resolved = resolve(source, entrypoint.name, (0, Entrypoint_helpers_1.getStack)(entrypoint));
@@ -90,7 +104,7 @@ function* syncResolveImports(resolve) {
     });
     const overriddenImports = applyImportOverrides(this.services, entrypoint, resolvedImports);
     const filteredImports = filterUnresolved(entrypoint, overriddenImports);
-    emitDependency(eventEmitter, entrypoint, filteredImports);
+    emitDependency(eventEmitter, entrypoint, filteredImports, this.data.phase);
     return filteredImports;
 }
 /**
@@ -99,9 +113,10 @@ function* syncResolveImports(resolve) {
 async function* asyncResolveImports(resolve) {
     const { data: { imports }, entrypoint, services: { eventEmitter }, } = this;
     const listOfImports = Array.from(imports?.entries() ?? []);
+    const preResolvedImports = getPreResolvedImports(this.data.preResolved);
     const { log } = entrypoint;
     if (listOfImports.length === 0) {
-        emitDependency(eventEmitter, entrypoint, []);
+        emitDependency(eventEmitter, entrypoint, [], this.data.phase);
         log('%s has no imports', entrypoint.name);
         return [];
     }
@@ -124,6 +139,15 @@ async function* asyncResolveImports(resolve) {
         };
     };
     const resolvedImports = await Promise.all(listOfImports.map(([source, importsOnly]) => {
+        const preResolved = preResolvedImports.get(source);
+        if (preResolved) {
+            const mergedOnly = (0, Entrypoint_helpers_1.mergeOnly)(preResolved.only, importsOnly);
+            log('[async-resolve] ♻️ %s (%o) in %s -> %s', source, mergedOnly, entrypoint.name, preResolved.resolved);
+            return {
+                ...preResolved,
+                only: mergedOnly,
+            };
+        }
         const cached = entrypoint.getDependency(source);
         if (cached) {
             return {
@@ -155,6 +179,6 @@ async function* asyncResolveImports(resolve) {
     log('resolved %d imports', resolvedImports.length);
     const overriddenImports = applyImportOverrides(this.services, entrypoint, resolvedImports);
     const filteredImports = filterUnresolved(entrypoint, overriddenImports);
-    emitDependency(eventEmitter, entrypoint, filteredImports);
+    emitDependency(eventEmitter, entrypoint, filteredImports, this.data.phase);
     return filteredImports;
 }

package/types/transform/generators/rewriteBarrelImports.d.ts

@@ -0,0 +1,15 @@
+import * as t from '@babel/types';
+import type { IEntrypointDependency } from '../Entrypoint.types';
+import type { ITransformAction } from '../types';
+type RewriteResult = {
+    ast: t.File;
+    code: string;
+    fullyRewrittenSources: string[];
+    imports: Map<string, string[]> | null;
+    optimizedCount: number;
+    partialFallbackSources: string[];
+    preResolvedImports: IEntrypointDependency[];
+    skippedCount: number;
+};
+export declare function rewriteOptimizedBarrelImports(this: ITransformAction, ast: t.File, code: string, resolvedImports: IEntrypointDependency[]): Generator<any, RewriteResult, any>;
+export {};