tcdona_unilib 1.0.0 → 1.0.2

package/staticMeta/sync.ts

@@ -0,0 +1,296 @@
+/**
+ * 目录同步工具：支持比较文件内容和修改时间，决定是否复制
+ */
+
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { err, ok } from 'neverthrow';
+import { Eff } from './eff.js';
+import type { ResultAsync } from 'neverthrow';
+import { fileInit } from './enum.api.js';
+
+// ==================== 日志配置 ====================
+
+const fileId = fileInit('src/staticMeta/sync.ts');
+
+// ==================== 类型定义 ====================
+
+export interface SyncStats {
+    copied: number;
+    skipped: number;
+    deleted: number;
+    errors: number;
+}
+
+export interface SyncConfig {
+    fedoc: string;
+    tcsdd: string;
+    relativeDir: string;
+}
+
+// ==================== 同步配置 ====================
+
+// 默认配置：src/staticMeta 到目标项目
+const defaultConfig: SyncConfig = {
+    fedoc: '/Users/admin/Documents/proj/tech/hk-fe-doc/src',
+    tcsdd: '/Users/admin/Documents/tc/tcsdd/src',
+    relativeDir: 'staticMeta',
+};
+
+// ==================== 同步函数 ====================
+
+/**
+ * 同步单个文件：根据内容和修改时间决定是否复制
+ */
+async function syncFile(
+    srcPath: string,
+    destPath: string,
+    stats: SyncStats,
+): Promise<void> {
+    let shouldCopy = false;
+
+    try {
+        // 检查目标文件是否存在
+        const destExists = await fs
+            .access(destPath)
+            .then(() => true)
+            .catch(() => false);
+
+        if (!destExists) {
+            // 目标文件不存在，直接复制
+            shouldCopy = true;
+        } else {
+            // 目标文件存在，比较内容和修改时间
+            const [srcStat, destStat, srcContent, destContent]
+                = await Promise.all([
+                    fs.stat(srcPath),
+                    fs.stat(destPath),
+                    fs.readFile(srcPath),
+                    fs.readFile(destPath),
+                ]);
+
+            // 先比较内容
+            if (!srcContent.equals(destContent)) {
+                shouldCopy = true;
+            } else if (srcStat.mtime > destStat.mtime) {
+                // 内容相同但源文件更新，也复制
+                shouldCopy = true;
+            }
+        }
+
+        if (shouldCopy) {
+            await fs.copyFile(srcPath, destPath);
+            stats.copied++;
+        } else {
+            stats.skipped++;
+        }
+    } catch (err) {
+        stats.errors++;
+        throw err;
+    }
+}
+
+/**
+ * 获取目录中所有文件的相对路径集合
+ */
+async function getFileSet(
+    dirPath: string,
+    basePath: string = dirPath,
+): Promise<Set<string>> {
+    const fileSet = new Set<string>();
+
+    try {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry.name);
+            const relativePath = path.relative(basePath, fullPath);
+
+            if (entry.isDirectory()) {
+                // 递归获取子目录中的文件
+                const subFiles = await getFileSet(fullPath, basePath);
+                subFiles.forEach((file) => fileSet.add(file));
+            } else if (entry.isFile()) {
+                if (!fullPath.endsWith('/dep.ts')) {
+                    fileSet.add(relativePath);
+                }
+            }
+        }
+    } catch (err) {
+        // 目录可能不存在，返回空集合
+    }
+
+    return fileSet;
+}
+
+/**
+ * 删除目标目录中多余的文件和目录
+ */
+async function cleanupExtraFiles(
+    srcDir: string,
+    destDir: string,
+    stats: SyncStats,
+): Promise<void> {
+    try {
+        const srcFileSet = await getFileSet(srcDir);
+        const destFileSet = await getFileSet(destDir);
+
+        // 找出目标中有但源中没有的文件
+        const filesToDelete: string[] = [];
+        destFileSet.forEach((file) => {
+            if (!srcFileSet.has(file)) {
+                filesToDelete.push(file);
+            }
+        });
+
+        // 删除多余的文件（从最深的路径开始删除，避免文件夹不为空的问题）
+        const sortedFiles = filesToDelete.sort((a, b) => b.localeCompare(a));
+
+        for (const file of sortedFiles) {
+            const fullPath = path.join(destDir, file);
+            try {
+                const stat = await fs.stat(fullPath);
+                if (stat.isDirectory()) {
+                    await fs.rm(fullPath, { recursive: true, force: true });
+                } else {
+                    await fs.unlink(fullPath);
+                }
+                stats.deleted++;
+            } catch (err) {
+                fileId('deleteFileFailed').error(`Failed to delete ${fullPath}: ${err}`);
+                stats.errors++;
+            }
+        }
+    } catch (err) {
+        fileId('cleanupFailed').error(`Failed to cleanup extra files: ${err}`);
+        stats.errors++;
+    }
+}
+
+/**
+ * 递归同步目录树（使用 Eff 处理取消信号）
+ */
+function syncDirectory(
+    srcPath: string,
+    destPath: string,
+    stats: SyncStats,
+    signal: AbortSignal,
+): ResultAsync<void, Error> {
+    return Eff.create(
+        async ({ signal: innerSignal }) => {
+            if (innerSignal.aborted) return err(new Error('操作已取消'));
+
+            try {
+                // 确保源目录存在
+                await fs.access(srcPath);
+
+                // 确保目标目录存在
+                await fs.mkdir(destPath, { recursive: true });
+
+                // 读取源目录内容
+                const entries = await fs.readdir(srcPath, { withFileTypes: true });
+
+                for (const entry of entries) {
+                    if (innerSignal.aborted) return err(new Error('操作已取消'));
+
+                    const srcEntryPath = path.join(srcPath, entry.name);
+                    const destEntryPath = path.join(destPath, entry.name);
+
+                    try {
+                        if (entry.isDirectory()) {
+                            // 递归同步子目录
+                            const dirResult = await syncDirectory(
+                                srcEntryPath,
+                                destEntryPath,
+                                stats,
+                                innerSignal,
+                            );
+                            if (dirResult.isErr()) {
+                                return err(dirResult.error);
+                            }
+                        } else if (entry.isFile()) {
+                            // 同步文件
+                            if (srcEntryPath.endsWith('/dep.ts')) continue; // 跳过 dep.ts 文件
+                            await syncFile(srcEntryPath, destEntryPath, stats);
+                        }
+                    } catch (err) {
+                        stats.errors++;
+                        fileId('syncEntryFailed').error(
+                            `Failed to sync ${entry.isDirectory() ? 'directory' : 'file'} ${srcEntryPath}: ${err}`,
+                        );
+                    }
+                }
+
+                return ok(undefined);
+            } catch (error) {
+                return err(new Error(`同步失败: ${error}`));
+            }
+        },
+        signal,
+    );
+}
+
+/**
+ * 执行目录同步：返回统计信息（已复制、已跳过、已删除、错误数）
+ */
+function sync(config: SyncConfig, from: 'fedoc' | 'tcsdd'): ResultAsync<SyncStats, Error> {
+    return Eff.root(async ({ signal }) => {
+        if (signal.aborted) return err(new Error('操作已取消'));
+
+        const stats: SyncStats = {
+            copied: 0,
+            skipped: 0,
+            deleted: 0,
+            errors: 0,
+        };
+
+        const to = from === 'fedoc' ? 'tcsdd' : 'fedoc';
+
+        const srcDir = path.join(config[from], config.relativeDir);
+        const destDir = path.join(config[to], config.relativeDir);
+        fileId('syncStart').info(
+            `开始同步: ${srcDir} -> ${destDir}`,
+        );
+
+        const result = await syncDirectory(srcDir, destDir, stats, signal);
+
+        if (result.isErr()) {
+            stats.errors++;
+            fileId('syncDirectoryFailed').error(`Failed to sync directory: ${result.error}`);
+        }
+
+        // 清理目标目录中多余的文件（源目录中已删除的文件）
+        if (signal.aborted) return ok(stats);
+        await cleanupExtraFiles(srcDir, destDir, stats);
+
+        return ok(stats);
+    });
+}
+
+/**
+ * 同步 staticMeta 目录：支持在两个项目之间双向同步
+ */
+export const tz = (tzCtx: { selection: ['fedoc' | 'tcsdd'] }) => {
+    const from = tzCtx.selection[0];
+    if (from !== 'fedoc' && from !== 'tcsdd') return;
+    return Eff.root(async ({ signal }) => {
+        if (signal.aborted) return err(new Error('操作已取消'));
+
+        const config = defaultConfig;
+
+        const result = await sync(config, from);
+
+        if (result.isErr()) {
+            return err(result.error);
+        }
+
+        const stats = result.value;
+        fileId('syncComplete').info('同步完成:');
+        fileId('syncStatsCopied').info(`  - 已复制: ${stats.copied} 个文件`);
+        fileId('syncStatsSkipped').info(`  - 已跳过: ${stats.skipped} 个文件`);
+        fileId('syncStatsDeleted').info(`  - 已删除: ${stats.deleted} 个文件`);
+        fileId('syncStatsErrors').info(`  - 错误: ${stats.errors} 个`);
+
+        return ok(stats);
+    });
+};

package/staticMeta/url.ts

@@ -0,0 +1,110 @@
+/**
+ * URL 查询参数操作工具：构造、改写、合并查询参数
+ */
+
+/**
+ * 基于 base 和相对路径构造完整 URL，支持查询参数和 hash
+ */
+export const buildUrl = (
+    base: string,
+    path: string,
+    params: Record<string, any> = {},
+    hash?: string,
+) => {
+    const url = new URL(path, base); // path 可为相对/绝对
+    const sp = url.searchParams;
+
+    // 删除/增查参数 (会自动编码)
+    for (const [k, v] of Object.entries(params)) {
+        if (v === undefined || v === null) {
+            sp.delete(k);
+        } else if (Array.isArray(v)) {
+            sp.delete(k);
+            v.forEach((item: any) => sp.append(k, String(item)));
+        } else {
+            sp.set(k, String(v));
+        }
+    }
+
+    if (hash !== undefined) url.hash = hash; // 哈希 "#top" (可能不带)
+    return url.toString();
+}
+
+/**
+ * 改写现有 URL 的查询参数和 hash（支持设置、追加、删除参数）
+ */
+export const rewriteUrl = (
+    input: string,
+    {
+        set = {},
+        append = {},
+        del = [],
+        hash,
+    }: {
+        set?: Record<string, any>;
+        append?: Record<string, any>;
+        del?: string[];
+        hash?: string;
+    } = {},
+) => {
+    const url = new URL(input);
+    const sp = url.searchParams;
+
+    // 设置参数
+    for (const [k, v] of Object.entries(set)) {
+        if (v === undefined || v === null) sp.delete(k);
+        else sp.set(k, String(v));
+    }
+
+    // 追加参数
+    for (const [k, v] of Object.entries(append)) {
+        if (Array.isArray(v)) v.forEach((item: any) => sp.append(k, String(item)));
+        else sp.append(k, String(v));
+    }
+
+    // del: 删除参数
+    del.forEach((k) => sp.delete(k));
+
+    if (hash !== undefined) url.hash = hash;
+    return url.toString();
+}
+
+/**
+ * 合并查询参数字符串和参数对象
+ */
+export const mergeQueryString = (search: string, path: Record<string, any> = {}) => {
+    const sp = new URLSearchParams(search); // 符合 "?a=1" 或 "a=1"
+    for (const [k, v] of Object.entries(path)) {
+        if (v === undefined || v === null) sp.delete(k);
+        else sp.set(k, String(v));
+    }
+
+    const qs = sp.toString();
+    return qs ? `?${qs}` : '';
+}
+
+// export const tz = async () => {
+//     const cons = console;
+//     // 示例
+//     cons.log(
+//         buildUrl(
+//             'https://example.com/app/',
+//             './user/profile',
+//             { a: '中文 空格', page: 2, tag: ['a', 'b'], empty: null },
+//             'section-1',
+//         ),
+//     );
+//     // => https://example.com/app/user/profile?q=%E4%B8%AD%E6%96%87+%E7%A9%BA%E6%A0%BC%E6%A0%BCs%263%3D4
+//     // 示例：直接 token 匹配、追加 tag, 删除 debug
+//     cons.log(
+//         rewriteUrl('https://a.com/?token=old&debug=1#x', {
+//             set: { token: 'new' },
+//             append: { tag: ['x', 'y'] },
+//             del: ['debug'],
+//         }),
+//     );
+//     // => https://a.com/?token=new&tag=x&tag=y#x
+//     // 示例：合并查询参数
+//     cons.log(mergeQueryString('?a=1&b=2', { b: 'x', c: 3, a: null }));
+//     // => ?b=x&c=3
+// };

package/tinypool.ts

@@ -0,0 +1,27 @@
+export {
+  Tinypool,
+  isTransferable,
+  isMovable,
+  markMovable,
+  isTaskQueue,
+  kTransferable,
+  kValue,
+  kQueueOptions,
+  kRequestCountField,
+  kResponseCountField,
+  kFieldCount,
+} from "tinypool"
+export type {
+  Options,
+  Task,
+  TaskQueue,
+  Transferable,
+  TinypoolChannel,
+  TinypoolWorker,
+  TinypoolData,
+  TinypoolPrivateData,
+  TinypoolWorkerMessage,
+  StartupMessage,
+  RequestMessage,
+  ResponseMessage,
+} from "tinypool"