@graphrefly/ts 0.0.0

package/dist/chunk-G4M3NHRJ.js

@@ -0,0 +1,688 @@
+import {
+  initNode,
+  toCheckpointJson
+} from "./chunk-PKVBHGBM.js";
+import {
+  errorPayload
+} from "./chunk-DK554R7P.js";
+
+// src/graph/sources.ts
+function source(factory, setup, opts) {
+  return {
+    factory,
+    opts,
+    body: (ctx) => {
+      let cleanup;
+      let deactivated = false;
+      ctx.onDeactivation(() => {
+        deactivated = true;
+        if (typeof cleanup === "function") cleanup();
+      });
+      const maybeCleanup = setup(ctx);
+      cleanup = typeof maybeCleanup === "function" ? maybeCleanup : void 0;
+      if (deactivated && typeof cleanup === "function") cleanup();
+    }
+  };
+}
+function assertNonEmptyString(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string`);
+  }
+}
+function cleanupDriverWork(active, cancelSlot) {
+  active.value = false;
+  const cancel = cancelSlot.value;
+  cancelSlot.value = void 0;
+  if (cancel !== void 0) runDriverCancel(cancel);
+}
+function installDriverCancel(active, cancelSlot, cancel) {
+  if (active.value) cancelSlot.value = cancel;
+  else runDriverCancel(cancel);
+}
+function runDriverCancel(cancel) {
+  try {
+    cancel();
+  } catch {
+  }
+}
+function driverOneShotSource(factory, missing, start) {
+  return source(
+    factory,
+    (ctx) => {
+      const active = { value: true };
+      const cancelSlot = { value: void 0 };
+      const callback = (result) => {
+        if (!active.value) return;
+        cleanupDriverWork(active, cancelSlot);
+        if (result.ok) ctx.down([["DATA", result.value], ["COMPLETE"]]);
+        else ctx.down([["ERROR", errorPayload(result.error)]]);
+      };
+      let cancel;
+      try {
+        cancel = start(ctx, callback);
+      } catch (e) {
+        active.value = false;
+        ctx.down([["ERROR", errorPayload(e)]]);
+        return;
+      }
+      if (cancel === void 0) {
+        active.value = false;
+        ctx.down([["ERROR", missing]]);
+        return;
+      }
+      installDriverCancel(active, cancelSlot, cancel);
+      return () => cleanupDriverWork(active, cancelSlot);
+    },
+    { pool: "async", pausable: false }
+  );
+}
+function driverStreamSource(factory, missing, start, dataOf, errorOf) {
+  return source(
+    factory,
+    (ctx) => {
+      const active = { value: true };
+      const cancelSlot = { value: void 0 };
+      const callback = (event) => {
+        if (!active.value) return;
+        if (event.kind === "event") {
+          const value = dataOf(event);
+          if (value !== void 0) ctx.down([["DATA", value]]);
+        } else if (event.kind === "error") {
+          cleanupDriverWork(active, cancelSlot);
+          ctx.down([["ERROR", errorPayload(errorOf(event))]]);
+        } else if (event.kind === "complete") {
+          cleanupDriverWork(active, cancelSlot);
+          ctx.down([["COMPLETE"]]);
+        }
+      };
+      let cancel;
+      try {
+        cancel = start(ctx, callback);
+      } catch (e) {
+        active.value = false;
+        ctx.down([["ERROR", errorPayload(e)]]);
+        return;
+      }
+      if (cancel === void 0) {
+        active.value = false;
+        ctx.down([["ERROR", missing]]);
+        return;
+      }
+      installDriverCancel(active, cancelSlot, cancel);
+      return () => cleanupDriverWork(active, cancelSlot);
+    },
+    { pool: "async", pausable: false }
+  );
+}
+function isNode(x) {
+  return x != null && typeof x === "object" && "cache" in x && typeof x.subscribe === "function";
+}
+function isThenable(x) {
+  return x != null && typeof x.then === "function";
+}
+function isAsyncIterable(x) {
+  return x !== null && x !== void 0 && typeof x[Symbol.asyncIterator] === "function";
+}
+function isIterable(x) {
+  return x !== null && x !== void 0 && typeof x[Symbol.iterator] === "function";
+}
+function parseCronField(field, min, max) {
+  if (field.length === 0) throw new Error("Invalid cron field: empty");
+  const out = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    if (part.length === 0) throw new Error(`Invalid cron field: ${field}`);
+    const stepParts = part.split("/");
+    if (stepParts.length > 2) throw new Error(`Invalid cron step: ${part}`);
+    const [range, stepText] = stepParts;
+    if (range == null || range.length === 0) throw new Error(`Invalid cron field: ${field}`);
+    if (stepText === "") throw new Error(`Invalid cron step: ${part}`);
+    const step = stepText == null ? 1 : parseCronInt(stepText, `Invalid cron step: ${part}`);
+    if (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, extra] = range.split("-");
+      if (extra !== void 0 || a === "" || b === "")
+        throw new Error(`Invalid cron field: ${field}`);
+      start = parseCronInt(a, `Invalid cron field: ${field}`);
+      end = parseCronInt(b, `Invalid cron field: ${field}`);
+    } else {
+      start = parseCronInt(range, `Invalid cron field: ${field}`);
+      end = start;
+    }
+    if (!Number.isInteger(start) || !Number.isInteger(end)) {
+      throw new Error(`Invalid cron field: ${field}`);
+    }
+    if (start < min || end > max) {
+      throw new RangeError(`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) out.add(i);
+  }
+  return out;
+}
+function parseCronInt(text, message) {
+  if (!/^\d+$/.test(text)) throw new Error(message);
+  const value = Number.parseInt(text, 10);
+  if (!Number.isSafeInteger(value)) throw new Error(message);
+  return value;
+}
+function parseCron(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5 || parts.some((part) => part.length === 0)) {
+    throw new Error(`Invalid cron: expected 5 fields, got ${parts.length}`);
+  }
+  return {
+    minutes: parseCronField(parts[0], 0, 59),
+    hours: parseCronField(parts[1], 0, 23),
+    daysOfMonth: parseCronField(parts[2], 1, 31),
+    months: parseCronField(parts[3], 1, 12),
+    daysOfWeek: parseCronField(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());
+}
+function cronMinuteKey(date) {
+  return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}-${date.getHours()}-${date.getMinutes()}`;
+}
+function dateToTimestampNs(date) {
+  return (BigInt(date.getTime()) * 1000000n).toString();
+}
+function fromCron(expr, opts = {}) {
+  const schedule = parseCron(expr);
+  const { tickMs = 6e4, output = "timestamp_ns", signal } = opts;
+  if (!Number.isFinite(tickMs) || tickMs <= 0) {
+    throw new RangeError("fromCron: tickMs must be a positive finite number");
+  }
+  return source(
+    "fromCron",
+    (ctx) => {
+      let done = false;
+      let lastFiredKey;
+      let intervalId;
+      const cleanup = () => {
+        done = true;
+        if (intervalId !== void 0) clearInterval(intervalId);
+        intervalId = void 0;
+        signal?.removeEventListener("abort", onAbort);
+      };
+      const onAbort = () => {
+        if (done) return;
+        cleanup();
+        ctx.down([["ERROR", errorPayload(signal?.reason)]]);
+      };
+      const emitNow = (now) => {
+        if (output === "date") ctx.down([["DATA", now]]);
+        else if (output === "timestamp_ms") ctx.down([["DATA", now.getTime()]]);
+        else ctx.down([["DATA", dateToTimestampNs(now)]]);
+      };
+      const check = () => {
+        if (done) return;
+        const now = /* @__PURE__ */ new Date();
+        const key = cronMinuteKey(now);
+        if (key !== lastFiredKey && matchesCron(schedule, now)) {
+          lastFiredKey = key;
+          emitNow(now);
+        }
+      };
+      if (signal?.aborted) {
+        onAbort();
+        return cleanup;
+      }
+      signal?.addEventListener("abort", onAbort, { once: true });
+      check();
+      intervalId = setInterval(check, tickMs);
+      return cleanup;
+    },
+    { pool: "sync", pausable: false }
+  );
+}
+function runProcess(program, args = []) {
+  return runProcessWithOptions({ program, args });
+}
+function fromProcess(program, args = []) {
+  return processSource("fromProcess", { program, args });
+}
+function runProcessWithOptions(command) {
+  return processSource("runProcess", command);
+}
+function processSource(factory, command) {
+  assertNonEmptyString(command.program, `${factory}: program`);
+  return driverOneShotSource(
+    factory,
+    `${factory}: missing process driver`,
+    (ctx, callback) => ctx.environment().processDriver()?.run(command, callback)
+  );
+}
+function fromHttp(url) {
+  return fromHttpWithOptions({ method: "GET", url });
+}
+function fromHttpWithOptions(request) {
+  assertNonEmptyString(request.url, "fromHttp: url");
+  assertNonEmptyString(request.method, "fromHttp: method");
+  return driverOneShotSource(
+    "fromHttp",
+    "fromHttp: missing http driver",
+    (ctx, callback) => ctx.environment().httpDriver()?.request(request, callback)
+  );
+}
+function fromSSE(url) {
+  return fromSSEWithOptions({ url });
+}
+function fromSSEWithOptions(request) {
+  assertNonEmptyString(request.url, "fromSSE: url");
+  return driverStreamSource(
+    "fromSSE",
+    "fromSSE: missing sse driver",
+    (ctx, callback) => ctx.environment().sseDriver()?.connect(request, callback),
+    (event) => event.kind === "event" ? event.event : void 0,
+    (event) => event.kind === "error" ? event.error : void 0
+  );
+}
+function fromWebSocket(url) {
+  return fromWebSocketWithOptions({ url });
+}
+function fromWebSocketWithOptions(request) {
+  assertNonEmptyString(request.url, "fromWebSocket: url");
+  return driverStreamSource(
+    "fromWebSocket",
+    "fromWebSocket: missing websocket driver",
+    (ctx, callback) => ctx.environment().webSocketDriver()?.connect(request, callback),
+    (event) => event.kind === "event" ? event.event : void 0,
+    (event) => event.kind === "error" ? event.error : void 0
+  );
+}
+function fromWebhook(id) {
+  return fromWebhookWithOptions({ id });
+}
+function fromWebhookWithOptions(registration) {
+  assertNonEmptyString(registration.id, "fromWebhook: id");
+  return driverStreamSource(
+    "fromWebhook",
+    "fromWebhook: missing webhook driver",
+    (ctx, callback) => ctx.environment().webhookDriver()?.register(registration, callback),
+    (event) => event.kind === "event" ? event.event : void 0,
+    (event) => event.kind === "error" ? event.error : void 0
+  );
+}
+function timerSource(factory, ms, opts) {
+  const { period, signal } = opts ?? {};
+  const op = source(
+    factory,
+    (ctx) => {
+      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 onAbort = () => {
+        if (done) return;
+        cleanup();
+        ctx.down([["ERROR", errorPayload(signal?.reason)]]);
+      };
+      const finish = () => {
+        if (done) return;
+        if (period != null) {
+          ctx.down([["DATA", count++]]);
+          iv = setInterval(() => {
+            if (done) return;
+            ctx.down([["DATA", count++]]);
+          }, period);
+        } else {
+          done = true;
+          signal?.removeEventListener("abort", onAbort);
+          ctx.down([["DATA", count++], ["COMPLETE"]]);
+        }
+      };
+      if (signal?.aborted) {
+        onAbort();
+        return;
+      }
+      signal?.addEventListener("abort", onAbort, { once: true });
+      t = setTimeout(finish, ms);
+      return cleanup;
+    },
+    { pool: "sync", pausable: false }
+  );
+  if (factory === "timer" && period === void 0 && signal === void 0) {
+    return { ...op, restore: { ref: "timer", config: { ms: toCheckpointJson(ms, "timer.ms") } } };
+  }
+  return op;
+}
+function timer(ms, opts) {
+  return timerSource("timer", ms, opts);
+}
+function fromTimer(ms, opts) {
+  return timerSource("fromTimer", ms, opts);
+}
+function interval(ms) {
+  return timerSource("interval", ms, { period: ms });
+}
+function fromPromise(p, opts) {
+  const signal = opts?.signal;
+  return source(
+    "fromPromise",
+    (ctx) => {
+      let settled = false;
+      const onAbort = () => {
+        if (settled) return;
+        settled = true;
+        ctx.down([["ERROR", errorPayload(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);
+          ctx.down([["DATA", v], ["COMPLETE"]]);
+        },
+        (e) => {
+          if (settled) return;
+          settled = true;
+          signal?.removeEventListener("abort", onAbort);
+          ctx.down([["ERROR", errorPayload(e)]]);
+        }
+      );
+      return () => {
+        settled = true;
+        signal?.removeEventListener("abort", onAbort);
+      };
+    },
+    { pool: "async" }
+  );
+}
+function fromAsyncIter(iterable, opts) {
+  const outerSignal = opts?.signal;
+  return source(
+    "fromAsyncIter",
+    (ctx) => {
+      const ac = new AbortController();
+      const onOuterAbort = () => ac.abort(outerSignal?.reason);
+      outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
+      let done = false;
+      const pump = async () => {
+        try {
+          for await (const v of iterable) {
+            if (ac.signal.aborted) break;
+            ctx.down([["DATA", v]]);
+          }
+          if (!ac.signal.aborted) ctx.down([["COMPLETE"]]);
+        } catch (e) {
+          if (!ac.signal.aborted) ctx.down([["ERROR", errorPayload(e)]]);
+        } finally {
+          done = true;
+        }
+      };
+      void pump();
+      return () => {
+        if (!done) ac.abort();
+        outerSignal?.removeEventListener("abort", onOuterAbort);
+      };
+    },
+    { pool: "async" }
+  );
+}
+function of(...values) {
+  return source(
+    "of",
+    (ctx) => {
+      for (const value of values) ctx.down([["DATA", value]]);
+      ctx.down([["COMPLETE"]]);
+    },
+    { pool: "sync" }
+  );
+}
+function fromIter(iterable) {
+  return source(
+    "fromIter",
+    (ctx) => {
+      for (const v of iterable) ctx.down([["DATA", v]]);
+      ctx.down([["COMPLETE"]]);
+    },
+    { pool: "sync" }
+  );
+}
+function empty() {
+  return source(
+    "empty",
+    (ctx) => {
+      ctx.down([["COMPLETE"]]);
+    },
+    { pool: "sync" }
+  );
+}
+function never() {
+  return source("never", () => void 0, { pool: "sync" });
+}
+function throwError(err) {
+  return source(
+    "throwError",
+    (ctx) => {
+      ctx.down([["ERROR", errorPayload(err)]]);
+    },
+    { pool: "sync" }
+  );
+}
+function fromEvent(target, type, opts = {}) {
+  if (target == null || typeof target.addEventListener !== "function") {
+    throw new TypeError("fromEvent: target must implement addEventListener");
+  }
+  if (typeof target.removeEventListener !== "function") {
+    throw new TypeError("fromEvent: target must implement removeEventListener");
+  }
+  if (typeof type !== "string" || type.length === 0) {
+    throw new TypeError("fromEvent: event type must be a non-empty string");
+  }
+  return source(
+    "fromEvent",
+    (ctx) => {
+      let done = false;
+      const handler = (event) => {
+        if (!done) ctx.down([["DATA", event]]);
+      };
+      target.addEventListener(type, handler, opts);
+      return () => {
+        done = true;
+        target.removeEventListener(type, handler, opts);
+      };
+    },
+    { pool: "sync" }
+  );
+}
+function fromPushNotification(register) {
+  if (typeof register !== "function") {
+    throw new TypeError("fromPushNotification: register must be a function");
+  }
+  return source(
+    "fromPushNotification",
+    (ctx) => {
+      let done = false;
+      const deliver = (payload) => {
+        if (!done) ctx.down([["DATA", payload]]);
+      };
+      const unsubscribe = register(deliver);
+      return () => {
+        done = true;
+        if (typeof unsubscribe === "function") unsubscribe();
+      };
+    },
+    { pool: "sync" }
+  );
+}
+function fromAny(input, opts = {}) {
+  if (isNode(input)) return input;
+  const { iter, ...nodeOpts } = opts;
+  if (isThenable(input)) {
+    return initNode(fromPromise(input), [], nodeOpts);
+  }
+  if (input !== null && input !== void 0) {
+    const candidate = input;
+    if (typeof candidate[Symbol.asyncIterator] === "function") {
+      return initNode(fromAsyncIter(input), [], nodeOpts);
+    }
+    if (iter === true && typeof candidate[Symbol.iterator] === "function") {
+      return initNode(fromIter(input), [], nodeOpts);
+    }
+  }
+  return initNode(of(input), [], nodeOpts);
+}
+function firstValueFrom(source2) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let shouldUnsub = false;
+    let unsub;
+    const finish = (f) => {
+      if (settled) return;
+      settled = true;
+      f();
+      if (unsub) {
+        unsub();
+        unsub = void 0;
+      } else {
+        shouldUnsub = true;
+      }
+    };
+    unsub = source2.subscribe((msg) => {
+      if (msg[0] === "DATA") {
+        finish(() => resolve(msg[1]));
+      } else if (msg[0] === "ERROR") {
+        finish(() => reject(msg[1]));
+      } else if (msg[0] === "COMPLETE") {
+        finish(() => reject(new Error("firstValueFrom: completed without DATA")));
+      } else if (msg[0] === "TEARDOWN") {
+        finish(() => reject(new Error("firstValueFrom: torn down without DATA")));
+      }
+    });
+    if (shouldUnsub) {
+      unsub?.();
+      unsub = void 0;
+    }
+  });
+}
+function singleFromAnyValue(value) {
+  if (value === void 0) {
+    throw new TypeError("singleFromAny: undefined is the substrate SENTINEL");
+  }
+  return value;
+}
+async function firstFromAsyncIterable(input) {
+  const iter = input[Symbol.asyncIterator]();
+  const { value, done } = await iter.next();
+  if (done) {
+    await iter.return?.();
+    throw new Error("singleFromAny: factory returned empty async iterable");
+  }
+  try {
+    await iter.return?.();
+  } catch {
+  }
+  return value;
+}
+function firstFromIterable(input) {
+  const iter = input[Symbol.iterator]();
+  const { value, done } = iter.next();
+  if (done) {
+    iter.return?.();
+    return Promise.reject(new Error("singleFromAny: factory returned empty iterable"));
+  }
+  try {
+    iter.return?.();
+  } catch {
+  }
+  return Promise.resolve(value);
+}
+function nodeInputToPromise(input, opts) {
+  if (isThenable(input)) return Promise.resolve(input).then(singleFromAnyValue);
+  if (isNode(input)) return firstValueFrom(input).then(singleFromAnyValue);
+  if (isAsyncIterable(input)) return firstFromAsyncIterable(input).then(singleFromAnyValue);
+  if (opts.iter === true && isIterable(input)) {
+    return firstFromIterable(input).then(singleFromAnyValue);
+  }
+  if (input === void 0) {
+    return Promise.reject(new TypeError("singleFromAny: undefined is the substrate SENTINEL"));
+  }
+  return Promise.resolve(singleFromAnyValue(input));
+}
+function singleFromAny(factory, opts = {}) {
+  const keyOf = opts.keyOf ?? ((key) => key);
+  const inFlight = /* @__PURE__ */ new Map();
+  return (key) => {
+    const dedupeKey = keyOf(key);
+    const existing = inFlight.get(dedupeKey);
+    if (existing) return existing;
+    let resolvePending;
+    let rejectPending;
+    let tracked;
+    const cleanup = () => {
+      if (inFlight.get(dedupeKey) === tracked) inFlight.delete(dedupeKey);
+    };
+    const pending = new Promise((resolve, reject) => {
+      resolvePending = resolve;
+      rejectPending = reject;
+    });
+    tracked = pending.then(
+      (value) => {
+        cleanup();
+        return value;
+      },
+      (error) => {
+        cleanup();
+        throw error;
+      }
+    );
+    inFlight.set(dedupeKey, tracked);
+    try {
+      nodeInputToPromise(factory(key), opts).then(resolvePending, rejectPending);
+    } catch (e) {
+      rejectPending(e);
+    }
+    return tracked;
+  };
+}
+
+export {
+  parseCron,
+  matchesCron,
+  fromCron,
+  runProcess,
+  fromProcess,
+  runProcessWithOptions,
+  fromHttp,
+  fromHttpWithOptions,
+  fromSSE,
+  fromSSEWithOptions,
+  fromWebSocket,
+  fromWebSocketWithOptions,
+  fromWebhook,
+  fromWebhookWithOptions,
+  timer,
+  fromTimer,
+  interval,
+  fromPromise,
+  fromAsyncIter,
+  of,
+  fromIter,
+  empty,
+  never,
+  throwError,
+  fromEvent,
+  fromPushNotification,
+  fromAny,
+  firstValueFrom,
+  singleFromAny
+};
+//# sourceMappingURL=chunk-G4M3NHRJ.js.map