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

package/types/transform/generators/baseProcessingHandlers.js

@@ -1,23 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.baseProcessingHandlers = void 0;
-const explodeReexports_1 = require("./explodeReexports");
-const getExports_1 = require("./getExports");
-const processEntrypoint_1 = require("./processEntrypoint");
-const processImports_1 = require("./processImports");
-const transform_1 = require("./transform");
+import { getExports } from './getExports';
+import { processEntrypointAsync } from './processEntrypoint';
+import { processImports } from './processImports';
+import { transform } from './transform';
 // eslint-disable-next-line require-yield
 function* emptyHandler() {
     throw new Error(`Handler for ${this.type} is not implemented`);
 }
-exports.baseProcessingHandlers = {
+export const baseProcessingHandlers = {
     collect: (emptyHandler),
     evalFile: (emptyHandler),
+    explodeReexports: (emptyHandler),
     extract: (emptyHandler),
     workflow: (emptyHandler),
-    explodeReexports: explodeReexports_1.explodeReexports,
-    getExports: getExports_1.getExports,
-    processEntrypoint: processEntrypoint_1.processEntrypoint,
-    processImports: processImports_1.processImports,
-    transform: transform_1.transform,
+    getExports,
+    processEntrypoint: processEntrypointAsync,
+    processImports,
+    transform,
 };

package/types/transform/generators/collect.js

@@ -1,56 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.collect = collect;
-const buildOptions_1 = require("../../options/buildOptions");
-const collector_1 = require("../../plugins/collector");
-const TransformMetadata_1 = require("../../utils/TransformMetadata");
+import { oxcShaker } from '../../shaker';
+import { collectOxcRuntime } from '../../utils/collectOxcRuntime';
 /**
  * Parses the specified file, finds tags, applies run-time replacements,
  * removes dead code.
  */
 // eslint-disable-next-line require-yield
-function* collect() {
-    const { babel, options } = this.services;
+export function* collect() {
+    const { options } = this.services;
     const { valueCache } = this.data;
     const { entrypoint } = this;
     const { loadedAndParsed, name } = entrypoint;
+    const preevalResult = entrypoint.getPreevalResult();
     if (loadedAndParsed.evaluator === 'ignored') {
         throw new Error('entrypoint was ignored');
     }
-    const transformPlugins = [
-        [
-            collector_1.filename,
-            {
-                ...options.pluginOptions,
-                values: valueCache,
-            },
-        ],
-    ];
-    const transformConfig = (0, buildOptions_1.buildOptions)({
-        envName: 'wyw-in-js',
-        plugins: transformPlugins,
-        sourceMaps: true,
-        sourceFileName: name,
-        inputSourceMap: options.inputSourceMap,
-        root: options.root,
-        ast: true,
-        babelrc: false,
-        configFile: false,
-        sourceType: 'unambiguous',
-    });
-    const result = babel.transformFromAstSync(loadedAndParsed.ast, loadedAndParsed.code, {
-        ...transformConfig,
-        cwd: options.root,
-        filename: name,
-    });
-    if (!result || !result.ast?.program) {
-        throw new Error('Babel transform failed');
+    if (loadedAndParsed.evaluator !== oxcShaker) {
+        throw new Error(`[wyw-in-js] ${name} matched a legacy evaluator. The Oxc runtime path supports only the default Oxc evaluator.`);
     }
-    const transformMetadata = (0, TransformMetadata_1.getTransformMetadata)(result.metadata);
+    const result = collectOxcRuntime(loadedAndParsed.code, name, options.root ?? process.cwd(), {
+        ...options.pluginOptions,
+        preserveSideEffectImportLocals: new Set(preevalResult?.staticSideEffectImportLocals ?? []),
+    }, valueCache, options.inputSourceMap);
     return {
-        ast: result.ast,
+        ast: null,
         code: result.code,
         map: result.map,
-        metadata: transformMetadata ?? null,
+        metadata: result.metadata,
     };
 }

package/types/transform/generators/createStylisPreprocessor.js

@@ -1,48 +1,8 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stylisGlobalPlugin = void 0;
-exports.transformUrl = transformUrl;
-exports.createStylisUrlReplacePlugin = createStylisUrlReplacePlugin;
-exports.createKeyframeSuffixerPlugin = createKeyframeSuffixerPlugin;
-exports.createStylisPreprocessor = createStylisPreprocessor;
 /* eslint-disable no-continue */
-const path = __importStar(require("path"));
-const stylis_1 = require("stylis");
+import * as path from 'path';
+import { compile, middleware, prefixer, serialize, stringify, tokenize, COMMENT, RULESET, KEYFRAMES, DECLARATION, } from 'stylis';
 const POSIX_SEP = path.posix.sep;
-function transformUrl(url, outputFilename, sourceFilename, platformPath = path) {
+export function transformUrl(url, outputFilename, sourceFilename, platformPath = path) {
     // Replace asset path with new path relative to the output CSS
     const relative = platformPath.relative(platformPath.dirname(outputFilename), 
     // Get the absolute path to the asset from the path relative to the JS file
@@ -76,15 +36,15 @@ function propsIsString(props) {
     return (typeof props === 'string' || throwIfNotProd('props', props, 'string[]'));
 }
 const isDeclaration = (element) => {
-    return (element.type === stylis_1.DECLARATION &&
+    return (element.type === DECLARATION &&
         propsIsString(element.props) &&
         childrenIsString(element.children));
 };
 const isKeyframes = (element) => {
-    return element.type === stylis_1.KEYFRAMES && propsAreStrings(element.props);
+    return element.type === KEYFRAMES && propsAreStrings(element.props);
 };
 const isRuleset = (element) => {
-    return element.type === stylis_1.RULESET && propsAreStrings(element.props);
+    return element.type === RULESET && propsAreStrings(element.props);
 };
 function nonMediaParent(element) {
     let { parent } = element;
@@ -99,7 +59,7 @@ function nonMediaParent(element) {
 /**
  * Stylis plugin that mimics :global() selector behavior from Stylis v3.
  */
-const stylisGlobalPlugin = (element) => {
+export const stylisGlobalPlugin = (element) => {
     function getGlobalSelectorModifiers(el) {
         const parent = nonMediaParent(el);
         const value = getOriginalElementValue(el);
@@ -133,7 +93,7 @@ const stylisGlobalPlugin = (element) => {
                 return cssSelector;
             }
             const { includeBaseSelector, includeSpaceDelimiter } = getGlobalSelectorModifiers(element);
-            const tokens = (0, stylis_1.tokenize)(cssSelector);
+            const tokens = tokenize(cssSelector);
             let selector = '';
             for (let i = 0, len = tokens.length; i < len; i++) {
                 const token = tokens[i];
@@ -166,8 +126,7 @@ const stylisGlobalPlugin = (element) => {
         }),
     });
 };
-exports.stylisGlobalPlugin = stylisGlobalPlugin;
-function createStylisUrlReplacePlugin(filename, outputFilename) {
+export function createStylisUrlReplacePlugin(filename, outputFilename) {
     return (element) => {
         if (element.type === 'decl' && outputFilename) {
             // When writing to a file, we need to adjust the relative paths inside url(..) expressions.
@@ -177,7 +136,7 @@ function createStylisUrlReplacePlugin(filename, outputFilename) {
         }
     };
 }
-function createKeyframeSuffixerPlugin() {
+export function createKeyframeSuffixerPlugin() {
     const prefixes = ['webkit', 'moz', 'ms', 'o', ''].map((i) => i ? `-${i}-` : '');
     const getPrefixedProp = (prop) => prefixes.map((prefix) => `${prefix}${prop}`);
     const buildPropsRegexp = (prop, isAtRule) => {
@@ -253,7 +212,7 @@ function createKeyframeSuffixerPlugin() {
             if (animationPropsSet.has(element.props)) {
                 const scopedKeyframes = getDefinedKeyframes(element);
                 const patch = Object.fromEntries(keys.map((key) => {
-                    const tokens = (0, stylis_1.tokenize)(element[key]);
+                    const tokens = tokenize(element[key]);
                     let result = '';
                     for (let i = 0; i < tokens.length; i += 1) {
                         if (tokens[i] === ':' &&
@@ -402,12 +361,12 @@ function createStylisDisplayNormalizationPlugin() {
 }
 function createStylisStringifier(keepComments) {
     if (!keepComments) {
-        return stylis_1.stringify;
+        return stringify;
     }
     const keepAllComments = keepComments === true;
     const keepCommentsFilter = keepComments instanceof RegExp ? keepComments : null;
     return (element, index, children, callback) => {
-        if (element.type === stylis_1.COMMENT) {
+        if (element.type === COMMENT) {
             if (!keepAllComments && keepCommentsFilter) {
                 const commentValue = typeof element.children === 'string'
                     ? element.children
@@ -419,20 +378,20 @@ function createStylisStringifier(keepComments) {
             }
             return element.value;
         }
-        return (0, stylis_1.stringify)(element, index, children, callback);
+        return stringify(element, index, children, callback);
     };
 }
-function createStylisPreprocessor(options) {
+export function createStylisPreprocessor(options) {
     const stringifier = createStylisStringifier(options.keepComments);
     function stylisPreprocess(selector, text) {
-        const compiled = (0, stylis_1.compile)(`${selector} {${text}}\n`);
-        return (0, stylis_1.serialize)(compiled, (0, stylis_1.middleware)([
+        const compiled = compile(`${selector} {${text}}\n`);
+        return serialize(compiled, middleware([
             createStylisUrlReplacePlugin(options.filename, options.outputFilename),
-            exports.stylisGlobalPlugin,
+            stylisGlobalPlugin,
             options.prefixer === false
                 ? null
                 : createStylisDisplayNormalizationPlugin(),
-            options.prefixer === false ? null : stylis_1.prefixer,
+            options.prefixer === false ? null : prefixer,
             createKeyframeSuffixerPlugin(),
             stringifier,
         ].filter(isMiddleware)));

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

@@ -1,6 +1,6 @@
-import type { IEvalAction, SyncScenarioForAction } from '../types';
+import type { AsyncScenarioForAction, IEvalAction } from '../types';
 /**
  * Executes the code prepared in previous steps within the current `Entrypoint`.
  * Returns all exports that were requested in `only`.
  */
-export declare function evalFile(this: IEvalAction): SyncScenarioForAction<IEvalAction>;
+export declare function evalFile(this: IEvalAction): AsyncScenarioForAction<IEvalAction>;

package/types/transform/generators/evalFile.js

@@ -1,36 +1,32 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.evalFile = evalFile;
-const evaluators_1 = __importDefault(require("../../evaluators"));
-const hasWywPreval_1 = __importDefault(require("../../utils/hasWywPreval"));
-const UnprocessedEntrypointError_1 = require("../actions/UnprocessedEntrypointError");
-const wrap = (fn) => {
-    try {
-        return fn();
-    }
-    catch (e) {
-        return e;
-    }
-};
+import evaluate from '../../evaluators';
+import { isUnprocessedEntrypointError } from '../actions/UnprocessedEntrypointError';
 /**
  * Executes the code prepared in previous steps within the current `Entrypoint`.
  * Returns all exports that were requested in `only`.
  */
 // eslint-disable-next-line require-yield
-function* evalFile() {
+export async function* evalFile() {
     const { entrypoint } = this;
     const { log } = entrypoint;
+    const preevalResult = entrypoint.getPreevalResult();
+    if (preevalResult && (preevalResult.dependencyNames?.length ?? 0) === 0) {
+        const valueCache = new Map();
+        preevalResult.staticValueCache?.forEach((value, key) => {
+            valueCache.set(key, value);
+        });
+        const dependencies = [...new Set(preevalResult.staticDependencies ?? [])];
+        log(`<< skipped evaluate __wywPreval %O`, valueCache);
+        return [valueCache, dependencies];
+    }
     log(`>> evaluate __wywPreval`);
     let evaluated;
     while (evaluated === undefined) {
         try {
-            evaluated = (0, evaluators_1.default)(this.services, entrypoint);
+            // eslint-disable-next-line no-await-in-loop
+            evaluated = await this.services.eventEmitter.perf('transform:evalFile', () => evaluate(this.services, entrypoint));
         }
         catch (e) {
-            if ((0, UnprocessedEntrypointError_1.isUnprocessedEntrypointError)(e)) {
+            if (isUnprocessedEntrypointError(e)) {
                 entrypoint.log('Evaluation has been aborted because one if the required files is not processed. Schedule reprocessing and repeat evaluation.');
                 yield ['processEntrypoint', e.entrypoint, undefined];
             }
@@ -39,17 +35,19 @@ function* evalFile() {
             }
         }
     }
-    const wywPreval = (0, hasWywPreval_1.default)(evaluated.value)
-        ? evaluated.value.__wywPreval
-        : undefined;
-    if (!wywPreval) {
+    if (!evaluated.values) {
         return null;
     }
-    const valueCache = new Map();
-    Object.entries(wywPreval).forEach(([key, lazyValue]) => {
-        const value = wrap(lazyValue);
+    const valueCache = evaluated.values;
+    preevalResult?.staticValueCache?.forEach((value, key) => {
         valueCache.set(key, value);
     });
+    const dependencies = [
+        ...new Set([
+            ...evaluated.dependencies,
+            ...(preevalResult?.staticDependencies ?? []),
+        ]),
+    ];
     log(`<< evaluated __wywPreval %O`, valueCache);
-    return [valueCache, evaluated.dependencies];
+    return [valueCache, dependencies];
 }

package/types/transform/generators/extract.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extract = extract;
-const source_map_1 = require("source-map");
-const createStylisPreprocessor_1 = require("./createStylisPreprocessor");
+import { SourceMapGenerator } from 'source-map';
+import { createStylisPreprocessor } from './createStylisPreprocessor';
 function extractCssFromAst(rules, originalCode, options) {
     const mappings = [];
     let cssText = '';
@@ -18,7 +15,7 @@ function extractCssFromAst(rules, originalCode, options) {
                 break;
             case 'stylis':
             default:
-                preprocessor = (0, createStylisPreprocessor_1.createStylisPreprocessor)(options);
+                preprocessor = createStylisPreprocessor(options);
         }
     }
     Object.keys(rules).forEach((selector, index) => {
@@ -45,7 +42,7 @@ function extractCssFromAst(rules, originalCode, options) {
         rules,
         get cssSourceMapText() {
             if (mappings?.length) {
-                const generator = new source_map_1.SourceMapGenerator({
+                const generator = new SourceMapGenerator({
                     file: options.filename.replace(/\.js$/, '.css'),
                 });
                 mappings.forEach((mapping) => generator.addMapping({ ...mapping, source: options.filename }));
@@ -60,7 +57,7 @@ function extractCssFromAst(rules, originalCode, options) {
  * Extract artifacts (e.g. CSS) from processors
  */
 // eslint-disable-next-line require-yield
-function* extract() {
+export function* extract() {
     const { options } = this.services;
     const { entrypoint } = this;
     const { processors } = this.data;

package/types/transform/generators/getExports.js

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findExportsInImports = findExportsInImports;
-exports.getExports = getExports;
-const collectExportsAndImports_1 = require("../../utils/collectExportsAndImports");
-function findExportsInImports(entrypoint, imports) {
+/* eslint-disable no-continue */
+import { collectOxcExportsAndImports } from '../../utils/collectOxcExportsAndImports';
+import { oxcShaker } from '../../shaker';
+export function findExportsInImports(entrypoint, imports) {
     const results = [];
     for (const imp of imports) {
         const { resolved } = imp;
@@ -12,7 +10,6 @@ function findExportsInImports(entrypoint, imports) {
         }
         const newEntrypoint = entrypoint.createChild(resolved, []);
         if (newEntrypoint === 'loop') {
-            // eslint-disable-next-line no-continue
             continue;
         }
         results.push({
@@ -22,48 +19,44 @@ function findExportsInImports(entrypoint, imports) {
     }
     return results;
 }
-function* getExports() {
+export function* getExports() {
     const { entrypoint, services: { cache }, } = this;
     const { loadedAndParsed } = entrypoint;
-    if (loadedAndParsed.ast === undefined) {
-        return [];
-    }
-    entrypoint.log(`get exports from %s`, entrypoint.name);
+    entrypoint.log('get exports from %s', entrypoint.name);
     if (cache.has('exports', entrypoint.name)) {
         return cache.get('exports', entrypoint.name);
     }
     let withWildcardReexport = [];
     const result = [];
-    this.services.babel.traverse(loadedAndParsed.ast, {
-        Program(path) {
-            const { exports, reexports } = (0, collectExportsAndImports_1.collectExportsAndImports)(path, 'disabled');
-            Object.keys(exports).forEach((token) => {
-                result.push(token);
-            });
-            reexports.forEach((e) => {
-                if (e.exported !== '*') {
-                    result.push(e.exported);
-                }
-            });
-            withWildcardReexport = reexports.filter((e) => e.exported === '*');
-        },
+    if (loadedAndParsed.evaluator !== oxcShaker) {
+        throw new Error(`[wyw-in-js] ${entrypoint.name} matched a legacy evaluator. The Oxc runtime path supports only the default Oxc evaluator.`);
+    }
+    const { exports, reexports } = collectOxcExportsAndImports(loadedAndParsed.code, loadedAndParsed.evalConfig.filename ?? entrypoint.name);
+    Object.keys(exports).forEach((token) => {
+        result.push(token);
+    });
+    reexports.forEach((reexport) => {
+        if (reexport.exported !== '*') {
+            result.push(reexport.exported);
+        }
     });
+    withWildcardReexport = reexports.filter((reexport) => reexport.exported === '*');
     if (withWildcardReexport.length) {
         const resolvedImports = yield* this.getNext('resolveImports', entrypoint, {
-            imports: new Map(withWildcardReexport.map((i) => [i.source, []])),
+            imports: new Map(withWildcardReexport.map((item) => [item.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);
+            const childExports = yield* this.getNext('getExports', importedEntrypoint.entrypoint, undefined);
+            result.push(...childExports);
         }
         cache.add('exports', entrypoint.name, result);
         cache.setCacheDependencies('exports', entrypoint.name, dependencyFilenames);
-        entrypoint.log(`exports: %o`, result);
+        entrypoint.log('exports: %o', result);
         return result;
     }
-    entrypoint.log(`exports: %o`, result);
+    entrypoint.log('exports: %o', result);
     cache.add('exports', entrypoint.name, result);
     return result;
 }

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

@@ -7,9 +7,9 @@ export declare const baseHandlers: {
     evalFile: typeof evalFile;
     extract: typeof extract;
     workflow: typeof workflow;
-    explodeReexports: typeof import("./explodeReexports").explodeReexports;
+    explodeReexports: (this: import("../types").IExplodeReexportsAction) => import("../types").SyncScenarioForAction<import("../types").IExplodeReexportsAction>;
     getExports: typeof import("./getExports").getExports;
-    processEntrypoint: typeof import("./processEntrypoint").processEntrypoint;
+    processEntrypoint: typeof import("./processEntrypoint").processEntrypointAsync;
     processImports: typeof import("./processImports").processImports;
     transform: typeof import("./transform").transform;
 };

package/types/transform/generators/index.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.baseHandlers = void 0;
-const baseProcessingHandlers_1 = require("./baseProcessingHandlers");
-const collect_1 = require("./collect");
-const evalFile_1 = require("./evalFile");
-const extract_1 = require("./extract");
-const workflow_1 = require("./workflow");
-exports.baseHandlers = {
-    ...baseProcessingHandlers_1.baseProcessingHandlers,
-    collect: collect_1.collect,
-    evalFile: evalFile_1.evalFile,
-    extract: extract_1.extract,
-    workflow: workflow_1.workflow,
+import { baseProcessingHandlers } from './baseProcessingHandlers';
+import { collect } from './collect';
+import { evalFile } from './evalFile';
+import { extract } from './extract';
+import { workflow } from './workflow';
+export const baseHandlers = {
+    ...baseProcessingHandlers,
+    collect,
+    evalFile,
+    extract,
+    workflow,
 };

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

@@ -1,9 +1,9 @@
-import type { IProcessEntrypointAction, SyncScenarioForAction } from '../types';
+import type { AsyncScenarioForAction, IProcessEntrypointAction, SyncScenarioForAction } from '../types';
 /**
  * The first stage of processing an entrypoint.
  * This stage is responsible for:
- * - scheduling the explodeReexports action
  * - scheduling the transform action
  * - rescheduling itself if the entrypoint is superseded
  */
 export declare function processEntrypoint(this: IProcessEntrypointAction): SyncScenarioForAction<IProcessEntrypointAction>;
+export declare function processEntrypointAsync(this: IProcessEntrypointAction): AsyncScenarioForAction<IProcessEntrypointAction>;

package/types/transform/generators/processEntrypoint.js

@@ -1,4 +1,3 @@
-"use strict";
 var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
     if (value !== null && value !== void 0) {
         if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
@@ -51,43 +50,29 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-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;
-};
+import { isAborted } from '../actions/AbortError';
 /**
  * The first stage of processing an entrypoint.
  * This stage is responsible for:
- * - scheduling the explodeReexports action
  * - scheduling the transform action
  * - rescheduling itself if the entrypoint is superseded
  */
-function* processEntrypoint() {
+export function* processEntrypoint() {
     const { only, log } = this.entrypoint;
     log('start processing (only: %o)', only);
+    if (this.entrypoint.transformed) {
+        log('already transformed, skip processing');
+        return;
+    }
+    if (this.entrypoint.isProcessing) {
+        log('already processing, skip duplicate request');
+        return;
+    }
     this.entrypoint.beginProcessing();
     try {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
             const abortSignal = __addDisposableResource(env_1, this.createAbortSignal(), false);
-            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);
@@ -108,7 +93,56 @@ function* processEntrypoint() {
         }
     }
     catch (e) {
-        if ((0, AbortError_1.isAborted)(e) && this.entrypoint.supersededWith) {
+        if (isAborted(e) && this.entrypoint.supersededWith) {
+            log('processing aborted, schedule the next attempt');
+            yield* this.getNext('processEntrypoint', this.entrypoint.supersededWith, undefined, null);
+            return;
+        }
+        log(`Unhandled error: %O`, e);
+        throw e;
+    }
+    finally {
+        this.entrypoint.endProcessing();
+    }
+}
+export async function* processEntrypointAsync() {
+    const { only, log } = this.entrypoint;
+    log('start processing (only: %o)', only);
+    if (this.entrypoint.transformed) {
+        log('already transformed, skip processing');
+        return;
+    }
+    if (this.entrypoint.isProcessing) {
+        log('already processing, wait for existing request');
+        await this.entrypoint.waitForProcessing();
+        return;
+    }
+    this.entrypoint.beginProcessing();
+    try {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const abortSignal = __addDisposableResource(env_2, this.createAbortSignal(), false);
+            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_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    }
+    catch (e) {
+        if (isAborted(e) && this.entrypoint.supersededWith) {
             log('processing aborted, schedule the next attempt');
             yield* this.getNext('processEntrypoint', this.entrypoint.supersededWith, undefined, null);
             return;

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

@@ -1,5 +1,2 @@
 import type { IProcessImportsAction, SyncScenarioForAction } from '../types';
-/**
- * Creates new entrypoints and emits processEntrypoint for each resolved import
- */
 export declare function processImports(this: IProcessImportsAction): SyncScenarioForAction<IProcessImportsAction>;