@yiin/reactive-proxy-state 1.0.22 → 1.0.24

package/dist/index.cjs

@@ -34856,6 +34856,9 @@ __export(exports_src, {
   isComputed: () => isComputed,
   deepEqual: () => deepEqual,
   deepClone: () => deepClone,
+  createRendererBridgeEmitter: () => createRendererBridgeEmitter,
+  createMainBridgeEmitter: () => createMainBridgeEmitter,
+  createBridgeEmitter: () => createBridgeEmitter,
   computed: () => computed,
   cleanupEffect: () => cleanupEffect,
   activeEffect: () => activeEffect
@@ -35986,6 +35989,80 @@ function wrapArray(arr, emit, path = []) {
             return result;
           };
           return methodCache[prop];
+        case "find": {
+          track(target, Symbol.iterator);
+          if (!methodCache[prop]) {
+            methodCache[prop] = function(predicate, thisArg) {
+              const idx = Array.prototype.findIndex.call(target, predicate, thisArg);
+              if (idx === -1)
+                return;
+              const value2 = target[idx];
+              if (!isObject2(value2))
+                return value2;
+              const propKey = String(idx);
+              const pathKey = path.length > 0 ? `${path.join(".")}.${propKey}` : propKey;
+              let newPath = getPathConcat(pathKey);
+              if (newPath === undefined) {
+                newPath = path.concat(propKey);
+                setPathConcat(pathKey, newPath);
+              }
+              if (globalSeen.has(value2))
+                return globalSeen.get(value2);
+              const cachedValueProxy = wrapperCache.get(value2);
+              if (cachedValueProxy)
+                return cachedValueProxy;
+              if (Array.isArray(value2))
+                return wrapArray(value2, emit, newPath);
+              if (value2 instanceof Map)
+                return wrapMap(value2, emit, newPath);
+              if (value2 instanceof Set)
+                return wrapSet(value2, emit, newPath);
+              if (value2 instanceof Date)
+                return new Date(value2.getTime());
+              return reactive(value2, emit, newPath);
+            };
+          }
+          return methodCache[prop];
+        }
+        case "at": {
+          track(target, Symbol.iterator);
+          if (!methodCache[prop]) {
+            methodCache[prop] = function(index) {
+              let idx = Number(index);
+              if (!Number.isInteger(idx))
+                idx = Math.trunc(idx);
+              if (idx < 0)
+                idx = target.length + idx;
+              if (idx < 0 || idx >= target.length)
+                return;
+              const value2 = target[idx];
+              if (!isObject2(value2))
+                return value2;
+              const propKey = String(idx);
+              const pathKey = path.length > 0 ? `${path.join(".")}.${propKey}` : propKey;
+              let newPath = getPathConcat(pathKey);
+              if (newPath === undefined) {
+                newPath = path.concat(propKey);
+                setPathConcat(pathKey, newPath);
+              }
+              if (globalSeen.has(value2))
+                return globalSeen.get(value2);
+              const cachedValueProxy = wrapperCache.get(value2);
+              if (cachedValueProxy)
+                return cachedValueProxy;
+              if (Array.isArray(value2))
+                return wrapArray(value2, emit, newPath);
+              if (value2 instanceof Map)
+                return wrapMap(value2, emit, newPath);
+              if (value2 instanceof Set)
+                return wrapSet(value2, emit, newPath);
+              if (value2 instanceof Date)
+                return new Date(value2.getTime());
+              return reactive(value2, emit, newPath);
+            };
+          }
+          return methodCache[prop];
+        }
         case Symbol.iterator:
         case "values":
         case "keys":
@@ -35995,7 +36072,6 @@ function wrapArray(arr, emit, path = []) {
         case "filter":
         case "reduce":
         case "reduceRight":
-        case "find":
         case "findIndex":
         case "every":
         case "some":
@@ -36487,3 +36563,94 @@ function trackVueReactiveEvents(vueState, emit, options = {}) {
   }
   return stop;
 }
+// src/integrations/electron-bridge.ts
+function makeTx() {
+  try {
+    const g = globalThis;
+    if (g.crypto && typeof g.crypto.randomUUID === "function") {
+      return g.crypto.randomUUID();
+    }
+  } catch {}
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function createBridgeEmitter(opts) {
+  const { id, apply, send, onMessage, forward, seenLimit = 1000 } = opts;
+  let muteCount = 0;
+  const mute = (fn) => {
+    muteCount++;
+    try {
+      return fn();
+    } finally {
+      muteCount--;
+    }
+  };
+  const seen = new Set;
+  const order = [];
+  const markSeen = (tx) => {
+    if (seen.has(tx))
+      return;
+    seen.add(tx);
+    order.push(tx);
+    if (order.length > seenLimit) {
+      const oldest = order.shift();
+      seen.delete(oldest);
+    }
+  };
+  const emit = (event) => {
+    if (muteCount > 0)
+      return;
+    const msg = { tx: makeTx(), origin: id, event };
+    markSeen(msg.tx);
+    send(msg);
+  };
+  const unsubscribe = onMessage((msg, ctx) => {
+    if (!msg || !msg.tx)
+      return;
+    if (seen.has(msg.tx))
+      return;
+    markSeen(msg.tx);
+    if (msg.origin === id)
+      return;
+    mute(() => apply(msg.event));
+    if (forward)
+      forward(msg, ctx);
+  });
+  const stop = () => unsubscribe();
+  return { emit, stop, mute };
+}
+function createRendererBridgeEmitter(opts) {
+  const { id, channel, ipcRenderer, apply, seenLimit } = opts;
+  return createBridgeEmitter({
+    id,
+    apply,
+    seenLimit,
+    send: (msg) => ipcRenderer.send(channel, msg),
+    onMessage: (cb) => {
+      const handler = (_e, msg) => cb(msg);
+      ipcRenderer.on(channel, handler);
+      return () => ipcRenderer.off(channel, handler);
+    }
+  });
+}
+function createMainBridgeEmitter(opts) {
+  const { id = "main", channel, ipcMain, windows, apply, seenLimit } = opts;
+  const broadcast = (msg, exceptId) => {
+    for (const w of windows()) {
+      if (exceptId != null && w.webContents.id === exceptId)
+        continue;
+      w.webContents.send(channel, msg);
+    }
+  };
+  return createBridgeEmitter({
+    id,
+    apply,
+    seenLimit,
+    send: (msg) => broadcast(msg),
+    onMessage: (cb) => {
+      const handler = (e, msg) => cb(msg, { senderId: e?.sender?.id });
+      ipcMain.on(channel, handler);
+      return () => ipcMain.off(channel, handler);
+    },
+    forward: (msg, ctx) => broadcast(msg, ctx?.senderId)
+  });
+}

package/dist/index.d.ts

@@ -8,3 +8,4 @@ export * from './ref';
 export * from './computed';
 export * from './mark-raw';
 export * from './integrations/vue3';
+export * from './integrations/electron-bridge';

package/dist/index.js

@@ -35930,6 +35930,80 @@ function wrapArray(arr, emit, path = []) {
             return result;
           };
           return methodCache[prop];
+        case "find": {
+          track(target, Symbol.iterator);
+          if (!methodCache[prop]) {
+            methodCache[prop] = function(predicate, thisArg) {
+              const idx = Array.prototype.findIndex.call(target, predicate, thisArg);
+              if (idx === -1)
+                return;
+              const value2 = target[idx];
+              if (!isObject2(value2))
+                return value2;
+              const propKey = String(idx);
+              const pathKey = path.length > 0 ? `${path.join(".")}.${propKey}` : propKey;
+              let newPath = getPathConcat(pathKey);
+              if (newPath === undefined) {
+                newPath = path.concat(propKey);
+                setPathConcat(pathKey, newPath);
+              }
+              if (globalSeen.has(value2))
+                return globalSeen.get(value2);
+              const cachedValueProxy = wrapperCache.get(value2);
+              if (cachedValueProxy)
+                return cachedValueProxy;
+              if (Array.isArray(value2))
+                return wrapArray(value2, emit, newPath);
+              if (value2 instanceof Map)
+                return wrapMap(value2, emit, newPath);
+              if (value2 instanceof Set)
+                return wrapSet(value2, emit, newPath);
+              if (value2 instanceof Date)
+                return new Date(value2.getTime());
+              return reactive(value2, emit, newPath);
+            };
+          }
+          return methodCache[prop];
+        }
+        case "at": {
+          track(target, Symbol.iterator);
+          if (!methodCache[prop]) {
+            methodCache[prop] = function(index) {
+              let idx = Number(index);
+              if (!Number.isInteger(idx))
+                idx = Math.trunc(idx);
+              if (idx < 0)
+                idx = target.length + idx;
+              if (idx < 0 || idx >= target.length)
+                return;
+              const value2 = target[idx];
+              if (!isObject2(value2))
+                return value2;
+              const propKey = String(idx);
+              const pathKey = path.length > 0 ? `${path.join(".")}.${propKey}` : propKey;
+              let newPath = getPathConcat(pathKey);
+              if (newPath === undefined) {
+                newPath = path.concat(propKey);
+                setPathConcat(pathKey, newPath);
+              }
+              if (globalSeen.has(value2))
+                return globalSeen.get(value2);
+              const cachedValueProxy = wrapperCache.get(value2);
+              if (cachedValueProxy)
+                return cachedValueProxy;
+              if (Array.isArray(value2))
+                return wrapArray(value2, emit, newPath);
+              if (value2 instanceof Map)
+                return wrapMap(value2, emit, newPath);
+              if (value2 instanceof Set)
+                return wrapSet(value2, emit, newPath);
+              if (value2 instanceof Date)
+                return new Date(value2.getTime());
+              return reactive(value2, emit, newPath);
+            };
+          }
+          return methodCache[prop];
+        }
         case Symbol.iterator:
         case "values":
         case "keys":
@@ -35939,7 +36013,6 @@ function wrapArray(arr, emit, path = []) {
         case "filter":
         case "reduce":
         case "reduceRight":
-        case "find":
         case "findIndex":
         case "every":
         case "some":
@@ -36431,6 +36504,97 @@ function trackVueReactiveEvents(vueState, emit, options = {}) {
   }
   return stop;
 }
+// src/integrations/electron-bridge.ts
+function makeTx() {
+  try {
+    const g = globalThis;
+    if (g.crypto && typeof g.crypto.randomUUID === "function") {
+      return g.crypto.randomUUID();
+    }
+  } catch {}
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function createBridgeEmitter(opts) {
+  const { id, apply, send, onMessage, forward, seenLimit = 1000 } = opts;
+  let muteCount = 0;
+  const mute = (fn) => {
+    muteCount++;
+    try {
+      return fn();
+    } finally {
+      muteCount--;
+    }
+  };
+  const seen = new Set;
+  const order = [];
+  const markSeen = (tx) => {
+    if (seen.has(tx))
+      return;
+    seen.add(tx);
+    order.push(tx);
+    if (order.length > seenLimit) {
+      const oldest = order.shift();
+      seen.delete(oldest);
+    }
+  };
+  const emit = (event) => {
+    if (muteCount > 0)
+      return;
+    const msg = { tx: makeTx(), origin: id, event };
+    markSeen(msg.tx);
+    send(msg);
+  };
+  const unsubscribe = onMessage((msg, ctx) => {
+    if (!msg || !msg.tx)
+      return;
+    if (seen.has(msg.tx))
+      return;
+    markSeen(msg.tx);
+    if (msg.origin === id)
+      return;
+    mute(() => apply(msg.event));
+    if (forward)
+      forward(msg, ctx);
+  });
+  const stop = () => unsubscribe();
+  return { emit, stop, mute };
+}
+function createRendererBridgeEmitter(opts) {
+  const { id, channel, ipcRenderer, apply, seenLimit } = opts;
+  return createBridgeEmitter({
+    id,
+    apply,
+    seenLimit,
+    send: (msg) => ipcRenderer.send(channel, msg),
+    onMessage: (cb) => {
+      const handler = (_e, msg) => cb(msg);
+      ipcRenderer.on(channel, handler);
+      return () => ipcRenderer.off(channel, handler);
+    }
+  });
+}
+function createMainBridgeEmitter(opts) {
+  const { id = "main", channel, ipcMain, windows, apply, seenLimit } = opts;
+  const broadcast = (msg, exceptId) => {
+    for (const w of windows()) {
+      if (exceptId != null && w.webContents.id === exceptId)
+        continue;
+      w.webContents.send(channel, msg);
+    }
+  };
+  return createBridgeEmitter({
+    id,
+    apply,
+    seenLimit,
+    send: (msg) => broadcast(msg),
+    onMessage: (cb) => {
+      const handler = (e, msg) => cb(msg, { senderId: e?.sender?.id });
+      ipcMain.on(channel, handler);
+      return () => ipcMain.off(channel, handler);
+    },
+    forward: (msg, ctx) => broadcast(msg, ctx?.senderId)
+  });
+}
 export {
   watchEffect,
   watch,
@@ -36454,6 +36618,9 @@ export {
   isComputed,
   deepEqual,
   deepClone,
+  createRendererBridgeEmitter,
+  createMainBridgeEmitter,
+  createBridgeEmitter,
   computed,
   cleanupEffect,
   activeEffect

package/dist/integrations/electron-bridge.d.ts

@@ -0,0 +1,71 @@
+import type { StateEvent } from "../types";
+export type BridgeMessage = {
+    tx: string;
+    origin: string;
+    event: StateEvent;
+};
+type OnMessage = (cb: (msg: BridgeMessage, ctx?: any) => void) => () => void;
+type Send = (msg: BridgeMessage, ctx?: any) => void;
+type Forward = (msg: BridgeMessage, ctx?: any) => void;
+/**
+ * Create a loop-safe bridge emitter for bi-directional sync.
+ * - Tags every message with tx + origin
+ * - Mutes emit while applying remote updates
+ * - Dedupe by tx using a small LRU
+ */
+export declare function createBridgeEmitter(opts: {
+    id: string;
+    apply: (event: StateEvent) => void;
+    send: Send;
+    onMessage: OnMessage;
+    forward?: Forward;
+    seenLimit?: number;
+}): {
+    emit: (event: StateEvent) => void;
+    stop: () => void;
+    mute: <T>(fn: () => T) => T;
+};
+/**
+ * Renderer-side bridge bound to Electron's ipcRenderer.
+ * Keep this generic by accepting a minimal ipcRenderer-like object.
+ */
+export declare function createRendererBridgeEmitter(opts: {
+    id: string;
+    channel: string;
+    ipcRenderer: {
+        send: (channel: string, msg: any) => void;
+        on: (channel: string, handler: (event: any, msg: any) => void) => void;
+        off: (channel: string, handler: (event: any, msg: any) => void) => void;
+    };
+    apply: (event: StateEvent) => void;
+    seenLimit?: number;
+}): {
+    emit: (event: StateEvent) => void;
+    stop: () => void;
+    mute: <T>(fn: () => T) => T;
+};
+/**
+ * Main-process bridge bound to Electron's ipcMain and BrowserWindows.
+ * Accepts a provider for windows to avoid importing Electron types.
+ */
+export declare function createMainBridgeEmitter(opts: {
+    id?: string;
+    channel: string;
+    ipcMain: {
+        on: (channel: string, handler: (event: any, msg: any) => void) => void;
+        off: (channel: string, handler: (event: any, msg: any) => void) => void;
+    };
+    windows: () => {
+        webContents: {
+            id: number;
+            send: (channel: string, msg: any) => void;
+        };
+    }[];
+    apply: (event: StateEvent) => void;
+    seenLimit?: number;
+}): {
+    emit: (event: StateEvent) => void;
+    stop: () => void;
+    mute: <T>(fn: () => T) => T;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yiin/reactive-proxy-state",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "author": "Yiin <stanislovas@yiin.lt>",
   "repository": {
     "type": "git",