@chelone/core 0.6.0 → 0.9.0

package/dist/realtime/broadcast-channel-transport.js

@@ -1,63 +1,69 @@
 import { createTopicHub } from "./topic-hub.js";
+// src/realtime/broadcast-channel-transport.ts
 function isEnvelope(value) {
-  if (typeof value !== "object" || value === null) return false;
-  if (!("topic" in value) || typeof value.topic !== "string") return false;
-  if (!("event" in value)) return false;
-  const { event } = value;
-  return typeof event === "object" && event !== null && "type" in event && typeof event.type === "string";
+	if (typeof value !== "object" || value === null) return false;
+	if (!("topic" in value) || typeof value.topic !== "string") return false;
+	if (!("event" in value)) return false;
+	const { event } = value;
+	return typeof event === "object" && event !== null && "type" in event && typeof event.type === "string";
 }
-function broadcastChannelTransport({
-  channel,
-  onError
-}) {
-  if (typeof BroadcastChannel === "undefined") {
-    throw new Error(
-      "broadcastChannelTransport needs the global BroadcastChannel, which this environment does not have."
-    );
-  }
-  const hub = createTopicHub({ onError });
-  const broadcast = new BroadcastChannel(channel);
-  let closed = false;
-  const onMessage = (message) => {
-    if (!isEnvelope(message.data)) {
-      hub.report({
-        kind: "parse_failed",
-        cause: message.data,
-        retrying: false
-      });
-      return;
-    }
-    const { topic, event } = message.data;
-    hub.dispatch({ payload: void 0, ...event, topic });
-  };
-  broadcast.addEventListener("message", onMessage);
-  return {
-    subscribe: hub.subscribe,
-    async publish(topic, event) {
-      if (closed) {
-        throw new Error("broadcastChannelTransport is closed");
-      }
-      try {
-        broadcast.postMessage({ topic, event });
-      } catch (cause) {
-        hub.report({ kind: "send_failed", topic, cause, retrying: false });
-        throw cause;
-      }
-      hub.dispatch({ ...event, topic });
-    },
-    onReconnect: hub.onReconnect,
-    onStatusChange: hub.onStatusChange,
-    onError: hub.onError,
-    getStatus: hub.getStatus,
-    close() {
-      if (closed) return;
-      closed = true;
-      broadcast.removeEventListener("message", onMessage);
-      broadcast.close();
-      hub.setStatus("disconnected");
-    }
-  };
+/** Carries realtime events between the tabs of one browser, with no server. */
+function broadcastChannelTransport({ channel, onError }) {
+	if (typeof BroadcastChannel === "undefined") throw new Error("broadcastChannelTransport needs the global BroadcastChannel, which this environment does not have.");
+	const hub = createTopicHub({ onError });
+	const broadcast = new BroadcastChannel(channel);
+	let closed = false;
+	const onMessage = (message) => {
+		if (!isEnvelope(message.data)) {
+			hub.report({
+				kind: "parse_failed",
+				cause: message.data,
+				retrying: false
+			});
+			return;
+		}
+		const { topic, event } = message.data;
+		hub.dispatch({
+			payload: void 0,
+			...event,
+			topic
+		});
+	};
+	broadcast.addEventListener("message", onMessage);
+	return {
+		subscribe: hub.subscribe,
+		async publish(topic, event) {
+			if (closed) throw new Error("broadcastChannelTransport is closed");
+			try {
+				broadcast.postMessage({
+					topic,
+					event
+				});
+			} catch (cause) {
+				hub.report({
+					kind: "send_failed",
+					topic,
+					cause,
+					retrying: false
+				});
+				throw cause;
+			}
+			hub.dispatch({
+				...event,
+				topic
+			});
+		},
+		onReconnect: hub.onReconnect,
+		onStatusChange: hub.onStatusChange,
+		onError: hub.onError,
+		getStatus: hub.getStatus,
+		close() {
+			if (closed) return;
+			closed = true;
+			broadcast.removeEventListener("message", onMessage);
+			broadcast.close();
+			hub.setStatus("disconnected");
+		}
+	};
 }
-export {
-  broadcastChannelTransport
-};
+export { broadcastChannelTransport };

package/dist/realtime/copy-members.js

@@ -1,16 +1,24 @@
+// src/realtime/copy-members.ts
+/**
+* A copy of `source` that keeps what a spread drops: methods on the prototype
+* chain of a class instance, bound to `source` so they still see its state.
+*/
 function copyMembers(source) {
-  const copy = { ...source };
-  let proto = Object.getPrototypeOf(source);
-  while (proto && proto !== Object.prototype) {
-    for (const key of Reflect.ownKeys(proto)) {
-      if (key === "constructor" || Object.hasOwn(copy, key)) continue;
-      const { value } = Object.getOwnPropertyDescriptor(proto, key) ?? {};
-      if (typeof value === "function") copy[key] = value.bind(source);
-    }
-    proto = Object.getPrototypeOf(proto);
-  }
-  return copy;
+	const copy = { ...source };
+	let proto = Object.getPrototypeOf(source);
+	while (proto && proto !== Object.prototype) {
+		for (const key of Reflect.ownKeys(proto)) {
+			if (key === "constructor" || Object.hasOwn(copy, key)) continue;
+			const { value } = Object.getOwnPropertyDescriptor(proto, key) ?? {};
+			if (typeof value === "function") Object.defineProperty(copy, key, {
+				value: value.bind(source),
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+		}
+		proto = Object.getPrototypeOf(proto);
+	}
+	return copy;
 }
-export {
-  copyMembers
-};
+export { copyMembers };

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

@@ -1,51 +1,43 @@
 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();
-  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);
-    }
-  };
+// 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 };