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

package/types/transform/generators/processImports.js

@@ -1,7 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processImports = processImports;
-const importOverrides_1 = require("../../utils/importOverrides");
+/* eslint-disable no-continue */
+import { hasCachedWywPrevalExport, } from '../../utils/hasCachedWywPrevalExport';
+import { toImportKey } from '../../utils/importOverrides';
+import { stripQueryAndHash } from '../../utils/parseRequest';
+import { isSuperSet, mergeOnly } from '../Entrypoint.helpers';
 const warnedSlowImportsByServices = new WeakMap();
 function emitWarning(services, message) {
     if (services.emitWarning) {
@@ -22,10 +23,18 @@ function getWarnedSlowImports(services) {
 function isWarningEnabled(value) {
     return Boolean(value) && value !== '0' && value !== 'false';
 }
-/**
- * Creates new entrypoints and emits processEntrypoint for each resolved import
- */
-function* processImports() {
+function hasLoop(name, parent, processed = []) {
+    if (parent.name === name || processed.includes(parent.name)) {
+        return true;
+    }
+    for (const nextParent of parent.parents) {
+        if (hasLoop(name, nextParent, [...processed, parent.name])) {
+            return true;
+        }
+    }
+    return false;
+}
+export function* processImports() {
     const slowImportWarningsEnabled = isWarningEnabled(process.env.WYW_WARN_SLOW_IMPORTS);
     const slowImportThresholdMs = (() => {
         const raw = process.env.WYW_WARN_SLOW_IMPORTS_MS;
@@ -40,13 +49,44 @@ function* processImports() {
         ? getWarnedSlowImports(this.services)
         : null;
     const { root } = this.services.options;
+    const prepareStageRequiresEvaluatedDeps = this.entrypoint.only.includes('__wywPreval');
+    const skippedParentDependencySources = new Set(this.data.skipParentDependencyTracking ?? []);
     for (const dependency of this.data.resolved) {
         const { resolved, only } = dependency;
         if (!resolved) {
             continue;
         }
-        this.entrypoint.addDependency(dependency);
-        const nextEntrypoint = this.entrypoint.createChild(resolved, only);
+        const cached = this.services.cache.get('entrypoints', resolved);
+        const shouldRequireWywPreval = prepareStageRequiresEvaluatedDeps &&
+            (!cached?.evaluated ||
+                cached.ignored ||
+                hasCachedWywPrevalExport(this.services, resolved, cached));
+        const requiredOnly = shouldRequireWywPreval
+            ? mergeOnly(only, ['__wywPreval'])
+            : only;
+        if (!skippedParentDependencySources.has(dependency.source)) {
+            this.entrypoint.addDependency({
+                ...dependency,
+                only: requiredOnly,
+            });
+        }
+        const canReuseTransformedDependency = !prepareStageRequiresEvaluatedDeps &&
+            Boolean(cached && !cached.evaluated && cached.transformed);
+        if (cached &&
+            (cached.evaluated || canReuseTransformedDependency) &&
+            isSuperSet(cached.only, requiredOnly) &&
+            !hasLoop(resolved, this.entrypoint) &&
+            !this.services.cache.checkFreshness(resolved, stripQueryAndHash(resolved))) {
+            if (Array.isArray(cached.parents)) {
+                if (!cached.parents
+                    .map((parent) => parent.name)
+                    .includes(this.entrypoint.name)) {
+                    cached.parents.push(this.entrypoint);
+                }
+            }
+            continue;
+        }
+        const nextEntrypoint = this.entrypoint.createChild(resolved, requiredOnly);
         if (nextEntrypoint === 'loop' || nextEntrypoint.ignored) {
             continue;
         }
@@ -57,7 +97,7 @@ function* processImports() {
             slowImportThresholdMs > 0) {
             const durationMs = performance.now() - startedAt;
             if (durationMs >= slowImportThresholdMs) {
-                const { key: importKey } = (0, importOverrides_1.toImportKey)({
+                const { key: importKey } = toImportKey({
                     source: dependency.source,
                     resolved,
                     root,
@@ -66,20 +106,20 @@ function* processImports() {
                 if (!warnedSlowImports.has(dedupeKey)) {
                     warnedSlowImports.add(dedupeKey);
                     const warning = [
-                        `[wyw-in-js] Slow import during prepare stage`,
-                        ``,
+                        '[wyw-in-js] Slow import during prepare stage',
+                        '',
                         `file: ${this.entrypoint.name}`,
                         `import: ${dependency.source}`,
                         `resolved: ${resolved}`,
                         `duration: ${durationMs.toFixed(1)}ms`,
-                        ``,
-                        `tip: if this import is runtime-only or heavy, mock it during evaluation via importOverrides:`,
-                        `  importOverrides: {`,
+                        '',
+                        'tip: if this import is runtime-only or heavy, mock it during evaluation via importOverrides:',
+                        '  importOverrides: {',
                         `    '${importKey}': { mock: './path/to/mock' },`,
-                        `  }`,
-                        ``,
-                        `note: importOverrides affects only build-time evaluation (it does not change your bundler runtime behavior)`,
-                        ``,
+                        '  }',
+                        '',
+                        'note: importOverrides affects only build-time evaluation (it does not change your bundler runtime behavior)',
+                        '',
                         `note: configure threshold with WYW_WARN_SLOW_IMPORTS_MS (current: ${slowImportThresholdMs}ms)`,
                     ].join('\n');
                     emitWarning(this.services, warning);

package/types/transform/generators/resolveImports.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncResolveImports = syncResolveImports;
-exports.asyncResolveImports = asyncResolveImports;
 /* eslint-disable no-continue,no-await-in-loop,require-yield */
-const getFileIdx_1 = require("../../utils/getFileIdx");
-const Entrypoint_helpers_1 = require("../Entrypoint.helpers");
-const importOverrides_1 = require("../../utils/importOverrides");
+import { getFileIdx } from '../../utils/getFileIdx';
+import { getStack, isSuperSet, mergeOnly } from '../Entrypoint.helpers';
+import { applyImportOverrideToOnly, getImportOverride, resolveMockSpecifier, toImportKey, } from '../../utils/importOverrides';
 function applyImportOverrides(services, entrypoint, resolvedImports) {
     const overrides = services.options.pluginOptions.importOverrides;
     if (!overrides || Object.keys(overrides).length === 0) {
@@ -13,20 +9,20 @@ function applyImportOverrides(services, entrypoint, resolvedImports) {
     }
     const { root } = services.options;
     const importer = entrypoint.name;
-    const stack = (0, Entrypoint_helpers_1.getStack)(entrypoint);
+    const stack = getStack(entrypoint);
     return resolvedImports.map((dependency) => {
-        const { key } = (0, importOverrides_1.toImportKey)({
+        const { key } = toImportKey({
             source: dependency.source,
             resolved: dependency.resolved,
             root,
         });
-        const override = (0, importOverrides_1.getImportOverride)(overrides, key);
+        const override = getImportOverride(overrides, key);
         if (!override) {
             return dependency;
         }
-        const nextOnly = (0, importOverrides_1.applyImportOverrideToOnly)(dependency.only, override);
+        const nextOnly = applyImportOverrideToOnly(dependency.only, override);
         const nextResolved = override.mock
-            ? (0, importOverrides_1.resolveMockSpecifier)({
+            ? resolveMockSpecifier({
                 mock: override.mock,
                 importer,
                 root,
@@ -50,7 +46,7 @@ function emitDependency(emitter, entrypoint, imports, phase) {
             from: resolved,
             what: only,
         })),
-        fileIdx: (0, getFileIdx_1.getFileIdx)(entrypoint.name),
+        fileIdx: getFileIdx(entrypoint.name),
     });
 }
 function filterUnresolved(entrypoint, resolvedImports) {
@@ -68,7 +64,7 @@ function getPreResolvedImports(preResolved) {
 /**
  * Synchronously resolves specified imports with a provided resolver.
  */
-function* syncResolveImports(resolve) {
+export function* syncResolveImports(resolve) {
     const { data: { imports }, entrypoint, services: { eventEmitter }, } = this;
     const listOfImports = Array.from(imports?.entries() ?? []);
     const preResolvedImports = getPreResolvedImports(this.data.preResolved);
@@ -81,7 +77,7 @@ function* syncResolveImports(resolve) {
     const resolvedImports = listOfImports.map(([source, only]) => {
         const preResolved = preResolvedImports.get(source);
         if (preResolved) {
-            const mergedOnly = (0, Entrypoint_helpers_1.mergeOnly)(preResolved.only, only);
+            const mergedOnly = mergeOnly(preResolved.only, only);
             log('[sync-resolve] ♻️ %s -> %s (only: %o)', source, preResolved.resolved, mergedOnly);
             return {
                 ...preResolved,
@@ -90,7 +86,7 @@ function* syncResolveImports(resolve) {
         }
         let resolved = null;
         try {
-            resolved = resolve(source, entrypoint.name, (0, Entrypoint_helpers_1.getStack)(entrypoint));
+            resolved = resolve(source, entrypoint.name, getStack(entrypoint));
             log('[sync-resolve] ✅ %s -> %s (only: %o)', source, resolved, only);
         }
         catch (err) {
@@ -110,7 +106,7 @@ function* syncResolveImports(resolve) {
 /**
  * Asynchronously resolves specified imports with a provided resolver.
  */
-async function* asyncResolveImports(resolve) {
+export async function* asyncResolveImports(resolve) {
     const { data: { imports }, entrypoint, services: { eventEmitter }, } = this;
     const listOfImports = Array.from(imports?.entries() ?? []);
     const preResolvedImports = getPreResolvedImports(this.data.preResolved);
@@ -124,7 +120,7 @@ async function* asyncResolveImports(resolve) {
     const getResolveTask = async (source, only) => {
         let resolved = null;
         try {
-            resolved = await resolve(source, entrypoint.name, (0, Entrypoint_helpers_1.getStack)(entrypoint));
+            resolved = await resolve(source, entrypoint.name, getStack(entrypoint));
         }
         catch (err) {
             log('[async-resolve] ❌ cannot resolve %s in %s: %O', source, entrypoint.name, err);
@@ -141,7 +137,7 @@ async function* asyncResolveImports(resolve) {
     const resolvedImports = await Promise.all(listOfImports.map(([source, importsOnly]) => {
         const preResolved = preResolvedImports.get(source);
         if (preResolved) {
-            const mergedOnly = (0, Entrypoint_helpers_1.mergeOnly)(preResolved.only, importsOnly);
+            const mergedOnly = mergeOnly(preResolved.only, importsOnly);
             log('[async-resolve] ♻️ %s (%o) in %s -> %s', source, mergedOnly, entrypoint.name, preResolved.resolved);
             return {
                 ...preResolved,
@@ -152,7 +148,7 @@ async function* asyncResolveImports(resolve) {
         if (cached) {
             return {
                 source,
-                only: (0, Entrypoint_helpers_1.mergeOnly)(cached.only, importsOnly),
+                only: mergeOnly(cached.only, importsOnly),
                 resolved: cached.resolved,
             };
         }
@@ -160,11 +156,11 @@ async function* asyncResolveImports(resolve) {
         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)) {
+                if (isSuperSet(res.only, importsOnly)) {
                     return res;
                 }
                 // Is this branch even possible?
-                const merged = (0, Entrypoint_helpers_1.mergeOnly)(res.only, importsOnly);
+                const merged = mergeOnly(res.only, importsOnly);
                 log('merging imports %o and %o: %o', importsOnly, res.only, merged);
                 return { ...res, only: merged };
             });

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

@@ -0,0 +1,2 @@
+import type { ITransformAction, SyncScenarioFor } from '../types';
+export declare function resolveStaticOxcPreevalValues(this: ITransformAction): SyncScenarioFor<boolean>;