@anyreplay/electron 0.0.0-stage → 0.2.1

package/dist/preload.cjs

@@ -0,0 +1,86 @@
+"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/preload.ts
+var preload_exports = {};
+__export(preload_exports, {
+  exposeAnyReplay: () => exposeAnyReplay
+});
+module.exports = __toCommonJS(preload_exports);
+var import_electron = require("electron");
+
+// src/bridge.ts
+var BRIDGE_KEY = "anyreplayElectron";
+var CHANNELS = {
+  /** renderer → main (invoke): `AppInfo`. */
+  appInfo: "anyreplay:app-info",
+  /** main → renderer: flush now, then answer on `flushed` with the same id. */
+  flush: "anyreplay:flush",
+  /** renderer → main: a flush asked for by `flush` has finished. */
+  flushed: "anyreplay:flushed",
+  /** main → renderer: an uncaught exception in the main process. */
+  mainError: "anyreplay:main-error"
+};
+
+// src/preload.ts
+function exposeAnyReplay() {
+  let flushHandler = null;
+  let errorListener = null;
+  import_electron.ipcRenderer.on(CHANNELS.flush, (_event, id) => {
+    void (async () => {
+      try {
+        await flushHandler?.();
+      } catch {
+      }
+      import_electron.ipcRenderer.send(CHANNELS.flushed, id);
+    })();
+  });
+  import_electron.ipcRenderer.on(CHANNELS.mainError, (_event, error) => {
+    try {
+      errorListener?.(error);
+    } catch {
+    }
+  });
+  const bridge = {
+    version: 1,
+    appInfo: async () => {
+      try {
+        return await import_electron.ipcRenderer.invoke(CHANNELS.appInfo) ?? {};
+      } catch {
+        return {};
+      }
+    },
+    onFlushRequest: (flush) => {
+      flushHandler = flush;
+    },
+    onMainError: (listener) => {
+      errorListener = listener;
+    }
+  };
+  if (process.contextIsolated) {
+    import_electron.contextBridge.exposeInMainWorld(BRIDGE_KEY, bridge);
+  } else {
+    globalThis[BRIDGE_KEY] = bridge;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exposeAnyReplay
+});
+//# sourceMappingURL=preload.cjs.map

package/dist/preload.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/preload.ts","../src/bridge.ts"],"sourcesContent":["import { contextBridge, ipcRenderer } from 'electron';\nimport { BRIDGE_KEY, CHANNELS, type AnyReplayBridge, type AppInfo, type MainErrorMessage } from './bridge.js';\n\n/**\n * Exposes `window.anyreplayElectron` to the page. Call it once from your\n * preload script:\n *\n * ```ts\n * // preload.ts\n * import { exposeAnyReplay } from '@anyreplay/electron/preload';\n * exposeAnyReplay();\n * ```\n *\n * Works with `contextIsolation: true` and `sandbox: true` (Electron's\n * defaults) and needs no `nodeIntegration`: it uses only `contextBridge` and\n * `ipcRenderer`, the two modules a sandboxed preload has. A sandboxed preload\n * cannot `import` from `node_modules` at run time, so bundle it (Electron\n * Forge, electron-vite and electron-builder setups all do).\n *\n * With `contextIsolation: false` there is no bridge to cross; the API is put\n * on `window` directly.\n */\nexport function exposeAnyReplay(): void {\n  let flushHandler: (() => Promise<void> | void) | null = null;\n  let errorListener: ((error: MainErrorMessage) => void) | null = null;\n\n  ipcRenderer.on(CHANNELS.flush, (_event, id: unknown) => {\n    void (async () => {\n      try {\n        await flushHandler?.();\n      } catch {\n        /* a failed flush still has to be answered, or quitting waits for the timeout */\n      }\n      ipcRenderer.send(CHANNELS.flushed, id);\n    })();\n  });\n\n  ipcRenderer.on(CHANNELS.mainError, (_event, error: MainErrorMessage) => {\n    try {\n      errorListener?.(error);\n    } catch {\n      /* never let the recorder break the window */\n    }\n  });\n\n  const bridge: AnyReplayBridge = {\n    version: 1,\n    appInfo: async (): Promise<AppInfo> => {\n      try {\n        return ((await ipcRenderer.invoke(CHANNELS.appInfo)) ?? {}) as AppInfo;\n      } catch {\n        // No handler: `setupAnyReplay()` was not called in the main process.\n        // The renderer falls back to the options it was given.\n        return {};\n      }\n    },\n    onFlushRequest: (flush) => { flushHandler = flush; },\n    onMainError: (listener) => { errorListener = listener; },\n  };\n\n  if (process.contextIsolated) {\n    contextBridge.exposeInMainWorld(BRIDGE_KEY, bridge);\n  } else {\n    (globalThis as unknown as Record<string, unknown>)[BRIDGE_KEY] = bridge;\n  }\n}\n","/**\n * The contract between the three halves of the Electron SDK.\n *\n * The renderer records; the preload script is the only code that can talk to\n * the main process; the main process knows the app's id and version and sees\n * the app quit. They share nothing but these names, so each entry point can be\n * imported on its own without pulling in the others (or the recorder, which\n * has no business in the main process).\n */\n\n/** The global the preload script exposes through `contextBridge`. */\nexport const BRIDGE_KEY = 'anyreplayElectron';\n\n/** IPC channels. All of them, so a reviewer can see exactly what crosses. */\nexport const CHANNELS = {\n  /** renderer → main (invoke): `AppInfo`. */\n  appInfo: 'anyreplay:app-info',\n  /** main → renderer: flush now, then answer on `flushed` with the same id. */\n  flush: 'anyreplay:flush',\n  /** renderer → main: a flush asked for by `flush` has finished. */\n  flushed: 'anyreplay:flushed',\n  /** main → renderer: an uncaught exception in the main process. */\n  mainError: 'anyreplay:main-error',\n} as const;\n\n/** What the main process says about the app. */\nexport interface AppInfo {\n  /** The app id (§2.2 of the SDK contract), already checked against the id pattern. Absent when none could be found. */\n  appId?: string;\n  /** `app.getVersion()`. */\n  appVersion?: string;\n}\n\n/** An uncaught exception in the main process, as sent to a window. Raw: the renderer redacts it. */\nexport interface MainErrorMessage {\n  name?: string;\n  message: string;\n  stack?: string;\n}\n\n/**\n * What the preload script exposes on `window.anyreplayElectron`.\n *\n * Deliberately narrow: three fixed channels, no generic `send` or `invoke`, so\n * exposing it gives page script no more reach into the main process than\n * asking for the app's version and answering a flush.\n */\nexport interface AnyReplayBridge {\n  /** The bridge's own version, so a newer renderer can tell an older preload apart. */\n  readonly version: 1;\n  appInfo: () => Promise<AppInfo>;\n  /** The renderer's flush; called when the main process is about to quit. Replaces any earlier one. */\n  onFlushRequest: (flush: () => Promise<void> | void) => void;\n  /** Called with each main-process error forwarded to this window. Replaces any earlier listener. */\n  onMainError: (listener: (error: MainErrorMessage) => void) => void;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAA2C;;;ACWpC,IAAM,aAAa;AAGnB,IAAM,WAAW;AAAA;AAAA,EAEtB,SAAS;AAAA;AAAA,EAET,OAAO;AAAA;AAAA,EAEP,SAAS;AAAA;AAAA,EAET,WAAW;AACb;;;ADDO,SAAS,kBAAwB;AACtC,MAAI,eAAoD;AACxD,MAAI,gBAA4D;AAEhE,8BAAY,GAAG,SAAS,OAAO,CAAC,QAAQ,OAAgB;AACtD,UAAM,YAAY;AAChB,UAAI;AACF,cAAM,eAAe;AAAA,MACvB,QAAQ;AAAA,MAER;AACA,kCAAY,KAAK,SAAS,SAAS,EAAE;AAAA,IACvC,GAAG;AAAA,EACL,CAAC;AAED,8BAAY,GAAG,SAAS,WAAW,CAAC,QAAQ,UAA4B;AACtE,QAAI;AACF,sBAAgB,KAAK;AAAA,IACvB,QAAQ;AAAA,IAER;AAAA,EACF,CAAC;AAED,QAAM,SAA0B;AAAA,IAC9B,SAAS;AAAA,IACT,SAAS,YAA8B;AACrC,UAAI;AACF,eAAS,MAAM,4BAAY,OAAO,SAAS,OAAO,KAAM,CAAC;AAAA,MAC3D,QAAQ;AAGN,eAAO,CAAC;AAAA,MACV;AAAA,IACF;AAAA,IACA,gBAAgB,CAAC,UAAU;AAAE,qBAAe;AAAA,IAAO;AAAA,IACnD,aAAa,CAAC,aAAa;AAAE,sBAAgB;AAAA,IAAU;AAAA,EACzD;AAEA,MAAI,QAAQ,iBAAiB;AAC3B,kCAAc,kBAAkB,YAAY,MAAM;AAAA,EACpD,OAAO;AACL,IAAC,WAAkD,UAAU,IAAI;AAAA,EACnE;AACF;","names":[]}

package/dist/preload.d.cts

@@ -0,0 +1,22 @@
+/**
+ * Exposes `window.anyreplayElectron` to the page. Call it once from your
+ * preload script:
+ *
+ * ```ts
+ * // preload.ts
+ * import { exposeAnyReplay } from '@anyreplay/electron/preload';
+ * exposeAnyReplay();
+ * ```
+ *
+ * Works with `contextIsolation: true` and `sandbox: true` (Electron's
+ * defaults) and needs no `nodeIntegration`: it uses only `contextBridge` and
+ * `ipcRenderer`, the two modules a sandboxed preload has. A sandboxed preload
+ * cannot `import` from `node_modules` at run time, so bundle it (Electron
+ * Forge, electron-vite and electron-builder setups all do).
+ *
+ * With `contextIsolation: false` there is no bridge to cross; the API is put
+ * on `window` directly.
+ */
+declare function exposeAnyReplay(): void;
+
+export { exposeAnyReplay };

package/dist/preload.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Exposes `window.anyreplayElectron` to the page. Call it once from your
+ * preload script:
+ *
+ * ```ts
+ * // preload.ts
+ * import { exposeAnyReplay } from '@anyreplay/electron/preload';
+ * exposeAnyReplay();
+ * ```
+ *
+ * Works with `contextIsolation: true` and `sandbox: true` (Electron's
+ * defaults) and needs no `nodeIntegration`: it uses only `contextBridge` and
+ * `ipcRenderer`, the two modules a sandboxed preload has. A sandboxed preload
+ * cannot `import` from `node_modules` at run time, so bundle it (Electron
+ * Forge, electron-vite and electron-builder setups all do).
+ *
+ * With `contextIsolation: false` there is no bridge to cross; the API is put
+ * on `window` directly.
+ */
+declare function exposeAnyReplay(): void;
+
+export { exposeAnyReplay };

package/dist/preload.js

@@ -0,0 +1,51 @@
+import {
+  BRIDGE_KEY,
+  CHANNELS
+} from "./chunk-5TQ2HVGX.js";
+
+// src/preload.ts
+import { contextBridge, ipcRenderer } from "electron";
+function exposeAnyReplay() {
+  let flushHandler = null;
+  let errorListener = null;
+  ipcRenderer.on(CHANNELS.flush, (_event, id) => {
+    void (async () => {
+      try {
+        await flushHandler?.();
+      } catch {
+      }
+      ipcRenderer.send(CHANNELS.flushed, id);
+    })();
+  });
+  ipcRenderer.on(CHANNELS.mainError, (_event, error) => {
+    try {
+      errorListener?.(error);
+    } catch {
+    }
+  });
+  const bridge = {
+    version: 1,
+    appInfo: async () => {
+      try {
+        return await ipcRenderer.invoke(CHANNELS.appInfo) ?? {};
+      } catch {
+        return {};
+      }
+    },
+    onFlushRequest: (flush) => {
+      flushHandler = flush;
+    },
+    onMainError: (listener) => {
+      errorListener = listener;
+    }
+  };
+  if (process.contextIsolated) {
+    contextBridge.exposeInMainWorld(BRIDGE_KEY, bridge);
+  } else {
+    globalThis[BRIDGE_KEY] = bridge;
+  }
+}
+export {
+  exposeAnyReplay
+};
+//# sourceMappingURL=preload.js.map

package/dist/preload.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/preload.ts"],"sourcesContent":["import { contextBridge, ipcRenderer } from 'electron';\nimport { BRIDGE_KEY, CHANNELS, type AnyReplayBridge, type AppInfo, type MainErrorMessage } from './bridge.js';\n\n/**\n * Exposes `window.anyreplayElectron` to the page. Call it once from your\n * preload script:\n *\n * ```ts\n * // preload.ts\n * import { exposeAnyReplay } from '@anyreplay/electron/preload';\n * exposeAnyReplay();\n * ```\n *\n * Works with `contextIsolation: true` and `sandbox: true` (Electron's\n * defaults) and needs no `nodeIntegration`: it uses only `contextBridge` and\n * `ipcRenderer`, the two modules a sandboxed preload has. A sandboxed preload\n * cannot `import` from `node_modules` at run time, so bundle it (Electron\n * Forge, electron-vite and electron-builder setups all do).\n *\n * With `contextIsolation: false` there is no bridge to cross; the API is put\n * on `window` directly.\n */\nexport function exposeAnyReplay(): void {\n  let flushHandler: (() => Promise<void> | void) | null = null;\n  let errorListener: ((error: MainErrorMessage) => void) | null = null;\n\n  ipcRenderer.on(CHANNELS.flush, (_event, id: unknown) => {\n    void (async () => {\n      try {\n        await flushHandler?.();\n      } catch {\n        /* a failed flush still has to be answered, or quitting waits for the timeout */\n      }\n      ipcRenderer.send(CHANNELS.flushed, id);\n    })();\n  });\n\n  ipcRenderer.on(CHANNELS.mainError, (_event, error: MainErrorMessage) => {\n    try {\n      errorListener?.(error);\n    } catch {\n      /* never let the recorder break the window */\n    }\n  });\n\n  const bridge: AnyReplayBridge = {\n    version: 1,\n    appInfo: async (): Promise<AppInfo> => {\n      try {\n        return ((await ipcRenderer.invoke(CHANNELS.appInfo)) ?? {}) as AppInfo;\n      } catch {\n        // No handler: `setupAnyReplay()` was not called in the main process.\n        // The renderer falls back to the options it was given.\n        return {};\n      }\n    },\n    onFlushRequest: (flush) => { flushHandler = flush; },\n    onMainError: (listener) => { errorListener = listener; },\n  };\n\n  if (process.contextIsolated) {\n    contextBridge.exposeInMainWorld(BRIDGE_KEY, bridge);\n  } else {\n    (globalThis as unknown as Record<string, unknown>)[BRIDGE_KEY] = bridge;\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAS,eAAe,mBAAmB;AAsBpC,SAAS,kBAAwB;AACtC,MAAI,eAAoD;AACxD,MAAI,gBAA4D;AAEhE,cAAY,GAAG,SAAS,OAAO,CAAC,QAAQ,OAAgB;AACtD,UAAM,YAAY;AAChB,UAAI;AACF,cAAM,eAAe;AAAA,MACvB,QAAQ;AAAA,MAER;AACA,kBAAY,KAAK,SAAS,SAAS,EAAE;AAAA,IACvC,GAAG;AAAA,EACL,CAAC;AAED,cAAY,GAAG,SAAS,WAAW,CAAC,QAAQ,UAA4B;AACtE,QAAI;AACF,sBAAgB,KAAK;AAAA,IACvB,QAAQ;AAAA,IAER;AAAA,EACF,CAAC;AAED,QAAM,SAA0B;AAAA,IAC9B,SAAS;AAAA,IACT,SAAS,YAA8B;AACrC,UAAI;AACF,eAAS,MAAM,YAAY,OAAO,SAAS,OAAO,KAAM,CAAC;AAAA,MAC3D,QAAQ;AAGN,eAAO,CAAC;AAAA,MACV;AAAA,IACF;AAAA,IACA,gBAAgB,CAAC,UAAU;AAAE,qBAAe;AAAA,IAAO;AAAA,IACnD,aAAa,CAAC,aAAa;AAAE,sBAAgB;AAAA,IAAU;AAAA,EACzD;AAEA,MAAI,QAAQ,iBAAiB;AAC3B,kBAAc,kBAAkB,YAAY,MAAM;AAAA,EACpD,OAAO;AACL,IAAC,WAAkD,UAAU,IAAI;AAAA,EACnE;AACF;","names":[]}

package/package.json

@@ -1,6 +1,77 @@
 {
   "name": "@anyreplay/electron",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.1",
+  "description": "Session replay for Electron apps: records each window with the AnyReplay browser SDK, reports the app's id and version, and flushes before the app quits.",
+  "license": "MIT",
+  "homepage": "https://anyreplay.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/baemtech/anyreplay-sdk.git",
+    "directory": "electron"
+  },
+  "bugs": {
+    "url": "https://github.com/baemtech/anyreplay-sdk/issues"
+  },
+  "keywords": [
+    "session-replay",
+    "session-recording",
+    "electron",
+    "desktop",
+    "anyreplay"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./preload": {
+      "types": "./dist/preload.d.ts",
+      "import": "./dist/preload.js",
+      "require": "./dist/preload.cjs"
+    },
+    "./main": {
+      "types": "./dist/main.d.ts",
+      "import": "./dist/main.js",
+      "require": "./dist/main.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@anyreplay/browser": "^0.2.1"
+  },
+  "peerDependencies": {
+    "electron": ">=28"
+  },
+  "peerDependenciesMeta": {
+    "electron": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "electron": "38.8.6",
+    "jsdom": "25.0.1",
+    "tsup": "8.3.5",
+    "typescript": "5.8.3",
+    "vitest": "2.1.8",
+    "@anyreplay/shared": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
 }