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

package/dist/preload/instrumentation/wxml.js

@@ -1,13 +1,7 @@
-import { SimulatorChannel } from '../../shared/ipc-channels.js';
-import { sendToHost } from '../runtime/host.js';
 import { clearWxmlSnapshot, setWxmlSnapshot, unhighlightElement, } from '../runtime/bridge.js';
 import { WXML_DEBOUNCE_MS, WXML_RETRY_INTERVAL_MS, WXML_RETRY_TIMEOUT_MS, NAVIGATION_POLL_INTERVAL_MS, NAVIGATION_TIMEOUT_MS, } from '../shared/constants.js';
-import { createDisposableSet } from './disposable.js';
 import { walkInstance } from './wxml-extract.js';
-function findActivePageIframe() {
-    const iframes = document.querySelectorAll('.dimina-native-webview__window');
-    return iframes.length > 0 ? iframes[iframes.length - 1] : null;
-}
+import { getActivePageIframe } from '../shared/page-iframe.js';
 function getVueAppFromIframe(iframe) {
     try {
         const doc = iframe.contentDocument;
@@ -27,197 +21,213 @@ function getVueAppFromIframe(iframe) {
         return null;
     }
 }
-let wxmlTimer;
-let currentObserver = null;
-let currentIframe = null;
-let topObserver = null;
-let retryTimer;
-let retryTimeout;
-let navigationWaitTimer;
-let navigationWaitTimeout;
-const disposables = createDisposableSet();
-function clearTimers() {
-    if (wxmlTimer)
-        clearTimeout(wxmlTimer);
-    if (retryTimer)
-        clearInterval(retryTimer);
-    if (retryTimeout)
-        clearTimeout(retryTimeout);
-    if (navigationWaitTimer)
-        clearInterval(navigationWaitTimer);
-    if (navigationWaitTimeout)
-        clearTimeout(navigationWaitTimeout);
-    wxmlTimer = undefined;
-    retryTimer = undefined;
-    retryTimeout = undefined;
-    navigationWaitTimer = undefined;
-    navigationWaitTimeout = undefined;
-}
-function publishTree(tree) {
-    if (tree) {
-        const normalized = Array.isArray(tree)
-            ? { tagName: '#fragment', attrs: {}, children: tree }
-            : tree;
-        setWxmlSnapshot(normalized, true);
-        sendToHost(SimulatorChannel.Wxml, normalized);
-        return;
-    }
-    clearWxmlSnapshot();
-    unhighlightElement();
-}
-function sendWxmlTree() {
-    const iframe = findActivePageIframe();
-    if (!iframe) {
-        publishTree(null);
-        return;
-    }
+/** Compute the normalized WXML tree for the currently-active page, or `null`. */
+function computeWxmlTree() {
+    const iframe = getActivePageIframe();
+    if (!iframe)
+        return null;
     const instance = getVueAppFromIframe(iframe);
-    if (!instance) {
-        publishTree(null);
-        return;
-    }
+    if (!instance)
+        return null;
     const tree = walkInstance(instance, 0);
-    if (!tree) {
-        publishTree(null);
-        return;
-    }
-    publishTree(tree);
+    if (!tree)
+        return null;
+    return Array.isArray(tree)
+        ? { tagName: '#fragment', attrs: {}, children: tree }
+        : tree;
 }
-function observeIframe(iframe) {
-    if (iframe === currentIframe)
-        return;
-    if (currentObserver) {
-        currentObserver.disconnect();
-        currentObserver = null;
-    }
-    if (navigationWaitTimer) {
-        clearInterval(navigationWaitTimer);
+/**
+ * The WXML snapshot data source.
+ *
+ * Observes the simulator page's Vue tree (retry-attach + MutationObserver +
+ * top-level navigation observer), recomputes a normalized {@link WxmlNode}
+ * tree on every (debounced) change, stores it internally, and calls `emit()`
+ * so the `miniappSnapshot` host publishes it. The source itself never touches
+ * IPC — the host owns the push/pull transport and the install-time publish.
+ *
+ * It keeps the `__simulatorData.getWxml()` automation surface working by
+ * mirroring each computed tree into the simulator bridge via
+ * `setWxmlSnapshot` / `clearWxmlSnapshot`.
+ */
+export function createWxmlSource() {
+    let tree = null;
+    let emit = null;
+    let wxmlTimer;
+    let currentObserver = null;
+    let currentIframe = null;
+    let topObserver = null;
+    let retryTimer;
+    let retryTimeout;
+    let navigationWaitTimer;
+    let navigationWaitTimeout;
+    function clearTimers() {
+        if (wxmlTimer)
+            clearTimeout(wxmlTimer);
+        if (retryTimer)
+            clearInterval(retryTimer);
+        if (retryTimeout)
+            clearTimeout(retryTimeout);
+        if (navigationWaitTimer)
+            clearInterval(navigationWaitTimer);
+        if (navigationWaitTimeout)
+            clearTimeout(navigationWaitTimeout);
+        wxmlTimer = undefined;
+        retryTimer = undefined;
+        retryTimeout = undefined;
         navigationWaitTimer = undefined;
-    }
-    if (navigationWaitTimeout) {
-        clearTimeout(navigationWaitTimeout);
         navigationWaitTimeout = undefined;
     }
-    currentIframe = iframe;
-    const doc = iframe.contentDocument;
-    if (!doc?.body) {
-        publishTree(null);
-        return;
+    /**
+     * Recompute the tree, store it, mirror it to the automation bridge, and
+     * notify the host. The single update path shared by attach, navigation and
+     * MutationObserver callbacks.
+     */
+    function refresh() {
+        tree = computeWxmlTree();
+        if (tree) {
+            setWxmlSnapshot(tree, true);
+        }
+        else {
+            clearWxmlSnapshot();
+            unhighlightElement();
+        }
+        emit?.();
     }
-    sendWxmlTree();
-    currentObserver = new MutationObserver(() => {
-        clearTimeout(wxmlTimer);
-        wxmlTimer = setTimeout(sendWxmlTree, WXML_DEBOUNCE_MS);
-    });
-    currentObserver.observe(doc.body, { childList: true, subtree: true });
-}
-function tryAttach() {
-    const iframe = findActivePageIframe();
-    if (!iframe)
-        return false;
-    const instance = getVueAppFromIframe(iframe);
-    if (!instance)
-        return false;
-    observeIframe(iframe);
-    return true;
-}
-function scheduleAttach() {
-    if (retryTimer)
-        clearInterval(retryTimer);
-    if (retryTimeout)
-        clearTimeout(retryTimeout);
-    retryTimer = setInterval(() => {
-        if (tryAttach() && retryTimer) {
-            clearInterval(retryTimer);
-            retryTimer = undefined;
+    function observeIframe(iframe) {
+        if (iframe === currentIframe)
+            return;
+        if (currentObserver) {
+            currentObserver.disconnect();
+            currentObserver = null;
         }
-    }, WXML_RETRY_INTERVAL_MS);
-    retryTimeout = setTimeout(() => {
-        if (retryTimer)
-            clearInterval(retryTimer);
-        retryTimer = undefined;
-    }, WXML_RETRY_TIMEOUT_MS);
-}
-function observeTopLevel() {
-    if (topObserver)
-        return;
-    topObserver = new MutationObserver(() => {
-        const iframe = findActivePageIframe();
-        if (!iframe) {
-            publishTree(null);
+        if (navigationWaitTimer) {
+            clearInterval(navigationWaitTimer);
+            navigationWaitTimer = undefined;
+        }
+        if (navigationWaitTimeout) {
+            clearTimeout(navigationWaitTimeout);
+            navigationWaitTimeout = undefined;
+        }
+        currentIframe = iframe;
+        const doc = iframe.contentDocument;
+        if (!doc?.body) {
+            refresh();
             return;
         }
-        if (iframe !== currentIframe) {
-            if (navigationWaitTimer) {
-                clearInterval(navigationWaitTimer);
-                navigationWaitTimer = undefined;
+        refresh();
+        currentObserver = new MutationObserver(() => {
+            clearTimeout(wxmlTimer);
+            wxmlTimer = setTimeout(refresh, WXML_DEBOUNCE_MS);
+        });
+        currentObserver.observe(doc.body, { childList: true, subtree: true });
+    }
+    function tryAttach() {
+        const iframe = getActivePageIframe();
+        if (!iframe)
+            return false;
+        const instance = getVueAppFromIframe(iframe);
+        if (!instance)
+            return false;
+        observeIframe(iframe);
+        return true;
+    }
+    function scheduleAttach() {
+        if (retryTimer)
+            clearInterval(retryTimer);
+        if (retryTimeout)
+            clearTimeout(retryTimeout);
+        retryTimer = setInterval(() => {
+            if (tryAttach() && retryTimer) {
+                clearInterval(retryTimer);
+                retryTimer = undefined;
             }
-            if (navigationWaitTimeout) {
-                clearTimeout(navigationWaitTimeout);
-                navigationWaitTimeout = undefined;
+        }, WXML_RETRY_INTERVAL_MS);
+        retryTimeout = setTimeout(() => {
+            if (retryTimer)
+                clearInterval(retryTimer);
+            retryTimer = undefined;
+        }, WXML_RETRY_TIMEOUT_MS);
+    }
+    function observeTopLevel() {
+        if (topObserver)
+            return;
+        topObserver = new MutationObserver(() => {
+            const iframe = getActivePageIframe();
+            if (!iframe) {
+                refresh();
+                return;
             }
-            navigationWaitTimer = setInterval(() => {
-                if (getVueAppFromIframe(iframe)) {
+            if (iframe !== currentIframe) {
+                if (navigationWaitTimer) {
+                    clearInterval(navigationWaitTimer);
+                    navigationWaitTimer = undefined;
+                }
+                if (navigationWaitTimeout) {
+                    clearTimeout(navigationWaitTimeout);
+                    navigationWaitTimeout = undefined;
+                }
+                navigationWaitTimer = setInterval(() => {
+                    if (getVueAppFromIframe(iframe)) {
+                        if (navigationWaitTimer) {
+                            clearInterval(navigationWaitTimer);
+                            navigationWaitTimer = undefined;
+                        }
+                        if (navigationWaitTimeout) {
+                            clearTimeout(navigationWaitTimeout);
+                            navigationWaitTimeout = undefined;
+                        }
+                        observeIframe(iframe);
+                    }
+                }, NAVIGATION_POLL_INTERVAL_MS);
+                navigationWaitTimeout = setTimeout(() => {
                     if (navigationWaitTimer) {
                         clearInterval(navigationWaitTimer);
                         navigationWaitTimer = undefined;
                     }
-                    if (navigationWaitTimeout) {
-                        clearTimeout(navigationWaitTimeout);
-                        navigationWaitTimeout = undefined;
-                    }
-                    observeIframe(iframe);
-                }
-            }, NAVIGATION_POLL_INTERVAL_MS);
-            navigationWaitTimeout = setTimeout(() => {
-                if (navigationWaitTimer) {
-                    clearInterval(navigationWaitTimer);
-                    navigationWaitTimer = undefined;
+                    navigationWaitTimeout = undefined;
+                }, NAVIGATION_TIMEOUT_MS);
+            }
+        });
+        if (document.body) {
+            topObserver.observe(document.body, { childList: true, subtree: true });
+        }
+        else {
+            document.addEventListener('DOMContentLoaded', () => {
+                if (document.body && topObserver) {
+                    topObserver.observe(document.body, { childList: true, subtree: true });
                 }
-                navigationWaitTimeout = undefined;
-            }, NAVIGATION_TIMEOUT_MS);
+            }, { once: true });
         }
-    });
-    if (document.body) {
-        topObserver.observe(document.body, { childList: true, subtree: true });
     }
-    else {
-        document.addEventListener('DOMContentLoaded', () => {
-            if (document.body && topObserver) {
-                topObserver.observe(document.body, { childList: true, subtree: true });
+    return {
+        id: 'wxml',
+        snapshot: () => tree,
+        start(onChange) {
+            emit = onChange;
+            // If a page with a mounted Vue app is already present, observeIframe()
+            // computes & stores the tree synchronously and emits once. Otherwise the
+            // retry timer drives the first emit once a page mounts.
+            if (!tryAttach()) {
+                scheduleAttach();
             }
-        }, { once: true });
-    }
-}
-export function installWxmlInstrumentation() {
-    if (!tryAttach()) {
-        scheduleAttach();
-    }
-    observeTopLevel();
-    disposables.add(() => {
-        if (currentObserver) {
-            currentObserver.disconnect();
-            currentObserver = null;
-        }
-    });
-    disposables.add(() => {
-        if (topObserver) {
-            topObserver.disconnect();
-            topObserver = null;
-        }
-    });
-    disposables.add(() => {
-        currentIframe = null;
-        clearTimers();
-    });
-    disposables.add(() => {
-        clearWxmlSnapshot();
-        unhighlightElement();
-    });
-    return () => {
-        disposables.disposeAll();
+            observeTopLevel();
+        },
+        dispose() {
+            if (currentObserver) {
+                currentObserver.disconnect();
+                currentObserver = null;
+            }
+            if (topObserver) {
+                topObserver.disconnect();
+                topObserver = null;
+            }
+            currentIframe = null;
+            clearTimers();
+            clearWxmlSnapshot();
+            unhighlightElement();
+            tree = null;
+            emit = null;
+        },
     };
 }
-export const setupWxmlObserver = installWxmlInstrumentation;
-export { sendWxmlTree };
 //# sourceMappingURL=wxml.js.map

package/dist/preload/miniapp-snapshot/host.d.ts

@@ -0,0 +1,12 @@
+/**
+ * miniappSnapshot — preload-side host.
+ *
+ * The hub that owns every data source's lifecycle plus the push/pull
+ * transport. preload registers sources, then calls `install()` once.
+ *
+ * See `./types.ts` for the contract and `docs/miniapp-snapshot.md` for the
+ * architecture rationale.
+ */
+import type { MiniappSnapshotHost } from './types.js';
+export declare function createMiniappSnapshotHost(): MiniappSnapshotHost;
+//# sourceMappingURL=host.d.ts.map

package/dist/preload/miniapp-snapshot/host.js

@@ -0,0 +1,117 @@
+/**
+ * miniappSnapshot — preload-side host.
+ *
+ * The hub that owns every data source's lifecycle plus the push/pull
+ * transport. preload registers sources, then calls `install()` once.
+ *
+ * See `./types.ts` for the contract and `docs/miniapp-snapshot.md` for the
+ * architecture rationale.
+ */
+import { contextBridge } from 'electron';
+import { MiniappSnapshotChannel } from '../../shared/ipc-channels.js';
+import { onHostMessage, sendToHost } from '../runtime/host.js';
+/** Page-global key under which the automation accessor is exposed. */
+const ACCESSOR_KEY = '__miniappSnapshot';
+/**
+ * Expose `api` on the page global as `__miniappSnapshot`, preferring
+ * `contextBridge.exposeInMainWorld` and falling back to a direct `window`
+ * assignment when the context bridge is unavailable. Returns a disposer that
+ * restores the previous `window` state — mirroring `bridge.ts`.
+ */
+function exposeApi(api) {
+    try {
+        contextBridge.exposeInMainWorld(ACCESSOR_KEY, api);
+    }
+    catch {
+        ;
+        window.__miniappSnapshot = api;
+    }
+    return () => {
+        const windowRef = window;
+        if (windowRef[ACCESSOR_KEY] === api) {
+            delete windowRef[ACCESSOR_KEY];
+        }
+    };
+}
+export function createMiniappSnapshotHost() {
+    const sources = [];
+    const byId = new Map();
+    let installed = false;
+    let disposed = false;
+    // Global, strictly-increasing publish counter shared across every source.
+    let seq = 0;
+    /**
+     * Read a fresh snapshot of `source` and push it over the Push channel with
+     * a freshly-allocated global `seq`. The single publish path shared by the
+     * initial install, runtime `emit()`, and renderer-initiated `pull`.
+     */
+    function publish(source) {
+        if (disposed)
+            return;
+        seq += 1;
+        const envelope = {
+            id: source.id,
+            seq,
+            ts: Date.now(),
+            data: source.snapshot(),
+        };
+        sendToHost(MiniappSnapshotChannel.Push, envelope);
+    }
+    function register(source) {
+        if (installed) {
+            throw new Error('MiniappSnapshotHost: register() called after install()');
+        }
+        if (byId.has(source.id)) {
+            throw new Error(`MiniappSnapshotHost: duplicate source id "${source.id}"`);
+        }
+        const erased = source;
+        byId.set(source.id, erased);
+        sources.push(erased);
+    }
+    function install() {
+        if (installed) {
+            throw new Error('MiniappSnapshotHost: install() called twice');
+        }
+        installed = true;
+        for (const source of sources) {
+            // Each source gets its own emit callback bound to that source, so
+            // emit() publishes exactly the calling source (fresh snapshot, fresh
+            // seq). After disposal `publish` is a no-op via the `disposed` guard.
+            source.start(() => publish(source));
+            // Fixed framework step: publish the initial snapshot immediately after
+            // start() — reload re-sync is install() re-running, not a per-source
+            // responsibility.
+            publish(source);
+        }
+        const disposePull = onHostMessage(MiniappSnapshotChannel.Pull, (...args) => {
+            const payload = args[0];
+            const id = payload?.id;
+            if (typeof id !== 'string')
+                return;
+            const source = byId.get(id);
+            if (!source)
+                return;
+            publish(source);
+        });
+        // Synchronous automation accessor — lets the main process / e2e / MCP
+        // read any panel's current snapshot via `executeJavaScript`. `get` reads
+        // `source.snapshot()` fresh on every call (never cached).
+        const api = {
+            get: (id) => byId.get(id)?.snapshot(),
+            ids: () => sources.map((source) => source.id),
+        };
+        const disposeApi = exposeApi(api);
+        return () => {
+            if (disposed)
+                return;
+            disposed = true;
+            disposePull();
+            disposeApi();
+            for (const source of sources) {
+                source.dispose();
+            }
+        };
+    }
+    return { register, install };
+}
+//# sourceMappingURL=host.js.map

package/dist/preload/miniapp-snapshot/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * miniappSnapshot — preload-side contract.
+ *
+ * `miniappSnapshot` is the unified snapshot framework shared by devtools
+ * panels (AppData, WXML, …). preload is the single source of truth; the
+ * renderer is a pure projection of immutable full snapshots.
+ *
+ * This file is the CONTRACT only — it declares the interfaces every data
+ * source and the host must satisfy. The host implementation lives in
+ * `./host.ts`.
+ *
+ * See `docs/miniapp-snapshot.md` for the architecture rationale.
+ */
+/** Identifier of one snapshot data source, e.g. 'appdata' | 'wxml'. */
+export type SnapshotSourceId = string;
+/**
+ * The transport unit: a full snapshot plus its metadata.
+ *
+ * - `seq` is a GLOBAL strictly-increasing integer shared across every
+ *   source, so the renderer can drop stale envelopes and panels can be
+ *   aligned to the same moment.
+ * - `ts` is `Date.now()` at publish time.
+ * - `data` is the full, immutable snapshot — the renderer replaces its
+ *   state wholesale, never merges.
+ */
+export interface SnapshotEnvelope<T = unknown> {
+    id: SnapshotSourceId;
+    seq: number;
+    ts: number;
+    data: T;
+}
+/** A preload-side data source that produces full snapshots of one panel's state. */
+export interface MiniappSnapshotSource<T = unknown> {
+    readonly id: SnapshotSourceId;
+    /** Current full snapshot — the source of truth. Called fresh at each publish. */
+    snapshot(): T;
+    /** Begin observing. `emit` must be called by the source whenever its snapshot changes. */
+    start(emit: () => void): void;
+    /** Tear down observers. */
+    dispose(): void;
+}
+/**
+ * The hub: manages every data source's lifecycle plus the push/pull
+ * transport. preload registers sources, then calls `install()` once.
+ */
+export interface MiniappSnapshotHost {
+    register<T>(source: MiniappSnapshotSource<T>): void;
+    /** Starts every source, publishes each initial snapshot, wires the pull channel. Returns a disposer. */
+    install(): () => void;
+}
+/**
+ * Synchronous automation accessor exposed on the page global as
+ * `__miniappSnapshot` by `install()`. Lets the main process / e2e / MCP read
+ * any registered panel's current snapshot via `webContents.executeJavaScript`.
+ */
+export interface MiniappSnapshotApi {
+    /** Fresh `source.snapshot()` result for `id`, or `undefined` for an unknown id. */
+    get(id: SnapshotSourceId): unknown;
+    /** Registered source ids, in registration order. */
+    ids(): SnapshotSourceId[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/preload/miniapp-snapshot/types.js

@@ -0,0 +1,15 @@
+/**
+ * miniappSnapshot — preload-side contract.
+ *
+ * `miniappSnapshot` is the unified snapshot framework shared by devtools
+ * panels (AppData, WXML, …). preload is the single source of truth; the
+ * renderer is a pure projection of immutable full snapshots.
+ *
+ * This file is the CONTRACT only — it declares the interfaces every data
+ * source and the host must satisfy. The host implementation lives in
+ * `./host.ts`.
+ *
+ * See `docs/miniapp-snapshot.md` for the architecture rationale.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/preload/runtime/bridge.js

@@ -1,4 +1,5 @@
-import { contextBridge } from 'electron';
+import { exposeOnMainWorld } from '../shared/expose.js';
+import { getActivePageIframe } from '../shared/page-iframe.js';
 const state = {
     appdata: { gen: 0, ready: true, data: {} },
     storage: { gen: 0, ready: false, namespace: null, data: {} },
@@ -47,10 +48,6 @@ function clone(value) {
         return value;
     }
 }
-function getPageIframe() {
-    const iframes = document.querySelectorAll('.dimina-native-webview__window');
-    return iframes.length > 0 ? iframes[iframes.length - 1] : null;
-}
 function ensureOverlay(doc) {
     if (highlightOverlay && highlightOverlay.ownerDocument === doc)
         return highlightOverlay;
@@ -66,7 +63,7 @@ function ensureOverlay(doc) {
 function highlightElement(sid) {
     if (!sid)
         return null;
-    const iframe = getPageIframe();
+    const iframe = getActivePageIframe();
     if (!iframe?.contentDocument)
         return null;
     const doc = iframe.contentDocument;
@@ -177,26 +174,10 @@ export function installSimulatorBridge() {
     if (!exposedApi) {
         exposedApi = buildApi();
     }
-    try {
-        contextBridge.exposeInMainWorld('__simulatorData', {
-            ...exposedApi,
-            getAppdata: () => clone(state.appdata.data),
-            getAppdataSnapshot: () => clone(state.appdata),
-            getStorageSnapshot: () => clone(state.storage),
-            getWxml: () => clone(state.wxml.data),
-            getWxmlSnapshot: () => clone(state.wxml),
-        });
-    }
-    catch {
-        ;
-        window.__simulatorData = exposedApi;
-    }
+    const dispose = exposeOnMainWorld('__simulatorData', exposedApi);
     return () => {
         resetBridgeState();
-        const windowRef = window;
-        if (windowRef.__simulatorData === exposedApi) {
-            delete windowRef.__simulatorData;
-        }
+        dispose();
     };
 }
 //# sourceMappingURL=bridge.js.map

package/dist/preload/runtime/custom-apis.d.ts

@@ -0,0 +1,6 @@
+export interface DiminaCustomApisBridge {
+    list(): Promise<string[]>;
+    invoke(name: string, params: unknown): Promise<unknown>;
+}
+export declare function installCustomApisBridge(): () => void;
+//# sourceMappingURL=custom-apis.d.ts.map