@chelone/core 0.5.0 → 0.7.0

package/dist/realtime/in-memory-lock-provider.js

@@ -1,62 +1,43 @@
-import { lockTopic, lockResourceTopic } from "./topics.js";
+import { announceLock } from "./announce-lock.js";
 import { LockConflictError } from "./types.js";
-const storeKey = (resource, id) => JSON.stringify([resource, String(id)]);
-function inMemoryLockProvider({
-  publisher
-} = {}) {
-  const store = /* @__PURE__ */ new Map();
-  const announce = async (type, lock) => {
-    if (!publisher) return;
-    const event = { type, payload: lock };
-    try {
-      await Promise.all([
-        publisher.publish(lockTopic(lock.resource, lock.recordId), event),
-        publisher.publish(lockResourceTopic(lock.resource), event)
-      ]);
-    } catch {
-    }
-  };
-  return {
-    async lock(resource, { id, identity }) {
-      const key = storeKey(resource, id);
-      const existing = store.get(key);
-      if (existing) {
-        if (String(existing.identity) !== String(identity)) {
-          throw new LockConflictError(existing);
-        }
-        return existing;
-      }
-      const lock = {
-        resource,
-        recordId: id,
-        identity,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      store.set(key, lock);
-      await announce("locked", lock);
-      return lock;
-    },
-    async unlock(resource, { id, identity }) {
-      const key = storeKey(resource, id);
-      const existing = store.get(key);
-      if (!existing) {
-        throw new Error(`No lock on ${resource}/${String(id)} to release`);
-      }
-      if (String(existing.identity) !== String(identity)) {
-        throw new LockConflictError(existing);
-      }
-      store.delete(key);
-      await announce("unlocked", existing);
-      return existing;
-    },
-    async getLock(resource, { id }) {
-      return store.get(storeKey(resource, id)) ?? null;
-    },
-    async getLocks(resource) {
-      return [...store.values()].filter((lock) => lock.resource === resource);
-    }
-  };
+// src/realtime/in-memory-lock-provider.ts
+var storeKey = (resource, id) => JSON.stringify([resource, String(id)]);
+/** A `LockProvider` kept in a `Map`, for tests and demos. */
+function inMemoryLockProvider({ publisher } = {}) {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		async lock(resource, { id, identity }) {
+			const key = storeKey(resource, id);
+			const existing = store.get(key);
+			if (existing) {
+				if (String(existing.identity) !== String(identity)) throw new LockConflictError(existing);
+				return existing;
+			}
+			const lock = {
+				resource,
+				recordId: id,
+				identity,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			store.set(key, lock);
+			await announceLock(publisher, "locked", lock);
+			return lock;
+		},
+		async unlock(resource, { id, identity }) {
+			const key = storeKey(resource, id);
+			const existing = store.get(key);
+			if (!existing) throw new Error(`No lock on ${resource}/${String(id)} to release`);
+			if (String(existing.identity) !== String(identity)) throw new LockConflictError(existing);
+			store.delete(key);
+			await announceLock(publisher, "unlocked", existing);
+			return existing;
+		},
+		async getLock(resource, { id }) {
+			return store.get(storeKey(resource, id)) ?? null;
+		},
+		async getLocks(resource) {
+			return [...store.values()].filter((lock) => lock.resource === resource);
+		}
+	};
 }
-export {
-  inMemoryLockProvider
-};
+export { inMemoryLockProvider };

package/dist/realtime/live.js

@@ -1,118 +1,112 @@
 import { lockKey, locksKey, resourceKey } from "../data/keys.js";
 import { hasUnsettledUndoables, onUndoablesSettled } from "../data/undoable.js";
 import { assertRealtimeDataProvider } from "./realtime-data-provider.js";
-import { recordTopic, resourceTopic, lockTopic, lockResourceTopic } from "./topics.js";
+import { lockResourceTopic, lockTopic, recordTopic, resourceTopic } from "./topics.js";
+// src/realtime/live.ts
 function subscribeLive(ctx, spec) {
-  const { dataProvider } = ctx;
-  assertRealtimeDataProvider(dataProvider, spec.caller);
-  let stopped = false;
-  let scheduled = false;
-  let missed = false;
-  const schedule = () => {
-    if (scheduled) return;
-    scheduled = true;
-    queueMicrotask(() => {
-      scheduled = false;
-      if (!stopped) spec.invalidate();
-    });
-  };
-  let stopWaiting;
-  const holdForUndoable = () => {
-    if (stopWaiting) return;
-    stopWaiting = onUndoablesSettled(() => {
-      stopWaiting?.();
-      stopWaiting = void 0;
-      onEvent();
-    });
-  };
-  const onEvent = () => {
-    if (stopped) return;
-    if (spec.holdWhileUndoable && hasUnsettledUndoables()) {
-      holdForUndoable();
-      return;
-    }
-    if (spec.options?.paused?.()) {
-      missed = true;
-      return;
-    }
-    schedule();
-  };
-  const unsubscribes = spec.topics.map(
-    (topic) => dataProvider.subscribe(topic, onEvent)
-  );
-  if (spec.topics.length > 0 && dataProvider.onReconnect) {
-    unsubscribes.push(dataProvider.onReconnect(onEvent));
-  }
-  return {
-    stop() {
-      stopped = true;
-      stopWaiting?.();
-      stopWaiting = void 0;
-      for (const unsubscribe of unsubscribes.splice(0)) unsubscribe();
-    },
-    resume() {
-      if (stopped || !missed) return;
-      missed = false;
-      onEvent();
-    }
-  };
+	const { dataProvider } = ctx;
+	assertRealtimeDataProvider(dataProvider, spec.caller);
+	let stopped = false;
+	let scheduled = false;
+	let missed = false;
+	const schedule = () => {
+		if (scheduled) return;
+		scheduled = true;
+		queueMicrotask(() => {
+			scheduled = false;
+			if (!stopped) spec.invalidate();
+		});
+	};
+	let stopWaiting;
+	const holdForUndoable = () => {
+		if (stopWaiting) return;
+		stopWaiting = onUndoablesSettled(() => {
+			stopWaiting?.();
+			stopWaiting = void 0;
+			onEvent();
+		});
+	};
+	const onEvent = () => {
+		if (stopped) return;
+		if (spec.holdWhileUndoable && hasUnsettledUndoables()) {
+			holdForUndoable();
+			return;
+		}
+		if (spec.options?.paused?.()) {
+			missed = true;
+			return;
+		}
+		schedule();
+	};
+	const unsubscribes = spec.topics.map((topic) => dataProvider.subscribe(topic, onEvent));
+	if (spec.topics.length > 0 && dataProvider.onReconnect) unsubscribes.push(dataProvider.onReconnect(onEvent));
+	return {
+		stop() {
+			stopped = true;
+			stopWaiting?.();
+			stopWaiting = void 0;
+			for (const unsubscribe of unsubscribes.splice(0)) unsubscribe();
+		},
+		resume() {
+			if (stopped || !missed) return;
+			missed = false;
+			onEvent();
+		}
+	};
 }
+/** Invalidates everything under the resource except lock queries, which have their own subscribers. */
 function invalidateResource(ctx, resource) {
-  void ctx.queryClient.invalidateQueries({
-    queryKey: resourceKey(resource),
-    predicate: ({ queryKey }) => queryKey[1] !== "getLock" && queryKey[1] !== "getLocks"
-  });
+	ctx.queryClient.invalidateQueries({
+		queryKey: resourceKey(resource),
+		predicate: ({ queryKey }) => queryKey[1] !== "getLock" && queryKey[1] !== "getLocks"
+	});
 }
+/** Refetches the resource's lists, shows and edits when anything in it changes or the connection comes back. */
 function subscribeLiveResource(ctx, resource, options) {
-  return subscribeLive(ctx, {
-    caller: "subscribeLiveResource",
-    topics: [resourceTopic(resource)],
-    invalidate: () => invalidateResource(ctx, resource),
-    options,
-    holdWhileUndoable: true
-  });
+	return subscribeLive(ctx, {
+		caller: "subscribeLiveResource",
+		topics: [resourceTopic(resource)],
+		invalidate: () => invalidateResource(ctx, resource),
+		options,
+		holdWhileUndoable: true
+	});
 }
+/** Like `subscribeLiveResource`, for the events of one record. */
 function subscribeLiveRecord(ctx, resource, id, options) {
-  return subscribeLive(ctx, {
-    caller: "subscribeLiveRecord",
-    topics: [recordTopic(resource, id)],
-    invalidate: () => invalidateResource(ctx, resource),
-    options,
-    holdWhileUndoable: true
-  });
+	return subscribeLive(ctx, {
+		caller: "subscribeLiveRecord",
+		topics: [recordTopic(resource, id)],
+		invalidate: () => invalidateResource(ctx, resource),
+		options,
+		holdWhileUndoable: true
+	});
 }
+/** Like `subscribeLiveRecord`, for several records: one invalidation however many of them change. */
 function subscribeLiveRecords(ctx, resource, ids, options) {
-  return subscribeLive(ctx, {
-    caller: "subscribeLiveRecords",
-    // `1` and `"1"` give the same topic; listen once.
-    topics: [...new Set(ids.map((id) => recordTopic(resource, id)))],
-    invalidate: () => invalidateResource(ctx, resource),
-    options,
-    holdWhileUndoable: true
-  });
+	return subscribeLive(ctx, {
+		caller: "subscribeLiveRecords",
+		topics: [...new Set(ids.map((id) => recordTopic(resource, id)))],
+		invalidate: () => invalidateResource(ctx, resource),
+		options,
+		holdWhileUndoable: true
+	});
 }
+/** Refetches one record's lock when it is taken or released. */
 function subscribeLiveLock(ctx, resource, id) {
-  return subscribeLive(ctx, {
-    caller: "subscribeLiveLock",
-    topics: [lockTopic(resource, id)],
-    invalidate: () => void ctx.queryClient.invalidateQueries({
-      queryKey: lockKey(resource, { id })
-    }),
-    holdWhileUndoable: false
-  });
+	return subscribeLive(ctx, {
+		caller: "subscribeLiveLock",
+		topics: [lockTopic(resource, id)],
+		invalidate: () => void ctx.queryClient.invalidateQueries({ queryKey: lockKey(resource, { id }) }),
+		holdWhileUndoable: false
+	});
 }
+/** Refetches the resource's lock list when any lock is taken or released. */
 function subscribeLiveLocks(ctx, resource) {
-  return subscribeLive(ctx, {
-    caller: "subscribeLiveLocks",
-    topics: [lockResourceTopic(resource)],
-    invalidate: () => void ctx.queryClient.invalidateQueries({ queryKey: locksKey(resource) }),
-    holdWhileUndoable: false
-  });
+	return subscribeLive(ctx, {
+		caller: "subscribeLiveLocks",
+		topics: [lockResourceTopic(resource)],
+		invalidate: () => void ctx.queryClient.invalidateQueries({ queryKey: locksKey(resource) }),
+		holdWhileUndoable: false
+	});
 }
-export {
-  subscribeLiveLock,
-  subscribeLiveLocks,
-  subscribeLiveRecord,
-  subscribeLiveRecords,
-  subscribeLiveResource
-};
+export { subscribeLiveLock, subscribeLiveLocks, subscribeLiveRecord, subscribeLiveRecords, subscribeLiveResource };

package/dist/realtime/lock-options.js

@@ -1,22 +1,22 @@
 import { lockKey, locksKey } from "../data/keys.js";
 import { assertRealtimeDataProvider } from "./realtime-data-provider.js";
+// src/realtime/lock-options.ts
+/** One record's lock, cached under `lockKey`. Resolves to `null` when unlocked. */
 function getLockOptions(ctx, resource, params) {
-  const { dataProvider } = ctx;
-  assertRealtimeDataProvider(dataProvider, "getLockOptions");
-  return {
-    queryKey: lockKey(resource, params),
-    queryFn: () => dataProvider.getLock(resource, params)
-  };
+	const { dataProvider } = ctx;
+	assertRealtimeDataProvider(dataProvider, "getLockOptions");
+	return {
+		queryKey: lockKey(resource, params),
+		queryFn: () => dataProvider.getLock(resource, params)
+	};
 }
+/** Every lock held on a resource, cached under `locksKey`. */
 function getLocksOptions(ctx, resource) {
-  const { dataProvider } = ctx;
-  assertRealtimeDataProvider(dataProvider, "getLocksOptions");
-  return {
-    queryKey: locksKey(resource),
-    queryFn: () => dataProvider.getLocks(resource)
-  };
+	const { dataProvider } = ctx;
+	assertRealtimeDataProvider(dataProvider, "getLocksOptions");
+	return {
+		queryKey: locksKey(resource),
+		queryFn: () => dataProvider.getLocks(resource)
+	};
 }
-export {
-  getLockOptions,
-  getLocksOptions
-};
+export { getLockOptions, getLocksOptions };

package/dist/realtime/lock-session.js

@@ -1,82 +1,95 @@
 import { createMicroStore } from "../store/micro-store.js";
-const toError = (error) => error instanceof Error ? error : new Error(String(error));
-function createLockSession({
-  dataProvider,
-  resource,
-  id,
-  getIdentity,
-  meta,
-  onError
-}) {
-  const store = createMicroStore({
-    lock: null,
-    isLocking: false,
-    error: null
-  });
-  const metaParam = meta ? { meta } : {};
-  let held = null;
-  let running = false;
-  let epoch = 0;
-  let queue = Promise.resolve();
-  const enqueue = (step) => {
-    queue = queue.then(step).catch(() => {
-    });
-    return queue;
-  };
-  const acquire = async (myEpoch) => {
-    const isCurrent = () => epoch === myEpoch;
-    try {
-      const identity = await getIdentity();
-      const lock = await dataProvider.lock(resource, {
-        id,
-        identity,
-        ...metaParam
-      });
-      held = { identity };
-      if (isCurrent()) store.setState({ lock, isLocking: false });
-    } catch (cause) {
-      if (!isCurrent()) return;
-      const error = toError(cause);
-      store.setState({ isLocking: false, error });
-      onError?.(error);
-    }
-  };
-  const release = async () => {
-    if (!held) return;
-    const { identity } = held;
-    held = null;
-    try {
-      await dataProvider.unlock(resource, { id, identity, ...metaParam });
-    } catch (cause) {
-      onError?.(toError(cause));
-    }
-  };
-  return {
-    store,
-    start() {
-      if (running) return queue;
-      running = true;
-      const myEpoch = ++epoch;
-      store.setState({ isLocking: true, error: null });
-      return enqueue(() => acquire(myEpoch));
-    },
-    stop() {
-      if (!running) return queue;
-      running = false;
-      epoch++;
-      store.setState({ lock: null, isLocking: false, error: null });
-      return enqueue(release);
-    }
-  };
+// src/realtime/lock-session.ts
+var toError = (error) => error instanceof Error ? error : new Error(String(error));
+/**
+* Takes a record's lock on `start()` and gives it back on `stop()`. Steps run
+* one after another, so a `stop()` that arrives while `lock` is in flight
+* releases the lock once it lands, and `start()`, `stop()`, `start()` in one
+* tick ends holding it. Locks carry no expiry: a crashed tab leaves its lock
+* until the lock provider drops it.
+*/
+function createLockSession({ dataProvider, resource, id, getIdentity, meta, onError }) {
+	const store = createMicroStore({
+		lock: null,
+		isLocking: false,
+		error: null
+	});
+	const metaParam = meta ? { meta } : {};
+	let held = null;
+	let running = false;
+	let epoch = 0;
+	let queue = Promise.resolve();
+	const enqueue = (step) => {
+		queue = queue.then(step).catch(() => {});
+		return queue;
+	};
+	const acquire = async (myEpoch) => {
+		const isCurrent = () => epoch === myEpoch;
+		try {
+			const identity = await getIdentity();
+			const lock = await dataProvider.lock(resource, {
+				id,
+				identity,
+				...metaParam
+			});
+			held = { identity };
+			if (isCurrent()) store.setState({
+				lock,
+				isLocking: false
+			});
+		} catch (cause) {
+			if (!isCurrent()) return;
+			const error = toError(cause);
+			store.setState({
+				isLocking: false,
+				error
+			});
+			onError?.(error);
+		}
+	};
+	const release = async () => {
+		if (!held) return;
+		const { identity } = held;
+		held = null;
+		try {
+			await dataProvider.unlock(resource, {
+				id,
+				identity,
+				...metaParam
+			});
+		} catch (cause) {
+			onError?.(toError(cause));
+		}
+	};
+	return {
+		store,
+		start() {
+			if (running) return queue;
+			running = true;
+			const myEpoch = ++epoch;
+			store.setState({
+				isLocking: true,
+				error: null
+			});
+			return enqueue(() => acquire(myEpoch));
+		},
+		stop() {
+			if (!running) return queue;
+			running = false;
+			epoch++;
+			store.setState({
+				lock: null,
+				isLocking: false,
+				error: null
+			});
+			return enqueue(release);
+		}
+	};
 }
+/** The explicit identity wins; otherwise the auth provider's. */
 async function resolveLockIdentity(authProvider, explicit) {
-  if (explicit !== void 0) return explicit;
-  if (authProvider?.getIdentity) return (await authProvider.getIdentity()).id;
-  throw new Error(
-    "no identity available. Pass identity explicitly or configure an authProvider."
-  );
+	if (explicit !== void 0) return explicit;
+	if (authProvider?.getIdentity) return (await authProvider.getIdentity()).id;
+	throw new Error("no identity available. Pass identity explicitly or configure an authProvider.");
 }
-export {
-  createLockSession,
-  resolveLockIdentity
-};
+export { createLockSession, resolveLockIdentity };

package/dist/realtime/memory-transport.js

@@ -1,68 +1,27 @@
-const addListener = (listeners, listener) => {
-  listeners.add(listener);
-  return () => {
-    listeners.delete(listener);
-  };
-};
-function memoryTransport({
-  delayMs,
-  onError
-} = {}) {
-  const subscribers = /* @__PURE__ */ new Map();
-  const publishedEvents = [];
-  const reconnectListeners = /* @__PURE__ */ new Set();
-  const statusListeners = /* @__PURE__ */ new Set();
-  const errorListeners = /* @__PURE__ */ new Set();
-  let status = "connected";
-  const report = (error) => {
-    for (const handler of [...onError ? [onError] : [], ...errorListeners]) {
-      try {
-        handler(error);
-      } catch {
-      }
-    }
-  };
-  return {
-    publishedEvents,
-    subscribe(topic, callback) {
-      const subscription = {
-        callback
-      };
-      const set = subscribers.get(topic) ?? /* @__PURE__ */ new Set();
-      set.add(subscription);
-      subscribers.set(topic, set);
-      return () => {
-        set.delete(subscription);
-      };
-    },
-    async publish(topic, event) {
-      const full = { topic, ...event };
-      publishedEvents.push(full);
-      if (delayMs) await new Promise((resolve) => setTimeout(resolve, delayMs));
-      const live = subscribers.get(topic);
-      for (const subscription of [...live ?? []]) {
-        if (!live?.has(subscription)) continue;
-        const { callback } = subscription;
-        try {
-          callback(full);
-        } catch (cause) {
-          report({ kind: "handler_threw", topic, cause, retrying: false });
-        }
-      }
-    },
-    onReconnect: (callback) => addListener(reconnectListeners, callback),
-    onStatusChange: (callback) => addListener(statusListeners, callback),
-    onError: (callback) => addListener(errorListeners, callback),
-    getStatus: () => status,
-    simulateReconnect() {
-      for (const listener of [...reconnectListeners]) listener();
-    },
-    setStatus(next) {
-      status = next;
-      for (const listener of [...statusListeners]) listener(next);
-    }
-  };
+import { createTopicHub } from "./topic-hub.js";
+// src/realtime/memory-transport.ts
+/** Routes events by topic inside one process, with no server or client library. */
+function memoryTransport({ delayMs, onError } = {}) {
+	const hub = createTopicHub({ onError });
+	const publishedEvents = [];
+	return {
+		publishedEvents,
+		subscribe: hub.subscribe,
+		async publish(topic, event) {
+			const full = {
+				topic,
+				...event
+			};
+			publishedEvents.push(full);
+			if (delayMs) await new Promise((resolve) => setTimeout(resolve, delayMs));
+			hub.dispatch(full);
+		},
+		onReconnect: hub.onReconnect,
+		onStatusChange: hub.onStatusChange,
+		onError: hub.onError,
+		getStatus: hub.getStatus,
+		simulateReconnect: hub.reconnected,
+		setStatus: hub.setStatus
+	};
 }
-export {
-  memoryTransport
-};
+export { memoryTransport };