electron-state-sync 1.1.0

package/dist/react-query.d.cts

@@ -0,0 +1,58 @@
+import { a as SyncStateChannelOptions, t as SyncStateBridge } from "./types-C18dHgLI.cjs";
+
+//#region src/renderer/react-query.d.ts
+interface SyncStateQueryOptions extends SyncStateChannelOptions {
+  bridge?: SyncStateBridge;
+  staleTime?: number;
+  gcTime?: number;
+  queryKey?: unknown[];
+}
+/**
+ * Hook for syncing state with TanStack Query
+ *
+ * Provides a query-based interface to sync state between renderer and main process.
+ * Automatically refetches when remote changes occur.
+ *
+ * @example
+ * ```typescript
+ * import { useSyncState } from 'electron-state-sync/react-query';
+ *
+ * function App() {
+ *   const { data: count, isSynced, update } = useSyncState(0, {
+ *     name: 'counter'
+ *   });
+ *
+ *   return <div onClick={() => update(5)}>{count}</div>;
+ * }
+ * ```
+ */
+declare const useSyncState: <StateValue>(initialValue: StateValue, options: SyncStateQueryOptions) => {
+  data: StateValue;
+  isSynced: boolean;
+  update: (value: StateValue) => void;
+};
+/**
+ * Hook for creating a mutation to update synced state
+ *
+ * Provides a simpler mutation-only interface for updating state.
+ *
+ * @example
+ * ```typescript
+ * import { useSyncMutation } from 'electron-state-sync/react-query';
+ *
+ * function App() {
+ *   const { mutate, isSynced } = useSyncMutation<number>({
+ *     name: 'counter'
+ *   });
+ *
+ *   return <button onClick={() => mutate(10)}>Set to 10</button>;
+ * }
+ * ```
+ */
+declare const useSyncMutation: <StateValue>(options: SyncStateQueryOptions) => {
+  mutate: (value: StateValue) => void;
+  isSynced: boolean;
+};
+//#endregion
+export { SyncStateQueryOptions, useSyncState as useQuerySyncState, useSyncState, useSyncMutation };
+//# sourceMappingURL=react-query.d.cts.map

package/dist/react-query.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-query.d.cts","names":[],"sources":["../src/renderer/react-query.ts"],"sourcesContent":[],"mappings":";;;UAYiB,qBAAA,SAA8B;EAA9B,MAAA,CAAA,EACN,eAD4B;EAkC1B,SAAA,CAAA,EAAA,MA6DZ;EA5De,MAAA,CAAA,EAAA,MAAA;EACL,QAAA,CAAA,EAAA,OAAA,EAAA;;;;AA+EX;;;;;;;;;;;;;;;;;cAjFa,yCACG,qBACL;QAEH;;kBAEU;;;;;;;;;;;;;;;;;;;;cA2EL,uCACF;kBACU"}

package/dist/react-query.d.ts

@@ -0,0 +1,58 @@
+import { a as SyncStateChannelOptions, t as SyncStateBridge } from "./types-7wPPX0ty.js";
+
+//#region src/renderer/react-query.d.ts
+interface SyncStateQueryOptions extends SyncStateChannelOptions {
+  bridge?: SyncStateBridge;
+  staleTime?: number;
+  gcTime?: number;
+  queryKey?: unknown[];
+}
+/**
+ * Hook for syncing state with TanStack Query
+ *
+ * Provides a query-based interface to sync state between renderer and main process.
+ * Automatically refetches when remote changes occur.
+ *
+ * @example
+ * ```typescript
+ * import { useSyncState } from 'electron-state-sync/react-query';
+ *
+ * function App() {
+ *   const { data: count, isSynced, update } = useSyncState(0, {
+ *     name: 'counter'
+ *   });
+ *
+ *   return <div onClick={() => update(5)}>{count}</div>;
+ * }
+ * ```
+ */
+declare const useSyncState: <StateValue>(initialValue: StateValue, options: SyncStateQueryOptions) => {
+  data: StateValue;
+  isSynced: boolean;
+  update: (value: StateValue) => void;
+};
+/**
+ * Hook for creating a mutation to update synced state
+ *
+ * Provides a simpler mutation-only interface for updating state.
+ *
+ * @example
+ * ```typescript
+ * import { useSyncMutation } from 'electron-state-sync/react-query';
+ *
+ * function App() {
+ *   const { mutate, isSynced } = useSyncMutation<number>({
+ *     name: 'counter'
+ *   });
+ *
+ *   return <button onClick={() => mutate(10)}>Set to 10</button>;
+ * }
+ * ```
+ */
+declare const useSyncMutation: <StateValue>(options: SyncStateQueryOptions) => {
+  mutate: (value: StateValue) => void;
+  isSynced: boolean;
+};
+//#endregion
+export { SyncStateQueryOptions, useSyncState as useQuerySyncState, useSyncState, useSyncMutation };
+//# sourceMappingURL=react-query.d.ts.map

package/dist/react-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-query.d.ts","names":[],"sources":["../src/renderer/react-query.ts"],"sourcesContent":[],"mappings":";;;UAYiB,qBAAA,SAA8B;EAA9B,MAAA,CAAA,EACN,eAD4B;EAkC1B,SAAA,CAAA,EAAA,MA6DZ;EA5De,MAAA,CAAA,EAAA,MAAA;EACL,QAAA,CAAA,EAAA,OAAA,EAAA;;;;AA+EX;;;;;;;;;;;;;;;;;cAjFa,yCACG,qBACL;QAEH;;kBAEU;;;;;;;;;;;;;;;;;;;;cA2EL,uCACF;kBACU"}

package/dist/react-query.js

@@ -0,0 +1,112 @@
+import { a as resolveSyncStateBridge, t as getGlobalConfig } from "./renderer-C7zF3UQm.js";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useMutation, useQuery } from "@tanstack/react-query";
+
+//#region src/renderer/react-query.ts
+const DEFAULT_STALE_TIME = 1e3;
+const DEFAULT_GC_TIME = 3e5;
+const createChannelOptions = (options) => {
+	const globalConfig = getGlobalConfig();
+	return {
+		baseChannel: options.baseChannel ?? globalConfig.baseChannel,
+		name: options.name
+	};
+};
+/**
+* Hook for syncing state with TanStack Query
+*
+* Provides a query-based interface to sync state between renderer and main process.
+* Automatically refetches when remote changes occur.
+*
+* @example
+* ```typescript
+* import { useSyncState } from 'electron-state-sync/react-query';
+*
+* function App() {
+*   const { data: count, isSynced, update } = useSyncState(0, {
+*     name: 'counter'
+*   });
+*
+*   return <div onClick={() => update(5)}>{count}</div>;
+* }
+* ```
+*/
+const useSyncState = (initialValue, 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 query = useQuery({
+		gcTime: options.gcTime ?? DEFAULT_GC_TIME,
+		queryFn: () => bridge.get(channelOptions),
+		queryKey: options.queryKey ?? [
+			"sync-state",
+			channelOptions.baseChannel,
+			channelOptions.name
+		],
+		refetchOnWindowFocus: false,
+		staleTime: options.staleTime ?? DEFAULT_STALE_TIME
+	});
+	const mutation = useMutation({ mutationFn: (value) => bridge.set(channelOptions, value) });
+	useEffect(() => {
+		const unsubscribe = bridge.subscribe(channelOptions, () => {
+			query.refetch();
+		});
+		return () => {
+			unsubscribe();
+		};
+	}, [
+		bridge,
+		channelOptions,
+		query
+	]);
+	useEffect(() => {
+		if (!query.isLoading && !query.isFetching) setIsSynced(true);
+	}, [query.isLoading, query.isFetching]);
+	const update = useCallback((value) => {
+		mutation.mutate(value);
+	}, [mutation]);
+	return {
+		data: query.data ?? initialValue,
+		isSynced,
+		update
+	};
+};
+/**
+* Hook for creating a mutation to update synced state
+*
+* Provides a simpler mutation-only interface for updating state.
+*
+* @example
+* ```typescript
+* import { useSyncMutation } from 'electron-state-sync/react-query';
+*
+* function App() {
+*   const { mutate, isSynced } = useSyncMutation<number>({
+*     name: 'counter'
+*   });
+*
+*   return <button onClick={() => mutate(10)}>Set to 10</button>;
+* }
+* ```
+*/
+const useSyncMutation = (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]);
+	const mutation = useMutation({ mutationFn: (value) => bridge.set(channelOptions, value) });
+	return {
+		isSynced,
+		mutate: (value) => mutation.mutate(value)
+	};
+};
+
+//#endregion
+export { useSyncState as useQuerySyncState, useSyncState, useSyncMutation };
+//# sourceMappingURL=react-query.js.map

package/dist/react-query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-query.js","names":[],"sources":["../src/renderer/react-query.ts"],"sourcesContent":["import { useCallback, useEffect, useMemo, useState } from \"react\";\nimport { useMutation, useQuery } from \"@tanstack/react-query\";\n\nimport type { SyncStateChannelOptions } from \"../channels\";\nimport type { SyncStateBridge } from \"../types\";\nimport { resolveSyncStateBridge } from \"./bridge\";\nimport { getGlobalConfig } from \"./index\";\n\n// Default query timings\nconst DEFAULT_STALE_TIME = 1000;\nconst DEFAULT_GC_TIME = 300_000;\n\nexport interface SyncStateQueryOptions extends SyncStateChannelOptions {\n  bridge?: SyncStateBridge;\n  staleTime?: number;\n  gcTime?: number;\n  queryKey?: unknown[];\n}\n\nconst createChannelOptions = (options: SyncStateQueryOptions): SyncStateChannelOptions => {\n  const globalConfig = getGlobalConfig();\n  return {\n    baseChannel: options.baseChannel ?? globalConfig.baseChannel,\n    name: options.name,\n  };\n};\n\n/**\n * Hook for syncing state with TanStack Query\n *\n * Provides a query-based interface to sync state between renderer and main process.\n * Automatically refetches when remote changes occur.\n *\n * @example\n * ```typescript\n * import { useSyncState } from 'electron-state-sync/react-query';\n *\n * function App() {\n *   const { data: count, isSynced, update } = useSyncState(0, {\n *     name: 'counter'\n *   });\n *\n *   return <div onClick={() => update(5)}>{count}</div>;\n * }\n * ```\n */\nexport const useSyncState = <StateValue>(\n  initialValue: StateValue,\n  options: SyncStateQueryOptions,\n): {\n  data: StateValue;\n  isSynced: boolean;\n  update: (value: StateValue) => void;\n} => {\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  // Query for fetching state from main process\n  const query = useQuery({\n    gcTime: options.gcTime ?? DEFAULT_GC_TIME,\n    queryFn: () => bridge.get<StateValue>(channelOptions),\n    queryKey: options.queryKey ?? [\"sync-state\", channelOptions.baseChannel, channelOptions.name],\n    refetchOnWindowFocus: false,\n    staleTime: options.staleTime ?? DEFAULT_STALE_TIME,\n  });\n\n  // Mutation for updating state\n  const mutation = useMutation({\n    mutationFn: (value: StateValue) => bridge.set(channelOptions, value),\n  });\n\n  // Subscribe to remote updates and refetch query\n  useEffect(() => {\n    const unsubscribe = bridge.subscribe<StateValue>(channelOptions, () => {\n      query.refetch();\n    });\n\n    return () => {\n      unsubscribe();\n    };\n  }, [bridge, channelOptions, query]);\n\n  // Check sync status on mount\n  useEffect(() => {\n    if (!query.isLoading && !query.isFetching) {\n      setIsSynced(true);\n    }\n  }, [query.isLoading, query.isFetching]);\n\n  // Update function that mutates state\n  const update = useCallback(\n    (value: StateValue) => {\n      mutation.mutate(value);\n    },\n    [mutation],\n  );\n\n  return {\n    data: query.data ?? initialValue,\n    isSynced,\n    update,\n  };\n};\n\n/**\n * Hook for creating a mutation to update synced state\n *\n * Provides a simpler mutation-only interface for updating state.\n *\n * @example\n * ```typescript\n * import { useSyncMutation } from 'electron-state-sync/react-query';\n *\n * function App() {\n *   const { mutate, isSynced } = useSyncMutation<number>({\n *     name: 'counter'\n *   });\n *\n *   return <button onClick={() => mutate(10)}>Set to 10</button>;\n * }\n * ```\n */\nexport const useSyncMutation = <StateValue>(\n  options: SyncStateQueryOptions,\n): { mutate: (value: StateValue) => void; 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  // Check if synced on mount\n  useEffect(() => {\n    void bridge.get<StateValue>(channelOptions).then(() => {\n      setIsSynced(true);\n    });\n  }, [bridge, channelOptions]);\n\n  const mutation = useMutation({\n    mutationFn: (value: StateValue) => bridge.set(channelOptions, value),\n  });\n\n  return {\n    isSynced,\n    mutate: (value: StateValue) => mutation.mutate(value),\n  };\n};\n\nexport { useSyncState as useQuerySyncState };\n"],"mappings":";;;;;AASA,MAAM,qBAAqB;AAC3B,MAAM,kBAAkB;AASxB,MAAM,wBAAwB,YAA4D;CACxF,MAAM,eAAe,iBAAiB;AACtC,QAAO;EACL,aAAa,QAAQ,eAAe,aAAa;EACjD,MAAM,QAAQ;EACf;;;;;;;;;;;;;;;;;;;;;AAsBH,MAAa,gBACX,cACA,YAKG;CACH,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;CAGD,MAAM,QAAQ,SAAS;EACrB,QAAQ,QAAQ,UAAU;EAC1B,eAAe,OAAO,IAAgB,eAAe;EACrD,UAAU,QAAQ,YAAY;GAAC;GAAc,eAAe;GAAa,eAAe;GAAK;EAC7F,sBAAsB;EACtB,WAAW,QAAQ,aAAa;EACjC,CAAC;CAGF,MAAM,WAAW,YAAY,EAC3B,aAAa,UAAsB,OAAO,IAAI,gBAAgB,MAAM,EACrE,CAAC;AAGF,iBAAgB;EACd,MAAM,cAAc,OAAO,UAAsB,sBAAsB;AACrE,SAAM,SAAS;IACf;AAEF,eAAa;AACX,gBAAa;;IAEd;EAAC;EAAQ;EAAgB;EAAM,CAAC;AAGnC,iBAAgB;AACd,MAAI,CAAC,MAAM,aAAa,CAAC,MAAM,WAC7B,aAAY,KAAK;IAElB,CAAC,MAAM,WAAW,MAAM,WAAW,CAAC;CAGvC,MAAM,SAAS,aACZ,UAAsB;AACrB,WAAS,OAAO,MAAM;IAExB,CAAC,SAAS,CACX;AAED,QAAO;EACL,MAAM,MAAM,QAAQ;EACpB;EACA;EACD;;;;;;;;;;;;;;;;;;;;AAqBH,MAAa,mBACX,YAC+D;CAC/D,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;AAGD,iBAAgB;AACd,EAAK,OAAO,IAAgB,eAAe,CAAC,WAAW;AACrD,eAAY,KAAK;IACjB;IACD,CAAC,QAAQ,eAAe,CAAC;CAE5B,MAAM,WAAW,YAAY,EAC3B,aAAa,UAAsB,OAAO,IAAI,gBAAgB,MAAM,EACrE,CAAC;AAEF,QAAO;EACL;EACA,SAAS,UAAsB,SAAS,OAAO,MAAM;EACtD"}

package/dist/react.cjs

@@ -0,0 +1,46 @@
+const require_renderer = require('./renderer-D3YziJ_U.cjs');
+let react = require("react");
+
+//#region src/renderer/react.ts
+const createChannelOptions = (options) => {
+	const globalConfig = require_renderer.getGlobalConfig();
+	return {
+		baseChannel: options.baseChannel ?? globalConfig.baseChannel,
+		name: options.name
+	};
+};
+const useSyncState = (initialValue, options) => {
+	const [stateValue, setStateValue] = (0, react.useState)(initialValue);
+	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]);
+	const applyRemoteValue = (0, react.useCallback)((value) => {
+		setStateValue(value);
+		setIsSynced(true);
+	}, []);
+	const setAndSync = (0, react.useCallback)((value) => {
+		setStateValue(value);
+		bridge.set(channelOptions, value);
+	}, [bridge, channelOptions]);
+	(0, react.useEffect)(() => {
+		const unsubscribe = bridge.subscribe(channelOptions, applyRemoteValue);
+		bridge.get(channelOptions).then(applyRemoteValue);
+		return () => {
+			unsubscribe();
+		};
+	}, [
+		applyRemoteValue,
+		bridge,
+		channelOptions
+	]);
+	return [
+		stateValue,
+		setAndSync,
+		isSynced
+	];
+};
+
+//#endregion
+exports.useSyncState = useSyncState;
+exports.useSyncStateReact = useSyncState;

package/dist/react.d.cts

@@ -0,0 +1,11 @@
+import { a as SyncStateChannelOptions, t as SyncStateBridge } from "./types-C18dHgLI.cjs";
+
+//#region src/renderer/react.d.ts
+interface UseSyncStateReactOptions extends SyncStateChannelOptions {
+  bridge?: SyncStateBridge;
+}
+type UseSyncStateReactResult<StateValue> = readonly [StateValue, (value: StateValue) => void, boolean];
+declare const useSyncState: <StateValue>(initialValue: StateValue, options: UseSyncStateReactOptions) => UseSyncStateReactResult<StateValue>;
+//#endregion
+export { UseSyncStateReactOptions, UseSyncStateReactResult, useSyncState, useSyncState as useSyncStateReact };
+//# sourceMappingURL=react.d.cts.map

package/dist/react.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.cts","names":[],"sources":["../src/renderer/react.ts"],"sourcesContent":[],"mappings":";;;UAOiB,wBAAA,SAAiC;EAAjC,MAAA,CAAA,EACN,eADM;AAIjB;AAca,KAdD,uBAkDX,CAAA,UAAA,CAAA,GAAA,SAAA,CAjDC,UAcc,EACL,CAAA,KAAA,EAdD,UAcC,EAAA,GAAA,IAAA,EACgB,OAAA,CAAxB;AAAuB,cAHb,YAGa,EAAA,CAAA,UAAA,CAAA,CAAA,YAAA,EAFV,UAEU,EAAA,OAAA,EADf,wBACe,EAAA,GAAvB,uBAAuB,CAAC,UAAD,CAAA"}

package/dist/react.d.ts

@@ -0,0 +1,11 @@
+import { a as SyncStateChannelOptions, t as SyncStateBridge } from "./types-7wPPX0ty.js";
+
+//#region src/renderer/react.d.ts
+interface UseSyncStateReactOptions extends SyncStateChannelOptions {
+  bridge?: SyncStateBridge;
+}
+type UseSyncStateReactResult<StateValue> = readonly [StateValue, (value: StateValue) => void, boolean];
+declare const useSyncState: <StateValue>(initialValue: StateValue, options: UseSyncStateReactOptions) => UseSyncStateReactResult<StateValue>;
+//#endregion
+export { UseSyncStateReactOptions, UseSyncStateReactResult, useSyncState, useSyncState as useSyncStateReact };
+//# sourceMappingURL=react.d.ts.map

package/dist/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","names":[],"sources":["../src/renderer/react.ts"],"sourcesContent":[],"mappings":";;;UAOiB,wBAAA,SAAiC;EAAjC,MAAA,CAAA,EACN,eADM;AAIjB;AAca,KAdD,uBAkDX,CAAA,UAAA,CAAA,GAAA,SAAA,CAjDC,UAcc,EACL,CAAA,KAAA,EAdD,UAcC,EAAA,GAAA,IAAA,EACgB,OAAA,CAAxB;AAAuB,cAHb,YAGa,EAAA,CAAA,UAAA,CAAA,CAAA,YAAA,EAFV,UAEU,EAAA,OAAA,EADf,wBACe,EAAA,GAAvB,uBAAuB,CAAC,UAAD,CAAA"}

package/dist/react.js

@@ -0,0 +1,46 @@
+import { a as resolveSyncStateBridge, t as getGlobalConfig } from "./renderer-C7zF3UQm.js";
+import { useCallback, useEffect, useMemo, useState } from "react";
+
+//#region src/renderer/react.ts
+const createChannelOptions = (options) => {
+	const globalConfig = getGlobalConfig();
+	return {
+		baseChannel: options.baseChannel ?? globalConfig.baseChannel,
+		name: options.name
+	};
+};
+const useSyncState = (initialValue, options) => {
+	const [stateValue, setStateValue] = useState(initialValue);
+	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 applyRemoteValue = useCallback((value) => {
+		setStateValue(value);
+		setIsSynced(true);
+	}, []);
+	const setAndSync = useCallback((value) => {
+		setStateValue(value);
+		bridge.set(channelOptions, value);
+	}, [bridge, channelOptions]);
+	useEffect(() => {
+		const unsubscribe = bridge.subscribe(channelOptions, applyRemoteValue);
+		bridge.get(channelOptions).then(applyRemoteValue);
+		return () => {
+			unsubscribe();
+		};
+	}, [
+		applyRemoteValue,
+		bridge,
+		channelOptions
+	]);
+	return [
+		stateValue,
+		setAndSync,
+		isSynced
+	];
+};
+
+//#endregion
+export { useSyncState, useSyncState as useSyncStateReact };
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","names":[],"sources":["../src/renderer/react.ts"],"sourcesContent":["import { useCallback, 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 UseSyncStateReactOptions extends SyncStateChannelOptions {\n  bridge?: SyncStateBridge;\n}\n\nexport type UseSyncStateReactResult<StateValue> = readonly [\n  StateValue,\n  (value: StateValue) => void,\n  boolean,\n];\n\nconst createChannelOptions = (options: UseSyncStateReactOptions): SyncStateChannelOptions => {\n  const globalConfig = getGlobalConfig();\n  return {\n    baseChannel: options.baseChannel ?? globalConfig.baseChannel,\n    name: options.name,\n  };\n};\n\nexport const useSyncState = <StateValue>(\n  initialValue: StateValue,\n  options: UseSyncStateReactOptions,\n): UseSyncStateReactResult<StateValue> => {\n  const [stateValue, setStateValue] = useState(initialValue);\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  const applyRemoteValue = useCallback((value: StateValue): void => {\n    setStateValue(value);\n    setIsSynced(true);\n  }, []);\n\n  const setAndSync = useCallback(\n    (value: StateValue): void => {\n      setStateValue(value);\n      void bridge.set(channelOptions, value);\n    },\n    [bridge, channelOptions],\n  );\n\n  useEffect(() => {\n    const unsubscribe = bridge.subscribe(channelOptions, applyRemoteValue);\n    void bridge.get<StateValue>(channelOptions).then(applyRemoteValue);\n\n    return () => {\n      unsubscribe();\n    };\n  }, [applyRemoteValue, bridge, channelOptions]);\n\n  return [stateValue, setAndSync, isSynced] as const;\n};\n\n// Backward compatibility alias\nexport { useSyncState as useSyncStateReact };\n"],"mappings":";;;;AAiBA,MAAM,wBAAwB,YAA+D;CAC3F,MAAM,eAAe,iBAAiB;AACtC,QAAO;EACL,aAAa,QAAQ,eAAe,aAAa;EACjD,MAAM,QAAQ;EACf;;AAGH,MAAa,gBACX,cACA,YACwC;CACxC,MAAM,CAAC,YAAY,iBAAiB,SAAS,aAAa;CAC1D,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;CAED,MAAM,mBAAmB,aAAa,UAA4B;AAChE,gBAAc,MAAM;AACpB,cAAY,KAAK;IAChB,EAAE,CAAC;CAEN,MAAM,aAAa,aAChB,UAA4B;AAC3B,gBAAc,MAAM;AACpB,EAAK,OAAO,IAAI,gBAAgB,MAAM;IAExC,CAAC,QAAQ,eAAe,CACzB;AAED,iBAAgB;EACd,MAAM,cAAc,OAAO,UAAU,gBAAgB,iBAAiB;AACtE,EAAK,OAAO,IAAgB,eAAe,CAAC,KAAK,iBAAiB;AAElE,eAAa;AACX,gBAAa;;IAEd;EAAC;EAAkB;EAAQ;EAAe,CAAC;AAE9C,QAAO;EAAC;EAAY;EAAY;EAAS"}

package/dist/redux.cjs

@@ -0,0 +1,148 @@
+const require_renderer = require('./renderer-D3YziJ_U.cjs');
+let react = require("react");
+let react_redux = require("react-redux");
+
+//#region src/renderer/redux.ts
+const createChannelOptions = (options) => {
+	const globalConfig = require_renderer.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 = require_renderer.getGlobalConfig();
+	const bridge = require_renderer.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] = (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]);
+	const actionType = (0, react.useMemo)(() => options.actionType || `${channelOptions.baseChannel}/${channelOptions.name}/set`, [
+		options.actionType,
+		channelOptions.baseChannel,
+		channelOptions.name
+	]);
+	const state = (0, react_redux.useSelector)((state$1) => options.selector ? options.selector(state$1) : state$1);
+	const dispatch = (0, react_redux.useDispatch)();
+	(0, react.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 = require_renderer.getGlobalConfig();
+	const bridge = require_renderer.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
+exports.createSyncActionCreator = createSyncActionCreator;
+exports.syncStateMiddleware = syncStateMiddleware;
+exports.useReduxSyncState = useSyncState;
+exports.useSyncState = useSyncState;

package/dist/redux.d.cts

@@ -0,0 +1,80 @@
+import { a as SyncStateChannelOptions, t as SyncStateBridge } from "./types-C18dHgLI.cjs";
+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.cts.map

package/dist/redux.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redux.d.cts","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"}