@dimina-kit/devtools 0.4.0-dev.20260828161241 → 0.4.0-dev.20260907055341

package/dist/preload/windows/main.cjs

@@ -3124,6 +3124,37 @@ var main_exports = {};
 module.exports = __toCommonJS(main_exports);
 var import_electron = require("electron");
 
+// ../dimina-electron-runtime/dist/shared/host-env.js
+function deviceInfoToHostEnv(d) {
+  const insets = d.safeAreaInsets;
+  const windowHeight = Math.max(0, d.screenHeight - insets.top - insets.bottom);
+  const left = insets.left;
+  const right = d.screenWidth - insets.right;
+  return {
+    brand: d.brand,
+    model: d.model,
+    system: d.system,
+    platform: d.platform,
+    pixelRatio: d.pixelRatio,
+    screenWidth: d.screenWidth,
+    screenHeight: d.screenHeight,
+    windowWidth: d.screenWidth,
+    windowHeight,
+    statusBarHeight: d.statusBarHeight,
+    safeAreaInsets: insets,
+    deviceOrientation: d.orientation,
+    safeArea: {
+      left,
+      top: insets.top,
+      right,
+      bottom: d.screenHeight - insets.bottom,
+      width: Math.max(0, right - left),
+      height: windowHeight
+    },
+    screenTop: d.statusBarHeight
+  };
+}
+
 // ../dimina-electron-runtime/dist/shared/bridge-channels.js
 var BRIDGE_CHANNELS = {
   SPAWN: "dmb:spawn",
@@ -3574,19 +3605,46 @@ function resolveVPath(url) {
 }
 
 // src/simulator/temp-files.ts
+var MAX_TEMP_FILE_ENTRIES = 200;
 var tempFiles = /* @__PURE__ */ new Map();
 var activeSink = null;
+function rememberTempFile(path2, blob) {
+  tempFiles.set(path2, blob);
+  while (tempFiles.size > MAX_TEMP_FILE_ENTRIES) {
+    const oldest = tempFiles.keys().next();
+    if (oldest.done) break;
+    tempFiles.delete(oldest.value);
+  }
+}
 function cryptoRandomId() {
   const c = globalThis.crypto;
   if (c && typeof c.randomUUID === "function") return c.randomUUID();
   return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
 }
-function createTempFilePath(blob) {
+function allocateTempFilePath(blob) {
   const path2 = `difile://_tmp/${cryptoRandomId()}`;
-  tempFiles.set(path2, blob);
+  rememberTempFile(path2, blob);
+  return path2;
+}
+function createTempFilePath(blob) {
+  const path2 = allocateTempFilePath(blob);
   activeSink?.write(path2, blob);
   return path2;
 }
+async function createTempFilePathAsync(blob) {
+  const path2 = allocateTempFilePath(blob);
+  try {
+    if (activeSink?.writeAndWait) {
+      await activeSink.writeAndWait(path2, blob);
+    } else {
+      activeSink?.write(path2, blob);
+    }
+  } catch (error) {
+    tempFiles.delete(path2);
+    throw error;
+  }
+  return path2;
+}
 async function resolveTempFilePath(path2) {
   const cached = tempFiles.get(path2);
   if (cached) return cached;
@@ -3595,7 +3653,7 @@ async function resolveTempFilePath(path2) {
     throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6 ${path2}`);
   }
   const blob = await response.blob();
-  tempFiles.set(path2, blob);
+  rememberTempFile(path2, blob);
   return blob;
 }
 function getTempFileName(path2, blob, fallback = "file") {
@@ -4299,6 +4357,112 @@ function compressImage({ src, quality = 80, success, fail, complete }) {
   };
   img.src = src;
 }
+var MAX_CANVAS_IMAGE_BYTES = 32 * 1024 * 1024;
+var MAX_CANVAS_BASE64_CHARS = Math.floor(MAX_CANVAS_IMAGE_BYTES * 4 / 3) + 8;
+var PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+function matchesImageType(bytes, fileType) {
+  if (fileType === "png") {
+    return bytes.length >= PNG_SIGNATURE.length && PNG_SIGNATURE.every((byte, i) => bytes[i] === byte);
+  }
+  return bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255;
+}
+var CANVAS_DATA_URL_PREFIX = /^data:image\/(png|jpeg|jpg);base64,/;
+var STRICT_BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
+var SAFE_CANVAS_APP_ID = /^[A-Za-z0-9._-]+$/;
+function isValidCanvasAppId(appId) {
+  return typeof appId === "string" && SAFE_CANVAS_APP_ID.test(appId) && appId !== "." && appId !== "..";
+}
+function readCanvasDataURL(dataURL, fileType, appId) {
+  if (!dataURL || typeof dataURL !== "string") return { reason: "dataURL is required" };
+  if (fileType !== "png" && fileType !== "jpg") return { reason: "invalid file type" };
+  if (!isValidCanvasAppId(appId)) return { reason: "invalid appId" };
+  const prefix = CANVAS_DATA_URL_PREFIX.exec(dataURL);
+  if (dataURL.startsWith("data:") && !prefix) return { reason: "invalid dataURL" };
+  const declaredType = prefix?.[1];
+  if (declaredType && declaredType !== fileType && !(declaredType === "jpeg" && fileType === "jpg")) {
+    return { reason: "file type mismatch" };
+  }
+  return { base64Data: prefix ? dataURL.slice(prefix[0].length) : dataURL, fileType };
+}
+function isStrictBase64(base64Data) {
+  return !!base64Data && base64Data.length % 4 === 0 && STRICT_BASE64.test(base64Data);
+}
+var MAX_IN_FLIGHT_CANVAS_EXPORTS = 2;
+var MAX_PENDING_CANVAS_BASE64_CHARS = MAX_IN_FLIGHT_CANVAS_EXPORTS * MAX_CANVAS_BASE64_CHARS;
+var pendingCanvasExports = /* @__PURE__ */ new Map();
+function reserveCanvasExport(appId, chars) {
+  const state = pendingCanvasExports.get(appId) ?? { count: 0, chars: 0 };
+  if (state.count >= MAX_IN_FLIGHT_CANVAS_EXPORTS) return false;
+  if (state.chars + chars > MAX_PENDING_CANVAS_BASE64_CHARS) return false;
+  state.count += 1;
+  state.chars += chars;
+  pendingCanvasExports.set(appId, state);
+  return true;
+}
+function releaseCanvasExport(appId, chars) {
+  const state = pendingCanvasExports.get(appId);
+  if (!state) return;
+  state.count -= 1;
+  state.chars -= chars;
+  if (state.count <= 0) pendingCanvasExports.delete(appId);
+}
+function decodeCanvasBytes(base64Data, fileType) {
+  let bytes;
+  try {
+    const byteChars = atob(base64Data);
+    bytes = new Uint8Array(byteChars.length);
+    for (let i = 0; i < byteChars.length; i++) {
+      bytes[i] = byteChars.charCodeAt(i);
+    }
+  } catch {
+    return { reason: "base64 decode failed" };
+  }
+  if (bytes.length > MAX_CANVAS_IMAGE_BYTES) return { reason: "data too large" };
+  if (!matchesImageType(bytes, fileType)) return { reason: "invalid image data" };
+  return { blob: new Blob([bytes], { type: fileType === "jpg" ? "image/jpeg" : "image/png" }) };
+}
+async function saveCanvasTempFile({ dataURL, fileType = "png", success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  const failWith = (reason) => {
+    const result = { errMsg: `canvasToTempFilePath:fail ${reason}` };
+    onFail?.(result);
+    onComplete?.(result);
+  };
+  const head = readCanvasDataURL(dataURL, fileType, this.appId);
+  if ("reason" in head) {
+    failWith(head.reason);
+    return;
+  }
+  const { base64Data, fileType: imageType } = head;
+  if (base64Data.length > MAX_CANVAS_BASE64_CHARS) {
+    failWith("data too large");
+    return;
+  }
+  if (!isStrictBase64(base64Data)) {
+    failWith("base64 decode failed");
+    return;
+  }
+  if (!reserveCanvasExport(this.appId, base64Data.length)) {
+    failWith("too many pending exports");
+    return;
+  }
+  try {
+    const decoded = decodeCanvasBytes(base64Data, imageType);
+    if ("reason" in decoded) {
+      failWith(decoded.reason);
+      return;
+    }
+    const tempFilePath = await createTempFilePathAsync(decoded.blob);
+    const result = { tempFilePath, errMsg: "canvasToTempFilePath:ok" };
+    onSuccess?.(result);
+    onComplete?.(result);
+  } catch (error) {
+    console.warn("[simulator] canvas temp file write failed", error);
+    failWith("write failed");
+  } finally {
+    releaseCanvasExport(this.appId, base64Data.length);
+  }
+}
 function saveImageToPhotosAlbum({ filePath, success, fail, complete }) {
   const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
   const triggerDownload = (href) => {
@@ -5160,11 +5324,12 @@ function getWindowInfo({ success, complete } = {}) {
 }
 function getSystemSetting({ success, complete } = {}) {
   const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
+  const device = this.getCurrentDevice?.();
   const info = {
     bluetoothEnabled: false,
     locationEnabled: true,
     wifiEnabled: true,
-    deviceOrientation: "portrait"
+    deviceOrientation: device && deviceInfoToHostEnv(device).deviceOrientation || "portrait"
   };
   onSuccess?.(info);
   onComplete?.();
@@ -5186,6 +5351,17 @@ function readWindowMetrics(miniApp) {
   };
 }
 function buildSystemInfo(miniApp) {
+  const device = miniApp.getCurrentDevice?.();
+  if (device) {
+    return {
+      ...deviceInfoToHostEnv(device),
+      language: "zh_CN",
+      version: "8.0.5",
+      SDKVersion: "3.0.0",
+      fontSizeSetting: 16,
+      theme: window.matchMedia?.("(prefers-color-scheme: dark)").matches ? "dark" : "light"
+    };
+  }
   const { wb, di, dev, pixelRatio, screenWidth, screenHeight, windowWidth, windowHeight } = readWindowMetrics(miniApp);
   const statusBarHeight = di["statusBarHeight"] ?? dev?.statusBarHeight ?? 0;
   const bottomInset = di["safeAreaInsets"]?.bottom ?? dev?.safeAreaInsets?.bottom ?? 0;
@@ -5286,6 +5462,7 @@ var simulatorApis = {
   previewImage,
   compressImage,
   saveImageToPhotosAlbum,
+  saveCanvasTempFile,
   getImageInfo,
   // Media: Video
   chooseMedia,