electron-state-sync 1.1.0

package/dist/redux.d.ts

@@ -0,0 +1,80 @@
+import { a as SyncStateChannelOptions, t as SyncStateBridge } from "./types-7wPPX0ty.js";
+import { Middleware, UnknownAction } from "@reduxjs/toolkit";
+
+//#region src/renderer/redux.d.ts
+interface SyncStateReduxOptions extends SyncStateChannelOptions {
+  bridge?: SyncStateBridge;
+  selector?: (state: unknown) => unknown;
+  actionType?: string;
+}
+interface SyncStateActionMeta {
+  syncState?: {
+    skipSync?: boolean;
+  };
+}
+interface SyncStateAction<StateValue> extends UnknownAction {
+  payload: StateValue;
+  meta: SyncStateActionMeta;
+}
+/**
+ * Redux middleware for syncing state with Electron main process
+ *
+ * @example
+ * ```typescript
+ * import { configureStore } from '@reduxjs/toolkit';
+ * import { syncStateMiddleware } from 'electron-state-sync/redux';
+ *
+ * const store = configureStore({
+ *   reducer: { counter: counterReducer },
+ *   middleware: (getDefaultMiddleware) =>
+ *     getDefaultMiddleware().concat(
+ *       syncStateMiddleware({
+ *         name: 'counter',
+ *         selector: (state) => state.counter.value
+ *       })
+ *     )
+ * });
+ * ```
+ */
+declare const syncStateMiddleware: (options: SyncStateReduxOptions) => Middleware<object, any, never>;
+/**
+ * Hook for accessing synced state in React components
+ *
+ * @example
+ * ```typescript
+ * import { useSyncState } from 'electron-state-sync/redux';
+ *
+ * function App() {
+ *   const { state: count, isSynced } = useSyncState<number>({
+ *     name: 'counter',
+ *     selector: (state) => state.counter.value
+ *   });
+ *
+ *   return <div>{count}</div>;
+ * }
+ * ```
+ */
+declare const useSyncState: <StateValue>(options: SyncStateReduxOptions) => {
+  state: StateValue;
+  isSynced: boolean;
+};
+/**
+ * Hook to create an action creator that syncs with main process
+ *
+ * @example
+ * ```typescript
+ * import { createSyncActionCreator } from 'electron-state-sync/redux';
+ *
+ * const setCount = createSyncActionCreator<number>('counter/set', {
+ *   name: 'counter'
+ * });
+ *
+ * // In component
+ * const dispatch = useDispatch();
+ * dispatch(setCount(42));
+ * ```
+ */
+declare const createSyncActionCreator: <StateValue>(actionType: string, options: SyncStateReduxOptions) => ((value: StateValue) => SyncStateAction<StateValue>);
+//#endregion
+export { SyncStateReduxOptions, createSyncActionCreator, syncStateMiddleware, useSyncState as useReduxSyncState, useSyncState };
+//# sourceMappingURL=redux.d.ts.map

package/dist/redux.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redux.d.ts","names":[],"sources":["../src/renderer/redux.ts"],"sourcesContent":[],"mappings":";;;;UAUiB,qBAAA,SAA8B;EAA9B,MAAA,CAAA,EACN,eAD4B;EAqB7B,QAAA,CAAA,EAAA,CAAA,KAAA,EAAA,OAAmB,EAAA,GAAA,OAAA;EAOnB,UAAA,CAAA,EAAA,MAAe;;UAPf,mBAAA,CASF;EAFsC,SAAA,CAAA,EAAA;IAAa,QAAA,CAAA,EAAA,OAAA;EA+B9C,CAAA;AAqDb;AAkEA,UAtJU,eAsJG,CAAA,UAqBZ,CAAA,SA3K6C,aA2K7C,CAAA;EAnBU,OAAA,EAvJA,UAuJA;EACC,IAAA,EAvJJ,mBAuJI;;;;;;;;;;;;;;;;;;;;;;cA1HC,+BACF,0BACR;;;;;;;;;;;;;;;;;;cAmDU,oCACF;SACC;;;;;;;;;;;;;;;;;;;cAgEC,mEAEF,mCACC,eAAe,gBAAgB"}

package/dist/redux.js

@@ -0,0 +1,146 @@
+import { a as resolveSyncStateBridge, t as getGlobalConfig } from "./renderer-C7zF3UQm.js";
+import { useEffect, useMemo, useState } from "react";
+import { useDispatch, useSelector } from "react-redux";
+
+//#region src/renderer/redux.ts
+const createChannelOptions = (options) => {
+	const globalConfig = getGlobalConfig();
+	return {
+		baseChannel: options.baseChannel ?? globalConfig.baseChannel,
+		name: options.name
+	};
+};
+const storeRemoteUpdates = /* @__PURE__ */ new WeakMap();
+const channelStores = /* @__PURE__ */ new Map();
+const shouldSkipSyncAction = (action) => {
+	const { meta } = action;
+	return Boolean(meta?.syncState?.skipSync);
+};
+/**
+* Redux middleware for syncing state with Electron main process
+*
+* @example
+* ```typescript
+* import { configureStore } from '@reduxjs/toolkit';
+* import { syncStateMiddleware } from 'electron-state-sync/redux';
+*
+* const store = configureStore({
+*   reducer: { counter: counterReducer },
+*   middleware: (getDefaultMiddleware) =>
+*     getDefaultMiddleware().concat(
+*       syncStateMiddleware({
+*         name: 'counter',
+*         selector: (state) => state.counter.value
+*       })
+*     )
+* });
+* ```
+*/
+const syncStateMiddleware = (options) => {
+	const globalConfig = getGlobalConfig();
+	const bridge = resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = createChannelOptions(options);
+	return (storeAPI) => (next) => (action) => {
+		const channelKey = `${channelOptions.baseChannel}:${channelOptions.name}`;
+		channelStores.set(channelKey, storeAPI);
+		const result = next(action);
+		const nextState = storeAPI.getState();
+		if (storeRemoteUpdates.get(storeAPI)) {
+			storeRemoteUpdates.set(storeAPI, false);
+			return result;
+		}
+		if (shouldSkipSyncAction(action)) return result;
+		const selectedState = options.selector ? options.selector(nextState) : nextState;
+		bridge.set(channelOptions, selectedState);
+		return result;
+	};
+};
+/**
+* Hook for accessing synced state in React components
+*
+* @example
+* ```typescript
+* import { useSyncState } from 'electron-state-sync/redux';
+*
+* function App() {
+*   const { state: count, isSynced } = useSyncState<number>({
+*     name: 'counter',
+*     selector: (state) => state.counter.value
+*   });
+*
+*   return <div>{count}</div>;
+* }
+* ```
+*/
+const useSyncState = (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]);
+	const actionType = useMemo(() => options.actionType || `${channelOptions.baseChannel}/${channelOptions.name}/set`, [
+		options.actionType,
+		channelOptions.baseChannel,
+		channelOptions.name
+	]);
+	const state = useSelector((state$1) => options.selector ? options.selector(state$1) : state$1);
+	const dispatch = useDispatch();
+	useEffect(() => {
+		const channelKey = `${channelOptions.baseChannel}:${channelOptions.name}`;
+		const unsubscribe = bridge.subscribe(channelOptions, (value) => {
+			const store = channelStores.get(channelKey);
+			if (store) storeRemoteUpdates.set(store, true);
+			dispatch({
+				payload: value,
+				type: actionType
+			});
+		});
+		bridge.get(channelOptions).then(() => {
+			setIsSynced(true);
+		});
+		return () => {
+			unsubscribe();
+		};
+	}, [
+		bridge,
+		channelOptions,
+		dispatch,
+		actionType
+	]);
+	return {
+		isSynced,
+		state
+	};
+};
+/**
+* Hook to create an action creator that syncs with main process
+*
+* @example
+* ```typescript
+* import { createSyncActionCreator } from 'electron-state-sync/redux';
+*
+* const setCount = createSyncActionCreator<number>('counter/set', {
+*   name: 'counter'
+* });
+*
+* // In component
+* const dispatch = useDispatch();
+* dispatch(setCount(42));
+* ```
+*/
+const createSyncActionCreator = (actionType, options) => {
+	const globalConfig = getGlobalConfig();
+	const bridge = resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = createChannelOptions(options);
+	return (value) => {
+		bridge.set(channelOptions, value);
+		return {
+			meta: { syncState: { skipSync: true } },
+			payload: value,
+			type: actionType
+		};
+	};
+};
+
+//#endregion
+export { createSyncActionCreator, syncStateMiddleware, useSyncState as useReduxSyncState, useSyncState };
+//# sourceMappingURL=redux.js.map

package/dist/redux.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redux.js","names":["state"],"sources":["../src/renderer/redux.ts"],"sourcesContent":["import { useEffect, useMemo, useState } from \"react\";\n\nimport type { Middleware, UnknownAction } from \"@reduxjs/toolkit\";\nimport { useDispatch, useSelector } from \"react-redux\";\n\nimport type { SyncStateChannelOptions } from \"../channels\";\nimport type { SyncStateBridge } from \"../types\";\nimport { resolveSyncStateBridge } from \"./bridge\";\nimport { getGlobalConfig } from \"./index\";\n\nexport interface SyncStateReduxOptions extends SyncStateChannelOptions {\n  bridge?: SyncStateBridge;\n  selector?: (state: unknown) => unknown;\n  actionType?: string;\n}\n\nconst createChannelOptions = (options: SyncStateReduxOptions): SyncStateChannelOptions => {\n  const globalConfig = getGlobalConfig();\n  return {\n    baseChannel: options.baseChannel ?? globalConfig.baseChannel,\n    name: options.name,\n  };\n};\n\n// Track remote updates per store\nconst storeRemoteUpdates = new WeakMap<object, boolean>();\n\n// Store references to stores keyed by channel key, so useSyncState can access them\nconst channelStores = new Map<string, object>();\n\n// 标记需要跳过中间件同步的 action 元信息\ninterface SyncStateActionMeta {\n  syncState?: {\n    skipSync?: boolean;\n  };\n}\n\n// 同步 action 的结构定义\ninterface SyncStateAction<StateValue> extends UnknownAction {\n  payload: StateValue;\n  meta: SyncStateActionMeta;\n}\n\n// 检查 action 是否需要跳过同步\nconst shouldSkipSyncAction = (action: UnknownAction): boolean => {\n  const { meta } = action as { meta?: SyncStateActionMeta };\n  return Boolean(meta?.syncState?.skipSync);\n};\n\n/**\n * Redux middleware for syncing state with Electron main process\n *\n * @example\n * ```typescript\n * import { configureStore } from '@reduxjs/toolkit';\n * import { syncStateMiddleware } from 'electron-state-sync/redux';\n *\n * const store = configureStore({\n *   reducer: { counter: counterReducer },\n *   middleware: (getDefaultMiddleware) =>\n *     getDefaultMiddleware().concat(\n *       syncStateMiddleware({\n *         name: 'counter',\n *         selector: (state) => state.counter.value\n *       })\n *     )\n * });\n * ```\n */\nexport const syncStateMiddleware = (\n  options: SyncStateReduxOptions,\n): Middleware<object, any, never> => {\n  const globalConfig = getGlobalConfig();\n  const bridge = resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);\n  const channelOptions = createChannelOptions(options);\n\n  return (storeAPI) => (next) => (action) => {\n    // Store reference to this store for useSyncState to access\n    const channelKey = `${channelOptions.baseChannel}:${channelOptions.name}`;\n    channelStores.set(channelKey, storeAPI);\n    const result = next(action);\n    const nextState = storeAPI.getState();\n\n    // Check if applying remote update\n    const isRemote = storeRemoteUpdates.get(storeAPI);\n    if (isRemote) {\n      storeRemoteUpdates.set(storeAPI, false);\n      return result;\n    }\n\n    // 如果 action 已经触发同步，跳过重复发送\n    if (shouldSkipSyncAction(action as UnknownAction)) {\n      return result;\n    }\n\n    // Select state to sync\n    const selectedState = options.selector ? options.selector(nextState) : nextState;\n\n    // Local update - sync to main process\n    void bridge.set(channelOptions, selectedState as unknown);\n\n    return result;\n  };\n};\n\n/**\n * Hook for accessing synced state in React components\n *\n * @example\n * ```typescript\n * import { useSyncState } from 'electron-state-sync/redux';\n *\n * function App() {\n *   const { state: count, isSynced } = useSyncState<number>({\n *     name: 'counter',\n *     selector: (state) => state.counter.value\n *   });\n *\n *   return <div>{count}</div>;\n * }\n * ```\n */\nexport const useSyncState = <StateValue>(\n  options: SyncStateReduxOptions,\n): { state: StateValue; 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  const actionType = useMemo(\n    () => options.actionType || `${channelOptions.baseChannel}/${channelOptions.name}/set`,\n    [options.actionType, channelOptions.baseChannel, channelOptions.name],\n  );\n\n  // Select state from Redux store\n  const state = useSelector((state: unknown) =>\n    options.selector ? (options.selector(state) as StateValue) : (state as StateValue),\n  );\n\n  // Subscribe to remote updates\n  const dispatch = useDispatch();\n  useEffect(() => {\n    const channelKey = `${channelOptions.baseChannel}:${channelOptions.name}`;\n    const unsubscribe = bridge.subscribe<StateValue>(channelOptions, (value) => {\n      // Mark as remote update by setting the flag before dispatching\n      const store = channelStores.get(channelKey);\n      if (store) {\n        storeRemoteUpdates.set(store, true);\n      }\n      dispatch({\n        payload: value,\n        type: actionType,\n      } as UnknownAction);\n    });\n\n    void bridge.get<StateValue>(channelOptions).then(() => {\n      setIsSynced(true);\n    });\n\n    return () => {\n      unsubscribe();\n    };\n  }, [bridge, channelOptions, dispatch, actionType]);\n\n  return { isSynced, state };\n};\n\nexport { useSyncState as useReduxSyncState };\n\n/**\n * Hook to create an action creator that syncs with main process\n *\n * @example\n * ```typescript\n * import { createSyncActionCreator } from 'electron-state-sync/redux';\n *\n * const setCount = createSyncActionCreator<number>('counter/set', {\n *   name: 'counter'\n * });\n *\n * // In component\n * const dispatch = useDispatch();\n * dispatch(setCount(42));\n * ```\n */\nexport const createSyncActionCreator = <StateValue>(\n  actionType: string,\n  options: SyncStateReduxOptions,\n): ((value: StateValue) => SyncStateAction<StateValue>) => {\n  const globalConfig = getGlobalConfig();\n  const bridge = resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);\n  const channelOptions = createChannelOptions(options);\n\n  return (value: StateValue) => {\n    void bridge.set(channelOptions, value);\n    return {\n      // 标记为已同步，避免中间件重复发送\n      meta: {\n        syncState: {\n          skipSync: true,\n        },\n      },\n      payload: value,\n      type: actionType,\n    };\n  };\n};\n"],"mappings":";;;;;AAgBA,MAAM,wBAAwB,YAA4D;CACxF,MAAM,eAAe,iBAAiB;AACtC,QAAO;EACL,aAAa,QAAQ,eAAe,aAAa;EACjD,MAAM,QAAQ;EACf;;AAIH,MAAM,qCAAqB,IAAI,SAA0B;AAGzD,MAAM,gCAAgB,IAAI,KAAqB;AAgB/C,MAAM,wBAAwB,WAAmC;CAC/D,MAAM,EAAE,SAAS;AACjB,QAAO,QAAQ,MAAM,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;AAuB3C,MAAa,uBACX,YACmC;CACnC,MAAM,eAAe,iBAAiB;CACtC,MAAM,SAAS,uBAAuB,QAAQ,UAAU,aAAa,OAAO;CAC5E,MAAM,iBAAiB,qBAAqB,QAAQ;AAEpD,SAAQ,cAAc,UAAU,WAAW;EAEzC,MAAM,aAAa,GAAG,eAAe,YAAY,GAAG,eAAe;AACnE,gBAAc,IAAI,YAAY,SAAS;EACvC,MAAM,SAAS,KAAK,OAAO;EAC3B,MAAM,YAAY,SAAS,UAAU;AAIrC,MADiB,mBAAmB,IAAI,SAAS,EACnC;AACZ,sBAAmB,IAAI,UAAU,MAAM;AACvC,UAAO;;AAIT,MAAI,qBAAqB,OAAwB,CAC/C,QAAO;EAIT,MAAM,gBAAgB,QAAQ,WAAW,QAAQ,SAAS,UAAU,GAAG;AAGvE,EAAK,OAAO,IAAI,gBAAgB,cAAyB;AAEzD,SAAO;;;;;;;;;;;;;;;;;;;;AAqBX,MAAa,gBACX,YAC6C;CAC7C,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;CACD,MAAM,aAAa,cACX,QAAQ,cAAc,GAAG,eAAe,YAAY,GAAG,eAAe,KAAK,OACjF;EAAC,QAAQ;EAAY,eAAe;EAAa,eAAe;EAAK,CACtE;CAGD,MAAM,QAAQ,aAAa,YACzB,QAAQ,WAAY,QAAQ,SAASA,QAAM,GAAmBA,QAC/D;CAGD,MAAM,WAAW,aAAa;AAC9B,iBAAgB;EACd,MAAM,aAAa,GAAG,eAAe,YAAY,GAAG,eAAe;EACnE,MAAM,cAAc,OAAO,UAAsB,iBAAiB,UAAU;GAE1E,MAAM,QAAQ,cAAc,IAAI,WAAW;AAC3C,OAAI,MACF,oBAAmB,IAAI,OAAO,KAAK;AAErC,YAAS;IACP,SAAS;IACT,MAAM;IACP,CAAkB;IACnB;AAEF,EAAK,OAAO,IAAgB,eAAe,CAAC,WAAW;AACrD,eAAY,KAAK;IACjB;AAEF,eAAa;AACX,gBAAa;;IAEd;EAAC;EAAQ;EAAgB;EAAU;EAAW,CAAC;AAElD,QAAO;EAAE;EAAU;EAAO;;;;;;;;;;;;;;;;;;AAqB5B,MAAa,2BACX,YACA,YACyD;CACzD,MAAM,eAAe,iBAAiB;CACtC,MAAM,SAAS,uBAAuB,QAAQ,UAAU,aAAa,OAAO;CAC5E,MAAM,iBAAiB,qBAAqB,QAAQ;AAEpD,SAAQ,UAAsB;AAC5B,EAAK,OAAO,IAAI,gBAAgB,MAAM;AACtC,SAAO;GAEL,MAAM,EACJ,WAAW,EACT,UAAU,MACX,EACF;GACD,SAAS;GACT,MAAM;GACP"}

package/dist/renderer/index.cjs

@@ -0,0 +1,7 @@
+const require_renderer = require('../renderer-D3YziJ_U.cjs');
+
+exports.SyncStateError = require_renderer.SyncStateError;
+exports.createSyncStateChannels = require_renderer.createSyncStateChannels;
+exports.getGlobalConfig = require_renderer.getGlobalConfig;
+exports.initSyncState = require_renderer.initSyncState;
+exports.resolveSyncStateBridge = require_renderer.resolveSyncStateBridge;

package/dist/renderer/index.d.cts

@@ -0,0 +1,23 @@
+import { a as SyncStateChannelOptions, i as SyncStateListener, n as SyncStateError, o as SyncStateChannels, r as SyncStateErrorCode, s as createSyncStateChannels, t as SyncStateBridge } from "../types-C18dHgLI.cjs";
+
+//#region src/renderer/window.d.ts
+declare global {
+  interface Window {
+    syncState?: SyncStateBridge;
+  }
+}
+//# sourceMappingURL=window.d.ts.map
+//#endregion
+//#region src/renderer/bridge.d.ts
+declare const resolveSyncStateBridge: (bridge?: SyncStateBridge) => SyncStateBridge;
+//#endregion
+//#region src/renderer/index.d.ts
+interface SyncStateRendererGlobalConfig {
+  baseChannel?: string;
+  bridge?: SyncStateBridge;
+}
+declare const initSyncState: (config: SyncStateRendererGlobalConfig) => void;
+declare const getGlobalConfig: () => SyncStateRendererGlobalConfig;
+//#endregion
+export { type SyncStateBridge, type SyncStateChannelOptions, type SyncStateChannels, SyncStateError, type SyncStateErrorCode, type SyncStateListener, SyncStateRendererGlobalConfig, createSyncStateChannels, getGlobalConfig, initSyncState, resolveSyncStateBridge };
+//# sourceMappingURL=index.d.cts.map

package/dist/renderer/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/renderer/window.ts","../../src/renderer/bridge.ts","../../src/renderer/index.ts"],"sourcesContent":[],"mappings":";;;;;IAAgD,SAAA,CAAA,EAIhC,eAJgC;EAAA;;;;;cCMnC,kCAAmC,oBAAkB;;;ADFnC,UEQd,6BAAA,CFRc;;WEUpB;;ADRE,cCaA,aDJZ,EAAA,CAAA,MAT+C,ECaV,6BDJrC,EAAA,GAAA,IAAA;cCQY,uBAAsB"}

package/dist/renderer/index.d.ts

@@ -0,0 +1,23 @@
+import { a as SyncStateChannelOptions, i as SyncStateListener, n as SyncStateError, o as SyncStateChannels, r as SyncStateErrorCode, s as createSyncStateChannels, t as SyncStateBridge } from "../types-7wPPX0ty.js";
+
+//#region src/renderer/window.d.ts
+declare global {
+  interface Window {
+    syncState?: SyncStateBridge;
+  }
+}
+//# sourceMappingURL=window.d.ts.map
+//#endregion
+//#region src/renderer/bridge.d.ts
+declare const resolveSyncStateBridge: (bridge?: SyncStateBridge) => SyncStateBridge;
+//#endregion
+//#region src/renderer/index.d.ts
+interface SyncStateRendererGlobalConfig {
+  baseChannel?: string;
+  bridge?: SyncStateBridge;
+}
+declare const initSyncState: (config: SyncStateRendererGlobalConfig) => void;
+declare const getGlobalConfig: () => SyncStateRendererGlobalConfig;
+//#endregion
+export { type SyncStateBridge, type SyncStateChannelOptions, type SyncStateChannels, SyncStateError, type SyncStateErrorCode, type SyncStateListener, SyncStateRendererGlobalConfig, createSyncStateChannels, getGlobalConfig, initSyncState, resolveSyncStateBridge };
+//# sourceMappingURL=index.d.ts.map

package/dist/renderer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/renderer/window.ts","../../src/renderer/bridge.ts","../../src/renderer/index.ts"],"sourcesContent":[],"mappings":";;;;;IAAgD,SAAA,CAAA,EAIhC,eAJgC;EAAA;;;;;cCMnC,kCAAmC,oBAAkB;;;ADFnC,UEQd,6BAAA,CFRc;;WEUpB;;ADRE,cCaA,aDJZ,EAAA,CAAA,MAT+C,ECaV,6BDJrC,EAAA,GAAA,IAAA;cCQY,uBAAsB"}

package/dist/renderer/index.js

@@ -0,0 +1,3 @@
+import { a as resolveSyncStateBridge, i as createSyncStateChannels, n as initSyncState, r as SyncStateError, t as getGlobalConfig } from "../renderer-C7zF3UQm.js";
+
+export { SyncStateError, createSyncStateChannels, getGlobalConfig, initSyncState, resolveSyncStateBridge };

package/dist/renderer-C7zF3UQm.js

@@ -0,0 +1,57 @@
+//#region src/renderer/bridge.ts
+const resolveSyncStateBridge = (bridge) => {
+	const globalBridge = globalThis.syncState;
+	const resolvedBridge = bridge ?? globalBridge;
+	if (!resolvedBridge) throw new Error("globalThis.syncState not injected, please check preload configuration");
+	return resolvedBridge;
+};
+
+//#endregion
+//#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/renderer/index.ts
+let globalConfig = {};
+const initSyncState = (config) => {
+	globalConfig = { ...config };
+};
+const getGlobalConfig = () => globalConfig;
+
+//#endregion
+export { resolveSyncStateBridge as a, createSyncStateChannels as i, initSyncState as n, SyncStateError as r, getGlobalConfig as t };
+//# sourceMappingURL=renderer-C7zF3UQm.js.map

package/dist/renderer-C7zF3UQm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer-C7zF3UQm.js","names":[],"sources":["../src/renderer/bridge.ts","../src/channels.ts","../src/types.ts","../src/renderer/index.ts"],"sourcesContent":["import type { SyncStateBridge } from \"../types\";\n\ninterface SyncStateGlobal {\n  syncState?: SyncStateBridge;\n}\n\nexport const resolveSyncStateBridge = (bridge?: SyncStateBridge): SyncStateBridge => {\n  const globalBridge = (globalThis as SyncStateGlobal).syncState;\n  const resolvedBridge = bridge ?? globalBridge;\n\n  if (!resolvedBridge) {\n    throw new Error(\"globalThis.syncState not injected, please check preload configuration\");\n  }\n\n  return resolvedBridge;\n};\n","export interface SyncStateChannelOptions {\n  name: string;\n  baseChannel?: string;\n}\n\nexport interface SyncStateChannels {\n  getChannel: string;\n  setChannel: string;\n  subscribeChannel: string;\n  unsubscribeChannel: string;\n  updateChannel: string;\n}\n\nexport const createSyncStateChannels = (options: SyncStateChannelOptions): SyncStateChannels => {\n  const baseChannel = options.baseChannel ?? \"state\";\n  const channelPrefix = `${baseChannel}:${options.name}`;\n\n  return {\n    getChannel: `${channelPrefix}:get`,\n    setChannel: `${channelPrefix}:set`,\n    subscribeChannel: `${channelPrefix}:subscribe`,\n    unsubscribeChannel: `${channelPrefix}:unsubscribe`,\n    updateChannel: `${channelPrefix}:update`,\n  };\n};\n","import type { SyncStateChannelOptions } from \"./channels\";\n\nexport type SyncStateListener<StateValue> = (value: StateValue) => void;\n\nexport type SyncStateErrorCode = \"RENDERER_READONLY\" | \"RENDERER_INVALID_VALUE\";\n\nexport class SyncStateError extends Error {\n  public readonly code: SyncStateErrorCode;\n  public readonly stateName?: string;\n  public readonly baseChannel?: string;\n  public readonly cause?: Error;\n\n  public constructor(\n    code: SyncStateErrorCode,\n    message: string,\n    context?: { stateName?: string; baseChannel?: string; cause?: Error },\n  ) {\n    super(message);\n    this.code = code;\n    this.name = \"SyncStateError\";\n    this.stateName = context?.stateName;\n    this.baseChannel = context?.baseChannel;\n    this.cause = context?.cause;\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, SyncStateError);\n    }\n  }\n\n  public getFullMessage(): string {\n    const parts = [this.message];\n    if (this.stateName) {\n      parts.push(`\\n  State name: \"${this.stateName}\"`);\n    }\n    if (this.baseChannel) {\n      parts.push(`\\n  Channel prefix: \"${this.baseChannel}\"`);\n    }\n    if (this.cause) {\n      parts.push(`\\n  Original error: ${this.cause.message}`);\n    }\n    return parts.join(\"\");\n  }\n}\n\nexport interface SyncStateBridge {\n  get: <StateValue>(options: SyncStateChannelOptions) => Promise<StateValue>;\n  set: <StateValue>(options: SyncStateChannelOptions, value: StateValue) => Promise<void>;\n  subscribe: <StateValue>(\n    options: SyncStateChannelOptions,\n    listener: SyncStateListener<StateValue>,\n  ) => () => void;\n}\n","import \"./window\";\n\nimport type { SyncStateBridge } from \"../types\";\n\nexport { resolveSyncStateBridge } from \"./bridge\";\n\nexport { createSyncStateChannels } from \"../channels\";\nexport type { SyncStateChannelOptions, SyncStateChannels } from \"../channels\";\n\nexport { SyncStateError } from \"../types\";\nexport type { SyncStateBridge, SyncStateErrorCode, SyncStateListener } from \"../types\";\n\nexport interface SyncStateRendererGlobalConfig {\n  baseChannel?: string;\n  bridge?: SyncStateBridge;\n}\n\nlet globalConfig: SyncStateRendererGlobalConfig = {};\n\nexport const initSyncState = (config: SyncStateRendererGlobalConfig): void => {\n  globalConfig = { ...config };\n};\n\nexport const getGlobalConfig = (): SyncStateRendererGlobalConfig => globalConfig;\n"],"mappings":";AAMA,MAAa,0BAA0B,WAA8C;CACnF,MAAM,eAAgB,WAA+B;CACrD,MAAM,iBAAiB,UAAU;AAEjC,KAAI,CAAC,eACH,OAAM,IAAI,MAAM,wEAAwE;AAG1F,QAAO;;;;;ACDT,MAAa,2BAA2B,YAAwD;CAE9F,MAAM,gBAAgB,GADF,QAAQ,eAAe,QACN,GAAG,QAAQ;AAEhD,QAAO;EACL,YAAY,GAAG,cAAc;EAC7B,YAAY,GAAG,cAAc;EAC7B,kBAAkB,GAAG,cAAc;EACnC,oBAAoB,GAAG,cAAc;EACrC,eAAe,GAAG,cAAc;EACjC;;;;;ACjBH,IAAa,iBAAb,MAAa,uBAAuB,MAAM;CACxC,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAEhB,AAAO,YACL,MACA,SACA,SACA;AACA,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,OAAK,OAAO;AACZ,OAAK,YAAY,SAAS;AAC1B,OAAK,cAAc,SAAS;AAC5B,OAAK,QAAQ,SAAS;AAEtB,MAAI,MAAM,kBACR,OAAM,kBAAkB,MAAM,eAAe;;CAIjD,AAAO,iBAAyB;EAC9B,MAAM,QAAQ,CAAC,KAAK,QAAQ;AAC5B,MAAI,KAAK,UACP,OAAM,KAAK,oBAAoB,KAAK,UAAU,GAAG;AAEnD,MAAI,KAAK,YACP,OAAM,KAAK,wBAAwB,KAAK,YAAY,GAAG;AAEzD,MAAI,KAAK,MACP,OAAM,KAAK,uBAAuB,KAAK,MAAM,UAAU;AAEzD,SAAO,MAAM,KAAK,GAAG;;;;;;ACvBzB,IAAI,eAA8C,EAAE;AAEpD,MAAa,iBAAiB,WAAgD;AAC5E,gBAAe,EAAE,GAAG,QAAQ;;AAG9B,MAAa,wBAAuD"}

package/dist/renderer-D3YziJ_U.cjs

@@ -0,0 +1,86 @@
+
+//#region src/renderer/bridge.ts
+const resolveSyncStateBridge = (bridge) => {
+	const globalBridge = globalThis.syncState;
+	const resolvedBridge = bridge ?? globalBridge;
+	if (!resolvedBridge) throw new Error("globalThis.syncState not injected, please check preload configuration");
+	return resolvedBridge;
+};
+
+//#endregion
+//#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/renderer/index.ts
+let globalConfig = {};
+const initSyncState = (config) => {
+	globalConfig = { ...config };
+};
+const getGlobalConfig = () => globalConfig;
+
+//#endregion
+Object.defineProperty(exports, 'SyncStateError', {
+  enumerable: true,
+  get: function () {
+    return SyncStateError;
+  }
+});
+Object.defineProperty(exports, 'createSyncStateChannels', {
+  enumerable: true,
+  get: function () {
+    return createSyncStateChannels;
+  }
+});
+Object.defineProperty(exports, 'getGlobalConfig', {
+  enumerable: true,
+  get: function () {
+    return getGlobalConfig;
+  }
+});
+Object.defineProperty(exports, 'initSyncState', {
+  enumerable: true,
+  get: function () {
+    return initSyncState;
+  }
+});
+Object.defineProperty(exports, 'resolveSyncStateBridge', {
+  enumerable: true,
+  get: function () {
+    return resolveSyncStateBridge;
+  }
+});

package/dist/solid.cjs

@@ -0,0 +1,74 @@
+const require_renderer = require('./renderer-D3YziJ_U.cjs');
+let solid_js = require("solid-js");
+
+//#region src/renderer/solid.ts
+const createChannelOptions = (options) => {
+	const globalConfig = require_renderer.getGlobalConfig();
+	return {
+		baseChannel: options.baseChannel ?? globalConfig.baseChannel,
+		name: options.name
+	};
+};
+const createRemoteUpdateTracker = (setState, setIsSynced) => {
+	let isRemoteUpdate = false;
+	const applyRemoteValue = (value) => {
+		isRemoteUpdate = true;
+		setState(value);
+		setIsSynced(true);
+		isRemoteUpdate = false;
+	};
+	const shouldSkipLocalSync = () => {
+		if (!isRemoteUpdate) return false;
+		isRemoteUpdate = false;
+		return true;
+	};
+	return {
+		applyRemoteValue,
+		shouldSkipLocalSync
+	};
+};
+const createSyncSetter = (options) => (value) => {
+	const { accessor, bridge, channelOptions, setState, tracker } = options;
+	let nextValue = value;
+	if (typeof value === "function") nextValue = value(accessor());
+	if (tracker.shouldSkipLocalSync()) return setState(nextValue);
+	const resultValue = setState(nextValue);
+	bridge.set(channelOptions, nextValue);
+	return resultValue;
+};
+const useSyncState = (initialValue, options) => {
+	const [rawStateValue, rawSetStateValue] = (0, solid_js.createSignal)(initialValue);
+	const stateValue = rawStateValue;
+	const [isSynced, setIsSynced] = (0, solid_js.createSignal)(false);
+	const setStateValue = (value) => {
+		rawSetStateValue(value);
+		return value;
+	};
+	const globalConfig = require_renderer.getGlobalConfig();
+	const bridge = require_renderer.resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = createChannelOptions(options);
+	const tracker = createRemoteUpdateTracker(setStateValue, setIsSynced);
+	const setAndSync = createSyncSetter({
+		accessor: stateValue,
+		bridge,
+		channelOptions,
+		setState: setStateValue,
+		tracker
+	});
+	(0, solid_js.onMount)(() => {
+		const unsubscribe = bridge.subscribe(channelOptions, tracker.applyRemoteValue);
+		bridge.get(channelOptions).then(tracker.applyRemoteValue);
+		(0, solid_js.onCleanup)(() => {
+			unsubscribe();
+		});
+	});
+	return [
+		stateValue,
+		setAndSync,
+		isSynced
+	];
+};
+
+//#endregion
+exports.useSyncState = useSyncState;
+exports.useSyncStateSolid = useSyncState;

package/dist/solid.d.cts

@@ -0,0 +1,13 @@
+import { a as SyncStateChannelOptions, t as SyncStateBridge } from "./types-C18dHgLI.cjs";
+import { Accessor } from "solid-js";
+
+//#region src/renderer/solid.d.ts
+interface UseSyncStateSolidOptions extends SyncStateChannelOptions {
+  bridge?: SyncStateBridge;
+}
+type SyncStateSolidSetter<StateValue> = (value: StateValue | ((prev: StateValue) => StateValue)) => StateValue;
+type UseSyncStateSolidResult<StateValue> = readonly [Accessor<StateValue>, SyncStateSolidSetter<StateValue>, Accessor<boolean>];
+declare const useSyncState: <StateValue>(initialValue: StateValue, options: UseSyncStateSolidOptions) => UseSyncStateSolidResult<StateValue>;
+//#endregion
+export { SyncStateSolidSetter, UseSyncStateSolidOptions, UseSyncStateSolidResult, useSyncState, useSyncState as useSyncStateSolid };
+//# sourceMappingURL=solid.d.cts.map

package/dist/solid.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid.d.cts","names":[],"sources":["../src/renderer/solid.ts"],"sourcesContent":[],"mappings":";;;;UAOiB,wBAAA,SAAiC;EAAjC,MAAA,CAAA,EACN,eADM;AAKjB;AACS,KADG,oBACH,CAAA,UAAA,CAAA,GAAA,CAAA,KAAA,EAAA,UAAA,GAAA,CAAA,CAAA,IAAA,EAAqB,UAArB,EAAA,GAAoC,UAApC,CAAA,EAAA,GACJ,UADI;AAAqB,KAIlB,uBAJkB,CAAA,UAAA,CAAA,GAAA,SAAA,CAK5B,QAL2C,CAKlC,UALkC,CAAA,EAM3C,oBALG,CAKkB,UALlB,CAAA,EAMH,QANa,CAAA,OAAA,CAAA,CAGf;AACW,cA+EE,YA/EF,EAAA,CAAA,UAAA,CAAA,CAAA,YAAA,EAgFK,UAhFL,EAAA,OAAA,EAiFA,wBAjFA,EAAA,GAkFR,uBAlFQ,CAkFgB,UAlFhB,CAAA"}

package/dist/solid.d.ts

@@ -0,0 +1,13 @@
+import { a as SyncStateChannelOptions, t as SyncStateBridge } from "./types-7wPPX0ty.js";
+import { Accessor } from "solid-js";
+
+//#region src/renderer/solid.d.ts
+interface UseSyncStateSolidOptions extends SyncStateChannelOptions {
+  bridge?: SyncStateBridge;
+}
+type SyncStateSolidSetter<StateValue> = (value: StateValue | ((prev: StateValue) => StateValue)) => StateValue;
+type UseSyncStateSolidResult<StateValue> = readonly [Accessor<StateValue>, SyncStateSolidSetter<StateValue>, Accessor<boolean>];
+declare const useSyncState: <StateValue>(initialValue: StateValue, options: UseSyncStateSolidOptions) => UseSyncStateSolidResult<StateValue>;
+//#endregion
+export { SyncStateSolidSetter, UseSyncStateSolidOptions, UseSyncStateSolidResult, useSyncState, useSyncState as useSyncStateSolid };
+//# sourceMappingURL=solid.d.ts.map

package/dist/solid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid.d.ts","names":[],"sources":["../src/renderer/solid.ts"],"sourcesContent":[],"mappings":";;;;UAOiB,wBAAA,SAAiC;EAAjC,MAAA,CAAA,EACN,eADM;AAKjB;AACS,KADG,oBACH,CAAA,UAAA,CAAA,GAAA,CAAA,KAAA,EAAA,UAAA,GAAA,CAAA,CAAA,IAAA,EAAqB,UAArB,EAAA,GAAoC,UAApC,CAAA,EAAA,GACJ,UADI;AAAqB,KAIlB,uBAJkB,CAAA,UAAA,CAAA,GAAA,SAAA,CAK5B,QAL2C,CAKlC,UALkC,CAAA,EAM3C,oBALG,CAKkB,UALlB,CAAA,EAMH,QANa,CAAA,OAAA,CAAA,CAGf;AACW,cA+EE,YA/EF,EAAA,CAAA,UAAA,CAAA,CAAA,YAAA,EAgFK,UAhFL,EAAA,OAAA,EAiFA,wBAjFA,EAAA,GAkFR,uBAlFQ,CAkFgB,UAlFhB,CAAA"}

package/dist/solid.js

@@ -0,0 +1,74 @@
+import { a as resolveSyncStateBridge, t as getGlobalConfig } from "./renderer-C7zF3UQm.js";
+import { createSignal, onCleanup, onMount } from "solid-js";
+
+//#region src/renderer/solid.ts
+const createChannelOptions = (options) => {
+	const globalConfig = getGlobalConfig();
+	return {
+		baseChannel: options.baseChannel ?? globalConfig.baseChannel,
+		name: options.name
+	};
+};
+const createRemoteUpdateTracker = (setState, setIsSynced) => {
+	let isRemoteUpdate = false;
+	const applyRemoteValue = (value) => {
+		isRemoteUpdate = true;
+		setState(value);
+		setIsSynced(true);
+		isRemoteUpdate = false;
+	};
+	const shouldSkipLocalSync = () => {
+		if (!isRemoteUpdate) return false;
+		isRemoteUpdate = false;
+		return true;
+	};
+	return {
+		applyRemoteValue,
+		shouldSkipLocalSync
+	};
+};
+const createSyncSetter = (options) => (value) => {
+	const { accessor, bridge, channelOptions, setState, tracker } = options;
+	let nextValue = value;
+	if (typeof value === "function") nextValue = value(accessor());
+	if (tracker.shouldSkipLocalSync()) return setState(nextValue);
+	const resultValue = setState(nextValue);
+	bridge.set(channelOptions, nextValue);
+	return resultValue;
+};
+const useSyncState = (initialValue, options) => {
+	const [rawStateValue, rawSetStateValue] = createSignal(initialValue);
+	const stateValue = rawStateValue;
+	const [isSynced, setIsSynced] = createSignal(false);
+	const setStateValue = (value) => {
+		rawSetStateValue(value);
+		return value;
+	};
+	const globalConfig = getGlobalConfig();
+	const bridge = resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = createChannelOptions(options);
+	const tracker = createRemoteUpdateTracker(setStateValue, setIsSynced);
+	const setAndSync = createSyncSetter({
+		accessor: stateValue,
+		bridge,
+		channelOptions,
+		setState: setStateValue,
+		tracker
+	});
+	onMount(() => {
+		const unsubscribe = bridge.subscribe(channelOptions, tracker.applyRemoteValue);
+		bridge.get(channelOptions).then(tracker.applyRemoteValue);
+		onCleanup(() => {
+			unsubscribe();
+		});
+	});
+	return [
+		stateValue,
+		setAndSync,
+		isSynced
+	];
+};
+
+//#endregion
+export { useSyncState, useSyncState as useSyncStateSolid };
+//# sourceMappingURL=solid.js.map