yamlover 0.3.4 → 0.3.5

package/src/server/gitignore.ts

@@ -1,81 +0,0 @@
-/**
- * gitignore.ts — a predicate telling whether an absolute path is git-ignored.
- *
- * It honors `.gitignore` files from the repository root down to the file's
- * parent (nested `.gitignore`s included), plus an always-ignored `.git`. Built
- * once per server and handed to the materializer (see `setIgnoreFilter`), it only
- * filters *undescribed* (stray) entries — schema-described children are always
- * kept.
- */
-
-import fs from "node:fs";
-import path from "node:path";
-import ignore, { type Ignore } from "ignore";
-
-export function buildGitIgnore(dataRoot: string): (absPath: string) => boolean {
-  const gitRoot = findGitRoot(dataRoot) ?? dataRoot;
-  const cache = new Map<string, Ignore | null>(); // dir → its .gitignore matcher
-
-  const matcherFor = (dir: string): Ignore | null => {
-    if (!cache.has(dir)) {
-      let ig: Ignore | null = null;
-      try {
-        const gi = path.join(dir, ".gitignore");
-        if (fs.statSync(gi).isFile()) ig = ignore().add(fs.readFileSync(gi, "utf-8"));
-      } catch {
-        /* no .gitignore here */
-      }
-      cache.set(dir, ig);
-    }
-    return cache.get(dir)!;
-  };
-
-  return (absPath: string): boolean => {
-    const fromRoot = path.relative(gitRoot, absPath);
-    if (fromRoot === ".git" || fromRoot.startsWith(".git" + path.sep)) return true;
-
-    // A directory must be tested with a trailing slash, otherwise a `dir/`
-    // pattern (e.g. `node_modules/`) does not match the bare name.
-    let isDir = false;
-    try {
-      isDir = fs.statSync(absPath).isDirectory();
-    } catch {
-      /* gone */
-    }
-
-    // Test the path against every .gitignore from the repo root down to its
-    // parent directory; each file's patterns are relative to its own location.
-    const rel = path.relative(gitRoot, path.dirname(absPath));
-    const segs = rel === "" ? [] : rel.split(path.sep);
-    let dir = gitRoot;
-    const dirs = [gitRoot];
-    for (const s of segs) {
-      dir = path.join(dir, s);
-      dirs.push(dir);
-    }
-    for (const d of dirs) {
-      const ig = matcherFor(d);
-      if (!ig) continue;
-      const relToDir = path.relative(d, absPath);
-      if (!relToDir) continue;
-      if (ig.ignores(relToDir) || (isDir && ig.ignores(relToDir + "/"))) return true;
-    }
-    return false;
-  };
-}
-
-function findGitRoot(start: string): string | null {
-  let dir = path.resolve(start);
-  // If start is a file, begin at its directory.
-  try {
-    if (!fs.statSync(dir).isDirectory()) dir = path.dirname(dir);
-  } catch {
-    return null;
-  }
-  for (;;) {
-    if (fs.existsSync(path.join(dir, ".git"))) return dir;
-    const parent = path.dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}

package/src/server/node-kind.ts

@@ -1,61 +0,0 @@
-// Node-KIND classification — how a Store node is presented (the `type:` the client routes on). Kept
-// in its own module (no http/fs/gitignore deps) so it can be unit-tested under `node --test` against
-// a Store, independently of the HTTP layer (engine-api.ts), which only Vite can load (node:sqlite).
-import type { NodeRow, Store } from "../../../engine/ts/src/index.ts";
-
-// One ordered container, classified for display: a pure-keyed mapping is `object`, a pure-keyless
-// one `array`; a mapping mixing keyed + keyless OWNED entries is `mix`; a scalar/blob that ALSO
-// carries OWNED fields is `omni` (the `!!mix`/`!!var` shapes); plain scalars/blobs are
-// `scalar`/`binary`.
-export type Kind = "object" | "array" | "scalar" | "binary" | "omni" | "mix";
-
-/** A node's OWNED entries — the ones it authors, that constitute its content: containment children
- *  and forward `*` refs. A `~` back-edge (a REVERSE member, e.g. tag membership) is an upstream
- *  relation the node does NOT own, so it is excluded — it must not change the node's type. */
-export function ownedEntries(s: Store, p: string): ReturnType<Store["entries"]> {
-  return s.entries(p).filter((e) => e.kind !== "back");
-}
-
-/** A node's display {@link Kind}. A scalar/blob carrying OWNED fields is `omni`; a mapping that
- *  mixes keyed and keyless OWNED entries is `mix`; otherwise object|array|scalar|binary. The
- *  `is_array` flag marks a pure-keyless container. Reverse (`~`) members never count — a tagged PDF
- *  is still a `binary`, not an `omni` (they are upstream relations, not owned content). */
-export function displayKind(s: Store, p: string, row: NodeRow): Kind {
-  const ents = ownedEntries(s, p);
-  if (row.type === "blob") return ents.length ? "omni" : "binary";
-  if (row.type === "scalar") return ents.length ? "omni" : "scalar";
-  if (!ents.length) return row.is_array ? "array" : "object"; // empty container
-  if (row.is_array) return "array";
-  return ents.some((e) => e.label === null) ? "mix" : "object";
-}
-
-// Internal kind → the JSON-Schema-style `type:` name shown in the header/TOC and the schema view.
-// The YAML-tag shapes `!!mix`/`!!var` get full-word schema names (cf. !!seq→array, !!map→object):
-// `mix` → "mixed", `omni` → "variant". Scalars resolve to their JSON-ish primitive type.
-export function typeName(s: Store, p: string, row: NodeRow): string {
-  const k = displayKind(s, p, row);
-  if (k === "scalar") return scalarType(row.value);
-  if (k === "mix") return "mixed";
-  if (k === "omni") return "variant";
-  return k; // object | array | binary
-}
-
-export function scalarType(v: unknown): string {
-  if (v === null) return "null";
-  if (typeof v === "boolean") return "boolean";
-  if (typeof v === "number") return Number.isInteger(v) ? "integer" : "number";
-  return "string";
-}
-
-/** The three TYPE FACETS the client dispatches on (TYPES.md §1): the scalar self-VALUE's type
- *  (`null|boolean|integer|number|string|binary`, or null when there is no value facet), and
- *  whether the node OWNS any KEYED / ORDINAL (keyless) elements. Reverse `~` members are excluded
- *  (ownedEntries) — a tagged node keeps its facets, so a renderer can tolerate the extra keys. */
-export function facetsOf(s: Store, p: string, row: NodeRow): { valueType: string | null; hasKeyed: boolean; hasOrdinal: boolean } {
-  const ents = ownedEntries(s, p);
-  return {
-    valueType: row.type === "scalar" ? scalarType(row.value) : row.type === "blob" ? "binary" : null,
-    hasKeyed: ents.some((e) => e.label !== null),
-    hasOrdinal: ents.some((e) => e.label === null),
-  };
-}

package/src/server/tasks.ts

@@ -1,83 +0,0 @@
-// tasks.ts — the server's LONG-RUNNING TASK registry. Anything slow (the initial index, the
-// background hasher, a watcher reconcile, …) registers here and reports progress; every state
-// change is emitted (engine-api pushes it to the UI over the existing /api/events SSE stream
-// as a `{type:"task", task}` frame) and GET /api/tasks snapshots in-flight tasks for a freshly
-// loaded page. Generic on purpose: a future slow operation is just `registry.start(label)`.
-
-export interface TaskProgress {
-  done: number;
-  total?: number; // absent ⇒ indeterminate (the UI shows an activity bar, not a percent)
-  message?: string; // human-readable detail (current path, "writing index…", …)
-}
-
-export interface TaskInfo {
-  id: string;
-  label: string;
-  state: "running" | "done" | "error";
-  progress: TaskProgress;
-  startedAt: number; // epoch ms
-  finishedAt?: number;
-  error?: string;
-}
-
-export interface TaskHandle {
-  readonly id: string;
-  /** Report progress. Throttled (state changes are not) so a per-file caller cannot flood SSE. */
-  progress(done: number, total?: number, message?: string): void;
-  done(): void;
-  fail(err: unknown): void;
-}
-
-const PROGRESS_EMIT_MS = 150; // at most one progress frame per task per this interval
-const KEEP_FINISHED_MS = 5_000; // finished tasks stay listed briefly so completion is visible
-
-export class TaskRegistry {
-  private seq = 0;
-  private readonly tasks = new Map<string, TaskInfo>();
-  private readonly lastEmit = new Map<string, number>();
-
-  constructor(private readonly emit: (t: TaskInfo) => void) {}
-
-  start(label: string): TaskHandle {
-    const id = "t" + ++this.seq;
-    const info: TaskInfo = { id, label, state: "running", progress: { done: 0 }, startedAt: Date.now() };
-    this.tasks.set(id, info);
-    this.send(info, true);
-    const finish = (state: "done" | "error", error?: string): void => {
-      if (info.state !== "running") return; // done/fail are one-shot
-      info.state = state;
-      info.finishedAt = Date.now();
-      if (error !== undefined) info.error = error;
-      this.send(info, true);
-    };
-    return {
-      id,
-      progress: (done, total, message) => {
-        if (info.state !== "running") return;
-        info.progress = { done, ...(total !== undefined && { total }), ...(message !== undefined && { message }) };
-        this.send(info, false);
-      },
-      done: () => finish("done"),
-      fail: (err) => finish("error", String((err as Error)?.message ?? err)),
-    };
-  }
-
-  /** Running tasks + ones finished within the last few seconds (pruning the rest). */
-  list(): TaskInfo[] {
-    const now = Date.now();
-    for (const [id, t] of this.tasks) {
-      if (t.state !== "running" && now - (t.finishedAt ?? 0) > KEEP_FINISHED_MS) {
-        this.tasks.delete(id);
-        this.lastEmit.delete(id);
-      }
-    }
-    return [...this.tasks.values()].map((t) => ({ ...t, progress: { ...t.progress } }));
-  }
-
-  private send(t: TaskInfo, always: boolean): void {
-    const now = Date.now();
-    if (!always && now - (this.lastEmit.get(t.id) ?? 0) < PROGRESS_EMIT_MS) return;
-    this.lastEmit.set(t.id, now);
-    this.emit({ ...t, progress: { ...t.progress } });
-  }
-}