@graphrefly/graphrefly 0.21.0 → 0.22.0

package/dist/{chunk-VOQFK7YN.js → chunk-IR3KMOLX.js}

@@ -4,6 +4,7 @@ import {
   DIRTY,
   ERROR,
   PAUSE,
+  RESOLVED,
   RESUME,
   batch,
   derived,
@@ -11,7 +12,7 @@ import {
   producer,
   state,
   wallClockNs
-} from "./chunk-4MQ2J6IG.js";
+} from "./chunk-QA3RP5NH.js";
 
 // src/extra/observable.ts
 import { Observable } from "rxjs";
@@ -103,9 +104,6 @@ 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;
 }
@@ -135,20 +133,28 @@ function matchesAnyPattern(path, patterns) {
   return false;
 }
 function wrapSubscribeHook(inner, before) {
-  const wrapper = node([inner], ([val]) => val, {
-    describeKind: "operator",
-    initial: inner.get()
-  });
+  const wrapper = node(
+    [inner],
+    (data, a) => {
+      const batch0 = data[0];
+      if (batch0 == null || batch0.length === 0) {
+        a.down([[RESOLVED]]);
+        return;
+      }
+      for (const v of batch0) a.emit(v);
+    },
+    { describeKind: "derived", initial: inner.cache }
+  );
   const origSubscribe = wrapper.subscribe.bind(wrapper);
-  wrapper.subscribe = (sink, hints) => {
+  wrapper.subscribe = (sink, actor) => {
     before(sink);
-    return origSubscribe(sink, hints);
+    return origSubscribe(sink, actor);
   };
   return wrapper;
 }
 function fromTimer(ms, opts) {
   const { signal, period, ...rest } = opts ?? {};
-  return producer((_d, a) => {
+  return producer((a) => {
     let done = false;
     let count = 0;
     let t;
@@ -161,8 +167,8 @@ function fromTimer(ms, opts) {
     };
     const finish = () => {
       if (done) return;
-      a.emit(count++);
       if (period != null) {
+        a.emit(count++);
         iv = setInterval(() => {
           if (done) return;
           a.emit(count++);
@@ -170,7 +176,8 @@ function fromTimer(ms, opts) {
       } else {
         done = true;
         signal?.removeEventListener("abort", onAbort);
-        queueMicrotask(() => a.down([[COMPLETE]]));
+        a.emit(count++);
+        a.down([[COMPLETE]]);
       }
     };
     const onAbort = () => {
@@ -193,7 +200,7 @@ function fromCron(expr, opts) {
   const tickMs = tickOpt ?? 6e4;
   const emitDate = output === "date";
   return producer(
-    (_d, a) => {
+    (a) => {
       let lastFiredKey = -1;
       const check = () => {
         const now = /* @__PURE__ */ new Date();
@@ -212,7 +219,7 @@ function fromCron(expr, opts) {
 }
 function fromEvent(target, type, opts) {
   const { capture, passive, once, ...rest } = opts ?? {};
-  return producer((_d, a) => {
+  return producer((a) => {
     const handler = (e) => {
       a.emit(e);
     };
@@ -231,7 +238,7 @@ function fromFSWatch(paths, opts) {
   const excludePatterns = (exclude ?? ["**/node_modules/**", "**/.git/**", "**/dist/**"]).map(
     globToRegExp
   );
-  return producer((_d, a) => {
+  return producer((a) => {
     const pending = /* @__PURE__ */ new Map();
     const watchers = [];
     let stopped = false;
@@ -315,7 +322,7 @@ function fromFSWatch(paths, opts) {
   }, sourceOpts(rest));
 }
 function fromIter(iterable, opts) {
-  return producer((_d, a) => {
+  return producer((a) => {
     let cancelled = false;
     try {
       for (const x of iterable) {
@@ -336,7 +343,7 @@ function isThenable(x) {
 }
 function fromPromise(p, opts) {
   const { signal, ...rest } = opts ?? {};
-  return producer((_d, a) => {
+  return producer((a) => {
     let settled = false;
     const onAbort = () => {
       if (settled) return;
@@ -371,7 +378,7 @@ function fromPromise(p, opts) {
 }
 function fromAsyncIter(iterable, opts) {
   const { signal: outerSignal, ...rest } = opts ?? {};
-  return producer((_d, a) => {
+  return producer((a) => {
     const ac = new AbortController();
     const onOuterAbort = () => ac.abort(outerSignal?.reason);
     if (outerSignal?.aborted) {
@@ -388,18 +395,18 @@ function fromAsyncIter(iterable, opts) {
         (step) => {
           if (cancelled || signal.aborted) return;
           if (step.done) {
-            queueMicrotask(() => a.down([[COMPLETE]]));
+            a.down([[COMPLETE]]);
             return;
           }
           a.emit(step.value);
-          queueMicrotask(pump);
+          pump();
         },
         (e) => {
           if (!cancelled && !signal.aborted) a.down([[ERROR, e]]);
         }
       );
     };
-    queueMicrotask(pump);
+    pump();
     return () => {
       cancelled = true;
       outerSignal?.removeEventListener("abort", onOuterAbort);
@@ -409,7 +416,7 @@ function fromAsyncIter(iterable, opts) {
   }, sourceOpts(rest));
 }
 function isNode(x) {
-  return x != null && typeof x.subscribe === "function" && typeof x.get === "function";
+  return x != null && typeof x === "object" && "cache" in x && typeof x.subscribe === "function";
 }
 function fromAny(input, opts) {
   if (isNode(input)) {
@@ -433,7 +440,7 @@ function of(...values) {
   return fromIter(values, void 0);
 }
 function empty(opts) {
-  return producer((_d, a) => {
+  return producer((a) => {
     a.down([[COMPLETE]]);
     return void 0;
   }, sourceOpts(opts));
@@ -442,58 +449,64 @@ function never(opts) {
   return producer(() => void 0, sourceOpts(opts));
 }
 function throwError(err, opts) {
-  return producer((_d, a) => {
+  return producer((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;
+  const inner = node(
+    [source],
+    (data, _actions) => {
+      const batch0 = data[0];
+      if (batch0 != null && batch0.length > 0) {
+        for (const v of batch0) fn(v);
       }
-      return false;
-    }
-  });
+    },
+    { describeKind: "effect", ...opts }
+  );
   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;
+  return node(
+    [source],
+    (data, actions, ctx) => {
+      if (!ctx.store.buf) ctx.store.buf = [];
+      const buf = ctx.store.buf;
+      const batch0 = data[0];
+      if (batch0 != null && batch0.length > 0) {
+        for (const v of batch0) buf.push(v);
       }
-      if (msg[0] === COMPLETE) {
-        a.emit([...acc]);
-        a.down([[COMPLETE]]);
-        return true;
+      if (ctx.terminalDeps[0] === true) {
+        actions.emit([...buf]);
+        actions.down([[COMPLETE]]);
+        return;
       }
-      return false;
+      if (batch0 == null || batch0.length === 0) {
+        actions.down([[RESOLVED]]);
+      }
+    },
+    {
+      describeKind: "derived",
+      completeWhenDepsComplete: false,
+      ...opts
     }
-  });
+  );
 }
 function share(source, opts) {
   return producer(
-    (_d, a) => source.subscribe((msgs) => {
+    (a) => source.subscribe((msgs) => {
       a.down(msgs);
     }),
-    { ...sourceOpts(opts), initial: source.get() }
+    { ...sourceOpts(opts), initial: source.cache }
   );
 }
 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) => {
+    (a) => source.subscribe((msgs) => {
       for (const m of msgs) {
         if (m[0] === DATA) {
           buf.push(m[1]);
@@ -502,7 +515,7 @@ function replay(source, bufferSize, opts) {
       }
       a.down(msgs);
     }),
-    { ...sourceOpts(opts), initial: source.get() }
+    { ...sourceOpts(opts), initial: source.cache }
   );
   return wrapSubscribeHook(inner, (sink) => {
     for (const v of buf) {
@@ -516,35 +529,52 @@ function cached(source, opts) {
 function firstValueFrom(source) {
   return new Promise((resolve, reject) => {
     let settled = false;
-    const unsub = source.subscribe((msgs) => {
+    let shouldUnsub = false;
+    let unsub;
+    unsub = source.subscribe((msgs) => {
       for (const m of msgs) {
         if (settled) return;
         if (m[0] === DATA) {
           settled = true;
           resolve(m[1]);
-          queueMicrotask(() => unsub());
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
           return;
         }
         if (m[0] === ERROR) {
           settled = true;
           reject(m[1]);
-          queueMicrotask(() => unsub());
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
           return;
         }
         if (m[0] === COMPLETE) {
           settled = true;
           reject(new Error("completed without DATA"));
-          queueMicrotask(() => unsub());
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
           return;
         }
       }
     });
+    if (shouldUnsub) {
+      unsub?.();
+      unsub = void 0;
+    }
   });
 }
 function firstWhere(source, predicate) {
   return new Promise((resolve, reject) => {
     let settled = false;
-    const unsub = source.subscribe((msgs) => {
+    let shouldUnsub = false;
+    let unsub;
+    unsub = source.subscribe((msgs) => {
       for (const m of msgs) {
         if (settled) return;
         if (m[0] === DATA) {
@@ -552,24 +582,37 @@ function firstWhere(source, predicate) {
           if (predicate(v)) {
             settled = true;
             resolve(v);
-            queueMicrotask(() => unsub());
+            if (unsub) {
+              unsub();
+              unsub = void 0;
+            } else shouldUnsub = true;
             return;
           }
         }
         if (m[0] === ERROR) {
           settled = true;
           reject(m[1]);
-          queueMicrotask(() => unsub());
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
           return;
         }
         if (m[0] === COMPLETE) {
           settled = true;
           reject(new Error("completed without matching value"));
-          queueMicrotask(() => unsub());
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
           return;
         }
       }
     });
+    if (shouldUnsub) {
+      unsub?.();
+      unsub = void 0;
+    }
   });
 }
 var shareReplay = replay;
@@ -582,16 +625,16 @@ function reactiveCounter(cap) {
   return {
     node: counter,
     increment() {
-      const current = counter.get() ?? 0;
+      const current = counter.cache ?? 0;
       if (current >= cap) return false;
       counter.down([[DIRTY], [DATA, current + 1]]);
       return true;
     },
     get() {
-      return counter.get() ?? 0;
+      return counter.cache ?? 0;
     },
     atCap() {
-      return (counter.get() ?? 0) >= cap;
+      return (counter.cache ?? 0) >= cap;
     }
   };
 }
@@ -641,103 +684,290 @@ function createWatermarkController(sendUp, opts) {
 }
 
 // src/extra/reactive-log.ts
+var NativeLogBackend = class {
+  _version = 0;
+  _maxSize;
+  _buf;
+  _head = 0;
+  _size = 0;
+  constructor(initial, maxSize) {
+    if (maxSize !== void 0 && maxSize < 1) {
+      throw new RangeError("maxSize must be >= 1");
+    }
+    this._maxSize = maxSize;
+    if (maxSize !== void 0) {
+      this._buf = new Array(maxSize);
+      if (initial && initial.length > 0) {
+        const take = Math.min(initial.length, maxSize);
+        const start = initial.length - take;
+        for (let i = 0; i < take; i++) {
+          this._buf[i] = initial[start + i];
+        }
+        this._size = take;
+      }
+    } else {
+      this._buf = initial ? [...initial] : [];
+      this._size = this._buf.length;
+    }
+  }
+  get version() {
+    return this._version;
+  }
+  get size() {
+    return this._size;
+  }
+  at(index) {
+    if (!Number.isInteger(index)) return void 0;
+    const i = index >= 0 ? index : this._size + index;
+    if (i < 0 || i >= this._size) return void 0;
+    if (this._maxSize !== void 0) {
+      return this._buf[(this._head + i) % this._maxSize];
+    }
+    return this._buf[i];
+  }
+  append(value) {
+    this._rawAppend(value);
+    this._version += 1;
+  }
+  appendMany(values) {
+    if (values.length === 0) return;
+    const start = this._maxSize !== void 0 && values.length > this._maxSize ? values.length - this._maxSize : 0;
+    for (let i = start; i < values.length; i++) {
+      this._rawAppend(values[i]);
+    }
+    this._version += 1;
+  }
+  clear() {
+    if (this._size === 0) return 0;
+    const n = this._size;
+    if (this._maxSize === void 0) {
+      this._buf.length = 0;
+    } else {
+      for (let i = 0; i < n; i++) {
+        this._buf[(this._head + i) % this._maxSize] = void 0;
+      }
+    }
+    this._head = 0;
+    this._size = 0;
+    this._version += 1;
+    return n;
+  }
+  trimHead(n) {
+    if (!Number.isInteger(n) || n < 0) {
+      throw new RangeError(`trimHead: n must be a non-negative integer (got ${n})`);
+    }
+    if (n === 0 || this._size === 0) return 0;
+    const removed = Math.min(n, this._size);
+    if (this._maxSize === void 0) {
+      this._buf.splice(0, removed);
+    } else {
+      for (let i = 0; i < removed; i++) {
+        this._buf[(this._head + i) % this._maxSize] = void 0;
+      }
+      this._head = (this._head + removed) % this._maxSize;
+    }
+    this._size -= removed;
+    this._version += 1;
+    return removed;
+  }
+  slice(start, stop) {
+    if (!Number.isInteger(start) || start < 0) {
+      throw new RangeError(`slice: start must be a non-negative integer (got ${start})`);
+    }
+    if (stop !== void 0 && (!Number.isInteger(stop) || stop < 0)) {
+      throw new RangeError(`slice: stop must be a non-negative integer or undefined (got ${stop})`);
+    }
+    const end = stop === void 0 ? this._size : Math.min(Math.max(stop, 0), this._size);
+    const s = Math.min(start, this._size);
+    if (s >= end) return [];
+    const len = end - s;
+    if (this._maxSize === void 0) {
+      return this._buf.slice(s, end);
+    }
+    const out = new Array(len);
+    for (let i = 0; i < len; i++) {
+      out[i] = this._buf[(this._head + s + i) % this._maxSize];
+    }
+    return out;
+  }
+  tail(n) {
+    if (!Number.isInteger(n) || n < 0) {
+      throw new RangeError(`tail: n must be a non-negative integer (got ${n})`);
+    }
+    if (n === 0 || this._size === 0) return [];
+    const take = Math.min(n, this._size);
+    return this.slice(this._size - take, this._size);
+  }
+  toArray() {
+    if (this._maxSize === void 0) {
+      return [...this._buf];
+    }
+    const out = new Array(this._size);
+    for (let i = 0; i < this._size; i++) {
+      out[i] = this._buf[(this._head + i) % this._maxSize];
+    }
+    return out;
+  }
+  /** Internal append without version bump — used by `appendMany`. */
+  _rawAppend(value) {
+    if (this._maxSize === void 0) {
+      this._buf.push(value);
+      this._size = this._buf.length;
+      return;
+    }
+    if (this._size < this._maxSize) {
+      this._buf[(this._head + this._size) % this._maxSize] = value;
+      this._size += 1;
+    } else {
+      this._buf[this._head] = value;
+      this._head = (this._head + 1) % this._maxSize;
+    }
+  }
+};
 function keepaliveDerived(n) {
   return n.subscribe(() => {
   });
 }
+var DEFAULT_VIEW_CACHE_MAX = 64;
 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);
-  }
-  const entries = state(buf.length > 0 ? [...buf] : [], {
+  const { name, maxSize, versioning, backend: userBackend } = options;
+  const backend = userBackend ?? new NativeLogBackend(initial, maxSize);
+  const entries = state(backend.toArray(), {
     name,
     describeKind: "state",
-    equals: (a, b) => a === b
+    equals: (a, b) => a === b,
+    ...versioning != null ? { versioning } : {}
   });
   function pushSnapshot() {
-    const snapshot = [...buf];
+    const snapshot = backend.toArray();
     batch(() => {
       entries.down([[DIRTY]]);
       entries.down([[DATA, snapshot]]);
     });
   }
-  function trimBuf() {
-    if (maxSize !== void 0 && buf.length > maxSize) {
-      buf.splice(0, buf.length - maxSize);
+  const tailCache = /* @__PURE__ */ new Map();
+  const sliceCache = /* @__PURE__ */ new Map();
+  function sliceKey(start, stop) {
+    return `${start}:${stop === void 0 ? "END" : stop}`;
+  }
+  function evictOldestIfFull(cache) {
+    if (cache.size < DEFAULT_VIEW_CACHE_MAX) return;
+    const first = cache.keys().next();
+    if (first.done) return;
+    const oldest = cache.get(first.value);
+    if (oldest !== void 0) oldest.dispose();
+    cache.delete(first.value);
+  }
+  function wrapMutation(op) {
+    const prev = backend.version;
+    try {
+      return op();
+    } finally {
+      if (backend.version !== prev) pushSnapshot();
     }
   }
-  const bundle = {
+  return {
     entries,
+    get size() {
+      return backend.size;
+    },
+    at(index) {
+      return backend.at(index);
+    },
     append(value) {
-      buf.push(value);
-      trimBuf();
-      pushSnapshot();
+      wrapMutation(() => backend.append(value));
     },
     appendMany(values) {
       if (values.length === 0) return;
-      buf.push(...values);
-      trimBuf();
-      pushSnapshot();
+      wrapMutation(() => backend.appendMany(values));
     },
     clear() {
-      if (buf.length === 0) return;
-      buf.length = 0;
-      pushSnapshot();
+      wrapMutation(() => backend.clear());
     },
     trimHead(n) {
-      if (n < 0) {
-        throw new RangeError("n must be >= 0");
+      wrapMutation(() => backend.trimHead(n));
+    },
+    tail(n) {
+      if (!Number.isInteger(n) || n < 0) {
+        throw new RangeError(`tail: n must be a non-negative integer (got ${n})`);
       }
-      if (n === 0) return;
-      if (n >= buf.length) {
-        if (buf.length === 0) return;
-        buf.length = 0;
-      } else {
-        buf.splice(0, n);
+      const hit = tailCache.get(n);
+      if (hit !== void 0) {
+        tailCache.delete(n);
+        tailCache.set(n, hit);
+        return hit.node;
       }
-      pushSnapshot();
+      evictOldestIfFull(tailCache);
+      const node_ = derived(
+        [entries],
+        ([s]) => {
+          const list = s;
+          if (n === 0 || list.length === 0) return [];
+          return list.slice(Math.max(0, list.length - n));
+        },
+        { initial: backend.tail(n), describeKind: "derived" }
+      );
+      const dispose = keepaliveDerived(node_);
+      tailCache.set(n, { node: node_, dispose });
+      return node_;
     },
-    tail(n) {
-      if (n < 0) {
-        throw new RangeError("n must be >= 0");
+    slice(start, stop) {
+      if (!Number.isInteger(start) || start < 0) {
+        throw new RangeError(`slice: start must be a non-negative integer (got ${start})`);
+      }
+      if (stop !== void 0 && (!Number.isInteger(stop) || stop < 0)) {
+        throw new RangeError(
+          `slice: stop must be a non-negative integer or undefined (got ${stop})`
+        );
+      }
+      const key = sliceKey(start, stop);
+      const hit = sliceCache.get(key);
+      if (hit !== void 0) {
+        sliceCache.delete(key);
+        sliceCache.set(key, hit);
+        return hit.node;
       }
-      const e = entries.get();
-      const init = n === 0 ? [] : e.slice(Math.max(0, e.length - n));
-      const out = derived(
+      evictOldestIfFull(sliceCache);
+      const node_ = derived(
         [entries],
         ([s]) => {
           const list = s;
-          return n === 0 ? [] : list.slice(Math.max(0, list.length - n));
+          return stop === void 0 ? list.slice(start) : list.slice(start, stop);
         },
-        { initial: init, describeKind: "derived" }
+        { initial: backend.slice(start, stop), describeKind: "derived" }
       );
-      keepaliveDerived(out);
-      return out;
+      const dispose = keepaliveDerived(node_);
+      sliceCache.set(key, { node: node_, dispose });
+      return node_;
+    },
+    disposeTail(n) {
+      const hit = tailCache.get(n);
+      if (hit === void 0) return false;
+      hit.dispose();
+      tailCache.delete(n);
+      return true;
+    },
+    disposeSlice(start, stop) {
+      const key = sliceKey(start, stop);
+      const hit = sliceCache.get(key);
+      if (hit === void 0) return false;
+      hit.dispose();
+      sliceCache.delete(key);
+      return true;
+    },
+    disposeAllViews() {
+      for (const entry of tailCache.values()) entry.dispose();
+      tailCache.clear();
+      for (const entry of sliceCache.values()) entry.dispose();
+      sliceCache.clear();
+    },
+    dispose() {
+      for (const entry of tailCache.values()) entry.dispose();
+      tailCache.clear();
+      for (const entry of sliceCache.values()) entry.dispose();
+      sliceCache.clear();
     }
   };
-  return bundle;
-}
-function logSlice(log, start, stop) {
-  if (start < 0) {
-    throw new RangeError("start must be >= 0");
-  }
-  const e = log.entries.get();
-  const init = stop === void 0 ? e.slice(start) : e.slice(start, stop);
-  const out = derived(
-    [log.entries],
-    ([s]) => {
-      const list = s;
-      return stop === void 0 ? list.slice(start) : list.slice(start, stop);
-    },
-    { initial: init, describeKind: "derived" }
-  );
-  keepaliveDerived(out);
-  return out;
 }
 
 export {
@@ -770,7 +1000,7 @@ export {
   keepalive,
   reactiveCounter,
   createWatermarkController,
-  reactiveLog,
-  logSlice
+  NativeLogBackend,
+  reactiveLog
 };
-//# sourceMappingURL=chunk-VOQFK7YN.js.map
+//# sourceMappingURL=chunk-IR3KMOLX.js.map