@wyw-in-js/transform 1.0.6 → 1.0.8

package/types/transform/generators/transform.js

@@ -9,8 +9,10 @@ exports.transform = transform;
 const buildOptions_1 = require("../../options/buildOptions");
 const dynamic_import_1 = __importDefault(require("../../plugins/dynamic-import"));
 const preeval_1 = __importDefault(require("../../plugins/preeval"));
+const shaker_1 = require("../../shaker");
 const TransformMetadata_1 = require("../../utils/TransformMetadata");
 const getPluginKey_1 = require("../../utils/getPluginKey");
+const rewriteBarrelImports_1 = require("./rewriteBarrelImports");
 const EMPTY_FILE = '=== empty file ===';
 const hasKeyInList = (plugin, list) => {
     const pluginKey = (0, getPluginKey_1.getPluginKey)(plugin);
@@ -41,34 +43,57 @@ function runPreevalStage(babel, evalConfig, pluginOptions, code, originalAst, ev
     }
     return result;
 }
-const prepareCode = (services, item, originalAst) => {
-    const { log, only, loadedAndParsed } = item;
+const isPrevalOnly = (only) => only.length === 1 && only[0] === '__wywPreval';
+const prepareEvaluatorInput = (services, item, originalAst) => {
+    const { only, loadedAndParsed, log } = item;
     if (loadedAndParsed.evaluator === 'ignored') {
-        log('is ignored');
-        return [loadedAndParsed.code ?? '', null, null];
+        throw new Error(`Cannot prepare ignored entrypoint ${item.name}`);
     }
-    const { code, evalConfig, evaluator } = loadedAndParsed;
+    const { code, evalConfig } = 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] === '__wywPreval' && !transformMetadata) {
+    if (isPrevalOnly(only) && !transformMetadata) {
         log('[evaluator:end] no metadata');
-        return [preevalStageResult.code, null, null];
+        return {
+            kind: 'short-circuit',
+            code: preevalStageResult.code,
+        };
     }
     log('[preeval] metadata %O', transformMetadata);
-    log('[evaluator:start] using %s', evaluator.name);
-    log.extend('source')('%s', preevalStageResult.code);
-    const evaluatorConfig = {
-        onlyExports: only,
-        highPriorityPlugins: pluginOptions.highPriorityPlugins,
-        features: pluginOptions.features,
-        importOverrides: pluginOptions.importOverrides,
-        root: options.root,
+    return {
+        kind: 'continue',
+        ast: preevalStageResult.ast,
+        code: preevalStageResult.code,
+        evalConfig,
+        evaluatorConfig: {
+            onlyExports: only,
+            highPriorityPlugins: pluginOptions.highPriorityPlugins,
+            features: pluginOptions.features,
+            importOverrides: pluginOptions.importOverrides,
+            root: options.root,
+        },
+        metadata: transformMetadata ?? null,
     };
-    const [, transformedCode, imports] = eventEmitter.perf('transform:evaluator', () => evaluator(evalConfig, preevalStageResult.ast, preevalStageResult.code, evaluatorConfig, babel));
+};
+const prepareCode = (services, item, originalAst) => {
+    const { log, loadedAndParsed } = item;
+    if (loadedAndParsed.evaluator === 'ignored') {
+        log('is ignored');
+        return [loadedAndParsed.code ?? '', null, null];
+    }
+    const { evaluator } = loadedAndParsed;
+    const { babel, eventEmitter } = services;
+    const prepared = prepareEvaluatorInput(services, item, originalAst);
+    if (prepared.kind === 'short-circuit') {
+        return [prepared.code, null, null];
+    }
+    log('[evaluator:start] using %s', evaluator.name);
+    log.extend('source')('%s', prepared.code);
+    const [, transformedCode, imports] = eventEmitter.perf('transform:evaluator', () => evaluator(prepared.evalConfig, prepared.ast, prepared.code, prepared.evaluatorConfig, babel));
     log('[evaluator:end]');
-    return [transformedCode, imports, transformMetadata ?? null];
+    return [transformedCode, imports, prepared.metadata];
 };
 exports.prepareCode = prepareCode;
 function* internalTransform(prepareFn) {
@@ -119,6 +144,110 @@ function* internalTransform(prepareFn) {
  * 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);
+function* transform() {
+    const { only, loadedAndParsed, log } = this.entrypoint;
+    if (loadedAndParsed.evaluator === 'ignored') {
+        log('is ignored');
+        return {
+            code: loadedAndParsed.code ?? '',
+            metadata: null,
+        };
+    }
+    if (loadedAndParsed.evaluator !== shaker_1.shaker) {
+        return yield* internalTransform.call(this, exports.prepareCode);
+    }
+    log('>> (%o)', only);
+    const prepared = prepareEvaluatorInput(this.services, this.entrypoint, loadedAndParsed.ast);
+    if (prepared.kind === 'short-circuit') {
+        if (loadedAndParsed.code === prepared.code) {
+            log('<< (%o)\n === no changes ===', only);
+        }
+        else {
+            log('<< (%o)', only);
+            log.extend('source')('%s', prepared.code || EMPTY_FILE);
+        }
+        if (prepared.code === '') {
+            log('is skipped');
+            return {
+                code: loadedAndParsed.code ?? '',
+                metadata: null,
+            };
+        }
+        return {
+            code: prepared.code,
+            metadata: null,
+        };
+    }
+    log('[evaluator:start] using %s', loadedAndParsed.evaluator.name);
+    log.extend('source')('%s', prepared.code);
+    const { babel, eventEmitter } = this.services;
+    const [shakenAst, shakenCode, shakenImports] = eventEmitter.perf('transform:evaluator', () => (0, shaker_1.shakeToESM)(prepared.evalConfig, prepared.ast, prepared.code, prepared.evaluatorConfig, babel));
+    let nextAst = shakenAst;
+    let nextCode = shakenCode;
+    let nextResolvedImports = [];
+    if (shakenImports !== null && shakenImports.size > 0) {
+        const resolvedImports = yield* this.getNext('resolveImports', this.entrypoint, {
+            imports: shakenImports,
+            phase: 'initial',
+        });
+        if (resolvedImports.length > 0) {
+            const rewritten = yield* rewriteBarrelImports_1.rewriteOptimizedBarrelImports.call(this, shakenAst, shakenCode, resolvedImports);
+            nextAst = rewritten.ast;
+            nextCode = rewritten.code;
+            if (rewritten.optimizedCount > 0) {
+                const fullyRewrittenSources = new Set(rewritten.fullyRewrittenSources);
+                const partialFallbackSources = new Set(rewritten.partialFallbackSources);
+                for (const dependency of resolvedImports) {
+                    if (dependency.resolved &&
+                        (fullyRewrittenSources.has(dependency.source) ||
+                            partialFallbackSources.has(dependency.source))) {
+                        if (partialFallbackSources.has(dependency.source)) {
+                            this.entrypoint.addDependency(dependency);
+                        }
+                        else {
+                            this.entrypoint.addInvalidationDependency(dependency);
+                        }
+                        this.entrypoint.markInvalidateOnDependencyChange(dependency.resolved);
+                    }
+                }
+                nextResolvedImports = yield* this.getNext('resolveImports', this.entrypoint, {
+                    imports: rewritten.imports,
+                    phase: 'rewritten',
+                    preResolved: rewritten.preResolvedImports,
+                });
+            }
+            else {
+                nextResolvedImports = resolvedImports;
+            }
+        }
+    }
+    if (nextResolvedImports.length !== 0) {
+        yield [
+            'processImports',
+            this.entrypoint,
+            {
+                resolved: nextResolvedImports,
+            },
+        ];
+    }
+    const [, preparedCode] = eventEmitter.perf('transform:emitCommonJS', () => (0, shaker_1.emitCommonJS)(prepared.evalConfig, nextAst, nextCode, babel));
+    log('[evaluator:end]');
+    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,
+        };
+    }
+    return {
+        code: preparedCode,
+        metadata: prepared.metadata,
+    };
 }

package/types/transform/types.d.ts

@@ -34,6 +34,7 @@ export type AnyIteratorResult<TMode extends 'async' | 'sync', TResult> = {
     sync: IteratorResult<YieldArg, TResult>;
 }[TMode];
 export interface IBaseAction<TAction extends ActionQueueItem, TResult, TData> extends IBaseNode {
+    actionContext: unknown;
     abortSignal: AbortSignal | null;
     createAbortSignal: () => AbortSignal & Disposable;
     data: TData;
@@ -123,6 +124,8 @@ export interface IProcessImportsAction extends IBaseAction<IProcessImportsAction
 }
 export interface IResolveImportsAction extends IBaseAction<IResolveImportsAction, IEntrypointDependency[], {
     imports: Map<string, string[]> | null;
+    phase?: 'initial' | 'rewritten';
+    preResolved?: IEntrypointDependency[];
 }> {
     type: 'resolveImports';
 }

package/types/transform.js

@@ -21,6 +21,24 @@ const resolveImports_1 = require("./transform/generators/resolveImports");
 const withDefaultServices_1 = require("./transform/helpers/withDefaultServices");
 const memoizedSyncResolve = new WeakMap();
 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);
+    }
+    let actionContext = actionContextsByHandlers.get(customHandlersKey);
+    if (!actionContext) {
+        actionContext = {};
+        actionContextsByHandlers.set(customHandlersKey, actionContext);
+    }
+    return actionContext;
+};
 function transformSync(partialServices, originalCode, syncResolve, customHandlers = {}) {
     const { options } = partialServices;
     const pluginOptions = (0, loadWywOptions_1.loadWywOptions)(options.pluginOptions);
@@ -35,6 +53,18 @@ function transformSync(partialServices, originalCode, syncResolve, customHandler
         // 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 {
@@ -42,18 +72,9 @@ function transformSync(partialServices, originalCode, syncResolve, customHandler
             sourceMap: options.inputSourceMap,
         };
     }
-    const workflowAction = entrypoint.createAction('workflow', undefined);
-    if (!memoizedSyncResolve.has(syncResolve)) {
-        memoizedSyncResolve.set(syncResolve, function resolveImports() {
-            return resolveImports_1.syncResolveImports.call(this, syncResolve);
-        });
-    }
+    const workflowAction = entrypoint.createAction('workflow', undefined, null, actionContext);
     try {
-        const result = (0, actionRunner_1.syncActionRunner)(workflowAction, {
-            ...generators_1.baseHandlers,
-            ...customHandlers,
-            resolveImports: memoizedSyncResolve.get(syncResolve),
-        });
+        const result = (0, actionRunner_1.syncActionRunner)(workflowAction, actionHandlers);
         entrypoint.log('%s is ready', entrypoint.name);
         return result;
     }
@@ -92,6 +113,19 @@ 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);
     if (entrypoint.ignored) {
         return {
@@ -99,19 +133,9 @@ async function transform(partialServices, originalCode, asyncResolve, customHand
             sourceMap: options.inputSourceMap,
         };
     }
-    const workflowAction = entrypoint.createAction('workflow', undefined);
-    if (!memoizedAsyncResolve.has(asyncResolve)) {
-        const resolveImports = function resolveImports() {
-            return resolveImports_1.asyncResolveImports.call(this, asyncResolve);
-        };
-        memoizedAsyncResolve.set(asyncResolve, resolveImports);
-    }
+    const workflowAction = entrypoint.createAction('workflow', undefined, null, actionContext);
     try {
-        const result = await (0, actionRunner_1.asyncActionRunner)(workflowAction, {
-            ...generators_1.baseHandlers,
-            ...customHandlers,
-            resolveImports: memoizedAsyncResolve.get(asyncResolve),
-        });
+        const result = await (0, actionRunner_1.asyncActionRunner)(workflowAction, actionHandlers);
         entrypoint.log('%s is ready', entrypoint.name);
         return result;
     }

package/types/utils/collectTemplateDependencies.js

@@ -18,6 +18,15 @@ const valueToLiteral_1 = require("./valueToLiteral");
 function staticEval(ex, evaluate = false) {
     if (!evaluate)
         return undefined;
+    if (ex.isIdentifier()) {
+        const binding = ex.scope.getBinding(ex.node.name);
+        // Babel may "evaluate" a destructured binding to its source container
+        // object/array instead of the bound value, which changes template semantics.
+        if (binding?.path.isVariableDeclarator() &&
+            !binding.path.get('id').isIdentifier()) {
+            return undefined;
+        }
+    }
     const result = ex.evaluate();
     if (result.confident && !(0, shared_1.hasEvalMeta)(result.value)) {
         return [result.value];