@cloudcome/utils-core 1.1.1 → 1.2.0

package/dist/async.cjs

@@ -0,0 +1,219 @@
+"use strict";
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _tasks, _length, _AsyncQueue_instances, add_fn, addAndRun_fn, _startResolved, _startRejected, _startResults, _startPwr, _startLength, _running, run_fn, _stopResolved, _stopRejected, _stopLength, _stopResults, _stopPwr;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fn = require("./fn.cjs");
+class AsyncQueue {
+  /**
+   * 创建一个异步任务队列
+   * @param asyncFns - 要执行的异步函数数组
+   * @param options - 队列配置选项
+   */
+  constructor(asyncFns, options) {
+    __privateAdd(this, _AsyncQueue_instances);
+    __privateAdd(this, _tasks, []);
+    __privateAdd(this, _length, 0);
+    __privateAdd(this, _startResolved, 0);
+    __privateAdd(this, _startRejected, 0);
+    __privateAdd(this, _startResults, []);
+    __privateAdd(this, _startPwr, null);
+    __privateAdd(this, _startLength, 0);
+    __privateAdd(this, _running, 0);
+    __privateAdd(this, _stopResolved, 0);
+    __privateAdd(this, _stopRejected, 0);
+    __privateAdd(this, _stopLength, -1);
+    __privateAdd(this, _stopResults, []);
+    __privateAdd(this, _stopPwr, null);
+    this.options = options;
+    asyncFns.forEach((afn, idx) => {
+      __privateMethod(this, _AsyncQueue_instances, add_fn).call(this, "push", afn);
+    });
+  }
+  get length() {
+    return __privateGet(this, _length);
+  }
+  get limit() {
+    var _a;
+    return ((_a = this.options) == null ? void 0 : _a.limit) || 0;
+  }
+  async push(afn) {
+    return __privateMethod(this, _AsyncQueue_instances, addAndRun_fn).call(this, "push", afn);
+  }
+  async unshift(afn) {
+    return __privateMethod(this, _AsyncQueue_instances, addAndRun_fn).call(this, "unshift", afn);
+  }
+  get startSettled() {
+    return __privateGet(this, _startResolved) === __privateGet(this, _startLength) || __privateGet(this, _startRejected) > 0;
+  }
+  /**
+   * 启动队列中的任务执行
+   * @returns 返回一个 Promise，在所有启动任务完成后解析为结果数组
+   */
+  async start() {
+    if (__privateGet(this, _startPwr)) return __privateGet(this, _startPwr).promise;
+    __privateSet(this, _startLength, __privateGet(this, _length));
+    __privateSet(this, _startPwr, Promise.withResolvers());
+    if (__privateGet(this, _startLength) === 0) {
+      __privateGet(this, _startPwr).resolve([]);
+    } else {
+      __privateMethod(this, _AsyncQueue_instances, run_fn).call(this);
+    }
+    return __privateGet(this, _startPwr).promise;
+  }
+  get stopSettled() {
+    return __privateGet(this, _stopResolved) === __privateGet(this, _stopLength) || __privateGet(this, _stopRejected) > 0;
+  }
+  /**
+   * 终止队列中的任务执行，终止队列后不再可以追加异步任务
+   * @returns 返回一个 Promise，在所有启动任务完成后解析为结果数组
+   */
+  async stop() {
+    if (__privateGet(this, _stopPwr)) {
+      return __privateGet(this, _stopPwr).promise;
+    }
+    __privateSet(this, _stopLength, __privateGet(this, _length));
+    __privateSet(this, _stopPwr, Promise.withResolvers());
+    if (__privateGet(this, _stopLength) === 0) {
+      __privateGet(this, _stopPwr).resolve([]);
+    } else {
+      __privateMethod(this, _AsyncQueue_instances, run_fn).call(this);
+    }
+    return __privateGet(this, _stopPwr).promise;
+  }
+}
+_tasks = new WeakMap();
+_length = new WeakMap();
+_AsyncQueue_instances = new WeakSet();
+add_fn = function(method, afn, pwr) {
+  __privateGet(this, _tasks)[method]({
+    idx: __privateWrapper(this, _length)._++,
+    afn,
+    pwr
+  });
+};
+addAndRun_fn = function(method, afn) {
+  if (__privateGet(this, _stopLength) >= 0) {
+    throw new Error("异步队列已被终止，无法添加新的任务");
+  }
+  const pwr = Promise.withResolvers();
+  __privateMethod(this, _AsyncQueue_instances, add_fn).call(this, method, afn, pwr);
+  if (__privateGet(this, _startPwr) && __privateGet(this, _running) === 0) {
+    __privateMethod(this, _AsyncQueue_instances, run_fn).call(this);
+  }
+  return pwr.promise;
+};
+_startResolved = new WeakMap();
+_startRejected = new WeakMap();
+_startResults = new WeakMap();
+_startPwr = new WeakMap();
+_startLength = new WeakMap();
+_running = new WeakMap();
+run_fn = function() {
+  while (this.limit === 0 || __privateGet(this, _running) < this.limit) {
+    const task = __privateGet(this, _tasks).shift();
+    if (!task) break;
+    __privateWrapper(this, _running)._++;
+    task.afn().then((result) => {
+      var _a, _b, _c;
+      __privateWrapper(this, _running)._--;
+      (_a = task.pwr) == null ? void 0 : _a.resolve(result);
+      if (task.idx < __privateGet(this, _startLength)) {
+        __privateGet(this, _startResults)[task.idx] = result;
+        __privateWrapper(this, _startResolved)._++;
+      }
+      if (__privateGet(this, _startResolved) === __privateGet(this, _startLength)) {
+        (_b = __privateGet(this, _startPwr)) == null ? void 0 : _b.resolve(__privateGet(this, _startResults));
+      }
+      __privateGet(this, _stopResults)[task.idx] = result;
+      __privateWrapper(this, _stopResolved)._++;
+      if (__privateGet(this, _stopResolved) === __privateGet(this, _stopLength)) {
+        (_c = __privateGet(this, _stopPwr)) == null ? void 0 : _c.resolve(__privateGet(this, _stopResults));
+      } else {
+        __privateMethod(this, _AsyncQueue_instances, run_fn).call(this);
+      }
+    }).catch((reason) => {
+      var _a, _b, _c;
+      __privateWrapper(this, _running)._--;
+      (_a = task.pwr) == null ? void 0 : _a.reject(reason);
+      if (task.idx < __privateGet(this, _startLength)) {
+        __privateWrapper(this, _startRejected)._++;
+        (_b = __privateGet(this, _startPwr)) == null ? void 0 : _b.reject(reason);
+      }
+      if (__privateGet(this, _stopLength) > 0) {
+        __privateWrapper(this, _stopRejected)._++;
+        (_c = __privateGet(this, _stopPwr)) == null ? void 0 : _c.reject(reason);
+      }
+    });
+  }
+};
+_stopResolved = new WeakMap();
+_stopRejected = new WeakMap();
+_stopLength = new WeakMap();
+_stopResults = new WeakMap();
+_stopPwr = new WeakMap();
+function asyncLimit(asyncFns, limit) {
+  const aq = new AsyncQueue(asyncFns, { limit });
+  return aq.start();
+}
+function asyncShared(af, options) {
+  let executedPromise;
+  let executing = false;
+  let executingInputs;
+  let executedTime = 0;
+  const _sharedAf = async (from, ...inputs) => {
+    var _a;
+    executingInputs = inputs;
+    if (executing && executedPromise) {
+      return executedPromise;
+    }
+    if (executedPromise && Date.now() - executedTime < ((options == null ? void 0 : options.maxAge) || 0)) {
+      return executedPromise;
+    }
+    executing = true;
+    (_a = options == null ? void 0 : options.onExecute) == null ? void 0 : _a.call(options, ...executingInputs);
+    executedPromise = af(...executingInputs);
+    executingInputs = void 0;
+    executedPromise.then((res) => {
+      var _a2;
+      (_a2 = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a2.call(options, res);
+    }).catch((err) => {
+      var _a2;
+      (_a2 = options == null ? void 0 : options.onError) == null ? void 0 : _a2.call(options, err);
+    }).finally(() => {
+      var _a2;
+      executing = false;
+      executedTime = Date.now();
+      (_a2 = options == null ? void 0 : options.onFinally) == null ? void 0 : _a2.call(options);
+      if (executingInputs && (options == null ? void 0 : options.trailing)) {
+        _sharedAf("trailing", ...executingInputs);
+      }
+    });
+    return executedPromise;
+  };
+  return function sharedAf(...inputs) {
+    var _a;
+    (_a = options == null ? void 0 : options.onTrigger) == null ? void 0 : _a.call(options, ...inputs);
+    const p = _sharedAf("trigger", ...inputs);
+    p.catch(fn.fnNoop);
+    return p;
+  };
+}
+exports.AsyncQueue = AsyncQueue;
+exports.asyncLimit = asyncLimit;
+exports.asyncShared = asyncShared;
+//# sourceMappingURL=async.cjs.map

package/dist/async.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.cjs","sources":["../src/async.ts"],"sourcesContent":["import { fnNoop } from './fn';\nimport type { AnyArray, AnyAsyncFunction } from './types';\n\n/**\n * 表示异步任务的类型\n * @template T - 任务返回值的类型\n */\ntype AsyncTask<T> = {\n  /** 任务索引 */\n  idx: number;\n  /** 异步任务函数 */\n  afn: () => Promise<T>;\n  /** Promise 的解析器对象 */\n  pwr?: PromiseWithResolvers<T>;\n};\n\n/**\n * 异步任务队列的配置选项\n */\nexport type TAsyncQueueOptions = {\n  /**\n   * 并发限制数，0 表示无限制\n   * @default 0\n   */\n  limit?: number;\n};\n\n/**\n * 异步任务队列，用于管理和控制异步任务的执行\n * @template T - 任务返回值的类型\n */\nexport class AsyncQueue<T> {\n  #tasks: AsyncTask<T>[] = [];\n  #length = 0;\n\n  /**\n   * 创建一个异步任务队列\n   * @param asyncFns - 要执行的异步函数数组\n   * @param options - 队列配置选项\n   */\n  constructor(\n    asyncFns: Array<() => Promise<T>>,\n    readonly options?: TAsyncQueueOptions,\n  ) {\n    asyncFns.forEach((afn, idx) => {\n      this.#add('push', afn);\n    });\n  }\n\n  get length() {\n    return this.#length;\n  }\n\n  get limit() {\n    return this.options?.limit || 0;\n  }\n\n  #add(method: 'unshift' | 'push', afn: () => Promise<T>, pwr?: PromiseWithResolvers<T>) {\n    this.#tasks[method]({\n      idx: this.#length++,\n      afn: afn,\n      pwr: pwr,\n    });\n  }\n\n  #addAndRun(method: 'unshift' | 'push', afn: () => Promise<T>) {\n    // 明确终止了\n    if (this.#stopLength >= 0) {\n      throw new Error('异步队列已被终止，无法添加新的任务');\n    }\n\n    const pwr = Promise.withResolvers<T>();\n    this.#add(method, afn, pwr);\n\n    if (this.#startPwr && this.#running === 0) {\n      this.#run();\n    }\n\n    return pwr.promise;\n  }\n\n  async push(afn: () => Promise<T>) {\n    return this.#addAndRun('push', afn);\n  }\n\n  async unshift(afn: () => Promise<T>) {\n    return this.#addAndRun('unshift', afn);\n  }\n\n  #startResolved = 0;\n  #startRejected = 0;\n  get startSettled() {\n    return this.#startResolved === this.#startLength || this.#startRejected > 0;\n  }\n\n  #startResults: T[] = [];\n  #startPwr: PromiseWithResolvers<T[]> | null = null;\n  #startLength = 0;\n\n  /**\n   * 启动队列中的任务执行\n   * @returns 返回一个 Promise，在所有启动任务完成后解析为结果数组\n   */\n  async start(): Promise<T[]> {\n    if (this.#startPwr) return this.#startPwr.promise;\n\n    // 固化启动时长度，便于判断 start 异步结果\n    this.#startLength = this.#length;\n    this.#startPwr = Promise.withResolvers<T[]>();\n\n    if (this.#startLength === 0) {\n      this.#startPwr.resolve([]);\n    } else {\n      this.#run();\n    }\n\n    return this.#startPwr.promise;\n  }\n\n  #running = 0;\n  #run() {\n    while (this.limit === 0 || this.#running < this.limit) {\n      const task = this.#tasks.shift();\n\n      // 无任务可执行\n      if (!task) break;\n\n      this.#running++;\n\n      task\n        .afn()\n        .then((result) => {\n          this.#running--;\n          task.pwr?.resolve(result);\n\n          // 属于启动任务\n          if (task.idx < this.#startLength) {\n            this.#startResults[task.idx] = result;\n            this.#startResolved++;\n          }\n\n          // 所有启动任务都已执行完毕\n          if (this.#startResolved === this.#startLength) {\n            this.#startPwr?.resolve(this.#startResults);\n          }\n\n          this.#stopResults[task.idx] = result;\n          this.#stopResolved++;\n\n          // 所有停止任务都已执行完毕\n          if (this.#stopResolved === this.#stopLength) {\n            this.#stopPwr?.resolve(this.#stopResults);\n          } else {\n            this.#run();\n          }\n        })\n        .catch((reason) => {\n          this.#running--;\n          task.pwr?.reject(reason);\n\n          // 属于启动任务\n          if (task.idx < this.#startLength) {\n            this.#startRejected++;\n            this.#startPwr?.reject(reason);\n          }\n\n          // 属于停止任务\n          if (this.#stopLength > 0) {\n            this.#stopRejected++;\n            this.#stopPwr?.reject(reason);\n          }\n        });\n    }\n  }\n  #stopResolved = 0;\n  #stopRejected = 0;\n  get stopSettled() {\n    return this.#stopResolved === this.#stopLength || this.#stopRejected > 0;\n  }\n\n  #stopLength = -1;\n  #stopResults: T[] = [];\n\n  #stopPwr?: PromiseWithResolvers<T[]> | null = null;\n\n  /**\n   * 终止队列中的任务执行，终止队列后不再可以追加异步任务\n   * @returns 返回一个 Promise，在所有启动任务完成后解析为结果数组\n   */\n  async stop() {\n    if (this.#stopPwr) {\n      return this.#stopPwr.promise;\n    }\n\n    this.#stopLength = this.#length;\n    this.#stopPwr = Promise.withResolvers<T[]>();\n\n    if (this.#stopLength === 0) {\n      this.#stopPwr.resolve([]);\n    } else {\n      this.#run();\n    }\n\n    return this.#stopPwr.promise;\n  }\n}\n\n/**\n * 使用给定的并发限制执行异步函数\n *\n * 此函数的目的是控制一组异步函数的并发执行数量，通过创建一个AsyncQueue实例来管理这些异步函数的执行\n * 它确保在任何给定时间只有最多`limit`数量的异步函数被执行，以避免潜在的性能问题或资源竞争\n *\n * @param asyncFns 一个包含异步函数的数组，每个异步函数都不需要参数，并返回一个Promise\n * @param limit 并发限制的数量，表示同时执行的异步函数的最大数量，0 表示不限制\n * @returns 返回一个Promise，当所有异步函数都执行完毕后，该Promise将被解析\n */\nexport function asyncLimit<T>(asyncFns: Array<() => Promise<T>>, limit: number) {\n  const aq = new AsyncQueue<T>(asyncFns, { limit });\n  return aq.start();\n}\n\n/**\n * 异步共享函数的配置选项\n */\nexport type AsyncSharedOptions<I extends AnyArray, O> = {\n  /**\n   * 是否在调用结束后再执行（只在运行期间有再次调用时才会生效）\n   * @type {boolean}\n   * @default false\n   * @example\n   * const sharedFn = asyncShared(fetchData, { trailing: true });\n   * // 如果在 fetchData 执行期间多次调用 sharedFn，则会在 fetchData 结束后再次执行\n   */\n  trailing?: boolean;\n\n  /**\n   * 缓存结果的最大有效期（毫秒）\n   * @type {number}\n   * @example\n   * const sharedFn = asyncShared(fetchData, { maxAge: 1000 });\n   * // 在 1 秒内调用 sharedFn 会直接返回缓存结果\n   */\n  maxAge?: number;\n\n  /**\n   * 在调用共享函数时触发的回调函数\n   * @param inputs - 传递给共享函数的参数\n   * @example\n   * const options: AsyncSharedOptions<typeof fetchData> = {\n   *   onTrigger: (...args) => console.log('Calling with:', args)\n   * };\n   */\n  onTrigger?: (...inputs: I) => unknown;\n\n  /**\n   * 在执行异步函数时触发的回调函数\n   * @param args - 传递给异步函数的参数\n   * @example\n   * const options: AsyncSharedOptions<typeof fetchData> = {\n   *   onExecute: (...args) => console.log('Executing with:', args)\n   * };\n   */\n  onExecute?: (...args: I) => unknown;\n\n  /**\n   * 在异步函数成功执行后触发的回调函数\n   * @param output - 异步函数的返回结果\n   * @example\n   * const options: AsyncSharedOptions<typeof fetchData> = {\n   *   onSuccess: (result) => console.log('Success:', result)\n   * };\n   */\n  onSuccess?: (output: O) => unknown;\n\n  /**\n   * 在异步函数执行失败时触发的回调函数\n   * @param error - 异步函数抛出的错误\n   * @example\n   * const options: AsyncSharedOptions<typeof fetchData> = {\n   *   onError: (error) => console.error('Error:', error)\n   * };\n   */\n  onError?: (error: unknown) => unknown;\n\n  /**\n   * 在异步函数执行完成（无论成功或失败）时触发的回调函数\n   * @example\n   * const options: AsyncSharedOptions<typeof fetchData> = {\n   *   onFinally: () => console.log('Execution completed')\n   * };\n   */\n  onFinally?: () => unknown;\n};\n\n/**\n * 创建一个共享执行结果的异步函数\n * @template F - 异步函数类型\n * @param {F} af - 要共享的异步函数\n * @param {AsyncSharedOptions} [options] - 配置选项\n * @returns {F} 返回一个新的异步函数，该函数会共享执行结果\n * @example\n * const fetchData = async (id) => {\n *   // 模拟异步操作\n *   return await fetch(`/api/data/${id}`);\n * };\n *\n * const sharedFetch = asyncShared(fetchData, { maxAge: 1000 });\n *\n * // 多次调用会共享同一个请求\n * const result1 = await sharedFetch(1);\n * const result2 = await sharedFetch(1); // 上次请求完成后 1000ms 内直接返回缓存结果\n */\nexport function asyncShared<I extends AnyArray, O>(\n  af: (...inputs: I) => Promise<O>,\n  options?: AsyncSharedOptions<I, O>,\n) {\n  let executedPromise: Promise<O> | undefined;\n  let executing = false;\n  let executingInputs: I | undefined;\n  let executedTime = 0;\n\n  const _sharedAf = async (from: 'trigger' | 'trailing', ...inputs: I) => {\n    executingInputs = inputs;\n\n    // 如果正在运行，则复用运行结果\n    if (executing && executedPromise) {\n      return executedPromise;\n    }\n\n    // 如果已运行结束空闲时，判断是否在等待时间内\n    if (executedPromise && Date.now() - executedTime < (options?.maxAge || 0)) {\n      return executedPromise;\n    }\n\n    // 否则直接执行\n    executing = true;\n    options?.onExecute?.(...executingInputs);\n    executedPromise = af(...executingInputs);\n    executingInputs = undefined;\n    executedPromise\n      .then((res) => {\n        options?.onSuccess?.(res);\n      })\n      .catch((err) => {\n        options?.onError?.(err);\n      })\n      .finally(() => {\n        executing = false;\n        executedTime = Date.now();\n        options?.onFinally?.();\n\n        // 执行期间多次调用，则重新执行\n        if (executingInputs && options?.trailing) {\n          _sharedAf('trailing', ...executingInputs);\n        }\n      });\n\n    return executedPromise;\n  };\n\n  return function sharedAf(...inputs: I): Promise<O> {\n    options?.onTrigger?.(...inputs);\n    const p = _sharedAf('trigger', ...inputs);\n    // 必须捕获错误，否则单测错误边界时会抛错\n    p.catch(fnNoop);\n    return p;\n  };\n}\n\n// const af1 = asyncShared(async () => {\n//   return 1;\n// });\n// const n = await af1();\n\n// const af2 = asyncShared(async (a: number) => {\n//   return a + 1;\n// });\n// const n2 = await af2(2);\n"],"names":["_a","fnNoop"],"mappings":"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"}

package/dist/async.d.ts

@@ -0,0 +1,137 @@
+import { AnyArray } from './types';
+/**
+ * 异步任务队列的配置选项
+ */
+export type TAsyncQueueOptions = {
+    /**
+     * 并发限制数，0 表示无限制
+     * @default 0
+     */
+    limit?: number;
+};
+/**
+ * 异步任务队列，用于管理和控制异步任务的执行
+ * @template T - 任务返回值的类型
+ */
+export declare class AsyncQueue<T> {
+    #private;
+    readonly options?: TAsyncQueueOptions | undefined;
+    /**
+     * 创建一个异步任务队列
+     * @param asyncFns - 要执行的异步函数数组
+     * @param options - 队列配置选项
+     */
+    constructor(asyncFns: Array<() => Promise<T>>, options?: TAsyncQueueOptions | undefined);
+    get length(): number;
+    get limit(): number;
+    push(afn: () => Promise<T>): Promise<T>;
+    unshift(afn: () => Promise<T>): Promise<T>;
+    get startSettled(): boolean;
+    /**
+     * 启动队列中的任务执行
+     * @returns 返回一个 Promise，在所有启动任务完成后解析为结果数组
+     */
+    start(): Promise<T[]>;
+    get stopSettled(): boolean;
+    /**
+     * 终止队列中的任务执行，终止队列后不再可以追加异步任务
+     * @returns 返回一个 Promise，在所有启动任务完成后解析为结果数组
+     */
+    stop(): Promise<T[]>;
+}
+/**
+ * 使用给定的并发限制执行异步函数
+ *
+ * 此函数的目的是控制一组异步函数的并发执行数量，通过创建一个AsyncQueue实例来管理这些异步函数的执行
+ * 它确保在任何给定时间只有最多`limit`数量的异步函数被执行，以避免潜在的性能问题或资源竞争
+ *
+ * @param asyncFns 一个包含异步函数的数组，每个异步函数都不需要参数，并返回一个Promise
+ * @param limit 并发限制的数量，表示同时执行的异步函数的最大数量，0 表示不限制
+ * @returns 返回一个Promise，当所有异步函数都执行完毕后，该Promise将被解析
+ */
+export declare function asyncLimit<T>(asyncFns: Array<() => Promise<T>>, limit: number): Promise<T[]>;
+/**
+ * 异步共享函数的配置选项
+ */
+export type AsyncSharedOptions<I extends AnyArray, O> = {
+    /**
+     * 是否在调用结束后再执行（只在运行期间有再次调用时才会生效）
+     * @type {boolean}
+     * @default false
+     * @example
+     * const sharedFn = asyncShared(fetchData, { trailing: true });
+     * // 如果在 fetchData 执行期间多次调用 sharedFn，则会在 fetchData 结束后再次执行
+     */
+    trailing?: boolean;
+    /**
+     * 缓存结果的最大有效期（毫秒）
+     * @type {number}
+     * @example
+     * const sharedFn = asyncShared(fetchData, { maxAge: 1000 });
+     * // 在 1 秒内调用 sharedFn 会直接返回缓存结果
+     */
+    maxAge?: number;
+    /**
+     * 在调用共享函数时触发的回调函数
+     * @param inputs - 传递给共享函数的参数
+     * @example
+     * const options: AsyncSharedOptions<typeof fetchData> = {
+     *   onTrigger: (...args) => console.log('Calling with:', args)
+     * };
+     */
+    onTrigger?: (...inputs: I) => unknown;
+    /**
+     * 在执行异步函数时触发的回调函数
+     * @param args - 传递给异步函数的参数
+     * @example
+     * const options: AsyncSharedOptions<typeof fetchData> = {
+     *   onExecute: (...args) => console.log('Executing with:', args)
+     * };
+     */
+    onExecute?: (...args: I) => unknown;
+    /**
+     * 在异步函数成功执行后触发的回调函数
+     * @param output - 异步函数的返回结果
+     * @example
+     * const options: AsyncSharedOptions<typeof fetchData> = {
+     *   onSuccess: (result) => console.log('Success:', result)
+     * };
+     */
+    onSuccess?: (output: O) => unknown;
+    /**
+     * 在异步函数执行失败时触发的回调函数
+     * @param error - 异步函数抛出的错误
+     * @example
+     * const options: AsyncSharedOptions<typeof fetchData> = {
+     *   onError: (error) => console.error('Error:', error)
+     * };
+     */
+    onError?: (error: unknown) => unknown;
+    /**
+     * 在异步函数执行完成（无论成功或失败）时触发的回调函数
+     * @example
+     * const options: AsyncSharedOptions<typeof fetchData> = {
+     *   onFinally: () => console.log('Execution completed')
+     * };
+     */
+    onFinally?: () => unknown;
+};
+/**
+ * 创建一个共享执行结果的异步函数
+ * @template F - 异步函数类型
+ * @param {F} af - 要共享的异步函数
+ * @param {AsyncSharedOptions} [options] - 配置选项
+ * @returns {F} 返回一个新的异步函数，该函数会共享执行结果
+ * @example
+ * const fetchData = async (id) => {
+ *   // 模拟异步操作
+ *   return await fetch(`/api/data/${id}`);
+ * };
+ *
+ * const sharedFetch = asyncShared(fetchData, { maxAge: 1000 });
+ *
+ * // 多次调用会共享同一个请求
+ * const result1 = await sharedFetch(1);
+ * const result2 = await sharedFetch(1); // 上次请求完成后 1000ms 内直接返回缓存结果
+ */
+export declare function asyncShared<I extends AnyArray, O>(af: (...inputs: I) => Promise<O>, options?: AsyncSharedOptions<I, O>): (...inputs: I) => Promise<O>;

package/dist/async.mjs

@@ -0,0 +1,219 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _tasks, _length, _AsyncQueue_instances, add_fn, addAndRun_fn, _startResolved, _startRejected, _startResults, _startPwr, _startLength, _running, run_fn, _stopResolved, _stopRejected, _stopLength, _stopResults, _stopPwr;
+import { fnNoop } from "./fn.mjs";
+class AsyncQueue {
+  /**
+   * 创建一个异步任务队列
+   * @param asyncFns - 要执行的异步函数数组
+   * @param options - 队列配置选项
+   */
+  constructor(asyncFns, options) {
+    __privateAdd(this, _AsyncQueue_instances);
+    __privateAdd(this, _tasks, []);
+    __privateAdd(this, _length, 0);
+    __privateAdd(this, _startResolved, 0);
+    __privateAdd(this, _startRejected, 0);
+    __privateAdd(this, _startResults, []);
+    __privateAdd(this, _startPwr, null);
+    __privateAdd(this, _startLength, 0);
+    __privateAdd(this, _running, 0);
+    __privateAdd(this, _stopResolved, 0);
+    __privateAdd(this, _stopRejected, 0);
+    __privateAdd(this, _stopLength, -1);
+    __privateAdd(this, _stopResults, []);
+    __privateAdd(this, _stopPwr, null);
+    this.options = options;
+    asyncFns.forEach((afn, idx) => {
+      __privateMethod(this, _AsyncQueue_instances, add_fn).call(this, "push", afn);
+    });
+  }
+  get length() {
+    return __privateGet(this, _length);
+  }
+  get limit() {
+    var _a;
+    return ((_a = this.options) == null ? void 0 : _a.limit) || 0;
+  }
+  async push(afn) {
+    return __privateMethod(this, _AsyncQueue_instances, addAndRun_fn).call(this, "push", afn);
+  }
+  async unshift(afn) {
+    return __privateMethod(this, _AsyncQueue_instances, addAndRun_fn).call(this, "unshift", afn);
+  }
+  get startSettled() {
+    return __privateGet(this, _startResolved) === __privateGet(this, _startLength) || __privateGet(this, _startRejected) > 0;
+  }
+  /**
+   * 启动队列中的任务执行
+   * @returns 返回一个 Promise，在所有启动任务完成后解析为结果数组
+   */
+  async start() {
+    if (__privateGet(this, _startPwr)) return __privateGet(this, _startPwr).promise;
+    __privateSet(this, _startLength, __privateGet(this, _length));
+    __privateSet(this, _startPwr, Promise.withResolvers());
+    if (__privateGet(this, _startLength) === 0) {
+      __privateGet(this, _startPwr).resolve([]);
+    } else {
+      __privateMethod(this, _AsyncQueue_instances, run_fn).call(this);
+    }
+    return __privateGet(this, _startPwr).promise;
+  }
+  get stopSettled() {
+    return __privateGet(this, _stopResolved) === __privateGet(this, _stopLength) || __privateGet(this, _stopRejected) > 0;
+  }
+  /**
+   * 终止队列中的任务执行，终止队列后不再可以追加异步任务
+   * @returns 返回一个 Promise，在所有启动任务完成后解析为结果数组
+   */
+  async stop() {
+    if (__privateGet(this, _stopPwr)) {
+      return __privateGet(this, _stopPwr).promise;
+    }
+    __privateSet(this, _stopLength, __privateGet(this, _length));
+    __privateSet(this, _stopPwr, Promise.withResolvers());
+    if (__privateGet(this, _stopLength) === 0) {
+      __privateGet(this, _stopPwr).resolve([]);
+    } else {
+      __privateMethod(this, _AsyncQueue_instances, run_fn).call(this);
+    }
+    return __privateGet(this, _stopPwr).promise;
+  }
+}
+_tasks = new WeakMap();
+_length = new WeakMap();
+_AsyncQueue_instances = new WeakSet();
+add_fn = function(method, afn, pwr) {
+  __privateGet(this, _tasks)[method]({
+    idx: __privateWrapper(this, _length)._++,
+    afn,
+    pwr
+  });
+};
+addAndRun_fn = function(method, afn) {
+  if (__privateGet(this, _stopLength) >= 0) {
+    throw new Error("异步队列已被终止，无法添加新的任务");
+  }
+  const pwr = Promise.withResolvers();
+  __privateMethod(this, _AsyncQueue_instances, add_fn).call(this, method, afn, pwr);
+  if (__privateGet(this, _startPwr) && __privateGet(this, _running) === 0) {
+    __privateMethod(this, _AsyncQueue_instances, run_fn).call(this);
+  }
+  return pwr.promise;
+};
+_startResolved = new WeakMap();
+_startRejected = new WeakMap();
+_startResults = new WeakMap();
+_startPwr = new WeakMap();
+_startLength = new WeakMap();
+_running = new WeakMap();
+run_fn = function() {
+  while (this.limit === 0 || __privateGet(this, _running) < this.limit) {
+    const task = __privateGet(this, _tasks).shift();
+    if (!task) break;
+    __privateWrapper(this, _running)._++;
+    task.afn().then((result) => {
+      var _a, _b, _c;
+      __privateWrapper(this, _running)._--;
+      (_a = task.pwr) == null ? void 0 : _a.resolve(result);
+      if (task.idx < __privateGet(this, _startLength)) {
+        __privateGet(this, _startResults)[task.idx] = result;
+        __privateWrapper(this, _startResolved)._++;
+      }
+      if (__privateGet(this, _startResolved) === __privateGet(this, _startLength)) {
+        (_b = __privateGet(this, _startPwr)) == null ? void 0 : _b.resolve(__privateGet(this, _startResults));
+      }
+      __privateGet(this, _stopResults)[task.idx] = result;
+      __privateWrapper(this, _stopResolved)._++;
+      if (__privateGet(this, _stopResolved) === __privateGet(this, _stopLength)) {
+        (_c = __privateGet(this, _stopPwr)) == null ? void 0 : _c.resolve(__privateGet(this, _stopResults));
+      } else {
+        __privateMethod(this, _AsyncQueue_instances, run_fn).call(this);
+      }
+    }).catch((reason) => {
+      var _a, _b, _c;
+      __privateWrapper(this, _running)._--;
+      (_a = task.pwr) == null ? void 0 : _a.reject(reason);
+      if (task.idx < __privateGet(this, _startLength)) {
+        __privateWrapper(this, _startRejected)._++;
+        (_b = __privateGet(this, _startPwr)) == null ? void 0 : _b.reject(reason);
+      }
+      if (__privateGet(this, _stopLength) > 0) {
+        __privateWrapper(this, _stopRejected)._++;
+        (_c = __privateGet(this, _stopPwr)) == null ? void 0 : _c.reject(reason);
+      }
+    });
+  }
+};
+_stopResolved = new WeakMap();
+_stopRejected = new WeakMap();
+_stopLength = new WeakMap();
+_stopResults = new WeakMap();
+_stopPwr = new WeakMap();
+function asyncLimit(asyncFns, limit) {
+  const aq = new AsyncQueue(asyncFns, { limit });
+  return aq.start();
+}
+function asyncShared(af, options) {
+  let executedPromise;
+  let executing = false;
+  let executingInputs;
+  let executedTime = 0;
+  const _sharedAf = async (from, ...inputs) => {
+    var _a;
+    executingInputs = inputs;
+    if (executing && executedPromise) {
+      return executedPromise;
+    }
+    if (executedPromise && Date.now() - executedTime < ((options == null ? void 0 : options.maxAge) || 0)) {
+      return executedPromise;
+    }
+    executing = true;
+    (_a = options == null ? void 0 : options.onExecute) == null ? void 0 : _a.call(options, ...executingInputs);
+    executedPromise = af(...executingInputs);
+    executingInputs = void 0;
+    executedPromise.then((res) => {
+      var _a2;
+      (_a2 = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a2.call(options, res);
+    }).catch((err) => {
+      var _a2;
+      (_a2 = options == null ? void 0 : options.onError) == null ? void 0 : _a2.call(options, err);
+    }).finally(() => {
+      var _a2;
+      executing = false;
+      executedTime = Date.now();
+      (_a2 = options == null ? void 0 : options.onFinally) == null ? void 0 : _a2.call(options);
+      if (executingInputs && (options == null ? void 0 : options.trailing)) {
+        _sharedAf("trailing", ...executingInputs);
+      }
+    });
+    return executedPromise;
+  };
+  return function sharedAf(...inputs) {
+    var _a;
+    (_a = options == null ? void 0 : options.onTrigger) == null ? void 0 : _a.call(options, ...inputs);
+    const p = _sharedAf("trigger", ...inputs);
+    p.catch(fnNoop);
+    return p;
+  };
+}
+export {
+  AsyncQueue,
+  asyncLimit,
+  asyncShared
+};
+//# sourceMappingURL=async.mjs.map

package/dist/async.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.mjs","sources":["../src/async.ts"],"sourcesContent":["import { fnNoop } from './fn';\nimport type { AnyArray, AnyAsyncFunction } from './types';\n\n/**\n * 表示异步任务的类型\n * @template T - 任务返回值的类型\n */\ntype AsyncTask<T> = {\n  /** 任务索引 */\n  idx: number;\n  /** 异步任务函数 */\n  afn: () => Promise<T>;\n  /** Promise 的解析器对象 */\n  pwr?: PromiseWithResolvers<T>;\n};\n\n/**\n * 异步任务队列的配置选项\n */\nexport type TAsyncQueueOptions = {\n  /**\n   * 并发限制数，0 表示无限制\n   * @default 0\n   */\n  limit?: number;\n};\n\n/**\n * 异步任务队列，用于管理和控制异步任务的执行\n * @template T - 任务返回值的类型\n */\nexport class AsyncQueue<T> {\n  #tasks: AsyncTask<T>[] = [];\n  #length = 0;\n\n  /**\n   * 创建一个异步任务队列\n   * @param asyncFns - 要执行的异步函数数组\n   * @param options - 队列配置选项\n   */\n  constructor(\n    asyncFns: Array<() => Promise<T>>,\n    readonly options?: TAsyncQueueOptions,\n  ) {\n    asyncFns.forEach((afn, idx) => {\n      this.#add('push', afn);\n    });\n  }\n\n  get length() {\n    return this.#length;\n  }\n\n  get limit() {\n    return this.options?.limit || 0;\n  }\n\n  #add(method: 'unshift' | 'push', afn: () => Promise<T>, pwr?: PromiseWithResolvers<T>) {\n    this.#tasks[method]({\n      idx: this.#length++,\n      afn: afn,\n      pwr: pwr,\n    });\n  }\n\n  #addAndRun(method: 'unshift' | 'push', afn: () => Promise<T>) {\n    // 明确终止了\n    if (this.#stopLength >= 0) {\n      throw new Error('异步队列已被终止，无法添加新的任务');\n    }\n\n    const pwr = Promise.withResolvers<T>();\n    this.#add(method, afn, pwr);\n\n    if (this.#startPwr && this.#running === 0) {\n      this.#run();\n    }\n\n    return pwr.promise;\n  }\n\n  async push(afn: () => Promise<T>) {\n    return this.#addAndRun('push', afn);\n  }\n\n  async unshift(afn: () => Promise<T>) {\n    return this.#addAndRun('unshift', afn);\n  }\n\n  #startResolved = 0;\n  #startRejected = 0;\n  get startSettled() {\n    return this.#startResolved === this.#startLength || this.#startRejected > 0;\n  }\n\n  #startResults: T[] = [];\n  #startPwr: PromiseWithResolvers<T[]> | null = null;\n  #startLength = 0;\n\n  /**\n   * 启动队列中的任务执行\n   * @returns 返回一个 Promise，在所有启动任务完成后解析为结果数组\n   */\n  async start(): Promise<T[]> {\n    if (this.#startPwr) return this.#startPwr.promise;\n\n    // 固化启动时长度，便于判断 start 异步结果\n    this.#startLength = this.#length;\n    this.#startPwr = Promise.withResolvers<T[]>();\n\n    if (this.#startLength === 0) {\n      this.#startPwr.resolve([]);\n    } else {\n      this.#run();\n    }\n\n    return this.#startPwr.promise;\n  }\n\n  #running = 0;\n  #run() {\n    while (this.limit === 0 || this.#running < this.limit) {\n      const task = this.#tasks.shift();\n\n      // 无任务可执行\n      if (!task) break;\n\n      this.#running++;\n\n      task\n        .afn()\n        .then((result) => {\n          this.#running--;\n          task.pwr?.resolve(result);\n\n          // 属于启动任务\n          if (task.idx < this.#startLength) {\n            this.#startResults[task.idx] = result;\n            this.#startResolved++;\n          }\n\n          // 所有启动任务都已执行完毕\n          if (this.#startResolved === this.#startLength) {\n            this.#startPwr?.resolve(this.#startResults);\n          }\n\n          this.#stopResults[task.idx] = result;\n          this.#stopResolved++;\n\n          // 所有停止任务都已执行完毕\n          if (this.#stopResolved === this.#stopLength) {\n            this.#stopPwr?.resolve(this.#stopResults);\n          } else {\n            this.#run();\n          }\n        })\n        .catch((reason) => {\n          this.#running--;\n          task.pwr?.reject(reason);\n\n          // 属于启动任务\n          if (task.idx < this.#startLength) {\n            this.#startRejected++;\n            this.#startPwr?.reject(reason);\n          }\n\n          // 属于停止任务\n          if (this.#stopLength > 0) {\n            this.#stopRejected++;\n            this.#stopPwr?.reject(reason);\n          }\n        });\n    }\n  }\n  #stopResolved = 0;\n  #stopRejected = 0;\n  get stopSettled() {\n    return this.#stopResolved === this.#stopLength || this.#stopRejected > 0;\n  }\n\n  #stopLength = -1;\n  #stopResults: T[] = [];\n\n  #stopPwr?: PromiseWithResolvers<T[]> | null = null;\n\n  /**\n   * 终止队列中的任务执行，终止队列后不再可以追加异步任务\n   * @returns 返回一个 Promise，在所有启动任务完成后解析为结果数组\n   */\n  async stop() {\n    if (this.#stopPwr) {\n      return this.#stopPwr.promise;\n    }\n\n    this.#stopLength = this.#length;\n    this.#stopPwr = Promise.withResolvers<T[]>();\n\n    if (this.#stopLength === 0) {\n      this.#stopPwr.resolve([]);\n    } else {\n      this.#run();\n    }\n\n    return this.#stopPwr.promise;\n  }\n}\n\n/**\n * 使用给定的并发限制执行异步函数\n *\n * 此函数的目的是控制一组异步函数的并发执行数量，通过创建一个AsyncQueue实例来管理这些异步函数的执行\n * 它确保在任何给定时间只有最多`limit`数量的异步函数被执行，以避免潜在的性能问题或资源竞争\n *\n * @param asyncFns 一个包含异步函数的数组，每个异步函数都不需要参数，并返回一个Promise\n * @param limit 并发限制的数量，表示同时执行的异步函数的最大数量，0 表示不限制\n * @returns 返回一个Promise，当所有异步函数都执行完毕后，该Promise将被解析\n */\nexport function asyncLimit<T>(asyncFns: Array<() => Promise<T>>, limit: number) {\n  const aq = new AsyncQueue<T>(asyncFns, { limit });\n  return aq.start();\n}\n\n/**\n * 异步共享函数的配置选项\n */\nexport type AsyncSharedOptions<I extends AnyArray, O> = {\n  /**\n   * 是否在调用结束后再执行（只在运行期间有再次调用时才会生效）\n   * @type {boolean}\n   * @default false\n   * @example\n   * const sharedFn = asyncShared(fetchData, { trailing: true });\n   * // 如果在 fetchData 执行期间多次调用 sharedFn，则会在 fetchData 结束后再次执行\n   */\n  trailing?: boolean;\n\n  /**\n   * 缓存结果的最大有效期（毫秒）\n   * @type {number}\n   * @example\n   * const sharedFn = asyncShared(fetchData, { maxAge: 1000 });\n   * // 在 1 秒内调用 sharedFn 会直接返回缓存结果\n   */\n  maxAge?: number;\n\n  /**\n   * 在调用共享函数时触发的回调函数\n   * @param inputs - 传递给共享函数的参数\n   * @example\n   * const options: AsyncSharedOptions<typeof fetchData> = {\n   *   onTrigger: (...args) => console.log('Calling with:', args)\n   * };\n   */\n  onTrigger?: (...inputs: I) => unknown;\n\n  /**\n   * 在执行异步函数时触发的回调函数\n   * @param args - 传递给异步函数的参数\n   * @example\n   * const options: AsyncSharedOptions<typeof fetchData> = {\n   *   onExecute: (...args) => console.log('Executing with:', args)\n   * };\n   */\n  onExecute?: (...args: I) => unknown;\n\n  /**\n   * 在异步函数成功执行后触发的回调函数\n   * @param output - 异步函数的返回结果\n   * @example\n   * const options: AsyncSharedOptions<typeof fetchData> = {\n   *   onSuccess: (result) => console.log('Success:', result)\n   * };\n   */\n  onSuccess?: (output: O) => unknown;\n\n  /**\n   * 在异步函数执行失败时触发的回调函数\n   * @param error - 异步函数抛出的错误\n   * @example\n   * const options: AsyncSharedOptions<typeof fetchData> = {\n   *   onError: (error) => console.error('Error:', error)\n   * };\n   */\n  onError?: (error: unknown) => unknown;\n\n  /**\n   * 在异步函数执行完成（无论成功或失败）时触发的回调函数\n   * @example\n   * const options: AsyncSharedOptions<typeof fetchData> = {\n   *   onFinally: () => console.log('Execution completed')\n   * };\n   */\n  onFinally?: () => unknown;\n};\n\n/**\n * 创建一个共享执行结果的异步函数\n * @template F - 异步函数类型\n * @param {F} af - 要共享的异步函数\n * @param {AsyncSharedOptions} [options] - 配置选项\n * @returns {F} 返回一个新的异步函数，该函数会共享执行结果\n * @example\n * const fetchData = async (id) => {\n *   // 模拟异步操作\n *   return await fetch(`/api/data/${id}`);\n * };\n *\n * const sharedFetch = asyncShared(fetchData, { maxAge: 1000 });\n *\n * // 多次调用会共享同一个请求\n * const result1 = await sharedFetch(1);\n * const result2 = await sharedFetch(1); // 上次请求完成后 1000ms 内直接返回缓存结果\n */\nexport function asyncShared<I extends AnyArray, O>(\n  af: (...inputs: I) => Promise<O>,\n  options?: AsyncSharedOptions<I, O>,\n) {\n  let executedPromise: Promise<O> | undefined;\n  let executing = false;\n  let executingInputs: I | undefined;\n  let executedTime = 0;\n\n  const _sharedAf = async (from: 'trigger' | 'trailing', ...inputs: I) => {\n    executingInputs = inputs;\n\n    // 如果正在运行，则复用运行结果\n    if (executing && executedPromise) {\n      return executedPromise;\n    }\n\n    // 如果已运行结束空闲时，判断是否在等待时间内\n    if (executedPromise && Date.now() - executedTime < (options?.maxAge || 0)) {\n      return executedPromise;\n    }\n\n    // 否则直接执行\n    executing = true;\n    options?.onExecute?.(...executingInputs);\n    executedPromise = af(...executingInputs);\n    executingInputs = undefined;\n    executedPromise\n      .then((res) => {\n        options?.onSuccess?.(res);\n      })\n      .catch((err) => {\n        options?.onError?.(err);\n      })\n      .finally(() => {\n        executing = false;\n        executedTime = Date.now();\n        options?.onFinally?.();\n\n        // 执行期间多次调用，则重新执行\n        if (executingInputs && options?.trailing) {\n          _sharedAf('trailing', ...executingInputs);\n        }\n      });\n\n    return executedPromise;\n  };\n\n  return function sharedAf(...inputs: I): Promise<O> {\n    options?.onTrigger?.(...inputs);\n    const p = _sharedAf('trigger', ...inputs);\n    // 必须捕获错误，否则单测错误边界时会抛错\n    p.catch(fnNoop);\n    return p;\n  };\n}\n\n// const af1 = asyncShared(async () => {\n//   return 1;\n// });\n// const n = await af1();\n\n// const af2 = asyncShared(async (a: number) => {\n//   return a + 1;\n// });\n// const n2 = await af2(2);\n"],"names":["_a"],"mappings":"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"}

package/dist/base64.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function base64toBlob(base64) {
+  const byteString = atob(base64.split(",")[1]);
+  const mimeString = base64.split(",")[0].split(":")[1].split(";")[0];
+  const ab = new ArrayBuffer(byteString.length);
+  const ua = new Uint8Array(ab);
+  for (let i = 0; i < byteString.length; i++) {
+    ua[i] = byteString.charCodeAt(i);
+  }
+  return new Blob([ab], {
+    type: mimeString
+  });
+}
+exports.base64toBlob = base64toBlob;
+//# sourceMappingURL=base64.cjs.map

package/dist/base64.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.cjs","sources":["../src/base64.ts"],"sourcesContent":["/**\n * base64 转换为 Blob 实例\n * @ref http://stackoverflow.com/q/18253378\n * @param base64 {String} base64 编码\n * @returns {Blob}\n */\nexport function base64toBlob(base64: string): Blob {\n  const byteString = atob(base64.split(',')[1]);\n  const mimeString = base64.split(',')[0].split(':')[1].split(';')[0];\n  const ab = new ArrayBuffer(byteString.length);\n  const ua = new Uint8Array(ab);\n\n  for (let i = 0; i < byteString.length; i++) {\n    ua[i] = byteString.charCodeAt(i);\n  }\n\n  return new Blob([ab], {\n    type: mimeString,\n  });\n}\n"],"names":[],"mappings":";;AAMO,SAAS,aAAa,QAAsB;AACjD,QAAM,aAAa,KAAK,OAAO,MAAM,GAAG,EAAE,CAAC,CAAC;AAC5C,QAAM,aAAa,OAAO,MAAM,GAAG,EAAE,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC;AAClE,QAAM,KAAK,IAAI,YAAY,WAAW,MAAM;AACtC,QAAA,KAAK,IAAI,WAAW,EAAE;AAE5B,WAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;AAC1C,OAAG,CAAC,IAAI,WAAW,WAAW,CAAC;AAAA,EAAA;AAGjC,SAAO,IAAI,KAAK,CAAC,EAAE,GAAG;AAAA,IACpB,MAAM;AAAA,EAAA,CACP;AACH;;"}

package/dist/base64.d.ts

@@ -0,0 +1,7 @@
+/**
+ * base64 转换为 Blob 实例
+ * @ref http://stackoverflow.com/q/18253378
+ * @param base64 {String} base64 编码
+ * @returns {Blob}
+ */
+export declare function base64toBlob(base64: string): Blob;