@nkzw/fate-devtools 2.0.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nkzw/fate-devtools",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Devtools for fate, with a Vite DevTools panel.",
   "homepage": "https://github.com/nkzw-tech/fate",
   "license": "MIT",
@@ -31,12 +31,12 @@
     }
   },
   "devDependencies": {
-    "@nkzw/fate": "2.0.0",
+    "@nkzw/fate": "2.1.0",
     "@types/react": "19.3.0",
     "@types/react-dom": "19.3.0",
     "react": "19.3.1",
     "react-dom": "19.3.1",
-    "react-fate": "2.0.0",
+    "react-fate": "2.1.0",
     "vite": "npm:@voidzero-dev/vite-plus-core@1.6.0",
     "vite-plus": "1.6.0"
   },

package/lib/src-CBLiWt9-.mjs

@@ -1,556 +0,0 @@
-// src/protocol.ts
-/**
-* Messages exchanged between an app running fate and the devtools panel.
-*
-* Both sides talk over a `BroadcastChannel`, so the panel works inside the
-* Vite DevTools dock (served from the dev server's origin) and as a standalone
-* tab on the same origin.
-*/
-const channelName = "fate-devtools";
-/** The app page exposes its page id here so an embedded panel can pick its own clients. */
-const pageIdGlobal = "__FATE_DEVTOOLS_PAGE_ID__";
-const isPanelMessage = (value) => typeof value === "object" && value !== null && value.source === "fate-devtools:panel";
-const listKeySeparator = " __fate__ ";
-const decodeListKeyPart = (part) => {
-	try {
-		return decodeURIComponent(part);
-	} catch {
-		return part;
-	}
-};
-/**
-* Splits a fate list key (`owner __fate__ field __fate__ hash`) into its parts.
-* Root lists are owned by `__root__`.
-*/
-const parseListKey = (key) => {
-	const parts = key.split(listKeySeparator);
-	return parts.length >= 3 ? {
-		field: decodeListKeyPart(parts[1]),
-		hash: decodeListKeyPart(parts[2]),
-		owner: decodeListKeyPart(parts[0])
-	} : {
-		field: key,
-		hash: "default",
-		owner: ""
-	};
-};
-// src/serialize.ts
-const maxDepth = 12;
-const maxArrayLength = 200;
-const maxStringLength = 2e3;
-/**
-* Converts arbitrary values into plain JSON that can cross a
-* `BroadcastChannel`. Cycles, functions, class instances, and very large
-* values are summarized instead of throwing.
-*/
-function toJSONValue(value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
-	switch (typeof value) {
-		case "string": return value.length > maxStringLength ? `${value.slice(0, maxStringLength)}… (${value.length} chars)` : value;
-		case "number": return Number.isFinite(value) ? value : String(value);
-		case "boolean": return value;
-		case "bigint": return `${value}n`;
-		case "undefined": return null;
-		case "symbol": return value.toString();
-		case "function": return `ƒ ${value.name || "anonymous"}()`;
-	}
-	if (value === null) return null;
-	const object = value;
-	const tag = Object.prototype.toString.call(object);
-	if (tag === "[object Date]") {
-		const date = object;
-		return Number.isNaN(date.getTime()) ? "Invalid Date" : date.toISOString();
-	}
-	if (tag === "[object Error]") {
-		const error = object;
-		return {
-			message: error.message,
-			name: error.name
-		};
-	}
-	if (seen.has(object)) return "[Circular]";
-	if (depth >= maxDepth) return Array.isArray(object) ? `[Array(${object.length})]` : "[Object]";
-	const ref = getNodeRef(object);
-	if (ref !== void 0) return { $ref: ref };
-	seen.add(object);
-	try {
-		if (tag === "[object Map]") return Object.fromEntries([...object].slice(0, maxArrayLength).map(([key, entry]) => [String(key), toJSONValue(entry, depth + 1, seen)]));
-		if (tag === "[object Set]" || Array.isArray(object)) {
-			const items = [...object];
-			const result = items.slice(0, maxArrayLength).map((entry) => toJSONValue(entry, depth + 1, seen));
-			return items.length > maxArrayLength ? [...result, `… ${items.length - maxArrayLength} more`] : result;
-		}
-		const result = {};
-		for (const key of Object.keys(object)) {
-			let entry;
-			try {
-				entry = object[key];
-			} catch (error) {
-				entry = error;
-			}
-			result[key] = toJSONValue(entry, depth + 1, seen);
-		}
-		return result;
-	} finally {
-		seen.delete(object);
-	}
-}
-/**
-* fate stores relations as frozen objects keyed by a private symbol. The
-* devtools turn them into `{ $ref: 'Type:id' }` so the panel can link to them.
-*/
-const getNodeRef = (object) => {
-	for (const symbol of Object.getOwnPropertySymbols(object)) if (symbol.description === "__fate__node-ref") {
-		const id = object[symbol];
-		return typeof id === "string" ? id : void 0;
-	}
-};
-const errorMessage = (error) => error instanceof Error ? error.message : typeof error === "string" ? error : JSON.stringify(toJSONValue(error));
-// src/index.ts
-const operationKinds = /* @__PURE__ */ new Set([
-	"fetchById",
-	"fetchList",
-	"fetchQuery",
-	"mutate",
-	"mutateDurably",
-	"subscribeById",
-	"subscribeConnection"
-]);
-const watcherTimeout = 5e3;
-const snapshotDelay = 120;
-const maxRecords = 5e3;
-const pageId = Math.random().toString(36).slice(2, 10);
-let nextClientId = 0;
-const parseEntityId = (id) => {
-	const index = id.indexOf(":");
-	return index < 0 ? {
-		rawId: id,
-		type: ""
-	} : {
-		rawId: id.slice(index + 1),
-		type: id.slice(0, index)
-	};
-};
-const nestedKeys = (value, prefix = "") => {
-	if (!value || typeof value !== "object") return [];
-	return Object.entries(value).flatMap(([key, entry]) => typeof entry === "function" ? [`${prefix}${key}`] : nestedKeys(entry, `${prefix}${key}.`));
-};
-const toPaths = (select) => {
-	if (!select || typeof select !== "object" || !(Symbol.iterator in select)) return [];
-	return [...select].map(String).sort();
-};
-/** Keeps a bounded log, dropping the oldest entries first. */
-var RingLog = class {
-	constructor(size) {
-		this.size = size;
-		this.entries = [];
-	}
-	push(entry) {
-		this.entries.push(entry);
-		if (this.entries.length > this.size) this.entries.splice(0, this.entries.length - this.size);
-	}
-	clear() {
-		this.entries = [];
-	}
-	values() {
-		return this.entries;
-	}
-};
-const connections = /* @__PURE__ */ new WeakMap();
-/**
-* Connects a fate client to the devtools panel. Returns a function that
-* disconnects it again and restores the client's original transport.
-*
-* Connecting the same client more than once is safe; the client stays
-* connected until every returned disposer has been called.
-*
-* The devtools are intended for development. Guard the call with
-* `import.meta.env.DEV` (or your bundler's equivalent) to keep them out of
-* production bundles.
-*/
-function connectFateDevtools(client, options = {}) {
-	if (typeof BroadcastChannel === "undefined") return () => {};
-	const existing = connections.get(client);
-	if (existing) {
-		existing.refCount++;
-		return once(() => release(client, existing));
-	}
-	const connection = {
-		dispose: attach(client, options),
-		refCount: 1
-	};
-	connections.set(client, connection);
-	return once(() => release(client, connection));
-}
-const once = (fn) => {
-	let called = false;
-	return () => {
-		if (!called) {
-			called = true;
-			fn();
-		}
-	};
-};
-const release = (client, connection) => {
-	connection.refCount--;
-	if (connection.refCount === 0) {
-		connections.delete(client);
-		connection.dispose();
-	}
-};
-function attach(client, options) {
-	const logSize = options.logSize ?? 300;
-	globalThis[pageIdGlobal] = pageId;
-	const summary = {
-		id: `${pageId}:${nextClientId++}`,
-		name: options.name ?? "fate",
-		pageId,
-		url: typeof location === "undefined" ? "" : location.href
-	};
-	const channel = new BroadcastChannel(channelName);
-	const operations = new RingLog(logSize);
-	const changes = new RingLog(logSize);
-	const watchers = /* @__PURE__ */ new Map();
-	let nextOperationId = 0;
-	let nextChangeId = 0;
-	let snapshotTimer;
-	let disposed = false;
-	const post = (message) => {
-		if (!disposed) channel.postMessage(message);
-	};
-	const isWatched = () => {
-		const now = Date.now();
-		for (const [watcher, lastSeen] of watchers) if (now - lastSeen > watcherTimeout) watchers.delete(watcher);
-		return watchers.size > 0;
-	};
-	const sendSnapshot = () => {
-		snapshotTimer = void 0;
-		if (!disposed && isWatched()) post({
-			snapshot: takeSnapshot(),
-			source: "fate-devtools:app",
-			type: "snapshot"
-		});
-	};
-	const scheduleSnapshot = () => {
-		if (snapshotTimer === void 0 && watchers.size > 0) snapshotTimer = setTimeout(sendSnapshot, snapshotDelay);
-	};
-	const originalTransport = client.transport;
-	if (originalTransport) {
-		const wrapped = /* @__PURE__ */ new Map();
-		client.transport = new Proxy(originalTransport, { get(target, property, receiver) {
-			const value = Reflect.get(target, property, receiver);
-			if (typeof value !== "function" || !operationKinds.has(property)) return value;
-			let fn = wrapped.get(property);
-			if (!fn) {
-				fn = instrument(property, value.bind(target));
-				wrapped.set(property, fn);
-			}
-			return fn;
-		} });
-	}
-	function instrument(kind, fn) {
-		return (...args) => {
-			const entry = startOperation(kind, args);
-			operations.push(entry);
-			scheduleSnapshot();
-			const settle = (status, value) => {
-				entry.endedAt = Date.now();
-				entry.status = status;
-				if (status === "error") entry.error = errorMessage(value);
-				else entry.result = toJSONValue(value);
-				scheduleSnapshot();
-			};
-			if (kind === "subscribeById" || kind === "subscribeConnection") {
-				const handlerIndex = kind === "subscribeById" ? 4 : 5;
-				const handlers = args[handlerIndex];
-				if (handlers) {
-					const event = (name) => (...eventArgs) => {
-						entry.events = (entry.events ?? 0) + 1;
-						entry.result = toJSONValue(eventArgs[0]);
-						scheduleSnapshot();
-						return handlers[name]?.(...eventArgs);
-					};
-					args[handlerIndex] = {
-						...handlers,
-						...handlers.onData && { onData: event("onData") },
-						...handlers.onDelete && { onDelete: event("onDelete") },
-						...handlers.onEvent && { onEvent: event("onEvent") },
-						onError: (error) => {
-							entry.error = errorMessage(error);
-							entry.status = "error";
-							scheduleSnapshot();
-							handlers.onError?.(error);
-						}
-					};
-				}
-				try {
-					const unsubscribe = fn(...args);
-					entry.status = "live";
-					return () => {
-						entry.endedAt = Date.now();
-						if (entry.status === "live") entry.status = "closed";
-						scheduleSnapshot();
-						return unsubscribe();
-					};
-				} catch (error) {
-					settle("error", error);
-					throw error;
-				}
-			}
-			try {
-				const result = fn(...args);
-				Promise.resolve(result).then((value) => settle("success", value), (error) => settle("error", error));
-				return result;
-			} catch (error) {
-				settle("error", error);
-				throw error;
-			}
-		};
-	}
-	function startOperation(kind, args) {
-		const base = {
-			id: nextOperationId++,
-			kind,
-			startedAt: Date.now(),
-			status: "pending"
-		};
-		switch (kind) {
-			case "fetchById": return {
-				...base,
-				args: toJSONValue(args[3]),
-				input: toJSONValue({ ids: args[1] }),
-				name: String(args[0]),
-				select: toPaths(args[2])
-			};
-			case "fetchList":
-			case "fetchQuery": return {
-				...base,
-				args: toJSONValue(args[2]),
-				name: String(args[0]),
-				select: toPaths(args[1])
-			};
-			case "mutate": return {
-				...base,
-				args: toJSONValue(args[3]),
-				input: toJSONValue(args[1]),
-				name: String(args[0]),
-				select: toPaths(args[2])
-			};
-			case "mutateDurably": return {
-				...base,
-				args: toJSONValue(args[4]),
-				input: toJSONValue({
-					identity: args[3],
-					input: args[1]
-				}),
-				name: String(args[0]),
-				select: toPaths(args[2])
-			};
-			case "subscribeById": return {
-				...base,
-				args: toJSONValue(args[3]),
-				input: toJSONValue({ id: args[1] }),
-				name: String(args[0]),
-				select: toPaths(args[2])
-			};
-			case "subscribeConnection": return {
-				...base,
-				args: toJSONValue({
-					args: args[2],
-					selectionArgs: args[4]
-				}),
-				input: toJSONValue({ type: args[1] }),
-				name: String(args[0]),
-				select: toPaths(args[3])
-			};
-		}
-	}
-	const store = client.store;
-	const hadOwnOnChange = !!store && Object.hasOwn(store, "onChange");
-	const originalOnChange = store?.onChange;
-	if (store) store.onChange = (change, owner) => {
-		try {
-			changes.push({
-				at: Date.now(),
-				id: nextChangeId++,
-				...change.invalidated && { invalidated: true },
-				key: String(change.key),
-				kind: change.kind,
-				optimistic: !!store.isRecordingOptimistic || !!store.hasOptimisticUpdates,
-				...change.paths && { paths: [...change.paths].map(String) }
-			});
-			scheduleSnapshot();
-		} catch {}
-		return originalOnChange?.call(store, change, owner);
-	};
-	const unsubscribePersistence = client.persistence?.subscribe?.(scheduleSnapshot);
-	function takeSnapshot() {
-		const state = store?.dehydrate?.() ?? {
-			coverage: [],
-			lists: [],
-			records: []
-		};
-		const confirmed = store?.hasOptimisticUpdates ? store.dehydrateConfirmed?.() : void 0;
-		const confirmedRecords = confirmed ? new Map(confirmed.records) : void 0;
-		const confirmedLists = confirmed ? new Map(confirmed.lists) : void 0;
-		const coverage = new Map(state.coverage);
-		const stale = new Map(state.stale ?? []);
-		const records = state.records.slice(0, maxRecords).map(([id, record]) => {
-			const { rawId, type } = parseEntityId(String(id));
-			return {
-				coverage: coverage.get(id) ?? [],
-				id,
-				lists: store?.getListKeysForEntity?.(id) ?? [],
-				optimistic: !!confirmedRecords && confirmedRecords.get(id) !== record,
-				rawId,
-				record: toJSONValue(record),
-				stale: stale.get(id) ?? [],
-				type
-			};
-		});
-		const lists = state.lists.map(([key, list]) => {
-			const { field, owner } = parseListKey(key);
-			return {
-				field,
-				ids: list.ids.map(String),
-				key,
-				optimistic: !!confirmedLists && confirmedLists.get(key) !== list,
-				owner,
-				...list.pagination !== void 0 && { pagination: toJSONValue(list.pagination) },
-				state: toJSONValue(list)
-			};
-		});
-		return {
-			changes: [...changes.values()],
-			...typeof client.hydrationScope === "string" && { hydrationScope: client.hydrationScope },
-			id: summary.id,
-			lists,
-			live: [...client.liveSubscriptions ?? []].map(([key, subscription]) => ({
-				key,
-				subscribers: subscription.count ?? 0
-			})),
-			mutations: nestedKeys(client.mutations).sort(),
-			name: summary.name,
-			operations: operations.values().map((entry) => ({ ...entry })),
-			optimisticUpdates: !!store?.hasOptimisticUpdates,
-			...client.persistence?.getSnapshot && { persistence: toJSONValue(client.persistence.getSnapshot()) },
-			records,
-			requests: getRequests(client),
-			roots: Object.keys(client.roots ?? {}).sort(),
-			takenAt: Date.now(),
-			types: [...client.types?.keys() ?? []].sort()
-		};
-	}
-	function runAction(action) {
-		switch (action.type) {
-			case "gc":
-				client.gc?.();
-				break;
-			case "clear-log":
-				operations.clear();
-				changes.clear();
-				break;
-			case "invalidate-record":
-				store?.invalidateRecord?.(action.id);
-				break;
-			case "invalidate-all":
-				for (const [id] of store?.dehydrate?.().records ?? []) store?.invalidateRecord?.(id);
-				break;
-			case "delete-record": {
-				const { rawId, type } = parseEntityId(action.id);
-				client.deleteRecord?.(type, rawId);
-				break;
-			}
-			case "log-record": {
-				const record = store?.dehydrate?.().records.find(([id]) => id === action.id)?.[1];
-				globalThis.$fate = record;
-				console.log(`fate-devtools: ${action.id} (available as $fate)`, record);
-				break;
-			}
-		}
-		scheduleSnapshot();
-	}
-	const onMessage = (event) => {
-		const message = event.data;
-		if (!isPanelMessage(message)) return;
-		if (message.type === "discover") {
-			post({
-				client: summary,
-				source: "fate-devtools:app",
-				type: "connected"
-			});
-			return;
-		}
-		if (message.clientId !== summary.id) return;
-		switch (message.type) {
-			case "watch":
-				watchers.set(message.panelId, Date.now());
-				scheduleSnapshot();
-				break;
-			case "unwatch":
-				watchers.delete(message.panelId);
-				break;
-			case "action": try {
-				runAction(message.action);
-			} catch (error) {
-				console.error("fate-devtools: Action failed.", error);
-			}
-		}
-	};
-	channel.addEventListener("message", onMessage);
-	post({
-		client: summary,
-		source: "fate-devtools:app",
-		type: "connected"
-	});
-	const onPageHide = () => post({
-		clientId: summary.id,
-		source: "fate-devtools:app",
-		type: "disconnected"
-	});
-	globalThis.addEventListener?.("pagehide", onPageHide);
-	return () => {
-		onPageHide();
-		disposed = true;
-		globalThis.removeEventListener?.("pagehide", onPageHide);
-		if (snapshotTimer !== void 0) clearTimeout(snapshotTimer);
-		unsubscribePersistence?.();
-		channel.removeEventListener("message", onMessage);
-		channel.close();
-		if (originalTransport) client.transport = originalTransport;
-		if (store) {
-			if (hadOwnOnChange) store.onChange = originalOnChange;
-			else delete store.onChange;
-		}
-	};
-}
-function getRequests(client) {
-	const retained = client.operationLifetime?.operations;
-	const entries = /* @__PURE__ */ new Map();
-	const add = (descriptor, mode, status) => {
-		const key = descriptor?.key;
-		if (!key) return;
-		const existing = entries.get(key);
-		const modes = existing?.modes ?? [];
-		entries.set(key, {
-			items: existing?.items ?? (descriptor.items ?? []).map((item) => ({
-				...item.argsPayload !== void 0 && { args: toJSONValue(item.argsPayload) },
-				...item.ids && { ids: item.ids.map(String) },
-				kind: String(item.kind ?? ""),
-				name: String(item.name ?? ""),
-				paths: toPaths(item.plan?.paths),
-				...item.procedure && { procedure: item.procedure },
-				type: String(item.type ?? "")
-			})),
-			key,
-			modes: mode ? [...modes, {
-				mode,
-				status: status ?? "unknown"
-			}] : modes,
-			retainers: retained?.get(key)?.refCount ?? 0
-		});
-	};
-	for (const [, modes] of client.requests ?? []) for (const [mode, handle] of modes) add(handle.descriptor, mode, handle.status);
-	for (const [, operation] of retained ?? []) add(operation.descriptor);
-	return [...entries.values()];
-}
-export { connectFateDevtools as t };