@midscene/shared 0.7.2 → 0.7.3-beta-20241104100519.0

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

@@ -1,24 +1,27 @@
 // src/fs/index.ts
-import assert from "assert";
 import { existsSync, readFileSync } from "fs";
 import { dirname, join } from "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());
-  assert(pkgDir, "package.json not found");
-  const pkgJsonFile = join(pkgDir, "package.json");
-  if (pkgJsonFile) {
+  const pkgDir = findNearestPackageJson(dirToCheck);
+  const pkgJsonFile = pkgDir ? join(pkgDir, "package.json") : null;
+  if (pkgDir && pkgJsonFile) {
     const { name, version } = JSON.parse(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) {
@@ -34,5 +37,5 @@ function findNearestPackageJson(dir) {
 }
 export {
   findNearestPackageJson,
-  getMidscenePkgInfo
+  getRunningPkgInfo
 };

package/dist/es/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 };