@dimina-kit/devtools 0.3.1 → 0.3.2-dev.20260522085907

package/dist/preload/runtime/custom-apis.js

@@ -0,0 +1,43 @@
+import { ipcRenderer } from 'electron';
+import { SimulatorCustomApiBridgeChannel } from '../../shared/ipc-channels.js';
+import { exposeOnMainWorld } from '../shared/expose.js';
+// The simulator <webview> is intentionally kept off the workbench sender-policy
+// white-list, so it cannot reach `ipcMain.handle` directly. Instead the bridge
+// asks the trusted main-window renderer to proxy the call: webview sends via
+// `ipcRenderer.sendToHost`, host does the `ipcInvoke`, and posts the result
+// back through `<webview>.send`. Requests and responses are correlated by id
+// so concurrent invokes do not tangle.
+function buildBridge() {
+    let nextId = 1;
+    const pending = new Map();
+    ipcRenderer.on(SimulatorCustomApiBridgeChannel.Response, (_event, payload) => {
+        const entry = pending.get(payload.id);
+        if (!entry)
+            return;
+        pending.delete(payload.id);
+        if ('error' in payload) {
+            entry.reject(new Error(payload.error));
+        }
+        else {
+            entry.resolve(payload.result);
+        }
+    });
+    const send = (req) => {
+        return new Promise((resolve, reject) => {
+            pending.set(req.id, {
+                resolve: (value) => resolve(value),
+                reject,
+            });
+            ipcRenderer.sendToHost(SimulatorCustomApiBridgeChannel.Request, req);
+        });
+    };
+    return {
+        list: () => send({ id: nextId++, op: 'list' }),
+        invoke: (name, params) => send({ id: nextId++, op: 'invoke', name, params }),
+    };
+}
+export function installCustomApisBridge() {
+    const bridge = buildBridge();
+    return exposeOnMainWorld('__diminaCustomApis', bridge);
+}
+//# sourceMappingURL=custom-apis.js.map

package/dist/preload/runtime/host.d.ts

@@ -1,3 +1,4 @@
 export declare function sendToHost(channel: string, data: unknown): void;
+export declare function onHostMessage(channel: string, handler: (...args: unknown[]) => void): () => void;
 export declare function safeSerialize(val: unknown): unknown;
 //# sourceMappingURL=host.d.ts.map

package/dist/preload/runtime/host.js

@@ -2,6 +2,19 @@ import { ipcRenderer } from 'electron';
 export function sendToHost(channel, data) {
     ipcRenderer.sendToHost(channel, data);
 }
+export function onHostMessage(channel, handler) {
+    let active = true;
+    const wrapped = (_event, ...args) => {
+        if (!active)
+            return;
+        handler(...args);
+    };
+    ipcRenderer.on(channel, wrapped);
+    return () => {
+        active = false;
+        ipcRenderer.removeListener(channel, wrapped);
+    };
+}
 export function safeSerialize(val) {
     if (val === null || val === undefined)
         return val;

package/dist/preload/shared/expose.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Expose `value` on the renderer's main world under `key`.
+ *
+ * Prefers Electron's `contextBridge` (the path that works with
+ * `contextIsolation: true`). When `contextBridge` is unavailable — e.g. a
+ * webview running without context isolation — it falls back to assigning
+ * `value` directly onto the preload realm's `window`.
+ *
+ * Returns a disposer. It can only undo the fallback assignment (a
+ * `contextBridge` binding cannot be un-exposed); on the contextBridge path
+ * the disposer is a no-op. The disposer never clobbers a `window[key]` that
+ * something else has since reassigned.
+ */
+export declare function exposeOnMainWorld(key: string, value: unknown): () => void;
+//# sourceMappingURL=expose.d.ts.map

package/dist/preload/shared/expose.js

@@ -0,0 +1,33 @@
+import { contextBridge } from 'electron';
+/**
+ * Expose `value` on the renderer's main world under `key`.
+ *
+ * Prefers Electron's `contextBridge` (the path that works with
+ * `contextIsolation: true`). When `contextBridge` is unavailable — e.g. a
+ * webview running without context isolation — it falls back to assigning
+ * `value` directly onto the preload realm's `window`.
+ *
+ * Returns a disposer. It can only undo the fallback assignment (a
+ * `contextBridge` binding cannot be un-exposed); on the contextBridge path
+ * the disposer is a no-op. The disposer never clobbers a `window[key]` that
+ * something else has since reassigned.
+ */
+export function exposeOnMainWorld(key, value) {
+    let fellBack = false;
+    try {
+        contextBridge.exposeInMainWorld(key, value);
+    }
+    catch {
+        ;
+        window[key] = value;
+        fellBack = true;
+    }
+    return () => {
+        if (!fellBack)
+            return;
+        const w = window;
+        if (w[key] === value)
+            delete w[key];
+    };
+}
+//# sourceMappingURL=expose.js.map

package/dist/preload/shared/page-iframe.d.ts

@@ -0,0 +1,3 @@
+/** Locate the active page's webview iframe — the last one in the simulator stack. */
+export declare function getActivePageIframe(): HTMLIFrameElement | null;
+//# sourceMappingURL=page-iframe.d.ts.map

package/dist/preload/shared/page-iframe.js

@@ -0,0 +1,6 @@
+/** Locate the active page's webview iframe — the last one in the simulator stack. */
+export function getActivePageIframe() {
+    const iframes = document.querySelectorAll('.dimina-native-webview__window');
+    return iframes.length > 0 ? iframes[iframes.length - 1] : null;
+}
+//# sourceMappingURL=page-iframe.js.map

package/dist/preload/shared/types.d.ts

@@ -6,6 +6,7 @@
  */
 import type { Snapshot, StorageSnapshot, WxmlNode } from '../runtime/bridge.js';
 import type { ElementInspection } from '../../shared/ipc-channels.js';
+import type { MiniappSnapshotApi } from '../miniapp-snapshot/types.js';
 /** The simulator data bridge exposed via contextBridge. */
 export interface SimulatorDataBridge {
     getAppdata: () => Record<string, unknown>;
@@ -30,6 +31,7 @@ declare global {
         __simulatorData?: SimulatorDataBridge;
         __deviceInfo?: unknown;
         __simulatorHook?: SimulatorHook;
+        __miniappSnapshot?: MiniappSnapshotApi;
     }
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/preload/windows/main.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/preload/windows/main.ts
+var main_exports = {};
+module.exports = __toCommonJS(main_exports);
+var import_electron = require("electron");
+var api = {
+  ipc: {
+    invoke: (channel, ...args) => import_electron.ipcRenderer.invoke(channel, ...args),
+    send: (channel, ...args) => {
+      import_electron.ipcRenderer.send(channel, ...args);
+    },
+    on: (channel, listener) => {
+      import_electron.ipcRenderer.on(channel, listener);
+      return () => import_electron.ipcRenderer.removeListener(channel, listener);
+    },
+    once: (channel, listener) => {
+      import_electron.ipcRenderer.once(channel, listener);
+    },
+    removeListener: (channel, listener) => {
+      import_electron.ipcRenderer.removeListener(channel, listener);
+    }
+  }
+};
+import_electron.contextBridge.exposeInMainWorld("devtools", api);
+if (process.env.NODE_ENV === "test") {
+  import_electron.contextBridge.exposeInMainWorld("__testIpc", {
+    emit: (channel, ...args) => {
+      ;
+      import_electron.ipcRenderer.emit(channel, ...args);
+    }
+  });
+}
+//# sourceMappingURL=main.cjs.map

package/dist/preload/windows/main.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/preload/windows/main.ts"],
+  "sourcesContent": ["/**\n * Preload bridge for the main window, settings window, settings overlay\n * view, and popover overlay view. Exposes a minimal, typed `window.devtools`\n * surface so the renderer never has to call `window.require('electron')`.\n *\n * This file is bundled by esbuild to CJS at `dist/preload/windows/main.js`\n * (see package.json `build:preload`). It must remain a leaf module \u2014 do\n * NOT import other preload files via `.js` ESM specifiers; everything goes\n * through the Electron `contextBridge` / `ipcRenderer` runtime.\n *\n * Channel governance lives in the main process: `sender-policy.ts` plus the\n * per-handler zod schemas decide what's accepted. The preload layer is a\n * thin pass-through \u2014 a renderer inventing channel names will just hit a\n * main-side rejection, so duplicating an allowlist here added no real\n * defense for a devtool that loads user-trusted mini-programs.\n */\nimport { contextBridge, ipcRenderer, type IpcRendererEvent } from 'electron'\n\nconst api = {\n  ipc: {\n    invoke: (channel: string, ...args: unknown[]) => ipcRenderer.invoke(channel, ...args),\n    send: (channel: string, ...args: unknown[]) => {\n      ipcRenderer.send(channel, ...args)\n    },\n    on: (\n      channel: string,\n      listener: (event: IpcRendererEvent, ...args: unknown[]) => void,\n    ) => {\n      ipcRenderer.on(channel, listener)\n      return () => ipcRenderer.removeListener(channel, listener)\n    },\n    once: (\n      channel: string,\n      listener: (event: IpcRendererEvent, ...args: unknown[]) => void,\n    ) => {\n      ipcRenderer.once(channel, listener)\n    },\n    removeListener: (\n      channel: string,\n      listener: (...args: unknown[]) => void,\n    ) => {\n      ipcRenderer.removeListener(channel, listener)\n    },\n  },\n}\n\n// All host windows that load this preload run with `contextIsolation: true`\n// (main / settings / view-manager), so `contextBridge` is the path that\n// reaches the renderer's `window`. The simulator <webview> uses a separate\n// preload (`simulator.ts`).\ncontextBridge.exposeInMainWorld('devtools', api)\n\n// Test-only hatch: e2e helpers emit synthetic IPC events on the renderer's\n// ipcRenderer instance to trigger handlers registered via `devtools.ipc.on`\n// without round-tripping through the main process. Gated on NODE_ENV so\n// production builds never expose it.\nif (process.env.NODE_ENV === 'test') {\n  contextBridge.exposeInMainWorld('__testIpc', {\n    emit: (channel: string, ...args: unknown[]) => {\n      ;(ipcRenderer as unknown as { emit: (c: string, ...a: unknown[]) => void }).emit(channel, ...args)\n    },\n  })\n}\n\nexport type DevtoolsApi = typeof api\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAAA;AAAA;AAgBA,sBAAkE;AAElE,IAAM,MAAM;AAAA,EACV,KAAK;AAAA,IACH,QAAQ,CAAC,YAAoB,SAAoB,4BAAY,OAAO,SAAS,GAAG,IAAI;AAAA,IACpF,MAAM,CAAC,YAAoB,SAAoB;AAC7C,kCAAY,KAAK,SAAS,GAAG,IAAI;AAAA,IACnC;AAAA,IACA,IAAI,CACF,SACA,aACG;AACH,kCAAY,GAAG,SAAS,QAAQ;AAChC,aAAO,MAAM,4BAAY,eAAe,SAAS,QAAQ;AAAA,IAC3D;AAAA,IACA,MAAM,CACJ,SACA,aACG;AACH,kCAAY,KAAK,SAAS,QAAQ;AAAA,IACpC;AAAA,IACA,gBAAgB,CACd,SACA,aACG;AACH,kCAAY,eAAe,SAAS,QAAQ;AAAA,IAC9C;AAAA,EACF;AACF;AAMA,8BAAc,kBAAkB,YAAY,GAAG;AAM/C,IAAI,QAAQ,IAAI,aAAa,QAAQ;AACnC,gCAAc,kBAAkB,aAAa;AAAA,IAC3C,MAAM,CAAC,YAAoB,SAAoB;AAC7C;AAAC,MAAC,4BAA0E,KAAK,SAAS,GAAG,IAAI;AAAA,IACnG;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}