@wyw-in-js/transform 1.0.6 → 1.0.7

package/types/transform/BaseEntrypoint.d.ts

@@ -12,11 +12,13 @@ export declare abstract class BaseEntrypoint {
     readonly only: string[];
     readonly parents: ParentEntrypoint[];
     readonly dependencies: Map<string, IEntrypointDependency>;
+    readonly invalidationDependencies: Map<string, IEntrypointDependency>;
+    readonly invalidateOnDependencyChange: Set<string>;
     static createExports: (log: Debugger) => Record<string | symbol, unknown>;
     readonly idx: string;
     readonly log: Debugger;
     readonly seqId: number;
-    protected constructor(services: Services, evaluatedOnly: string[], exports: Record<string | symbol, unknown> | undefined, generation: number, name: string, only: string[], parents: ParentEntrypoint[], dependencies: Map<string, IEntrypointDependency>);
+    protected constructor(services: Services, evaluatedOnly: string[], exports: Record<string | symbol, unknown> | undefined, generation: number, name: string, only: string[], parents: ParentEntrypoint[], dependencies: Map<string, IEntrypointDependency>, invalidationDependencies: Map<string, IEntrypointDependency>, invalidateOnDependencyChange: Set<string>);
     get exports(): Record<string | symbol, unknown>;
     set exports(value: unknown);
     get ref(): string;

package/types/transform/BaseEntrypoint.js

@@ -116,13 +116,15 @@ class BaseEntrypoint {
     only;
     parents;
     dependencies;
+    invalidationDependencies;
+    invalidateOnDependencyChange;
     static createExports = exports.createExports;
     idx;
     log;
     // eslint-disable-next-line no-plusplus
     seqId = entrypointSeqId++;
     #exports;
-    constructor(services, evaluatedOnly, exports, generation, name, only, parents, dependencies) {
+    constructor(services, evaluatedOnly, exports, generation, name, only, parents, dependencies, invalidationDependencies, invalidateOnDependencyChange) {
         this.services = services;
         this.evaluatedOnly = evaluatedOnly;
         this.generation = generation;
@@ -130,6 +132,8 @@ class BaseEntrypoint {
         this.only = only;
         this.parents = parents;
         this.dependencies = dependencies;
+        this.invalidationDependencies = invalidationDependencies;
+        this.invalidateOnDependencyChange = invalidateOnDependencyChange;
         this.idx = (0, getFileIdx_1.getFileIdx)(name);
         this.log =
             parents[0]?.log.extend(this.ref, '->') ?? services.log.extend(this.ref);

package/types/transform/Entrypoint.d.ts

@@ -10,6 +10,8 @@ export declare class Entrypoint extends BaseEntrypoint {
     readonly initialCode: string | undefined;
     protected readonly resolveTasks: Map<string, Promise<IEntrypointDependency>>;
     readonly dependencies: Map<string, IEntrypointDependency>;
+    readonly invalidationDependencies: Map<string, IEntrypointDependency>;
+    readonly invalidateOnDependencyChange: Set<string>;
     readonly evaluated = false;
     readonly loadedAndParsed: IEntrypointCode | IIgnoredEntrypoint;
     protected onSupersedeHandlers: Array<(newEntrypoint: Entrypoint) => void>;
@@ -35,16 +37,23 @@ export declare class Entrypoint extends BaseEntrypoint {
     protected static create(services: Services, parent: ParentEntrypoint | null, name: string, only: string[], loadedCode: string | undefined): Entrypoint | 'loop';
     private static innerCreate;
     addDependency(dependency: IEntrypointDependency): void;
+    addInvalidationDependency(dependency: IEntrypointDependency): void;
     addResolveTask(name: string, dependency: Promise<IEntrypointDependency>): void;
+    applyDeferredSupersede(): Entrypoint | null;
     assertNotSuperseded(): void;
     assertTransformed(): void;
+    beginProcessing(): void;
     createAction<TType extends ActionTypes, TAction extends ActionByType<TType>>(actionType: TType, data: TAction['data'], abortSignal?: AbortSignal | null): BaseAction<TAction>;
     createChild(name: string, only: string[], loadedCode?: string): Entrypoint | 'loop';
     createEvaluated(): EvaluatedEntrypoint;
+    endProcessing(): void;
     getDependency(name: string): IEntrypointDependency | undefined;
+    getInvalidationDependency(name: string): IEntrypointDependency | undefined;
+    markInvalidateOnDependencyChange(filename: string): void;
     getResolveTask(name: string): Promise<IEntrypointDependency> | undefined;
     hasWywMetadata(): boolean;
     onSupersede(callback: (newEntrypoint: Entrypoint) => void): () => void;
     setTransformResult(res: ITransformFileResult | null): void;
+    private deferOnlySupersede;
     private supersede;
 }

package/types/transform/Entrypoint.js

@@ -1,14 +1,18 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Entrypoint = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
 const ts_invariant_1 = require("ts-invariant");
 const BaseEntrypoint_1 = require("./BaseEntrypoint");
 const Entrypoint_helpers_1 = require("./Entrypoint.helpers");
-const isStaticallyEvaluatableModule_1 = require("./isStaticallyEvaluatableModule");
 const EvaluatedEntrypoint_1 = require("./EvaluatedEntrypoint");
 const AbortError_1 = require("./actions/AbortError");
 const BaseAction_1 = require("./actions/BaseAction");
 const UnprocessedEntrypointError_1 = require("./actions/UnprocessedEntrypointError");
+const parseRequest_1 = require("../utils/parseRequest");
 const EMPTY_FILE = '=== empty file ===';
 function hasLoop(name, parent, processed = []) {
     if (parent.name === name || processed.includes(parent.name)) {
@@ -26,18 +30,24 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
     initialCode;
     resolveTasks;
     dependencies;
+    invalidationDependencies;
+    invalidateOnDependencyChange;
     evaluated = false;
     loadedAndParsed;
     onSupersedeHandlers = [];
     actionsCache = new Map();
     #hasWywMetadata = false;
+    #isProcessing = false;
+    #pendingOnly = null;
     #supersededWith = null;
     #transformResultCode = null;
-    constructor(services, parents, initialCode, name, only, exports, evaluatedOnly, loadedAndParsed, resolveTasks = new Map(), dependencies = new Map(), generation = 1) {
-        super(services, evaluatedOnly, exports, generation, name, only, parents, dependencies);
+    constructor(services, parents, initialCode, name, only, exports, evaluatedOnly, loadedAndParsed, resolveTasks = new Map(), dependencies = new Map(), invalidationDependencies = new Map(), invalidateOnDependencyChange = new Set(), generation = 1) {
+        super(services, evaluatedOnly, exports, generation, name, only, parents, dependencies, invalidationDependencies, invalidateOnDependencyChange);
         this.initialCode = initialCode;
         this.resolveTasks = resolveTasks;
         this.dependencies = dependencies;
+        this.invalidationDependencies = invalidationDependencies;
+        this.invalidateOnDependencyChange = invalidateOnDependencyChange;
         this.loadedAndParsed =
             loadedAndParsed ??
                 services.loadAndParseFn(services, name, initialCode, parents[0]?.log ?? services.log);
@@ -99,9 +109,18 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
     static innerCreate(services, parent, name, only, loadedCode) {
         const { cache } = services;
         const cached = cache.get('entrypoints', name);
-        const changed = loadedCode !== undefined
-            ? cache.invalidateIfChanged(name, loadedCode, undefined, 'loaded')
-            : false;
+        let changed = false;
+        if (loadedCode !== undefined) {
+            changed = cache.invalidateIfChanged(name, loadedCode, undefined, 'loaded');
+        }
+        else if (cached && cached.initialCode === undefined) {
+            try {
+                changed = cache.invalidateIfChanged(name, node_fs_1.default.readFileSync((0, parseRequest_1.stripQueryAndHash)(name), 'utf8'), undefined, 'fs');
+            }
+            catch {
+                changed = false;
+            }
+        }
         if (!cached?.evaluated && cached?.ignored) {
             return ['cached', cached];
         }
@@ -124,20 +143,18 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
                 return [isLoop ? 'loop' : 'cached', cached];
             }
             cached.log('is cached, but with different `only` %o (the cached one %o)', only, cached?.only);
-            return [isLoop ? 'loop' : 'created', cached.supersede(mergedOnly)];
-        }
-        const newEntrypoint = new Entrypoint(services, parent ? [parent] : [], loadedCode, name, mergedOnly, exports, evaluatedOnly, undefined, cached && 'resolveTasks' in cached ? cached.resolveTasks : undefined, cached && 'dependencies' in cached ? cached.dependencies : undefined, cached ? cached.generation + 1 : 1);
-        if (!newEntrypoint.ignored &&
-            !newEntrypoint.only.includes('*') &&
-            !newEntrypoint.only.includes('__wywPreval') &&
-            !newEntrypoint.only.includes('side-effect')) {
-            const { ast } = newEntrypoint.loadedAndParsed;
-            if (ast && (0, isStaticallyEvaluatableModule_1.isStaticallyEvaluatableModule)(ast)) {
-                newEntrypoint.log('[entrypoint] promote `only` to "*" for statically evaluatable module');
-                newEntrypoint.only.length = 0;
-                newEntrypoint.only.push('*');
+            if (cached.#isProcessing) {
+                cached.deferOnlySupersede(mergedOnly);
+                cached.log('is being processed, defer supersede (%o -> %o)', cached.only, mergedOnly);
+                return [isLoop ? 'loop' : 'cached', cached];
             }
+            return [isLoop ? 'loop' : 'created', cached.supersede(mergedOnly)];
         }
+        const newEntrypoint = new Entrypoint(services, parent ? [parent] : [], loadedCode, name, mergedOnly, exports, evaluatedOnly, undefined, cached && 'resolveTasks' in cached ? cached.resolveTasks : undefined, cached && 'dependencies' in cached ? cached.dependencies : undefined, cached && 'invalidationDependencies' in cached
+            ? cached.invalidationDependencies
+            : undefined, cached && 'invalidateOnDependencyChange' in cached
+            ? cached.invalidateOnDependencyChange
+            : undefined, cached ? cached.generation + 1 : 1);
         if (cached && !cached.evaluated) {
             cached.log('is cached, but with different code');
             cached.supersede(newEntrypoint);
@@ -148,9 +165,27 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
         this.resolveTasks.delete(dependency.source);
         this.dependencies.set(dependency.source, dependency);
     }
+    addInvalidationDependency(dependency) {
+        this.resolveTasks.delete(dependency.source);
+        this.invalidationDependencies.set(dependency.source, dependency);
+    }
     addResolveTask(name, dependency) {
         this.resolveTasks.set(name, dependency);
     }
+    applyDeferredSupersede() {
+        if (this.#supersededWith || this.#pendingOnly === null) {
+            return null;
+        }
+        const mergedOnly = (0, Entrypoint_helpers_1.mergeOnly)(this.only, this.#pendingOnly);
+        this.#pendingOnly = null;
+        if ((0, Entrypoint_helpers_1.isSuperSet)(this.only, mergedOnly)) {
+            return null;
+        }
+        this.log('apply deferred supersede (%o -> %o)', this.only, mergedOnly);
+        const nextEntrypoint = this.supersede(mergedOnly);
+        this.services.cache.add('entrypoints', this.name, nextEntrypoint);
+        return nextEntrypoint;
+    }
     assertNotSuperseded() {
         if (this.supersededWith) {
             this.log('superseded');
@@ -163,6 +198,9 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
             throw new UnprocessedEntrypointError_1.UnprocessedEntrypointError(this.supersededWith ?? this);
         }
     }
+    beginProcessing() {
+        this.#isProcessing = true;
+    }
     createAction(actionType, data, abortSignal = null) {
         if (!this.actionsCache.has(actionType)) {
             this.actionsCache.set(actionType, new Map());
@@ -187,13 +225,22 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
     createEvaluated() {
         const evaluatedOnly = (0, Entrypoint_helpers_1.mergeOnly)(this.evaluatedOnly, this.only);
         this.log('create EvaluatedEntrypoint for %o', evaluatedOnly);
-        const evaluated = new EvaluatedEntrypoint_1.EvaluatedEntrypoint(this.services, evaluatedOnly, this.exportsProxy, this.generation + 1, this.name, this.only, this.parents, this.dependencies);
+        const evaluated = new EvaluatedEntrypoint_1.EvaluatedEntrypoint(this.services, evaluatedOnly, this.exportsProxy, this.generation + 1, this.name, this.only, this.parents, this.dependencies, this.invalidationDependencies, this.invalidateOnDependencyChange);
         evaluated.initialCode = this.initialCode;
         return evaluated;
     }
+    endProcessing() {
+        this.#isProcessing = false;
+    }
     getDependency(name) {
         return this.dependencies.get(name);
     }
+    getInvalidationDependency(name) {
+        return this.invalidationDependencies.get(name);
+    }
+    markInvalidateOnDependencyChange(filename) {
+        this.invalidateOnDependencyChange.add(filename);
+    }
     getResolveTask(name) {
         return this.resolveTasks.get(name);
     }
@@ -221,10 +268,16 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
             type: 'setTransformResult',
         });
     }
+    deferOnlySupersede(only) {
+        this.#pendingOnly = this.#pendingOnly
+            ? (0, Entrypoint_helpers_1.mergeOnly)(this.#pendingOnly, only)
+            : [...only];
+    }
     supersede(newOnlyOrEntrypoint) {
+        this.#pendingOnly = null;
         const newEntrypoint = newOnlyOrEntrypoint instanceof Entrypoint
             ? newOnlyOrEntrypoint
-            : new Entrypoint(this.services, this.parents, this.initialCode, this.name, newOnlyOrEntrypoint, this.exports, this.evaluatedOnly, this.loadedAndParsed, this.resolveTasks, this.dependencies, this.generation + 1);
+            : new Entrypoint(this.services, this.parents, this.initialCode, this.name, newOnlyOrEntrypoint, this.exports, this.evaluatedOnly, this.loadedAndParsed, this.resolveTasks, this.dependencies, this.invalidationDependencies, this.invalidateOnDependencyChange, this.generation + 1);
         this.services.eventEmitter.entrypointEvent(this.seqId, {
             type: 'superseded',
             with: newEntrypoint.seqId,

package/types/transform/EvaluatedEntrypoint.d.ts

@@ -9,6 +9,8 @@ export interface IEvaluatedEntrypoint {
     generation: number;
     ignored: false;
     initialCode?: string;
+    invalidationDependencies: Map<string, IEntrypointDependency>;
+    invalidateOnDependencyChange: Set<string>;
     log: Debugger;
     only: string[];
 }

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,17 @@ 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 } = action.entrypoint;
+    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 +74,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 +113,7 @@ function* processEntrypoint() {
         log(`Unhandled error: %O`, e);
         throw e;
     }
+    finally {
+        this.entrypoint.endProcessing();
+    }
 }