@abreen/tada 1.13.7 → 1.14.1

package/watch/engine.ts

@@ -1,296 +0,0 @@
-import chokidar from 'chokidar';
-import { applyCommitPlan } from './fs-commit';
-import { emitWatchEvent } from './events';
-import type {
-  ChangeBatch,
-  CompilerBuildResult,
-  CompilerPlanResult,
-  WatchEngineOptions,
-  WatchEventKind,
-} from './types';
-
-function normalizeBatch(changes: Map<string, WatchEventKind>): ChangeBatch {
-  return {
-    changes: [...changes.entries()]
-      .sort(([a], [b]) => a.localeCompare(b))
-      .map(([path, kind]) => ({ path, kind })),
-  };
-}
-
-function mergeChangeKind(
-  previous: WatchEventKind | undefined,
-  next: WatchEventKind,
-): WatchEventKind {
-  if (!previous) {
-    return next;
-  }
-  if (previous === 'add' && next === 'unlink') {
-    return 'change';
-  }
-  if (previous === 'unlink' && next === 'add') {
-    return 'change';
-  }
-  if (previous === 'add' || next === 'add') {
-    return 'add';
-  }
-  if (previous === 'unlink' || next === 'unlink') {
-    return 'unlink';
-  }
-  return 'change';
-}
-
-function toDiagnostics(error: unknown): { message: string }[] {
-  if (error instanceof Error) {
-    return [{ message: error.message }];
-  }
-  return [{ message: String(error) }];
-}
-
-function isNoopCommit(commit: {
-  kind: string;
-  mutations?: unknown[];
-}): boolean {
-  return (
-    commit.kind === 'apply-mutations' && (commit.mutations?.length ?? 0) === 0
-  );
-}
-
-type BuildAttemptOutcome<Snapshot, Meta> =
-  | { kind: 'skipped'; batch: ChangeBatch; initial: boolean }
-  | {
-      kind: 'succeeded';
-      batch?: ChangeBatch;
-      initial: boolean;
-      result: Extract<CompilerBuildResult<Snapshot, Meta>, { ok: true }>;
-    }
-  | {
-      kind: 'failed';
-      batch?: ChangeBatch;
-      initial: boolean;
-      diagnostics: { message: string }[];
-      meta?: Meta;
-    };
-
-export async function runWatchEngine<Snapshot, Plan, Meta>(
-  options: WatchEngineOptions<Snapshot, Plan, Meta>,
-): Promise<void> {
-  const debounceMs = options.debounceMs ?? 300;
-  let snapshot: Snapshot | undefined;
-  let pending = new Map<string, WatchEventKind>();
-  let blocked = new Map<string, WatchEventKind>();
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  let running = false;
-
-  async function waitForQuietPeriod(): Promise<void> {
-    await new Promise(resolve => setTimeout(resolve, debounceMs));
-  }
-
-  async function runBuild(
-    batch?: ChangeBatch,
-    initial: boolean = false,
-  ): Promise<BuildAttemptOutcome<Snapshot, Meta>> {
-    await emitWatchEvent(options, { kind: 'build-started', batch, initial });
-    try {
-      let result: CompilerBuildResult<Snapshot, Meta> | null = null;
-      if (initial) {
-        result = await options.compiler.buildInitial();
-      } else if (batch) {
-        const nextPlan: CompilerPlanResult<Plan> = await options.compiler.plan(
-          snapshot,
-          batch,
-        );
-        if (nextPlan.kind === 'skip') {
-          return { kind: 'skipped', batch, initial };
-        }
-        result = await options.compiler.run(nextPlan.plan, snapshot);
-      }
-      if (!result) {
-        return { kind: 'skipped', batch: batch!, initial };
-      }
-
-      if (result.ok) {
-        return { kind: 'succeeded', batch, initial, result };
-      }
-
-      return {
-        kind: 'failed',
-        batch,
-        initial,
-        diagnostics: result.diagnostics,
-        meta: result.meta,
-      };
-    } catch (error) {
-      return {
-        kind: 'failed',
-        batch,
-        initial,
-        diagnostics: toDiagnostics(error),
-      };
-    }
-  }
-
-  async function flush(): Promise<void> {
-    if (running) {
-      return;
-    }
-    running = true;
-    try {
-      let finalSuccess:
-        | {
-            batch?: ChangeBatch;
-            initial: boolean;
-            result: Extract<CompilerBuildResult<Snapshot, Meta>, { ok: true }>;
-            changed: boolean;
-          }
-        | undefined;
-
-      while (pending.size > 0) {
-        const batch = normalizeBatch(pending);
-        pending = new Map();
-        const outcome = await runBuild(batch, false);
-
-        if (outcome.kind === 'skipped') {
-          if (pending.size === 0 && !finalSuccess) {
-            await emitWatchEvent(options, {
-              kind: 'build-skipped',
-              batch: outcome.batch,
-            });
-          }
-          continue;
-        }
-
-        if (outcome.kind === 'failed') {
-          await emitWatchEvent(options, {
-            kind: 'build-failed',
-            initial: outcome.initial,
-            batch: outcome.batch,
-            diagnostics: outcome.diagnostics,
-            meta: outcome.meta,
-          });
-          if (outcome.batch) {
-            for (const change of outcome.batch.changes) {
-              blocked.set(
-                change.path,
-                mergeChangeKind(blocked.get(change.path), change.kind),
-              );
-            }
-          }
-          return;
-        }
-
-        const changed = !isNoopCommit(outcome.result.commit);
-        if (changed) {
-          applyCommitPlan(outcome.result.commit);
-        }
-        snapshot = outcome.result.snapshot;
-        finalSuccess = {
-          batch: outcome.batch,
-          initial: outcome.initial,
-          result: outcome.result,
-          changed: (finalSuccess?.changed ?? false) || changed,
-        };
-
-        if (pending.size === 0) {
-          await waitForQuietPeriod();
-        }
-      }
-
-      if (finalSuccess) {
-        await emitWatchEvent(options, {
-          kind: 'build-succeeded',
-          initial: finalSuccess.initial,
-          batch: finalSuccess.batch,
-          changed: finalSuccess.changed,
-          snapshot: finalSuccess.result.snapshot,
-          meta: finalSuccess.result.meta,
-          diagnostics: finalSuccess.result.diagnostics || [],
-        });
-      }
-    } finally {
-      running = false;
-      if (pending.size > 0) {
-        schedule();
-      }
-    }
-  }
-
-  function schedule(): void {
-    if (timer) {
-      clearTimeout(timer);
-    }
-    timer = setTimeout(() => {
-      timer = null;
-      void flush();
-    }, debounceMs);
-  }
-
-  function onFileChange(filePath: string, kind: WatchEventKind): void {
-    if (blocked.size > 0) {
-      for (const [blockedPath, blockedKind] of blocked) {
-        pending.set(
-          blockedPath,
-          mergeChangeKind(pending.get(blockedPath), blockedKind),
-        );
-      }
-      blocked = new Map();
-    }
-    pending.set(filePath, mergeChangeKind(pending.get(filePath), kind));
-    schedule();
-  }
-
-  const initialOutcome = await runBuild(undefined, true);
-  if (initialOutcome.kind === 'failed') {
-    await emitWatchEvent(options, {
-      kind: 'build-failed',
-      initial: true,
-      diagnostics: initialOutcome.diagnostics,
-      meta: initialOutcome.meta,
-    });
-  } else if (initialOutcome.kind === 'succeeded') {
-    applyCommitPlan(initialOutcome.result.commit);
-    snapshot = initialOutcome.result.snapshot;
-    await emitWatchEvent(options, {
-      kind: 'build-succeeded',
-      initial: true,
-      changed: !isNoopCommit(initialOutcome.result.commit),
-      snapshot: initialOutcome.result.snapshot,
-      meta: initialOutcome.result.meta,
-      diagnostics: initialOutcome.result.diagnostics || [],
-    });
-  }
-
-  const watcherEntries = options.compiler
-    .getWatchTargets()
-    .map(target => ({
-      target,
-      watcher: chokidar.watch(target.path, {
-        ignoreInitial: true,
-        atomic: true,
-        awaitWriteFinish: { stabilityThreshold: 100 },
-        depth: target.chokidar?.depth,
-      }),
-    }));
-
-  let readyCount = 0;
-  const readyGoal = watcherEntries.length;
-  const onReady = async () => {
-    readyCount += 1;
-    if (readyCount === readyGoal) {
-      await emitWatchEvent(options, { kind: 'watching' });
-    }
-  };
-
-  for (const { watcher, target } of watcherEntries) {
-    const emitIfIncluded = (filePath: string, kind: WatchEventKind) => {
-      if (!target.filter || target.filter(filePath)) {
-        onFileChange(filePath, kind);
-      }
-    };
-    watcher.on('add', filePath => emitIfIncluded(filePath, 'add'));
-    watcher.on('change', filePath => emitIfIncluded(filePath, 'change'));
-    watcher.on('unlink', filePath => emitIfIncluded(filePath, 'unlink'));
-    watcher.on('ready', () => void onReady());
-  }
-
-  return new Promise(() => {});
-}

package/watch/events.ts

@@ -1,10 +0,0 @@
-import type { WatchEngineOptions, WatchLifecycleEvent } from './types';
-
-export async function emitWatchEvent<Snapshot, Plan, Meta>(
-  options: WatchEngineOptions<Snapshot, Plan, Meta>,
-  event: WatchLifecycleEvent<Snapshot, Meta>,
-): Promise<void> {
-  if (options.onEvent) {
-    await options.onEvent(event);
-  }
-}

package/watch/types.d.ts

@@ -1,103 +0,0 @@
-export type WatchEventKind = 'add' | 'change' | 'unlink';
-
-export interface FileChange {
-  path: string;
-  kind: WatchEventKind;
-}
-
-export interface ChangeBatch {
-  changes: FileChange[];
-}
-
-export interface WatchTarget {
-  path: string;
-  chokidar?: { depth?: number };
-  filter?: (filePath: string) => boolean;
-}
-
-export interface WatchDiagnostic {
-  message: string;
-}
-
-export interface WriteFileMutation {
-  kind: 'write';
-  path: string;
-  content: string | Buffer;
-}
-
-export interface DeleteFileMutation {
-  kind: 'delete';
-  path: string;
-}
-
-export type FileMutation = WriteFileMutation | DeleteFileMutation;
-
-export interface ReplaceRootCommitPlan {
-  kind: 'replace-root';
-  stagedPath: string;
-  targetPath: string;
-}
-
-export interface ApplyMutationsCommitPlan {
-  kind: 'apply-mutations';
-  rootDir: string;
-  mutations: FileMutation[];
-}
-
-export type CommitPlan = ReplaceRootCommitPlan | ApplyMutationsCommitPlan;
-
-export type CompilerPlanResult<Plan> =
-  | { kind: 'skip' }
-  | { kind: 'build'; plan: Plan };
-
-export type CompilerBuildResult<Snapshot, Meta> =
-  | {
-      ok: true;
-      snapshot: Snapshot;
-      commit: CommitPlan;
-      diagnostics?: WatchDiagnostic[];
-      meta?: Meta;
-    }
-  | { ok: false; diagnostics: WatchDiagnostic[]; meta?: Meta };
-
-export interface WatchCompiler<Snapshot, Plan, Meta> {
-  getWatchTargets(): WatchTarget[];
-  buildInitial(): Promise<CompilerBuildResult<Snapshot, Meta>>;
-  plan(
-    snapshot: Snapshot | undefined,
-    batch: ChangeBatch,
-  ): Promise<CompilerPlanResult<Plan>>;
-  run(
-    plan: Plan,
-    snapshot: Snapshot | undefined,
-  ): Promise<CompilerBuildResult<Snapshot, Meta>>;
-}
-
-export type WatchLifecycleEvent<Snapshot, Meta> =
-  | { kind: 'watching' }
-  | { kind: 'build-started'; batch?: ChangeBatch; initial: boolean }
-  | {
-      kind: 'build-succeeded';
-      initial: boolean;
-      batch?: ChangeBatch;
-      changed: boolean;
-      snapshot: Snapshot;
-      meta?: Meta;
-      diagnostics: WatchDiagnostic[];
-    }
-  | {
-      kind: 'build-failed';
-      initial: boolean;
-      batch?: ChangeBatch;
-      diagnostics: WatchDiagnostic[];
-      meta?: Meta;
-    }
-  | { kind: 'build-skipped'; batch: ChangeBatch };
-
-export interface WatchEngineOptions<Snapshot, Plan, Meta> {
-  compiler: WatchCompiler<Snapshot, Plan, Meta>;
-  debounceMs?: number;
-  onEvent?: (
-    event: WatchLifecycleEvent<Snapshot, Meta>,
-  ) => void | Promise<void>;
-}