@dimina-kit/devtools 0.1.0-dev.20260422094158

package/dist/preload/windows/simulator.js

@@ -0,0 +1,969 @@
+"use strict";
+
+// src/preload/runtime/bridge.ts
+var import_electron = require("electron");
+var state = {
+  appdata: { gen: 0, ready: true, data: {} },
+  storage: { gen: 0, ready: false, namespace: null, data: {} },
+  wxml: { gen: 0, ready: false, data: null },
+  refreshHandler: null
+};
+var highlightOverlay = null;
+var exposedApi = null;
+function clone(value) {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    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;
+  highlightOverlay = doc.createElement("div");
+  highlightOverlay.id = "__simulator-highlight";
+  highlightOverlay.style.cssText = "position:fixed;pointer-events:none;z-index:999999;border:2px solid #1a73e8;background:rgba(26,115,232,0.12);transition:all 0.1s ease;display:none;border-radius:2px;";
+  doc.body.appendChild(highlightOverlay);
+  return highlightOverlay;
+}
+function highlightElement(sid) {
+  const iframe = getPageIframe();
+  if (!iframe?.contentDocument) return;
+  const doc = iframe.contentDocument;
+  const el = doc.querySelector(`[data-sid="${sid}"]`);
+  if (!el) return;
+  const rect = el.getBoundingClientRect();
+  const overlay = ensureOverlay(doc);
+  overlay.style.left = `${rect.left}px`;
+  overlay.style.top = `${rect.top}px`;
+  overlay.style.width = `${rect.width}px`;
+  overlay.style.height = `${rect.height}px`;
+  overlay.style.display = "block";
+}
+function unhighlightElement() {
+  if (highlightOverlay) highlightOverlay.style.display = "none";
+}
+function buildApi() {
+  return {
+    getAppdata: () => clone(state.appdata.data),
+    getAppdataSnapshot: () => clone(state.appdata),
+    getAppdataGen: () => state.appdata.gen,
+    getStorageSnapshot: () => clone(state.storage),
+    getStorageGen: () => state.storage.gen,
+    getWxml: () => clone(state.wxml.data),
+    getWxmlSnapshot: () => clone(state.wxml),
+    getWxmlGen: () => state.wxml.gen,
+    refresh: (type) => state.refreshHandler?.(type),
+    highlightElement,
+    unhighlightElement
+  };
+}
+function setAppDataSnapshot(data) {
+  state.appdata = {
+    gen: state.appdata.gen + 1,
+    ready: true,
+    data: clone(data)
+  };
+}
+function clearAppDataSnapshot() {
+  state.appdata = {
+    gen: state.appdata.gen + 1,
+    ready: true,
+    data: {}
+  };
+}
+function setStorageSnapshot(namespace, data) {
+  state.storage = {
+    gen: state.storage.gen + 1,
+    ready: namespace !== null,
+    namespace,
+    data: clone(data)
+  };
+}
+function clearStorageSnapshot() {
+  state.storage = {
+    gen: state.storage.gen + 1,
+    ready: false,
+    namespace: null,
+    data: {}
+  };
+}
+function setWxmlSnapshot(data, ready = true) {
+  state.wxml = {
+    gen: state.wxml.gen + 1,
+    ready,
+    data: clone(data)
+  };
+}
+function clearWxmlSnapshot() {
+  state.wxml = {
+    gen: state.wxml.gen + 1,
+    ready: false,
+    data: null
+  };
+}
+function resetBridgeState() {
+  clearAppDataSnapshot();
+  clearStorageSnapshot();
+  clearWxmlSnapshot();
+  unhighlightElement();
+  state.refreshHandler = null;
+}
+function installSimulatorBridge() {
+  if (!exposedApi) {
+    exposedApi = buildApi();
+  }
+  try {
+    import_electron.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;
+  }
+  return () => {
+    resetBridgeState();
+    const windowRef = window;
+    if (windowRef.__simulatorData === exposedApi) {
+      delete windowRef.__simulatorData;
+    }
+  };
+}
+
+// src/shared/ipc-channels.ts
+var SimulatorChannel = {
+  Attach: "simulator:attach",
+  Detach: "simulator:detach",
+  Resize: "simulator:resize",
+  SetVisible: "simulator:setVisible",
+  Console: "simulator:console",
+  Wxml: "simulator:wxml",
+  AppData: "simulator:appdata",
+  AppDataAll: "simulator:appdata-all",
+  Storage: "simulator:storage",
+  StorageAll: "simulator:storage-all"
+};
+
+// src/preload/runtime/host.ts
+var import_electron2 = require("electron");
+function sendToHost(channel, data) {
+  import_electron2.ipcRenderer.sendToHost(channel, data);
+}
+function safeSerialize(val) {
+  if (val === null || val === void 0) return val;
+  if (typeof val === "function") return `[Function: ${val.name || "anonymous"}]`;
+  if (typeof val !== "object") return val;
+  if (val instanceof Error) return { __isError: true, message: val.message, stack: val.stack };
+  try {
+    return structuredClone(val);
+  } catch {
+  }
+  try {
+    return JSON.parse(JSON.stringify(val));
+  } catch {
+  }
+  return String(val);
+}
+
+// src/preload/instrumentation/console.ts
+function installConsoleInstrumentation() {
+  const consoleRef = console;
+  const originals = /* @__PURE__ */ new Map();
+  const levels = ["log", "warn", "error", "info", "debug"];
+  for (const level of levels) {
+    const original = consoleRef[level]?.bind(console);
+    if (!original) continue;
+    originals.set(level, original);
+    consoleRef[level] = (...args) => {
+      original(...args);
+      sendToHost(SimulatorChannel.Console, {
+        source: "container",
+        level,
+        args: args.map(safeSerialize),
+        ts: Date.now()
+      });
+    };
+  }
+  const handleError = (event) => {
+    sendToHost(SimulatorChannel.Console, {
+      source: "container",
+      level: "error",
+      args: [{
+        message: event.message,
+        source: event.filename,
+        lineno: event.lineno,
+        colno: event.colno,
+        stack: event.error?.stack
+      }],
+      ts: Date.now()
+    });
+  };
+  const handleRejection = (event) => {
+    sendToHost(SimulatorChannel.Console, {
+      source: "container",
+      level: "error",
+      args: [{ message: "Unhandled Promise Rejection", reason: String(event.reason) }],
+      ts: Date.now()
+    });
+  };
+  window.addEventListener("error", handleError);
+  window.addEventListener("unhandledrejection", handleRejection);
+  return () => {
+    for (const [level, original] of originals) {
+      consoleRef[level] = original;
+    }
+    window.removeEventListener("error", handleError);
+    window.removeEventListener("unhandledrejection", handleRejection);
+  };
+}
+
+// src/preload/instrumentation/disposable.ts
+function createDisposableSet() {
+  const disposables2 = [];
+  return {
+    add: (fn) => disposables2.push(fn),
+    disposeAll: () => {
+      disposables2.forEach((fn) => fn());
+      disposables2.length = 0;
+    }
+  };
+}
+
+// src/preload/instrumentation/storage.ts
+var STORAGE_PREFIX = /^#\/?/;
+function getStorageNamespace() {
+  const hash = window.location.hash || "";
+  const normalized = hash.replace(STORAGE_PREFIX, "");
+  const candidate = normalized.split(/[|/?&]/, 1)[0]?.trim();
+  return candidate ? candidate : null;
+}
+function normalizeStorageKey(rawKey, namespace) {
+  const prefix = `${namespace}_`;
+  if (!rawKey.startsWith(prefix)) return null;
+  return rawKey.slice(prefix.length);
+}
+function readSnapshot(namespace) {
+  if (!namespace) return {};
+  const items = {};
+  for (let i = 0; i < localStorage.length; i++) {
+    const key = localStorage.key(i);
+    if (!key) continue;
+    const normalized = normalizeStorageKey(key, namespace);
+    if (normalized === null) continue;
+    items[normalized] = localStorage.getItem(key) ?? "";
+  }
+  return items;
+}
+function syncSnapshot(namespace) {
+  if (!namespace) {
+    clearStorageSnapshot();
+    return;
+  }
+  setStorageSnapshot(namespace, readSnapshot(namespace));
+}
+function installStorageInstrumentation() {
+  const originalSetItem = localStorage.setItem.bind(localStorage);
+  const originalRemoveItem = localStorage.removeItem.bind(localStorage);
+  const namespaceRef = { value: getStorageNamespace() };
+  const handleNamespaceChange = () => {
+    namespaceRef.value = getStorageNamespace();
+    syncSnapshot(namespaceRef.value);
+  };
+  const handleSetItem = (key, value) => {
+    const namespace = namespaceRef.value;
+    originalSetItem(key, value);
+    if (namespace) {
+      const normalized = normalizeStorageKey(key, namespace);
+      if (normalized !== null) {
+        const snapshot = readSnapshot(namespace);
+        setStorageSnapshot(namespace, snapshot);
+        sendToHost(SimulatorChannel.Storage, {
+          namespace,
+          action: "set",
+          key: normalized,
+          rawKey: key,
+          value,
+          ts: Date.now()
+        });
+      }
+    }
+  };
+  const handleRemoveItem = (key) => {
+    const namespace = namespaceRef.value;
+    originalRemoveItem(key);
+    if (namespace) {
+      const normalized = normalizeStorageKey(key, namespace);
+      if (normalized !== null) {
+        const snapshot = readSnapshot(namespace);
+        setStorageSnapshot(namespace, snapshot);
+        sendToHost(SimulatorChannel.Storage, {
+          namespace,
+          action: "remove",
+          key: normalized,
+          rawKey: key,
+          ts: Date.now()
+        });
+      }
+    }
+  };
+  const disposables2 = createDisposableSet();
+  localStorage.setItem = handleSetItem;
+  localStorage.removeItem = handleRemoveItem;
+  window.addEventListener("hashchange", handleNamespaceChange);
+  syncSnapshot(namespaceRef.value);
+  disposables2.add(() => {
+    localStorage.setItem = originalSetItem;
+    localStorage.removeItem = originalRemoveItem;
+  });
+  disposables2.add(() => {
+    window.removeEventListener("hashchange", handleNamespaceChange);
+  });
+  disposables2.add(() => {
+    clearStorageSnapshot();
+  });
+  return () => {
+    disposables2.disposeAll();
+  };
+}
+
+// src/preload/instrumentation/app-data.ts
+var appDataCache = /* @__PURE__ */ new Map();
+function publishSnapshot() {
+  const data = {};
+  for (const [key, value] of appDataCache) {
+    data[key] = value;
+  }
+  setAppDataSnapshot(data);
+}
+function decodeWorkerMessage(message) {
+  let payload = message;
+  if (typeof payload === "string") {
+    try {
+      payload = JSON.parse(payload);
+    } catch {
+      return null;
+    }
+  }
+  const record = payload;
+  if (record?.type !== "u" || !record.body) return null;
+  return record.body;
+}
+function createInstrumentedWorker(OriginalWorker) {
+  function InstrumentedWorker(scriptURL, options) {
+    const resolvedScriptURL = scriptURL instanceof URL ? scriptURL : new URL(scriptURL, window.location.href);
+    const worker = Reflect.construct(
+      OriginalWorker,
+      [resolvedScriptURL, options],
+      new.target ?? InstrumentedWorker
+    );
+    worker.addEventListener("message", (event) => {
+      const body = decodeWorkerMessage(event.data);
+      if (!body) return;
+      window.__simulatorHook?.appData({
+        bridgeId: body.bridgeId,
+        moduleId: body.moduleId,
+        data: body.data
+      });
+    });
+    return worker;
+  }
+  Object.setPrototypeOf(InstrumentedWorker, OriginalWorker);
+  Object.defineProperty(InstrumentedWorker, "prototype", {
+    value: OriginalWorker.prototype
+  });
+  return InstrumentedWorker;
+}
+function installAppDataInstrumentation() {
+  const disposables2 = createDisposableSet();
+  const originalHook = window.__simulatorHook;
+  const originalDescriptor = Object.getOwnPropertyDescriptor(window, "Worker");
+  const OriginalWorker = window.Worker;
+  window.__simulatorHook = {
+    appData: (body) => {
+      const record = body;
+      if (record?.bridgeId && record?.moduleId) {
+        const key = `${record.bridgeId}/${record.moduleId}`;
+        appDataCache.set(key, record.data);
+        publishSnapshot();
+      }
+      sendToHost(SimulatorChannel.AppData, body);
+    }
+  };
+  Object.defineProperty(window, "Worker", {
+    configurable: true,
+    writable: true,
+    value: createInstrumentedWorker(OriginalWorker)
+  });
+  publishSnapshot();
+  disposables2.add(() => {
+    if (originalDescriptor) {
+      Object.defineProperty(window, "Worker", originalDescriptor);
+    } else {
+      window.Worker = OriginalWorker;
+    }
+  });
+  disposables2.add(() => {
+    if (originalHook) {
+      window.__simulatorHook = originalHook;
+    } else {
+      delete window.__simulatorHook;
+    }
+  });
+  disposables2.add(() => {
+    appDataCache.clear();
+    clearAppDataSnapshot();
+    publishSnapshot();
+  });
+  return () => {
+    disposables2.disposeAll();
+  };
+}
+
+// src/preload/shared/constants.ts
+var WXML_DEBOUNCE_MS = 300;
+var WXML_RETRY_INTERVAL_MS = 500;
+var WXML_RETRY_TIMEOUT_MS = 1e4;
+var NAVIGATION_POLL_INTERVAL_MS = 200;
+var NAVIGATION_TIMEOUT_MS = 1e4;
+
+// src/preload/instrumentation/wxml-extract.ts
+var INTERNAL_CLASSES = /* @__PURE__ */ new Set([
+  "dd-swiper-wrapper",
+  "dd-swiper-slides",
+  "dd-swiper-slide-frame",
+  "dd-swiper-dots",
+  "dd-picker-overlay",
+  "dd-picker-container",
+  "dd-picker-header",
+  "dd-picker-body"
+]);
+var FRAMEWORK_TEMPLATE_RE = /^(taro_tmpl|tmpl_\d+)/;
+function resolveTemplateNameFromParent(instance) {
+  const parent = instance.parent;
+  if (!parent) return null;
+  const parentType = parent.type;
+  const components = parentType?.components;
+  if (components) {
+    for (const [regName, comp] of Object.entries(components)) {
+      if (comp === instance.type) return regName.startsWith("dd-") ? regName.slice(3) : regName;
+    }
+  }
+  const appComponents = instance.appContext?.components;
+  if (!appComponents) return null;
+  for (const [regName, comp] of Object.entries(appComponents)) {
+    if (comp === instance.type) return regName.startsWith("dd-") ? regName.slice(3) : regName;
+  }
+  return null;
+}
+function resolveTagName(instance) {
+  const type = instance.type;
+  if (!type) return "unknown";
+  if (typeof type.__tagName === "string") return type.__tagName;
+  const name = type.__name || type.name;
+  if (!name) {
+    if (type.__scopeId && type.components) return "page";
+    if (type.__scopeId) return resolveTemplateNameFromParent(instance) || "template";
+    return "unknown";
+  }
+  if (name === "dd-page") return "page";
+  if (name.startsWith("dd-")) return name.slice(3);
+  if (name.startsWith("Dd") && name.length > 2) return name.slice(2).toLowerCase();
+  return name;
+}
+function extractProps(instance) {
+  const out = {};
+  for (const raw of [instance.props, instance.attrs]) {
+    if (!raw) continue;
+    for (const [k, v] of Object.entries(raw)) {
+      if (typeof v === "function" || v === void 0) continue;
+      if (k === "data" || k.startsWith("__")) continue;
+      if (typeof v === "boolean" && !v) continue;
+      if (k === "class" && typeof v === "string") {
+        const cleaned = v.split(/\s+/).filter((c) => !c.startsWith("dd-")).join(" ");
+        if (cleaned) out[k] = cleaned;
+        continue;
+      }
+      out[k] = typeof v === "object" ? JSON.stringify(v) : String(v);
+    }
+  }
+  return out;
+}
+function isInternalElement(vnode) {
+  const props = vnode.props;
+  if (!props) return false;
+  const cls = String(props.class || "");
+  return cls.split(/\s+/).some((c) => INTERNAL_CLASSES.has(c));
+}
+function getElementSid(instance) {
+  const subTree = instance.subTree;
+  const el = subTree?.el;
+  return el?.getAttribute ? el.getAttribute("data-sid") ?? void 0 : void 0;
+}
+function isTransparentComponent(instance, tagName) {
+  if (tagName === "unknown") return true;
+  if (tagName === "template") {
+    const props = instance.props;
+    const is = props?.is;
+    if (is && FRAMEWORK_TEMPLATE_RE.test(is)) return true;
+    if (!is) {
+      const type = instance.type;
+      if (type?.__scopeId && !type.components) return true;
+    }
+  }
+  return false;
+}
+function extractChildrenFromVNode(vnode, depth) {
+  if (!vnode || depth > 50) return [];
+  if (vnode.component) {
+    const result2 = walkInstance(vnode.component, depth + 1);
+    return result2 ? Array.isArray(result2) ? result2 : [result2] : [];
+  }
+  if (vnode.suspense) {
+    const suspense = vnode.suspense;
+    const activeBranch = suspense.activeBranch;
+    return activeBranch ? extractChildrenFromVNode(activeBranch, depth + 1) : [];
+  }
+  if (typeof vnode.children === "string" && vnode.children.trim()) {
+    const vnodeType = vnode.type;
+    if (typeof vnodeType === "symbol" || typeof vnodeType === "string") {
+      return [{ tagName: "#text", attrs: {}, children: [], text: vnode.children.trim() }];
+    }
+  }
+  const kids = vnode.children;
+  if (!Array.isArray(kids)) return [];
+  const result = [];
+  for (const child of kids) {
+    if (!child) continue;
+    if (typeof child === "string") {
+      const trimmed = child.trim();
+      if (trimmed) result.push({ tagName: "#text", attrs: {}, children: [], text: trimmed });
+      continue;
+    }
+    if (typeof child !== "object") continue;
+    const c = child;
+    if (c.component) {
+      const walked = walkInstance(c.component, depth + 1);
+      if (walked) result.push(...Array.isArray(walked) ? walked : [walked]);
+      continue;
+    }
+    if (typeof c.type === "symbol") {
+      result.push(...extractChildrenFromVNode(c, depth + 1));
+      continue;
+    }
+    if (typeof c.type === "string") {
+      if (isInternalElement(c)) {
+        result.push(...extractChildrenFromVNode(c, depth + 1));
+      } else if (typeof c.children === "string" && c.children.trim()) {
+        result.push({ tagName: "#text", attrs: {}, children: [], text: c.children.trim() });
+      } else {
+        result.push(...extractChildrenFromVNode(c, depth + 1));
+      }
+      continue;
+    }
+    result.push(...extractChildrenFromVNode(c, depth + 1));
+  }
+  return result;
+}
+function walkInstance(instance, depth) {
+  if (depth > 50) return null;
+  const tagName = resolveTagName(instance);
+  const children = extractChildrenFromVNode(instance.subTree, depth);
+  if (isTransparentComponent(instance, tagName)) return children.length > 0 ? children : null;
+  const node = { tagName, attrs: extractProps(instance), children };
+  const sid = getElementSid(instance);
+  if (sid) node.sid = sid;
+  return node;
+}
+
+// src/preload/instrumentation/wxml.ts
+function findActivePageIframe() {
+  const iframes = document.querySelectorAll(".dimina-native-webview__window");
+  return iframes.length > 0 ? iframes[iframes.length - 1] : null;
+}
+function getVueAppFromIframe(iframe) {
+  try {
+    const doc = iframe.contentDocument;
+    if (!doc?.body) return null;
+    const body = doc.body;
+    const app = body.__vue_app__;
+    if (!app) return null;
+    if (app._instance) return app._instance;
+    const container = app._container;
+    const vnode = container?._vnode;
+    return vnode?.component ?? null;
+  } catch {
+    return null;
+  }
+}
+var wxmlTimer;
+var currentObserver = null;
+var currentIframe = null;
+var topObserver = null;
+var retryTimer;
+var retryTimeout;
+var navigationWaitTimer;
+var navigationWaitTimeout;
+var 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 = void 0;
+  retryTimer = void 0;
+  retryTimeout = void 0;
+  navigationWaitTimer = void 0;
+  navigationWaitTimeout = void 0;
+}
+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;
+  }
+  const instance = getVueAppFromIframe(iframe);
+  if (!instance) {
+    publishTree(null);
+    return;
+  }
+  const tree = walkInstance(instance, 0);
+  if (!tree) {
+    publishTree(null);
+    return;
+  }
+  publishTree(tree);
+}
+function observeIframe(iframe) {
+  if (iframe === currentIframe) return;
+  if (currentObserver) {
+    currentObserver.disconnect();
+    currentObserver = null;
+  }
+  if (navigationWaitTimer) {
+    clearInterval(navigationWaitTimer);
+    navigationWaitTimer = void 0;
+  }
+  if (navigationWaitTimeout) {
+    clearTimeout(navigationWaitTimeout);
+    navigationWaitTimeout = void 0;
+  }
+  currentIframe = iframe;
+  const doc = iframe.contentDocument;
+  if (!doc?.body) {
+    publishTree(null);
+    return;
+  }
+  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 = void 0;
+    }
+  }, WXML_RETRY_INTERVAL_MS);
+  retryTimeout = setTimeout(() => {
+    if (retryTimer) clearInterval(retryTimer);
+    retryTimer = void 0;
+  }, WXML_RETRY_TIMEOUT_MS);
+}
+function observeTopLevel() {
+  if (topObserver) return;
+  topObserver = new MutationObserver(() => {
+    const iframe = findActivePageIframe();
+    if (!iframe) {
+      publishTree(null);
+      return;
+    }
+    if (iframe !== currentIframe) {
+      if (navigationWaitTimer) {
+        clearInterval(navigationWaitTimer);
+        navigationWaitTimer = void 0;
+      }
+      if (navigationWaitTimeout) {
+        clearTimeout(navigationWaitTimeout);
+        navigationWaitTimeout = void 0;
+      }
+      navigationWaitTimer = setInterval(() => {
+        if (getVueAppFromIframe(iframe)) {
+          if (navigationWaitTimer) {
+            clearInterval(navigationWaitTimer);
+            navigationWaitTimer = void 0;
+          }
+          if (navigationWaitTimeout) {
+            clearTimeout(navigationWaitTimeout);
+            navigationWaitTimeout = void 0;
+          }
+          observeIframe(iframe);
+        }
+      }, NAVIGATION_POLL_INTERVAL_MS);
+      navigationWaitTimeout = setTimeout(() => {
+        if (navigationWaitTimer) {
+          clearInterval(navigationWaitTimer);
+          navigationWaitTimer = void 0;
+        }
+        navigationWaitTimeout = void 0;
+      }, 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 });
+      }
+    }, { once: true });
+  }
+}
+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();
+  };
+}
+
+// src/preload/shared/api-compat.ts
+function call(fn, payload) {
+  try {
+    fn?.(payload);
+  } catch {
+  }
+}
+function buildWindowInfo() {
+  const width = window.innerWidth || document.documentElement.clientWidth || 375;
+  const height = window.innerHeight || document.documentElement.clientHeight || 812;
+  const pixelRatio = window.devicePixelRatio || 2;
+  const statusBarHeight = 0;
+  return {
+    pixelRatio,
+    screenWidth: width,
+    screenHeight: height,
+    windowWidth: width,
+    windowHeight: height,
+    statusBarHeight,
+    safeArea: {
+      width,
+      height,
+      top: statusBarHeight,
+      bottom: height,
+      left: 0,
+      right: width
+    }
+  };
+}
+function makeStorageKey(key) {
+  return `dimina:${key}`;
+}
+function ensureWxApi(wx) {
+  if (typeof wx.canIUse !== "function") {
+    wx.canIUse = (_schema) => true;
+  }
+  if (typeof wx.getWindowInfo !== "function") {
+    wx.getWindowInfo = (opts = {}) => {
+      const info = buildWindowInfo();
+      call(opts.success, info);
+      call(opts.complete, void 0);
+      return info;
+    };
+  }
+  if (typeof wx.getSystemSetting !== "function") {
+    wx.getSystemSetting = (opts = {}) => {
+      const info = {
+        bluetoothEnabled: false,
+        locationEnabled: true,
+        wifiEnabled: true,
+        deviceOrientation: "portrait"
+      };
+      call(opts.success, info);
+      call(opts.complete, void 0);
+      return info;
+    };
+  }
+  if (typeof wx.getSystemInfoSync !== "function") {
+    wx.getSystemInfoSync = () => ({
+      brand: "simulator",
+      model: "web",
+      platform: "simulator",
+      system: "web",
+      language: "zh_CN",
+      SDKVersion: "3.0.0",
+      ...buildWindowInfo()
+    });
+  }
+  if (typeof wx.setStorageSync !== "function") {
+    wx.setStorageSync = (key, data) => {
+      const value = typeof data === "string" ? data : JSON.stringify(data);
+      localStorage.setItem(makeStorageKey(String(key)), value);
+    };
+  }
+  if (typeof wx.getStorageSync !== "function") {
+    wx.getStorageSync = (key) => {
+      const raw = localStorage.getItem(makeStorageKey(String(key)));
+      if (raw == null) return "";
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return raw;
+      }
+    };
+  }
+  if (typeof wx.removeStorageSync !== "function") {
+    wx.removeStorageSync = (key) => {
+      localStorage.removeItem(makeStorageKey(String(key)));
+    };
+  }
+  if (typeof wx.clearStorageSync !== "function") {
+    wx.clearStorageSync = () => {
+      const prefix = "dimina:";
+      const keys = [];
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key?.startsWith(prefix)) keys.push(key);
+      }
+      keys.forEach((key) => localStorage.removeItem(key));
+    };
+  }
+  if (typeof wx.getStorageInfoSync !== "function") {
+    wx.getStorageInfoSync = () => {
+      const prefix = "dimina:";
+      const keys = [];
+      let currentSize = 0;
+      for (let i = 0; i < localStorage.length; i++) {
+        const fullKey = localStorage.key(i);
+        if (!fullKey?.startsWith(prefix)) continue;
+        keys.push(fullKey.slice(prefix.length));
+        currentSize += (localStorage.getItem(fullKey) || "").length * 2;
+      }
+      return { keys, currentSize, limitSize: 10 * 1024 * 1024 };
+    };
+  }
+  if (typeof wx.request !== "function") {
+    wx.request = (opts) => {
+      const controller = new AbortController();
+      const method = (opts.method || "GET").toUpperCase();
+      let requestUrl = opts.url;
+      const init = {
+        method,
+        headers: { "Content-Type": "application/json", ...opts.header || {} },
+        signal: controller.signal
+      };
+      if (method === "GET" && opts.data && typeof opts.data === "object") {
+        const url = new URL(requestUrl, window.location.href);
+        Object.entries(opts.data).forEach(([key, value]) => {
+          url.searchParams.append(key, String(value));
+        });
+        requestUrl = url.toString();
+      } else if (opts.data != null) {
+        init.body = typeof opts.data === "string" ? opts.data : JSON.stringify(opts.data);
+      }
+      const timeoutId = Number(opts.timeout) > 0 ? window.setTimeout(() => controller.abort(), Number(opts.timeout)) : null;
+      fetch(requestUrl, init).then(async (response) => {
+        const headers = Object.fromEntries(response.headers.entries());
+        let data;
+        if (opts.dataType === "arraybuffer") data = await response.arrayBuffer();
+        else {
+          const text = await response.text();
+          if (opts.dataType === "text") data = text;
+          else {
+            try {
+              data = JSON.parse(text);
+            } catch {
+              data = text;
+            }
+          }
+        }
+        call(opts.success, { data, statusCode: response.status, header: headers, errMsg: "request:ok" });
+      }).catch((error) => {
+        call(opts.fail, { errMsg: `request:fail ${error instanceof Error ? error.message : String(error)}` });
+      }).finally(() => {
+        if (timeoutId != null) window.clearTimeout(timeoutId);
+        call(opts.complete, void 0);
+      });
+      return {
+        abort: () => controller.abort()
+      };
+    };
+  }
+}
+function setupApiCompatHook() {
+  const apply = () => {
+    const target = window;
+    if (!target.wx || typeof target.wx !== "object") {
+      target.wx = {};
+    }
+    const wx = target.wx;
+    ensureWxApi(wx);
+    return true;
+  };
+  if (apply()) return;
+  const timer = window.setInterval(() => {
+    if (apply()) window.clearInterval(timer);
+  }, 200);
+}
+
+// src/preload/windows/simulator.ts
+setupApiCompatHook();
+installSimulatorBridge();
+installConsoleInstrumentation();
+installStorageInstrumentation();
+installAppDataInstrumentation();
+installWxmlInstrumentation();
+//# sourceMappingURL=simulator.js.map