stitchkit 0.94.0 → 0.95.0

package/dist/index-mkm15s49.js

@@ -1,394 +0,0 @@
-import {
-  createBoundedChannel
-} from "./index-d9pk3td4.js";
-
-// src/browser/live-state.ts
-import { z } from "zod";
-var PositiveSafeIntegerSchema = z.number().int().positive().safe();
-var LiveStatePhaseSchema = z.enum([
-  "idle",
-  "opening",
-  "live",
-  "resync-required",
-  "unavailable",
-  "closed"
-]);
-var LiveStateStopReasonSchema = z.enum([
-  "gap",
-  "buffer-overflow",
-  "source-unavailable",
-  "source-error",
-  "controller-error",
-  "controller-capacity"
-]);
-var LiveStateControllerStatusSchema = z.object({
-  phase: LiveStatePhaseSchema,
-  generation: z.number().int().nonnegative(),
-  hasValue: z.boolean(),
-  bufferedEvents: z.number().int().nonnegative(),
-  bufferedBytes: z.number().int().nonnegative(),
-  receivedEvents: z.number().int().nonnegative(),
-  appliedEvents: z.number().int().nonnegative(),
-  duplicateEvents: z.number().int().nonnegative(),
-  gapEvents: z.number().int().nonnegative(),
-  refusedEvents: z.number().int().nonnegative(),
-  reason: LiveStateStopReasonSchema.optional()
-}).strict().readonly();
-function createLiveStateController(config) {
-  const maxBufferedEvents = PositiveSafeIntegerSchema.parse(config.maxBufferedEvents);
-  const maxBufferedBytes = PositiveSafeIntegerSchema.parse(config.maxBufferedBytes);
-  const subscribers = new Set;
-  let phase = "idle";
-  let reason;
-  let generation = 0;
-  let stored = { hasValue: false };
-  let receivedEvents = 0;
-  let appliedEvents = 0;
-  let duplicateEvents = 0;
-  let gapEvents = 0;
-  let refusedEvents = 0;
-  let current;
-  let opening;
-  let unsettledSourceOpens = 0;
-  let unsettledSourceCloses = 0;
-  let publishDepth = 0;
-  let controllerErrorObserverEnabled = true;
-  let subscriberErrorObserverEnabled = true;
-  const isPromiseLike = (value) => (typeof value === "object" || typeof value === "function") && value !== null && ("then" in value) && typeof value.then === "function";
-  const status = () => {
-    const buffered = current?.buffer.getSnapshot();
-    return LiveStateControllerStatusSchema.parse({
-      phase,
-      generation,
-      hasValue: stored.hasValue,
-      bufferedEvents: buffered?.queuedItems ?? 0,
-      bufferedBytes: buffered?.queuedBytes ?? 0,
-      receivedEvents,
-      appliedEvents,
-      duplicateEvents,
-      gapEvents,
-      refusedEvents,
-      ...reason && { reason }
-    });
-  };
-  const buildSnapshot = () => {
-    const metadata = status();
-    return stored.hasValue ? Object.freeze({ ...metadata, value: stored.value }) : metadata;
-  };
-  let published = buildSnapshot();
-  const reportControllerError = (error, at, atGeneration) => {
-    if (!config.onControllerError || !controllerErrorObserverEnabled)
-      return;
-    try {
-      const returned = config.onControllerError({
-        error,
-        generation: atGeneration,
-        phase: at
-      });
-      if (isPromiseLike(returned)) {
-        controllerErrorObserverEnabled = false;
-        Promise.resolve(returned).catch(() => {
-          return;
-        });
-      }
-    } catch {}
-  };
-  const reportSubscriberError = (error, snapshot) => {
-    if (!config.onSubscriberError || !subscriberErrorObserverEnabled)
-      return;
-    try {
-      const returned = config.onSubscriberError({ error, snapshot });
-      if (isPromiseLike(returned)) {
-        subscriberErrorObserverEnabled = false;
-        Promise.resolve(returned).catch(() => {
-          return;
-        });
-      }
-    } catch {}
-  };
-  const publish = () => {
-    const snapshot = buildSnapshot();
-    published = snapshot;
-    publishDepth += 1;
-    try {
-      for (const listener of subscribers) {
-        try {
-          const returned = listener(snapshot);
-          if (isPromiseLike(returned)) {
-            subscribers.delete(listener);
-            reportSubscriberError(new TypeError("Live-state subscribers must settle synchronously"), snapshot);
-            Promise.resolve(returned).catch(() => {
-              return;
-            });
-          }
-        } catch (error) {
-          reportSubscriberError(error, snapshot);
-        }
-      }
-    } finally {
-      publishDepth -= 1;
-    }
-    return published;
-  };
-  const publishAvailableCapacity = () => {
-    if (phase !== "unavailable" || reason !== "controller-capacity" || unsettledSourceOpens + unsettledSourceCloses >= 2)
-      return;
-    phase = "resync-required";
-    publish();
-  };
-  const closeSource = (active) => {
-    if (active.closePromise)
-      return active.closePromise;
-    if (!active.closeSource)
-      return Promise.resolve();
-    const at = phase;
-    unsettledSourceCloses += 1;
-    active.closePromise = Promise.resolve().then(() => active.closeSource?.()).then(() => {
-      return;
-    }).catch((error) => {
-      reportControllerError(error, at, active.id);
-    }).finally(() => {
-      unsettledSourceCloses -= 1;
-      publishAvailableCapacity();
-    });
-    return active.closePromise;
-  };
-  const retire = (active) => {
-    if (!active.retired) {
-      active.retired = true;
-      active.settleRetired();
-      active.abort.abort();
-      active.buffer.close({ mode: "discard" });
-    }
-    return closeSource(active);
-  };
-  const stopGeneration = (active, nextPhase, nextReason) => {
-    if (current !== active || active.retired || phase === "closed")
-      return;
-    phase = nextPhase;
-    reason = nextReason;
-    retire(active);
-    publish();
-  };
-  const apply = (active, event) => {
-    if (current !== active || active.retired || !stored.hasValue || phase !== "opening" && phase !== "live")
-      return;
-    let decision;
-    try {
-      decision = config.applyEvent(stored.value, event);
-    } catch (error) {
-      reportControllerError(error, phase, active.id);
-      stopGeneration(active, "unavailable", "controller-error");
-      return;
-    }
-    if (current !== active || active.retired || phase !== "opening" && phase !== "live")
-      return;
-    if (!decision || !["applied", "duplicate", "gap"].includes(decision.outcome) || decision.outcome === "applied" && !("state" in decision)) {
-      reportControllerError(new Error("applyEvent returned an invalid decision"), phase, active.id);
-      stopGeneration(active, "unavailable", "controller-error");
-      return;
-    }
-    if (decision.outcome === "duplicate") {
-      duplicateEvents += 1;
-      publish();
-      return;
-    }
-    if (decision.outcome === "gap") {
-      gapEvents += 1;
-      stopGeneration(active, "resync-required", "gap");
-      return;
-    }
-    stored = { hasValue: true, value: decision.state };
-    appliedEvents += 1;
-    publish();
-  };
-  const onEvent = (active, event) => {
-    if (current !== active || active.retired || phase === "closed")
-      return;
-    receivedEvents += 1;
-    if (phase === "opening") {
-      try {
-        const offered = active.buffer.offer(event);
-        if (offered.outcome === "refused") {
-          refusedEvents += 1;
-          stopGeneration(active, "resync-required", "buffer-overflow");
-        } else {
-          publish();
-        }
-      } catch (error) {
-        refusedEvents += 1;
-        reportControllerError(error, phase, active.id);
-        stopGeneration(active, "unavailable", "controller-error");
-      }
-      return;
-    }
-    if (phase === "live")
-      apply(active, event);
-  };
-  const openGeneration = async (active) => {
-    try {
-      if (active.retired || current !== active || phase === "closed")
-        return published;
-      unsettledSourceOpens += 1;
-      let sourceOpening;
-      try {
-        sourceOpening = config.source.open({
-          signal: active.abort.signal,
-          onEvent: (event) => onEvent(active, event),
-          onUnavailable: () => stopGeneration(active, "unavailable", "source-unavailable")
-        });
-      } catch (error) {
-        unsettledSourceOpens -= 1;
-        publishAvailableCapacity();
-        throw error;
-      }
-      sourceOpening = sourceOpening.then((opened2) => {
-        active.closeSource = () => opened2.close();
-        unsettledSourceOpens -= 1;
-        if (active.retired || current !== active || phase === "closed") {
-          closeSource(active);
-        }
-        publishAvailableCapacity();
-        return opened2;
-      }, (error) => {
-        unsettledSourceOpens -= 1;
-        publishAvailableCapacity();
-        throw error;
-      });
-      const outcome = await Promise.race([
-        sourceOpening.then((opened2) => ({ outcome: "opened", opened: opened2 })),
-        active.retiredPromise.then(() => ({ outcome: "retired" }))
-      ]);
-      if (outcome.outcome === "retired") {
-        return published;
-      }
-      const { opened } = outcome;
-      if (current !== active || active.retired || phase !== "opening") {
-        closeSource(active);
-        return published;
-      }
-      stored = { hasValue: true, value: opened.snapshot };
-      publish();
-      while (current === active && !active.retired && phase === "opening") {
-        if (active.buffer.getSnapshot().queuedItems === 0) {
-          active.buffer.close({ mode: "discard" });
-          phase = "live";
-          reason = undefined;
-          return publish();
-        }
-        const next = await active.buffer.next();
-        if (next.done)
-          break;
-        apply(active, next.value);
-      }
-      if (current && current !== active && opening)
-        return opening;
-      return published;
-    } catch (error) {
-      if (current === active && !active.retired && phase !== "closed") {
-        reportControllerError(error, phase, active.id);
-        stopGeneration(active, "unavailable", "source-error");
-      }
-      publishAvailableCapacity();
-      return published;
-    }
-  };
-  const begin = (startedByResync) => {
-    generation += 1;
-    phase = "opening";
-    reason = undefined;
-    let settleRetired = () => {
-      return;
-    };
-    const retiredPromise = new Promise((resolve) => {
-      settleRetired = resolve;
-    });
-    const active = {
-      id: generation,
-      startedByResync,
-      abort: new AbortController,
-      buffer: createBoundedChannel({
-        policy: "ordered",
-        maxItems: maxBufferedEvents,
-        maxBytes: maxBufferedBytes,
-        sizeOf: config.sizeOfEvent
-      }),
-      retiredPromise,
-      settleRetired,
-      retired: false,
-      sourceOpenStarted: false
-    };
-    current = active;
-    publish();
-    if (current !== active || active.retired || phase !== "opening") {
-      return opening ?? Promise.resolve(published);
-    }
-    active.sourceOpenStarted = true;
-    const operation = openGeneration(active);
-    opening = operation;
-    operation.finally(() => {
-      if (opening === operation)
-        opening = undefined;
-    });
-    return operation;
-  };
-  const close = () => {
-    if (phase === "closed")
-      return Promise.resolve(published);
-    const active = current;
-    current = undefined;
-    phase = "closed";
-    reason = undefined;
-    const snapshot = publish();
-    if (active)
-      retire(active);
-    config.signal?.removeEventListener("abort", abortFromConfig);
-    subscribers.clear();
-    return Promise.resolve(snapshot);
-  };
-  function abortFromConfig() {
-    close();
-  }
-  if (config.signal?.aborted) {
-    phase = "closed";
-    published = buildSnapshot();
-  } else {
-    config.signal?.addEventListener("abort", abortFromConfig, { once: true });
-  }
-  return {
-    start() {
-      if (phase === "idle")
-        return begin(false);
-      return opening ?? Promise.resolve(published);
-    },
-    resync() {
-      if (phase === "closed")
-        return Promise.resolve(published);
-      const active = current;
-      if (active?.startedByResync && !active.sourceOpenStarted && phase === "opening" && publishDepth > 0) {
-        return opening ?? Promise.resolve(published);
-      }
-      if (active) {
-        retire(active);
-        if (unsettledSourceOpens + unsettledSourceCloses >= 2) {
-          phase = "unavailable";
-          reason = "controller-capacity";
-          return Promise.resolve(publish());
-        }
-      }
-      return begin(true);
-    },
-    getSnapshot: () => published,
-    subscribe(listener) {
-      if (phase === "closed")
-        return () => {
-          return;
-        };
-      subscribers.add(listener);
-      return () => subscribers.delete(listener);
-    },
-    close
-  };
-}
-
-export { LiveStatePhaseSchema, LiveStateStopReasonSchema, LiveStateControllerStatusSchema, createLiveStateController };