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

package/types/debug/fileReporter.js

@@ -1,17 +1,18 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFileReporter = void 0;
 /* eslint-disable no-console */
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const EventEmitter_1 = require("../utils/EventEmitter");
+import { createWriteStream, existsSync, mkdirSync } from 'fs';
+import path from 'path';
+import { EventEmitter, isOnActionStartArgs } from '../utils/EventEmitter';
 const workingDir = process.cwd();
 function replacer(_key, value) {
-    if (typeof value === 'string' && path_1.default.isAbsolute(value)) {
-        return path_1.default.relative(workingDir, value);
+    if (value instanceof Error) {
+        return {
+            message: value.message,
+            name: value.name,
+            stack: value.stack,
+        };
+    }
+    if (typeof value === 'string' && path.isAbsolute(value)) {
+        return path.relative(workingDir, value);
     }
     if (value instanceof Map) {
         return Array.from(value.entries()).reduce((obj, [k, v]) => {
@@ -38,7 +39,7 @@ function printTimings(timings, startedAt, sourceRoot) {
             .sort(([a], [b]) => a.localeCompare(b))
             .forEach(([value, time]) => {
             const name = value.startsWith(sourceRoot)
-                ? path_1.default.relative(sourceRoot, value)
+                ? path.relative(sourceRoot, value)
                 : value;
             console.log(`    ${name}: ${time}ms`);
         });
@@ -47,24 +48,50 @@ function printTimings(timings, startedAt, sourceRoot) {
 const writeJSONl = (stream, data) => {
     stream.write(`${JSON.stringify(data, replacer)}\n`);
 };
-const createFileReporter = (options = false) => {
+const isPerfFinishEvent = (event) => {
+    if (!event || typeof event !== 'object') {
+        return false;
+    }
+    return ('type' in event &&
+        event.type === 'perf-span' &&
+        'method' in event &&
+        typeof event.method === 'string' &&
+        'spanId' in event &&
+        typeof event.spanId === 'number' &&
+        'startedAt' in event &&
+        typeof event.startedAt === 'number' &&
+        'finishedAt' in event &&
+        typeof event.finishedAt === 'number' &&
+        'durationMs' in event &&
+        typeof event.durationMs === 'number');
+};
+const isPerfStartEvent = (event) => {
+    if (!event || typeof event !== 'object') {
+        return false;
+    }
+    return 'type' in event && event.type === 'perf-span-start';
+};
+export const createFileReporter = (options = false) => {
     if (!options || !options.dir) {
         return {
-            emitter: EventEmitter_1.EventEmitter.dummy,
+            emitter: EventEmitter.dummy,
             onDone: () => { },
         };
     }
-    const reportFolder = (0, fs_1.existsSync)(options.dir)
+    const reportFolder = existsSync(options.dir)
         ? options.dir
-        : (0, fs_1.mkdirSync)(options.dir, {
+        : mkdirSync(options.dir, {
             recursive: true,
         });
     if (!reportFolder) {
         throw new Error(`Could not create directory ${options.dir}`);
     }
-    const actionStream = (0, fs_1.createWriteStream)(path_1.default.join(options.dir, 'actions.jsonl'));
-    const dependenciesStream = (0, fs_1.createWriteStream)(path_1.default.join(options.dir, 'dependencies.jsonl'));
-    const entrypointStream = (0, fs_1.createWriteStream)(path_1.default.join(options.dir, 'entrypoints.jsonl'));
+    const actionStream = createWriteStream(path.join(options.dir, 'actions.jsonl'));
+    const dependenciesStream = createWriteStream(path.join(options.dir, 'dependencies.jsonl'));
+    const entrypointStream = createWriteStream(path.join(options.dir, 'entrypoints.jsonl'));
+    const staticResolveStream = createWriteStream(path.join(options.dir, 'static-resolve.jsonl'));
+    const perfSpanStream = createWriteStream(path.join(options.dir, 'perf-spans.jsonl'));
+    const evalFilesStream = createWriteStream(path.join(options.dir, 'eval-files.jsonl'));
     const startedAt = performance.now();
     const timings = new Map();
     const addTiming = (label, key, value) => {
@@ -85,14 +112,29 @@ const createFileReporter = (options = false) => {
     const processSingleEvent = (meta) => {
         if (meta.type === 'dependency') {
             processDependencyEvent(meta);
+            return;
+        }
+        if (meta.type === 'staticResolve') {
+            writeJSONl(staticResolveStream, meta);
+        }
+        if (meta.type === 'eval-file') {
+            writeJSONl(evalFilesStream, meta);
         }
     };
     const startTimes = new Map();
-    const onEvent = (meta, type) => {
+    const onEvent = (meta, type, event) => {
         if (type === 'single') {
             processSingleEvent(meta);
             return;
         }
+        if (type === 'finish' && isPerfFinishEvent(event)) {
+            addTiming('method', event.method, event.durationMs);
+            writeJSONl(perfSpanStream, event);
+            return;
+        }
+        if (type === 'start' && isPerfStartEvent(event)) {
+            return;
+        }
         if (type === 'start') {
             Object.entries(meta).forEach(([label, value]) => {
                 startTimes.set(`${label}\0${value}`, performance.now());
@@ -109,7 +151,7 @@ const createFileReporter = (options = false) => {
     };
     let actionId = 0;
     const onAction = (...args) => {
-        if ((0, EventEmitter_1.isOnActionStartArgs)(args)) {
+        if (isOnActionStartArgs(args)) {
             const [, timestamp, type, idx, entrypointRef] = args;
             writeJSONl(actionStream, {
                 actionId,
@@ -134,7 +176,7 @@ const createFileReporter = (options = false) => {
     const onEntrypointEvent = (emitterId, timestamp, event) => {
         entrypointStream.write(`${JSON.stringify([emitterId, timestamp, event])}\n`);
     };
-    const emitter = new EventEmitter_1.EventEmitter(onEvent, onAction, onEntrypointEvent);
+    const emitter = new EventEmitter(onEvent, onAction, onEntrypointEvent);
     return {
         emitter,
         onDone: (sourceRoot) => {
@@ -144,8 +186,11 @@ const createFileReporter = (options = false) => {
             }
             actionStream.end();
             dependenciesStream.end();
+            entrypointStream.end();
+            staticResolveStream.end();
+            perfSpanStream.end();
+            evalFilesStream.end();
             timings.clear();
         },
     };
 };
-exports.createFileReporter = createFileReporter;

package/types/eval/broker.d.ts

@@ -0,0 +1,92 @@
+import type { Entrypoint } from '../transform/Entrypoint';
+import type { Services } from '../transform/types';
+type EvaluateResult = {
+    values: Map<string, unknown> | null;
+    dependencies: string[];
+};
+export declare const stripEntrypointGlobalsFromRunnerContext: (globals: Record<string, unknown>, entrypoint: string) => Record<string, unknown>;
+export declare class EvalBroker {
+    private readonly services;
+    private readonly asyncResolve;
+    private runner;
+    private runnerInputQueue;
+    private runnerReady;
+    private lastInitKey;
+    private lastHappyDomEnabled;
+    private evalQueue;
+    private readonly pending;
+    private nextId;
+    private readonly resolveCache;
+    private readonly resolveInFlight;
+    private readonly loadCache;
+    private readonly loadInFlight;
+    private readonly importsByModule;
+    private readonly onlyByModule;
+    private readonly sessionLinkGraph;
+    private readonly runtimeDependenciesByModule;
+    private readonly emittedDependencies;
+    private readonly lastSentLoadByModule;
+    private pendingEvals;
+    private evalFlushScheduled;
+    private stableInitHashCache;
+    private evalSeq;
+    private evalFileDebugLines;
+    private happyDomDisabled;
+    private happyDomDisableWarned;
+    private activeResolveRootId;
+    private currentServices;
+    constructor(services: Services, asyncResolve: (what: string, importer: string, stack: string[]) => Promise<string | null>);
+    private ensureImportsMapping;
+    private getImportOnly;
+    private getLoadRequestOnly;
+    evaluate(entrypoint: Entrypoint, services?: Services): Promise<EvaluateResult>;
+    private scheduleEvalFlush;
+    private runEvalBatch;
+    private runOneEntrypoint;
+    private recordEvalFileDebugLine;
+    private flushEvalFileDebugLines;
+    private resetPerEntrypointState;
+    private applyModuleExports;
+    dispose(): void;
+    private createRunnerProcess;
+    private attachRunnerListeners;
+    private ensureRunner;
+    private initIsolatedRunner;
+    private replaceRunner;
+    private getStableInitHash;
+    private initRunner;
+    private getRunnerFeatures;
+    private getInitTimeoutMs;
+    private warnHappyDomDisabledOnce;
+    private onData;
+    private handleMessage;
+    private handleRunnerStderr;
+    private handleWarn;
+    private handleResolve;
+    private normalizeResolvedId;
+    private resolveImport;
+    private getResolveStack;
+    private resolveImportImpl;
+    private finalizeResolvedImport;
+    private emitDependency;
+    private trackRuntimeDependency;
+    private trackImporterDependency;
+    private collectEntrypointDependencies;
+    private applyImportOverrides;
+    private resolveWithNativeFallback;
+    private maybeWarnNativeFallback;
+    private handleLoad;
+    private loadModule;
+    private loadModuleImpl;
+    private sendLoadResult;
+    private sendMessage;
+    private handleSendMessageError;
+    private request;
+    private resolvePending;
+    private rejectPending;
+    private rejectAllPending;
+    private mergeKnownDependencyOnly;
+}
+export declare const disposeEvalBroker: (cache: Services["cache"]) => void;
+export declare const getEvalBroker: (services: Services, asyncResolve: (what: string, importer: string, stack: string[]) => Promise<string | null>, cacheKey: string) => EvalBroker;
+export {};