@wyw-in-js/transform 0.1.0

package/types/transform/generators/resolveImports.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncResolveImports = exports.syncResolveImports = void 0;
+/* eslint-disable no-continue,no-await-in-loop,require-yield */
+const getFileIdx_1 = require("../../utils/getFileIdx");
+const Entrypoint_helpers_1 = require("../Entrypoint.helpers");
+function emitDependency(emitter, entrypoint, imports) {
+    emitter.single({
+        type: 'dependency',
+        file: entrypoint.name,
+        only: entrypoint.only,
+        imports: imports.map(({ resolved, only }) => ({
+            from: resolved,
+            what: only,
+        })),
+        fileIdx: (0, getFileIdx_1.getFileIdx)(entrypoint.name),
+    });
+}
+function filterUnresolved(entrypoint, resolvedImports) {
+    return resolvedImports.filter((i) => {
+        if (i.resolved === null) {
+            entrypoint.log(`[resolve] ✅ %s in %s is ignored`, i.source, entrypoint.name);
+            return false;
+        }
+        return true;
+    });
+}
+/**
+ * Synchronously resolves specified imports with a provided resolver.
+ */
+function* syncResolveImports(resolve) {
+    const { data: { imports }, entrypoint, services: { eventEmitter }, } = this;
+    const listOfImports = Array.from(imports?.entries() ?? []);
+    const { log } = entrypoint;
+    if (listOfImports.length === 0) {
+        emitDependency(eventEmitter, entrypoint, []);
+        log('%s has no imports', entrypoint.name);
+        return [];
+    }
+    const resolvedImports = listOfImports.map(([source, only]) => {
+        let resolved = null;
+        try {
+            resolved = resolve(source, entrypoint.name, (0, Entrypoint_helpers_1.getStack)(entrypoint));
+            log('[sync-resolve] ✅ %s -> %s (only: %o)', source, resolved, only);
+        }
+        catch (err) {
+            log('[sync-resolve] ❌ cannot resolve %s: %O', source, err);
+        }
+        return {
+            source,
+            only,
+            resolved,
+        };
+    });
+    const filteredImports = filterUnresolved(entrypoint, resolvedImports);
+    emitDependency(eventEmitter, entrypoint, filteredImports);
+    return filteredImports;
+}
+exports.syncResolveImports = syncResolveImports;
+/**
+ * Asynchronously resolves specified imports with a provided resolver.
+ */
+async function* asyncResolveImports(resolve) {
+    const { data: { imports }, entrypoint, services: { eventEmitter }, } = this;
+    const listOfImports = Array.from(imports?.entries() ?? []);
+    const { log } = entrypoint;
+    if (listOfImports.length === 0) {
+        emitDependency(eventEmitter, entrypoint, []);
+        log('%s has no imports', entrypoint.name);
+        return [];
+    }
+    log('resolving %d imports', listOfImports.length);
+    const getResolveTask = async (source, only) => {
+        let resolved = null;
+        try {
+            resolved = await resolve(source, entrypoint.name, (0, Entrypoint_helpers_1.getStack)(entrypoint));
+        }
+        catch (err) {
+            log('[async-resolve] ❌ cannot resolve %s in %s: %O', source, entrypoint.name, err);
+        }
+        if (resolved !== null) {
+            log('[async-resolve] ✅ %s (%o) in %s -> %s', source, only, entrypoint.name, resolved);
+        }
+        return {
+            source,
+            only,
+            resolved,
+        };
+    };
+    const resolvedImports = await Promise.all(listOfImports.map(([source, importsOnly]) => {
+        const cached = entrypoint.getDependency(source);
+        if (cached) {
+            return {
+                source,
+                only: (0, Entrypoint_helpers_1.mergeOnly)(cached.only, importsOnly),
+                resolved: cached.resolved,
+            };
+        }
+        const task = entrypoint.getResolveTask(source);
+        if (task) {
+            // If we have cached task, we need to merge only…
+            const newTask = task.then((res) => {
+                if ((0, Entrypoint_helpers_1.isSuperSet)(res.only, importsOnly)) {
+                    return res;
+                }
+                // Is this branch even possible?
+                const merged = (0, Entrypoint_helpers_1.mergeOnly)(res.only, importsOnly);
+                log('merging imports %o and %o: %o', importsOnly, res.only, merged);
+                return { ...res, only: merged };
+            });
+            // … and update the cache
+            entrypoint.addResolveTask(source, newTask);
+            return newTask;
+        }
+        const resolveTask = getResolveTask(source, importsOnly);
+        entrypoint.addResolveTask(source, resolveTask);
+        return resolveTask;
+    }));
+    log('resolved %d imports', resolvedImports.length);
+    const filteredImports = filterUnresolved(entrypoint, resolvedImports);
+    emitDependency(eventEmitter, entrypoint, filteredImports);
+    return filteredImports;
+}
+exports.asyncResolveImports = asyncResolveImports;

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

@@ -0,0 +1,17 @@
+import type { File } from '@babel/types';
+import type { WYWTransformMetadata } from '../../utils/TransformMetadata';
+import type { Entrypoint } from '../Entrypoint';
+import type { ITransformAction, Services, SyncScenarioForAction } from '../types';
+type PrepareCodeFn = (services: Services, item: Entrypoint, originalAst: File) => [
+    code: string,
+    imports: Map<string, string[]> | null,
+    metadata: WYWTransformMetadata | null
+];
+export declare const prepareCode: (services: Services, item: Entrypoint, originalAst: File) => [code: string, imports: Map<string, string[]> | null, metadata: WYWTransformMetadata | null];
+export declare function internalTransform(this: ITransformAction, prepareFn: PrepareCodeFn): SyncScenarioForAction<ITransformAction>;
+/**
+ * Prepares the code for evaluation. This includes removing dead and potentially unsafe code.
+ * Emits resolveImports and processImports events.
+ */
+export declare function transform(this: ITransformAction): SyncScenarioForAction<ITransformAction>;
+export {};

package/types/transform/generators/transform.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = exports.internalTransform = exports.prepareCode = void 0;
+const buildOptions_1 = require("../../options/buildOptions");
+const TransformMetadata_1 = require("../../utils/TransformMetadata");
+const getPluginKey_1 = require("../../utils/getPluginKey");
+const EMPTY_FILE = '=== empty file ===';
+const hasKeyInList = (plugin, list) => {
+    const pluginKey = (0, getPluginKey_1.getPluginKey)(plugin);
+    return pluginKey ? list.some((i) => pluginKey.includes(i)) : false;
+};
+function runPreevalStage(babel, evalConfig, pluginOptions, code, originalAst, eventEmitter) {
+    const preShakePlugins = evalConfig.plugins?.filter((i) => hasKeyInList(i, pluginOptions.highPriorityPlugins)) ?? [];
+    const plugins = [
+        ...preShakePlugins,
+        [
+            require.resolve('../../plugins/preeval'),
+            { ...pluginOptions, eventEmitter },
+        ],
+        [require.resolve('../../plugins/dynamic-import')],
+        ...(evalConfig.plugins ?? []).filter((i) => !hasKeyInList(i, pluginOptions.highPriorityPlugins)),
+    ];
+    const transformConfig = (0, buildOptions_1.buildOptions)({
+        ...evalConfig,
+        envName: 'linaria',
+        plugins,
+    });
+    const result = babel.transformFromAstSync(originalAst, code, transformConfig);
+    if (!result || !result.ast?.program) {
+        throw new Error('Babel transform failed');
+    }
+    return result;
+}
+const prepareCode = (services, item, originalAst) => {
+    const { log, only, loadedAndParsed } = item;
+    if (loadedAndParsed.evaluator === 'ignored') {
+        log('is ignored');
+        return [loadedAndParsed.code ?? '', null, null];
+    }
+    const { code, evalConfig, evaluator } = loadedAndParsed;
+    const { options, babel, eventEmitter } = services;
+    const { pluginOptions } = options;
+    const preevalStageResult = eventEmitter.perf('transform:preeval', () => runPreevalStage(babel, evalConfig, pluginOptions, code, originalAst, eventEmitter));
+    const transformMetadata = (0, TransformMetadata_1.getTransformMetadata)(preevalStageResult.metadata);
+    if (only.length === 1 &&
+        only[0] === '__linariaPreval' &&
+        !transformMetadata) {
+        log('[evaluator:end] no metadata');
+        return [preevalStageResult.code, null, null];
+    }
+    log('[preeval] metadata %O', transformMetadata);
+    log('[evaluator:start] using %s', evaluator.name);
+    const evaluatorConfig = {
+        onlyExports: only,
+        highPriorityPlugins: pluginOptions.highPriorityPlugins,
+        features: pluginOptions.features,
+    };
+    const [, transformedCode, imports] = eventEmitter.perf('transform:evaluator', () => evaluator(evalConfig, preevalStageResult.ast, preevalStageResult.code, evaluatorConfig, babel));
+    log('[evaluator:end]');
+    return [transformedCode, imports, transformMetadata ?? null];
+};
+exports.prepareCode = prepareCode;
+function* internalTransform(prepareFn) {
+    const { only, loadedAndParsed, log } = this.entrypoint;
+    if (loadedAndParsed.evaluator === 'ignored') {
+        log('is ignored');
+        return {
+            code: loadedAndParsed.code ?? '',
+            metadata: null,
+        };
+    }
+    log('>> (%o)', only);
+    const [preparedCode, imports, metadata] = prepareFn(this.services, this.entrypoint, loadedAndParsed.ast);
+    if (loadedAndParsed.code === preparedCode) {
+        log('<< (%o)\n === no changes ===', only);
+    }
+    else {
+        log('<< (%o)', only);
+        log.extend('source')('%s', preparedCode || EMPTY_FILE);
+    }
+    if (preparedCode === '') {
+        log('is skipped');
+        return {
+            code: loadedAndParsed.code ?? '',
+            metadata: null,
+        };
+    }
+    if (imports !== null && imports.size > 0) {
+        const resolvedImports = yield* this.getNext('resolveImports', this.entrypoint, {
+            imports,
+        });
+        if (resolvedImports.length !== 0) {
+            yield [
+                'processImports',
+                this.entrypoint,
+                {
+                    resolved: resolvedImports,
+                },
+            ];
+        }
+    }
+    return {
+        code: preparedCode,
+        metadata,
+    };
+}
+exports.internalTransform = internalTransform;
+/**
+ * Prepares the code for evaluation. This includes removing dead and potentially unsafe code.
+ * Emits resolveImports and processImports events.
+ */
+function transform() {
+    return internalTransform.call(this, exports.prepareCode);
+}
+exports.transform = transform;

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

@@ -0,0 +1,7 @@
+import type { IWorkflowAction, SyncScenarioForAction } from '../types';
+/**
+ * The entry point for file processing. Sequentially calls `processEntrypoint`,
+ * `evalFile`, `collect`, and `extract`. Returns the result of transforming
+ * the source code as well as all artifacts obtained from code execution.
+ */
+export declare function workflow(this: IWorkflowAction): SyncScenarioForAction<IWorkflowAction>;

package/types/transform/generators/workflow.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflow = void 0;
+const AbortError_1 = require("../actions/AbortError");
+/**
+ * The entry point for file processing. Sequentially calls `processEntrypoint`,
+ * `evalFile`, `collect`, and `extract`. Returns the result of transforming
+ * the source code as well as all artifacts obtained from code execution.
+ */
+function* workflow() {
+    const { cache, options } = this.services;
+    const { entrypoint } = this;
+    if (entrypoint.ignored) {
+        return {
+            code: entrypoint.loadedAndParsed.code ?? '',
+            sourceMap: options.inputSourceMap,
+        };
+    }
+    try {
+        yield* this.getNext('processEntrypoint', entrypoint, undefined, null);
+        entrypoint.assertNotSuperseded();
+    }
+    catch (e) {
+        if ((0, AbortError_1.isAborted)(e) && entrypoint.supersededWith) {
+            entrypoint.log('workflow aborted, schedule the next attempt');
+            return yield* this.getNext('workflow', entrypoint.supersededWith, undefined, null);
+        }
+        throw e;
+    }
+    const originalCode = entrypoint.loadedAndParsed.code ?? '';
+    // File is ignored or does not contain any tags. Return original code.
+    if (!entrypoint.hasLinariaMetadata()) {
+        if (entrypoint.generation === 1) {
+            // 1st generation here means that it's __linariaPreval entrypoint
+            // without __linariaPreval, so we don't need it cached
+            cache.delete('entrypoints', entrypoint.name);
+        }
+        return {
+            code: originalCode,
+            sourceMap: options.inputSourceMap,
+        };
+    }
+    // *** 2nd stage ***
+    const evalStageResult = yield* this.getNext('evalFile', entrypoint, undefined, null);
+    if (evalStageResult === null) {
+        return {
+            code: originalCode,
+            sourceMap: options.inputSourceMap,
+        };
+    }
+    const [valueCache, dependencies] = evalStageResult;
+    // *** 3rd stage ***
+    const collectStageResult = yield* this.getNext('collect', entrypoint, {
+        valueCache,
+    }, null);
+    if (!collectStageResult.metadata) {
+        return {
+            code: collectStageResult.code,
+            sourceMap: collectStageResult.map,
+        };
+    }
+    // *** 4th stage
+    const extractStageResult = yield* this.getNext('extract', entrypoint, {
+        processors: collectStageResult.metadata.processors,
+    }, null);
+    return {
+        ...extractStageResult,
+        code: collectStageResult.code ?? '',
+        dependencies,
+        replacements: [
+            ...extractStageResult.replacements,
+            ...collectStageResult.metadata.replacements,
+        ],
+        sourceMap: collectStageResult.map,
+    };
+}
+exports.workflow = workflow;

package/types/transform/helpers/loadLinariaOptions.d.ts

@@ -0,0 +1,6 @@
+import type { FeatureFlags, StrictOptions } from '@wyw-in-js/shared';
+import type { PluginOptions } from '../../types';
+export type PartialOptions = Partial<Omit<PluginOptions, 'features'>> & {
+    features?: Partial<FeatureFlags>;
+};
+export declare function loadLinariaOptions(overrides?: PartialOptions): StrictOptions;

package/types/transform/helpers/loadLinariaOptions.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadLinariaOptions = void 0;
+const cosmiconfig_1 = require("cosmiconfig");
+const shaker_1 = __importDefault(require("../../shaker"));
+const searchPlaces = [
+    `.linariarc`,
+    `.linariarc.json`,
+    `.linariarc.yaml`,
+    `.linariarc.yml`,
+    `.linariarc.js`,
+    `.linariarc.cjs`,
+    `.config/linariarc`,
+    `.config/linariarc.json`,
+    `.config/linariarc.yaml`,
+    `.config/linariarc.yml`,
+    `.config/linariarc.js`,
+    `.config/linariarc.cjs`,
+    `linaria.config.js`,
+    `linaria.config.cjs`,
+];
+const explorerSync = (0, cosmiconfig_1.cosmiconfigSync)('linaria', { searchPlaces });
+const cache = new WeakMap();
+const defaultOverrides = {};
+const nodeModulesRegExp = /[\\/]node_modules[\\/]/;
+function loadLinariaOptions(overrides = defaultOverrides) {
+    if (cache.has(overrides)) {
+        return cache.get(overrides);
+    }
+    const { configFile, ignore, rules, babelOptions = {}, ...rest } = overrides;
+    const result = 
+    // eslint-disable-next-line no-nested-ternary
+    configFile === false
+        ? undefined
+        : configFile !== undefined
+            ? explorerSync.load(configFile)
+            : explorerSync.search();
+    const defaultFeatures = {
+        dangerousCodeRemover: true,
+        globalCache: true,
+        happyDOM: true,
+        softErrors: false,
+        useBabelConfigs: true,
+    };
+    const options = {
+        displayName: false,
+        evaluate: true,
+        extensions: ['.cjs', '.cts', '.js', '.jsx', '.mjs', '.mts', '.ts', '.tsx'],
+        rules: rules ?? [
+            {
+                action: shaker_1.default,
+            },
+            {
+                // The old `ignore` option is used as a default value for `ignore` rule.
+                test: ignore ?? nodeModulesRegExp,
+                action: 'ignore',
+            },
+            {
+                // Do not ignore ES-modules
+                test: (filename, code) => {
+                    if (!nodeModulesRegExp.test(filename)) {
+                        return false;
+                    }
+                    // If a file contains `export` or `import` keywords, we assume it's an ES-module
+                    return /(?:^|\*\/|;)\s*(?:export|import)\s/m.test(code);
+                },
+                action: shaker_1.default,
+            },
+        ],
+        babelOptions,
+        highPriorityPlugins: ['module-resolver'],
+        ...(result ? result.config : {}),
+        ...rest,
+        features: {
+            ...defaultFeatures,
+            ...(result ? result.config.features : {}),
+            ...rest.features,
+        },
+    };
+    cache.set(overrides, options);
+    return options;
+}
+exports.loadLinariaOptions = loadLinariaOptions;

package/types/transform/helpers/withDefaultServices.d.ts

@@ -0,0 +1,5 @@
+import type { Services } from '../types';
+type RequiredServices = 'options';
+export type PartialServices = Partial<Omit<Services, RequiredServices>> & Pick<Services, RequiredServices>;
+export declare const withDefaultServices: ({ babel, cache, eventEmitter, loadAndParseFn, log, options, }: PartialServices) => Services;
+export {};

package/types/transform/helpers/withDefaultServices.js

@@ -0,0 +1,40 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withDefaultServices = void 0;
+const babelCore = __importStar(require("@babel/core"));
+const cache_1 = require("../../cache");
+const EventEmitter_1 = require("../../utils/EventEmitter");
+const Entrypoint_helpers_1 = require("../Entrypoint.helpers");
+const rootLog_1 = require("../rootLog");
+const withDefaultServices = ({ babel = babelCore, cache = new cache_1.TransformCacheCollection(), eventEmitter = EventEmitter_1.EventEmitter.dummy, loadAndParseFn = Entrypoint_helpers_1.loadAndParse, log = rootLog_1.rootLog, options, }) => ({
+    babel,
+    cache,
+    eventEmitter,
+    loadAndParseFn,
+    log,
+    options,
+});
+exports.withDefaultServices = withDefaultServices;

package/types/transform/rootLog.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="debug" />
+import type { Debugger } from '@wyw-in-js/shared';
+export declare const rootLog: Debugger;

package/types/transform/rootLog.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rootLog = void 0;
+const shared_1 = require("@wyw-in-js/shared");
+exports.rootLog = shared_1.logger.extend('transform');

package/types/transform/types.d.ts

@@ -0,0 +1,137 @@
+/// <reference types="debug" />
+import type { BabelFileResult } from '@babel/core';
+import type { ValueCache } from '@wyw-in-js/processor-utils';
+import type { Debugger, Artifact, StrictOptions } from '@wyw-in-js/shared';
+import type { Core } from '../babel';
+import type { TransformCacheCollection } from '../cache';
+import type { Options, ITransformFileResult } from '../types';
+import type { EventEmitter } from '../utils/EventEmitter';
+import type { WYWTransformMetadata } from '../utils/TransformMetadata';
+import type { Entrypoint } from './Entrypoint';
+import type { LoadAndParseFn, IEntrypointDependency } from './Entrypoint.types';
+import type { BaseAction } from './actions/BaseAction';
+import type { IExtracted, IWorkflowActionLinariaResult, IWorkflowActionNonLinariaResult } from './actions/types';
+export type Services = {
+    babel: Core;
+    cache: TransformCacheCollection;
+    eventEmitter: EventEmitter;
+    loadAndParseFn: LoadAndParseFn;
+    log: Debugger;
+    options: Options & {
+        pluginOptions: StrictOptions;
+    };
+};
+export interface IBaseNode {
+    type: ActionTypes;
+}
+export type ActionByType<TType extends ActionQueueItem['type']> = Extract<ActionQueueItem, {
+    type: TType;
+}>;
+export declare const Pending: unique symbol;
+export type YieldResult = Exclude<ActionQueueItem['result'], typeof Pending>;
+export type AnyIteratorResult<TMode extends 'async' | 'sync', TResult> = {
+    async: Promise<IteratorResult<YieldArg, TResult>>;
+    sync: IteratorResult<YieldArg, TResult>;
+}[TMode];
+export interface IBaseAction<TAction extends ActionQueueItem, TResult, TData> extends IBaseNode {
+    abortSignal: AbortSignal | null;
+    createAbortSignal: () => AbortSignal & Disposable;
+    data: TData;
+    entrypoint: Entrypoint;
+    getNext: GetNext;
+    idx: string;
+    result: TResult | typeof Pending;
+    run: <TMode extends 'async' | 'sync'>(handler: Handler<TMode, TAction>) => {
+        next: (arg: YieldResult) => AnyIteratorResult<TMode, TResult>;
+        throw(e: unknown): AnyIteratorResult<TMode, TResult>;
+    };
+    services: Services;
+}
+type NextParams<TType extends ActionTypes, TNextAction extends ActionByType<TType> = ActionByType<TType>> = [
+    type: TType,
+    entrypoint: Entrypoint,
+    data: TNextAction['data'],
+    abortSignal?: AbortSignal | null
+];
+export type YieldArg = {
+    [K in ActionQueueItem['type']]: NextParams<K>;
+}[ActionQueueItem['type']];
+export type SyncScenarioFor<TResult> = {
+    [Symbol.iterator](): SyncScenarioFor<TResult>;
+    next(arg: YieldResult): IteratorResult<YieldArg, TResult>;
+    return(value: TResult): IteratorResult<YieldArg, TResult>;
+    throw(e: unknown): IteratorResult<YieldArg, TResult>;
+};
+export type AsyncScenarioFor<TResult> = {
+    [Symbol.asyncIterator](): AsyncScenarioFor<TResult>;
+    next(arg: YieldResult): Promise<IteratorResult<YieldArg, TResult>>;
+    return(value: TResult | PromiseLike<TResult>): Promise<IteratorResult<YieldArg, TResult>>;
+    throw(e: unknown): Promise<IteratorResult<YieldArg, TResult>>;
+};
+export type SyncScenarioForAction<TAction extends ActionQueueItem> = SyncScenarioFor<TypeOfResult<TAction>>;
+export type AsyncScenarioForAction<TAction extends ActionQueueItem> = AsyncScenarioFor<TypeOfResult<TAction>>;
+export type Handler<TMode extends 'async' | 'sync', TAction extends ActionQueueItem> = ((this: BaseAction<TAction>) => {
+    async: AsyncScenarioForAction<TAction>;
+    sync: SyncScenarioForAction<TAction>;
+}[TMode]) & {
+    recover?: (e: unknown, action: BaseAction<TAction>) => YieldArg;
+};
+export type Handlers<TMode extends 'async' | 'sync'> = {
+    [TAction in ActionQueueItem as TAction['type']]: Handler<TMode, TAction>;
+};
+export type TypeOfResult<T extends ActionQueueItem> = Exclude<T['result'], typeof Pending>;
+export type GetNext = <TType extends ActionTypes, TNextAction extends ActionByType<TType> = ActionByType<TType>>(...args: NextParams<TType, TNextAction>) => Generator<[
+    TType,
+    Entrypoint,
+    TNextAction['data'],
+    AbortSignal | null
+], TypeOfResult<TNextAction>, YieldResult>;
+export interface ICollectActionResult {
+    ast: BabelFileResult['ast'];
+    code: BabelFileResult['code'];
+    map?: BabelFileResult['map'];
+    metadata?: WYWTransformMetadata | null;
+}
+export interface ICollectAction extends IBaseAction<ICollectAction, ICollectActionResult, {
+    valueCache: ValueCache;
+}> {
+    type: 'collect';
+}
+export interface IEvalAction extends IBaseAction<IEvalAction, [ValueCache, string[]] | null, undefined> {
+    type: 'evalFile';
+}
+export interface IExplodeReexportsAction extends IBaseAction<IExplodeReexportsAction, void, undefined> {
+    type: 'explodeReexports';
+}
+export interface IExtractAction extends IBaseAction<IExtractAction, IExtracted, {
+    processors: {
+        artifacts: Artifact[];
+    }[];
+}> {
+    type: 'extract';
+}
+export interface IGetExportsAction extends IBaseAction<IGetExportsAction, string[], undefined> {
+    type: 'getExports';
+}
+export interface IProcessEntrypointAction extends IBaseAction<IProcessEntrypointAction, void, undefined> {
+    type: 'processEntrypoint';
+}
+export interface IProcessImportsAction extends IBaseAction<IProcessImportsAction, void, {
+    resolved: IEntrypointDependency[];
+}> {
+    type: 'processImports';
+}
+export interface IResolveImportsAction extends IBaseAction<IResolveImportsAction, IEntrypointDependency[], {
+    imports: Map<string, string[]> | null;
+}> {
+    type: 'resolveImports';
+}
+export interface ITransformAction extends IBaseAction<ITransformAction, ITransformFileResult, undefined> {
+    type: 'transform';
+}
+export interface IWorkflowAction extends IBaseAction<IWorkflowAction, IWorkflowActionLinariaResult | IWorkflowActionNonLinariaResult, undefined> {
+    type: 'workflow';
+}
+export type ActionQueueItem = IEvalAction | IExplodeReexportsAction | IExtractAction | IGetExportsAction | ICollectAction | IProcessEntrypointAction | IProcessImportsAction | IResolveImportsAction | ITransformAction | IWorkflowAction;
+export type ActionTypes = ActionQueueItem['type'];
+export {};

package/types/transform/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pending = void 0;
+exports.Pending = Symbol('pending');

package/types/transform.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This file exposes transform function that:
+ * - parse the passed code to AST
+ * - transforms the AST using Linaria babel preset ('./babel/index.js) and additional config defined in Linaria config file or passed to bundler configuration.
+ * - runs generated CSS files through default of user-defined preprocessor
+ * - generates source maps for CSS files
+ * - return transformed code (without Linaria template literals), generated CSS, source maps and babel metadata from transform step.
+ */
+import type { PartialOptions } from './transform/helpers/loadLinariaOptions';
+import type { Handlers, Services } from './transform/types';
+import type { Result } from './types';
+type PartialServices = Partial<Omit<Services, 'options'>> & {
+    options: Omit<Services['options'], 'pluginOptions'> & {
+        pluginOptions?: PartialOptions;
+    };
+};
+type AllHandlers<TMode extends 'async' | 'sync'> = Handlers<TMode>;
+export declare function transformSync(partialServices: PartialServices, originalCode: string, syncResolve: (what: string, importer: string, stack: string[]) => string, customHandlers?: Partial<AllHandlers<'sync'>>): Result;
+export declare function transform(partialServices: PartialServices, originalCode: string, asyncResolve: (what: string, importer: string, stack: string[]) => Promise<string | null>, customHandlers?: Partial<AllHandlers<'sync'>>): Promise<Result>;
+export {};