use-everywhere 1.0.0 → 1.0.2

package/dist/shared-worker.cjs

@@ -1,33 +1,15 @@
 'use client';
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/shared-worker.ts
-var shared_worker_exports = {};
-__export(shared_worker_exports, {
-  relay: () => import_shared_worker.relay,
-  startRelay: () => import_shared_worker.startRelay
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _use_everywhere_core_shared_worker = require("@use-everywhere/core/shared-worker");
+Object.defineProperty(exports, "relay", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core_shared_worker.relay;
+	}
 });
-module.exports = __toCommonJS(shared_worker_exports);
-var import_shared_worker = require("@use-everywhere/core/shared-worker");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  relay,
-  startRelay
+Object.defineProperty(exports, "startRelay", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core_shared_worker.startRelay;
+	}
 });

package/dist/shared-worker.d.cts

@@ -1,2 +1,3 @@
-export { Relay, RelayPort, RelayScope, relay, startRelay } from '@use-everywhere/core/shared-worker';
-import '@use-everywhere/core/testing';
+
+import { Relay, RelayPort, RelayScope, relay, startRelay } from "@use-everywhere/core/shared-worker";
+export { type Relay, type RelayPort, type RelayScope, relay, startRelay };

package/dist/shared-worker.d.ts

@@ -1,2 +1,3 @@
-export { Relay, RelayPort, RelayScope, relay, startRelay } from '@use-everywhere/core/shared-worker';
-import '@use-everywhere/core/testing';
+
+import { Relay, RelayPort, RelayScope, relay, startRelay } from "@use-everywhere/core/shared-worker";
+export { type Relay, type RelayPort, type RelayScope, relay, startRelay };

package/dist/shared-worker.js

@@ -1,8 +1,3 @@
 'use client';
-
-// src/shared-worker.ts
-import { startRelay, relay } from "@use-everywhere/core/shared-worker";
-export {
-  relay,
-  startRelay
-};
+import { relay, startRelay } from "@use-everywhere/core/shared-worker";
+export { relay, startRelay };

package/dist/testing.cjs

@@ -1,33 +1,15 @@
 'use client';
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/testing.ts
-var testing_exports = {};
-__export(testing_exports, {
-  MemoryHub: () => import_testing.MemoryHub,
-  MemoryTransport: () => import_testing.MemoryTransport
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _use_everywhere_core_testing = require("@use-everywhere/core/testing");
+Object.defineProperty(exports, "MemoryHub", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core_testing.MemoryHub;
+	}
 });
-module.exports = __toCommonJS(testing_exports);
-var import_testing = require("@use-everywhere/core/testing");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  MemoryHub,
-  MemoryTransport
+Object.defineProperty(exports, "MemoryTransport", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core_testing.MemoryTransport;
+	}
 });

package/dist/testing.d.cts

@@ -1 +1,3 @@
-export { MemoryHub, MemoryTransport } from '@use-everywhere/core/testing';
+
+import { MemoryHub, MemoryTransport } from "@use-everywhere/core/testing";
+export { MemoryHub, MemoryTransport };

package/dist/testing.d.ts

@@ -1 +1,3 @@
-export { MemoryHub, MemoryTransport } from '@use-everywhere/core/testing';
+
+import { MemoryHub, MemoryTransport } from "@use-everywhere/core/testing";
+export { MemoryHub, MemoryTransport };

package/dist/testing.js

@@ -1,8 +1,3 @@
 'use client';
-
-// src/testing.ts
 import { MemoryHub, MemoryTransport } from "@use-everywhere/core/testing";
-export {
-  MemoryHub,
-  MemoryTransport
-};
+export { MemoryHub, MemoryTransport };

package/dist/use-peers-DtpHGzXE.js

@@ -0,0 +1,315 @@
+'use client';
+import { useCallback, useEffect, useSyncExternalStore } from "react";
+import { DEFAULT_NAME as DEFAULT_NAME$1, NoopTransport, createChannel, createLeader, createPresence, createSharedReducer, createSharedStore } from "@use-everywhere/core";
+//#region src/dev.ts
+let inDev = false;
+try {
+	inDev = process.env.NODE_ENV !== "production";
+} catch {}
+const warned = /* @__PURE__ */ new Set();
+const DOCS = "https://rxova.org/packages/use-everywhere/errors";
+/**
+* Stamp a diagnostic with its code and the page that explains it. Core's twin
+* of this, for the same reason the twin of `devWarn` exists — see above.
+*
+* Codes are permanent, and a retired one is never reused: an old build in
+* somebody's browser is still emitting it. Core owns UE1xxx, this package
+* UE2xxx.
+*/
+function diagnostic(code, message) {
+	return `[use-everywhere] ${code}: ${message}\n  → ${DOCS}/#${code.toLowerCase()}`;
+}
+/** Warn once per distinct message, development only. */
+function devWarn(code, message) {
+	if (!inDev) return;
+	const line = diagnostic(code, message);
+	if (warned.has(line)) return;
+	warned.add(line);
+	console.warn(line);
+}
+/** The initial each key was first registered with. Populated only in development — dynamic keys would otherwise grow it without bound. */
+const seenInitials = /* @__PURE__ */ new Map();
+/**
+* Catch two callers registering one key with different defaults. The first
+* registration wins and the second is silently discarded, which is the kind of
+* disagreement that surfaces much later as "why is this value not what I set".
+*/
+function warnOnInitialMismatch(storeName, key, initial) {
+	if (!inDev) return;
+	const id = `${storeName} ${key}`;
+	if (!seenInitials.has(id)) {
+		seenInitials.set(id, initial);
+		return;
+	}
+	const first = seenInitials.get(id);
+	const comparable = (v) => v === null || typeof v !== "object";
+	if (comparable(first) && comparable(initial) && !Object.is(first, initial)) devWarn("UE2001", `useSharedState('${key}') was called with different initial values (${String(first)} and ${String(initial)}). The first registration wins, so the second is ignored. Define the default once — createStoreHooks, or a shared constant.`);
+}
+const EMPTY = Object.freeze({});
+const NO_PEERS$1 = Object.freeze([]);
+const noop = () => {};
+const unsubscribe = () => noop;
+/**
+* One frozen object serving as store, presence and leader. Their surfaces do
+* not collide, and a server render never distinguishes two inert engines by
+* identity — so this is a single shared constant rather than three allocations
+* in every bundle that imports a hook.
+*/
+const INERT = Object.freeze({
+	clientId: "",
+	hydrated: Promise.resolve(),
+	state: EMPTY,
+	getVersions: () => EMPTY,
+	set: noop,
+	subscribeKey: unsubscribe,
+	registerKey: noop,
+	getSnapshot: () => EMPTY,
+	getPeers: () => NO_PEERS$1,
+	setMetadata: noop,
+	resign: noop,
+	setEligible: noop,
+	subscribe: unsubscribe,
+	close: noop
+});
+const createServerStore = () => INERT;
+const createServerPresence = () => INERT;
+/**
+* Leadership needs its own snapshot shape, so it wraps the shared constant.
+* `waitForLeadership` never settles on a server: there is no election to win,
+* and resolving would run leader-only work during a render that is about to be
+* thrown away. A pending promise is the honest answer.
+*/
+const NO_LEADER = Object.freeze({
+	leaderId: null,
+	isLeader: false
+});
+const NEVER = () => new Promise(() => {});
+const createServerLeader = () => ({
+	...INERT,
+	strategy: "heartbeat",
+	getSnapshot: () => NO_LEADER,
+	waitForLeadership: NEVER
+});
+/**
+* A reducer carries its initial value, so it allocates too. `dispatch` is a
+* no-op: a server render has no peers to order anything with, and an action
+* applied here would show a value the browser is about to disagree with.
+*/
+const createServerReducer = (initial) => ({
+	...INERT,
+	getSnapshot: () => initial,
+	dispatch: noop,
+	pendingCount: () => 0
+});
+/** Channels carry their name, so this is the one double that allocates. */
+const createServerChannel = (name) => ({
+	...INERT,
+	name,
+	post: noop,
+	on: unsubscribe
+});
+//#endregion
+//#region src/registry.ts
+const stores = /* @__PURE__ */ new Map();
+const presences = /* @__PURE__ */ new Map();
+const channels = /* @__PURE__ */ new Map();
+const leaders = /* @__PURE__ */ new Map();
+const storeConfig = /* @__PURE__ */ new Map();
+/**
+* Checked per call, not captured once: a module evaluated during SSR and a
+* module evaluated in the browser are different module instances, so there is
+* no cache to invalidate — but reading it lazily keeps the bundler from
+* folding the branch away in a build that serves both.
+*/
+const isServer = () => typeof window === "undefined";
+/** Per-scope store creation: what leaves this tab and what is let back in. */
+const scopeOptions = {
+	everywhere: {},
+	tabs: { accept: (meta) => meta.kind !== "worker" },
+	tab: { transport: () => new NoopTransport() }
+};
+/** Imperative access to the store behind useSharedState (patch logs, non-React code). */
+function getSharedStore(name = DEFAULT_NAME$1, scope = "everywhere") {
+	return getStore(name, scope);
+}
+/**
+* Options to build a store with when it is first needed. Registered by
+* createStoreHooks at module scope and consumed by getStore on creation — which is
+* what lets persistence be declared in one place without constructing anything
+* on import.
+*/
+/**
+* A configuration's shape, ignoring the adapter's identity. Hot Module
+* Replacement re-evaluates the defining module and builds a *new* adapter
+* object each time, so identity comparison would call every hot edit a
+* conflict; what actually matters is whether the store would be built
+* differently.
+*/
+function configSignature(options) {
+	const persist = options?.persist;
+	if (!persist) return "none";
+	return `persist:${persist.keys?.join(",") ?? "*"}:${persist.debounceMs ?? "default"}:v${persist.version ?? 0}`;
+}
+function configureStore(name, scope, options) {
+	const key = `${scope} ${name}`;
+	if (stores.has(key)) {
+		if (configSignature(storeConfig.get(key)) === configSignature(options)) return;
+		if (process.env.NODE_ENV !== "production") devWarn("UE2002", `createStoreHooks('${name}') ran after that store was already created, with different options. The live store keeps the configuration it was built with. Move createStoreHooks to module scope, before any component reads the store.`);
+		return;
+	}
+	storeConfig.set(key, options);
+}
+function getStore(name, scope = "everywhere") {
+	const key = `${scope} ${name}`;
+	let store = stores.get(key);
+	if (!store) {
+		store = isServer() ? createServerStore() : createSharedStore(name, {}, {
+			...scopeOptions[scope],
+			...storeConfig.get(key)
+		});
+		stores.set(key, store);
+	}
+	return store;
+}
+/**
+* One Presence per name per tab.
+*
+* `includeSelf` is part of the key rather than the options, because it changes
+* what the roster *is*: two components on one name disagreeing about it would
+* otherwise silently get whichever answer was built first.
+*/
+function getPresence(name, includeSelf = false) {
+	const key = includeSelf ? `self ${name}` : name;
+	let presence = presences.get(key);
+	if (!presence) {
+		presence = isServer() ? createServerPresence() : createPresence(name, { includeSelf });
+		presences.set(key, presence);
+	}
+	return presence;
+}
+/**
+* One Leader per name per tab. Eligibility is deliberately *not* part of the
+* key: two Leaders on one name would share a bus and a clientId, and since a
+* post never loops back locally, neither would ever see the other's claims.
+* Timing options are first-wins, like every other engine here.
+*/
+function getLeader(name, options) {
+	let leader = leaders.get(name);
+	if (!leader) {
+		leader = isServer() ? createServerLeader() : createLeader(name, options);
+		leaders.set(name, leader);
+		if (options) leaderOptions.set(name, options);
+	} else if (options) warnOnLeaderOptionConflict(name, options);
+	return leader;
+}
+/** What the first caller elected with, so a later caller asking for different timings can be told it was ignored. */
+const leaderOptions = /* @__PURE__ */ new Map();
+function warnOnLeaderOptionConflict(name, options) {
+	const first = leaderOptions.get(name);
+	for (const key of ["heartbeatMs", "leaseMs"]) {
+		const requested = options[key];
+		if (requested !== void 0 && requested !== first?.[key]) {
+			if (process.env.NODE_ENV !== "production") devWarn("UE2003", `leader "${name}": ${key} ignored — the first useLeader/getLeader call fixes the election timings for this tab.`);
+		}
+	}
+}
+/**
+* Options to build a channel with when it is first needed. Registered by
+* defineChannel at module scope and consumed by getChannel on creation — the
+* same deferral createStoreHooks uses, so declaring a schema constructs nothing on
+* import.
+*/
+const channelConfig = /* @__PURE__ */ new Map();
+function configureChannel(name, options) {
+	if (channels.has(name)) {
+		const before = Object.keys(channelConfig.get(name)?.schema ?? {}).sort();
+		const after = Object.keys(options.schema ?? {}).sort();
+		if (before.join() === after.join()) return;
+		if (process.env.NODE_ENV !== "production") devWarn("UE2004", `defineChannel('${name}') ran after that channel was already created, with different options. The live channel keeps the configuration it was built with. Move defineChannel to module scope, before any component sends or receives on it.`);
+		return;
+	}
+	channelConfig.set(name, options);
+}
+const reducers = /* @__PURE__ */ new Map();
+/**
+* One reducer per name+key per tab, like every other engine here.
+*
+* The reducer is handed this tab's existing `Leader` rather than electing its
+* own: the leader is the sequencer, and a page that already has a seat for this
+* bus must not run a second election to get another one.
+*
+* The first caller's reducer function wins. A hook re-renders with a new
+* function identity every time, and swapping the fold under a history that has
+* already been applied would give this tab a different answer from its peers —
+* which is the one thing an ordered reducer exists to prevent.
+*/
+function getReducer(name, key, reducer, initial) {
+	const id = `${name} ${key}`;
+	let existing = reducers.get(id);
+	if (!existing) {
+		existing = isServer() ? createServerReducer(initial) : createSharedReducer(name, reducer, initial, {
+			key,
+			leader: getLeader(name)
+		});
+		reducers.set(id, existing);
+	}
+	return existing;
+}
+function getChannel(name) {
+	let channel = channels.get(name);
+	if (!channel) {
+		channel = isServer() ? createServerChannel(name) : createChannel(name, channelConfig.get(name));
+		channels.set(name, channel);
+	}
+	return channel;
+}
+//#endregion
+//#region src/use-peers.ts
+const NO_PEERS = Object.freeze([]);
+/**
+* The tabs/windows/workers currently alive on this origin.
+*
+* Each peer carries whatever it published about itself as `metadata` — see
+* {@link usePresenceMetadata} for publishing this client's.
+*/
+function usePeers(options) {
+	const presence = getPresence(options?.name ?? DEFAULT_NAME$1, options?.includeSelf ?? false);
+	return useSyncExternalStore(useCallback((onChange) => presence.subscribe(onChange), [presence]), () => presence.getPeers(), () => NO_PEERS);
+}
+/**
+* This client's own id on the presence bus (matches patch origin ids).
+*
+* Read through useSyncExternalStore rather than returned straight from render,
+* because the id is minted per environment: a server would render one value and
+* the browser a different one, and any component that puts it in the DOM would
+* mismatch on hydration. The server snapshot is a constant empty string, which
+* React also uses for the client's hydrating render, so markup matches; the
+* real id arrives in the commit straight after. Treat `''` as "not known yet".
+*/
+function useClientId(options) {
+	const presence = getPresence(options?.name ?? DEFAULT_NAME$1);
+	return useSyncExternalStore(useCallback(() => () => {}, [presence]), () => presence.clientId, () => "");
+}
+/**
+* Publish what this client wants peers to know about it — a display name, a tab
+* title, a cursor.
+*
+* Safe to call with a fresh object every render: the value is compared by
+* contents, so an unchanged one announces nothing and re-renders nobody.
+*
+* ```tsx
+* usePresenceMetadata({ name: user.name, editing: currentDocId });
+* ```
+*
+* Published in an effect rather than during render, because announcing is a
+* side effect on every other tab — and a render that React throws away must not
+* be one other tabs already saw.
+*/
+function usePresenceMetadata(metadata, options) {
+	const presence = getPresence(options?.name ?? DEFAULT_NAME$1, options?.includeSelf ?? false);
+	useEffect(() => {
+		presence.setMetadata(metadata);
+	}, [presence, metadata]);
+}
+//#endregion
+export { configureChannel as a, getLeader as c, getStore as d, warnOnInitialMismatch as f, DEFAULT_NAME$1 as i, getReducer as l, usePeers as n, configureStore as o, usePresenceMetadata as r, getChannel as s, useClientId as t, getSharedStore as u };