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

package/types/transform.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * This file exposes sync and async transform functions that:
  * - parse the passed code to AST
@@ -6,105 +5,96 @@
  * - shakes each dependency and removes unused code
  * - runs generated code in a sandbox
  * - collects artifacts
- * - returns transformed code (without WYW template literals), generated CSS, source maps and babel metadata from transform step.
+ * - returns transformed code (without WYW template literals), generated CSS, source maps and transform metadata.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformSync = transformSync;
-exports.transform = transform;
-const shared_1 = require("@wyw-in-js/shared");
-const loadWywOptions_1 = require("./transform/helpers/loadWywOptions");
-const cache_1 = require("./cache");
-const Entrypoint_1 = require("./transform/Entrypoint");
-const actionRunner_1 = require("./transform/actions/actionRunner");
-const generators_1 = require("./transform/generators");
-const resolveImports_1 = require("./transform/generators/resolveImports");
-const withDefaultServices_1 = require("./transform/helpers/withDefaultServices");
-const memoizedSyncResolve = new WeakMap();
+import { createHash } from 'crypto';
+import { isFeatureEnabled } from '@wyw-in-js/shared';
+import { loadWywOptions } from './transform/helpers/loadWywOptions';
+import { TransformCacheCollection } from './cache';
+import { Entrypoint } from './transform/Entrypoint';
+import { asyncActionRunner } from './transform/actions/actionRunner';
+import { baseHandlers } from './transform/generators';
+import { asyncResolveImports } from './transform/generators/resolveImports';
+import { withDefaultServices } from './transform/helpers/withDefaultServices';
+import { getEvalBroker } from './eval/broker';
+import { encodeGlobals } from './eval/serialize';
 const memoizedAsyncResolve = new WeakMap();
-const EMPTY_CUSTOM_HANDLERS = {};
-const memoizedActionContexts = new WeakMap();
-const getActionContext = (resolveImportsHandler, customHandlers) => {
-    const customHandlersKey = Object.keys(customHandlers).length === 0
-        ? EMPTY_CUSTOM_HANDLERS
-        : customHandlers;
-    let actionContextsByHandlers = memoizedActionContexts.get(resolveImportsHandler);
-    if (!actionContextsByHandlers) {
-        actionContextsByHandlers = new WeakMap();
-        memoizedActionContexts.set(resolveImportsHandler, actionContextsByHandlers);
+const resolverIds = new WeakMap();
+let resolverId = 0;
+const getResolverId = (fn) => {
+    if (typeof fn !== 'function')
+        return null;
+    const resolver = fn;
+    const cached = resolverIds.get(resolver);
+    if (cached)
+        return cached;
+    resolverId += 1;
+    resolverIds.set(resolver, resolverId);
+    return resolverId;
+};
+const isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const canonicalizeForHash = (value) => {
+    if (Array.isArray(value)) {
+        return value.map((item) => canonicalizeForHash(item));
     }
-    let actionContext = actionContextsByHandlers.get(customHandlersKey);
-    if (!actionContext) {
-        actionContext = {};
-        actionContextsByHandlers.set(customHandlersKey, actionContext);
+    if (isPlainObject(value)) {
+        return Object.fromEntries(Object.keys(value)
+            .sort()
+            .map((key) => [key, canonicalizeForHash(value[key])]));
     }
-    return actionContext;
+    return value;
 };
-function transformSync(partialServices, originalCode, syncResolve, customHandlers = {}) {
-    const { options } = partialServices;
-    const pluginOptions = (0, loadWywOptions_1.loadWywOptions)(options.pluginOptions);
-    const services = (0, withDefaultServices_1.withDefaultServices)({
-        ...partialServices,
-        options: {
-            ...options,
-            pluginOptions,
-        },
+const getEvalCacheKey = (pluginOptions, asyncResolveKey, asyncResolve) => {
+    const evalOptions = pluginOptions.eval ?? {};
+    const payload = JSON.stringify({
+        errors: evalOptions.errors,
+        resolver: evalOptions.resolver,
+        require: evalOptions.require,
+        runtime: evalOptions.runtime,
+        strategy: evalOptions.strategy,
+        globals: canonicalizeForHash(encodeGlobals(evalOptions.globals ?? {})),
+        customResolver: getResolverId(evalOptions.customResolver),
+        customLoader: getResolverId(evalOptions.customLoader),
+        // Bundlers like webpack can recreate transport resolvers per file. Allow
+        // them to provide a stable scope key so cache/broker reuse tracks resolver
+        // semantics instead of closure identity.
+        bundlerResolver: asyncResolveKey ?? getResolverId(asyncResolve),
+        overrideContext: getResolverId(pluginOptions.overrideContext),
+        importOverrides: pluginOptions.importOverrides ?? null,
+        extensions: pluginOptions.extensions,
+        features: pluginOptions.features,
     });
-    if (!(0, shared_1.isFeatureEnabled)(pluginOptions.features, 'globalCache', options.filename)) {
-        // If global cache is disabled, we need to create a new cache for each file
-        services.cache = new cache_1.TransformCacheCollection();
-    }
-    if (!memoizedSyncResolve.has(syncResolve)) {
-        memoizedSyncResolve.set(syncResolve, function resolveImports() {
-            return resolveImports_1.syncResolveImports.call(this, syncResolve);
-        });
-    }
-    const resolveImportsHandler = memoizedSyncResolve.get(syncResolve);
-    const actionHandlers = {
-        ...generators_1.baseHandlers,
-        ...customHandlers,
-        resolveImports: resolveImportsHandler,
-    };
-    const actionContext = getActionContext(resolveImportsHandler, customHandlers);
-    const entrypoint = Entrypoint_1.Entrypoint.createRoot(services, options.filename, ['__wywPreval'], originalCode);
-    if (entrypoint.ignored) {
-        return {
-            code: originalCode,
-            sourceMap: options.inputSourceMap,
-        };
-    }
-    const workflowAction = entrypoint.createAction('workflow', undefined, null, actionContext);
-    try {
-        const result = (0, actionRunner_1.syncActionRunner)(workflowAction, actionHandlers);
-        entrypoint.log('%s is ready', entrypoint.name);
-        return result;
-    }
-    catch (err) {
-        entrypoint.log('Unhandled error %O', err);
-        if ((0, shared_1.isFeatureEnabled)(pluginOptions.features, 'softErrors', options.filename)) {
-            // eslint-disable-next-line no-console
-            console.error(`Error during transform of ${entrypoint.name}:`, err);
-            return {
-                code: originalCode,
-                sourceMap: options.inputSourceMap,
-            };
-        }
-        throw err;
-    }
+    return createHash('sha256').update(payload).digest('hex');
+};
+export function transformSync(
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_partialServices, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_originalCode, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_syncResolve, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_customHandlers = {}) {
+    throw new Error('[wyw-in-js] transformSync is not supported in v2. Use transform() (async) instead.');
 }
-async function transform(partialServices, originalCode, asyncResolve, customHandlers = {}) {
+export async function transform(partialServices, originalCode, asyncResolve, customHandlers = {}) {
     const { options } = partialServices;
-    const pluginOptions = (0, loadWywOptions_1.loadWywOptions)(options.pluginOptions);
-    const services = (0, withDefaultServices_1.withDefaultServices)({
+    const pluginOptions = loadWywOptions(options.pluginOptions);
+    const services = withDefaultServices({
         ...partialServices,
         options: {
             ...options,
             pluginOptions,
         },
     });
-    if (!(0, shared_1.isFeatureEnabled)(pluginOptions.features, 'globalCache', options.filename)) {
+    if (!isFeatureEnabled(pluginOptions.features, 'globalCache', options.filename)) {
         // If global cache is disabled, we need to create a new cache for each file
-        services.cache = new cache_1.TransformCacheCollection();
+        services.cache = new TransformCacheCollection();
     }
+    const evalCacheKey = getEvalCacheKey(pluginOptions, services.asyncResolveKey, asyncResolve);
+    services.cache.setKeySalt(evalCacheKey);
+    services.asyncResolve = asyncResolve;
+    services.evalBroker = getEvalBroker(services, asyncResolve, evalCacheKey);
     /*
      * This method can be run simultaneously for multiple files.
      * A shared cache is accessible for all runs, but each run has its own queue
@@ -113,35 +103,34 @@ async function transform(partialServices, originalCode, asyncResolve, customHand
      * but the "only" option has changed, the file will be re-processed using
      * the combined "only" option.
      */
-    if (!memoizedAsyncResolve.has(asyncResolve)) {
-        const resolveImports = function resolveImports() {
-            return resolveImports_1.asyncResolveImports.call(this, asyncResolve);
-        };
-        memoizedAsyncResolve.set(asyncResolve, resolveImports);
-    }
-    const resolveImportsHandler = memoizedAsyncResolve.get(asyncResolve);
-    const actionHandlers = {
-        ...generators_1.baseHandlers,
-        ...customHandlers,
-        resolveImports: resolveImportsHandler,
-    };
-    const actionContext = getActionContext(resolveImportsHandler, customHandlers);
-    const entrypoint = Entrypoint_1.Entrypoint.createRoot(services, options.filename, ['__wywPreval'], originalCode);
+    const entrypoint = Entrypoint.createRoot(services, options.filename, ['__wywPreval'], originalCode);
     if (entrypoint.ignored) {
         return {
             code: originalCode,
             sourceMap: options.inputSourceMap,
         };
     }
-    const workflowAction = entrypoint.createAction('workflow', undefined, null, actionContext);
+    // Separate top-level runs must not share action state, even for the same
+    // entrypoint, otherwise concurrent transforms can collide in BaseAction.run.
+    const workflowAction = entrypoint.createAction('workflow', undefined, null, {});
+    if (!memoizedAsyncResolve.has(asyncResolve)) {
+        const resolveImports = function resolveImports() {
+            return asyncResolveImports.call(this, asyncResolve);
+        };
+        memoizedAsyncResolve.set(asyncResolve, resolveImports);
+    }
     try {
-        const result = await (0, actionRunner_1.asyncActionRunner)(workflowAction, actionHandlers);
+        const result = await asyncActionRunner(workflowAction, {
+            ...baseHandlers,
+            ...customHandlers,
+            resolveImports: memoizedAsyncResolve.get(asyncResolve),
+        });
         entrypoint.log('%s is ready', entrypoint.name);
         return result;
     }
     catch (err) {
         entrypoint.log('Unhandled error %O', err);
-        if ((0, shared_1.isFeatureEnabled)(pluginOptions.features, 'softErrors', options.filename)) {
+        if (isFeatureEnabled(pluginOptions.features, 'softErrors', options.filename)) {
             // eslint-disable-next-line no-console
             console.error(`Error during transform of ${entrypoint.name}:`, err);
             return {

package/types/types.d.ts

@@ -1,8 +1,4 @@
-import type { BabelFile, PluginPass } from '@babel/core';
-import type { NodePath } from '@babel/traverse';
-import type { File, Program } from '@babel/types';
 import type { RawSourceMap } from 'source-map';
-import type { BaseProcessor } from '@wyw-in-js/processor-utils';
 import type { Debugger, Replacement, Rules, StrictOptions } from '@wyw-in-js/shared';
 import type { WYWTransformMetadata, WYWTransformResultMetadata } from './utils/TransformMetadata';
 import type { WYWTransformDiagnostic } from './utils/TransformDiagnostics';
@@ -18,15 +14,6 @@ export type ParentEntrypoint = {
     seqId: number;
 };
 export type Dependencies = string[];
-export interface IPluginState extends PluginPass {
-    dependencies: Dependencies;
-    file: BabelFile & {
-        metadata: {
-            wywInJS?: WYWTransformMetadata;
-        };
-    };
-    processors: BaseProcessor[];
-}
 export interface ITransformFileResult {
     code: string;
     metadata: WYWTransformMetadata | null;
@@ -55,16 +42,6 @@ export type Options = {
 };
 export type PreprocessorFn = (selector: string, cssText: string) => string;
 export type Preprocessor = 'none' | 'stylis' | PreprocessorFn | void;
-export type MissedBabelCoreTypes = {
-    File: new (options: {
-        filename: string;
-    }, file: {
-        ast: File;
-        code: string;
-    }) => {
-        path: NodePath<Program>;
-    };
-};
 export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
 export interface JSONObject {
     [x: string]: JSONValue;

package/types/types.js

@@ -1,5 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 /**
  * CSS-related types
  */

package/types/utils/EventEmitter.d.ts

@@ -45,14 +45,29 @@ export interface OnAction {
     (...args: OnActionStartArgs): number;
     (...args: OnActionFinishArgs): void;
 }
+type PerfStatus = 'failed' | 'finished';
+export type PerfFinishEvent = {
+    durationMs: number;
+    error?: unknown;
+    finishedAt: number;
+    isAsync: boolean;
+    method: string;
+    spanId: number;
+    startedAt: number;
+    status: PerfStatus;
+    type: 'perf-span';
+};
 export declare class EventEmitter {
     protected onEvent: OnEvent;
     protected onAction: OnAction;
     protected onEntrypointEvent: OnEntrypointEvent;
+    readonly enabled: boolean;
     static dummy: EventEmitter;
-    constructor(onEvent: OnEvent, onAction: OnAction, onEntrypointEvent: OnEntrypointEvent);
+    private perfSpanId;
+    constructor(onEvent: OnEvent, onAction: OnAction, onEntrypointEvent: OnEntrypointEvent, enabled?: boolean);
     action<TRes>(actonType: string, idx: string, entrypointRef: string, fn: () => TRes): TRes;
     entrypointEvent(sequenceId: number, event: EntrypointEvent): void;
     perf<TRes>(method: string, fn: () => TRes): TRes;
     single(labels: Record<string, unknown>): void;
 }
+export {};

package/types/utils/EventEmitter.js

@@ -1,23 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventEmitter = exports.isOnActionFinishArgs = exports.isOnActionStartArgs = void 0;
-const isOnActionStartArgs = (args) => {
+export const isOnActionStartArgs = (args) => {
     return args[0] === 'start';
 };
-exports.isOnActionStartArgs = isOnActionStartArgs;
-const isOnActionFinishArgs = (args) => {
+export const isOnActionFinishArgs = (args) => {
     return args[0] === 'finish' || args[0] === 'fail';
 };
-exports.isOnActionFinishArgs = isOnActionFinishArgs;
-class EventEmitter {
+export class EventEmitter {
     onEvent;
     onAction;
     onEntrypointEvent;
-    static dummy = new EventEmitter(() => { }, () => 0, () => { });
-    constructor(onEvent, onAction, onEntrypointEvent) {
+    enabled;
+    static dummy = new EventEmitter(() => { }, () => 0, () => { }, false);
+    perfSpanId = 0;
+    constructor(onEvent, onAction, onEntrypointEvent, enabled = true) {
         this.onEvent = onEvent;
         this.onAction = onAction;
         this.onEntrypointEvent = onEntrypointEvent;
+        this.enabled = enabled;
     }
     action(actonType, idx, entrypointRef, fn) {
         const id = this.onAction('start', performance.now(), actonType, idx, entrypointRef);
@@ -40,16 +38,48 @@ class EventEmitter {
         this.onEntrypointEvent(sequenceId, performance.now(), event);
     }
     perf(method, fn) {
+        const spanId = this.perfSpanId;
+        this.perfSpanId += 1;
+        const startedAt = performance.now();
         const labels = { method };
-        this.onEvent(labels, 'start');
-        const result = fn();
-        if (result instanceof Promise) {
-            result.then(() => this.onEvent(labels, 'finish'), () => this.onEvent(labels, 'finish'));
+        const startEvent = {
+            method,
+            spanId,
+            startedAt,
+            type: 'perf-span-start',
+        };
+        this.onEvent(labels, 'start', startEvent);
+        const finish = (status, isAsync, error) => {
+            const finishedAt = performance.now();
+            const finishEvent = {
+                durationMs: finishedAt - startedAt,
+                finishedAt,
+                isAsync,
+                method,
+                spanId,
+                startedAt,
+                status,
+                type: 'perf-span',
+            };
+            if (error !== undefined) {
+                finishEvent.error = error;
+            }
+            this.onEvent(labels, 'finish', finishEvent);
+        };
+        try {
+            const result = fn();
+            if (result instanceof Promise) {
+                result.then(() => finish('finished', true), (error) => finish('failed', true, error));
+            }
+            else {
+                finish('finished', false);
+            }
+            return result;
         }
-        else {
-            this.onEvent(labels, 'finish');
+        catch (error) {
+            finish('failed', false, error);
+            throw error;
         }
-        return result;
     }
     single(labels) {
         this.onEvent({
@@ -58,4 +88,3 @@ class EventEmitter {
         }, 'single');
     }
 }
-exports.EventEmitter = EventEmitter;

package/types/utils/ShakerMetadata.js

@@ -1,5 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasShakerMetadata = void 0;
-const hasShakerMetadata = (metadata) => metadata !== undefined && 'wywEvaluator' in metadata;
-exports.hasShakerMetadata = hasShakerMetadata;
+export const hasShakerMetadata = (metadata) => metadata !== undefined && 'wywEvaluator' in metadata;

package/types/utils/TransformDiagnostics.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectTransformDiagnostics = void 0;
-const processor_utils_1 = require("@wyw-in-js/processor-utils");
-const collectTransformDiagnostics = (filename, processors) => processors.flatMap((processor) => processor.artifacts
-    .filter(processor_utils_1.isProcessorDiagnosticArtifact)
+import { isProcessorDiagnosticArtifact } from '@wyw-in-js/processor-utils';
+export const collectTransformDiagnostics = (filename, processors) => processors.flatMap((processor) => processor.artifacts
+    .filter(isProcessorDiagnosticArtifact)
     .map(([, diagnostic]) => ({
     ...diagnostic,
     className: processor.className,
@@ -12,4 +9,3 @@ const collectTransformDiagnostics = (filename, processors) => processors.flatMap
     filename,
     start: diagnostic.start ?? null,
 })));
-exports.collectTransformDiagnostics = collectTransformDiagnostics;

package/types/utils/TransformMetadata.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifyTransformManifest = exports.createTransformManifest = exports.toTransformResultMetadata = exports.getTransformMetadata = exports.withTransformMetadata = void 0;
-const processor_utils_1 = require("@wyw-in-js/processor-utils");
-const withTransformMetadata = (value) => typeof value === 'object' &&
+import { isProcessorDiagnosticArtifact } from '@wyw-in-js/processor-utils';
+export const withTransformMetadata = (value) => typeof value === 'object' &&
     value !== null &&
     typeof value.wywInJS === 'object';
-exports.withTransformMetadata = withTransformMetadata;
-const getTransformMetadata = (value) => {
-    if ((0, exports.withTransformMetadata)(value) && value.wywInJS !== null) {
+export const getTransformMetadata = (value) => {
+    if (withTransformMetadata(value) && value.wywInJS !== null) {
         const metadata = value.wywInJS;
         // eslint-disable-next-line no-param-reassign
         delete value.wywInJS;
@@ -15,12 +11,11 @@ const getTransformMetadata = (value) => {
     }
     return undefined;
 };
-exports.getTransformMetadata = getTransformMetadata;
-const toTransformResultMetadata = (metadata, dependencies) => ({
+export const toTransformResultMetadata = (metadata, dependencies) => ({
     dependencies,
     processors: metadata.processors.map((processor) => ({
         artifacts: processor.artifacts
-            .filter((artifact) => !(0, processor_utils_1.isProcessorDiagnosticArtifact)(artifact))
+            .filter((artifact) => !isProcessorDiagnosticArtifact(artifact))
             .map(([type, data]) => [type, data]),
         className: processor.className,
         displayName: processor.displayName,
@@ -29,12 +24,9 @@ const toTransformResultMetadata = (metadata, dependencies) => ({
     replacements: [...metadata.replacements],
     rules: { ...metadata.rules },
 });
-exports.toTransformResultMetadata = toTransformResultMetadata;
-const createTransformManifest = (metadata, context) => ({
+export const createTransformManifest = (metadata, context) => ({
     ...metadata,
     ...context,
     version: 1,
 });
-exports.createTransformManifest = createTransformManifest;
-const stringifyTransformManifest = (manifest) => `${JSON.stringify(manifest, null, 2)}\n`;
-exports.stringifyTransformManifest = stringifyTransformManifest;
+export const stringifyTransformManifest = (manifest) => `${JSON.stringify(manifest, null, 2)}\n`;

package/types/utils/applyOxcProcessors/applyOxcProcessors.d.ts

@@ -0,0 +1,8 @@
+import type { BaseProcessor, IFileContext } from '@wyw-in-js/processor-utils';
+import type { StrictOptions } from '@wyw-in-js/shared';
+import { EventEmitter } from '../EventEmitter';
+import type { ApplyOxcProcessorsResult } from './types';
+export declare const applyOxcProcessors: (code: string, fileContext: IFileContext, options: Pick<StrictOptions, "classNameSlug" | "displayName" | "eval" | "extensions" | "staticBindings" | "tagResolver"> & {
+    eventEmitter?: EventEmitter;
+    preserveSideEffectImportLocals?: Set<string>;
+}, callback: (processor: BaseProcessor) => void, cleanupUnused?: boolean) => ApplyOxcProcessorsResult;