@weapp-core/shared 3.0.3 → 3.0.5

package/README.md

@@ -3,12 +3,14 @@
 ## 简介
 
 `@weapp-core/shared` 汇总 weapp-vite 生态内的通用工具函数与依赖封装，供多个包复用。
+根入口默认保持小程序运行时安全；Node 专用能力通过独立子入口导出。
 
 ## 特性
 
 - 常用字符串与路径处理工具
 - 对象合并与判定工具
-- 统一导出常用第三方工具（`defu`、`get`、`set`、`object-hash`）
+- 统一导出常用第三方工具（`defu`、`get`、`set`）
+- 通过 `@weapp-core/shared/node` 提供 Node 专用哈希与文件系统能力
 
 ## 安装
 
@@ -23,13 +25,14 @@ import {
   addExtension,
   defu,
   escapeStringRegexp,
-  objectHash,
   removeExtension,
 } from '@weapp-core/shared'
+import { fs, objectHash } from '@weapp-core/shared/node'
 
 const name = addExtension('pages/index/index')
 const cleaned = removeExtension('app.json')
 const hash = objectHash({ foo: 'bar' })
+const exists = await fs.pathExists('app.json')
 ```
 
 ## 配置

package/dist/fs/index.d.ts

@@ -0,0 +1,93 @@
+import { Dirent, OpenMode, PathLike, Stats, closeSync, constants, existsSync, mkdirSync, openSync, promises, readFileSync, unlinkSync, utimesSync, watch, writeFileSync } from "node:fs";
+import { FileHandle } from "node:fs/promises";
+
+//#region src/fs/index.d.ts
+interface JsonReadOptions {
+  encoding?: BufferEncoding;
+  throws?: boolean;
+}
+interface JsonWriteOptions {
+  encoding?: BufferEncoding;
+  replacer?: ((this: any, key: string, value: any) => any) | Array<number | string> | null;
+  spaces?: number | string;
+}
+interface CopyOptions {
+  dereference?: boolean;
+  errorOnExist?: boolean;
+  filter?: (src: string, dest: string) => boolean | Promise<boolean>;
+  overwrite?: boolean;
+  preserveTimestamps?: boolean;
+  verbatimSymlinks?: boolean;
+}
+interface MoveOptions {
+  overwrite?: boolean;
+}
+declare function pathExists(target: string): Promise<boolean>;
+declare function pathExistsSync(target: string): boolean;
+declare function exists(target: string): Promise<boolean>;
+declare function ensureDir(dir: string): Promise<void>;
+declare function ensureFile(file: string): Promise<void>;
+declare function remove(target: string): Promise<void>;
+declare function ensureSymlink(target: string, file: string): Promise<void>;
+declare function emptyDir(dir: string): Promise<void>;
+declare function outputFile(file: string, data: string | NodeJS.ArrayBufferView, options?: BufferEncoding): Promise<void>;
+declare function appendFile(file: string, data: string | NodeJS.ArrayBufferView, options?: BufferEncoding): Promise<void>;
+declare function writeJson(file: string, data: unknown, options?: JsonWriteOptions): Promise<void>;
+declare function writeJSON(file: string, data: unknown, options?: JsonWriteOptions): Promise<void>;
+declare function outputJson(file: string, data: unknown, options?: JsonWriteOptions): Promise<void>;
+declare function outputJSON(file: string, data: unknown, options?: JsonWriteOptions): Promise<void>;
+declare function readJson<T = unknown>(file: string, options?: JsonReadOptions): Promise<T | null>;
+declare function readJSON<T = unknown>(file: string, options?: JsonReadOptions): Promise<T | null>;
+declare function readJsonSync<T = unknown>(file: string, options?: JsonReadOptions): T | null;
+declare function copy(src: string, dest: string, options?: CopyOptions): Promise<void>;
+declare function move(src: string, dest: string, options?: MoveOptions): Promise<void>;
+declare function close$1(handle: number | FileHandle): Promise<void>;
+declare const fs: {
+  Dirent: typeof Dirent;
+  Stats: typeof Stats;
+  access: typeof promises.access;
+  appendFile: typeof appendFile;
+  close: typeof close$1;
+  closeSync: typeof closeSync;
+  constants: typeof constants;
+  copy: typeof copy;
+  emptyDir: typeof emptyDir;
+  ensureDir: typeof ensureDir;
+  ensureFile: typeof ensureFile;
+  ensureSymlink: typeof ensureSymlink;
+  exists: typeof exists;
+  existsSync: typeof existsSync;
+  mkdir: typeof promises.mkdir;
+  mkdirSync: typeof mkdirSync;
+  mkdtemp: typeof promises.mkdtemp;
+  move: typeof move;
+  open: (file: PathLike, flags: OpenMode) => Promise<FileHandle>;
+  openSync: typeof openSync;
+  outputFile: typeof outputFile;
+  outputJSON: typeof outputJSON;
+  outputJson: typeof outputJson;
+  pathExists: typeof pathExists;
+  pathExistsSync: typeof pathExistsSync;
+  readFile: typeof promises.readFile;
+  readFileSync: typeof readFileSync;
+  readJSON: typeof readJSON;
+  readJson: typeof readJson;
+  readJsonSync: typeof readJsonSync;
+  readdir: typeof promises.readdir;
+  rm: typeof promises.rm;
+  remove: typeof remove;
+  stat: typeof promises.stat;
+  symlink: typeof promises.symlink;
+  unlinkSync: typeof unlinkSync;
+  utimes: typeof promises.utimes;
+  utimesSync: typeof utimesSync;
+  watch: typeof watch;
+  writeFile: typeof promises.writeFile;
+  writeFileSync: typeof writeFileSync;
+  writeJSON: typeof writeJSON;
+  writeJson: typeof writeJson;
+};
+type FsDirent = Dirent;
+type FsStats = Stats;
+//#endregion
+export { CopyOptions, FsDirent, FsStats, JsonReadOptions, JsonWriteOptions, MoveOptions, fs };

package/dist/fs/index.js

@@ -0,0 +1,198 @@
+import { Dirent, Stats, close, closeSync, constants, existsSync, mkdirSync, openSync, promises, readFileSync, unlinkSync, utimesSync, watch, writeFileSync } from "node:fs";
+import path from "node:path";
+//#region src/fs/index.ts
+function normalizeJsonEncoding(encoding) {
+	return encoding ?? "utf8";
+}
+function normalizeJsonText(source) {
+	return source.charCodeAt(0) === 65279 ? source.slice(1) : source;
+}
+function serializeJson(data, options) {
+	const replacer = options?.replacer;
+	if (typeof replacer === "function") return JSON.stringify(data, replacer, options?.spaces);
+	if (Array.isArray(replacer)) return JSON.stringify(data, replacer, options?.spaces);
+	return JSON.stringify(data, null, options?.spaces);
+}
+async function pathExists(target) {
+	try {
+		await promises.access(target);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function pathExistsSync(target) {
+	try {
+		return existsSync(target);
+	} catch {
+		return false;
+	}
+}
+async function exists(target) {
+	return pathExists(target);
+}
+async function ensureDir(dir) {
+	await promises.mkdir(dir, { recursive: true });
+}
+async function ensureFile(file) {
+	await ensureDir(path.dirname(file));
+	await (await promises.open(file, "a")).close();
+}
+async function remove(target) {
+	await promises.rm(target, {
+		force: true,
+		recursive: true
+	});
+}
+async function ensureSymlink(target, file) {
+	await ensureDir(path.dirname(file));
+	try {
+		if (await promises.readlink(file) === target) return;
+		await remove(file);
+	} catch (error) {
+		if (error?.code !== "ENOENT") throw error;
+	}
+	await promises.symlink(target, file);
+}
+async function emptyDir(dir) {
+	await ensureDir(dir);
+	const entries = await promises.readdir(dir, { withFileTypes: true });
+	await Promise.all(entries.map((entry) => {
+		return remove(path.join(dir, entry.name));
+	}));
+}
+async function outputFile(file, data, options) {
+	await ensureDir(path.dirname(file));
+	await promises.writeFile(file, data, options);
+}
+async function appendFile(file, data, options) {
+	await ensureDir(path.dirname(file));
+	await promises.appendFile(file, data, options);
+}
+async function writeJson(file, data, options) {
+	const source = serializeJson(data, options);
+	await promises.writeFile(file, source, normalizeJsonEncoding(options?.encoding));
+}
+async function writeJSON(file, data, options) {
+	await writeJson(file, data, options);
+}
+async function outputJson(file, data, options) {
+	await ensureDir(path.dirname(file));
+	await writeJson(file, data, options);
+}
+async function outputJSON(file, data, options) {
+	await outputJson(file, data, options);
+}
+async function readJson(file, options) {
+	try {
+		const source = await promises.readFile(file, normalizeJsonEncoding(options?.encoding));
+		return JSON.parse(normalizeJsonText(source));
+	} catch (error) {
+		if (options?.throws === false && error instanceof SyntaxError) return null;
+		throw error;
+	}
+}
+async function readJSON(file, options) {
+	return readJson(file, options);
+}
+function readJsonSync(file, options) {
+	try {
+		const source = readFileSync(file, normalizeJsonEncoding(options?.encoding));
+		return JSON.parse(normalizeJsonText(source));
+	} catch (error) {
+		if (options?.throws === false && error instanceof SyntaxError) return null;
+		throw error;
+	}
+}
+async function copy(src, dest, options) {
+	await promises.cp(src, dest, {
+		...typeof options?.dereference === "boolean" ? { dereference: options.dereference } : {},
+		...typeof options?.errorOnExist === "boolean" ? { errorOnExist: options.errorOnExist } : {},
+		...typeof options?.filter === "function" ? { filter: options.filter } : {},
+		...typeof options?.preserveTimestamps === "boolean" ? { preserveTimestamps: options.preserveTimestamps } : {},
+		...typeof options?.verbatimSymlinks === "boolean" ? { verbatimSymlinks: options.verbatimSymlinks } : {},
+		force: options?.overwrite ?? true,
+		recursive: true
+	});
+}
+async function move(src, dest, options) {
+	if (src === dest) return;
+	if (await pathExists(dest)) {
+		if (!options?.overwrite) {
+			const error = /* @__PURE__ */ new Error(`dest already exists: ${dest}`);
+			error.code = "EEXIST";
+			throw error;
+		}
+		await remove(dest);
+	}
+	await ensureDir(path.dirname(dest));
+	try {
+		await promises.rename(src, dest);
+	} catch (error) {
+		if (error?.code !== "EXDEV") throw error;
+		await copy(src, dest, { overwrite: options?.overwrite ?? true });
+		await remove(src);
+	}
+}
+async function close$1(handle) {
+	if (typeof handle === "number") {
+		await new Promise((resolve, reject) => {
+			close(handle, (error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve();
+			});
+		});
+		return;
+	}
+	await handle.close();
+}
+const fs = {
+	Dirent,
+	Stats,
+	access: promises.access,
+	appendFile,
+	close: close$1,
+	closeSync,
+	constants,
+	copy,
+	emptyDir,
+	ensureDir,
+	ensureFile,
+	ensureSymlink,
+	exists,
+	existsSync,
+	mkdir: promises.mkdir,
+	mkdirSync,
+	mkdtemp: promises.mkdtemp,
+	move,
+	open: (file, flags) => promises.open(file, flags),
+	openSync,
+	outputFile,
+	outputJSON,
+	outputJson,
+	pathExists,
+	pathExistsSync,
+	readFile: promises.readFile,
+	readFileSync,
+	readJSON,
+	readJson,
+	readJsonSync,
+	readdir: promises.readdir,
+	rm: promises.rm,
+	remove,
+	stat: promises.stat,
+	symlink: promises.symlink,
+	unlinkSync,
+	utimes: promises.utimes,
+	utimesSync,
+	watch,
+	writeFile: promises.writeFile,
+	writeFileSync,
+	writeJSON,
+	writeJson
+};
+//#endregion
+export { fs };