@graphrefly/graphrefly 0.1.0

package/dist/chunk-KWXPDASV.js

@@ -0,0 +1,781 @@
+import {
+  COMPLETE,
+  DATA,
+  DIRTY,
+  ERROR,
+  PAUSE,
+  RESUME,
+  batch,
+  derived,
+  node,
+  producer,
+  state,
+  wallClockNs
+} from "./chunk-5X3LAO3B.js";
+
+// src/extra/observable.ts
+import { Observable } from "rxjs";
+function toObservable(node2) {
+  return new Observable((subscriber) => {
+    const unsub = node2.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (subscriber.closed) return;
+        if (m[0] === DATA) {
+          subscriber.next(m[1]);
+        } else if (m[0] === ERROR) {
+          subscriber.error(m[1]);
+          return;
+        } else if (m[0] === COMPLETE) {
+          subscriber.complete();
+          return;
+        }
+      }
+    });
+    return unsub;
+  });
+}
+function toMessages$(node2) {
+  return new Observable((subscriber) => {
+    const unsub = node2.subscribe((msgs) => {
+      if (subscriber.closed) return;
+      subscriber.next(msgs);
+      for (const m of msgs) {
+        if (m[0] === ERROR) {
+          subscriber.error(m[1]);
+          return;
+        }
+        if (m[0] === COMPLETE) {
+          subscriber.complete();
+          return;
+        }
+      }
+    });
+    return unsub;
+  });
+}
+function observeNode$(graph, path, options) {
+  return new Observable((subscriber) => {
+    const handle = graph.observe(path, options);
+    const unsub = handle.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (subscriber.closed) return;
+        if (m[0] === DATA) {
+          subscriber.next(m[1]);
+        } else if (m[0] === ERROR) {
+          subscriber.error(m[1]);
+          return;
+        } else if (m[0] === COMPLETE) {
+          subscriber.complete();
+          return;
+        }
+      }
+    });
+    return unsub;
+  });
+}
+function observeGraph$(graph, options) {
+  return new Observable((subscriber) => {
+    const handle = graph.observe(options);
+    const unsub = handle.subscribe((nodePath, messages) => {
+      if (subscriber.closed) return;
+      subscriber.next({ path: nodePath, messages });
+    });
+    return unsub;
+  });
+}
+
+// src/extra/cron.ts
+function parseField(field, min, max) {
+  const result = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    const [range, stepStr] = part.split("/");
+    const step = stepStr ? Number.parseInt(stepStr, 10) : 1;
+    if (Number.isNaN(step) || step < 1) throw new Error(`Invalid cron step: ${part}`);
+    let start;
+    let end;
+    if (range === "*") {
+      start = min;
+      end = max;
+    } else if (range.includes("-")) {
+      const [a, b] = range.split("-");
+      start = Number.parseInt(a, 10);
+      end = Number.parseInt(b, 10);
+    } else {
+      start = Number.parseInt(range, 10);
+      end = start;
+    }
+    if (Number.isNaN(start) || Number.isNaN(end)) throw new Error(`Invalid cron field: ${field}`);
+    if (start < min || end > max)
+      throw new Error(`Cron field out of range: ${field} (${min}-${max})`);
+    if (start > end) throw new Error(`Invalid cron range: ${start}-${end} in ${field}`);
+    for (let i = start; i <= end; i += step) result.add(i);
+  }
+  return result;
+}
+function parseCron(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) throw new Error(`Invalid cron: expected 5 fields, got ${parts.length}`);
+  return {
+    minutes: parseField(parts[0], 0, 59),
+    hours: parseField(parts[1], 0, 23),
+    daysOfMonth: parseField(parts[2], 1, 31),
+    months: parseField(parts[3], 1, 12),
+    daysOfWeek: parseField(parts[4], 0, 6)
+  };
+}
+function matchesCron(schedule, date) {
+  return schedule.minutes.has(date.getMinutes()) && schedule.hours.has(date.getHours()) && schedule.daysOfMonth.has(date.getDate()) && schedule.months.has(date.getMonth() + 1) && schedule.daysOfWeek.has(date.getDay());
+}
+
+// src/extra/sources.ts
+import { existsSync, watch } from "fs";
+import { resolve as resolvePath } from "path";
+function sourceOpts(opts) {
+  return { describeKind: "producer", ...opts };
+}
+function operatorOpts(opts) {
+  return { describeKind: "operator", ...opts };
+}
+function escapeRegexChar(ch) {
+  return /[\\^$+?.()|[\]{}]/.test(ch) ? `\\${ch}` : ch;
+}
+function globToRegExp(glob) {
+  let out = "^";
+  for (let i = 0; i < glob.length; i += 1) {
+    const ch = glob[i];
+    if (ch === "*") {
+      const next = glob[i + 1];
+      if (next === "*") {
+        out += ".*";
+        i += 1;
+      } else {
+        out += "[^/]*";
+      }
+      continue;
+    }
+    out += escapeRegexChar(ch);
+  }
+  out += "$";
+  return new RegExp(out);
+}
+function matchesAnyPattern(path, patterns) {
+  for (const pattern of patterns) {
+    if (pattern.test(path)) return true;
+  }
+  return false;
+}
+function wrapSubscribeHook(inner, before) {
+  const wrapper = node([inner], ([val]) => val, {
+    describeKind: "operator",
+    initial: inner.get()
+  });
+  const origSubscribe = wrapper.subscribe.bind(wrapper);
+  wrapper.subscribe = (sink, hints) => {
+    before(sink);
+    return origSubscribe(sink, hints);
+  };
+  return wrapper;
+}
+function fromTimer(ms, opts) {
+  const { signal, period, ...rest } = opts ?? {};
+  return producer((_d, a) => {
+    let done = false;
+    let count = 0;
+    let t;
+    let iv;
+    const cleanup = () => {
+      done = true;
+      if (t !== void 0) clearTimeout(t);
+      if (iv !== void 0) clearInterval(iv);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const finish = () => {
+      if (done) return;
+      a.emit(count++);
+      if (period != null) {
+        iv = setInterval(() => {
+          if (done) return;
+          a.emit(count++);
+        }, period);
+      } else {
+        done = true;
+        signal?.removeEventListener("abort", onAbort);
+        queueMicrotask(() => a.down([[COMPLETE]]));
+      }
+    };
+    const onAbort = () => {
+      if (done) return;
+      cleanup();
+      a.down([[ERROR, signal.reason]]);
+    };
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    t = setTimeout(finish, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    return cleanup;
+  }, sourceOpts(rest));
+}
+function fromCron(expr, opts) {
+  const schedule = parseCron(expr);
+  const { tickMs: tickOpt, output, ...rest } = opts ?? {};
+  const tickMs = tickOpt ?? 6e4;
+  const emitDate = output === "date";
+  return producer(
+    (_d, a) => {
+      let lastFiredKey = -1;
+      const check = () => {
+        const now = /* @__PURE__ */ new Date();
+        const key = now.getFullYear() * 1e8 + (now.getMonth() + 1) * 1e6 + now.getDate() * 1e4 + now.getHours() * 100 + now.getMinutes();
+        if (key !== lastFiredKey && matchesCron(schedule, now)) {
+          lastFiredKey = key;
+          a.emit(emitDate ? now : wallClockNs());
+        }
+      };
+      check();
+      const id = setInterval(check, tickMs);
+      return () => clearInterval(id);
+    },
+    { ...sourceOpts(rest), name: rest.name ?? `cron:${expr}` }
+  );
+}
+function fromEvent(target, type, opts) {
+  const { capture, passive, once, ...rest } = opts ?? {};
+  return producer((_d, a) => {
+    const handler = (e) => {
+      a.emit(e);
+    };
+    const options = { capture, passive, once };
+    target.addEventListener(type, handler, options);
+    return () => target.removeEventListener(type, handler, options);
+  }, sourceOpts(rest));
+}
+function fromFSWatch(paths, opts) {
+  const list = Array.isArray(paths) ? paths : [paths];
+  if (list.length === 0) {
+    throw new RangeError("fromFSWatch expects at least one path");
+  }
+  const { recursive = true, debounce = 100, include, exclude, ...rest } = opts ?? {};
+  const includePatterns = include?.map(globToRegExp) ?? [];
+  const excludePatterns = (exclude ?? ["**/node_modules/**", "**/.git/**", "**/dist/**"]).map(
+    globToRegExp
+  );
+  return producer((_d, a) => {
+    const pending = /* @__PURE__ */ new Map();
+    const watchers = [];
+    let stopped = false;
+    let terminalEmitted = false;
+    let generation = 0;
+    const closeWatchers = () => {
+      for (const watcher of watchers.splice(0)) watcher.close();
+    };
+    const emitError = (err) => {
+      if (terminalEmitted) return;
+      terminalEmitted = true;
+      stopped = true;
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+      pending.clear();
+      closeWatchers();
+      a.down([[ERROR, err]]);
+    };
+    let timer;
+    const flush = (token) => {
+      timer = void 0;
+      if (stopped || terminalEmitted) return;
+      if (pending.size === 0) return;
+      const batchMessages = [];
+      for (const evt of pending.values()) batchMessages.push([DATA, evt]);
+      pending.clear();
+      if (stopped || terminalEmitted || token !== generation) return;
+      a.down(batchMessages);
+    };
+    try {
+      for (const basePath of list) {
+        const watcher = watch(
+          basePath,
+          { recursive },
+          (eventType, fileName) => {
+            if (stopped || terminalEmitted) return;
+            if (fileName == null) return;
+            const rel = String(fileName).replaceAll("\\", "/");
+            const abs = resolvePath(basePath, String(fileName));
+            const normalized = abs.replaceAll("\\", "/");
+            const root = resolvePath(basePath).replaceAll("\\", "/");
+            const relForMatch = rel.startsWith("./") ? rel.slice(2) : rel;
+            const included = includePatterns.length === 0 || matchesAnyPattern(normalized, includePatterns) || matchesAnyPattern(relForMatch, includePatterns);
+            if (!included) return;
+            const excluded = matchesAnyPattern(normalized, excludePatterns) || matchesAnyPattern(relForMatch, excludePatterns);
+            if (excluded) return;
+            let kind = "change";
+            if (eventType === "rename") {
+              try {
+                kind = existsSync(normalized) ? "create" : "delete";
+              } catch {
+                kind = "rename";
+              }
+            }
+            pending.set(normalized, {
+              type: kind,
+              path: normalized,
+              root,
+              relative_path: relForMatch,
+              timestamp_ns: wallClockNs()
+            });
+            if (timer !== void 0) clearTimeout(timer);
+            const token = generation;
+            timer = setTimeout(() => flush(token), debounce);
+          }
+        );
+        watcher.on("error", (err) => emitError(err));
+        watchers.push(watcher);
+      }
+    } catch (err) {
+      emitError(err);
+    }
+    return () => {
+      stopped = true;
+      generation += 1;
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+      closeWatchers();
+      pending.clear();
+    };
+  }, sourceOpts(rest));
+}
+function fromIter(iterable, opts) {
+  return producer((_d, a) => {
+    let cancelled = false;
+    try {
+      for (const x of iterable) {
+        if (cancelled) return;
+        a.emit(x);
+      }
+      if (!cancelled) a.down([[COMPLETE]]);
+    } catch (e) {
+      if (!cancelled) a.down([[ERROR, e]]);
+    }
+    return () => {
+      cancelled = true;
+    };
+  }, sourceOpts(opts));
+}
+function isThenable(x) {
+  return x != null && typeof x.then === "function";
+}
+function fromPromise(p, opts) {
+  const { signal, ...rest } = opts ?? {};
+  return producer((_d, a) => {
+    let settled = false;
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      a.down([[ERROR, signal.reason]]);
+    };
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    void Promise.resolve(p).then(
+      (v) => {
+        if (settled) return;
+        settled = true;
+        signal?.removeEventListener("abort", onAbort);
+        a.emit(v);
+        a.down([[COMPLETE]]);
+      },
+      (e) => {
+        if (settled) return;
+        settled = true;
+        signal?.removeEventListener("abort", onAbort);
+        a.down([[ERROR, e]]);
+      }
+    );
+    return () => {
+      settled = true;
+      signal?.removeEventListener("abort", onAbort);
+    };
+  }, sourceOpts(rest));
+}
+function fromAsyncIter(iterable, opts) {
+  const { signal: outerSignal, ...rest } = opts ?? {};
+  return producer((_d, a) => {
+    const ac = new AbortController();
+    const onOuterAbort = () => ac.abort(outerSignal?.reason);
+    if (outerSignal?.aborted) {
+      ac.abort(outerSignal.reason);
+    } else {
+      outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
+    }
+    const signal = outerSignal ?? ac.signal;
+    let cancelled = false;
+    const it = iterable[Symbol.asyncIterator]();
+    const pump = () => {
+      if (cancelled || signal.aborted) return;
+      void Promise.resolve(it.next()).then(
+        (step) => {
+          if (cancelled || signal.aborted) return;
+          if (step.done) {
+            queueMicrotask(() => a.down([[COMPLETE]]));
+            return;
+          }
+          a.emit(step.value);
+          queueMicrotask(pump);
+        },
+        (e) => {
+          if (!cancelled && !signal.aborted) a.down([[ERROR, e]]);
+        }
+      );
+    };
+    queueMicrotask(pump);
+    return () => {
+      cancelled = true;
+      outerSignal?.removeEventListener("abort", onOuterAbort);
+      ac.abort();
+      void Promise.resolve(it.return?.()).catch(() => void 0);
+    };
+  }, sourceOpts(rest));
+}
+function isNode(x) {
+  return x != null && typeof x.subscribe === "function" && typeof x.get === "function";
+}
+function fromAny(input, opts) {
+  if (isNode(input)) {
+    return input;
+  }
+  if (isThenable(input)) {
+    return fromPromise(input, opts);
+  }
+  if (input !== null && input !== void 0) {
+    const candidate = input;
+    if (typeof candidate[Symbol.asyncIterator] === "function") {
+      return fromAsyncIter(input, opts);
+    }
+    if (typeof candidate[Symbol.iterator] === "function") {
+      return fromIter(input, opts);
+    }
+  }
+  return of(input);
+}
+function of(...values) {
+  return fromIter(values, void 0);
+}
+function empty(opts) {
+  return producer((_d, a) => {
+    a.down([[COMPLETE]]);
+    return void 0;
+  }, sourceOpts(opts));
+}
+function never(opts) {
+  return producer(() => void 0, sourceOpts(opts));
+}
+function throwError(err, opts) {
+  return producer((_d, a) => {
+    a.down([[ERROR, err]]);
+    return void 0;
+  }, sourceOpts(opts));
+}
+function forEach(source, fn, opts) {
+  const inner = node([source], () => void 0, {
+    describeKind: "effect",
+    ...opts,
+    onMessage(msg, _i, _a) {
+      if (msg[0] === DATA) {
+        fn(msg[1]);
+        return true;
+      }
+      return false;
+    }
+  });
+  return inner.subscribe(() => {
+  });
+}
+function toArray(source, opts) {
+  const acc = [];
+  return node([source], () => void 0, {
+    ...operatorOpts(opts),
+    completeWhenDepsComplete: false,
+    onMessage(msg, _i, a) {
+      if (msg[0] === DATA) {
+        acc.push(msg[1]);
+        return true;
+      }
+      if (msg[0] === COMPLETE) {
+        a.emit([...acc]);
+        a.down([[COMPLETE]]);
+        return true;
+      }
+      return false;
+    }
+  });
+}
+function share(source, opts) {
+  return producer(
+    (_d, a) => source.subscribe((msgs) => {
+      a.down(msgs);
+    }),
+    { ...sourceOpts(opts), initial: source.get() }
+  );
+}
+function replay(source, bufferSize, opts) {
+  if (bufferSize < 1) throw new RangeError("replay expects bufferSize >= 1");
+  const buf = [];
+  const inner = producer(
+    (_d, a) => source.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] === DATA) {
+          buf.push(m[1]);
+          if (buf.length > bufferSize) buf.shift();
+        }
+      }
+      a.down(msgs);
+    }),
+    { ...sourceOpts(opts), initial: source.get() }
+  );
+  return wrapSubscribeHook(inner, (sink) => {
+    for (const v of buf) {
+      sink([[DATA, v]]);
+    }
+  });
+}
+function cached(source, opts) {
+  return replay(source, 1, opts);
+}
+function firstValueFrom(source) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const unsub = source.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (settled) return;
+        if (m[0] === DATA) {
+          settled = true;
+          resolve(m[1]);
+          queueMicrotask(() => unsub());
+          return;
+        }
+        if (m[0] === ERROR) {
+          settled = true;
+          reject(m[1]);
+          queueMicrotask(() => unsub());
+          return;
+        }
+        if (m[0] === COMPLETE) {
+          settled = true;
+          reject(new Error("completed without DATA"));
+          queueMicrotask(() => unsub());
+          return;
+        }
+      }
+    });
+  });
+}
+var shareReplay = replay;
+
+// src/extra/backpressure.ts
+var nextLockId = 0;
+function createWatermarkController(sendUp, opts) {
+  if (opts.highWaterMark < 1) throw new RangeError("highWaterMark must be >= 1");
+  if (opts.lowWaterMark < 0) throw new RangeError("lowWaterMark must be >= 0");
+  if (opts.lowWaterMark >= opts.highWaterMark)
+    throw new RangeError("lowWaterMark must be < highWaterMark");
+  const lockId = /* @__PURE__ */ Symbol(`bp-${++nextLockId}`);
+  let pending = 0;
+  let paused = false;
+  return {
+    onEnqueue() {
+      pending += 1;
+      if (!paused && pending >= opts.highWaterMark) {
+        paused = true;
+        sendUp([[PAUSE, lockId]]);
+        return true;
+      }
+      return false;
+    },
+    onDequeue() {
+      if (pending > 0) pending -= 1;
+      if (paused && pending <= opts.lowWaterMark) {
+        paused = false;
+        sendUp([[RESUME, lockId]]);
+        return true;
+      }
+      return false;
+    },
+    get pending() {
+      return pending;
+    },
+    get paused() {
+      return paused;
+    },
+    dispose() {
+      if (paused) {
+        paused = false;
+        sendUp([[RESUME, lockId]]);
+      }
+    }
+  };
+}
+
+// src/extra/reactive-base.ts
+function snapshotEqualsVersion(a, b) {
+  if (typeof a !== "object" || a == null || typeof b !== "object" || b == null) {
+    return Object.is(a, b);
+  }
+  if (!("version" in a) || !("version" in b)) return Object.is(a, b);
+  return a.version === b.version;
+}
+function bumpVersion(current, nextValue, v0) {
+  if (v0 != null) {
+    return { version: current.version + 1, value: nextValue, v0 };
+  }
+  return { version: current.version + 1, value: nextValue };
+}
+
+// src/extra/reactive-log.ts
+function emptySnapshot() {
+  return { version: 0, value: { entries: [] } };
+}
+function keepaliveDerived(n) {
+  return n.subscribe(() => {
+  });
+}
+function reactiveLog(initial, options = {}) {
+  const { name, maxSize } = options;
+  if (maxSize !== void 0 && maxSize < 1) {
+    throw new RangeError("maxSize must be >= 1");
+  }
+  const buf = initial ? [...initial] : [];
+  if (maxSize !== void 0 && buf.length > maxSize) {
+    buf.splice(0, buf.length - maxSize);
+  }
+  let current = buf.length > 0 ? { version: 1, value: { entries: [...buf] } } : emptySnapshot();
+  const entries = state(current, {
+    name,
+    describeKind: "state",
+    equals: snapshotEqualsVersion
+  });
+  function pushSnapshot() {
+    const ev = entries.v;
+    current = bumpVersion(
+      current,
+      { entries: [...buf] },
+      ev ? { id: ev.id, version: ev.version } : void 0
+    );
+    batch(() => {
+      entries.down([[DIRTY]]);
+      entries.down([[DATA, current]]);
+    });
+  }
+  function trimBuf() {
+    if (maxSize !== void 0 && buf.length > maxSize) {
+      buf.splice(0, buf.length - maxSize);
+    }
+  }
+  const bundle = {
+    entries,
+    append(value) {
+      buf.push(value);
+      trimBuf();
+      pushSnapshot();
+    },
+    appendMany(values) {
+      if (values.length === 0) return;
+      buf.push(...values);
+      trimBuf();
+      pushSnapshot();
+    },
+    clear() {
+      if (buf.length === 0) return;
+      buf.length = 0;
+      pushSnapshot();
+    },
+    trimHead(n) {
+      if (n < 0) {
+        throw new RangeError("n must be >= 0");
+      }
+      if (n === 0) return;
+      if (n >= buf.length) {
+        if (buf.length === 0) return;
+        buf.length = 0;
+      } else {
+        buf.splice(0, n);
+      }
+      pushSnapshot();
+    },
+    tail(n) {
+      if (n < 0) {
+        throw new RangeError("n must be >= 0");
+      }
+      const snap = entries.get();
+      const e = snap.value.entries;
+      const init = n === 0 ? [] : e.slice(Math.max(0, e.length - n));
+      const out = derived(
+        [entries],
+        ([s]) => {
+          const list = s.value.entries;
+          return n === 0 ? [] : list.slice(Math.max(0, list.length - n));
+        },
+        { initial: init, describeKind: "derived" }
+      );
+      keepaliveDerived(out);
+      return out;
+    }
+  };
+  return bundle;
+}
+function logSlice(log, start, stop) {
+  if (start < 0) {
+    throw new RangeError("start must be >= 0");
+  }
+  const snap = log.entries.get();
+  const e = snap.value.entries;
+  const init = stop === void 0 ? e.slice(start) : e.slice(start, stop);
+  const out = derived(
+    [log.entries],
+    ([s]) => {
+      const list = s.value.entries;
+      return stop === void 0 ? list.slice(start) : list.slice(start, stop);
+    },
+    { initial: init, describeKind: "derived" }
+  );
+  keepaliveDerived(out);
+  return out;
+}
+
+export {
+  toObservable,
+  toMessages$,
+  observeNode$,
+  observeGraph$,
+  parseCron,
+  matchesCron,
+  escapeRegexChar,
+  globToRegExp,
+  matchesAnyPattern,
+  fromTimer,
+  fromCron,
+  fromEvent,
+  fromFSWatch,
+  fromIter,
+  fromPromise,
+  fromAsyncIter,
+  fromAny,
+  of,
+  empty,
+  never,
+  throwError,
+  forEach,
+  toArray,
+  share,
+  replay,
+  cached,
+  firstValueFrom,
+  shareReplay,
+  createWatermarkController,
+  snapshotEqualsVersion,
+  bumpVersion,
+  reactiveLog,
+  logSlice
+};
+//# sourceMappingURL=chunk-KWXPDASV.js.map