@midscene/shared 0.7.2 → 0.7.3-beta-20241104100519.0

package/dist/lib/fs.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,43 +15,38 @@ var __copyProps = (to, from, except, desc) => {
   }
   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,
-  getMidscenePkgInfo: () => getMidscenePkgInfo
+  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;
-function getMidscenePkgInfo(dir) {
-  if (pkg) {
-    return pkg;
+var pkgCacheMap = {};
+var ifInBrowser = typeof window !== "undefined";
+function getRunningPkgInfo(dir) {
+  if (ifInBrowser) {
+    return null;
+  }
+  const dirToCheck = dir || process.cwd();
+  if (pkgCacheMap[dirToCheck]) {
+    return pkgCacheMap[dirToCheck];
   }
-  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 pkgDir = findNearestPackageJson(dirToCheck);
+  const pkgJsonFile = pkgDir ? (0, import_node_path.join)(pkgDir, "package.json") : null;
+  if (pkgDir && pkgJsonFile) {
     const { name, version } = JSON.parse((0, import_node_fs.readFileSync)(pkgJsonFile, "utf-8"));
-    pkg = { name, version, dir: pkgDir };
-    return pkg;
+    pkgCacheMap[dirToCheck] = { name, version, dir: pkgDir };
+    return pkgCacheMap[dirToCheck];
   }
   return {
-    name: "midscene-unknown-page-name",
+    name: "midscene-unknown-package-name",
     version: "0.0.0",
-    dir: pkgDir
+    dir: dirToCheck
   };
 }
 function findNearestPackageJson(dir) {
@@ -70,5 +63,5 @@ function findNearestPackageJson(dir) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   findNearestPackageJson,
-  getMidscenePkgInfo
+  getRunningPkgInfo
 });

package/dist/lib/img.d.ts

@@ -0,0 +1,143 @@
+import { Buffer } from 'node:buffer';
+import Jimp from 'jimp';
+import { NodeType } from './constants.js';
+
+interface Size$1 {
+    width: number;
+    height: number;
+}
+interface ImageInfo extends Size$1 {
+    jimpImage: Jimp;
+}
+/**
+ * Retrieves the dimensions of an image asynchronously
+ *
+ * @param image - The image data, which can be a string path or a buffer
+ * @returns A Promise that resolves to an object containing the width and height of the image
+ * @throws Error if the image data is invalid
+ */
+declare function imageInfo(image: string | Buffer | Jimp): Promise<ImageInfo>;
+/**
+ * Retrieves the dimensions of an image from a base64-encoded string
+ *
+ * @param imageBase64 - The base64-encoded image data
+ * @returns A Promise that resolves to an object containing the width and height of the image
+ * @throws Error if the image data is invalid
+ */
+declare function imageInfoOfBase64(imageBase64: string): Promise<ImageInfo>;
+declare function bufferFromBase64(imageBase64: string): Promise<Buffer>;
+/**
+ * Encodes an image file to a base64 encoded string
+ *
+ * @param image The path of the image file
+ * @param withHeader Determine whether to return data including the file header information, the default is true
+ *
+ * @returns The base64 encoded string of the image file, which may or may not include header information depending on the withHeader parameter
+ *
+ * @throws When the image type is not supported, an error will be thrown
+ */
+declare function base64Encoded(image: string, withHeader?: boolean): string;
+declare function base64ToPngFormat(base64: string): string;
+
+/**
+/**
+ * Saves a Base64-encoded image to a file
+ *
+ * @param options - An object containing the Base64-encoded image data and the output file path
+ * @param options.base64Data - The Base64-encoded image data
+ * @param options.outputPath - The path where the image will be saved
+ * @throws Error if there is an error during the saving process
+ */
+declare function saveBase64Image(options: {
+    base64Data: string;
+    outputPath: string;
+}): Promise<void>;
+/**
+ * Transforms an image path into a base64-encoded string
+ * @param inputPath - The path of the image file to be encoded
+ * @returns A Promise that resolves to a base64-encoded string representing the image file
+ */
+declare function transformImgPathToBase64(inputPath: string): Promise<string>;
+/**
+ * Resizes an image from a base64-encoded string
+ *
+ * @param base64Data - A base64-encoded string representing the image
+ * @returns A Promise that resolves to a base64-encoded string representing the resized image
+ * @throws An error if the width or height cannot be determined from the metadata
+ */
+declare function resizeImg(inputData: Buffer, newSize?: {
+    width: number;
+    height: number;
+}): Promise<Buffer>;
+declare function resizeImgBase64(inputData: string, newSize?: {
+    width: number;
+    height: number;
+}): Promise<string>;
+/**
+ * Calculates new dimensions for an image while maintaining its aspect ratio.
+ *
+ * This function is designed to resize an image to fit within a specified maximum width and height
+ * while maintaining the original aspect ratio. If the original width or height exceeds the maximum
+ * dimensions, the image will be scaled down to fit.
+ *
+ * @param {number} originalWidth - The original width of the image.
+ * @param {number} originalHeight - The original height of the image.
+ * @returns {Object} An object containing the new width and height.
+ * @throws {Error} Throws an error if the width or height is not a positive number.
+ */
+declare function calculateNewDimensions(originalWidth: number, originalHeight: number): {
+    width: number;
+    height: number;
+};
+/**
+ * Trims an image and returns the trimming information, including the offset from the left and top edges, and the trimmed width and height
+ *
+ * @param image - The image to be trimmed. This can be a file path or a Buffer object containing the image data
+ * @returns A Promise that resolves to an object containing the trimming information. If the image does not need to be trimmed, this object will be null
+ */
+declare function trimImage(image: string | Buffer): Promise<{
+    trimOffsetLeft: number;
+    trimOffsetTop: number;
+    width: number;
+    height: number;
+} | null>;
+
+interface Point {
+    left: number;
+    top: number;
+}
+interface Size {
+    width: number;
+    height: number;
+}
+type Rect = Point & Size;
+
+type ElementType = {
+    locator?: string;
+    rect: Rect;
+    center?: [number, number];
+    id?: string;
+    indexId: number;
+    attributes?: {
+        nodeType: NodeType;
+        [key: string]: string;
+    };
+};
+declare const compositeElementInfoImg: (options: {
+    inputImgBase64: string;
+    elementsPositionInfo: Array<ElementType>;
+    size?: {
+        width: number;
+        height: number;
+    };
+}) => Promise<string>;
+declare const processImageElementInfo: (options: {
+    inputImgBase64: string;
+    elementsPositionInfo: Array<ElementType>;
+    elementsPositionInfoWithoutText: Array<ElementType>;
+}) => Promise<{
+    compositeElementInfoImgBase64: string;
+    compositeElementInfoImgWithoutTextBase64: string;
+}>;
+
+export { base64Encoded, base64ToPngFormat, bufferFromBase64, calculateNewDimensions, compositeElementInfoImg, imageInfo, imageInfoOfBase64, processImageElementInfo, resizeImg, resizeImgBase64, saveBase64Image, transformImgPathToBase64, trimImage };