@wyw-in-js/transform 1.0.6 → 1.0.7

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

@@ -123,6 +123,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';
 }