@wyw-in-js/transform 0.1.0

package/types/transform/Entrypoint.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entrypoint = void 0;
+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 EMPTY_FILE = '=== empty file ===';
+function hasLoop(name, parent, processed = []) {
+    if (parent.name === name || processed.includes(parent.name)) {
+        return true;
+    }
+    for (const p of parent.parents) {
+        const found = hasLoop(name, p, [...processed, parent.name]);
+        if (found) {
+            return found;
+        }
+    }
+    return false;
+}
+class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
+    initialCode;
+    resolveTasks;
+    dependencies;
+    evaluated = false;
+    loadedAndParsed;
+    onSupersedeHandlers = [];
+    actionsCache = new Map();
+    #hasLinariaMetadata = false;
+    #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);
+        this.initialCode = initialCode;
+        this.resolveTasks = resolveTasks;
+        this.dependencies = dependencies;
+        this.loadedAndParsed =
+            loadedAndParsed ??
+                services.loadAndParseFn(services, name, initialCode, parents[0]?.log ?? services.log);
+        if (this.loadedAndParsed.code !== undefined) {
+            services.cache.invalidateIfChanged(name, this.loadedAndParsed.code);
+        }
+        this.log.extend('source')('created %s (%o)\n%s', name, only, this.originalCode || EMPTY_FILE);
+    }
+    get ignored() {
+        return this.loadedAndParsed.evaluator === 'ignored';
+    }
+    get originalCode() {
+        return this.loadedAndParsed.code;
+    }
+    get supersededWith() {
+        return this.#supersededWith?.supersededWith ?? this.#supersededWith;
+    }
+    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');
+        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) {
+        const { cache, eventEmitter } = services;
+        return eventEmitter.perf('createEntrypoint', () => {
+            const [status, entrypoint] = Entrypoint.innerCreate(services, parent
+                ? {
+                    evaluated: parent.evaluated,
+                    log: parent.log,
+                    name: parent.name,
+                    parents: parent.parents,
+                    seqId: parent.seqId,
+                }
+                : null, name, only, loadedCode);
+            if (status !== 'cached') {
+                cache.add('entrypoints', name, entrypoint);
+            }
+            return status === 'loop' ? 'loop' : entrypoint;
+        });
+    }
+    static innerCreate(services, parent, name, only, loadedCode) {
+        const { cache } = services;
+        const cached = cache.get('entrypoints', name);
+        const changed = loadedCode !== undefined
+            ? cache.invalidateIfChanged(name, loadedCode)
+            : false;
+        if (!cached?.evaluated && cached?.ignored) {
+            return ['cached', cached];
+        }
+        const exports = cached?.exports;
+        const evaluatedOnly = cached?.evaluatedOnly ?? [];
+        const mergedOnly = !changed && cached?.only
+            ? (0, Entrypoint_helpers_1.mergeOnly)(cached.only, only).filter((i) => !evaluatedOnly.includes(i))
+            : only;
+        if (cached?.evaluated) {
+            cached.log('is already evaluated with', cached.evaluatedOnly);
+        }
+        if (!changed && cached && !cached.evaluated) {
+            const isLoop = parent && hasLoop(name, parent);
+            if (isLoop) {
+                parent.log('[createEntrypoint] %s is a loop', name);
+            }
+            if (parent && !cached.parents.map((p) => p.name).includes(parent.name)) {
+                cached.parents.push(parent);
+            }
+            if ((0, Entrypoint_helpers_1.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);
+            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 (cached && !cached.evaluated) {
+            cached.log('is cached, but with different code');
+            cached.supersede(newEntrypoint);
+        }
+        return ['created', newEntrypoint];
+    }
+    addDependency(dependency) {
+        this.resolveTasks.delete(dependency.source);
+        this.dependencies.set(dependency.source, dependency);
+    }
+    addResolveTask(name, dependency) {
+        this.resolveTasks.set(name, dependency);
+    }
+    assertNotSuperseded() {
+        if (this.supersededWith) {
+            this.log('superseded');
+            throw new AbortError_1.AbortError('superseded');
+        }
+    }
+    assertTransformed() {
+        if (this.transformedCode === null) {
+            this.log('not transformed');
+            throw new UnprocessedEntrypointError_1.UnprocessedEntrypointError(this.supersededWith ?? this);
+        }
+    }
+    createAction(actionType, data, abortSignal = null) {
+        if (!this.actionsCache.has(actionType)) {
+            this.actionsCache.set(actionType, new Map());
+        }
+        const cache = this.actionsCache.get(actionType);
+        const cached = cache.get(data);
+        if (cached && !cached.abortSignal?.aborted) {
+            return cached;
+        }
+        const newAction = new BaseAction_1.BaseAction(actionType, this.services, this, data, abortSignal);
+        cache.set(data, newAction);
+        this.services.eventEmitter.entrypointEvent(this.seqId, {
+            type: 'actionCreated',
+            actionType,
+            actionIdx: newAction.idx,
+        });
+        return newAction;
+    }
+    createChild(name, only, loadedCode) {
+        return Entrypoint.create(this.services, this, name, only, loadedCode);
+    }
+    createEvaluated() {
+        const evaluatedOnly = (0, Entrypoint_helpers_1.mergeOnly)(this.evaluatedOnly, this.only);
+        this.log('create EvaluatedEntrypoint for %o', evaluatedOnly);
+        return new EvaluatedEntrypoint_1.EvaluatedEntrypoint(this.services, evaluatedOnly, this.exportsProxy, this.generation + 1, this.name, this.only, this.parents);
+    }
+    getDependency(name) {
+        return this.dependencies.get(name);
+    }
+    getResolveTask(name) {
+        return this.resolveTasks.get(name);
+    }
+    hasLinariaMetadata() {
+        return this.#hasLinariaMetadata;
+    }
+    onSupersede(callback) {
+        if (this.#supersededWith) {
+            callback(this.#supersededWith);
+            return () => { };
+        }
+        this.onSupersedeHandlers.push(callback);
+        return () => {
+            const index = this.onSupersedeHandlers.indexOf(callback);
+            if (index >= 0) {
+                this.onSupersedeHandlers.splice(index, 1);
+            }
+        };
+    }
+    setTransformResult(res) {
+        this.#hasLinariaMetadata = Boolean(res?.metadata);
+        this.#transformResultCode = res?.code ?? null;
+        this.services.eventEmitter.entrypointEvent(this.seqId, {
+            isNull: res === null,
+            type: 'setTransformResult',
+        });
+    }
+    supersede(newOnlyOrEntrypoint) {
+        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);
+        this.services.eventEmitter.entrypointEvent(this.seqId, {
+            type: 'superseded',
+            with: newEntrypoint.seqId,
+        });
+        this.log('superseded by %s (%o -> %o)', newEntrypoint.name, this.only, newEntrypoint.only);
+        this.#supersededWith = newEntrypoint;
+        this.onSupersedeHandlers.forEach((handler) => handler(newEntrypoint));
+        return newEntrypoint;
+    }
+}
+exports.Entrypoint = Entrypoint;

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

@@ -0,0 +1,23 @@
+/// <reference types="debug" />
+import type { TransformOptions } from '@babel/core';
+import type { File } from '@babel/types';
+import type { Debugger, Evaluator } from '@wyw-in-js/shared';
+import type { Services } from './types';
+export interface IEntrypointCode {
+    readonly ast: File;
+    code: string;
+    evalConfig: TransformOptions;
+    evaluator: Evaluator;
+}
+export interface IIgnoredEntrypoint {
+    readonly ast?: File;
+    readonly code?: string;
+    evaluator: 'ignored';
+    reason: 'extension' | 'rule';
+}
+export interface IEntrypointDependency {
+    only: string[];
+    resolved: string | null;
+    source: string;
+}
+export type LoadAndParseFn = (services: Services, name: string, loadedCode: string | undefined, log: Debugger) => IEntrypointCode | IIgnoredEntrypoint;

package/types/transform/Entrypoint.types.js

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

package/types/transform/EvaluatedEntrypoint.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="debug" />
+import type { Debugger } from '@wyw-in-js/shared';
+import { BaseEntrypoint } from './BaseEntrypoint';
+export interface IEvaluatedEntrypoint {
+    evaluated: true;
+    evaluatedOnly: string[];
+    exports: Record<string | symbol, unknown>;
+    generation: number;
+    ignored: false;
+    log: Debugger;
+    only: string[];
+}
+export declare class EvaluatedEntrypoint extends BaseEntrypoint implements IEvaluatedEntrypoint {
+    readonly evaluated = true;
+    readonly ignored = false;
+}

package/types/transform/EvaluatedEntrypoint.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluatedEntrypoint = void 0;
+const BaseEntrypoint_1 = require("./BaseEntrypoint");
+class EvaluatedEntrypoint extends BaseEntrypoint_1.BaseEntrypoint {
+    evaluated = true;
+    ignored = false;
+}
+exports.EvaluatedEntrypoint = EvaluatedEntrypoint;

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

@@ -0,0 +1,4 @@
+export declare class AbortError extends Error {
+    constructor(reason?: string);
+}
+export declare const isAborted: (value: unknown) => value is AbortError;

package/types/transform/actions/AbortError.js

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

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

@@ -0,0 +1,40 @@
+/// <reference types="debug" />
+import '../../utils/dispose-polyfill';
+import type { Debugger } from '@wyw-in-js/shared';
+import type { Entrypoint } from '../Entrypoint';
+import type { ActionQueueItem, ActionTypes, AnyIteratorResult, Handler, IBaseAction, Services, TypeOfResult, YieldResult } from '../types';
+import { Pending } from '../types';
+export type ActionByType<TType extends ActionTypes> = Extract<ActionQueueItem, {
+    type: TType;
+}>;
+type GetBase<TAction extends ActionQueueItem> = IBaseAction<TAction, TypeOfResult<TAction>, TAction['data']>;
+export declare class BaseAction<TAction extends ActionQueueItem> implements GetBase<TAction> {
+    readonly type: TAction['type'];
+    readonly services: Services;
+    readonly entrypoint: Entrypoint;
+    readonly data: TAction['data'];
+    readonly abortSignal: AbortSignal | null;
+    readonly idx: string;
+    result: TypeOfResult<TAction> | typeof Pending;
+    private activeScenario;
+    private activeScenarioError?;
+    private activeScenarioNextResults;
+    constructor(type: TAction['type'], services: Services, entrypoint: Entrypoint, data: TAction['data'], abortSignal: AbortSignal | null);
+    get log(): Debugger;
+    get ref(): string;
+    createAbortSignal(): AbortSignal & Disposable;
+    getNext<TNextType extends ActionTypes, TNextAction extends ActionByType<TNextType> = ActionByType<TNextType>>(type: TNextType, entrypoint: Entrypoint, data: TNextAction['data'], abortSignal?: AbortSignal | null): Generator<[
+        TNextType,
+        Entrypoint,
+        TNextAction['data'],
+        AbortSignal | null
+    ], TypeOfResult<TNextAction>, YieldResult>;
+    onAbort(fn: () => void): () => void;
+    run<TMode extends 'async' | 'sync', THandler extends Handler<TMode, TAction> = Handler<TMode, TAction>>(handler: THandler): {
+        next: (arg: YieldResult) => AnyIteratorResult<TMode, TypeOfResult<TAction>>;
+        throw: (e: unknown) => AnyIteratorResult<TMode, TypeOfResult<TAction>>;
+    };
+    protected emitAction<TRes>(yieldIdx: number, fn: () => TRes): TRes;
+    private rethrowActiveScenarioError;
+}
+export {};

package/types/transform/actions/BaseAction.js

@@ -0,0 +1,149 @@
+"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");
+let actionIdx = 0;
+class BaseAction {
+    type;
+    services;
+    entrypoint;
+    data;
+    abortSignal;
+    idx;
+    result = types_1.Pending;
+    activeScenario = null;
+    activeScenarioError;
+    activeScenarioNextResults = [];
+    constructor(type, services, entrypoint, data, abortSignal) {
+        this.type = type;
+        this.services = services;
+        this.entrypoint = entrypoint;
+        this.data = data;
+        this.abortSignal = abortSignal;
+        actionIdx += 1;
+        this.idx = actionIdx.toString(16).padStart(6, '0');
+    }
+    get log() {
+        return this.entrypoint.log.extend(this.ref);
+    }
+    get ref() {
+        return `${this.type}@${this.idx}`;
+    }
+    createAbortSignal() {
+        const abortController = new AbortController();
+        const unsubscribeFromParentAbort = this.onAbort(() => {
+            this.entrypoint.log('parent aborted');
+            abortController.abort();
+        });
+        const unsubscribeFromSupersede = this.entrypoint.onSupersede(() => {
+            this.entrypoint.log('entrypoint superseded, aborting processing');
+            abortController.abort();
+        });
+        const abortSignal = abortController.signal;
+        abortSignal[Symbol.dispose] = () => {
+            unsubscribeFromParentAbort();
+            unsubscribeFromSupersede();
+        };
+        return abortSignal;
+    }
+    *getNext(type, entrypoint, data, abortSignal = this.abortSignal) {
+        return (yield [
+            type,
+            entrypoint,
+            data,
+            abortSignal,
+        ]);
+    }
+    onAbort(fn) {
+        this.abortSignal?.addEventListener('abort', fn);
+        return () => {
+            this.abortSignal?.removeEventListener('abort', fn);
+        };
+    }
+    run(handler) {
+        if (!this.activeScenario) {
+            this.activeScenario = handler.call(this);
+            this.activeScenarioNextResults = [];
+        }
+        let nextIdx = 0;
+        const throwFn = (e) => this.emitAction(nextIdx, () => this.activeScenario.throw(e));
+        const nextFn = (arg) => this.emitAction(nextIdx, () => this.activeScenario.next(arg));
+        const processNextResult = (result, onError) => {
+            if ('then' in result) {
+                result.then((r) => {
+                    if (r.done) {
+                        this.result = r.value;
+                    }
+                }, onError);
+            }
+            else if (result.done) {
+                this.result = result.value;
+            }
+            this.activeScenarioNextResults.push(result);
+        };
+        const processError = (e) => {
+            if (this.activeScenarioNextResults.length > nextIdx) {
+                this.log('error was already handled in another branch, result idx is %d', nextIdx);
+                return;
+            }
+            this.log('error processing, result idx is %d', nextIdx);
+            try {
+                const nextResult = throwFn(e);
+                processNextResult(nextResult, processError);
+            }
+            catch (errorInGenerator) {
+                const { recover } = handler;
+                if (recover) {
+                    const nextResult = {
+                        done: false,
+                        value: recover(errorInGenerator, this),
+                    };
+                    processNextResult(nextResult, processError);
+                    return;
+                }
+                this.activeScenarioError = errorInGenerator;
+                throw errorInGenerator;
+            }
+        };
+        const processNext = (arg) => {
+            if (this.activeScenarioNextResults.length > nextIdx) {
+                this.log('next was already handled in another branch, result idx is %d', nextIdx);
+                return;
+            }
+            this.log('next processing, result idx is %d', nextIdx);
+            try {
+                const nextResult = nextFn(arg);
+                processNextResult(nextResult, processError);
+            }
+            catch (e) {
+                processError(e);
+            }
+        };
+        return {
+            next: (arg) => {
+                this.rethrowActiveScenarioError();
+                processNext(arg);
+                return this.activeScenarioNextResults[nextIdx++];
+            },
+            throw: (e) => {
+                this.rethrowActiveScenarioError();
+                processError(e);
+                return this.activeScenarioNextResults[nextIdx++];
+            },
+        };
+    }
+    emitAction(yieldIdx, fn) {
+        return this.services.eventEmitter.action(this.type, `${this.idx}:${yieldIdx + 1}`, this.entrypoint.ref, fn);
+    }
+    rethrowActiveScenarioError() {
+        if (!this.activeScenarioError) {
+            return;
+        }
+        this.log('scenario has an unhandled error from another branch, rethrow %o', this.activeScenarioError);
+        // eslint-disable-next-line @typescript-eslint/no-throw-literal
+        throw this.activeScenarioError;
+    }
+}
+exports.BaseAction = BaseAction;

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

@@ -0,0 +1,6 @@
+import type { Entrypoint } from '../Entrypoint';
+export declare class UnprocessedEntrypointError extends Error {
+    entrypoint: Entrypoint;
+    constructor(entrypoint: Entrypoint);
+}
+export declare const isUnprocessedEntrypointError: (value: unknown) => value is UnprocessedEntrypointError;

package/types/transform/actions/UnprocessedEntrypointError.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUnprocessedEntrypointError = exports.UnprocessedEntrypointError = void 0;
+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;

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

@@ -0,0 +1,4 @@
+import type { ActionQueueItem, Handlers, TypeOfResult } from '../types';
+import type { BaseAction } from './BaseAction';
+export declare function asyncActionRunner<TAction extends ActionQueueItem>(action: BaseAction<TAction>, actionHandlers: Handlers<'async' | 'sync'>, stack?: string[]): Promise<TypeOfResult<TAction>>;
+export declare function syncActionRunner<TAction extends ActionQueueItem>(action: BaseAction<TAction>, actionHandlers: Handlers<'sync'>, stack?: string[]): TypeOfResult<TAction>;

package/types/transform/actions/actionRunner.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncActionRunner = exports.asyncActionRunner = void 0;
+const types_1 = require("../types");
+const AbortError_1 = require("./AbortError");
+function getHandler(action, actionHandlers) {
+    const handler = actionHandlers[action.type];
+    if (!handler) {
+        throw new Error(`No handler for action ${action.type}`);
+    }
+    // FIXME Handlers<TMode>[TAction['type']] is not assignable to Handler<TMode, TAction>
+    return handler;
+}
+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) {
+        action.log('result is cached');
+        return action.result;
+    }
+    const handler = getHandler(action, actionHandlers);
+    const generator = action.run(handler);
+    let actionResult;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        if (action.abortSignal?.aborted) {
+            action.log('action is aborted');
+            generator.throw(new AbortError_1.AbortError(stack[0]));
+        }
+        const result = await (isActionError(actionResult)
+            ? generator.throw(actionResult[1])
+            : generator.next(actionResult));
+        if (result.done) {
+            return result.value;
+        }
+        const [type, entrypoint, data, abortSignal] = result.value;
+        const nextAction = entrypoint.createAction(type, data, abortSignal);
+        try {
+            actionResult = await asyncActionRunner(nextAction, actionHandlers, [
+                ...stack,
+                getActionRef(type, entrypoint),
+            ]);
+        }
+        catch (e) {
+            nextAction.log('error', e);
+            actionResult = [ACTION_ERROR, e];
+        }
+    }
+}
+exports.asyncActionRunner = asyncActionRunner;
+function syncActionRunner(action, actionHandlers, stack = [getActionRef(action.type, action.entrypoint)]) {
+    if (action.result !== types_1.Pending) {
+        action.log('result is cached');
+        return action.result;
+    }
+    const handler = getHandler(action, actionHandlers);
+    const generator = action.run(handler);
+    let actionResult;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        if (action.abortSignal?.aborted) {
+            action.log('action is aborted');
+            generator.throw(new AbortError_1.AbortError(stack[0]));
+        }
+        const result = isActionError(actionResult)
+            ? generator.throw(actionResult[1])
+            : generator.next(actionResult);
+        if (result.done) {
+            return result.value;
+        }
+        const [type, entrypoint, data, abortSignal] = result.value;
+        const nextAction = entrypoint.createAction(type, data, abortSignal);
+        try {
+            actionResult = syncActionRunner(nextAction, actionHandlers, [
+                ...stack,
+                getActionRef(type, entrypoint),
+            ]);
+        }
+        catch (e) {
+            nextAction.log('error', e);
+            actionResult = [ACTION_ERROR, e];
+        }
+    }
+}
+exports.syncActionRunner = syncActionRunner;

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

@@ -0,0 +1,15 @@
+import type { BabelFileResult } from '@babel/core';
+import type { Replacements, Rules } from '@wyw-in-js/shared';
+export interface IExtracted {
+    cssSourceMapText: string;
+    cssText: string;
+    replacements: Replacements;
+    rules: Rules;
+}
+export interface IWorkflowActionNonLinariaResult {
+    code: string;
+    sourceMap: BabelFileResult['map'];
+}
+export interface IWorkflowActionLinariaResult extends IExtracted, IWorkflowActionNonLinariaResult {
+    dependencies: string[];
+}

package/types/transform/actions/types.js

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

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

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

package/types/transform/generators/baseProcessingHandlers.js

@@ -0,0 +1,23 @@
+"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");
+// eslint-disable-next-line require-yield
+function* emptyHandler() {
+    throw new Error(`Handler for ${this.type} is not implemented`);
+}
+exports.baseProcessingHandlers = {
+    collect: (emptyHandler),
+    evalFile: (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,
+};