@midscene/core 0.0.1

package/dist/lib/image.js

@@ -0,0 +1,307 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/image/index.ts
+var image_exports = {};
+__export(image_exports, {
+  alignCoordByTrim: () => alignCoordByTrim,
+  base64Encoded: () => base64Encoded,
+  calculateNewDimensions: () => calculateNewDimensions,
+  composeSectionDiagram: () => composeSectionDiagram,
+  imageInfo: () => imageInfo,
+  imageInfoOfBase64: () => imageInfoOfBase64,
+  resizeImg: () => resizeImg,
+  saveBase64Image: () => saveBase64Image,
+  transformImgPathToBase64: () => transformImgPathToBase64,
+  trimImage: () => trimImage
+});
+module.exports = __toCommonJS(image_exports);
+
+// src/image/info.ts
+var import_node_assert = __toESM(require("assert"));
+var import_buffer = require("buffer");
+var import_node_fs = require("fs");
+var import_sharp = __toESM(require("sharp"));
+async function imageInfo(image) {
+  const { width, height } = await (0, import_sharp.default)(image).metadata();
+  (0, import_node_assert.default)(width && height, `invalid image: ${image}`);
+  return { width, height };
+}
+async function imageInfoOfBase64(imageBase64) {
+  const base64Data = imageBase64.replace(/^data:image\/\w+;base64,/, "");
+  return imageInfo(import_buffer.Buffer.from(base64Data, "base64"));
+}
+function base64Encoded(image, withHeader = true) {
+  const imageBuffer = (0, import_node_fs.readFileSync)(image);
+  if (!withHeader) {
+    return imageBuffer.toString("base64");
+  }
+  if (image.endsWith("png")) {
+    return `data:image/png;base64,${imageBuffer.toString("base64")}`;
+  } else if (image.endsWith("jpg") || image.endsWith("jpeg")) {
+    return `data:image/jpeg;base64,${imageBuffer.toString("base64")}`;
+  }
+  throw new Error("unsupported image type");
+}
+
+// src/image/transform.ts
+var import_node_buffer = require("buffer");
+var import_sharp2 = __toESM(require("sharp"));
+async function saveBase64Image(options) {
+  const { base64Data, outputPath } = options;
+  const base64Image = base64Data.split(";base64,").pop() || base64Data;
+  const imageBuffer = import_node_buffer.Buffer.from(base64Image, "base64");
+  await (0, import_sharp2.default)(imageBuffer).toFile(outputPath);
+  console.log("Image successfully written to file.");
+}
+async function transformImgPathToBase64(inputPath) {
+  return await (0, import_sharp2.default)(inputPath).toBuffer().then((data) => {
+    const base64Data = data.toString("base64");
+    return base64Data;
+  });
+}
+async function resizeImg(base64Data) {
+  const base64Image = base64Data.split(";base64,").pop() || base64Data;
+  const imageBuffer = import_node_buffer.Buffer.from(base64Image, "base64");
+  const metadata = await (0, import_sharp2.default)(imageBuffer).metadata();
+  const { width, height } = metadata;
+  if (!width || !height) {
+    throw Error("undefined width or height with url");
+  }
+  const newSize = calculateNewDimensions(width, height);
+  return await (0, import_sharp2.default)(imageBuffer).resize(newSize.width, newSize.height).toBuffer().then((data) => {
+    const base64Data2 = data.toString("base64");
+    return base64Data2;
+  });
+}
+function calculateNewDimensions(originalWidth, originalHeight) {
+  const maxWidth = 768;
+  const maxHeight = 2048;
+  let newWidth = originalWidth;
+  let newHeight = originalHeight;
+  const aspectRatio = originalWidth / originalHeight;
+  if (originalWidth > maxWidth) {
+    newWidth = maxWidth;
+    newHeight = newWidth / aspectRatio;
+  }
+  if (newHeight > maxHeight) {
+    newHeight = maxHeight;
+    newWidth = newHeight * aspectRatio;
+  }
+  return {
+    width: Math.round(newWidth),
+    height: Math.round(newHeight)
+  };
+}
+async function trimImage(image) {
+  const { info } = await (0, import_sharp2.default)(image).trim().toBuffer({
+    resolveWithObject: true
+  });
+  if (typeof info.trimOffsetLeft === "undefined" || typeof info.trimOffsetTop === "undefined") {
+    return null;
+  }
+  return {
+    trimOffsetLeft: info.trimOffsetLeft,
+    trimOffsetTop: info.trimOffsetTop,
+    width: info.width,
+    height: info.height
+  };
+}
+async function alignCoordByTrim(image, center) {
+  const img = await (0, import_sharp2.default)(image).extract(center).toBuffer();
+  const trimInfo = await trimImage(img);
+  if (!trimInfo) {
+    return center;
+  }
+  return {
+    left: center.left - trimInfo.trimOffsetLeft,
+    top: center.top - trimInfo.trimOffsetTop,
+    width: trimInfo.width,
+    height: trimInfo.height
+  };
+}
+
+// src/image/visualization.ts
+var import_buffer2 = require("buffer");
+var import_sharp3 = __toESM(require("sharp"));
+
+// src/utils.ts
+var import_os = require("os");
+var import_path = require("path");
+var import_fs = require("fs");
+var import_crypto = require("crypto");
+var import_assert = __toESM(require("assert"));
+var pkg;
+function getPkgInfo() {
+  if (pkg) {
+    return pkg;
+  }
+  let pkgJsonFile = "";
+  if ((0, import_fs.existsSync)((0, import_path.join)(__dirname, "../package.json"))) {
+    pkgJsonFile = (0, import_path.join)(__dirname, "../package.json");
+  } else if ((0, import_fs.existsSync)((0, import_path.join)(__dirname, "../../../package.json"))) {
+    pkgJsonFile = (0, import_path.join)(__dirname, "../../../package.json");
+  }
+  if (pkgJsonFile) {
+    const { name, version } = JSON.parse((0, import_fs.readFileSync)(pkgJsonFile, "utf-8"));
+    pkg = { name, version };
+    return pkg;
+  } else {
+    return {
+      name: "midscene-unknown-page-name",
+      version: "0.0.0"
+    };
+  }
+}
+var logDir = (0, import_path.join)(process.cwd(), "./midscene_run/");
+function getTmpDir() {
+  const path = (0, import_path.join)((0, import_os.tmpdir)(), getPkgInfo().name);
+  (0, import_fs.mkdirSync)(path, { recursive: true });
+  return path;
+}
+function getTmpFile(fileExt) {
+  const filename = `${(0, import_crypto.randomUUID)()}.${fileExt}`;
+  return (0, import_path.join)(getTmpDir(), filename);
+}
+
+// src/image/visualization.ts
+var colors = [
+  {
+    name: "Red",
+    hex: "#FF0000"
+  },
+  {
+    name: "Green",
+    hex: "#00FF00"
+  },
+  {
+    name: "Blue",
+    hex: "#0000FF"
+  },
+  {
+    name: "Yellow",
+    hex: "#FFFF00"
+  },
+  {
+    name: "Cyan",
+    hex: "#00FFFF"
+  },
+  {
+    name: "Magenta",
+    hex: "#FF00FF"
+  },
+  {
+    name: "Orange",
+    hex: "#FFA500"
+  },
+  {
+    name: "Purple",
+    hex: "#800080"
+  },
+  {
+    name: "Brown",
+    hex: "#A52A2A"
+  },
+  {
+    name: "Pink",
+    hex: "#FFC0CB"
+  },
+  {
+    name: "Light Blue",
+    hex: "#ADD8E6"
+  },
+  {
+    name: "Lime",
+    hex: "#00FF00"
+  },
+  {
+    name: "Violet",
+    hex: "#EE82EE"
+  },
+  {
+    name: "Gold",
+    hex: "#FFD700"
+  },
+  {
+    name: "Teal",
+    hex: "#008080"
+  }
+];
+var sizeLimit = 512;
+var textFontSize = 12;
+async function composeSectionDiagram(sections, context) {
+  const { width, height } = await imageInfo(context.screenshotBase64);
+  const ratio = Math.min(sizeLimit / width, sizeLimit / height, 1);
+  const canvasWidth = width * ratio;
+  const canvasHeight = height * ratio;
+  const sectionNameColorMap = {};
+  const rects = sections.map((section, index) => {
+    const { left, top, width: width2, height: height2 } = section.rect;
+    const color = colors[index % colors.length];
+    sectionNameColorMap[section.name] = color;
+    return `
+            <rect x="${left * ratio}" y="${top * ratio}" width="${width2 * ratio}" height="${height2 * ratio}" fill="${color.hex}" />
+            <text x="${left * ratio}" y="${top * ratio + textFontSize}" font-family="Arial" font-size="${textFontSize}" fill="black">
+                ${section.name}
+            </text>
+        `;
+  });
+  const rectangles = `
+        <svg width="${canvasWidth}" height="${canvasHeight}">
+        ${rects.join("\n")}
+        </svg>
+    `;
+  const svgBuffer = import_buffer2.Buffer.from(rectangles);
+  const file = getTmpFile("png");
+  await (0, import_sharp3.default)({
+    create: {
+      width: canvasWidth,
+      height: canvasHeight,
+      channels: 4,
+      background: { r: 255, g: 255, b: 255, alpha: 1 }
+    }
+  }).composite([{ input: svgBuffer }]).png().toFile(file);
+  return {
+    file,
+    sectionNameColorMap
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  alignCoordByTrim,
+  base64Encoded,
+  calculateNewDimensions,
+  composeSectionDiagram,
+  imageInfo,
+  imageInfoOfBase64,
+  resizeImg,
+  saveBase64Image,
+  transformImgPathToBase64,
+  trimImage
+});