@meerkapp/electron-bridge 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 meerkapp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,93 @@
+# @meerkapp/electron-bridge
+
+Bridge between Electron main process and PWA renderer for the Meerk warehouse management system. Provides SQLite persistence via a UtilityProcess with a MessageChannel-based IPC API and a SignalDB storage adapter.
+
+## Installation
+
+```sh
+pnpm add @meerkapp/electron-bridge
+```
+
+> **Note:** `better-sqlite3` requires native compilation. After installing, run:
+> ```sh
+> npx @electron/rebuild
+> ```
+
+## Usage
+
+### Main process
+
+```ts
+import { app, ipcMain } from 'electron'
+import { setupElectronBridge } from '@meerkapp/electron-bridge'
+
+app.whenReady().then(() => {
+  setupElectronBridge(app, ipcMain)
+  // ...create BrowserWindow etc.
+})
+```
+
+### Preload script
+
+Point Electron's `webPreferences.preload` to the bundled preload file:
+
+```ts
+import { BrowserWindow } from 'electron'
+import path from 'path'
+
+new BrowserWindow({
+  webPreferences: {
+    preload: path.join(
+      path.dirname(require.resolve('@meerkapp/electron-bridge')),
+      'preload.cjs'
+    ),
+    contextIsolation: true,
+    sandbox: false,
+  },
+})
+```
+
+### Renderer / PWA
+
+```ts
+import { createSQLiteIPCAdapter, isElectron } from '@meerkapp/electron-bridge'
+import { Collection } from '@signaldb/core'
+
+if (isElectron()) {
+  const adapter = createSQLiteIPCAdapter<Product, string>(
+    '/path/to/products.db',
+    'products'
+  )
+
+  const products = new Collection({ persistence: adapter })
+}
+```
+
+### Accessing `window.db` directly
+
+`window.db` is exposed by the preload script and provides the full `DbApi`:
+
+```ts
+const result = await window.db.checkFileExists({ filePath: '/path/to/file.db' })
+if (result.success && result.data?.exists) {
+  // ...
+}
+```
+
+## Native module rebuild
+
+`better-sqlite3` is a native Node.js addon and must be compiled against the Electron version in use. Run after `pnpm install`:
+
+```sh
+npx @electron/rebuild -f -w better-sqlite3
+```
+
+Add this to your `postinstall` script to automate it:
+
+```json
+{
+  "scripts": {
+    "postinstall": "electron-rebuild -f -w better-sqlite3"
+  }
+}
+```

package/dist/db-process.cjs

@@ -0,0 +1,164 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/db-process.ts
+var import_path = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+process.on("uncaughtException", (error) => {
+  console.error("[DB Process] Uncaught Exception:", error);
+});
+process.on("unhandledRejection", (reason) => {
+  console.error("[DB Process] Unhandled Rejection:", reason);
+});
+var dbConnections = /* @__PURE__ */ new Map();
+function getConnection(dbPath) {
+  if (dbConnections.has(dbPath)) return dbConnections.get(dbPath);
+  const dir = import_path.default.dirname(dbPath);
+  if (!import_fs.default.existsSync(dir)) import_fs.default.mkdirSync(dir, { recursive: true });
+  const db = new import_better_sqlite3.default(dbPath);
+  db.pragma("journal_mode = WAL");
+  dbConnections.set(dbPath, db);
+  return db;
+}
+if (!process.parentPort) {
+  console.error("[DB Process] Must be run as UtilityProcess");
+  process.exit(1);
+}
+var port = null;
+process.parentPort.on("message", (e) => {
+  if (e.data?.type === "port") {
+    port = e.ports[0];
+    port.on("message", handleMessage);
+    port.start();
+  }
+});
+function handleMessage(e) {
+  const { id, method, args } = e.data;
+  try {
+    const result = executeMethod(method, args);
+    port?.postMessage({ id, success: true, ...result });
+  } catch (error) {
+    console.error(`[DB Process] Error in ${method}:`, error);
+    port?.postMessage({ id, success: false, error: error.message });
+  }
+}
+function executeMethod(method, args) {
+  const { dbPath, tableName, filePath, items, ids, field } = args;
+  switch (method) {
+    case "setup": {
+      const db = getConnection(dbPath);
+      db.exec(`CREATE TABLE IF NOT EXISTS "${tableName}" (id TEXT PRIMARY KEY, data TEXT)`);
+      return {};
+    }
+    case "readAll": {
+      const db = getConnection(dbPath);
+      const rows = db.prepare(`SELECT data FROM "${tableName}"`).all();
+      return { data: rows.map((r) => JSON.parse(r.data)) };
+    }
+    case "readIds": {
+      const db = getConnection(dbPath);
+      const placeholders = ids.map(() => "?").join(", ");
+      const rows = db.prepare(`SELECT data FROM "${tableName}" WHERE id IN (${placeholders})`).all(...ids);
+      return { data: rows.map((r) => JSON.parse(r.data)) };
+    }
+    case "insert":
+    case "replace": {
+      const db = getConnection(dbPath);
+      const stmt = db.prepare(`INSERT OR REPLACE INTO "${tableName}" (id, data) VALUES (?, ?)`);
+      const run = db.transaction((rows) => {
+        for (const item of rows) stmt.run(String(item.id), JSON.stringify(item));
+      });
+      run(items);
+      return {};
+    }
+    case "remove": {
+      const db = getConnection(dbPath);
+      const stmt = db.prepare(`DELETE FROM "${tableName}" WHERE id = ?`);
+      const run = db.transaction((rows) => {
+        for (const item of rows) stmt.run(String(item.id));
+      });
+      run(items);
+      return {};
+    }
+    case "removeAll": {
+      const db = getConnection(dbPath);
+      db.prepare(`DELETE FROM "${tableName}"`).run();
+      return {};
+    }
+    case "createIndex": {
+      const db = getConnection(dbPath);
+      const colName = `idx_${field}`;
+      const existing = db.pragma(`table_xinfo("${tableName}")`);
+      if (!existing.some((col) => col.name === colName)) {
+        db.exec(
+          `ALTER TABLE "${tableName}" ADD COLUMN "${colName}" TEXT GENERATED ALWAYS AS (json_extract(data, '$.${field}')) VIRTUAL`
+        );
+      }
+      db.exec(`CREATE INDEX IF NOT EXISTS "idx_${tableName}_${field}" ON "${tableName}" ("${colName}")`);
+      return {};
+    }
+    case "dropIndex": {
+      const db = getConnection(dbPath);
+      db.exec(`DROP INDEX IF EXISTS "idx_${tableName}_${field}"`);
+      return {};
+    }
+    case "readIndex": {
+      const db = getConnection(dbPath);
+      const rows = db.prepare(`SELECT id, json_extract(data, '$.${field}') as field_value FROM "${tableName}"`).all();
+      const index = {};
+      for (const row of rows) {
+        if (row.field_value == null) continue;
+        const key = String(row.field_value);
+        if (!index[key]) index[key] = [];
+        index[key].push(row.id);
+      }
+      return { data: index };
+    }
+    case "getMaxUpdatedAt": {
+      const db = getConnection(dbPath);
+      const cols = db.pragma(`table_xinfo("${tableName}")`);
+      const hasColumn = cols.some((col) => col.name === "idx_updated_at");
+      if (!hasColumn) return { data: { maxUpdatedAt: null, hasColumn: false } };
+      const row = db.prepare(`SELECT MAX(idx_updated_at) as maxUpdatedAt FROM "${tableName}"`).get();
+      return { data: { maxUpdatedAt: row.maxUpdatedAt, hasColumn: true } };
+    }
+    case "checkFileExists": {
+      return { data: { exists: import_fs.default.existsSync(filePath) } };
+    }
+    case "deleteDbFile": {
+      if (dbConnections.has(filePath)) {
+        dbConnections.get(filePath).close();
+        dbConnections.delete(filePath);
+      }
+      const base = filePath.endsWith(".db") ? filePath.slice(0, -3) : filePath;
+      for (const p of [base + ".db", base + ".db-wal", base + ".db-shm"]) {
+        if (import_fs.default.existsSync(p)) import_fs.default.unlinkSync(p);
+      }
+      return {};
+    }
+    default:
+      throw new Error(`Unknown method: ${method}`);
+  }
+}

package/dist/index.cjs

@@ -0,0 +1,116 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createSQLiteIPCAdapter: () => createSQLiteIPCAdapter,
+  isElectron: () => isElectron,
+  setupElectronBridge: () => setupElectronBridge
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/signaldb-adapter.ts
+var import_core = require("@signaldb/core");
+function createSQLiteIPCAdapter(dbPath, tableName) {
+  return (0, import_core.createStorageAdapter)({
+    async setup() {
+      const result = await window.db.setup({ dbPath, tableName });
+      if (!result.success) throw new Error(result.error || "Failed to setup table");
+    },
+    async teardown() {
+    },
+    async readAll() {
+      const result = await window.db.readAll({ dbPath, tableName });
+      if (!result.success) throw new Error(result.error || "Failed to read data");
+      return result.data;
+    },
+    async readIds(ids) {
+      const result = await window.db.readIds({ dbPath, tableName, ids });
+      if (!result.success) throw new Error(result.error || "Failed to read items by IDs");
+      return result.data;
+    },
+    async createIndex(field) {
+      const result = await window.db.createIndex({ dbPath, tableName, field });
+      if (!result.success) throw new Error(result.error || `Failed to create index for field: ${field}`);
+    },
+    async dropIndex(field) {
+      const result = await window.db.dropIndex({ dbPath, tableName, field });
+      if (!result.success) throw new Error(result.error || `Failed to drop index for field: ${field}`);
+    },
+    async readIndex(field) {
+      const result = await window.db.readIndex({ dbPath, tableName, field });
+      if (!result.success) throw new Error(result.error || `Failed to read index for field: ${field}`);
+      const indexMap = /* @__PURE__ */ new Map();
+      if (result.data) {
+        for (const [key, ids] of Object.entries(result.data)) {
+          indexMap.set(key, new Set(ids));
+        }
+      }
+      return indexMap;
+    },
+    async insert(items) {
+      const result = await window.db.insert({ dbPath, tableName, items });
+      if (!result.success) throw new Error(result.error || "Failed to insert items");
+    },
+    async replace(items) {
+      const result = await window.db.replace({ dbPath, tableName, items });
+      if (!result.success) throw new Error(result.error || "Failed to replace items");
+    },
+    async remove(items) {
+      const result = await window.db.remove({ dbPath, tableName, items });
+      if (!result.success) throw new Error(result.error || "Failed to remove items");
+    },
+    async removeAll() {
+      const result = await window.db.removeAll({ dbPath, tableName });
+      if (!result.success) throw new Error(result.error || "Failed to remove all items");
+    }
+  });
+}
+
+// src/main.ts
+var import_electron = require("electron");
+var import_path = __toESM(require("path"), 1);
+function setupElectronBridge(electronApp, electronIpcMain) {
+  const dbProcessPath = import_path.default.join(__dirname, "db-process.cjs");
+  const child = import_electron.utilityProcess.fork(dbProcessPath);
+  electronIpcMain.on("db:port", (event) => {
+    child.postMessage({ type: "port" }, [event.ports[0]]);
+  });
+  electronApp.on("before-quit", () => child.kill());
+}
+
+// src/index.ts
+var isElectron = () => typeof window !== "undefined" && !!window.db;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSQLiteIPCAdapter,
+  isElectron,
+  setupElectronBridge
+});

package/dist/index.d.cts

@@ -0,0 +1,87 @@
+import * as _signaldb_core from '@signaldb/core';
+import { app, ipcMain } from 'electron';
+
+declare function createSQLiteIPCAdapter<T extends {
+    id: I;
+} & Record<string, any>, I extends string | number>(dbPath: string, tableName: string): _signaldb_core.StorageAdapter<T, I>;
+
+declare function setupElectronBridge(electronApp: typeof app, electronIpcMain: typeof ipcMain): void;
+
+interface DbResult<T = void> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+interface DbApi {
+    setup(args: {
+        dbPath: string;
+        tableName: string;
+    }): Promise<DbResult>;
+    readAll(args: {
+        dbPath: string;
+        tableName: string;
+    }): Promise<DbResult<any[]>>;
+    readIds(args: {
+        dbPath: string;
+        tableName: string;
+        ids: (string | number)[];
+    }): Promise<DbResult<any[]>>;
+    insert(args: {
+        dbPath: string;
+        tableName: string;
+        items: any[];
+    }): Promise<DbResult>;
+    replace(args: {
+        dbPath: string;
+        tableName: string;
+        items: any[];
+    }): Promise<DbResult>;
+    remove(args: {
+        dbPath: string;
+        tableName: string;
+        items: any[];
+    }): Promise<DbResult>;
+    removeAll(args: {
+        dbPath: string;
+        tableName: string;
+    }): Promise<DbResult>;
+    createIndex(args: {
+        dbPath: string;
+        tableName: string;
+        field: string;
+    }): Promise<DbResult>;
+    dropIndex(args: {
+        dbPath: string;
+        tableName: string;
+        field: string;
+    }): Promise<DbResult>;
+    readIndex(args: {
+        dbPath: string;
+        tableName: string;
+        field: string;
+    }): Promise<DbResult<Record<string, (string | number)[]>>>;
+    getMaxUpdatedAt(args: {
+        dbPath: string;
+        tableName: string;
+    }): Promise<DbResult<{
+        maxUpdatedAt: string | null;
+        hasColumn: boolean;
+    }>>;
+    checkFileExists(args: {
+        filePath: string;
+    }): Promise<DbResult<{
+        exists: boolean;
+    }>>;
+    deleteDbFile(args: {
+        filePath: string;
+    }): Promise<DbResult>;
+}
+declare global {
+    interface Window {
+        db: DbApi;
+    }
+}
+
+declare const isElectron: () => boolean;
+
+export { type DbApi, type DbResult, createSQLiteIPCAdapter, isElectron, setupElectronBridge };

package/dist/index.d.ts

@@ -0,0 +1,87 @@
+import * as _signaldb_core from '@signaldb/core';
+import { app, ipcMain } from 'electron';
+
+declare function createSQLiteIPCAdapter<T extends {
+    id: I;
+} & Record<string, any>, I extends string | number>(dbPath: string, tableName: string): _signaldb_core.StorageAdapter<T, I>;
+
+declare function setupElectronBridge(electronApp: typeof app, electronIpcMain: typeof ipcMain): void;
+
+interface DbResult<T = void> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+interface DbApi {
+    setup(args: {
+        dbPath: string;
+        tableName: string;
+    }): Promise<DbResult>;
+    readAll(args: {
+        dbPath: string;
+        tableName: string;
+    }): Promise<DbResult<any[]>>;
+    readIds(args: {
+        dbPath: string;
+        tableName: string;
+        ids: (string | number)[];
+    }): Promise<DbResult<any[]>>;
+    insert(args: {
+        dbPath: string;
+        tableName: string;
+        items: any[];
+    }): Promise<DbResult>;
+    replace(args: {
+        dbPath: string;
+        tableName: string;
+        items: any[];
+    }): Promise<DbResult>;
+    remove(args: {
+        dbPath: string;
+        tableName: string;
+        items: any[];
+    }): Promise<DbResult>;
+    removeAll(args: {
+        dbPath: string;
+        tableName: string;
+    }): Promise<DbResult>;
+    createIndex(args: {
+        dbPath: string;
+        tableName: string;
+        field: string;
+    }): Promise<DbResult>;
+    dropIndex(args: {
+        dbPath: string;
+        tableName: string;
+        field: string;
+    }): Promise<DbResult>;
+    readIndex(args: {
+        dbPath: string;
+        tableName: string;
+        field: string;
+    }): Promise<DbResult<Record<string, (string | number)[]>>>;
+    getMaxUpdatedAt(args: {
+        dbPath: string;
+        tableName: string;
+    }): Promise<DbResult<{
+        maxUpdatedAt: string | null;
+        hasColumn: boolean;
+    }>>;
+    checkFileExists(args: {
+        filePath: string;
+    }): Promise<DbResult<{
+        exists: boolean;
+    }>>;
+    deleteDbFile(args: {
+        filePath: string;
+    }): Promise<DbResult>;
+}
+declare global {
+    interface Window {
+        db: DbApi;
+    }
+}
+
+declare const isElectron: () => boolean;
+
+export { type DbApi, type DbResult, createSQLiteIPCAdapter, isElectron, setupElectronBridge };

package/dist/index.js

@@ -0,0 +1,77 @@
+// src/signaldb-adapter.ts
+import { createStorageAdapter } from "@signaldb/core";
+function createSQLiteIPCAdapter(dbPath, tableName) {
+  return createStorageAdapter({
+    async setup() {
+      const result = await window.db.setup({ dbPath, tableName });
+      if (!result.success) throw new Error(result.error || "Failed to setup table");
+    },
+    async teardown() {
+    },
+    async readAll() {
+      const result = await window.db.readAll({ dbPath, tableName });
+      if (!result.success) throw new Error(result.error || "Failed to read data");
+      return result.data;
+    },
+    async readIds(ids) {
+      const result = await window.db.readIds({ dbPath, tableName, ids });
+      if (!result.success) throw new Error(result.error || "Failed to read items by IDs");
+      return result.data;
+    },
+    async createIndex(field) {
+      const result = await window.db.createIndex({ dbPath, tableName, field });
+      if (!result.success) throw new Error(result.error || `Failed to create index for field: ${field}`);
+    },
+    async dropIndex(field) {
+      const result = await window.db.dropIndex({ dbPath, tableName, field });
+      if (!result.success) throw new Error(result.error || `Failed to drop index for field: ${field}`);
+    },
+    async readIndex(field) {
+      const result = await window.db.readIndex({ dbPath, tableName, field });
+      if (!result.success) throw new Error(result.error || `Failed to read index for field: ${field}`);
+      const indexMap = /* @__PURE__ */ new Map();
+      if (result.data) {
+        for (const [key, ids] of Object.entries(result.data)) {
+          indexMap.set(key, new Set(ids));
+        }
+      }
+      return indexMap;
+    },
+    async insert(items) {
+      const result = await window.db.insert({ dbPath, tableName, items });
+      if (!result.success) throw new Error(result.error || "Failed to insert items");
+    },
+    async replace(items) {
+      const result = await window.db.replace({ dbPath, tableName, items });
+      if (!result.success) throw new Error(result.error || "Failed to replace items");
+    },
+    async remove(items) {
+      const result = await window.db.remove({ dbPath, tableName, items });
+      if (!result.success) throw new Error(result.error || "Failed to remove items");
+    },
+    async removeAll() {
+      const result = await window.db.removeAll({ dbPath, tableName });
+      if (!result.success) throw new Error(result.error || "Failed to remove all items");
+    }
+  });
+}
+
+// src/main.ts
+import { utilityProcess } from "electron";
+import path from "path";
+function setupElectronBridge(electronApp, electronIpcMain) {
+  const dbProcessPath = path.join(__dirname, "db-process.cjs");
+  const child = utilityProcess.fork(dbProcessPath);
+  electronIpcMain.on("db:port", (event) => {
+    child.postMessage({ type: "port" }, [event.ports[0]]);
+  });
+  electronApp.on("before-quit", () => child.kill());
+}
+
+// src/index.ts
+var isElectron = () => typeof window !== "undefined" && !!window.db;
+export {
+  createSQLiteIPCAdapter,
+  isElectron,
+  setupElectronBridge
+};

package/dist/preload.cjs

@@ -0,0 +1,39 @@
+"use strict";
+
+// src/preload.ts
+var import_electron = require("electron");
+var { port1, port2 } = new MessageChannel();
+import_electron.ipcRenderer.postMessage("db:port", null, [port2]);
+var requestId = 0;
+var pending = /* @__PURE__ */ new Map();
+port1.onmessage = (e) => {
+  const { id, success, error, ...data } = e.data;
+  const handler = pending.get(id);
+  if (!handler) return;
+  pending.delete(id);
+  if (success) handler.resolve(data);
+  else handler.reject(new Error(error));
+};
+port1.start();
+function invoke(method, args) {
+  return new Promise((resolve, reject) => {
+    const id = ++requestId;
+    pending.set(id, { resolve, reject });
+    port1.postMessage({ id, method, args });
+  });
+}
+import_electron.contextBridge.exposeInMainWorld("db", {
+  setup: (args) => invoke("setup", args),
+  readAll: (args) => invoke("readAll", args),
+  readIds: (args) => invoke("readIds", args),
+  insert: (args) => invoke("insert", args),
+  replace: (args) => invoke("replace", args),
+  remove: (args) => invoke("remove", args),
+  removeAll: (args) => invoke("removeAll", args),
+  createIndex: (args) => invoke("createIndex", args),
+  dropIndex: (args) => invoke("dropIndex", args),
+  readIndex: (args) => invoke("readIndex", args),
+  getMaxUpdatedAt: (args) => invoke("getMaxUpdatedAt", args),
+  checkFileExists: (args) => invoke("checkFileExists", args),
+  deleteDbFile: (args) => invoke("deleteDbFile", args)
+});

package/dist/preload.d.cts

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

package/dist/preload.d.ts

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

package/dist/preload.js

@@ -0,0 +1,37 @@
+// src/preload.ts
+import { contextBridge, ipcRenderer } from "electron";
+var { port1, port2 } = new MessageChannel();
+ipcRenderer.postMessage("db:port", null, [port2]);
+var requestId = 0;
+var pending = /* @__PURE__ */ new Map();
+port1.onmessage = (e) => {
+  const { id, success, error, ...data } = e.data;
+  const handler = pending.get(id);
+  if (!handler) return;
+  pending.delete(id);
+  if (success) handler.resolve(data);
+  else handler.reject(new Error(error));
+};
+port1.start();
+function invoke(method, args) {
+  return new Promise((resolve, reject) => {
+    const id = ++requestId;
+    pending.set(id, { resolve, reject });
+    port1.postMessage({ id, method, args });
+  });
+}
+contextBridge.exposeInMainWorld("db", {
+  setup: (args) => invoke("setup", args),
+  readAll: (args) => invoke("readAll", args),
+  readIds: (args) => invoke("readIds", args),
+  insert: (args) => invoke("insert", args),
+  replace: (args) => invoke("replace", args),
+  remove: (args) => invoke("remove", args),
+  removeAll: (args) => invoke("removeAll", args),
+  createIndex: (args) => invoke("createIndex", args),
+  dropIndex: (args) => invoke("dropIndex", args),
+  readIndex: (args) => invoke("readIndex", args),
+  getMaxUpdatedAt: (args) => invoke("getMaxUpdatedAt", args),
+  checkFileExists: (args) => invoke("checkFileExists", args),
+  deleteDbFile: (args) => invoke("deleteDbFile", args)
+});

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@meerkapp/electron-bridge",
+  "version": "0.1.0",
+  "description": "Bridge between Electron main process and PWA renderer for Meerk warehouse management system",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./db-process": "./dist/db-process.cjs",
+    "./preload": "./dist/preload.cjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "better-sqlite3": "^11.0.0"
+  },
+  "peerDependencies": {
+    "@signaldb/core": "2.0.0-beta.6",
+    "electron": "^37.5.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/node": "^22.0.0",
+    "electron": "^37.5.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "registry": "https://npm.pkg.github.com"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}