electron-pinia-sync 1.0.0 → 1.2.0

package/dist/main/index.d.cts

@@ -0,0 +1,153 @@
+import { StateTree, Pinia, Store as Store$1 } from 'pinia';
+import Store from 'electron-store';
+
+/**
+ * Common types shared across Main, Renderer, and Preload processes
+ */
+
+/**
+ * Debug level configuration
+ */
+type DebugLevel$1 = boolean | 'verbose' | 'minimal';
+/**
+ * Message sent from Main to Renderer when state is updated
+ */
+interface StateUpdateMessage {
+    /** Store ID */
+    storeId: string;
+    /** New state */
+    state: StateTree;
+    /** Transaction ID that caused this update (if any) */
+    transactionId?: string;
+}
+/**
+ * Options for configuring store persistence
+ */
+interface PersistOptions {
+    /** Whether to persist this store to disk */
+    enabled: boolean;
+    /** Optional custom key for electron-store (defaults to storeId) */
+    key?: string;
+}
+/**
+ * API exposed to Renderer via contextBridge
+ */
+interface PiniaSyncAPI {
+    /**
+     * Pull initial state from Main process
+     */
+    pullState: (storeId: string) => Promise<StateTree | null>;
+    /**
+     * Send state patch to Main process
+     */
+    patchState: (storeId: string, patch: Partial<StateTree>, transactionId: string) => Promise<void>;
+    /**
+     * Subscribe to state updates from Main process
+     */
+    onStateUpdate: (callback: (message: StateUpdateMessage) => void) => () => void;
+}
+declare global {
+    interface Window {
+        piniaSync?: PiniaSyncAPI;
+    }
+}
+
+/**
+ * Debug utilities for electron-pinia-sync
+ *
+ * Enable debug logging programmatically:
+ * - { debug: true } - enable debug logging
+ * - { debug: 'verbose' } - enable verbose logging with state diffs
+ * - { debug: 'minimal' } - only log errors and warnings
+ */
+type DebugLevel = boolean | 'verbose' | 'minimal';
+interface DebugLogger {
+    log: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+    debug: (message: string, ...args: unknown[]) => void;
+    verbose: (message: string, ...args: unknown[]) => void;
+}
+/**
+ * Create a debug logger for a specific namespace
+ */
+declare function createDebugLogger(namespace: string, debugLevel?: DebugLevel, customLogger?: Partial<DebugLogger>): DebugLogger;
+/**
+ * Format state for debug output (truncate large objects)
+ */
+declare function formatStateForDebug(state: unknown, maxLength?: number): string;
+/**
+ * Format patch for debug output
+ */
+declare function formatPatchForDebug(patch: unknown): string;
+
+interface MainSyncOptions {
+    /**
+     * electron-store configuration options
+     */
+    storeOptions?: ConstructorParameters<typeof Store<Record<string, StateTree>>>[0];
+    /**
+     * Custom Pinia instance (optional, will create one if not provided)
+     */
+    pinia?: Pinia;
+    /**
+     * Enable debug logging
+     * - true: enable debug logging
+     * - 'verbose': enable verbose logging with state diffs
+     * - 'minimal': only log errors and warnings
+     * - false: disable debug logging (default)
+     */
+    debug?: DebugLevel$1;
+    /**
+     * Custom logger (for testing or custom logging)
+     */
+    logger?: Partial<DebugLogger>;
+}
+
+/**
+ * Main process synchronization manager
+ * Manages Pinia stores in the Main process and handles IPC communication
+ */
+
+declare class MainSync {
+    private pinia;
+    private electronStore;
+    private storeMetadata;
+    private processingTransactions;
+    private readonly MAX_TRANSACTION_HISTORY;
+    private debug;
+    constructor(options?: MainSyncOptions);
+    /**
+     * Get the Pinia instance managed by this sync manager
+     */
+    getPinia(): Pinia;
+    /**
+     * Register a store with the sync manager
+     */
+    registerStore(storeId: string, store: Store$1, options?: {
+        persist?: boolean | PersistOptions;
+    }): void;
+    /**
+     * Normalize persist options to standard format
+     */
+    private normalizePersistOptions;
+    /**
+     * Setup IPC handlers for communication with renderers
+     */
+    private setupIpcHandlers;
+    private addTransaction;
+    /**
+     * Broadcast state update to all renderer processes
+     */
+    private broadcastStateUpdate;
+    /**
+     * Cleanup IPC handlers
+     */
+    destroy(): void;
+}
+/**
+ * Create and initialize the Main process sync manager
+ */
+declare function createMainSync(options?: MainSyncOptions): MainSync;
+
+export { type DebugLevel, type DebugLogger, MainSync, createDebugLogger, createMainSync, formatPatchForDebug, formatStateForDebug };

package/dist/main/index.js

@@ -1,8 +1,7 @@
-import { ipcMain, BrowserWindow } from 'electron';
-import { createPinia } from 'pinia';
-import Store from 'electron-store';
-
 // src/main/index.ts
+import { BrowserWindow, ipcMain } from "electron";
+import { createPinia } from "pinia";
+import Store from "electron-store";
 
 // src/types.ts
 var IPC_CHANNELS = {
@@ -11,7 +10,10 @@ var IPC_CHANNELS = {
   /** Renderer sends patch to Main */
   STATE_PATCH: "pinia-sync:state-patch",
   /** Main broadcasts state update to all Renderers */
-  STATE_UPDATED: "pinia-sync:state-updated"};
+  STATE_UPDATED: "pinia-sync:state-updated",
+  /** Renderer requests full state sync */
+  STATE_SYNC: "pinia-sync:state-sync"
+};
 
 // src/debug.ts
 function createDebugLogger(namespace, debugLevel = false, customLogger) {
@@ -216,6 +218,10 @@ var MainSync = class {
 function createMainSync(options) {
   return new MainSync(options);
 }
-console.log("main sync plugin loaded");
-
-export { MainSync, createDebugLogger, createMainSync, formatPatchForDebug, formatStateForDebug };
+export {
+  MainSync,
+  createDebugLogger,
+  createMainSync,
+  formatPatchForDebug,
+  formatStateForDebug
+};

package/dist/preload/index.cjs

@@ -0,0 +1,63 @@
+"use strict";
+
+// src/preload/index.ts
+var import_electron = require("electron");
+
+// src/types.ts
+var IPC_CHANNELS = {
+  /** Renderer requests initial state from Main */
+  STATE_PULL: "pinia-sync:state-pull",
+  /** Renderer sends patch to Main */
+  STATE_PATCH: "pinia-sync:state-patch",
+  /** Main broadcasts state update to all Renderers */
+  STATE_UPDATED: "pinia-sync:state-updated",
+  /** Renderer requests full state sync */
+  STATE_SYNC: "pinia-sync:state-sync"
+};
+
+// src/preload/index.ts
+var piniaSyncAPI = {
+  /**
+   * Pull initial state from Main process
+   */
+  async pullState(storeId) {
+    console.log(`[preload] IPC invoke: ${IPC_CHANNELS.STATE_PULL} for store "${storeId}"`);
+    const request = { storeId };
+    const response = await import_electron.ipcRenderer.invoke(
+      IPC_CHANNELS.STATE_PULL,
+      request
+    );
+    console.log(`[preload] IPC response: STATE_PULL for "${storeId}" - state:`, response.state ? "received" : "null");
+    return response.state;
+  },
+  /**
+   * Send state patch to Main process
+   */
+  async patchState(storeId, patch, transactionId) {
+    console.log(`[preload] IPC invoke: ${IPC_CHANNELS.STATE_PATCH} for store "${storeId}", transaction: ${transactionId}`);
+    const message = {
+      storeId,
+      patch,
+      transactionId
+    };
+    await import_electron.ipcRenderer.invoke(IPC_CHANNELS.STATE_PATCH, message);
+    console.log(`[preload] IPC response: STATE_PATCH for "${storeId}" completed`);
+  },
+  /**
+   * Subscribe to state updates from Main process
+   */
+  onStateUpdate(callback) {
+    console.log(`[preload] IPC listener registered: ${IPC_CHANNELS.STATE_UPDATED}`);
+    const listener = (_event, message) => {
+      console.log(`[preload] IPC event received: ${IPC_CHANNELS.STATE_UPDATED} for store "${message.storeId}", transaction: ${message.transactionId || "none"}`);
+      callback(message);
+    };
+    import_electron.ipcRenderer.on(IPC_CHANNELS.STATE_UPDATED, listener);
+    return () => {
+      console.log(`[preload] IPC listener removed: ${IPC_CHANNELS.STATE_UPDATED}`);
+      import_electron.ipcRenderer.removeListener(IPC_CHANNELS.STATE_UPDATED, listener);
+    };
+  }
+};
+import_electron.contextBridge.exposeInMainWorld("piniaSync", piniaSyncAPI);
+console.log("[preload] piniaSync API exposed to window");

package/dist/preload/index.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/preload/index.js

@@ -1,6 +1,5 @@
-import { contextBridge, ipcRenderer } from 'electron';
-
 // src/preload/index.ts
+import { contextBridge, ipcRenderer } from "electron";
 
 // src/types.ts
 var IPC_CHANNELS = {
@@ -9,7 +8,10 @@ var IPC_CHANNELS = {
   /** Renderer sends patch to Main */
   STATE_PATCH: "pinia-sync:state-patch",
   /** Main broadcasts state update to all Renderers */
-  STATE_UPDATED: "pinia-sync:state-updated"};
+  STATE_UPDATED: "pinia-sync:state-updated",
+  /** Renderer requests full state sync */
+  STATE_SYNC: "pinia-sync:state-sync"
+};
 
 // src/preload/index.ts
 var piniaSyncAPI = {
@@ -57,4 +59,3 @@ var piniaSyncAPI = {
 };
 contextBridge.exposeInMainWorld("piniaSync", piniaSyncAPI);
 console.log("[preload] piniaSync API exposed to window");
-console.log("[preload] electron-pinia-sync preload script initialized");

package/dist/renderer/index.cjs

@@ -0,0 +1,268 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/renderer/index.ts
+var renderer_exports = {};
+__export(renderer_exports, {
+  createDebugLogger: () => createDebugLogger,
+  createRendererSync: () => createRendererSync,
+  formatPatchForDebug: () => formatPatchForDebug,
+  formatStateForDebug: () => formatStateForDebug
+});
+module.exports = __toCommonJS(renderer_exports);
+
+// node_modules/microdiff/dist/index.js
+var richTypes = { Date: true, RegExp: true, String: true, Number: true };
+function diff(obj, newObj, options = { cyclesFix: true }, _stack = []) {
+  let diffs = [];
+  const isObjArray = Array.isArray(obj);
+  for (const key in obj) {
+    const objKey = obj[key];
+    const path = isObjArray ? +key : key;
+    if (!(key in newObj)) {
+      diffs.push({
+        type: "REMOVE",
+        path: [path],
+        oldValue: obj[key]
+      });
+      continue;
+    }
+    const newObjKey = newObj[key];
+    const areCompatibleObjects = typeof objKey === "object" && typeof newObjKey === "object" && Array.isArray(objKey) === Array.isArray(newObjKey);
+    if (objKey && newObjKey && areCompatibleObjects && !richTypes[Object.getPrototypeOf(objKey)?.constructor?.name] && (!options.cyclesFix || !_stack.includes(objKey))) {
+      diffs.push.apply(diffs, diff(objKey, newObjKey, options, options.cyclesFix ? _stack.concat([objKey]) : []).map((difference) => {
+        difference.path.unshift(path);
+        return difference;
+      }));
+    } else if (objKey !== newObjKey && // treat NaN values as equivalent
+    !(Number.isNaN(objKey) && Number.isNaN(newObjKey)) && !(areCompatibleObjects && (isNaN(objKey) ? objKey + "" === newObjKey + "" : +objKey === +newObjKey))) {
+      diffs.push({
+        path: [path],
+        type: "CHANGE",
+        value: newObjKey,
+        oldValue: objKey
+      });
+    }
+  }
+  const isNewObjArray = Array.isArray(newObj);
+  for (const key in newObj) {
+    if (!(key in obj)) {
+      diffs.push({
+        type: "CREATE",
+        path: [isNewObjArray ? +key : key],
+        value: newObj[key]
+      });
+    }
+  }
+  return diffs;
+}
+
+// src/debug.ts
+function createDebugLogger(namespace, debugLevel = false, customLogger) {
+  const isEnabled = debugLevel !== false;
+  const isVerbose = debugLevel === "verbose" || debugLevel === true;
+  const prefix = `[${namespace}]`;
+  const noop = () => {
+  };
+  const logger = customLogger || console;
+  return {
+    log: logger.log?.bind(logger, prefix) || console.log.bind(console, prefix),
+    warn: logger.warn?.bind(logger, prefix) || console.warn.bind(console, prefix),
+    error: logger.error?.bind(logger, prefix) || console.error.bind(console, prefix),
+    debug: isEnabled ? logger.log?.bind(logger, prefix) || console.log.bind(console, prefix) : noop,
+    verbose: isVerbose ? logger.log?.bind(logger, `${prefix}[VERBOSE]`) || console.log.bind(console, `${prefix}[VERBOSE]`) : noop
+  };
+}
+function formatStateForDebug(state, maxLength = 200) {
+  try {
+    const json = JSON.stringify(state);
+    if (json.length > maxLength) {
+      return json.substring(0, maxLength) + `... (${json.length} chars total)`;
+    }
+    return json;
+  } catch {
+    return "[Circular or non-serializable]";
+  }
+}
+function formatPatchForDebug(patch) {
+  try {
+    const keys = Object.keys(patch);
+    if (keys.length === 0) {
+      return "{}";
+    }
+    if (keys.length > 5) {
+      return `{ ${keys.slice(0, 5).join(", ")}, ... (${keys.length} keys) }`;
+    }
+    return JSON.stringify(patch, null, 2);
+  } catch {
+    return "[Invalid patch]";
+  }
+}
+
+// src/utils/toRawState.ts
+function toRawState(state) {
+  return JSON.parse(JSON.stringify(state));
+}
+
+// src/renderer/index.ts
+function generateTransactionId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+function calculatePatch(oldState, newState, mutation) {
+  const differences = diff(oldState, newState);
+  if (differences.length === 0) {
+    return extractPatchFromMutation(mutation, newState);
+  }
+  const patch = {};
+  for (const change of differences) {
+    if (change.path.length === 0) {
+      return newState;
+    }
+    const topLevelKey = change.path[0];
+    if (typeof topLevelKey === "string" || typeof topLevelKey === "number") {
+      patch[topLevelKey] = newState[topLevelKey];
+    }
+  }
+  return Object.keys(patch).length > 0 ? patch : extractPatchFromMutation(mutation, newState);
+}
+function extractPatchFromMutation(mutation, state) {
+  if (mutation.type === "patch object") {
+    return mutation.payload;
+  } else if (mutation.type === "patch function") {
+    return state;
+  } else if (mutation.type === "direct") {
+    const patch = {};
+    const events = mutation.events;
+    if (events && Array.isArray(events) && events.length > 0) {
+      const firstEvent = events[0];
+      const key = firstEvent?.key;
+      if (typeof key === "string" && key in state) {
+        patch[key] = state[key];
+        return patch;
+      }
+    }
+    return state;
+  } else {
+    return state;
+  }
+}
+function createRendererSync(options = {}) {
+  const debug = createDebugLogger("electron-pinia-sync:renderer", options.debug ?? false, options.logger);
+  debug.debug("Initializing RendererSync");
+  let api = options.customApi;
+  if (!api) {
+    if (typeof window !== "undefined" && window.piniaSync) {
+      api = window.piniaSync;
+    } else if (typeof globalThis !== "undefined" && globalThis.window?.piniaSync) {
+      api = globalThis.window.piniaSync;
+    }
+  }
+  if (!api) {
+    debug.error("window.piniaSync is not available. Make sure the preload script is loaded correctly.");
+    throw new Error("Pinia sync API not available");
+  }
+  debug.debug("Pinia sync API found");
+  const processingTransactions = /* @__PURE__ */ new Set();
+  return function rendererSyncPlugin(context) {
+    const { store } = context;
+    debug.debug(`Initializing sync for store: ${store.$id}`);
+    let isApplyingRemoteUpdate = false;
+    let previousState = toRawState(store.$state);
+    const initializeState = async () => {
+      debug.debug(`Pulling initial state for store: ${store.$id}`);
+      try {
+        const state = await api.pullState(store.$id);
+        if (state !== null) {
+          debug.verbose(`Received initial state for ${store.$id}:`, formatStateForDebug(state));
+          isApplyingRemoteUpdate = true;
+          store.$patch(state);
+          previousState = toRawState(store.$state);
+          isApplyingRemoteUpdate = false;
+          debug.debug(`Successfully initialized state for store: ${store.$id}`);
+        } else {
+          debug.debug(`No initial state available for store: ${store.$id}`);
+        }
+      } catch (error) {
+        debug.error(`Failed to pull initial state for store "${store.$id}":`, error);
+      }
+    };
+    const subscribeToLocalChanges = () => {
+      debug.debug(`Subscribing to local changes for store: ${store.$id}`);
+      store.$subscribe((mutation, state) => {
+        if (isApplyingRemoteUpdate) {
+          debug.verbose(`Skipping sync for ${store.$id} (applying remote update)`);
+          return;
+        }
+        debug.verbose(`Local state changed for ${store.$id}, mutation type: ${mutation.type}`);
+        const patch = calculatePatch(previousState, state, mutation);
+        previousState = toRawState(state);
+        if (Object.keys(patch).length === 0) {
+          debug.verbose(`No changes detected for ${store.$id}, skipping sync`);
+          return;
+        }
+        debug.verbose(`Calculated patch for ${store.$id}:`, formatPatchForDebug(patch));
+        const transactionId = generateTransactionId();
+        debug.debug(`Syncing patch to Main (transaction: ${transactionId})`);
+        processingTransactions.add(transactionId);
+        const rawPatch = toRawState(patch);
+        api.patchState(store.$id, rawPatch, transactionId).catch((error) => {
+          debug.error(`Failed to sync state for store "${store.$id}":`, error);
+        }).finally(() => {
+          setTimeout(() => {
+            processingTransactions.delete(transactionId);
+          }, 100);
+        });
+      }, { detached: true });
+    };
+    const subscribeToRemoteUpdates = () => {
+      debug.debug(`Subscribing to remote updates for store: ${store.$id}`);
+      const unsubscribe = api.onStateUpdate((message) => {
+        if (message.storeId !== store.$id) {
+          return;
+        }
+        debug.verbose(`Received remote update for ${store.$id}`, message.transactionId ? `(transaction: ${message.transactionId})` : "");
+        if (message.transactionId && processingTransactions.has(message.transactionId)) {
+          debug.verbose(`Skipping echo update for ${store.$id} (transaction: ${message.transactionId})`);
+          return;
+        }
+        debug.verbose(`Applying remote state to ${store.$id}:`, formatStateForDebug(message.state));
+        isApplyingRemoteUpdate = true;
+        store.$patch(message.state);
+        previousState = toRawState(store.$state);
+        isApplyingRemoteUpdate = false;
+        debug.debug(`Successfully applied remote update to store: ${store.$id}`);
+      });
+      store._piniaSync_unsubscribe = unsubscribe;
+    };
+    debug.debug(`Initializing store synchronization for: ${store.$id}`);
+    initializeState();
+    subscribeToLocalChanges();
+    subscribeToRemoteUpdates();
+    debug.debug(`Store ${store.$id} sync setup complete`);
+    const originalDispose = store.$dispose.bind(store);
+    store.$dispose = () => {
+      debug.debug(`Disposing store: ${store.$id}`);
+      const unsubscribe = store._piniaSync_unsubscribe;
+      if (unsubscribe) {
+        unsubscribe();
+      }
+      originalDispose();
+    };
+  };
+}

package/dist/renderer/index.d.cts

@@ -0,0 +1,123 @@
+import { StateTree, PiniaPluginContext } from 'pinia';
+
+/**
+ * Common types shared across Main, Renderer, and Preload processes
+ */
+
+/**
+ * Debug level configuration
+ */
+type DebugLevel$1 = boolean | 'verbose' | 'minimal';
+/**
+ * Message sent from Main to Renderer when state is updated
+ */
+interface StateUpdateMessage {
+    /** Store ID */
+    storeId: string;
+    /** New state */
+    state: StateTree;
+    /** Transaction ID that caused this update (if any) */
+    transactionId?: string;
+}
+/**
+ * Options for configuring store persistence
+ */
+interface PersistOptions {
+    /** Whether to persist this store to disk */
+    enabled: boolean;
+    /** Optional custom key for electron-store (defaults to storeId) */
+    key?: string;
+}
+/**
+ * Extended Pinia store options with persistence support
+ */
+interface SyncStoreOptions {
+    /** Persistence configuration */
+    persist?: boolean | PersistOptions;
+}
+/**
+ * API exposed to Renderer via contextBridge
+ */
+interface PiniaSyncAPI {
+    /**
+     * Pull initial state from Main process
+     */
+    pullState: (storeId: string) => Promise<StateTree | null>;
+    /**
+     * Send state patch to Main process
+     */
+    patchState: (storeId: string, patch: Partial<StateTree>, transactionId: string) => Promise<void>;
+    /**
+     * Subscribe to state updates from Main process
+     */
+    onStateUpdate: (callback: (message: StateUpdateMessage) => void) => () => void;
+}
+declare global {
+    interface Window {
+        piniaSync?: PiniaSyncAPI;
+    }
+}
+
+/**
+ * Debug utilities for electron-pinia-sync
+ *
+ * Enable debug logging programmatically:
+ * - { debug: true } - enable debug logging
+ * - { debug: 'verbose' } - enable verbose logging with state diffs
+ * - { debug: 'minimal' } - only log errors and warnings
+ */
+type DebugLevel = boolean | 'verbose' | 'minimal';
+interface DebugLogger {
+    log: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+    debug: (message: string, ...args: unknown[]) => void;
+    verbose: (message: string, ...args: unknown[]) => void;
+}
+/**
+ * Create a debug logger for a specific namespace
+ */
+declare function createDebugLogger(namespace: string, debugLevel?: DebugLevel, customLogger?: Partial<DebugLogger>): DebugLogger;
+/**
+ * Format state for debug output (truncate large objects)
+ */
+declare function formatStateForDebug(state: unknown, maxLength?: number): string;
+/**
+ * Format patch for debug output
+ */
+declare function formatPatchForDebug(patch: unknown): string;
+
+/**
+ * Options for the renderer sync plugin
+ */
+interface RendererSyncOptions {
+    /**
+     * Enable debug logging
+     * - true: enable debug logging
+     * - 'verbose': enable verbose logging with state diffs
+     * - 'minimal': only log errors and warnings
+     * - false: disable debug logging (default)
+     */
+    debug?: DebugLevel$1;
+    /**
+     * Custom logger (default: console)
+     */
+    logger?: Partial<DebugLogger>;
+    /**
+     * Custom API implementation (for testing)
+     * @internal
+     */
+    customApi?: PiniaSyncAPI;
+}
+
+/**
+ * Renderer process Pinia plugin
+ * Synchronizes local store changes with Main process and receives updates
+ */
+
+/**
+ * Create the Pinia plugin for renderer process synchronization
+ */
+declare function createRendererSync(options?: RendererSyncOptions): (context: PiniaPluginContext) => void;
+
+export { type DebugLevel, type DebugLogger, type SyncStoreOptions, createDebugLogger, createRendererSync, formatPatchForDebug, formatStateForDebug };