electron-state-sync 1.1.0

package/bunfig.toml

@@ -0,0 +1,7 @@
+[test]
+# Only run tests in the test/ directory, exclude e2e
+coverage = false
+coverageDir = "coverage"
+coverageThreshold = { "global": { "branches": 0, "functions": 0, "lines": 0, "statements": 0 } }
+preload = ["./test/setup.ts"]
+root = "./test"

package/dist/jotai.cjs

@@ -0,0 +1,106 @@
+const require_renderer = require('./renderer-D3YziJ_U.cjs');
+let react = require("react");
+let jotai = require("jotai");
+
+//#region src/renderer/jotai.ts
+const createChannelOptions = (options) => {
+	const globalConfig = require_renderer.getGlobalConfig();
+	return {
+		baseChannel: options.baseChannel ?? globalConfig.baseChannel,
+		name: options.name
+	};
+};
+const syncedAtoms = /* @__PURE__ */ new Map();
+/**
+* Create a synced atom that synchronizes with Electron main process
+*
+* @example
+* ```typescript
+* import { syncStateAtom, useAtom } from 'electron-state-sync/jotai';
+*
+* const countAtom = syncStateAtom(0, { name: 'counter' });
+*
+* function App() {
+*   const [count, setCount] = useAtom(countAtom);
+*   return <div onClick={() => setCount(5)}>{count}</div>;
+* }
+* ```
+*/
+const syncStateAtom = (initialValue, options) => {
+	const globalConfig = require_renderer.getGlobalConfig();
+	const bridge = require_renderer.resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = createChannelOptions(options);
+	const baseAtom = (0, jotai.atom)(initialValue);
+	const wrapper = { atom: baseAtom };
+	const atomKey = `${channelOptions.baseChannel}:${channelOptions.name}`;
+	syncedAtoms.set(atomKey, wrapper);
+	let pendingRemoteValue = initialValue;
+	let hasPendingRemoteValue = false;
+	const applyRemoteValue = (value) => {
+		if (wrapper.setAtom) {
+			wrapper.setAtom(value);
+			return;
+		}
+		pendingRemoteValue = value;
+		hasPendingRemoteValue = true;
+	};
+	baseAtom.onMount = (setAtom) => {
+		wrapper.setAtom = setAtom;
+		if (hasPendingRemoteValue) {
+			setAtom(pendingRemoteValue);
+			hasPendingRemoteValue = false;
+		}
+		return () => {
+			wrapper.setAtom = void 0;
+		};
+	};
+	wrapper.unsubscribe = bridge.subscribe(channelOptions, applyRemoteValue);
+	bridge.get(channelOptions).then(applyRemoteValue);
+	return (0, jotai.atom)((get) => get(baseAtom), (get, set, value) => {
+		const currentValue = get(baseAtom);
+		const nextValue = typeof value === "function" ? value(currentValue) : value;
+		set(baseAtom, nextValue);
+		bridge.set(channelOptions, nextValue);
+	});
+};
+/**
+* Hook to access sync status for a synced atom
+*
+* @example
+* ```typescript
+* import { useSyncStateStatus } from 'electron-state-sync/jotai';
+*
+* function App() {
+*   const { isSynced } = useSyncStateStatus({ name: 'counter' });
+*   return isSynced ? <div>Synced</div> : <div>Loading...</div>;
+* }
+* ```
+*/
+const useSyncStateStatus = (options) => {
+	const [isSynced, setIsSynced] = (0, react.useState)(false);
+	const globalConfig = require_renderer.getGlobalConfig();
+	const bridge = require_renderer.resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = (0, react.useMemo)(() => createChannelOptions(options), [options.baseChannel, options.name]);
+	(0, react.useEffect)(() => {
+		bridge.get(channelOptions).then(() => {
+			setIsSynced(true);
+		});
+	}, [bridge, channelOptions]);
+	return { isSynced };
+};
+/**
+* Cleanup function for synced atoms
+*
+* Call this when unmounting components to prevent memory leaks
+*/
+const cleanupSyncedAtom = (options) => {
+	const channelOptions = createChannelOptions(options);
+	const atomKey = `${channelOptions.baseChannel}:${channelOptions.name}`;
+	syncedAtoms.get(atomKey)?.unsubscribe?.();
+	syncedAtoms.delete(atomKey);
+};
+
+//#endregion
+exports.cleanupSyncedAtom = cleanupSyncedAtom;
+exports.syncStateAtom = syncStateAtom;
+exports.useSyncStateStatus = useSyncStateStatus;

package/dist/jotai.d.cts

@@ -0,0 +1,48 @@
+import { a as SyncStateChannelOptions, t as SyncStateBridge } from "./types-C18dHgLI.cjs";
+import { PrimitiveAtom } from "jotai";
+
+//#region src/renderer/jotai.d.ts
+interface SyncStateJotaiOptions extends SyncStateChannelOptions {
+  bridge?: SyncStateBridge;
+}
+/**
+ * Create a synced atom that synchronizes with Electron main process
+ *
+ * @example
+ * ```typescript
+ * import { syncStateAtom, useAtom } from 'electron-state-sync/jotai';
+ *
+ * const countAtom = syncStateAtom(0, { name: 'counter' });
+ *
+ * function App() {
+ *   const [count, setCount] = useAtom(countAtom);
+ *   return <div onClick={() => setCount(5)}>{count}</div>;
+ * }
+ * ```
+ */
+declare const syncStateAtom: <StateValue>(initialValue: StateValue, options: SyncStateJotaiOptions) => PrimitiveAtom<StateValue>;
+/**
+ * Hook to access sync status for a synced atom
+ *
+ * @example
+ * ```typescript
+ * import { useSyncStateStatus } from 'electron-state-sync/jotai';
+ *
+ * function App() {
+ *   const { isSynced } = useSyncStateStatus({ name: 'counter' });
+ *   return isSynced ? <div>Synced</div> : <div>Loading...</div>;
+ * }
+ * ```
+ */
+declare const useSyncStateStatus: (options: SyncStateJotaiOptions) => {
+  isSynced: boolean;
+};
+/**
+ * Cleanup function for synced atoms
+ *
+ * Call this when unmounting components to prevent memory leaks
+ */
+declare const cleanupSyncedAtom: (options: SyncStateJotaiOptions) => void;
+//#endregion
+export { SyncStateJotaiOptions, cleanupSyncedAtom, syncStateAtom, useSyncStateStatus };
+//# sourceMappingURL=jotai.d.cts.map

package/dist/jotai.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jotai.d.cts","names":[],"sources":["../src/renderer/jotai.ts"],"sourcesContent":[],"mappings":";;;;UAQiB,qBAAA,SAA8B;EAA9B,MAAA,CAAA,EACN,eAD4B;AAsCvC;;;;;;AAoFA;AAuBA;;;;;;;;;cA3Ga,0CACG,qBACL,0BACR,cAAc;;;;;;;;;;;;;;cAiFJ,8BAA+B;;;;;;;;cAuB/B,6BAA8B"}

package/dist/jotai.d.ts

@@ -0,0 +1,48 @@
+import { a as SyncStateChannelOptions, t as SyncStateBridge } from "./types-7wPPX0ty.js";
+import { PrimitiveAtom } from "jotai";
+
+//#region src/renderer/jotai.d.ts
+interface SyncStateJotaiOptions extends SyncStateChannelOptions {
+  bridge?: SyncStateBridge;
+}
+/**
+ * Create a synced atom that synchronizes with Electron main process
+ *
+ * @example
+ * ```typescript
+ * import { syncStateAtom, useAtom } from 'electron-state-sync/jotai';
+ *
+ * const countAtom = syncStateAtom(0, { name: 'counter' });
+ *
+ * function App() {
+ *   const [count, setCount] = useAtom(countAtom);
+ *   return <div onClick={() => setCount(5)}>{count}</div>;
+ * }
+ * ```
+ */
+declare const syncStateAtom: <StateValue>(initialValue: StateValue, options: SyncStateJotaiOptions) => PrimitiveAtom<StateValue>;
+/**
+ * Hook to access sync status for a synced atom
+ *
+ * @example
+ * ```typescript
+ * import { useSyncStateStatus } from 'electron-state-sync/jotai';
+ *
+ * function App() {
+ *   const { isSynced } = useSyncStateStatus({ name: 'counter' });
+ *   return isSynced ? <div>Synced</div> : <div>Loading...</div>;
+ * }
+ * ```
+ */
+declare const useSyncStateStatus: (options: SyncStateJotaiOptions) => {
+  isSynced: boolean;
+};
+/**
+ * Cleanup function for synced atoms
+ *
+ * Call this when unmounting components to prevent memory leaks
+ */
+declare const cleanupSyncedAtom: (options: SyncStateJotaiOptions) => void;
+//#endregion
+export { SyncStateJotaiOptions, cleanupSyncedAtom, syncStateAtom, useSyncStateStatus };
+//# sourceMappingURL=jotai.d.ts.map

package/dist/jotai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jotai.d.ts","names":[],"sources":["../src/renderer/jotai.ts"],"sourcesContent":[],"mappings":";;;;UAQiB,qBAAA,SAA8B;EAA9B,MAAA,CAAA,EACN,eAD4B;AAsCvC;;;;;;AAoFA;AAuBA;;;;;;;;;cA3Ga,0CACG,qBACL,0BACR,cAAc;;;;;;;;;;;;;;cAiFJ,8BAA+B;;;;;;;;cAuB/B,6BAA8B"}

package/dist/jotai.js

@@ -0,0 +1,105 @@
+import { a as resolveSyncStateBridge, t as getGlobalConfig } from "./renderer-C7zF3UQm.js";
+import { useEffect, useMemo, useState } from "react";
+import { atom } from "jotai";
+
+//#region src/renderer/jotai.ts
+const createChannelOptions = (options) => {
+	const globalConfig = getGlobalConfig();
+	return {
+		baseChannel: options.baseChannel ?? globalConfig.baseChannel,
+		name: options.name
+	};
+};
+const syncedAtoms = /* @__PURE__ */ new Map();
+/**
+* Create a synced atom that synchronizes with Electron main process
+*
+* @example
+* ```typescript
+* import { syncStateAtom, useAtom } from 'electron-state-sync/jotai';
+*
+* const countAtom = syncStateAtom(0, { name: 'counter' });
+*
+* function App() {
+*   const [count, setCount] = useAtom(countAtom);
+*   return <div onClick={() => setCount(5)}>{count}</div>;
+* }
+* ```
+*/
+const syncStateAtom = (initialValue, options) => {
+	const globalConfig = getGlobalConfig();
+	const bridge = resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = createChannelOptions(options);
+	const baseAtom = atom(initialValue);
+	const wrapper = { atom: baseAtom };
+	const atomKey = `${channelOptions.baseChannel}:${channelOptions.name}`;
+	syncedAtoms.set(atomKey, wrapper);
+	let pendingRemoteValue = initialValue;
+	let hasPendingRemoteValue = false;
+	const applyRemoteValue = (value) => {
+		if (wrapper.setAtom) {
+			wrapper.setAtom(value);
+			return;
+		}
+		pendingRemoteValue = value;
+		hasPendingRemoteValue = true;
+	};
+	baseAtom.onMount = (setAtom) => {
+		wrapper.setAtom = setAtom;
+		if (hasPendingRemoteValue) {
+			setAtom(pendingRemoteValue);
+			hasPendingRemoteValue = false;
+		}
+		return () => {
+			wrapper.setAtom = void 0;
+		};
+	};
+	wrapper.unsubscribe = bridge.subscribe(channelOptions, applyRemoteValue);
+	bridge.get(channelOptions).then(applyRemoteValue);
+	return atom((get) => get(baseAtom), (get, set, value) => {
+		const currentValue = get(baseAtom);
+		const nextValue = typeof value === "function" ? value(currentValue) : value;
+		set(baseAtom, nextValue);
+		bridge.set(channelOptions, nextValue);
+	});
+};
+/**
+* Hook to access sync status for a synced atom
+*
+* @example
+* ```typescript
+* import { useSyncStateStatus } from 'electron-state-sync/jotai';
+*
+* function App() {
+*   const { isSynced } = useSyncStateStatus({ name: 'counter' });
+*   return isSynced ? <div>Synced</div> : <div>Loading...</div>;
+* }
+* ```
+*/
+const useSyncStateStatus = (options) => {
+	const [isSynced, setIsSynced] = useState(false);
+	const globalConfig = getGlobalConfig();
+	const bridge = resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = useMemo(() => createChannelOptions(options), [options.baseChannel, options.name]);
+	useEffect(() => {
+		bridge.get(channelOptions).then(() => {
+			setIsSynced(true);
+		});
+	}, [bridge, channelOptions]);
+	return { isSynced };
+};
+/**
+* Cleanup function for synced atoms
+*
+* Call this when unmounting components to prevent memory leaks
+*/
+const cleanupSyncedAtom = (options) => {
+	const channelOptions = createChannelOptions(options);
+	const atomKey = `${channelOptions.baseChannel}:${channelOptions.name}`;
+	syncedAtoms.get(atomKey)?.unsubscribe?.();
+	syncedAtoms.delete(atomKey);
+};
+
+//#endregion
+export { cleanupSyncedAtom, syncStateAtom, useSyncStateStatus };
+//# sourceMappingURL=jotai.js.map

package/dist/jotai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jotai.js","names":[],"sources":["../src/renderer/jotai.ts"],"sourcesContent":["import { atom, type Getter, type PrimitiveAtom, type Setter } from \"jotai\";\nimport { useEffect, useMemo, useState } from \"react\";\n\nimport type { SyncStateChannelOptions } from \"../channels\";\nimport type { SyncStateBridge } from \"../types\";\nimport { resolveSyncStateBridge } from \"./bridge\";\nimport { getGlobalConfig } from \"./index\";\n\nexport interface SyncStateJotaiOptions extends SyncStateChannelOptions {\n  bridge?: SyncStateBridge;\n}\n\ninterface SyncedAtomWrapper<StateValue> {\n  atom: PrimitiveAtom<StateValue>;\n  // 保存基础 atom 的 setter，用于应用远程更新\n  setAtom?: (value: StateValue) => void;\n  // 记录订阅的清理函数，供外部释放\n  unsubscribe?: () => void;\n}\n\nconst createChannelOptions = (options: SyncStateJotaiOptions): SyncStateChannelOptions => {\n  const globalConfig = getGlobalConfig();\n  return {\n    baseChannel: options.baseChannel ?? globalConfig.baseChannel,\n    name: options.name,\n  };\n};\n\n// Store synced atoms for cleanup\nconst syncedAtoms = new Map<string, SyncedAtomWrapper<unknown>>();\n\n/**\n * Create a synced atom that synchronizes with Electron main process\n *\n * @example\n * ```typescript\n * import { syncStateAtom, useAtom } from 'electron-state-sync/jotai';\n *\n * const countAtom = syncStateAtom(0, { name: 'counter' });\n *\n * function App() {\n *   const [count, setCount] = useAtom(countAtom);\n *   return <div onClick={() => setCount(5)}>{count}</div>;\n * }\n * ```\n */\nexport const syncStateAtom = <StateValue>(\n  initialValue: StateValue,\n  options: SyncStateJotaiOptions,\n): PrimitiveAtom<StateValue> => {\n  const globalConfig = getGlobalConfig();\n  const bridge = resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);\n  const channelOptions = createChannelOptions(options);\n\n  // Create wrapper to track sync state\n  const baseAtom = atom(initialValue);\n  const wrapper: SyncedAtomWrapper<StateValue> = {\n    atom: baseAtom,\n  };\n\n  // Store for cleanup\n  const atomKey = `${channelOptions.baseChannel}:${channelOptions.name}`;\n  syncedAtoms.set(atomKey, wrapper as SyncedAtomWrapper<unknown>);\n\n  // 待应用的远程值（atom 挂载前缓存）\n  let pendingRemoteValue = initialValue;\n  // 是否存在待处理的远程更新\n  let hasPendingRemoteValue = false;\n\n  // 应用主进程的远程更新\n  const applyRemoteValue = (value: StateValue): void => {\n    if (wrapper.setAtom) {\n      wrapper.setAtom(value);\n      return;\n    }\n    pendingRemoteValue = value;\n    hasPendingRemoteValue = true;\n  };\n\n  // 基础 atom 挂载时，补发缓存的远程值\n  baseAtom.onMount = (setAtom) => {\n    wrapper.setAtom = setAtom;\n    if (hasPendingRemoteValue) {\n      setAtom(pendingRemoteValue);\n      hasPendingRemoteValue = false;\n    }\n    return () => {\n      wrapper.setAtom = undefined;\n    };\n  };\n\n  // Subscribe to remote updates from main process\n  const unsubscribe = bridge.subscribe<StateValue>(channelOptions, applyRemoteValue);\n  wrapper.unsubscribe = unsubscribe;\n\n  // Initialize from main process\n  void bridge.get<StateValue>(channelOptions).then(applyRemoteValue);\n\n  // Create read-write atom with sync logic\n  const syncedAtom = atom(\n    (get: Getter) => get(baseAtom),\n    (get: Getter, set: Setter, value: StateValue | ((prev: StateValue) => StateValue)) => {\n      const currentValue = get(baseAtom);\n      const nextValue =\n        typeof value === \"function\"\n          ? (value as (prev: StateValue) => StateValue)(currentValue)\n          : value;\n\n      // Local update - sync to main process\n      set(baseAtom, nextValue);\n      void bridge.set(channelOptions, nextValue);\n    },\n  );\n\n  return syncedAtom as PrimitiveAtom<StateValue>;\n};\n\n/**\n * Hook to access sync status for a synced atom\n *\n * @example\n * ```typescript\n * import { useSyncStateStatus } from 'electron-state-sync/jotai';\n *\n * function App() {\n *   const { isSynced } = useSyncStateStatus({ name: 'counter' });\n *   return isSynced ? <div>Synced</div> : <div>Loading...</div>;\n * }\n * ```\n */\nexport const useSyncStateStatus = (options: SyncStateJotaiOptions): { isSynced: boolean } => {\n  const [isSynced, setIsSynced] = useState(false);\n  const globalConfig = getGlobalConfig();\n  const bridge = resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);\n  const channelOptions = useMemo(\n    () => createChannelOptions(options),\n    [options.baseChannel, options.name],\n  );\n\n  useEffect(() => {\n    void bridge.get(channelOptions).then(() => {\n      setIsSynced(true);\n    });\n  }, [bridge, channelOptions]);\n\n  return { isSynced };\n};\n\n/**\n * Cleanup function for synced atoms\n *\n * Call this when unmounting components to prevent memory leaks\n */\nexport const cleanupSyncedAtom = (options: SyncStateJotaiOptions): void => {\n  const channelOptions = createChannelOptions(options);\n  const atomKey = `${channelOptions.baseChannel}:${channelOptions.name}`;\n  // 清理订阅避免内存泄漏\n  const wrapper = syncedAtoms.get(atomKey);\n  wrapper?.unsubscribe?.();\n  syncedAtoms.delete(atomKey);\n};\n"],"mappings":";;;;;AAoBA,MAAM,wBAAwB,YAA4D;CACxF,MAAM,eAAe,iBAAiB;AACtC,QAAO;EACL,aAAa,QAAQ,eAAe,aAAa;EACjD,MAAM,QAAQ;EACf;;AAIH,MAAM,8BAAc,IAAI,KAAyC;;;;;;;;;;;;;;;;AAiBjE,MAAa,iBACX,cACA,YAC8B;CAC9B,MAAM,eAAe,iBAAiB;CACtC,MAAM,SAAS,uBAAuB,QAAQ,UAAU,aAAa,OAAO;CAC5E,MAAM,iBAAiB,qBAAqB,QAAQ;CAGpD,MAAM,WAAW,KAAK,aAAa;CACnC,MAAM,UAAyC,EAC7C,MAAM,UACP;CAGD,MAAM,UAAU,GAAG,eAAe,YAAY,GAAG,eAAe;AAChE,aAAY,IAAI,SAAS,QAAsC;CAG/D,IAAI,qBAAqB;CAEzB,IAAI,wBAAwB;CAG5B,MAAM,oBAAoB,UAA4B;AACpD,MAAI,QAAQ,SAAS;AACnB,WAAQ,QAAQ,MAAM;AACtB;;AAEF,uBAAqB;AACrB,0BAAwB;;AAI1B,UAAS,WAAW,YAAY;AAC9B,UAAQ,UAAU;AAClB,MAAI,uBAAuB;AACzB,WAAQ,mBAAmB;AAC3B,2BAAwB;;AAE1B,eAAa;AACX,WAAQ,UAAU;;;AAMtB,SAAQ,cADY,OAAO,UAAsB,gBAAgB,iBAAiB;AAIlF,CAAK,OAAO,IAAgB,eAAe,CAAC,KAAK,iBAAiB;AAkBlE,QAfmB,MAChB,QAAgB,IAAI,SAAS,GAC7B,KAAa,KAAa,UAA2D;EACpF,MAAM,eAAe,IAAI,SAAS;EAClC,MAAM,YACJ,OAAO,UAAU,aACZ,MAA2C,aAAa,GACzD;AAGN,MAAI,UAAU,UAAU;AACxB,EAAK,OAAO,IAAI,gBAAgB,UAAU;GAE7C;;;;;;;;;;;;;;;AAkBH,MAAa,sBAAsB,YAA0D;CAC3F,MAAM,CAAC,UAAU,eAAe,SAAS,MAAM;CAC/C,MAAM,eAAe,iBAAiB;CACtC,MAAM,SAAS,uBAAuB,QAAQ,UAAU,aAAa,OAAO;CAC5E,MAAM,iBAAiB,cACf,qBAAqB,QAAQ,EACnC,CAAC,QAAQ,aAAa,QAAQ,KAAK,CACpC;AAED,iBAAgB;AACd,EAAK,OAAO,IAAI,eAAe,CAAC,WAAW;AACzC,eAAY,KAAK;IACjB;IACD,CAAC,QAAQ,eAAe,CAAC;AAE5B,QAAO,EAAE,UAAU;;;;;;;AAQrB,MAAa,qBAAqB,YAAyC;CACzE,MAAM,iBAAiB,qBAAqB,QAAQ;CACpD,MAAM,UAAU,GAAG,eAAe,YAAY,GAAG,eAAe;AAGhE,CADgB,YAAY,IAAI,QAAQ,EAC/B,eAAe;AACxB,aAAY,OAAO,QAAQ"}

package/dist/main.cjs

@@ -0,0 +1,177 @@
+let electron = require("electron");
+
+//#region src/channels.ts
+const createSyncStateChannels = (options) => {
+	const channelPrefix = `${options.baseChannel ?? "state"}:${options.name}`;
+	return {
+		getChannel: `${channelPrefix}:get`,
+		setChannel: `${channelPrefix}:set`,
+		subscribeChannel: `${channelPrefix}:subscribe`,
+		unsubscribeChannel: `${channelPrefix}:unsubscribe`,
+		updateChannel: `${channelPrefix}:update`
+	};
+};
+
+//#endregion
+//#region src/types.ts
+var SyncStateError = class SyncStateError extends Error {
+	code;
+	stateName;
+	baseChannel;
+	cause;
+	constructor(code, message, context) {
+		super(message);
+		this.code = code;
+		this.name = "SyncStateError";
+		this.stateName = context?.stateName;
+		this.baseChannel = context?.baseChannel;
+		this.cause = context?.cause;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, SyncStateError);
+	}
+	getFullMessage() {
+		const parts = [this.message];
+		if (this.stateName) parts.push(`\n  State name: "${this.stateName}"`);
+		if (this.baseChannel) parts.push(`\n  Channel prefix: "${this.baseChannel}"`);
+		if (this.cause) parts.push(`\n  Original error: ${this.cause.message}`);
+		return parts.join("");
+	}
+};
+
+//#endregion
+//#region src/main.ts
+let globalConfig = {};
+const initSyncStateMain = (config) => {
+	globalConfig = { ...config };
+};
+const createReadonlyErrorMessage = (stateName, baseChannel) => `syncState renderer write is disabled by main process. State "${stateName}" has channel prefix "${baseChannel}". Please set allowRendererSet: true in main process to enable renderer write.`;
+const createInvalidValueErrorMessage = (stateName, baseChannel) => `syncState renderer write value validation failed. State "${stateName}" has channel prefix "${baseChannel}". Please check if the value conforms to resolveRendererValue validation rules.`;
+const INVALID_INITIAL_VALUE_WARNING_MESSAGE = "syncState Warning: Initial value contains non-serializable content (such as functions, Symbols, BigInts, etc.), which will prevent the value from being transmitted to renderer process via IPC";
+const checkType = (val) => {
+	if (val === null || val === void 0) return true;
+	if (typeof val === "string") return true;
+	if (typeof val === "number") return true;
+	if (typeof val === "boolean") return true;
+	if (typeof val === "function") return false;
+	if (typeof val === "symbol") return false;
+	if (typeof val === "bigint") return false;
+	if (Array.isArray(val)) return val.every((item) => checkType(item));
+	if (typeof val === "object") try {
+		JSON.stringify(val);
+		return Object.values(val).every((item) => checkType(item));
+	} catch {
+		return false;
+	}
+	return true;
+};
+const validateSerializable = (value) => checkType(value);
+const createSyncStateStore = (initialValue) => {
+	let state$1 = initialValue;
+	const getState = () => state$1;
+	const setState = (value) => {
+		state$1 = value;
+	};
+	return {
+		getState,
+		setState
+	};
+};
+const createSubscriptions = (channels, getState) => {
+	const subscribers = /* @__PURE__ */ new Set();
+	const broadcast = (value) => {
+		for (const subscriber of subscribers) if (subscriber.isDestroyed()) subscribers.delete(subscriber);
+		else subscriber.send(channels.updateChannel, value);
+	};
+	const handleSubscribe = ({ sender }) => {
+		subscribers.add(sender);
+		sender.once("destroyed", () => {
+			subscribers.delete(sender);
+		});
+		sender.send(channels.updateChannel, getState());
+	};
+	const handleUnsubscribe = ({ sender }) => {
+		subscribers.delete(sender);
+	};
+	const clear = () => {
+		subscribers.clear();
+	};
+	return {
+		broadcast,
+		clear,
+		handleSubscribe,
+		handleUnsubscribe
+	};
+};
+const createSetStateAndBroadcast = (setState, broadcast) => (value) => {
+	setState(value);
+	broadcast(value);
+};
+const createInvokeHandlers = (getState, setStateAndBroadcast, options) => {
+	const handleGet = () => getState();
+	const ensureRendererWritable = () => {
+		if (options.allowRendererSet === false) throw new SyncStateError("RENDERER_READONLY", createReadonlyErrorMessage(options.name, options.baseChannel ?? "state"), {
+			baseChannel: options.baseChannel ?? "state",
+			stateName: options.name
+		});
+	};
+	const resolveRendererValue = (value) => {
+		if (!options.resolveRendererValue) return value;
+		try {
+			return options.resolveRendererValue(value);
+		} catch (error) {
+			let message = "";
+			let cause = void 0;
+			if (error instanceof Error) {
+				const { message: errorMessage } = error;
+				message = errorMessage;
+				cause = error;
+			} else message = createInvalidValueErrorMessage(options.name, options.baseChannel ?? "state");
+			throw new SyncStateError("RENDERER_INVALID_VALUE", message, {
+				baseChannel: options.baseChannel ?? "state",
+				cause,
+				stateName: options.name
+			});
+		}
+	};
+	const handleSet = (_event, value) => {
+		ensureRendererWritable();
+		setStateAndBroadcast(resolveRendererValue(value));
+	};
+	return {
+		handleGet,
+		handleSet
+	};
+};
+const registerIpcHandlers = (channels, invokeHandlers, subscriptions) => {
+	electron.ipcMain.handle(channels.getChannel, invokeHandlers.handleGet);
+	electron.ipcMain.handle(channels.setChannel, invokeHandlers.handleSet);
+	electron.ipcMain.on(channels.subscribeChannel, subscriptions.handleSubscribe);
+	electron.ipcMain.on(channels.unsubscribeChannel, subscriptions.handleUnsubscribe);
+	return () => {
+		electron.ipcMain.removeHandler(channels.getChannel);
+		electron.ipcMain.removeHandler(channels.setChannel);
+		electron.ipcMain.removeListener(channels.subscribeChannel, subscriptions.handleSubscribe);
+		electron.ipcMain.removeListener(channels.unsubscribeChannel, subscriptions.handleUnsubscribe);
+		subscriptions.clear();
+	};
+};
+const state = (options) => {
+	const mergedOptions = {
+		allowRendererSet: globalConfig.allowRendererSet,
+		baseChannel: globalConfig.baseChannel,
+		...options
+	};
+	if (!validateSerializable(mergedOptions.initialValue)) console.warn(`${INVALID_INITIAL_VALUE_WARNING_MESSAGE}\n  State name: "${mergedOptions.name}"`);
+	const channels = createSyncStateChannels(mergedOptions);
+	const store = createSyncStateStore(mergedOptions.initialValue);
+	const subscriptions = createSubscriptions(channels, store.getState);
+	const setStateAndBroadcast = createSetStateAndBroadcast(store.setState, subscriptions.broadcast);
+	return {
+		dispose: registerIpcHandlers(channels, createInvokeHandlers(store.getState, setStateAndBroadcast, mergedOptions), subscriptions),
+		get: store.getState,
+		set: setStateAndBroadcast
+	};
+};
+
+//#endregion
+exports.initSyncStateMain = initSyncStateMain;
+exports.state = state;

package/dist/main.d.cts

@@ -0,0 +1,26 @@
+//#region src/channels.d.ts
+interface SyncStateChannelOptions {
+  name: string;
+  baseChannel?: string;
+}
+//#endregion
+//#region src/main.d.ts
+interface SyncStateMainGlobalConfig {
+  baseChannel?: string;
+  allowRendererSet?: boolean;
+}
+declare const initSyncStateMain: (config: SyncStateMainGlobalConfig) => void;
+interface SyncStateMainOptions<StateValue> extends SyncStateChannelOptions {
+  initialValue: StateValue;
+  allowRendererSet?: boolean;
+  resolveRendererValue?: (value: StateValue) => StateValue;
+}
+interface SyncStateMainHandle<StateValue> {
+  get: () => StateValue;
+  set: (value: StateValue) => void;
+  dispose: () => void;
+}
+declare const state: <StateValue>(options: SyncStateMainOptions<StateValue>) => SyncStateMainHandle<StateValue>;
+//#endregion
+export { SyncStateMainGlobalConfig, SyncStateMainHandle, SyncStateMainOptions, initSyncStateMain, state };
+//# sourceMappingURL=main.d.cts.map

package/dist/main.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.cts","names":[],"sources":["../src/channels.ts","../src/main.ts"],"sourcesContent":[],"mappings":";UAAiB,uBAAA;EAAA,IAAA,EAAA,MAAA;;;;;AAAA,UCSA,yBAAA,CDTuB;;;;ACSvB,cAOJ,iBAP6B,EAAA,CAAA,MAAA,EAOA,yBAPA,EAAA,GAAA,IAAA;AAO7B,UAII,oBAJyB,CAAA,UAAA,CAAA,SAIgB,uBAJS,CAAA;EAIlD,YAAA,EACD,UADqB;EACrB,gBAAA,CAAA,EAAA,OAAA;EAEiB,oBAAA,CAAA,EAAA,CAAA,KAAA,EAAA,UAAA,EAAA,GAAe,UAAf;;AAHyB,UAMzC,mBANyC,CAAA,UAAA,CAAA,CAAA;EAAuB,GAAA,EAAA,GAAA,GAOpE,UAPoE;EAMhE,GAAA,EAAA,CAAA,KAAA,EAEF,UAFqB,EAAA,GAAA,IAAA;EAuNvB,OAAA,EA0BZ,GAAA,GAAA,IAAA;;AAzBU,cADE,KACF,EAAA,CAAA,UAAA,CAAA,CAAA,OAAA,EAAA,oBAAA,CAAqB,UAArB,CAAA,EAAA,GACR,mBADQ,CACY,UADZ,CAAA"}

package/dist/main.d.ts

@@ -0,0 +1,26 @@
+//#region src/channels.d.ts
+interface SyncStateChannelOptions {
+  name: string;
+  baseChannel?: string;
+}
+//#endregion
+//#region src/main.d.ts
+interface SyncStateMainGlobalConfig {
+  baseChannel?: string;
+  allowRendererSet?: boolean;
+}
+declare const initSyncStateMain: (config: SyncStateMainGlobalConfig) => void;
+interface SyncStateMainOptions<StateValue> extends SyncStateChannelOptions {
+  initialValue: StateValue;
+  allowRendererSet?: boolean;
+  resolveRendererValue?: (value: StateValue) => StateValue;
+}
+interface SyncStateMainHandle<StateValue> {
+  get: () => StateValue;
+  set: (value: StateValue) => void;
+  dispose: () => void;
+}
+declare const state: <StateValue>(options: SyncStateMainOptions<StateValue>) => SyncStateMainHandle<StateValue>;
+//#endregion
+export { SyncStateMainGlobalConfig, SyncStateMainHandle, SyncStateMainOptions, initSyncStateMain, state };
+//# sourceMappingURL=main.d.ts.map

package/dist/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","names":[],"sources":["../src/channels.ts","../src/main.ts"],"sourcesContent":[],"mappings":";UAAiB,uBAAA;EAAA,IAAA,EAAA,MAAA;;;;;AAAA,UCSA,yBAAA,CDTuB;;;;ACSvB,cAOJ,iBAP6B,EAAA,CAAA,MAAA,EAOA,yBAPA,EAAA,GAAA,IAAA;AAO7B,UAII,oBAJyB,CAAA,UAAA,CAAA,SAIgB,uBAJS,CAAA;EAIlD,YAAA,EACD,UADqB;EACrB,gBAAA,CAAA,EAAA,OAAA;EAEiB,oBAAA,CAAA,EAAA,CAAA,KAAA,EAAA,UAAA,EAAA,GAAe,UAAf;;AAHyB,UAMzC,mBANyC,CAAA,UAAA,CAAA,CAAA;EAAuB,GAAA,EAAA,GAAA,GAOpE,UAPoE;EAMhE,GAAA,EAAA,CAAA,KAAA,EAEF,UAFqB,EAAA,GAAA,IAAA;EAuNvB,OAAA,EA0BZ,GAAA,GAAA,IAAA;;AAzBU,cADE,KACF,EAAA,CAAA,UAAA,CAAA,CAAA,OAAA,EAAA,oBAAA,CAAqB,UAArB,CAAA,EAAA,GACR,mBADQ,CACY,UADZ,CAAA"}