@midscene/shared 0.7.1 → 0.7.2-beta-20241024094141.0

package/dist/browser/constants.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/constants/index.ts
+var constants_exports = {};
+__export(constants_exports, {
+  CONTAINER_MINI_HEIGHT: () => CONTAINER_MINI_HEIGHT,
+  CONTAINER_MINI_WIDTH: () => CONTAINER_MINI_WIDTH,
+  NodeType: () => NodeType,
+  TEXT_MAX_SIZE: () => TEXT_MAX_SIZE,
+  TEXT_SIZE_THRESHOLD: () => TEXT_SIZE_THRESHOLD
+});
+module.exports = __toCommonJS(constants_exports);
+var TEXT_SIZE_THRESHOLD = 9;
+var TEXT_MAX_SIZE = 40;
+var CONTAINER_MINI_HEIGHT = 3;
+var CONTAINER_MINI_WIDTH = 3;
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2["CONTAINER"] = "CONTAINER Node";
+  NodeType2["FORM_ITEM"] = "FORM_ITEM Node";
+  NodeType2["BUTTON"] = "BUTTON Node";
+  NodeType2["IMG"] = "IMG Node";
+  NodeType2["TEXT"] = "TEXT Node";
+  return NodeType2;
+})(NodeType || {});

package/dist/{types → browser}/fs.d.ts

@@ -3,7 +3,7 @@ interface PkgInfo {
     version: string;
     dir: string;
 }
-declare function getMidscenePkgInfo(dir: string): PkgInfo;
+declare function getRunningPkgInfo(dir?: string): PkgInfo | null;
 /**
  * Find the nearest package.json file recursively
  * @param {string} dir - Home directory
@@ -11,4 +11,4 @@ declare function getMidscenePkgInfo(dir: string): PkgInfo;
  */
 declare function findNearestPackageJson(dir: string): string | null;
 
-export { findNearestPackageJson, getMidscenePkgInfo };
+export { findNearestPackageJson, getRunningPkgInfo };

package/dist/browser/fs.js

@@ -0,0 +1,73 @@
+"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/fs/index.ts
+var fs_exports = {};
+__export(fs_exports, {
+  findNearestPackageJson: () => findNearestPackageJson,
+  getRunningPkgInfo: () => getRunningPkgInfo
+});
+module.exports = __toCommonJS(fs_exports);
+var import_node_assert = __toESM(require("assert"));
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var pkg;
+var ifInBrowser = typeof window !== "undefined";
+function getRunningPkgInfo(dir) {
+  if (ifInBrowser) {
+    return null;
+  }
+  if (pkg) {
+    return pkg;
+  }
+  const pkgDir = findNearestPackageJson(dir || process.cwd());
+  (0, import_node_assert.default)(pkgDir, "package.json not found");
+  const pkgJsonFile = (0, import_node_path.join)(pkgDir, "package.json");
+  if (pkgJsonFile) {
+    const { name, version } = JSON.parse((0, import_node_fs.readFileSync)(pkgJsonFile, "utf-8"));
+    pkg = { name, version, dir: pkgDir };
+    return pkg;
+  }
+  return {
+    name: "midscene-unknown-package-name",
+    version: "0.0.0",
+    dir: pkgDir
+  };
+}
+function findNearestPackageJson(dir) {
+  const packageJsonPath = (0, import_node_path.join)(dir, "package.json");
+  if ((0, import_node_fs.existsSync)(packageJsonPath)) {
+    return dir;
+  }
+  const parentDir = (0, import_node_path.dirname)(dir);
+  if (parentDir === dir) {
+    return null;
+  }
+  return findNearestPackageJson(parentDir);
+}

package/dist/{types → browser}/img.d.ts

@@ -21,6 +21,7 @@ declare function imageInfo(image: string | Buffer): Promise<Size$1>;
  * @throws Error if the image data is invalid
  */
 declare function imageInfoOfBase64(imageBase64: string): Promise<Size$1>;
+declare function bufferFromBase64(imageBase64: string): Promise<Buffer>;
 /**
  * Encodes an image file to a base64 encoded string
  *
@@ -34,6 +35,7 @@ declare function imageInfoOfBase64(imageBase64: string): Promise<Size$1>;
 declare function base64Encoded(image: string, withHeader?: boolean): string;
 declare function base64ToPngFormat(base64: string): string;
 
+/**
 /**
  * Saves a Base64-encoded image to a file
  *
@@ -126,4 +128,4 @@ declare const processImageElementInfo: (options: {
     compositeElementInfoImgWithoutTextBase64: string;
 }>;
 
-export { base64Encoded, base64ToPngFormat, calculateNewDimensions, compositeElementInfoImg, imageInfo, imageInfoOfBase64, processImageElementInfo, resizeImg, saveBase64Image, transformImgPathToBase64, trimImage };
+export { base64Encoded, base64ToPngFormat, bufferFromBase64, calculateNewDimensions, compositeElementInfoImg, imageInfo, imageInfoOfBase64, processImageElementInfo, resizeImg, saveBase64Image, transformImgPathToBase64, trimImage };

package/dist/browser/img.js

@@ -0,0 +1,366 @@
+"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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/img/index.ts
+var img_exports = {};
+__export(img_exports, {
+  base64Encoded: () => base64Encoded,
+  base64ToPngFormat: () => base64ToPngFormat,
+  bufferFromBase64: () => bufferFromBase64,
+  calculateNewDimensions: () => calculateNewDimensions,
+  compositeElementInfoImg: () => compositeElementInfoImg,
+  imageInfo: () => imageInfo,
+  imageInfoOfBase64: () => imageInfoOfBase64,
+  processImageElementInfo: () => processImageElementInfo,
+  resizeImg: () => resizeImg,
+  saveBase64Image: () => saveBase64Image,
+  transformImgPathToBase64: () => transformImgPathToBase64,
+  trimImage: () => trimImage
+});
+module.exports = __toCommonJS(img_exports);
+
+// src/img/info.ts
+var import_node_assert = __toESM(require("assert"));
+var import_node_buffer = require("buffer");
+var import_node_fs = require("fs");
+
+// src/img/get-jimp.ts
+var ifInBrowser = typeof window !== "undefined";
+function getJimp() {
+  return __async(this, null, function* () {
+    if (ifInBrowser) {
+      return (yield import("jimp/browser/lib/jimp.js")).default;
+    }
+    return (yield import("jimp")).default;
+  });
+}
+
+// src/img/info.ts
+function imageInfo(image) {
+  return __async(this, null, function* () {
+    const Jimp = yield getJimp();
+    let jimpImage;
+    if (typeof image === "string") {
+      jimpImage = yield Jimp.read(image);
+    } else if (import_node_buffer.Buffer.isBuffer(image)) {
+      jimpImage = yield Jimp.read(image);
+    } else {
+      throw new Error("Invalid image input: must be a string path or a Buffer");
+    }
+    const { width, height } = jimpImage.bitmap;
+    (0, import_node_assert.default)(
+      width && height,
+      `Invalid image: ${typeof image === "string" ? image : "Buffer"}`
+    );
+    return { width, height };
+  });
+}
+function imageInfoOfBase64(imageBase64) {
+  return __async(this, null, function* () {
+    const buffer = yield bufferFromBase64(imageBase64);
+    return imageInfo(buffer);
+  });
+}
+function bufferFromBase64(imageBase64) {
+  return __async(this, null, function* () {
+    const base64Data = imageBase64.replace(/^data:image\/\w+;base64,/, "");
+    return import_node_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")}`;
+  }
+  if (image.endsWith("jpg") || image.endsWith("jpeg")) {
+    return `data:image/jpeg;base64,${imageBuffer.toString("base64")}`;
+  }
+  throw new Error("unsupported image type");
+}
+function base64ToPngFormat(base64) {
+  return `data:image/png;base64,${base64}`;
+}
+
+// src/img/transform.ts
+var import_node_buffer2 = require("buffer");
+function saveBase64Image(options) {
+  return __async(this, null, function* () {
+    const { base64Data, outputPath } = options;
+    const base64Image = base64Data.split(";base64,").pop() || base64Data;
+    const imageBuffer = import_node_buffer2.Buffer.from(base64Image, "base64");
+    const Jimp = yield getJimp();
+    const image = yield Jimp.read(imageBuffer);
+    yield image.writeAsync(outputPath);
+  });
+}
+function transformImgPathToBase64(inputPath) {
+  return __async(this, null, function* () {
+    const Jimp = yield getJimp();
+    const image = yield Jimp.read(inputPath);
+    const buffer = yield image.getBufferAsync(Jimp.MIME_PNG);
+    return buffer.toString("base64");
+  });
+}
+function resizeImg(inputData, newSize) {
+  return __async(this, null, function* () {
+    const isBase64 = typeof inputData === "string";
+    const imageBuffer = isBase64 ? import_node_buffer2.Buffer.from(inputData.split(";base64,").pop() || inputData, "base64") : inputData;
+    const Jimp = yield getJimp();
+    const image = yield Jimp.read(imageBuffer);
+    const { width, height } = image.bitmap;
+    if (!width || !height) {
+      throw Error("Undefined width or height from the input image.");
+    }
+    const finalNewSize = newSize || calculateNewDimensions(width, height);
+    image.resize(finalNewSize.width, finalNewSize.height);
+    const resizedBuffer = yield image.getBufferAsync(Jimp.MIME_PNG);
+    return isBase64 ? resizedBuffer.toString("base64") : resizedBuffer;
+  });
+}
+function calculateNewDimensions(originalWidth, originalHeight) {
+  const maxWidth = 2048;
+  const maxHeight = 768;
+  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)
+  };
+}
+function trimImage(image) {
+  return __async(this, null, function* () {
+    const Jimp = yield getJimp();
+    const jimpImage = yield Jimp.read(
+      import_node_buffer2.Buffer.isBuffer(image) ? image : import_node_buffer2.Buffer.from(image)
+    );
+    const { width, height } = jimpImage.bitmap;
+    if (width <= 3 || height <= 3) {
+      return null;
+    }
+    const trimmedImage = jimpImage.autocrop();
+    const { width: trimmedWidth, height: trimmedHeight } = trimmedImage.bitmap;
+    const trimOffsetLeft = (width - trimmedWidth) / 2;
+    const trimOffsetTop = (height - trimmedHeight) / 2;
+    if (trimOffsetLeft === 0 && trimOffsetTop === 0) {
+      return null;
+    }
+    return {
+      trimOffsetLeft: -trimOffsetLeft,
+      trimOffsetTop: -trimOffsetTop,
+      width: trimmedWidth,
+      height: trimmedHeight
+    };
+  });
+}
+
+// src/img/box-select.ts
+var import_node_assert2 = __toESM(require("assert"));
+var createSvgOverlay = (elements, imageWidth, imageHeight) => {
+  const createPngOverlay = (elements2, imageWidth2, imageHeight2) => __async(void 0, null, function* () {
+    const Jimp = yield getJimp();
+    const image = new Jimp(imageWidth2, imageHeight2, 0);
+    const colors = [
+      { rect: 4278190335, text: 4294967295 }
+      // red, white
+      // { rect: 0x0000ffff, text: 0xffffffff }, // blue, white
+      // { rect: 0x8b4513ff, text: 0xffffffff }, // brown, white
+    ];
+    const boxPadding = 5;
+    for (let index = 0; index < elements2.length; index++) {
+      const element = elements2[index];
+      const color = colors[index % colors.length];
+      const paddedRect = {
+        left: Math.max(0, element.rect.left - boxPadding),
+        top: Math.max(0, element.rect.top - boxPadding),
+        width: Math.min(
+          imageWidth2 - element.rect.left,
+          element.rect.width + boxPadding * 2
+        ),
+        height: Math.min(
+          imageHeight2 - element.rect.top,
+          element.rect.height + boxPadding * 2
+        )
+      };
+      image.scan(
+        paddedRect.left,
+        paddedRect.top,
+        paddedRect.width,
+        paddedRect.height,
+        function(x, y, idx) {
+          if (x === paddedRect.left || x === paddedRect.left + paddedRect.width - 1 || y === paddedRect.top || y === paddedRect.top + paddedRect.height - 1) {
+            this.bitmap.data[idx + 0] = color.rect >> 24 & 255;
+            this.bitmap.data[idx + 1] = color.rect >> 16 & 255;
+            this.bitmap.data[idx + 2] = color.rect >> 8 & 255;
+            this.bitmap.data[idx + 3] = color.rect & 255;
+          }
+        }
+      );
+      const textWidth = element.indexId.toString().length * 8;
+      const textHeight = 12;
+      const rectWidth = textWidth + 5;
+      const rectHeight = textHeight + 4;
+      let rectX = paddedRect.left - rectWidth;
+      let rectY = paddedRect.top + paddedRect.height / 2 - textHeight / 2 - 2;
+      const checkOverlap = (x, y) => {
+        return elements2.slice(0, index).some((otherElement) => {
+          return x < otherElement.rect.left + otherElement.rect.width && x + rectWidth > otherElement.rect.left && y < otherElement.rect.top + otherElement.rect.height && y + rectHeight > otherElement.rect.top;
+        });
+      };
+      const isWithinBounds = (x, y) => {
+        return x >= 0 && x + rectWidth <= imageWidth2 && y >= 0 && y + rectHeight <= imageHeight2;
+      };
+      if (checkOverlap(rectX, rectY) || !isWithinBounds(rectX, rectY)) {
+        if (!checkOverlap(paddedRect.left, paddedRect.top - rectHeight - 2) && isWithinBounds(paddedRect.left, paddedRect.top - rectHeight - 2)) {
+          rectX = paddedRect.left;
+          rectY = paddedRect.top - rectHeight - 2;
+        } else if (!checkOverlap(
+          paddedRect.left,
+          paddedRect.top + paddedRect.height + 2
+        ) && isWithinBounds(
+          paddedRect.left,
+          paddedRect.top + paddedRect.height + 2
+        )) {
+          rectX = paddedRect.left;
+          rectY = paddedRect.top + paddedRect.height + 2;
+        } else if (!checkOverlap(
+          paddedRect.left + paddedRect.width + 2,
+          paddedRect.top
+        ) && isWithinBounds(paddedRect.left + paddedRect.width + 2, paddedRect.top)) {
+          rectX = paddedRect.left + paddedRect.width + 2;
+          rectY = paddedRect.top;
+        } else {
+          rectX = paddedRect.left;
+          rectY = paddedRect.top + 2;
+        }
+      }
+      image.scan(rectX, rectY, rectWidth, rectHeight, function(x, y, idx) {
+        this.bitmap.data[idx + 0] = color.rect >> 24 & 255;
+        this.bitmap.data[idx + 1] = color.rect >> 16 & 255;
+        this.bitmap.data[idx + 2] = color.rect >> 8 & 255;
+        this.bitmap.data[idx + 3] = color.rect & 255;
+      });
+      const font = yield Jimp.loadFont(Jimp.FONT_SANS_16_WHITE);
+      image.print(
+        font,
+        rectX,
+        rectY,
+        {
+          text: element.indexId.toString(),
+          alignmentX: Jimp.HORIZONTAL_ALIGN_CENTER,
+          alignmentY: Jimp.VERTICAL_ALIGN_MIDDLE
+        },
+        rectWidth,
+        rectHeight
+      );
+    }
+    return image.getBufferAsync(Jimp.MIME_PNG);
+  });
+  return createPngOverlay(elements, imageWidth, imageHeight);
+};
+var compositeElementInfoImg = (options) => __async(void 0, null, function* () {
+  const Jimp = yield getJimp();
+  const { inputImgBase64, elementsPositionInfo } = options;
+  const imageBuffer = yield bufferFromBase64(inputImgBase64);
+  const { width, height } = yield imageInfo(imageBuffer);
+  if (!width || !height) {
+    throw Error("Image processing failed because width or height is undefined");
+  }
+  const svgOverlay = yield createSvgOverlay(
+    elementsPositionInfo,
+    width,
+    height
+  );
+  return yield Jimp.read(imageBuffer).then((image) => __async(void 0, null, function* () {
+    const svgImage = yield Jimp.read(svgOverlay);
+    return image.composite(svgImage, 0, 0, {
+      mode: Jimp.BLEND_SOURCE_OVER,
+      opacitySource: 1,
+      opacityDest: 1
+    });
+  })).then((compositeImage) => {
+    return compositeImage.getBufferAsync(Jimp.MIME_PNG);
+  }).then((buffer) => {
+    return buffer.toString("base64");
+  }).catch((error) => {
+    throw error;
+  });
+});
+var processImageElementInfo = (options) => __async(void 0, null, function* () {
+  const base64Image = options.inputImgBase64.split(";base64,").pop();
+  (0, import_node_assert2.default)(base64Image, "base64Image is undefined");
+  const [
+    compositeElementInfoImgBase64,
+    compositeElementInfoImgWithoutTextBase64
+  ] = yield Promise.all([
+    compositeElementInfoImg({
+      inputImgBase64: options.inputImgBase64,
+      elementsPositionInfo: options.elementsPositionInfo
+    }),
+    compositeElementInfoImg({
+      inputImgBase64: options.inputImgBase64,
+      elementsPositionInfo: options.elementsPositionInfoWithoutText
+    })
+  ]);
+  return {
+    compositeElementInfoImgBase64,
+    compositeElementInfoImgWithoutTextBase64
+  };
+});

package/dist/browser/index.d.ts

@@ -0,0 +1,3 @@
+declare const _default: {};
+
+export { _default as default };

package/dist/browser/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var src_default = {};

package/dist/browser/utils.d.ts

@@ -0,0 +1,4 @@
+declare const ifInBrowser: boolean;
+declare function uuid(): string;
+
+export { ifInBrowser, uuid };

package/dist/browser/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  ifInBrowser: () => ifInBrowser,
+  uuid: () => uuid
+});
+module.exports = __toCommonJS(utils_exports);
+var import_node_crypto = require("crypto");
+var ifInBrowser = typeof window !== "undefined";
+function uuid() {
+  if (ifInBrowser) {
+    return Math.random().toString(36).substring(2, 15);
+  }
+  return (0, import_node_crypto.randomUUID)();
+}

package/dist/es/constants.d.ts

@@ -0,0 +1,13 @@
+declare const TEXT_SIZE_THRESHOLD = 9;
+declare const TEXT_MAX_SIZE = 40;
+declare const CONTAINER_MINI_HEIGHT = 3;
+declare const CONTAINER_MINI_WIDTH = 3;
+declare enum NodeType {
+    CONTAINER = "CONTAINER Node",
+    FORM_ITEM = "FORM_ITEM Node",
+    BUTTON = "BUTTON Node",
+    IMG = "IMG Node",
+    TEXT = "TEXT Node"
+}
+
+export { CONTAINER_MINI_HEIGHT, CONTAINER_MINI_WIDTH, NodeType, TEXT_MAX_SIZE, TEXT_SIZE_THRESHOLD };

package/dist/es/fs.d.ts

@@ -0,0 +1,14 @@
+interface PkgInfo {
+    name: string;
+    version: string;
+    dir: string;
+}
+declare function getRunningPkgInfo(dir?: string): PkgInfo | null;
+/**
+ * Find the nearest package.json file recursively
+ * @param {string} dir - Home directory
+ * @returns {string|null} - The most recent package.json file path or null
+ */
+declare function findNearestPackageJson(dir: string): string | null;
+
+export { findNearestPackageJson, getRunningPkgInfo };

package/dist/es/fs.js

@@ -3,7 +3,11 @@ import assert from "assert";
 import { existsSync, readFileSync } from "fs";
 import { dirname, join } from "path";
 var pkg;
-function getMidscenePkgInfo(dir) {
+var ifInBrowser = typeof window !== "undefined";
+function getRunningPkgInfo(dir) {
+  if (ifInBrowser) {
+    return null;
+  }
   if (pkg) {
     return pkg;
   }
@@ -16,7 +20,7 @@ function getMidscenePkgInfo(dir) {
     return pkg;
   }
   return {
-    name: "midscene-unknown-page-name",
+    name: "midscene-unknown-package-name",
     version: "0.0.0",
     dir: pkgDir
   };
@@ -34,5 +38,5 @@ function findNearestPackageJson(dir) {
 }
 export {
   findNearestPackageJson,
-  getMidscenePkgInfo
+  getRunningPkgInfo
 };