cc-translate 0.4.0

package/index.d.ts

@@ -0,0 +1,48 @@
+import { OpenAI } from "openai";
+import { ICwalletTranslateParams, IJson, IOpenaiConfig, IOutputLanguageFile, ISingleTranslate, ITranslateChat, ITranslateChatResponse, SupportLanguageType } from "./types";
+export declare class CwalletTranslate {
+    private OPENAI_KEY;
+    CACHE_ROOT_PATH: string;
+    ENTRY_ROOT_PATH: string;
+    SOURCE_LANGUAGE: SupportLanguageType;
+    OUTPUT_ROOT_PATH: string | undefined;
+    languages: SupportLanguageType[];
+    client: OpenAI | null;
+    openaiConfig: IOpenaiConfig;
+    fineTune: string[];
+    constructor(params: ICwalletTranslateParams);
+    get supportLanguages(): import("./types").ILanguage[];
+    get outputPath(): string;
+    searchLanguage(code: SupportLanguageType): import("./types").ILanguage | undefined;
+    createOpenAIClient: () => void;
+    /** 翻译入口文件的所有支持的语言文件夹和其中的文件 */
+    translate: () => Promise<void>;
+    /**
+     * 翻译单个文件
+     * @param params
+     * @returns
+     */
+    singleTranslate: (params: ISingleTranslate) => Promise<void>;
+    /**
+     * 使用open ai 进行翻译
+     * @param {string} key
+     * @param {string} value
+     * @param {OpenAI} client
+     * @param {string} language
+     * @returns
+     */
+    translateChat: (params: ITranslateChat) => Promise<ITranslateChatResponse>;
+    /**
+     * 对比缓存文件 获取需要翻译的内容
+     * @param language
+     * @param fileName
+     * @returns
+     */
+    getTranslateContent: (language: SupportLanguageType, fileName: string) => Promise<IJson | undefined>;
+    /**
+     * 输出语言文件
+     * @param {Object} jsonMap
+     */
+    outputLanguageFile: (params: IOutputLanguageFile) => Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EACL,uBAAuB,EACvB,KAAK,EACL,aAAa,EACb,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,EACd,sBAAsB,EACtB,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAsBjB,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,UAAU,CAAS;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,mBAAmB,CAAC;IACrC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,SAAS,EAAE,mBAAmB,EAAE,CAAC;IACjC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAQ;IAC7B,YAAY,EAAE,aAAa,CAAC;IAC5B,QAAQ,EAAE,MAAM,EAAE,CAAC;gBAEP,MAAM,EAAE,uBAAuB;IAc3C,IAAI,gBAAgB,kCAOnB;IAED,IAAI,UAAU,WAEb;IAED,cAAc,CAAC,IAAI,EAAE,mBAAmB;IAIxC,kBAAkB,aAOhB;IACF,8BAA8B;IAC9B,SAAS,sBAyDP;IACF;;;;OAIG;IACH,eAAe,WAAkB,gBAAgB,mBA4D/C;IAEF;;;;;;;OAOG;IACH,aAAa,WAAY,cAAc,KAAG,OAAO,CAAC,sBAAsB,CAAC,CA2DvE;IACF;;;;;OAKG;IACH,mBAAmB,aACP,mBAAmB,YACnB,MAAM,KACf,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CA8B3B;IAEF;;;OAGG;IACH,kBAAkB,WAAkB,mBAAmB,mBAsCrD;CACH"}

package/index.js

@@ -0,0 +1,274 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import path from "path";
+import fs from "fs";
+import colors from "ansi-colors";
+import { OpenAI } from "openai";
+import cliProgress from "cli-progress";
+import { chunkArray, getRandomNumber, notExistsToCreateFile, readFileOfDirSync, readJsonFileSync, } from "./lib/utils.js";
+import { getCacheFileSync, registerLanguageCacheFile, translateJSONDiffToJson, } from "./lib/cache/index.js";
+import { logErrorToFile } from "./lib/log/index.js";
+import { SUPPORT_LANGUAGE_MAP } from "./lib/support.js";
+const __dirname = process.cwd();
+const DEFAULT_OPENAI_CONFIG = {
+    model: "gpt-4o",
+};
+export class CwalletTranslate {
+    constructor(params) {
+        var _a, _b, _c;
+        this.client = null;
+        this.createOpenAIClient = () => {
+            /** 初始化openAi */
+            const client = new OpenAI({
+                apiKey: this.OPENAI_KEY,
+            });
+            this.client = client;
+        };
+        /** 翻译入口文件的所有支持的语言文件夹和其中的文件 */
+        this.translate = () => __awaiter(this, void 0, void 0, function* () {
+            console.log("🚀 开始翻译");
+            console.log(`🚀 使用的模型: ${this.openaiConfig.model} 🚀`);
+            console.log(`🚀 微调: ${this.fineTune} 🚀`);
+            const translateFolderPath = path.join(this.ENTRY_ROOT_PATH, this.SOURCE_LANGUAGE);
+            // 翻译源语言问价夹下的所有json文件
+            const translateFolders = yield readFileOfDirSync(translateFolderPath);
+            // 创建进度条
+            const multiBar = new cliProgress.MultiBar({
+                clearOnComplete: false,
+                hideCursor: true,
+                format: colors.cyan("{bar}") +
+                    "| {percentage}% || {filename} {value}/{total} ",
+            }, cliProgress.Presets.legacy);
+            let promises = [];
+            const arr = [];
+            for (const item of this.supportLanguages) {
+                // 源语言不翻译
+                if (item.code === this.SOURCE_LANGUAGE)
+                    continue;
+                for (const fileName of translateFolders) {
+                    const translateJson = yield this.getTranslateContent(item.code, fileName);
+                    if (!translateJson) {
+                        console.log(`${item.code}:${fileName} 没有需要翻译的内容`);
+                        continue;
+                    }
+                    arr.push(() => this.singleTranslate({
+                        language: item.code,
+                        fileName,
+                        multiBar,
+                        translateJson,
+                    }));
+                }
+            }
+            promises = chunkArray(arr, 8);
+            for (const chunk of promises) {
+                yield Promise.all(chunk.map((fn) => fn()));
+            }
+            multiBar.stop();
+            console.log("🚀 翻译完毕");
+        });
+        /**
+         * 翻译单个文件
+         * @param params
+         * @returns
+         */
+        this.singleTranslate = (params) => __awaiter(this, void 0, void 0, function* () {
+            const { 
+            /** 待翻译的语言 */
+            language, 
+            /** 待翻译的文件名 */
+            fileName, translateJson, multiBar, callback, } = params;
+            try {
+                /** 待翻译的文件路径 */
+                const translateFilePath = path.join(this.ENTRY_ROOT_PATH, language, fileName);
+                // 等待翻译的数组
+                const jsonMap = {};
+                // 生成chat循环代码
+                const promiseList = Object.entries(translateJson).map(([key, value], index) => () => this.translateChat({
+                    key,
+                    value,
+                    language,
+                    index,
+                    fileName,
+                }));
+                const progressBar = multiBar.create(promiseList.length, 0);
+                for (const fn of promiseList) {
+                    const result = yield fn();
+                    jsonMap[result.key] = result.value;
+                    progressBar.update(result.index + 1, {
+                        filename: `${language}:${fileName}`,
+                    });
+                }
+                this.outputLanguageFile({
+                    jsonMap,
+                    folderName: language,
+                    fileName,
+                    translateFilePath,
+                });
+                callback && callback();
+            }
+            catch (error) {
+                logErrorToFile({
+                    error: error,
+                    language,
+                    fileName,
+                    key: "",
+                });
+                return;
+            }
+        });
+        /**
+         * 使用open ai 进行翻译
+         * @param {string} key
+         * @param {string} value
+         * @param {OpenAI} client
+         * @param {string} language
+         * @returns
+         */
+        this.translateChat = (params) => {
+            return new Promise((resolve) => {
+                const { key, value, language, index, fileName } = params;
+                try {
+                    if (!this.client)
+                        throw new Error("Connection failed");
+                    const targetLanguage = this.searchLanguage(language);
+                    const originLanguage = this.searchLanguage(this.SOURCE_LANGUAGE);
+                    if (!targetLanguage) {
+                        throw new Error(`不支持的语言：${language}`);
+                    }
+                    if (!originLanguage) {
+                        throw new Error(`不支持的语言：${this.SOURCE_LANGUAGE}`);
+                    }
+                    setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                        var _a, _b, _c;
+                        const chatCompletion = yield this.client.chat.completions.create({
+                            model: (_a = this.openaiConfig) === null || _a === void 0 ? void 0 : _a.model,
+                            messages: [
+                                ...this.fineTune.map((val) => ({
+                                    role: "system",
+                                    content: val,
+                                })),
+                                {
+                                    role: "system",
+                                    content: `请将${originLanguage.name}翻译成${targetLanguage.name}`,
+                                },
+                                {
+                                    role: "system",
+                                    content: `翻译完成直接输出后对应意思的内容不要携带任何无关内容`,
+                                },
+                                {
+                                    role: "user",
+                                    content: value,
+                                },
+                            ],
+                        });
+                        resolve({
+                            key,
+                            value: (_c = (_b = chatCompletion === null || chatCompletion === void 0 ? void 0 : chatCompletion.choices[0]) === null || _b === void 0 ? void 0 : _b.message.content) !== null && _c !== void 0 ? _c : value,
+                            index,
+                        });
+                    }), getRandomNumber(200, 300));
+                }
+                catch (error) {
+                    logErrorToFile({ error: error, key, fileName, language });
+                    resolve({
+                        key,
+                        value,
+                        index,
+                        error: error,
+                    });
+                }
+            });
+        };
+        /**
+         * 对比缓存文件 获取需要翻译的内容
+         * @param language
+         * @param fileName
+         * @returns
+         */
+        this.getTranslateContent = (language, fileName) => __awaiter(this, void 0, void 0, function* () {
+            const translateFilePath = path.join(this.ENTRY_ROOT_PATH, this.SOURCE_LANGUAGE, fileName);
+            /** 缓存文件路径 */
+            const cacheFilePath = path.join(this.CACHE_ROOT_PATH, language, fileName);
+            if (!fs.existsSync(translateFilePath)) {
+                console.dir(`File not found: ${translateFilePath}`);
+                return;
+            }
+            const translateFileObject = yield readJsonFileSync(translateFilePath);
+            const cacheObject = yield getCacheFileSync(cacheFilePath);
+            const diffObject = translateJSONDiffToJson(cacheObject, translateFileObject);
+            if (Object.values(diffObject).length === 0) {
+                if (Object.keys(translateFileObject).length === 0) {
+                    this.outputLanguageFile({
+                        jsonMap: {},
+                        folderName: language,
+                        fileName,
+                        translateFilePath,
+                    });
+                }
+                return;
+            }
+            return diffObject;
+        });
+        /**
+         * 输出语言文件
+         * @param {Object} jsonMap
+         */
+        this.outputLanguageFile = (params) => __awaiter(this, void 0, void 0, function* () {
+            const { folderName, fileName, jsonMap, translateFilePath } = params;
+            const outputFilePath = path.join(this.outputPath, folderName, fileName);
+            //创建输出文件夹
+            notExistsToCreateFile(this.outputPath);
+            //创建输出的语言文件夹
+            notExistsToCreateFile(`${this.outputPath}/${folderName}`);
+            let oldJsonData = "";
+            // 检查是否存在文件
+            if (!fs.existsSync(outputFilePath)) {
+                oldJsonData = yield fs.readFileSync(path.join(this.ENTRY_ROOT_PATH, this.SOURCE_LANGUAGE, fileName), "utf8");
+            }
+            else {
+                oldJsonData = yield fs.readFileSync(outputFilePath, "utf8");
+            }
+            const oldJsonMap = JSON.parse(oldJsonData);
+            const newJsonMap = Object.assign(oldJsonMap, jsonMap);
+            yield fs.writeFileSync(path.resolve(outputFilePath), JSON.stringify(newJsonMap, null, 2), "utf8");
+            // 注册缓存
+            registerLanguageCacheFile({
+                sourceFilePath: path.join(this.ENTRY_ROOT_PATH, this.SOURCE_LANGUAGE, fileName),
+                jsonMap: newJsonMap,
+                fileName,
+                language: folderName,
+                folderName: this.CACHE_ROOT_PATH,
+            });
+        });
+        this.OPENAI_KEY = params.key;
+        this.CACHE_ROOT_PATH = path.resolve(__dirname, params.cacheFileRootPath);
+        this.ENTRY_ROOT_PATH = path.resolve(__dirname, params.fileRootPath);
+        this.openaiConfig = (_a = params.openaiConfig) !== null && _a !== void 0 ? _a : DEFAULT_OPENAI_CONFIG;
+        this.SOURCE_LANGUAGE = (_b = params.sourceLanguage) !== null && _b !== void 0 ? _b : "en";
+        this.OUTPUT_ROOT_PATH = params.outputRootPath
+            ? path.resolve(__dirname, params.outputRootPath)
+            : undefined;
+        this.fineTune = params.fineTune;
+        this.languages = (_c = params.languages) !== null && _c !== void 0 ? _c : [];
+        this.createOpenAIClient();
+    }
+    get supportLanguages() {
+        return Object.entries(SUPPORT_LANGUAGE_MAP)
+            .map(([key, val]) => val)
+            .filter(({ code }) => this.languages.includes(code) || code === this.SOURCE_LANGUAGE);
+    }
+    get outputPath() {
+        var _a;
+        return (_a = this.OUTPUT_ROOT_PATH) !== null && _a !== void 0 ? _a : this.ENTRY_ROOT_PATH;
+    }
+    searchLanguage(code) {
+        return this.supportLanguages.find((item) => item.code === code);
+    }
+}

package/lib/cache/index.d.ts

@@ -0,0 +1,20 @@
+import { IJson, IRegisterLanguageCacheFile } from "../../types";
+/**
+ * 和翻译缓存json文件对比 返回存在更改的json文件
+ * @param {object} cacheObject 已经缓存的对象
+ * @param {object} translateObject 需要翻译的对象
+ * @returns {object} 存在修改的对象
+ */
+export declare const translateJSONDiffToJson: (cacheObject: IJson, translateObject: IJson) => IJson;
+/**
+ * 获取缓存文件
+ * @param {string} filePath 缓存文件路径
+ * @returns {Promise<{key:value}>}
+ */
+export declare const getCacheFileSync: (filePath: string) => Promise<IJson>;
+/**
+ * 注册语言缓存文件
+ * @param {string} language
+ */
+export declare const registerLanguageCacheFile: (params: IRegisterLanguageCacheFile) => Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/lib/cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/cache/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,gBACrB,KAAK,mBACD,KAAK,UAiBvB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,aAAoB,MAAM,KAAG,OAAO,CAAC,KAAK,CAMtE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,WAC5B,0BAA0B,kBAmBnC,CAAC"}

package/lib/cache/index.js

@@ -0,0 +1,66 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import path from "path";
+import fs from "fs";
+import { notExistsToCreateFile, readJsonFileSync } from "../utils.js";
+/**
+ * 和翻译缓存json文件对比 返回存在更改的json文件
+ * @param {object} cacheObject 已经缓存的对象
+ * @param {object} translateObject 需要翻译的对象
+ * @returns {object} 存在修改的对象
+ */
+export const translateJSONDiffToJson = (cacheObject, translateObject) => {
+    if (Object.values(cacheObject).length === 0)
+        return translateObject;
+    // json文件内容diff
+    const pendingTranslateMap = {};
+    Object.entries(translateObject).forEach(([key, value]) => {
+        //不存在该key 是新增的key
+        if (!cacheObject[key]) {
+            pendingTranslateMap[key] = value;
+        }
+        // 存在缓存key但是内容不一样 需要重新翻译
+        else if (translateObject[key] !== cacheObject[key]) {
+            pendingTranslateMap[key] = value;
+        }
+    });
+    return pendingTranslateMap;
+};
+/**
+ * 获取缓存文件
+ * @param {string} filePath 缓存文件路径
+ * @returns {Promise<{key:value}>}
+ */
+export const getCacheFileSync = (filePath) => __awaiter(void 0, void 0, void 0, function* () {
+    if (fs.existsSync(filePath)) {
+        return yield readJsonFileSync(filePath);
+    }
+    else {
+        return {};
+    }
+});
+/**
+ * 注册语言缓存文件
+ * @param {string} language
+ */
+export const registerLanguageCacheFile = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { jsonMap, sourceFilePath, fileName, language, folderName } = params;
+    const cacheFilePath = path.join(folderName, language, fileName);
+    const sourceObject = yield readJsonFileSync(sourceFilePath);
+    const cacheObject = yield readJsonFileSync(cacheFilePath);
+    Object.entries(jsonMap).forEach(([key, value]) => {
+        cacheObject[key] = sourceObject[key];
+    });
+    if (Object.values(jsonMap).length === 0)
+        return;
+    notExistsToCreateFile(folderName);
+    notExistsToCreateFile(`${folderName}/${language}`);
+    yield fs.writeFileSync(cacheFilePath, JSON.stringify(cacheObject, null, 2), "utf8");
+});

package/lib/log/index.d.ts

@@ -0,0 +1,3 @@
+import { ITranslateLogError } from "../../types";
+export declare function logErrorToFile(params: ITranslateLogError): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/log/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/log/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAGjD,wBAAgB,cAAc,CAAC,MAAM,EAAE,kBAAkB,QAexD"}

package/lib/log/index.js

@@ -0,0 +1,17 @@
+import fs from "fs";
+export function logErrorToFile(params) {
+    const { error, key, language, fileName } = params;
+    const logMessage = `${new Date().toISOString()} - Error: ${error.message}
+  \nLanguage: ${language}
+  \nFileName: ${fileName}
+  \nkey:${key}
+  \nStack: ${error.stack}\n\n`;
+    fs.appendFile("error.log", logMessage, (err) => {
+        if (err) {
+            console.error("无法写入日志文件:", err);
+        }
+        else {
+            console.log("错误日志已写入 error.log 文件");
+        }
+    });
+}

package/lib/support.d.ts

@@ -0,0 +1,3 @@
+import { SupportLanguageMap } from "../types";
+export declare const SUPPORT_LANGUAGE_MAP: SupportLanguageMap;
+//# sourceMappingURL=support.d.ts.map

package/lib/support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"support.d.ts","sourceRoot":"","sources":["../src/lib/support.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAE9C,eAAO,MAAM,oBAAoB,EAAE,kBAqGlC,CAAC"}

package/lib/support.js

@@ -0,0 +1,102 @@
+export const SUPPORT_LANGUAGE_MAP = {
+    en: {
+        code: "en",
+        name: "英语",
+    },
+    ["zh-CN"]: {
+        code: "zh-CN",
+        name: "简体中文",
+    },
+    ["zh-TW"]: {
+        code: "zh-TW",
+        name: "繁体中文",
+    },
+    ja: {
+        code: "ja",
+        name: "日语",
+    },
+    ar: {
+        code: "ar",
+        name: "阿拉伯语",
+    },
+    bn: {
+        code: "bn",
+        name: "孟加拉语",
+    },
+    de: {
+        code: "de",
+        name: "德语",
+    },
+    ["es-ES"]: {
+        code: "es-ES",
+        name: "西班牙语",
+    },
+    fr: {
+        code: "fr",
+        name: "法语",
+    },
+    hi: {
+        code: "hi",
+        name: "印地语",
+    },
+    id: {
+        code: "id",
+        name: "印度尼西亚语",
+    },
+    it: {
+        code: "it",
+        name: "意大利语",
+    },
+    ko: {
+        code: "ko",
+        name: "韩语",
+    },
+    ms: {
+        code: "ms",
+        name: "马来语",
+    },
+    my: {
+        code: "my",
+        name: "缅甸语",
+    },
+    ["ne-NP"]: {
+        code: "ne-NP",
+        name: "尼泊尔语",
+    },
+    nl: {
+        code: "nl",
+        name: "荷兰语",
+    },
+    pl: {
+        code: "pl",
+        name: "波兰语",
+    },
+    ["pt-PT"]: {
+        code: "pt-PT",
+        name: "葡萄牙语",
+    },
+    ru: {
+        code: "ru",
+        name: "俄罗斯语",
+    },
+    tl: {
+        code: "tl",
+        name: "菲律宾语",
+    },
+    tr: {
+        code: "tr",
+        name: "土耳其语",
+    },
+    vi: {
+        code: "vi",
+        name: "越南语",
+    },
+    uk: {
+        code: "uk",
+        name: "乌克兰语",
+    },
+    ["ur-PK"]: {
+        code: "ur-PK",
+        name: "乌尔都语",
+    },
+};

package/lib/utils.d.ts

@@ -0,0 +1,25 @@
+import { ICreateJsonFileParams } from "../types";
+/**
+ * 不存在的文件夹则创建
+ * @param {string} path
+ */
+export declare const notExistsToCreateFile: (path: string) => void;
+/**
+ * 获取json文件 并返回 [[key,value],[key,value]...]]
+ * @param {*} path
+ * @returns
+ */
+export declare const readJsonFileSync: (path: string) => Promise<any>;
+/**
+ * 创建json文件
+ * @param {string} fileName 文件名
+ * @param {string} folderName  文件夹名
+ * @param {string} language 语言环境
+ * @param {object} jsonData 文件数据
+ */
+export declare const createJsonFile: (params: ICreateJsonFileParams) => void;
+export declare const getRandomNumber: (min: number, max: number) => number;
+export declare const isDirectoryPath: (path: string) => boolean;
+export declare const readFileOfDirSync: (dirPath: string) => string[];
+export declare function chunkArray<T extends object>(array: T[], chunkSize: number): T[][];
+//# sourceMappingURL=utils.d.ts.map

package/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/lib/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,qBAAqB,SAAU,MAAM,SAGjD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,SAAgB,MAAM,iBAUlD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,WAAY,qBAAqB,SAS3D,CAAC;AAEF,eAAO,MAAM,eAAe,QAAS,MAAM,OAAO,MAAM,WAEvD,CAAC;AAEF,eAAO,MAAM,eAAe,SAAU,MAAM,YAG3C,CAAC;AAEF,eAAO,MAAM,iBAAiB,YAAa,MAAM,aAKhD,CAAC;AAEF,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,SASzE"}

package/lib/utils.js

@@ -0,0 +1,75 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import path from "path";
+import fs from "fs";
+/**
+ * 不存在的文件夹则创建
+ * @param {string} path
+ */
+export const notExistsToCreateFile = (path) => {
+    if (fs.existsSync(path))
+        return;
+    fs.mkdirSync(path);
+};
+/**
+ * 获取json文件 并返回 [[key,value],[key,value]...]]
+ * @param {*} path
+ * @returns
+ */
+export const readJsonFileSync = (path) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        if (!fs.existsSync(path))
+            return {};
+        const jsonStr = yield fs.readFileSync(path, "utf8");
+        // 将JSON字符串解析为对象
+        return JSON.parse(jsonStr);
+    }
+    catch (error) {
+        console.error("解析JSON时出错:", error);
+        return {};
+    }
+});
+/**
+ * 创建json文件
+ * @param {string} fileName 文件名
+ * @param {string} folderName  文件夹名
+ * @param {string} language 语言环境
+ * @param {object} jsonData 文件数据
+ */
+export const createJsonFile = (params) => {
+    const { fileName, folderName, jsonData, language } = params;
+    notExistsToCreateFile(folderName);
+    notExistsToCreateFile(path.resolve(`${folderName}/${language}`));
+    fs.writeFileSync(path.resolve(`${folderName}/${language}/${fileName}`), JSON.stringify(jsonData, null, 2), "utf8");
+};
+export const getRandomNumber = (min, max) => {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+export const isDirectoryPath = (path) => {
+    if (!fs.existsSync(path))
+        return false;
+    return fs.statSync(path).isDirectory();
+};
+export const readFileOfDirSync = (dirPath) => {
+    if (!isDirectoryPath(dirPath))
+        return [];
+    const files = fs.readdirSync(dirPath);
+    // 筛选出所有文件夹
+    return files.filter((file) => path.extname(file) === ".json");
+};
+export function chunkArray(array, chunkSize) {
+    const result = [];
+    let index = 0;
+    while (index < array.length) {
+        result.push(array.slice(index, index + chunkSize));
+        index += chunkSize;
+    }
+    return result;
+}