@graphrefly/ts 0.0.0

package/dist/sources/node.cjs

@@ -0,0 +1,675 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/sources/node.ts
+var node_exports = {};
+__export(node_exports, {
+  fromFSWatch: () => fromFSWatch,
+  fromGitHook: () => fromGitHook,
+  fromSpawn: () => fromSpawn,
+  nodeProcessDriver: () => nodeProcessDriver,
+  runProcess: () => runProcess
+});
+module.exports = __toCommonJS(node_exports);
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+
+// src/protocol/messages.ts
+var SENTINEL = void 0;
+function isInvalidErrorPayload(v) {
+  return v === SENTINEL || typeof v === "boolean";
+}
+function errorPayload(reason, fallback = "error without a valid payload") {
+  return isInvalidErrorPayload(reason) ? new Error(fallback) : reason;
+}
+
+// src/sources/node.ts
+function source(factory, setup) {
+  return {
+    factory,
+    body: (ctx) => {
+      const cleanup = setup(ctx);
+      if (typeof cleanup === "function") ctx.onDeactivation(cleanup);
+    }
+  };
+}
+function normalizePath(path) {
+  return path.replaceAll("\\", "/");
+}
+function escapeRegExp(value) {
+  return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function globToRegExp(pattern) {
+  let out = "^";
+  for (let i = 0; i < pattern.length; i += 1) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      if (pattern[i + 1] === "*") {
+        out += ".*";
+        i += 1;
+      } else {
+        out += "[^/]*";
+      }
+    } else {
+      out += escapeRegExp(ch);
+    }
+  }
+  return new RegExp(`${out}$`);
+}
+function matchesAny(value, patterns) {
+  return patterns.some((pattern) => pattern.test(value));
+}
+function timestampNsNow() {
+  return (BigInt(Date.now()) * 1000000n).toString();
+}
+function validatePositiveFinite(name, value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new RangeError(`${name} must be a positive finite number`);
+  }
+}
+function validateNonNegativeFinite(name, value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new RangeError(`${name} must be a non-negative finite number`);
+  }
+}
+function eventTypeFor(eventType, path) {
+  if (eventType === "change") return "change";
+  try {
+    return (0, import_node_fs.existsSync)(path) ? "create" : "delete";
+  } catch {
+    return "rename";
+  }
+}
+function scanFiles(root, recursive, isExcluded) {
+  const resolved = (0, import_node_path.resolve)(root);
+  try {
+    const st = (0, import_node_fs.statSync)(resolved);
+    if (st.isFile()) return [resolved];
+    if (!st.isDirectory()) return [];
+  } catch {
+    return [];
+  }
+  const out = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = (0, import_node_fs.readdirSync)(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const abs = (0, import_node_path.join)(dir, entry.name);
+      const rel = (0, import_node_path.relative)(resolved, abs);
+      if (entry.isFile()) {
+        out.push(abs);
+      } else if (recursive && entry.isDirectory() && !isExcluded(abs, rel)) {
+        walk(abs);
+      }
+    }
+  }
+  walk(resolved);
+  return out;
+}
+function fromFSWatch(paths, opts = {}) {
+  const list = (Array.isArray(paths) ? paths : [paths]).map((path) => (0, import_node_path.resolve)(path));
+  if (list.length === 0) throw new RangeError("fromFSWatch: paths must not be empty");
+  const {
+    recursive = false,
+    debounceMs = 100,
+    initialScan = false,
+    include,
+    exclude = ["**/node_modules/**", "**/.git/**", "**/dist/**"],
+    signal
+  } = opts;
+  if (!Number.isFinite(debounceMs) || debounceMs < 0) {
+    throw new RangeError("fromFSWatch: debounceMs must be a non-negative finite number");
+  }
+  const includePatterns = (include ?? []).map(globToRegExp);
+  const excludePatterns = exclude.map(globToRegExp);
+  const accepts = (abs, rel) => {
+    const normalized = normalizePath(abs);
+    const relNormalized = normalizePath(rel);
+    const included = includePatterns.length === 0 || matchesAny(normalized, includePatterns) || matchesAny(relNormalized, includePatterns);
+    if (!included) return false;
+    return !isExcluded(normalized, relNormalized);
+  };
+  const isExcluded = (abs, rel) => {
+    const normalized = normalizePath(abs);
+    const relNormalized = normalizePath(rel);
+    return matchesAny(normalized, excludePatterns) || matchesAny(relNormalized, excludePatterns) || matchesAny(`${normalized}/`, excludePatterns) || relNormalized !== "" && matchesAny(`${relNormalized}/`, excludePatterns);
+  };
+  return source("fromFSWatch", (ctx) => {
+    let stopped = false;
+    let terminal = false;
+    let ready = initialScan === false;
+    let generation = 0;
+    let timer;
+    const watchers = [];
+    const pending = /* @__PURE__ */ new Map();
+    const buffered = /* @__PURE__ */ new Map();
+    const close = () => {
+      for (const watcher of watchers.splice(0)) watcher.close();
+    };
+    const cleanup = () => {
+      stopped = true;
+      generation += 1;
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+      signal?.removeEventListener("abort", onAbort);
+      close();
+      pending.clear();
+      buffered.clear();
+    };
+    const emitError = (err) => {
+      if (terminal) return;
+      terminal = true;
+      cleanup();
+      ctx.down([["ERROR", errorPayload(err)]]);
+    };
+    function onAbort() {
+      emitError(signal?.reason);
+    }
+    const flush = (token) => {
+      timer = void 0;
+      if (stopped || terminal || token !== generation || pending.size === 0) return;
+      const msgs = [...pending.values()].map((event) => ["DATA", event]);
+      pending.clear();
+      ctx.down(msgs);
+    };
+    const schedule = () => {
+      if (timer !== void 0) clearTimeout(timer);
+      const token = generation;
+      if (debounceMs === 0) flush(token);
+      else timer = setTimeout(() => flush(token), debounceMs);
+    };
+    const enqueue = (event) => {
+      if (!ready) {
+        buffered.set(event.path, event);
+        return;
+      }
+      pending.set(event.path, event);
+      schedule();
+    };
+    const eventFor = (basePath, eventType, fileName) => {
+      const root = normalizePath((0, import_node_path.resolve)(basePath));
+      const abs = normalizePath(fileName == null ? root : (0, import_node_path.resolve)(basePath, String(fileName)));
+      const rel = normalizePath(fileName == null ? "" : (0, import_node_path.relative)(root, abs));
+      if (!accepts(abs, rel)) return void 0;
+      return {
+        type: eventTypeFor(eventType, abs),
+        path: abs,
+        root,
+        relativePath: rel
+      };
+    };
+    if (signal?.aborted) {
+      onAbort();
+      return cleanup;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      for (const basePath of list) {
+        const watcher = (0, import_node_fs.watch)(basePath, { recursive }, (eventType, fileName) => {
+          if (stopped || terminal) return;
+          const event = eventFor(basePath, eventType, fileName);
+          if (event !== void 0) enqueue(event);
+        });
+        watcher.on("error", emitError);
+        watchers.push(watcher);
+      }
+    } catch (err) {
+      emitError(err);
+      return cleanup;
+    }
+    if (initialScan !== false) {
+      try {
+        for (const basePath of list) {
+          const root = normalizePath((0, import_node_path.resolve)(basePath));
+          let relRoot = root;
+          try {
+            if ((0, import_node_fs.statSync)(basePath).isFile()) relRoot = (0, import_node_path.dirname)(root);
+          } catch {
+            relRoot = root;
+          }
+          for (const absPath of scanFiles(basePath, recursive, isExcluded)) {
+            if (stopped || terminal) return cleanup;
+            const abs = normalizePath(absPath);
+            const rel = normalizePath((0, import_node_path.relative)(relRoot, abs));
+            if (!accepts(abs, rel)) continue;
+            pending.set(abs, {
+              type: "create",
+              path: abs,
+              root,
+              relativePath: rel
+            });
+          }
+        }
+        ready = true;
+        for (const [key, event] of buffered) pending.set(key, event);
+        buffered.clear();
+        if (pending.size > 0) schedule();
+      } catch (err) {
+        emitError(err);
+      }
+    }
+    return cleanup;
+  });
+}
+function fromSpawn(cmd, args = [], opts = {}) {
+  if (typeof cmd !== "string" || cmd.length === 0) {
+    throw new TypeError("fromSpawn: cmd must be a non-empty string");
+  }
+  const killGraceMs = opts.killGraceMs ?? 1e3;
+  validateNonNegativeFinite("fromSpawn: killGraceMs", killGraceMs);
+  return source("fromSpawn", (ctx) => {
+    let alive = true;
+    let terminal = false;
+    let exitInfo;
+    let child;
+    let killTimer;
+    const clearKillTimer = () => {
+      if (killTimer !== void 0) clearTimeout(killTimer);
+      killTimer = void 0;
+    };
+    const stop = () => {
+      alive = false;
+      child?.stdout?.removeAllListeners("data");
+      child?.stderr?.removeAllListeners("data");
+      if (!terminal) {
+        try {
+          child?.kill("SIGTERM");
+        } catch {
+        }
+        killTimer = setTimeout(() => {
+          if (!terminal) {
+            try {
+              child?.kill("SIGKILL");
+            } catch {
+            }
+          }
+        }, killGraceMs);
+        killTimer.unref?.();
+      }
+    };
+    try {
+      child = (0, import_node_child_process.spawn)(cmd, [...args], {
+        cwd: opts.cwd,
+        env: opts.env,
+        shell: opts.shell,
+        signal: opts.signal,
+        stdio: opts.stdio ?? "pipe"
+      });
+    } catch (err) {
+      terminal = true;
+      ctx.down([["ERROR", errorPayload(err)]]);
+      return () => void 0;
+    }
+    child.stdout?.on("data", (chunk) => {
+      if (alive) ctx.down([["DATA", { kind: "stdout", chunk }]]);
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (alive) ctx.down([["DATA", { kind: "stderr", chunk }]]);
+    });
+    child.on("error", (err) => {
+      if (!alive || terminal) return;
+      terminal = true;
+      alive = false;
+      ctx.down([["ERROR", errorPayload(err)]]);
+    });
+    child.on("exit", (code, signal) => {
+      exitInfo = { code, signal };
+    });
+    child.on("close", () => {
+      clearKillTimer();
+      if (!alive || terminal) return;
+      terminal = true;
+      alive = false;
+      const info = exitInfo ?? { code: null, signal: null };
+      ctx.down([["DATA", { kind: "exit", code: info.code, signal: info.signal }], ["COMPLETE"]]);
+    });
+    return stop;
+  });
+}
+function nodeProcessDriver(opts = {}) {
+  const killGraceMs = opts.killGraceMs ?? 1e3;
+  const maxBufferBytes = opts.maxBufferBytes ?? 16 * 1024 * 1024;
+  validateNonNegativeFinite("nodeProcessDriver: killGraceMs", killGraceMs);
+  validateNonNegativeFinite("nodeProcessDriver: maxBufferBytes", maxBufferBytes);
+  return {
+    run(command, callback) {
+      return runNodeProcessCommand(command, callback, {
+        killGraceMs,
+        maxBufferBytes,
+        shell: opts.shell
+      });
+    }
+  };
+}
+function runProcess(cmd, args = [], opts = {}) {
+  if (typeof cmd !== "string" || cmd.length === 0) {
+    throw new TypeError("runProcess: cmd must be a non-empty string");
+  }
+  const killGraceMs = opts.killGraceMs ?? 1e3;
+  validateNonNegativeFinite("runProcess: killGraceMs", killGraceMs);
+  return source("runProcess", (ctx) => {
+    let alive = true;
+    let terminal = false;
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let exitInfo;
+    let child;
+    let killTimer;
+    const clearKillTimer = () => {
+      if (killTimer !== void 0) clearTimeout(killTimer);
+      killTimer = void 0;
+    };
+    const stop = () => {
+      alive = false;
+      child?.stdout?.removeAllListeners("data");
+      child?.stderr?.removeAllListeners("data");
+      if (!terminal) {
+        try {
+          child?.kill("SIGTERM");
+        } catch {
+        }
+        killTimer = setTimeout(() => {
+          if (!terminal) {
+            try {
+              child?.kill("SIGKILL");
+            } catch {
+            }
+          }
+        }, killGraceMs);
+        killTimer.unref?.();
+      }
+    };
+    try {
+      child = (0, import_node_child_process.spawn)(cmd, [...args], {
+        cwd: opts.cwd,
+        env: opts.env,
+        shell: opts.shell,
+        signal: opts.signal,
+        stdio: opts.stdio ?? "pipe"
+      });
+    } catch (err) {
+      terminal = true;
+      ctx.down([["ERROR", errorPayload(err)]]);
+      return () => void 0;
+    }
+    child.stdout?.on("data", (chunk) => {
+      if (alive) stdoutChunks.push(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (alive) stderrChunks.push(chunk);
+    });
+    child.on("error", (err) => {
+      if (!alive || terminal) return;
+      terminal = true;
+      alive = false;
+      ctx.down([["ERROR", errorPayload(err)]]);
+    });
+    child.on("exit", (code, signal) => {
+      exitInfo = { code, signal };
+    });
+    child.on("close", () => {
+      clearKillTimer();
+      if (!alive || terminal) return;
+      terminal = true;
+      alive = false;
+      const info = exitInfo ?? { code: null, signal: null };
+      ctx.down([
+        [
+          "DATA",
+          {
+            stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+            stderr: Buffer.concat(stderrChunks).toString("utf8"),
+            exitCode: info.code,
+            signal: info.signal
+          }
+        ],
+        ["COMPLETE"]
+      ]);
+    });
+    return stop;
+  });
+}
+function runNodeProcessCommand(command, callback, opts) {
+  if (typeof command.program !== "string" || command.program.length === 0) {
+    callback({
+      ok: false,
+      error: new TypeError("nodeProcessDriver: program must be a non-empty string")
+    });
+    return () => void 0;
+  }
+  let alive = true;
+  let terminal = false;
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  let bufferedBytes = 0;
+  let exitInfo;
+  let child;
+  let killTimer;
+  const clearKillTimer = () => {
+    if (killTimer !== void 0) clearTimeout(killTimer);
+    killTimer = void 0;
+  };
+  const stop = () => {
+    if (!alive) return;
+    alive = false;
+    child?.stdout?.removeAllListeners("data");
+    child?.stderr?.removeAllListeners("data");
+    if (!terminal) {
+      try {
+        child?.kill("SIGTERM");
+      } catch {
+      }
+      killTimer = setTimeout(() => {
+        if (!terminal) {
+          try {
+            child?.kill("SIGKILL");
+          } catch {
+          }
+        }
+      }, opts.killGraceMs);
+      killTimer.unref?.();
+    }
+  };
+  try {
+    child = (0, import_node_child_process.spawn)(command.program, [...command.args], {
+      cwd: command.cwd,
+      env: command.env === void 0 ? void 0 : Object.fromEntries(command.env),
+      shell: opts.shell,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (err) {
+    terminal = true;
+    callback({ ok: false, error: err });
+    return () => void 0;
+  }
+  const fail = (error) => {
+    clearKillTimer();
+    if (!alive || terminal) return;
+    terminal = true;
+    alive = false;
+    child.stdout?.removeAllListeners("data");
+    child.stderr?.removeAllListeners("data");
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    killTimer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }, opts.killGraceMs);
+    killTimer.unref?.();
+    callback({ ok: false, error });
+  };
+  const pushOutput = (chunks, chunk) => {
+    if (!alive) return;
+    bufferedBytes += chunk.byteLength;
+    if (bufferedBytes > opts.maxBufferBytes) {
+      fail(
+        new RangeError(
+          `nodeProcessDriver: stdout/stderr exceeded maxBufferBytes (${opts.maxBufferBytes})`
+        )
+      );
+      return;
+    }
+    chunks.push(chunk);
+  };
+  child.stdout?.on("data", (chunk) => {
+    pushOutput(stdoutChunks, chunk);
+  });
+  child.stderr?.on("data", (chunk) => {
+    pushOutput(stderrChunks, chunk);
+  });
+  child.on("error", (err) => {
+    clearKillTimer();
+    if (!alive || terminal) return;
+    terminal = true;
+    alive = false;
+    callback({ ok: false, error: err });
+  });
+  child.on("exit", (code, signal) => {
+    exitInfo = { code, signal };
+  });
+  child.on("close", () => {
+    clearKillTimer();
+    if (!alive || terminal) return;
+    terminal = true;
+    alive = false;
+    const info = exitInfo ?? { code: null, signal: null };
+    callback({
+      ok: true,
+      value: {
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf8"),
+        exitCode: info.code,
+        signal: info.signal
+      }
+    });
+  });
+  return stop;
+}
+function stripFinalLineBreak(value) {
+  return value.replace(/\r?\n$/, "");
+}
+function gitText(repoPath, args) {
+  return stripFinalLineBreak((0, import_node_child_process.execFileSync)("git", ["-C", repoPath, ...args], { encoding: "utf8" }));
+}
+function gitPathList(repoPath, args) {
+  const out = (0, import_node_child_process.execFileSync)("git", ["-C", repoPath, ...args, "-z"]);
+  const text = out.toString("utf8");
+  if (text.length === 0) return [];
+  return text.split("\0").filter((part) => part.length > 0);
+}
+function readGitHead(repoPath, previousHead) {
+  const head = gitText(repoPath, ["rev-parse", "HEAD"]);
+  if (head.length === 0 || head === previousHead) return void 0;
+  const files = previousHead === void 0 ? [] : gitPathList(repoPath, ["diff", "--name-only", `${previousHead}..${head}`]);
+  return {
+    head,
+    files,
+    message: gitText(repoPath, ["log", "-1", "--format=%s", head]),
+    author: gitText(repoPath, ["log", "-1", "--format=%an", head])
+  };
+}
+function fromGitHook(repoPath, opts = {}) {
+  const { pollMs = 5e3, include, exclude, maxConsecutiveErrors = 1, signal } = opts;
+  validatePositiveFinite("fromGitHook: pollMs", pollMs);
+  if (!Number.isFinite(maxConsecutiveErrors) && maxConsecutiveErrors !== Infinity) {
+    throw new RangeError("fromGitHook: maxConsecutiveErrors must be finite or Infinity");
+  }
+  if (maxConsecutiveErrors <= 0) {
+    throw new RangeError("fromGitHook: maxConsecutiveErrors must be positive");
+  }
+  const resolvedRepoPath = (0, import_node_path.resolve)(repoPath);
+  const includePatterns = (include ?? []).map(globToRegExp);
+  const excludePatterns = (exclude ?? []).map(globToRegExp);
+  const accepts = (file) => {
+    const normalized = normalizePath(file);
+    const included = includePatterns.length === 0 || matchesAny(normalized, includePatterns);
+    return included && !matchesAny(normalized, excludePatterns);
+  };
+  return source("fromGitHook", (ctx) => {
+    let done = false;
+    let lastSeen;
+    let consecutiveErrors = 0;
+    let intervalId;
+    const cleanup = () => {
+      done = true;
+      if (intervalId !== void 0) clearInterval(intervalId);
+      intervalId = void 0;
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const fail = (err) => {
+      if (done) return;
+      cleanup();
+      ctx.down([["ERROR", errorPayload(err)]]);
+    };
+    const onAbort = () => fail(signal?.reason);
+    const poll = () => {
+      if (done) return;
+      try {
+        const result = readGitHead(resolvedRepoPath, lastSeen);
+        consecutiveErrors = 0;
+        if (result === void 0) return;
+        const isBaseline = lastSeen === void 0;
+        lastSeen = result.head;
+        if (isBaseline) return;
+        ctx.down([
+          [
+            "DATA",
+            {
+              hook: "post-commit",
+              commit: result.head,
+              files: result.files.filter(accepts),
+              message: result.message,
+              author: result.author,
+              timestamp_ns: timestampNsNow()
+            }
+          ]
+        ]);
+      } catch (err) {
+        consecutiveErrors += 1;
+        if (consecutiveErrors >= maxConsecutiveErrors) fail(err);
+      }
+    };
+    if (signal?.aborted) {
+      onAbort();
+      return cleanup;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    poll();
+    if (!done) intervalId = setInterval(poll, pollMs);
+    return cleanup;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fromFSWatch,
+  fromGitHook,
+  fromSpawn,
+  nodeProcessDriver,
+  runProcess
+});
+//# sourceMappingURL=node.cjs.map