@iflyrpa/share 0.0.1

package/dist/index.cjs

@@ -0,0 +1,178 @@
+'use strict';
+
+const fs = require('node:fs');
+const https = require('node:https');
+const path = require('node:path');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const https__default = /*#__PURE__*/_interopDefaultCompat(https);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+
+function pathExists(path2) {
+  return new Promise((resolve) => {
+    fs__default.stat(path2, (err) => {
+      resolve(!err);
+    });
+  });
+}
+function ensureFileSync(filePath) {
+  const dirPath = path__default.dirname(filePath);
+  try {
+    if (!fs__default.existsSync(dirPath)) {
+      fs__default.mkdirSync(dirPath, { recursive: true });
+    }
+  } catch (err) {
+    if (err instanceof Error) {
+      throw new Error(`Error creating directory: ${err.message}`);
+    }
+  }
+  try {
+    if (!fs__default.existsSync(filePath)) {
+      fs__default.writeFileSync(filePath, "");
+    }
+  } catch (err) {
+    if (err instanceof Error) {
+      throw new Error(`Error creating file: ${err.message}`);
+    }
+  }
+}
+function writeFile(filePath, data) {
+  return new Promise((resolve, reject) => {
+    fs__default.writeFile(filePath, data, (err) => {
+      if (err) {
+        console.error("Error writing file:", err);
+        reject();
+      } else {
+        console.log("File written successfully");
+        resolve();
+      }
+    });
+  });
+}
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const num1 = i < parts1.length ? parts1[i] : 0;
+    const num2 = i < parts2.length ? parts2[i] : 0;
+    if (num1 > num2)
+      return 1;
+    if (num1 < num2)
+      return -1;
+  }
+  return 0;
+}
+const semver = {
+  gt: (v1, v2) => compareVersions(v1, v2) === 1
+};
+function fetchJSON(url) {
+  return new Promise((resolve, reject) => {
+    https__default.get(url, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          const parsedData = JSON.parse(data);
+          resolve(parsedData);
+        } catch (e) {
+          if (e instanceof Error) {
+            reject(new Error(`Error parsing JSON: ${e.message}`));
+          }
+        }
+      });
+    }).on("error", (err) => {
+      reject(new Error(`Request failed: ${err.message}`));
+    });
+  });
+}
+function isNil(value) {
+  return value === null || value === void 0;
+}
+function ensureFile(filePath) {
+  return new Promise((resolve, reject) => {
+    const dirPath = path__default.dirname(filePath);
+    fs__default.stat(dirPath, (err, stats) => {
+      if (err) {
+        if (err.code === "ENOENT") {
+          fs__default.mkdir(dirPath, { recursive: true }, (err2) => {
+            if (err2) {
+              return reject(err2);
+            }
+            createFile();
+          });
+        } else {
+          return reject(err);
+        }
+      } else if (stats.isDirectory()) {
+        checkFile();
+      } else {
+        reject(new Error(`${dirPath} is not a directory`));
+      }
+    });
+    function checkFile() {
+      fs__default.stat(filePath, (err, stats) => {
+        if (err) {
+          if (err.code === "ENOENT") {
+            createFile();
+          } else {
+            reject(err);
+          }
+        } else if (stats.isFile()) {
+          resolve();
+        } else {
+          reject(new Error(`${filePath} is not a file`));
+        }
+      });
+    }
+    function createFile() {
+      fs__default.writeFile(filePath, "", (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    }
+  });
+}
+async function downloadImage(url, savePath) {
+  await ensureFile(savePath);
+  return new Promise((resolve, reject) => {
+    https__default.get(url, (response) => {
+      if (response.statusCode === 200) {
+        const fileStream = fs__default.createWriteStream(savePath);
+        response.pipe(fileStream);
+        fileStream.on("finish", () => {
+          fileStream.close();
+          console.log("\u4E0B\u8F7D\u5B8C\u6210\uFF0C\u6587\u4EF6\u5DF2\u4FDD\u5B58\u81F3:", savePath);
+          resolve(savePath);
+        });
+      } else {
+        console.log("\u56FE\u7247\u4E0B\u8F7D\u5931\u8D25:", response.statusCode);
+        response.resume();
+        reject();
+      }
+    }).on("error", (error) => {
+      console.error("\u8BF7\u6C42\u56FE\u7247\u65F6\u53D1\u751F\u9519\u8BEF:", error.message);
+      reject();
+    });
+  });
+}
+function getFilenameFromUrl(imageUrl) {
+  const parsedUrl = new URL(imageUrl);
+  return path__default.basename(parsedUrl.pathname);
+}
+
+exports.downloadImage = downloadImage;
+exports.ensureFile = ensureFile;
+exports.ensureFileSync = ensureFileSync;
+exports.fetchJSON = fetchJSON;
+exports.getFilenameFromUrl = getFilenameFromUrl;
+exports.isNil = isNil;
+exports.pathExists = pathExists;
+exports.semver = semver;
+exports.writeFile = writeFile;

package/dist/index.mjs

@@ -0,0 +1,162 @@
+import fs from 'node:fs';
+import https from 'node:https';
+import path from 'node:path';
+
+function pathExists(path2) {
+  return new Promise((resolve) => {
+    fs.stat(path2, (err) => {
+      resolve(!err);
+    });
+  });
+}
+function ensureFileSync(filePath) {
+  const dirPath = path.dirname(filePath);
+  try {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  } catch (err) {
+    if (err instanceof Error) {
+      throw new Error(`Error creating directory: ${err.message}`);
+    }
+  }
+  try {
+    if (!fs.existsSync(filePath)) {
+      fs.writeFileSync(filePath, "");
+    }
+  } catch (err) {
+    if (err instanceof Error) {
+      throw new Error(`Error creating file: ${err.message}`);
+    }
+  }
+}
+function writeFile(filePath, data) {
+  return new Promise((resolve, reject) => {
+    fs.writeFile(filePath, data, (err) => {
+      if (err) {
+        console.error("Error writing file:", err);
+        reject();
+      } else {
+        console.log("File written successfully");
+        resolve();
+      }
+    });
+  });
+}
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const num1 = i < parts1.length ? parts1[i] : 0;
+    const num2 = i < parts2.length ? parts2[i] : 0;
+    if (num1 > num2)
+      return 1;
+    if (num1 < num2)
+      return -1;
+  }
+  return 0;
+}
+const semver = {
+  gt: (v1, v2) => compareVersions(v1, v2) === 1
+};
+function fetchJSON(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          const parsedData = JSON.parse(data);
+          resolve(parsedData);
+        } catch (e) {
+          if (e instanceof Error) {
+            reject(new Error(`Error parsing JSON: ${e.message}`));
+          }
+        }
+      });
+    }).on("error", (err) => {
+      reject(new Error(`Request failed: ${err.message}`));
+    });
+  });
+}
+function isNil(value) {
+  return value === null || value === void 0;
+}
+function ensureFile(filePath) {
+  return new Promise((resolve, reject) => {
+    const dirPath = path.dirname(filePath);
+    fs.stat(dirPath, (err, stats) => {
+      if (err) {
+        if (err.code === "ENOENT") {
+          fs.mkdir(dirPath, { recursive: true }, (err2) => {
+            if (err2) {
+              return reject(err2);
+            }
+            createFile();
+          });
+        } else {
+          return reject(err);
+        }
+      } else if (stats.isDirectory()) {
+        checkFile();
+      } else {
+        reject(new Error(`${dirPath} is not a directory`));
+      }
+    });
+    function checkFile() {
+      fs.stat(filePath, (err, stats) => {
+        if (err) {
+          if (err.code === "ENOENT") {
+            createFile();
+          } else {
+            reject(err);
+          }
+        } else if (stats.isFile()) {
+          resolve();
+        } else {
+          reject(new Error(`${filePath} is not a file`));
+        }
+      });
+    }
+    function createFile() {
+      fs.writeFile(filePath, "", (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    }
+  });
+}
+async function downloadImage(url, savePath) {
+  await ensureFile(savePath);
+  return new Promise((resolve, reject) => {
+    https.get(url, (response) => {
+      if (response.statusCode === 200) {
+        const fileStream = fs.createWriteStream(savePath);
+        response.pipe(fileStream);
+        fileStream.on("finish", () => {
+          fileStream.close();
+          console.log("\u4E0B\u8F7D\u5B8C\u6210\uFF0C\u6587\u4EF6\u5DF2\u4FDD\u5B58\u81F3:", savePath);
+          resolve(savePath);
+        });
+      } else {
+        console.log("\u56FE\u7247\u4E0B\u8F7D\u5931\u8D25:", response.statusCode);
+        response.resume();
+        reject();
+      }
+    }).on("error", (error) => {
+      console.error("\u8BF7\u6C42\u56FE\u7247\u65F6\u53D1\u751F\u9519\u8BEF:", error.message);
+      reject();
+    });
+  });
+}
+function getFilenameFromUrl(imageUrl) {
+  const parsedUrl = new URL(imageUrl);
+  return path.basename(parsedUrl.pathname);
+}
+
+export { downloadImage, ensureFile, ensureFileSync, fetchJSON, getFilenameFromUrl, isNil, pathExists, semver, writeFile };

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@iflyrpa/share",
+  "version": "0.0.1",
+  "description": "",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./src/index.ts",
+  "author": "bijinfeng",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "devDependencies": {
+    "playwright-core": "1.46.1",
+    "unbuild": "^2.0.0"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev": "unbuild --stub"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./utils";
+
+export type * from "./types";

package/src/types.ts

@@ -0,0 +1,75 @@
+import type { Page } from "playwright";
+
+export type { Locator, Response, ElectronApplication } from "playwright-core";
+
+export interface CookiesSetDetails {
+	/**
+	 * The URL to associate the cookie with. The promise will be rejected if the URL is
+	 * invalid.
+	 */
+	url: string;
+	/**
+	 * The name of the cookie. Empty by default if omitted.
+	 */
+	name?: string;
+	/**
+	 * The value of the cookie. Empty by default if omitted.
+	 */
+	value?: string;
+	/**
+	 * The domain of the cookie; this will be normalized with a preceding dot so that
+	 * it's also valid for subdomains. Empty by default if omitted.
+	 */
+	domain?: string;
+	/**
+	 * The path of the cookie. Empty by default if omitted.
+	 */
+	path?: string;
+	/**
+	 * Whether the cookie should be marked as Secure. Defaults to false unless Same
+	 * Site=None attribute is used.
+	 */
+	secure?: boolean;
+	/**
+	 * Whether the cookie should be marked as HTTP only. Defaults to false.
+	 */
+	httpOnly?: boolean;
+	/**
+	 * The expiration date of the cookie as the number of seconds since the UNIX epoch.
+	 * If omitted then the cookie becomes a session cookie and will not be retained
+	 * between sessions.
+	 */
+	expirationDate?: number;
+	/**
+	 * The Same Site policy to apply to this cookie.  Can be `unspecified`,
+	 * `no_restriction`, `lax` or `strict`.  Default is `lax`.
+	 */
+	sameSite?: "unspecified" | "no_restriction" | "lax" | "strict";
+}
+
+export type CookieMap = CookiesSetDetails[];
+
+export interface PageParams {
+	cookies?: CookieMap;
+	url: string;
+	show?: boolean;
+}
+
+export interface LoggerImplement {
+	debug(...msg: unknown[]): void;
+	info(...msg: unknown[]): void;
+	warn(...msg: unknown[]): void;
+	error(prefix: string, err?: unknown): void;
+}
+
+export interface AutomateTask {
+	debug?: boolean; // debug 模式下可视化展示所有操作
+	cachePath: string; // 缓存目录
+	forceUpdate?: boolean; // 是否使用远程最新版本
+	logger: LoggerImplement;
+
+	getTmpPath(): string;
+	createPage(pageParams: PageParams): Promise<Page>;
+}
+
+export type CommonAction<T, D> = (task: AutomateTask, params: T) => Promise<D>;

package/src/utils.ts

@@ -0,0 +1,211 @@
+import fs from "node:fs";
+import https from "node:https";
+import path from "node:path";
+
+export function pathExists(path: string) {
+	return new Promise((resolve) => {
+		fs.stat(path, (err) => {
+			resolve(!err);
+		});
+	});
+}
+
+export function ensureFileSync(filePath: string) {
+	const dirPath = path.dirname(filePath);
+
+	// 检查目录是否存在
+	try {
+		if (!fs.existsSync(dirPath)) {
+			// 目录不存在，需要创建
+			fs.mkdirSync(dirPath, { recursive: true });
+		}
+	} catch (err) {
+		if (err instanceof Error) {
+			throw new Error(`Error creating directory: ${err.message}`);
+		}
+	}
+
+	// 检查文件是否存在
+	try {
+		if (!fs.existsSync(filePath)) {
+			// 文件不存在，创建文件
+			fs.writeFileSync(filePath, "");
+		}
+	} catch (err) {
+		if (err instanceof Error) {
+			throw new Error(`Error creating file: ${err.message}`);
+		}
+	}
+}
+
+export function writeFile(filePath: string, data: string) {
+	return new Promise<void>((resolve, reject) => {
+		fs.writeFile(filePath, data, (err) => {
+			if (err) {
+				console.error("Error writing file:", err);
+				reject();
+			} else {
+				console.log("File written successfully");
+				resolve();
+			}
+		});
+	});
+}
+
+function compareVersions(v1: string, v2: string) {
+	// 将两个版本号分割成数字数组
+	const parts1 = v1.split(".").map(Number);
+	const parts2 = v2.split(".").map(Number);
+
+	// 比较每个分割后的数字
+	for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+		// 如果某个版本号在这一段没有数字（即该段默认为0）
+		const num1 = i < parts1.length ? parts1[i] : 0;
+		const num2 = i < parts2.length ? parts2[i] : 0;
+
+		// 比较两个数字
+		if (num1 > num2) return 1;
+		if (num1 < num2) return -1;
+	}
+
+	// 如果所有的数字都相等，那么版本号相同
+	return 0;
+}
+
+export const semver = {
+	gt: (v1: string, v2: string) => compareVersions(v1, v2) === 1,
+};
+
+export function fetchJSON<T>(url: string) {
+	return new Promise<T>((resolve, reject) => {
+		https
+			.get(url, (res) => {
+				let data = "";
+
+				res.on("data", (chunk) => {
+					data += chunk;
+				});
+
+				res.on("end", () => {
+					try {
+						const parsedData = JSON.parse(data);
+						resolve(parsedData);
+					} catch (e) {
+						if (e instanceof Error) {
+							reject(new Error(`Error parsing JSON: ${e.message}`));
+						}
+					}
+				});
+			})
+			.on("error", (err) => {
+				reject(new Error(`Request failed: ${err.message}`));
+			});
+	});
+}
+
+export function isNil(value: unknown): value is null | undefined {
+	return value === null || value === undefined;
+}
+
+export function ensureFile(filePath: string) {
+	return new Promise<void>((resolve, reject) => {
+		const dirPath = path.dirname(filePath);
+
+		// 检查目录是否存在
+		fs.stat(dirPath, (err, stats) => {
+			if (err) {
+				if (err.code === "ENOENT") {
+					// 目录不存在，需要创建
+					fs.mkdir(dirPath, { recursive: true }, (err) => {
+						if (err) {
+							return reject(err);
+						}
+						createFile();
+					});
+				} else {
+					return reject(err);
+				}
+			} else if (stats.isDirectory()) {
+				// 目录已存在，检查文件
+				checkFile();
+			} else {
+				// 路径不是目录
+				reject(new Error(`${dirPath} is not a directory`));
+			}
+		});
+
+		function checkFile() {
+			fs.stat(filePath, (err, stats) => {
+				if (err) {
+					if (err.code === "ENOENT") {
+						// 文件不存在，创建文件
+						createFile();
+					} else {
+						reject(err);
+					}
+				} else if (stats.isFile()) {
+					// 文件已存在
+					resolve();
+				} else {
+					// 路径存在，但不是文件
+					reject(new Error(`${filePath} is not a file`));
+				}
+			});
+		}
+
+		function createFile() {
+			fs.writeFile(filePath, "", (err) => {
+				if (err) {
+					reject(err);
+				} else {
+					resolve();
+				}
+			});
+		}
+	});
+}
+
+// 下载图片并保存到指定路径
+export async function downloadImage(
+	url: string,
+	savePath: string,
+): Promise<string> {
+	await ensureFile(savePath);
+
+	return new Promise<string>((resolve, reject) => {
+		https
+			.get(url, (response) => {
+				// 检查响应状态码是否表明成功接收图片
+				if (response.statusCode === 200) {
+					// 创建文件写入流
+					const fileStream = fs.createWriteStream(savePath);
+					// 将响应流重定向到文件写入流
+					response.pipe(fileStream);
+
+					// 文件结束写入后关闭文件流
+					fileStream.on("finish", () => {
+						fileStream.close();
+						console.log("下载完成，文件已保存至:", savePath);
+						resolve(savePath);
+					});
+				} else {
+					// 如果响应状态码不是 200，打印错误信息
+					console.log("图片下载失败:", response.statusCode);
+					// 消费响应数据以释放内存
+					response.resume();
+					reject();
+				}
+			})
+			.on("error", (error) => {
+				// 如果请求过程中出现错误，打印错误信息并确保文件流关闭
+				console.error("请求图片时发生错误:", error.message);
+				reject();
+			});
+	});
+}
+
+// 从 URL 中获取文件名
+export function getFilenameFromUrl(imageUrl: string) {
+	const parsedUrl = new URL(imageUrl); // 使用 URL 构造函数解析完整的 URL
+	return path.basename(parsedUrl.pathname); // 获取路径名的最后一部分作为文件名
+}