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

package/types/transform/Entrypoint.js

@@ -1,18 +1,12 @@
-"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 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");
+import fs from 'node:fs';
+import { invariant } from 'ts-invariant';
+import { BaseEntrypoint } from './BaseEntrypoint';
+import { isSuperSet, mergeOnly } from './Entrypoint.helpers';
+import { EvaluatedEntrypoint } from './EvaluatedEntrypoint';
+import { AbortError } from './actions/AbortError';
+import { BaseAction } from './actions/BaseAction';
+import { UnprocessedEntrypointError } from './actions/UnprocessedEntrypointError';
+import { stripQueryAndHash } from '../utils/parseRequest';
 const EMPTY_FILE = '=== empty file ===';
 const DEFAULT_ACTION_CONTEXT = Symbol('defaultActionContext');
 function hasLoop(name, parent, processed = []) {
@@ -27,32 +21,45 @@ function hasLoop(name, parent, processed = []) {
     }
     return false;
 }
-class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
+export class Entrypoint extends BaseEntrypoint {
     initialCode;
     resolveTasks;
     dependencies;
     invalidationDependencies;
     invalidateOnDependencyChange;
+    skipCacheInvalidation;
     evaluated = false;
     loadedAndParsed;
     onSupersedeHandlers = [];
     actionsCache = new Map();
+    // Tracks how many times resolveImports has settled with `resolved: null`
+    // for a given source. Bundler resolvers can return null transiently early
+    // in a build (loader context for that file isn't registered yet); after a
+    // bounded number of retries we accept the null as authoritative.
+    #resolveTaskNullAttempts = new Map();
+    static RESOLVE_TASK_MAX_NULL_ATTEMPTS = 2;
     #hasWywMetadata = false;
+    #hasTransformResult = false;
     #isProcessing = false;
     #pendingOnly = null;
+    #preevalResult = null;
+    #processingPromise = null;
+    #resolveProcessing = null;
     #supersededWith = null;
     #transformResultCode = null;
-    constructor(services, parents, initialCode, name, only, exports, evaluatedOnly, loadedAndParsed, resolveTasks = new Map(), dependencies = new Map(), invalidationDependencies = new Map(), invalidateOnDependencyChange = new Set(), generation = 1) {
+    constructor(services, parents, initialCode, name, only, exports, evaluatedOnly, loadedAndParsed, resolveTasks = new Map(), dependencies = new Map(), invalidationDependencies = new Map(), invalidateOnDependencyChange = new Set(), generation = 1, skipCacheInvalidation = false) {
         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.skipCacheInvalidation = skipCacheInvalidation;
         this.loadedAndParsed =
             loadedAndParsed ??
                 services.loadAndParseFn(services, name, initialCode, parents[0]?.log ?? services.log);
-        if (this.loadedAndParsed.code !== undefined) {
+        if (!this.skipCacheInvalidation &&
+            this.loadedAndParsed.code !== undefined) {
             services.cache.invalidateIfChanged(name, this.loadedAndParsed.code, undefined, this.initialCode === undefined ? 'fs' : 'loaded');
         }
         const code = this.loadedAndParsed.evaluator === 'ignored'
@@ -72,24 +79,18 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
     get transformedCode() {
         return (this.#transformResultCode ?? this.supersededWith?.transformedCode ?? null);
     }
-    static createRoot(services, name, only, loadedCode) {
-        const created = Entrypoint.create(services, null, name, only, loadedCode);
-        (0, ts_invariant_1.invariant)(created !== 'loop', 'loop detected');
+    get transformed() {
+        return (this.#hasTransformResult || this.supersededWith?.transformed || false);
+    }
+    get isProcessing() {
+        return this.#isProcessing;
+    }
+    static createRoot(services, name, only, loadedCode, options = {}) {
+        const created = Entrypoint.create(services, null, name, only, loadedCode, options);
+        invariant(created !== 'loop', 'loop detected');
         return created;
     }
-    /**
-     * Creates an entrypoint for the specified file.
-     * If there is already an entrypoint for this file, there will be four possible outcomes:
-     * 1. If `loadedCode` is specified and is different from the one that was used to create the existing entrypoint,
-     *   the existing entrypoint will be superseded by a new one and all cached results for it will be invalidated.
-     *   It can happen if the file was changed and the watcher notified us about it, or we received a new version
-     *   of the file from a loader whereas the previous one was loaded from the filesystem.
-     *   The new entrypoint will be returned.
-     * 2. If `only` is subset of the existing entrypoint's `only`, the existing entrypoint will be returned.
-     * 3. If `only` is superset of the existing entrypoint's `only`, the existing entrypoint will be superseded and the new one will be returned.
-     * 4. If a loop is detected, 'ignored' will be returned, the existing entrypoint will be superseded or not depending on the `only` value.
-     */
-    static create(services, parent, name, only, loadedCode) {
+    static create(services, parent, name, only, loadedCode, options = {}) {
         const { cache, eventEmitter } = services;
         return eventEmitter.perf('createEntrypoint', () => {
             const [status, entrypoint] = Entrypoint.innerCreate(services, parent
@@ -100,14 +101,14 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
                     parents: parent.parents,
                     seqId: parent.seqId,
                 }
-                : null, name, only, loadedCode);
+                : null, name, only, loadedCode, options);
             if (status !== 'cached') {
                 cache.add('entrypoints', name, entrypoint);
             }
             return status === 'loop' ? 'loop' : entrypoint;
         });
     }
-    static innerCreate(services, parent, name, only, loadedCode) {
+    static innerCreate(services, parent, name, only, loadedCode, options) {
         const { cache } = services;
         const cached = cache.get('entrypoints', name);
         let changed = false;
@@ -116,7 +117,7 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
         }
         else if (cached && cached.initialCode === undefined) {
             try {
-                changed = cache.invalidateIfChanged(name, node_fs_1.default.readFileSync((0, parseRequest_1.stripQueryAndHash)(name), 'utf8'), undefined, 'fs');
+                changed = cache.invalidateIfChanged(name, fs.readFileSync(stripQueryAndHash(name), 'utf8'), undefined, 'fs');
             }
             catch {
                 changed = false;
@@ -127,10 +128,28 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
         }
         const exports = cached?.exports;
         const evaluatedOnly = changed ? [] : cached?.evaluatedOnly ?? [];
-        const mergedOnly = cached?.only ? (0, Entrypoint_helpers_1.mergeOnly)(cached.only, only) : [...only];
+        const mergedOnly = options.mergeCachedOnly !== false && cached?.only
+            ? mergeOnly(cached.only, only)
+            : [...only];
+        const reusableEvaluatedState = !changed && cached?.evaluated && cached.loadedAndParsed !== undefined;
+        const canReuseEvaluatedTransformResult = reusableEvaluatedState &&
+            isSuperSet(cached.evaluatedOnly, mergedOnly) &&
+            cached.hasTransformResult &&
+            cached.loadedAndParsed !== undefined;
         if (cached?.evaluated) {
             cached.log('is already evaluated with', cached.evaluatedOnly);
         }
+        if (canReuseEvaluatedTransformResult) {
+            const isLoop = parent && hasLoop(name, parent);
+            const reusedEntrypoint = new Entrypoint(services, parent ? [parent] : [], loadedCode, name, mergedOnly, exports, evaluatedOnly, cached.loadedAndParsed, undefined, cached.dependencies, cached.invalidationDependencies, cached.invalidateOnDependencyChange, cached.generation + 1, true);
+            reusedEntrypoint.reuseTransformResult(cached.transformResultCode, cached.hasWywMetadata);
+            if ('preevalResult' in cached &&
+                cached.preevalResult !== null &&
+                cached.preevalResult !== undefined) {
+                reusedEntrypoint.setPreevalResult(cached.preevalResult);
+            }
+            return [isLoop ? 'loop' : 'cached', reusedEntrypoint];
+        }
         if (!changed && cached && !cached.evaluated) {
             const isLoop = parent && hasLoop(name, parent);
             if (isLoop) {
@@ -139,23 +158,33 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
             if (parent && !cached.parents.map((p) => p.name).includes(parent.name)) {
                 cached.parents.push(parent);
             }
-            if ((0, Entrypoint_helpers_1.isSuperSet)(cached.only, mergedOnly)) {
+            if (isSuperSet(cached.only, mergedOnly)) {
                 cached.log('is cached', name);
                 return [isLoop ? 'loop' : 'cached', cached];
             }
             cached.log('is cached, but with different `only` %o (the cached one %o)', only, cached?.only);
             if (cached.#isProcessing) {
+                if (parent === null) {
+                    cached.log('is being processed during root request, supersede immediately (%o -> %o)', cached.only, mergedOnly);
+                    return [isLoop ? 'loop' : 'created', cached.supersede(mergedOnly)];
+                }
                 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
+        const newEntrypoint = new Entrypoint(services, parent ? [parent] : [], loadedCode, name, mergedOnly, exports, evaluatedOnly, reusableEvaluatedState ? cached.loadedAndParsed : 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 (reusableEvaluatedState &&
+            'preevalResult' in cached &&
+            cached.preevalResult !== null &&
+            cached.preevalResult !== undefined) {
+            newEntrypoint.setPreevalResult(cached.preevalResult);
+        }
         if (cached && !cached.evaluated) {
             cached.log('is cached, but with different code');
             cached.supersede(newEntrypoint);
@@ -171,15 +200,32 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
         this.invalidationDependencies.set(dependency.source, dependency);
     }
     addResolveTask(name, dependency) {
-        this.resolveTasks.set(name, dependency);
+        // Bounded retry of transient null resolutions. The first time a
+        // resolveTask settles to null, evict it from the cache so the next
+        // consumer re-attempts the resolver. After RESOLVE_TASK_MAX_NULL_ATTEMPTS
+        // failures the entry stays cached so we don't thrash. Successful (non-null)
+        // resolutions remain cached normally; this branch only ever fires for null.
+        const tracked = dependency.then((resolved) => {
+            if (resolved.resolved !== null) {
+                return resolved;
+            }
+            const attempts = (this.#resolveTaskNullAttempts.get(name) ?? 0) + 1;
+            this.#resolveTaskNullAttempts.set(name, attempts);
+            if (attempts < Entrypoint.RESOLVE_TASK_MAX_NULL_ATTEMPTS &&
+                this.resolveTasks.get(name) === tracked) {
+                this.resolveTasks.delete(name);
+            }
+            return resolved;
+        });
+        this.resolveTasks.set(name, tracked);
     }
     applyDeferredSupersede() {
         if (this.#supersededWith || this.#pendingOnly === null) {
             return null;
         }
-        const mergedOnly = (0, Entrypoint_helpers_1.mergeOnly)(this.only, this.#pendingOnly);
+        const mergedOnly = mergeOnly(this.only, this.#pendingOnly);
         this.#pendingOnly = null;
-        if ((0, Entrypoint_helpers_1.isSuperSet)(this.only, mergedOnly)) {
+        if (isSuperSet(this.only, mergedOnly)) {
             return null;
         }
         this.log('apply deferred supersede (%o -> %o)', this.only, mergedOnly);
@@ -190,17 +236,22 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
     assertNotSuperseded() {
         if (this.supersededWith) {
             this.log('superseded');
-            throw new AbortError_1.AbortError('superseded');
+            throw new AbortError('superseded');
         }
     }
     assertTransformed() {
         if (this.transformedCode === null) {
             this.log('not transformed');
-            throw new UnprocessedEntrypointError_1.UnprocessedEntrypointError(this.supersededWith ?? this);
+            throw new UnprocessedEntrypointError(this.supersededWith ?? this);
         }
     }
     beginProcessing() {
         this.#isProcessing = true;
+        if (!this.#processingPromise) {
+            this.#processingPromise = new Promise((resolve) => {
+                this.#resolveProcessing = resolve;
+            });
+        }
     }
     createAction(actionType, data, abortSignal = null, actionContext = DEFAULT_ACTION_CONTEXT) {
         if (!this.actionsCache.has(actionType)) {
@@ -215,7 +266,7 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
         if (cached && !cached.abortSignal?.aborted) {
             return cached;
         }
-        const newAction = new BaseAction_1.BaseAction(actionType, this.services, this, data, abortSignal, actionContext);
+        const newAction = new BaseAction(actionType, this.services, this, data, abortSignal, actionContext);
         cache.set(data, newAction);
         this.services.eventEmitter.entrypointEvent(this.seqId, {
             type: 'actionCreated',
@@ -228,18 +279,29 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
         return Entrypoint.create(this.services, this, name, only, loadedCode);
     }
     createEvaluated() {
-        const evaluatedOnly = (0, Entrypoint_helpers_1.mergeOnly)(this.evaluatedOnly, this.only);
+        const evaluatedOnly = 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, this.invalidationDependencies, this.invalidateOnDependencyChange);
+        const evaluated = new 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;
+        evaluated.hasTransformResult = this.#hasTransformResult;
+        evaluated.hasWywMetadata = this.#hasWywMetadata;
+        evaluated.loadedAndParsed = this.loadedAndParsed;
+        evaluated.preevalResult = this.#preevalResult;
+        evaluated.transformResultCode = this.#transformResultCode;
         return evaluated;
     }
     endProcessing() {
         this.#isProcessing = false;
+        this.#resolveProcessing?.();
+        this.#resolveProcessing = null;
+        this.#processingPromise = null;
     }
     getDependency(name) {
         return this.dependencies.get(name);
     }
+    getPreevalResult() {
+        return this.#preevalResult;
+    }
     getInvalidationDependency(name) {
         return this.invalidationDependencies.get(name);
     }
@@ -252,6 +314,14 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
     hasWywMetadata() {
         return this.#hasWywMetadata;
     }
+    waitForProcessing() {
+        return this.#processingPromise ?? Promise.resolve();
+    }
+    reuseTransformResult(code, hasWywMetadata) {
+        this.#hasTransformResult = true;
+        this.#hasWywMetadata = hasWywMetadata;
+        this.#transformResultCode = code;
+    }
     onSupersede(callback) {
         if (this.#supersededWith) {
             callback(this.#supersededWith);
@@ -266,6 +336,7 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
         };
     }
     setTransformResult(res) {
+        this.#hasTransformResult = true;
         this.#hasWywMetadata = Boolean(res?.metadata);
         this.#transformResultCode = res?.code ?? null;
         this.services.eventEmitter.entrypointEvent(this.seqId, {
@@ -273,24 +344,30 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
             type: 'setTransformResult',
         });
     }
+    setPreevalResult(result) {
+        this.#preevalResult = result;
+    }
     deferOnlySupersede(only) {
         this.#pendingOnly = this.#pendingOnly
-            ? (0, Entrypoint_helpers_1.mergeOnly)(this.#pendingOnly, only)
+            ? 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.invalidationDependencies, this.invalidateOnDependencyChange, this.generation + 1);
+        const widensOnly = !(newOnlyOrEntrypoint instanceof Entrypoint);
+        const newEntrypoint = widensOnly
+            ? 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)
+            : newOnlyOrEntrypoint;
         this.services.eventEmitter.entrypointEvent(this.seqId, {
             type: 'superseded',
             with: newEntrypoint.seqId,
         });
         this.log('superseded by %s (%o -> %o)', newEntrypoint.name, this.only, newEntrypoint.only);
+        if (widensOnly) {
+            newEntrypoint.#preevalResult = this.#preevalResult;
+        }
         this.#supersededWith = newEntrypoint;
         this.onSupersedeHandlers.forEach((handler) => handler(newEntrypoint));
         return newEntrypoint;
     }
 }
-exports.Entrypoint = Entrypoint;

package/types/transform/Entrypoint.types.d.ts

@@ -1,15 +1,15 @@
-import type { TransformOptions } from '@babel/core';
-import type { File } from '@babel/types';
-import type { Debugger, Evaluator } from '@wyw-in-js/shared';
+import type { Debugger, Evaluator, TransformEngineOptions } from '@wyw-in-js/shared';
 import type { Services } from './types';
+import type { WYWTransformMetadata } from '../utils/TransformMetadata';
+export type ParsedAst = unknown;
 export interface IEntrypointCode {
-    readonly ast: File;
+    readonly ast: ParsedAst;
     code: string;
-    evalConfig: TransformOptions;
+    evalConfig: TransformEngineOptions;
     evaluator: Evaluator;
 }
 export interface IIgnoredEntrypoint {
-    readonly ast?: File;
+    readonly ast?: ParsedAst;
     readonly code?: string;
     evaluator: 'ignored';
     reason: 'extension' | 'rule';
@@ -19,4 +19,26 @@ export interface IEntrypointDependency {
     resolved: string | null;
     source: string;
 }
+export interface IPreevalResult {
+    ast: ParsedAst | null;
+    baseCode?: string;
+    code: string;
+    dependencyNames?: string[];
+    evalCode?: string;
+    metadata: WYWTransformMetadata | null;
+    staticSideEffectImportLocals?: string[];
+    staticDependencies?: string[];
+    staticNullWYWMetaExtendsHelpers?: string[];
+    staticValueCache?: Map<string, unknown>;
+    staticValueCandidates?: Array<{
+        imports: Array<{
+            imported: 'default' | string;
+            importLocal?: string;
+            local: string;
+            source: string;
+        }>;
+        name: string;
+        source: string;
+    }>;
+}
 export type LoadAndParseFn = (services: Services, name: string, loadedCode: string | undefined, log: Debugger) => IEntrypointCode | IIgnoredEntrypoint;

package/types/transform/Entrypoint.types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/types/transform/EvaluatedEntrypoint.d.ts

@@ -1,21 +1,32 @@
 import type { Debugger } from '@wyw-in-js/shared';
 import { BaseEntrypoint } from './BaseEntrypoint';
-import type { IEntrypointDependency } from './Entrypoint.types';
-export interface IEvaluatedEntrypoint {
+import type { IEntrypointCode, IIgnoredEntrypoint, IEntrypointDependency, IPreevalResult } from './Entrypoint.types';
+import type { ParentEntrypoint } from '../types';
+export interface IEvaluatedEntrypoint extends ParentEntrypoint {
     dependencies: Map<string, IEntrypointDependency>;
     evaluated: true;
     evaluatedOnly: string[];
     exports: Record<string | symbol, unknown>;
     generation: number;
+    hasTransformResult: boolean;
+    hasWywMetadata: boolean;
     ignored: false;
     initialCode?: string;
     invalidationDependencies: Map<string, IEntrypointDependency>;
     invalidateOnDependencyChange: Set<string>;
+    loadedAndParsed?: IEntrypointCode | IIgnoredEntrypoint;
     log: Debugger;
     only: string[];
+    preevalResult: IPreevalResult | null;
+    transformResultCode: string | null;
 }
 export declare class EvaluatedEntrypoint extends BaseEntrypoint implements IEvaluatedEntrypoint {
     readonly evaluated = true;
     readonly ignored = false;
+    hasTransformResult: boolean;
+    hasWywMetadata: boolean;
     initialCode?: string;
+    loadedAndParsed?: IEntrypointCode | IIgnoredEntrypoint;
+    preevalResult: IPreevalResult | null;
+    transformResultCode: string | null;
 }

package/types/transform/EvaluatedEntrypoint.js

@@ -1,10 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EvaluatedEntrypoint = void 0;
-const BaseEntrypoint_1 = require("./BaseEntrypoint");
-class EvaluatedEntrypoint extends BaseEntrypoint_1.BaseEntrypoint {
+import { BaseEntrypoint } from './BaseEntrypoint';
+export class EvaluatedEntrypoint extends BaseEntrypoint {
     evaluated = true;
     ignored = false;
+    hasTransformResult = false;
+    hasWywMetadata = false;
     initialCode;
+    loadedAndParsed;
+    preevalResult = null;
+    transformResultCode = null;
 }
-exports.EvaluatedEntrypoint = EvaluatedEntrypoint;

package/types/transform/actions/AbortError.js

@@ -1,12 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAborted = exports.AbortError = void 0;
-class AbortError extends Error {
+export class AbortError extends Error {
     constructor(reason) {
         super(reason);
         this.name = 'AbortError';
     }
 }
-exports.AbortError = AbortError;
-const isAborted = (value) => value instanceof AbortError;
-exports.isAborted = isAborted;
+export const isAborted = (value) => value instanceof AbortError;

package/types/transform/actions/BaseAction.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseAction = void 0;
 /* eslint-disable no-plusplus */
-require("../../utils/dispose-polyfill");
-const types_1 = require("../types");
+import '../../utils/dispose-polyfill';
+import { Pending } from '../types';
 let actionIdx = 0;
-class BaseAction {
+export class BaseAction {
     type;
     services;
     entrypoint;
@@ -13,7 +10,7 @@ class BaseAction {
     abortSignal;
     actionContext;
     idx;
-    result = types_1.Pending;
+    result = Pending;
     activeScenario = null;
     activeScenarioError;
     activeScenarioNextResults = [];
@@ -153,4 +150,3 @@ class BaseAction {
         throw this.activeScenarioError;
     }
 }
-exports.BaseAction = BaseAction;

package/types/transform/actions/UnprocessedEntrypointError.js

@@ -1,13 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUnprocessedEntrypointError = exports.UnprocessedEntrypointError = void 0;
-class UnprocessedEntrypointError extends Error {
+export class UnprocessedEntrypointError extends Error {
     entrypoint;
     constructor(entrypoint) {
         super(`Entrypoint ${entrypoint.idx} is not processed and can't be evaluated`);
         this.entrypoint = entrypoint;
     }
 }
-exports.UnprocessedEntrypointError = UnprocessedEntrypointError;
-const isUnprocessedEntrypointError = (value) => value instanceof UnprocessedEntrypointError;
-exports.isUnprocessedEntrypointError = isUnprocessedEntrypointError;
+export const isUnprocessedEntrypointError = (value) => value instanceof UnprocessedEntrypointError;

package/types/transform/actions/actionRunner.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asyncActionRunner = asyncActionRunner;
-exports.syncActionRunner = syncActionRunner;
-const types_1 = require("../types");
-const AbortError_1 = require("./AbortError");
+import { Pending } from '../types';
+import { AbortError } from './AbortError';
 function getHandler(action, actionHandlers) {
     const handler = actionHandlers[action.type];
     if (!handler) {
@@ -15,8 +11,8 @@ function getHandler(action, actionHandlers) {
 const getActionRef = (type, entrypoint) => `${type}@${entrypoint.ref}`;
 const ACTION_ERROR = Symbol('ACTION_ERROR');
 const isActionError = (e) => Array.isArray(e) && e[0] === ACTION_ERROR;
-async function asyncActionRunner(action, actionHandlers, stack = [getActionRef(action.type, action.entrypoint)]) {
-    if (action.result !== types_1.Pending) {
+export async function asyncActionRunner(action, actionHandlers, stack = [getActionRef(action.type, action.entrypoint)]) {
+    if (action.result !== Pending) {
         action.log('result is cached');
         return action.result;
     }
@@ -27,7 +23,7 @@ async function asyncActionRunner(action, actionHandlers, stack = [getActionRef(a
     while (true) {
         if (action.abortSignal?.aborted) {
             action.log('action is aborted');
-            generator.throw(new AbortError_1.AbortError(stack[0]));
+            generator.throw(new AbortError(stack[0]));
         }
         const result = await (isActionError(actionResult)
             ? generator.throw(actionResult[1])
@@ -49,8 +45,8 @@ async function asyncActionRunner(action, actionHandlers, stack = [getActionRef(a
         }
     }
 }
-function syncActionRunner(action, actionHandlers, stack = [getActionRef(action.type, action.entrypoint)]) {
-    if (action.result !== types_1.Pending) {
+export function syncActionRunner(action, actionHandlers, stack = [getActionRef(action.type, action.entrypoint)]) {
+    if (action.result !== Pending) {
         action.log('result is cached');
         return action.result;
     }
@@ -61,7 +57,7 @@ function syncActionRunner(action, actionHandlers, stack = [getActionRef(action.t
     while (true) {
         if (action.abortSignal?.aborted) {
             action.log('action is aborted');
-            generator.throw(new AbortError_1.AbortError(stack[0]));
+            generator.throw(new AbortError(stack[0]));
         }
         const result = isActionError(actionResult)
             ? generator.throw(actionResult[1])

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

@@ -1,5 +1,5 @@
-import type { BabelFileResult } from '@babel/core';
 import type { Replacements, Rules } from '@wyw-in-js/shared';
+import type { RawSourceMap } from 'source-map';
 import type { WYWTransformDiagnostic } from '../../utils/TransformDiagnostics';
 import type { WYWTransformResultMetadata } from '../../utils/TransformMetadata';
 export interface IExtracted {
@@ -10,7 +10,7 @@ export interface IExtracted {
 }
 export interface IWorkflowActionNonLinariaResult {
     code: string;
-    sourceMap: BabelFileResult['map'];
+    sourceMap: RawSourceMap | null | undefined;
 }
 export interface IWorkflowActionLinariaResult extends IExtracted, IWorkflowActionNonLinariaResult {
     dependencies: string[];

package/types/transform/actions/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/types/transform/{barrelManifest.d.ts → barrelManifest.types.d.ts}

@@ -1,4 +1,3 @@
-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 = {
@@ -39,4 +38,3 @@ export type RawBarrelManifest = {
     kind: 'barrel';
     reexports: RawBarrelReexport[];
 };
-export declare function analyzeBarrelFile(ast: File): BarrelManifestCacheEntry | RawBarrelManifest;

package/types/transform/barrelManifest.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,17 +1,16 @@
-import type { SyncScenarioForAction, ICollectAction, IEvalAction, IExtractAction, IWorkflowAction } from '../types';
-import { explodeReexports } from './explodeReexports';
+import type { SyncScenarioForAction, ICollectAction, IEvalAction, IExplodeReexportsAction, IExtractAction, IWorkflowAction } from '../types';
 import { getExports } from './getExports';
-import { processEntrypoint } from './processEntrypoint';
+import { processEntrypointAsync } from './processEntrypoint';
 import { processImports } from './processImports';
 import { transform } from './transform';
 export declare const baseProcessingHandlers: {
     collect: (this: ICollectAction) => SyncScenarioForAction<ICollectAction>;
     evalFile: (this: IEvalAction) => SyncScenarioForAction<IEvalAction>;
+    explodeReexports: (this: IExplodeReexportsAction) => SyncScenarioForAction<IExplodeReexportsAction>;
     extract: (this: IExtractAction) => SyncScenarioForAction<IExtractAction>;
     workflow: (this: IWorkflowAction) => SyncScenarioForAction<IWorkflowAction>;
-    explodeReexports: typeof explodeReexports;
     getExports: typeof getExports;
-    processEntrypoint: typeof processEntrypoint;
+    processEntrypoint: typeof processEntrypointAsync;
     processImports: typeof processImports;
     transform: typeof transform;
 };