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

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,94 @@
  * - 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({
+        mode: evalOptions.mode,
+        resolver: evalOptions.resolver,
+        require: evalOptions.require,
+        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 +101,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,10 +1,7 @@
-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 } from './utils/TransformMetadata';
+import type { WYWTransformMetadata, WYWTransformResultMetadata } from './utils/TransformMetadata';
+import type { WYWTransformDiagnostic } from './utils/TransformDiagnostics';
 export type PluginOptions = StrictOptions & {
     configFile?: string | false;
     stage?: Stage;
@@ -17,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;
@@ -36,6 +24,8 @@ export type Result = {
     cssSourceMapText?: string;
     cssText?: string;
     dependencies?: string[];
+    diagnostics?: WYWTransformDiagnostic[];
+    metadata?: WYWTransformResultMetadata;
     replacements?: Replacement[];
     rules?: Rules;
     sourceMap?: RawSourceMap | null;
@@ -52,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.js

@@ -1,15 +1,10 @@
-"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;
@@ -58,4 +53,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.d.ts

@@ -0,0 +1,9 @@
+import type { BaseProcessor, ProcessorDiagnostic } from '@wyw-in-js/processor-utils';
+type DiagnosticProcessor = Pick<BaseProcessor, 'artifacts' | 'className' | 'displayName'>;
+export type WYWTransformDiagnostic = ProcessorDiagnostic & {
+    className: string;
+    displayName: string;
+    filename: string;
+};
+export declare const collectTransformDiagnostics: (filename: string, processors: DiagnosticProcessor[]) => WYWTransformDiagnostic[];
+export {};

package/types/utils/TransformDiagnostics.js

@@ -0,0 +1,11 @@
+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,
+    displayName: processor.displayName,
+    end: diagnostic.end ?? null,
+    filename,
+    start: diagnostic.start ?? null,
+})));

package/types/utils/TransformMetadata.d.ts

@@ -1,13 +1,31 @@
-import type { Artifact, Replacement, Rules } from '@wyw-in-js/shared';
+import type { BaseProcessor } from '@wyw-in-js/processor-utils';
+import type { Artifact, Location, Replacement, Rules } from '@wyw-in-js/shared';
+type TransformMetadataProcessor = Pick<BaseProcessor, 'artifacts' | 'className' | 'displayName' | 'location'>;
 export type WYWTransformMetadata = {
     dependencies: string[];
-    processors: {
-        artifacts: Artifact[];
-    }[];
+    processors: TransformMetadataProcessor[];
     replacements: Replacement[];
     rules: Rules;
 };
+export type WYWTransformProcessorMetadata = {
+    artifacts: Artifact[];
+    className: string;
+    displayName: string;
+    start: Location | null | undefined;
+};
+export type WYWTransformResultMetadata = Omit<WYWTransformMetadata, 'processors'> & {
+    processors: WYWTransformProcessorMetadata[];
+};
+export type WYWTransformManifest = WYWTransformResultMetadata & {
+    cssFile?: string;
+    source: string;
+    version: 1;
+};
 export declare const withTransformMetadata: (value: unknown) => value is {
     wywInJS: WYWTransformMetadata;
 };
 export declare const getTransformMetadata: (value: unknown) => WYWTransformMetadata | undefined;
+export declare const toTransformResultMetadata: (metadata: WYWTransformMetadata, dependencies: string[]) => WYWTransformResultMetadata;
+export declare const createTransformManifest: (metadata: WYWTransformResultMetadata, context: Pick<WYWTransformManifest, "cssFile" | "source">) => WYWTransformManifest;
+export declare const stringifyTransformManifest: (manifest: WYWTransformManifest) => string;
+export {};

package/types/utils/TransformMetadata.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTransformMetadata = exports.withTransformMetadata = void 0;
-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;
@@ -14,4 +11,22 @@ const getTransformMetadata = (value) => {
     }
     return undefined;
 };
-exports.getTransformMetadata = getTransformMetadata;
+export const toTransformResultMetadata = (metadata, dependencies) => ({
+    dependencies,
+    processors: metadata.processors.map((processor) => ({
+        artifacts: processor.artifacts
+            .filter((artifact) => !isProcessorDiagnosticArtifact(artifact))
+            .map(([type, data]) => [type, data]),
+        className: processor.className,
+        displayName: processor.displayName,
+        start: processor.location?.start ?? null,
+    })),
+    replacements: [...metadata.replacements],
+    rules: { ...metadata.rules },
+});
+export const createTransformManifest = (metadata, context) => ({
+    ...metadata,
+    ...context,
+    version: 1,
+});
+export const stringifyTransformManifest = (manifest) => `${JSON.stringify(manifest, null, 2)}\n`;

package/types/utils/applyOxcProcessors.d.ts

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