@lppx/nlearn 1.1.8 → 1.1.9

package/dist/src/demo/promise-async/04-/345/256/236/346/210/230/346/241/210/344/276/213.js

@@ -0,0 +1,349 @@
+"use strict";
+/**
+ * Promise 与 async/await 实战案例
+ * ===============================
+ * 本文件展示 Promise 在实际项目中的应用场景
+ * 适用于 Node.js >= 14.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchProcessing = batchProcessing;
+exports.requestDeduplication = requestDeduplication;
+exports.cascadeDataLoading = cascadeDataLoading;
+exports.timeoutAndCancellation = timeoutAndCancellation;
+exports.errorRecovery = errorRecovery;
+exports.dataPreloading = dataPreloading;
+// #region 示例1: 批量数据处理
+/**
+ * 批量处理数据，支持进度回调
+ */
+async function batchProcessing() {
+    console.log('=== 批量数据处理 ===\n');
+    async function processBatch(items, processor, options) {
+        const { batchSize, onProgress } = options;
+        const results = [];
+        for (let i = 0; i < items.length; i += batchSize) {
+            const batch = items.slice(i, i + batchSize);
+            const batchResults = await Promise.all(batch.map(processor));
+            results.push(...batchResults);
+            if (onProgress) {
+                onProgress(Math.min(i + batchSize, items.length), items.length);
+            }
+        }
+        return results;
+    }
+    // 模拟处理单个项目
+    async function processItem(id) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        return `处理完成: ${id}`;
+    }
+    const items = Array.from({ length: 20 }, (_, i) => i + 1);
+    console.log('开始批量处理 20 个项目（每批 5 个）\n');
+    const results = await processBatch(items, processItem, {
+        batchSize: 5,
+        onProgress: (current, total) => {
+            const percentage = ((current / total) * 100).toFixed(0);
+            console.log(`进度: ${current}/${total} (${percentage}%)`);
+        },
+    });
+    console.log(`\n完成！共处理 ${results.length} 个项目`);
+}
+// #endregion
+// #region 示例2: API 请求去重
+/**
+ * 防止重复的 API 请求
+ */
+async function requestDeduplication() {
+    console.log('\n=== API 请求去重 ===\n');
+    class ApiClient {
+        constructor() {
+            this.pendingRequests = new Map();
+        }
+        async fetch(url) {
+            // 如果已有相同请求正在进行，直接返回该 Promise
+            if (this.pendingRequests.has(url)) {
+                console.log(`复用请求: ${url}`);
+                return this.pendingRequests.get(url);
+            }
+            console.log(`发起新请求: ${url}`);
+            const promise = this.performRequest(url);
+            this.pendingRequests.set(url, promise);
+            // 请求完成后清理
+            promise.finally(() => {
+                this.pendingRequests.delete(url);
+            });
+            return promise;
+        }
+        async performRequest(url) {
+            // 模拟网络请求
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            return { url, data: '响应数据' };
+        }
+    }
+    const client = new ApiClient();
+    console.log('同时发起 5 个相同的请求...\n');
+    const results = await Promise.all([
+        client.fetch('/api/user/1'),
+        client.fetch('/api/user/1'),
+        client.fetch('/api/user/1'),
+        client.fetch('/api/user/1'),
+        client.fetch('/api/user/1'),
+    ]);
+    console.log('\n所有请求完成');
+    console.log('注意：虽然发起了 5 次请求，但实际只执行了 1 次网络请求');
+}
+// #endregion
+// #region 示例3: 级联数据加载
+/**
+ * 加载有依赖关系的数据
+ */
+async function cascadeDataLoading() {
+    console.log('\n=== 级联数据加载 ===\n');
+    // 模拟 API
+    async function fetchUser(userId) {
+        console.log(`获取用户 ${userId} 信息...`);
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        return { id: userId, name: `用户${userId}`, departmentId: userId * 10 };
+    }
+    async function fetchDepartment(deptId) {
+        console.log(`获取部门 ${deptId} 信息...`);
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        return { id: deptId, name: `部门${deptId}`, companyId: Math.floor(deptId / 10) };
+    }
+    async function fetchCompany(companyId) {
+        console.log(`获取公司 ${companyId} 信息...`);
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        return { id: companyId, name: `公司${companyId}` };
+    }
+    // 方式 1: 串行加载（慢）
+    console.log('方式 1: 串行加载\n');
+    const startTime1 = Date.now();
+    const user = await fetchUser(1);
+    const department = await fetchDepartment(user.departmentId);
+    const company = await fetchCompany(department.companyId);
+    console.log(`\n串行加载耗时: ${Date.now() - startTime1}ms`);
+    console.log('结果:', { user, department, company });
+    // 方式 2: 优化加载（快）
+    console.log('\n\n方式 2: 优化加载（并行加载多个用户）\n');
+    const startTime2 = Date.now();
+    const users = await Promise.all([fetchUser(1), fetchUser(2), fetchUser(3)]);
+    const deptIds = [...new Set(users.map((u) => u.departmentId))];
+    const departments = await Promise.all(deptIds.map(fetchDepartment));
+    const companyIds = [...new Set(departments.map((d) => d.companyId))];
+    const companies = await Promise.all(companyIds.map(fetchCompany));
+    console.log(`\n优化加载耗时: ${Date.now() - startTime2}ms`);
+    console.log(`加载了 ${users.length} 个用户, ${departments.length} 个部门, ${companies.length} 个公司`);
+}
+// #endregion
+// #region 示例4: 超时和取消
+/**
+ * 实现请求超时和取消功能
+ */
+async function timeoutAndCancellation() {
+    console.log('\n=== 超时和取消 ===\n');
+    class AbortablePromise {
+        constructor(executor) {
+            this.executor = executor;
+            this.aborted = false;
+        }
+        async run() {
+            return new Promise((resolve, reject) => {
+                this.executor(resolve, reject, { aborted: this.aborted });
+            });
+        }
+        abort() {
+            this.aborted = true;
+        }
+    }
+    // 示例：可取消的长时间操作
+    const operation = new AbortablePromise((resolve, reject, signal) => {
+        let count = 0;
+        const interval = setInterval(() => {
+            if (signal.aborted) {
+                clearInterval(interval);
+                reject(new Error('操作已取消'));
+                return;
+            }
+            count++;
+            console.log(`执行中... ${count}s`);
+            if (count >= 5) {
+                clearInterval(interval);
+                resolve('操作完成');
+            }
+        }, 1000);
+    });
+    // 2 秒后取消操作
+    setTimeout(() => {
+        console.log('\n取消操作！\n');
+        operation.abort();
+    }, 2500);
+    try {
+        const result = await operation.run();
+        console.log(result);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.log('错误:', error.message);
+        }
+    }
+}
+// #endregion
+// #region 示例5: 错误恢复策略
+/**
+ * 实现多种错误恢复策略
+ */
+async function errorRecovery() {
+    console.log('\n=== 错误恢复策略 ===\n');
+    let attemptCount = 0;
+    async function unreliableApi() {
+        attemptCount++;
+        if (attemptCount <= 2) {
+            throw new Error('API 暂时不可用');
+        }
+        return 'API 响应';
+    }
+    // 策略 1: 重试
+    async function withRetry(fn, retries) {
+        for (let i = 0; i < retries; i++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                if (i === retries - 1)
+                    throw error;
+                console.log(`重试 ${i + 1}/${retries - 1}`);
+            }
+        }
+        throw new Error('不应该到达这里');
+    }
+    // 策略 2: 降级
+    async function withFallback(fn, fallback) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            console.log('使用降级方案');
+            return fallback;
+        }
+    }
+    // 策略 3: 断路器
+    class CircuitBreaker {
+        constructor() {
+            this.failures = 0;
+            this.threshold = 3;
+            this.state = 'closed';
+        }
+        async execute(fn) {
+            if (this.state === 'open') {
+                throw new Error('断路器已打开');
+            }
+            try {
+                const result = await fn();
+                this.failures = 0;
+                return result;
+            }
+            catch (error) {
+                this.failures++;
+                if (this.failures >= this.threshold) {
+                    this.state = 'open';
+                    console.log('断路器打开！');
+                }
+                throw error;
+            }
+        }
+    }
+    console.log('测试重试策略:\n');
+    attemptCount = 0;
+    const result1 = await withRetry(unreliableApi, 3);
+    console.log('结果:', result1);
+    console.log('\n测试降级策略:\n');
+    const result2 = await withFallback(async () => {
+        throw new Error('失败');
+    }, '默认值');
+    console.log('结果:', result2);
+}
+// #endregion
+// #region 示例6: 数据预加载
+/**
+ * 实现数据预加载和懒加载
+ */
+async function dataPreloading() {
+    console.log('\n=== 数据预加载 ===\n');
+    class DataLoader {
+        constructor() {
+            this.cache = new Map();
+            this.loading = new Map();
+        }
+        async load(key, fetcher) {
+            // 从缓存返回
+            if (this.cache.has(key)) {
+                console.log(`从缓存加载: ${key}`);
+                return this.cache.get(key);
+            }
+            // 等待正在加载的请求
+            if (this.loading.has(key)) {
+                console.log(`等待加载中: ${key}`);
+                return this.loading.get(key);
+            }
+            // 开始新的加载
+            console.log(`开始加载: ${key}`);
+            const promise = fetcher();
+            this.loading.set(key, promise);
+            try {
+                const data = await promise;
+                this.cache.set(key, data);
+                return data;
+            }
+            finally {
+                this.loading.delete(key);
+            }
+        }
+        preload(key, fetcher) {
+            if (!this.cache.has(key) && !this.loading.has(key)) {
+                console.log(`预加载: ${key}`);
+                this.load(key, fetcher).catch(console.error);
+            }
+        }
+    }
+    const loader = new DataLoader();
+    // 预加载数据
+    loader.preload('data1', async () => {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        return '数据 1';
+    });
+    console.log('预加载已启动，继续其他工作...\n');
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    console.log('现在需要使用数据:\n');
+    const data = await loader.load('data1', async () => {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        return '数据 1';
+    });
+    console.log('获取到:', data);
+}
+// #endregion
+// 主函数：根据参数运行指定示例
+if (require.main === module) {
+    const exampleNumber = process.argv[2];
+    const examples = {
+        '1': batchProcessing,
+        '2': requestDeduplication,
+        '3': cascadeDataLoading,
+        '4': timeoutAndCancellation,
+        '5': errorRecovery,
+        '6': dataPreloading,
+    };
+    if (exampleNumber && examples[exampleNumber]) {
+        console.log(`\n运行示例 ${exampleNumber}:\n`);
+        examples[exampleNumber]().catch(console.error);
+    }
+    else {
+        console.log('请指定要运行的示例编号 (1-6)');
+        console.log('例如: ts-node src/demo/promise-async/04-实战案例.ts 1');
+        console.log('\n可用示例:');
+        console.log('1 - 批量数据处理');
+        console.log('2 - API 请求去重');
+        console.log('3 - 级联数据加载');
+        console.log('4 - 超时和取消');
+        console.log('5 - 错误恢复策略');
+        console.log('6 - 数据预加载');
+    }
+}

package/dist/src/demo/prompts/01-/345/237/272/347/241/200/346/246/202/345/277/265.js

@@ -10,6 +10,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.singlePrompt = singlePrompt;
+exports.promptChain = promptChain;
+exports.handleCancel = handleCancel;
+exports.onSubmitCallback = onSubmitCallback;
+exports.initialValues = initialValues;
 const prompts_1 = __importDefault(require("prompts"));
 // #region 示例1: 单个提示
 async function singlePrompt() {

package/dist/src/demo/prompts/02-/346/217/220/347/244/272/347/261/273/345/236/213.js

@@ -9,6 +9,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.textTypes = textTypes;
+exports.numberType = numberType;
+exports.confirmType = confirmType;
+exports.toggleType = toggleType;
+exports.selectType = selectType;
+exports.multiselectType = multiselectType;
+exports.listType = listType;
 const prompts_1 = __importDefault(require("prompts"));
 // #region 示例1: 文本类型 (text, password, invisible)
 async function textTypes() {

package/dist/src/demo/prompts/03-/351/253/230/347/272/247/347/211/271/346/200/247.js

@@ -8,6 +8,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validation = validation;
+exports.formatting = formatting;
+exports.dynamicPrompts = dynamicPrompts;
+exports.autocomplete = autocomplete;
+exports.usePreviousAnswers = usePreviousAnswers;
+exports.injectAnswers = injectAnswers;
 const prompts_1 = __importDefault(require("prompts"));
 // #region 示例1: 输入验证
 async function validation() {

package/dist/src/demo/prompts/04-/345/256/236/346/210/230/346/241/210/344/276/213.js

@@ -8,6 +8,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectInitializer = projectInitializer;
+exports.userRegistration = userRegistration;
+exports.configGenerator = configGenerator;
+exports.survey = survey;
 const prompts_1 = __importDefault(require("prompts"));
 // #region 示例1: 项目初始化工具
 async function projectInitializer() {

package/dist/src/demo/prompts/05-/346/250/241/347/263/212/350/241/245/345/205/250.js

@@ -9,6 +9,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicFuzzySearch = basicFuzzySearch;
+exports.multiFieldSearch = multiFieldSearch;
+exports.pinyinSearch = pinyinSearch;
+exports.advancedConfiguration = advancedConfiguration;
+exports.dynamicDataSource = dynamicDataSource;
+exports.multiSelectFuzzySearch = multiSelectFuzzySearch;
 const prompts_1 = __importDefault(require("prompts"));
 const fuse_js_1 = __importDefault(require("fuse.js"));
 // #region 示例1: 基础模糊搜索

package/dist/src/demo/yargs/01-/345/237/272/347/241/200/346/246/202/345/277/265.js

@@ -9,6 +9,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.demoSimpleArgumentParsing = demoSimpleArgumentParsing;
+exports.demoOptionTypes = demoOptionTypes;
+exports.demoBooleanOptions = demoBooleanOptions;
+exports.demoArrayOptions = demoArrayOptions;
+exports.demoHelpInfo = demoHelpInfo;
 const yargs_1 = __importDefault(require("yargs"));
 const helpers_1 = require("yargs/helpers");
 // #region 示例1: 最简单的参数解析

package/dist/src/demo/yargs/02-/345/221/275/344/273/244/347/263/273/347/273/237.js

@@ -9,6 +9,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.demoBasicCommand = demoBasicCommand;
+exports.demoMultipleCommands = demoMultipleCommands;
+exports.demoPositionalArguments = demoPositionalArguments;
+exports.demoOptionalPositionalArgs = demoOptionalPositionalArgs;
+exports.demoSubcommands = demoSubcommands;
+exports.demoCommandAliases = demoCommandAliases;
 const yargs_1 = __importDefault(require("yargs"));
 const helpers_1 = require("yargs/helpers");
 // #region 示例1: 基础命令定义

package/dist/src/demo/yargs/03-/351/253/230/347/272/247/347/211/271/346/200/247.js

@@ -9,6 +9,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.demoArgumentValidation = demoArgumentValidation;
+exports.demoArgumentConflicts = demoArgumentConflicts;
+exports.demoArgumentDependencies = demoArgumentDependencies;
+exports.demoMiddleware = demoMiddleware;
+exports.demoOptionGrouping = demoOptionGrouping;
+exports.demoEnvironmentVariables = demoEnvironmentVariables;
 const yargs_1 = __importDefault(require("yargs"));
 const helpers_1 = require("yargs/helpers");
 // #region 示例1: 参数验证

package/dist/src/demo/yargs/04-/345/256/236/346/210/230/346/241/210/344/276/213.js

@@ -9,6 +9,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.demoFileManagerTool = demoFileManagerTool;
+exports.demoDatabaseMigrationTool = demoDatabaseMigrationTool;
+exports.demoProjectScaffolder = demoProjectScaffolder;
+exports.demoDeploymentTool = demoDeploymentTool;
+exports.demoCompleteTaskManager = demoCompleteTaskManager;
 const yargs_1 = __importDefault(require("yargs"));
 const helpers_1 = require("yargs/helpers");
 // #region 示例1: 文件管理工具

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.8",
+  "version": "1.1.9",
   "description": "一个nodejs学习工具",
   "bin": {
     "nlearn": "dist/src/cli/index.js",