@webstir-io/webstir-frontend 0.1.40 → 0.1.41

package/src/watch/watchDaemon.ts

@@ -1,144 +0,0 @@
-import process from 'node:process';
-import { createInterface, Interface as ReadLineInterface } from 'node:readline';
-import { emitDiagnostic } from '../core/diagnostics.js';
-import { WatchCoordinator } from './watchCoordinator.js';
-import type { WatchDaemonCommand, WatchDaemonOptions } from './types.js';
-
-export class WatchDaemon {
-    private readonly coordinator: WatchCoordinator;
-    private readonly options: WatchDaemonOptions;
-    private readonly shutdownPromise: Promise<void>;
-    private resolveShutdown: (() => void) | null = null;
-    private commandQueue: Promise<void> = Promise.resolve();
-    private isShuttingDown = false;
-    private rl?: ReadLineInterface;
-
-    public constructor(options: WatchDaemonOptions) {
-        this.options = options;
-        this.coordinator = new WatchCoordinator({
-            workspaceRoot: options.workspaceRoot,
-            verbose: options.verbose ?? false,
-            hmrVerbose: options.hmrVerbose ?? false
-        });
-        this.shutdownPromise = new Promise((resolve) => {
-            this.resolveShutdown = resolve;
-        });
-    }
-
-    public async run(): Promise<void> {
-        if (this.options.autoStart !== false) {
-            await this.coordinator.start();
-        }
-
-        this.setupSignalHandlers();
-        this.setupCommandLoop();
-
-        await this.shutdownPromise;
-    }
-
-    private setupCommandLoop(): void {
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(false);
-        }
-        process.stdin.setEncoding('utf8');
-
-        this.rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
-        this.rl.on('line', (line) => this.processLine(line));
-        this.rl.on('close', () => {
-            void this.shutdown();
-        });
-    }
-
-    private setupSignalHandlers(): void {
-        const shutdown = () => {
-            void this.shutdown();
-        };
-
-        process.on('SIGINT', shutdown);
-        process.on('SIGTERM', shutdown);
-    }
-
-    private processLine(rawLine: string): void {
-        const line = rawLine.trim();
-        if (line.length === 0) {
-            return;
-        }
-
-        let command: WatchDaemonCommand | null = null;
-        try {
-            command = JSON.parse(line) as WatchDaemonCommand;
-        } catch (error) {
-            emitDiagnostic({
-                code: 'frontend.watch.command.invalid',
-                kind: 'watch-daemon',
-                stage: 'command',
-                severity: 'warning',
-                message: `Discarding invalid command payload: ${String(error)}`
-            });
-            return;
-        }
-
-        this.commandQueue = this.commandQueue.then(() => this.handleCommand(command!)).catch((error) => {
-            emitDiagnostic({
-                code: 'frontend.watch.command.failure',
-                kind: 'watch-daemon',
-                stage: 'command',
-                severity: 'error',
-                message: `Command handling failed: ${error instanceof Error ? error.message : String(error)}`
-            });
-        });
-    }
-
-    private async handleCommand(command: WatchDaemonCommand): Promise<void> {
-        switch (command.type) {
-            case 'start':
-                await this.coordinator.start();
-                return;
-            case 'reload':
-                await this.coordinator.reload();
-                return;
-            case 'change':
-                await this.coordinator.handleChange({ path: command.path });
-                return;
-            case 'shutdown':
-                await this.shutdown();
-                return;
-            case 'ping':
-                emitDiagnostic({
-                    code: 'frontend.watch.pong',
-                    kind: 'watch-daemon',
-                    stage: 'command',
-                    severity: 'info',
-                    message: 'Watch daemon heartbeat acknowledged.',
-                    data: command.id ? { id: command.id } : undefined
-                });
-                return;
-            default:
-                emitDiagnostic({
-                    code: 'frontend.watch.command.unknown',
-                    kind: 'watch-daemon',
-                    stage: 'command',
-                    severity: 'warning',
-                    message: `Unknown watch daemon command: ${(command as { type?: unknown }).type}`
-                });
-                return;
-        }
-    }
-
-    private async shutdown(): Promise<void> {
-        if (this.isShuttingDown) {
-            return;
-        }
-
-        this.isShuttingDown = true;
-
-        if (this.rl) {
-            this.rl.close();
-            this.rl = undefined;
-        }
-
-        await this.coordinator.stop();
-        this.resolveShutdown?.();
-        this.resolveShutdown = null;
-    }
-}

package/src/watch/watchReporter.ts

@@ -1,98 +0,0 @@
-import type { BuildResult, Message } from 'esbuild';
-import { emitDiagnostic } from '../core/diagnostics.js';
-import type { DiagnosticEvent } from '../core/diagnostics.js';
-
-export interface WatchReporterOptions {
-    readonly verbose: boolean;
-}
-
-export interface SerializedMessage {
-    readonly text: string;
-    readonly location?: {
-        readonly file?: string;
-        readonly line?: number;
-        readonly column?: number;
-    };
-}
-
-export class WatchReporter {
-    private readonly verbose: boolean;
-
-    public constructor(options: WatchReporterOptions) {
-        this.verbose = options.verbose;
-    }
-
-    public emit(event: DiagnosticEvent): void {
-        emitDiagnostic(event);
-    }
-
-    public emitVerbose(event: DiagnosticEvent): void {
-        if (!this.verbose) {
-            return;
-        }
-
-        emitDiagnostic(event);
-    }
-
-    public emitJavaScriptStats(pageName: string, result: BuildResult, durationMs: number): void {
-        if (!this.verbose) {
-            return;
-        }
-
-        const stats = extractMetafileStats(result);
-        const data: Record<string, unknown> = {
-            page: pageName,
-            durationMs: Number(durationMs.toFixed(1))
-        };
-
-        if (stats) {
-            data.inputs = stats.inputs;
-            data.outputs = stats.outputs;
-            data.bytes = stats.bytes;
-        }
-
-        emitDiagnostic({
-            code: 'frontend.watch.javascript.build.stats',
-            kind: 'watch-daemon',
-            stage: 'javascript',
-            severity: 'info',
-            message: `JavaScript rebuild stats for '${pageName}' (${durationMs.toFixed(1)}ms).`,
-            data
-        });
-    }
-}
-
-export function serializeMessages(messages: readonly Message[]): SerializedMessage[] {
-    return messages.map((message) => ({
-        text: message.text,
-        location: message.location
-            ? {
-                  file: message.location.file,
-                  line: message.location.line,
-                  column: message.location.column
-              }
-            : undefined
-    }));
-}
-
-function extractMetafileStats(result: BuildResult): MetafileStats | null {
-    if (!result.metafile) {
-        return null;
-    }
-
-    const inputs = Object.keys(result.metafile.inputs ?? {}).length;
-    const outputsEntries = Object.entries(result.metafile.outputs ?? {});
-    const bytes = outputsEntries.reduce((sum, [, output]) => sum + (output.bytes ?? 0), 0);
-
-    return {
-        inputs,
-        outputs: outputsEntries.length,
-        bytes
-    };
-}
-
-interface MetafileStats {
-    readonly inputs: number;
-    readonly outputs: number;
-    readonly bytes: number;
-}