@cloudcome/utils-core 1.1.1 → 1.2.1

package/dist/emitter.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 事件类型映射，key 为事件名称，value 为事件参数类型数组
+ */
+export type EmitterMap = Record<string, unknown[]>;
+/**
+ * 事件监听器函数类型
+ * @template E - EmitterMap 类型
+ * @template K - 事件名称类型
+ */
+export type EmitterListener<E extends EmitterMap, K extends keyof E> = (...payloads: E[K]) => false | unknown;
+/**
+ * 事件发射器类，用于管理事件监听和触发
+ * @template E - 事件类型映射
+ *
+ * @example
+ * type MyEvents = {
+ *   'click': [x: number, y: number];
+ *   'change': [value: string];
+ * };
+ *
+ * const emitter = new Emitter<MyEvents>();
+ * emitter.on('click', (x, y) => {
+ *   console.log(`Clicked at (${x}, ${y})`);
+ * });
+ * emitter.emit('click', 10, 20);
+ */
+export declare class Emitter<E extends EmitterMap> {
+    #private;
+    /**
+     * 注册事件监听器
+     * @param event - 要监听的事件名称
+     * @param listener - 事件监听器函数
+     * @example
+     * emitter.on('click', (x, y) => {
+     *   console.log(`Clicked at (${x}, ${y})`);
+     * });
+     */
+    on<K extends keyof E>(event: K, listener: EmitterListener<E, K>): void;
+    /**
+     * 移除事件监听器，有三种使用方式：
+     * 1. 移除特定事件的特定监听器
+     * 2. 移除特定事件的所有监听器
+     * 3. 移除所有事件的所有监听器
+     * @param event - 要移除的事件名称（可选）
+     * @param listener - 要移除的监听器函数（可选）
+     * @example
+     * // 移除特定事件的特定监听器
+     * emitter.off('click', clickHandler);
+     *
+     * // 移除特定事件的所有监听器
+     * emitter.off('click');
+     *
+     * // 移除所有事件的所有监听器
+     * emitter.off();
+     */
+    off<K extends keyof E>(event?: K, listener?: EmitterListener<E, K>): void;
+    /**
+     * 触发指定事件，调用所有注册的监听器
+     * @param event - 要触发的事件名称
+     * @param payloads - 传递给监听器的参数
+     * @remarks
+     * 监听器会按照注册的顺序依次执行，如果某个监听器返回 false，
+     * 则后续监听器将不会被执行
+     * @example
+     * emitter.emit('click', 10, 20);
+     */
+    emit<K extends keyof E>(event: K, ...payloads: Parameters<EmitterListener<E, K>>): void;
+}

package/dist/emitter.mjs

@@ -0,0 +1,94 @@
+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 __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _events, _Emitter_instances, offAll_fn, offEvent_fn, offListener_fn;
+class Emitter {
+  constructor() {
+    __privateAdd(this, _Emitter_instances);
+    __privateAdd(this, _events, /* @__PURE__ */ new Map());
+  }
+  /**
+   * 注册事件监听器
+   * @param event - 要监听的事件名称
+   * @param listener - 事件监听器函数
+   * @example
+   * emitter.on('click', (x, y) => {
+   *   console.log(`Clicked at (${x}, ${y})`);
+   * });
+   */
+  on(event, listener) {
+    const listeners = __privateGet(this, _events).get(event);
+    if (listeners) {
+      listeners.add(listener);
+    } else {
+      __privateGet(this, _events).set(event, /* @__PURE__ */ new Set([listener]));
+    }
+  }
+  /**
+   * 移除事件监听器，有三种使用方式：
+   * 1. 移除特定事件的特定监听器
+   * 2. 移除特定事件的所有监听器
+   * 3. 移除所有事件的所有监听器
+   * @param event - 要移除的事件名称（可选）
+   * @param listener - 要移除的监听器函数（可选）
+   * @example
+   * // 移除特定事件的特定监听器
+   * emitter.off('click', clickHandler);
+   *
+   * // 移除特定事件的所有监听器
+   * emitter.off('click');
+   *
+   * // 移除所有事件的所有监听器
+   * emitter.off();
+   */
+  off(event, listener) {
+    if (event && listener) {
+      __privateMethod(this, _Emitter_instances, offListener_fn).call(this, event, listener);
+    } else if (event) {
+      __privateMethod(this, _Emitter_instances, offEvent_fn).call(this, event);
+    } else {
+      __privateMethod(this, _Emitter_instances, offAll_fn).call(this);
+    }
+  }
+  /**
+   * 触发指定事件，调用所有注册的监听器
+   * @param event - 要触发的事件名称
+   * @param payloads - 传递给监听器的参数
+   * @remarks
+   * 监听器会按照注册的顺序依次执行，如果某个监听器返回 false，
+   * 则后续监听器将不会被执行
+   * @example
+   * emitter.emit('click', 10, 20);
+   */
+  emit(event, ...payloads) {
+    const listeners = __privateGet(this, _events).get(event);
+    if (!listeners) return;
+    for (const listener of [...listeners]) {
+      if (listener(...payloads) === false) {
+        break;
+      }
+    }
+  }
+}
+_events = new WeakMap();
+_Emitter_instances = new WeakSet();
+offAll_fn = function() {
+  __privateGet(this, _events).clear();
+};
+offEvent_fn = function(event) {
+  __privateGet(this, _events).delete(event);
+};
+offListener_fn = function(event, listener) {
+  const listeners = __privateGet(this, _events).get(event);
+  if (listeners) {
+    listeners.delete(listener);
+  }
+};
+export {
+  Emitter
+};
+//# sourceMappingURL=emitter.mjs.map

package/dist/emitter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.mjs","sources":["../src/emitter.ts"],"sourcesContent":["import type { AnyFunction, AnyObject } from './types';\n\n/**\n * 事件类型映射，key 为事件名称，value 为事件参数类型数组\n */\nexport type EmitterMap = Record<string, unknown[]>;\n\n/**\n * 事件监听器函数类型\n * @template E - EmitterMap 类型\n * @template K - 事件名称类型\n */\nexport type EmitterListener<E extends EmitterMap, K extends keyof E> = (...payloads: E[K]) => false | unknown;\n\n/**\n * 事件发射器类，用于管理事件监听和触发\n * @template E - 事件类型映射\n *\n * @example\n * type MyEvents = {\n *   'click': [x: number, y: number];\n *   'change': [value: string];\n * };\n *\n * const emitter = new Emitter<MyEvents>();\n * emitter.on('click', (x, y) => {\n *   console.log(`Clicked at (${x}, ${y})`);\n * });\n * emitter.emit('click', 10, 20);\n */\nexport class Emitter<E extends EmitterMap> {\n  #events: Map<keyof E, Set<AnyFunction>> = new Map();\n\n  /**\n   * 注册事件监听器\n   * @param event - 要监听的事件名称\n   * @param listener - 事件监听器函数\n   * @example\n   * emitter.on('click', (x, y) => {\n   *   console.log(`Clicked at (${x}, ${y})`);\n   * });\n   */\n  on<K extends keyof E>(event: K, listener: EmitterListener<E, K>) {\n    const listeners = this.#events.get(event);\n    if (listeners) {\n      listeners.add(listener);\n    } else {\n      this.#events.set(event, new Set([listener]));\n    }\n  }\n\n  /**\n   * 移除事件监听器，有三种使用方式：\n   * 1. 移除特定事件的特定监听器\n   * 2. 移除特定事件的所有监听器\n   * 3. 移除所有事件的所有监听器\n   * @param event - 要移除的事件名称（可选）\n   * @param listener - 要移除的监听器函数（可选）\n   * @example\n   * // 移除特定事件的特定监听器\n   * emitter.off('click', clickHandler);\n   *\n   * // 移除特定事件的所有监听器\n   * emitter.off('click');\n   *\n   * // 移除所有事件的所有监听器\n   * emitter.off();\n   */\n  off<K extends keyof E>(event?: K, listener?: EmitterListener<E, K>) {\n    if (event && listener) {\n      this.#offListener(event, listener);\n    } else if (event) {\n      this.#offEvent(event);\n    } else {\n      this.#offAll();\n    }\n  }\n\n  #offAll() {\n    this.#events.clear();\n  }\n\n  #offEvent<K extends keyof E>(event: K) {\n    this.#events.delete(event);\n  }\n\n  #offListener<K extends keyof E>(event: K, listener: EmitterListener<E, K>) {\n    const listeners = this.#events.get(event);\n\n    if (listeners) {\n      listeners.delete(listener);\n    }\n  }\n\n  /**\n   * 触发指定事件，调用所有注册的监听器\n   * @param event - 要触发的事件名称\n   * @param payloads - 传递给监听器的参数\n   * @remarks\n   * 监听器会按照注册的顺序依次执行，如果某个监听器返回 false，\n   * 则后续监听器将不会被执行\n   * @example\n   * emitter.emit('click', 10, 20);\n   */\n  emit<K extends keyof E>(event: K, ...payloads: Parameters<EmitterListener<E, K>>) {\n    const listeners = this.#events.get(event) as Set<EmitterListener<E, K>> | undefined;\n\n    if (!listeners) return;\n\n    // 避免在 emit、on 的过程中改变 listeners 从而影响本次 emit\n    for (const listener of [...listeners]) {\n      if (listener(...payloads) === false) {\n        break;\n      }\n    }\n  }\n}\n"],"names":[],"mappings":";;;;;;;AA8BO;AAAA,MAAM,QAA8B;AAAA,EAApC;AAAA;AACL,oDAA8C,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWlD,GAAsB,OAAU,UAAiC;AAC/D,UAAM,YAAY,mBAAK,SAAQ,IAAI,KAAK;AACxC,QAAI,WAAW;AACb,gBAAU,IAAI,QAAQ;AAAA,IAAA,OACjB;AACA,yBAAA,SAAQ,IAAI,OAAO,oBAAI,IAAI,CAAC,QAAQ,CAAC,CAAC;AAAA,IAAA;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBF,IAAuB,OAAW,UAAkC;AAClE,QAAI,SAAS,UAAU;AAChB,4BAAA,oCAAA,WAAa,OAAO;AAAA,eAChB,OAAO;AAChB,4BAAK,iCAAL,WAAe;AAAA,IAAK,OACf;AACL,4BAAK,+BAAL;AAAA,IAAa;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA6BF,KAAwB,UAAa,UAA6C;AAChF,UAAM,YAAY,mBAAK,SAAQ,IAAI,KAAK;AAExC,QAAI,CAAC,UAAW;AAGhB,eAAW,YAAY,CAAC,GAAG,SAAS,GAAG;AACrC,UAAI,SAAS,GAAG,QAAQ,MAAM,OAAO;AACnC;AAAA,MAAA;AAAA,IACF;AAAA,EACF;AAEJ;AArFE;AADK;AAgDL,YAAU,WAAA;AACR,qBAAK,SAAQ,MAAM;AAAA;AAGrB,uBAA6B,OAAU;AAChC,qBAAA,SAAQ,OAAO,KAAK;AAAA;AAG3B,iBAAA,SAAgC,OAAU,UAAiC;AACzE,QAAM,YAAY,mBAAK,SAAQ,IAAI,KAAK;AAExC,MAAI,WAAW;AACb,cAAU,OAAO,QAAQ;AAAA,EAAA;AAC3B;"}

package/dist/enum.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function defineEnum(definition) {
+  const keys = Object.keys(definition);
+  return {
+    ...[...Object.entries(definition)].reduce((acc, [key, dfn]) => {
+      if (key[0].toUpperCase() !== key[0]) {
+        throw new Error(`错误：枚举键名 ${key} 必须以大写字母开头`);
+      }
+      if (key.startsWith("$")) {
+        throw new Error(`错误：枚举键名 ${key} 不能以 $ 符号开头`);
+      }
+      acc[key] = dfn.value;
+      acc[`$${key}`] = { key, ...dfn };
+      return acc;
+    }, {}),
+    definition,
+    descriptions: keys.map((key) => ({
+      key,
+      ...definition[key]
+    })),
+    keys,
+    length: keys.length,
+    values: keys.map((key) => definition[key].value),
+    kvRecord: keys.reduce((acc, key) => {
+      acc[key] = definition[key].value;
+      return acc;
+    }, {}),
+    vkRecord: keys.reduce((acc, key) => {
+      acc[definition[key].value] = key;
+      return acc;
+    }, {}),
+    toKeyRecord(prop) {
+      return keys.reduce((acc, key) => {
+        acc[key] = definition[key][prop];
+        return acc;
+      }, {});
+    },
+    toValueRecord(prop) {
+      return keys.reduce(
+        (acc, key) => {
+          acc[definition[key].value] = definition[key][prop];
+          return acc;
+        },
+        {}
+      );
+    }
+  };
+}
+function declareEnum() {
+  return {
+    define(definition) {
+      return defineEnum(definition);
+    }
+  };
+}
+exports.declareEnum = declareEnum;
+//# sourceMappingURL=enum.cjs.map

package/dist/enum.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.cjs","sources":["../src/enum.ts"],"sourcesContent":["import type { AnyObject, MergeIntersection, UnionToIntersection, UnionToTuple } from './types';\n\nexport type EnumKey = string;\nexport type EnumValue = number | string;\nexport type EnumMetaAppend = {\n  key?: string;\n  value?: string | number;\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  [key: string]: any;\n};\nexport type EnumMeta<A extends EnumMetaAppend> = A & {\n  value: EnumValue;\n};\nexport type EnumDescription<A extends EnumMetaAppend> = Record<EnumKey, EnumMeta<A>>;\n\nconst enumError = Symbol('enumKeyError');\n\ntype _StartWithDollarSign<T extends string> = T extends `$${infer R}` ? R : never;\n\ntype _CheckDefinition<O extends AnyObject> = {\n  // [K in keyof O & string]: K extends Capitalize<K> ? O[K] : `错误：枚举键名 ${K} 必须大写字母开头`;\n  [K in keyof O & string]: K extends Capitalize<K>\n    ? K extends `$${infer R}`\n      ? O[K] & { [enumError]: `错误：枚举键名 ${K} 不能以 $ 符号开头` }\n      : O[K]\n    : O[K] & { [enumError]: `错误：枚举键名 ${K} 必须以大写字母开头` };\n};\n\ntype _ToOriginDefProp<T extends AnyObject> = {\n  [K in keyof T as `$${K & string}`]: MergeIntersection<T[K] & { readonly key: K }>;\n};\n\ntype _KVRecord<T> = T extends Record<string, AnyObject>\n  ? {\n      readonly [K in keyof T]: T[K]['value'];\n    }\n  : never;\n\ntype _VKRecord<T> = T extends Record<string, AnyObject>\n  ? MergeIntersection<\n      UnionToIntersection<\n        {\n          [K in keyof T]: {\n            [P in keyof T[K] as P extends 'value' ? T[K][P] & (string | number) : never]: K;\n          };\n        }[keyof T]\n      >\n    >\n  : never;\n\nexport type EnumExpose<A extends EnumMetaAppend, E extends EnumDescription<A>> = _ToOriginDefProp<E> &\n  _KVRecord<E> & {\n    readonly definition: E;\n    readonly descriptions: MergeIntersection<A & { key: keyof E }>[];\n    readonly keys: UnionToTuple<keyof E>;\n    readonly length: UnionToTuple<keyof E>['length'];\n    readonly values: UnionToTuple<E[keyof E]['value']>;\n    readonly kvRecord: _KVRecord<E>;\n    readonly vkRecord: _VKRecord<E>;\n    toKeyRecord: <P extends keyof A>(prop: P) => Record<keyof E, A[P]>;\n    toValueRecord: <P extends keyof A>(prop: P) => Record<E[keyof E]['value'], A[P]>;\n  };\n\n/**\n * 定义一个枚举类型，如果需要类型提示，需要使用 declareEnum 函数定义枚举。\n * @template A - 枚举元数据附加类型，扩展自 EnumMetaAppend\n * @template E - 枚举描述类型，键为枚举键名，值为枚举元数据\n * @param {_CheckDefinition<E>} definition - 枚举定义对象\n * @returns {EnumExpose<A, E>} 返回枚举的完整暴露对象\n * @example\n * ```typescript\n * const Status = defineEnum({\n *   Pending: { value: 0, label: '待处理' },\n *   Approved: { value: 1, label: '已批准' }\n * });\n * ```\n *\n * @property {E} definition - 原始枚举定义对象\n * @property {Array<MergeIntersection<A & { key: keyof E }>>} descriptions - 枚举项的完整描述数组\n * @property {UnionToTuple<keyof E>} keys - 枚举键名的元组\n * @property {\"UnionToTuple<keyof E>[\\\"length\\\"]\"} length - 枚举项的数量\n * @property {UnionToTuple<E[keyof E][\"value\"]>} values - 枚举值的元组\n * @property {Record<keyof E, E[keyof E][\"value\"]>} kvRecord - 键到值的映射记录\n * @property {Record<E[keyof E][\"value\"], E[keyof E]>} vkRecord - 值到键的映射记录\n * @property {function} toKeyRecord - 根据属性名创建键到属性值的映射记录\n * @property {function} toValueRecord - 根据属性名创建值到属性值的映射记录\n */\nfunction defineEnum<A extends EnumMetaAppend, const E extends EnumDescription<A>>(\n  definition: _CheckDefinition<E>,\n): EnumExpose<A, E> {\n  const keys = Object.keys(definition);\n\n  return {\n    ...[...Object.entries(definition)].reduce((acc, [key, dfn]) => {\n      if (key[0].toUpperCase() !== key[0]) {\n        throw new Error(`错误：枚举键名 ${key} 必须以大写字母开头`);\n      }\n\n      if (key.startsWith('$')) {\n        throw new Error(`错误：枚举键名 ${key} 不能以 $ 符号开头`);\n      }\n\n      // @ts-ignore\n      acc[key] = dfn.value;\n      // @ts-ignore\n      acc[`$${key}`] = { key, ...dfn };\n      return acc;\n    }, {}),\n    definition,\n    descriptions: keys.map((key) => ({\n      key,\n      ...definition[key],\n    })),\n    keys,\n    length: keys.length,\n    values: keys.map((key) => definition[key as keyof E].value),\n    kvRecord: keys.reduce((acc, key) => {\n      // @ts-ignore\n      acc[key] = definition[key].value;\n      return acc;\n    }, {}),\n    vkRecord: keys.reduce((acc, key) => {\n      // @ts-ignore\n      acc[definition[key].value] = key;\n      return acc;\n    }, {}),\n    toKeyRecord<P extends keyof A>(prop: P) {\n      return keys.reduce((acc, key) => {\n        // @ts-ignore\n        acc[key] = definition[key][prop];\n        return acc;\n      }, {});\n    },\n    toValueRecord<P extends keyof A>(prop: P) {\n      return keys.reduce(\n        (acc, key) => {\n          // @ts-ignore\n          acc[definition[key].value] = definition[key][prop];\n          return acc;\n        },\n        {} as Record<E[keyof E]['value'], A[P]>,\n      );\n    },\n  } as unknown as EnumExpose<A, E>;\n}\n\n/**\n * 声明一个枚举工厂函数\n * @template A - 枚举元数据附加类型，扩展自 EnumMetaAppend\n * @returns {Object} 返回包含 define 方法的对象\n *\n * @property {function} define - 定义枚举的函数\n *   @template E - 枚举描述类型\n *   @param {_CheckDefinition<E>} definition - 枚举定义对象\n *   @returns {EnumExpose<A, E>} 返回枚举的完整暴露对象\n *   @example\n *   ```typescript\n *   const createStatusEnum = declareEnum<{ label: string }>();\n *   const Status = createStatusEnum.define({\n *     Pending: { value: 0, label: '待处理' },\n *     Approved: { value: 1, label: '已批准' }\n *   });\n *   ```\n */\nexport function declareEnum<A extends EnumMetaAppend>() {\n  return {\n    define<const E extends EnumDescription<A>>(definition: _CheckDefinition<E>): EnumExpose<A, E> {\n      return defineEnum(definition);\n    },\n  };\n}\n"],"names":[],"mappings":";;AAuFA,SAAS,WACP,YACkB;AACZ,QAAA,OAAO,OAAO,KAAK,UAAU;AAE5B,SAAA;AAAA,IACL,GAAG,CAAC,GAAG,OAAO,QAAQ,UAAU,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,GAAG,MAAM;AAC7D,UAAI,IAAI,CAAC,EAAE,kBAAkB,IAAI,CAAC,GAAG;AACnC,cAAM,IAAI,MAAM,WAAW,GAAG,YAAY;AAAA,MAAA;AAGxC,UAAA,IAAI,WAAW,GAAG,GAAG;AACvB,cAAM,IAAI,MAAM,WAAW,GAAG,aAAa;AAAA,MAAA;AAIzC,UAAA,GAAG,IAAI,IAAI;AAEf,UAAI,IAAI,GAAG,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI;AACxB,aAAA;AAAA,IACT,GAAG,EAAE;AAAA,IACL;AAAA,IACA,cAAc,KAAK,IAAI,CAAC,SAAS;AAAA,MAC/B;AAAA,MACA,GAAG,WAAW,GAAG;AAAA,IAAA,EACjB;AAAA,IACF;AAAA,IACA,QAAQ,KAAK;AAAA,IACb,QAAQ,KAAK,IAAI,CAAC,QAAQ,WAAW,GAAc,EAAE,KAAK;AAAA,IAC1D,UAAU,KAAK,OAAO,CAAC,KAAK,QAAQ;AAElC,UAAI,GAAG,IAAI,WAAW,GAAG,EAAE;AACpB,aAAA;AAAA,IACT,GAAG,EAAE;AAAA,IACL,UAAU,KAAK,OAAO,CAAC,KAAK,QAAQ;AAElC,UAAI,WAAW,GAAG,EAAE,KAAK,IAAI;AACtB,aAAA;AAAA,IACT,GAAG,EAAE;AAAA,IACL,YAA+B,MAAS;AACtC,aAAO,KAAK,OAAO,CAAC,KAAK,QAAQ;AAE/B,YAAI,GAAG,IAAI,WAAW,GAAG,EAAE,IAAI;AACxB,eAAA;AAAA,MACT,GAAG,EAAE;AAAA,IACP;AAAA,IACA,cAAiC,MAAS;AACxC,aAAO,KAAK;AAAA,QACV,CAAC,KAAK,QAAQ;AAER,cAAA,WAAW,GAAG,EAAE,KAAK,IAAI,WAAW,GAAG,EAAE,IAAI;AAC1C,iBAAA;AAAA,QACT;AAAA,QACA,CAAA;AAAA,MACF;AAAA,IAAA;AAAA,EAEJ;AACF;AAoBO,SAAS,cAAwC;AAC/C,SAAA;AAAA,IACL,OAA2C,YAAmD;AAC5F,aAAO,WAAW,UAAU;AAAA,IAAA;AAAA,EAEhC;AACF;;"}

package/dist/enum.d.ts

@@ -0,0 +1,68 @@
+import { AnyObject, MergeIntersection, UnionToIntersection, UnionToTuple } from './types';
+export type EnumKey = string;
+export type EnumValue = number | string;
+export type EnumMetaAppend = {
+    key?: string;
+    value?: string | number;
+    [key: string]: any;
+};
+export type EnumMeta<A extends EnumMetaAppend> = A & {
+    value: EnumValue;
+};
+export type EnumDescription<A extends EnumMetaAppend> = Record<EnumKey, EnumMeta<A>>;
+declare const enumError: unique symbol;
+type _CheckDefinition<O extends AnyObject> = {
+    [K in keyof O & string]: K extends Capitalize<K> ? K extends `$${infer R}` ? O[K] & {
+        [enumError]: `错误：枚举键名 ${K} 不能以 $ 符号开头`;
+    } : O[K] : O[K] & {
+        [enumError]: `错误：枚举键名 ${K} 必须以大写字母开头`;
+    };
+};
+type _ToOriginDefProp<T extends AnyObject> = {
+    [K in keyof T as `$${K & string}`]: MergeIntersection<T[K] & {
+        readonly key: K;
+    }>;
+};
+type _KVRecord<T> = T extends Record<string, AnyObject> ? {
+    readonly [K in keyof T]: T[K]['value'];
+} : never;
+type _VKRecord<T> = T extends Record<string, AnyObject> ? MergeIntersection<UnionToIntersection<{
+    [K in keyof T]: {
+        [P in keyof T[K] as P extends 'value' ? T[K][P] & (string | number) : never]: K;
+    };
+}[keyof T]>> : never;
+export type EnumExpose<A extends EnumMetaAppend, E extends EnumDescription<A>> = _ToOriginDefProp<E> & _KVRecord<E> & {
+    readonly definition: E;
+    readonly descriptions: MergeIntersection<A & {
+        key: keyof E;
+    }>[];
+    readonly keys: UnionToTuple<keyof E>;
+    readonly length: UnionToTuple<keyof E>['length'];
+    readonly values: UnionToTuple<E[keyof E]['value']>;
+    readonly kvRecord: _KVRecord<E>;
+    readonly vkRecord: _VKRecord<E>;
+    toKeyRecord: <P extends keyof A>(prop: P) => Record<keyof E, A[P]>;
+    toValueRecord: <P extends keyof A>(prop: P) => Record<E[keyof E]['value'], A[P]>;
+};
+/**
+ * 声明一个枚举工厂函数
+ * @template A - 枚举元数据附加类型，扩展自 EnumMetaAppend
+ * @returns {Object} 返回包含 define 方法的对象
+ *
+ * @property {function} define - 定义枚举的函数
+ *   @template E - 枚举描述类型
+ *   @param {_CheckDefinition<E>} definition - 枚举定义对象
+ *   @returns {EnumExpose<A, E>} 返回枚举的完整暴露对象
+ *   @example
+ *   ```typescript
+ *   const createStatusEnum = declareEnum<{ label: string }>();
+ *   const Status = createStatusEnum.define({
+ *     Pending: { value: 0, label: '待处理' },
+ *     Approved: { value: 1, label: '已批准' }
+ *   });
+ *   ```
+ */
+export declare function declareEnum<A extends EnumMetaAppend>(): {
+    define<const E extends EnumDescription<A>>(definition: _CheckDefinition<E>): EnumExpose<A, E>;
+};
+export {};

package/dist/enum.mjs

@@ -0,0 +1,58 @@
+function defineEnum(definition) {
+  const keys = Object.keys(definition);
+  return {
+    ...[...Object.entries(definition)].reduce((acc, [key, dfn]) => {
+      if (key[0].toUpperCase() !== key[0]) {
+        throw new Error(`错误：枚举键名 ${key} 必须以大写字母开头`);
+      }
+      if (key.startsWith("$")) {
+        throw new Error(`错误：枚举键名 ${key} 不能以 $ 符号开头`);
+      }
+      acc[key] = dfn.value;
+      acc[`$${key}`] = { key, ...dfn };
+      return acc;
+    }, {}),
+    definition,
+    descriptions: keys.map((key) => ({
+      key,
+      ...definition[key]
+    })),
+    keys,
+    length: keys.length,
+    values: keys.map((key) => definition[key].value),
+    kvRecord: keys.reduce((acc, key) => {
+      acc[key] = definition[key].value;
+      return acc;
+    }, {}),
+    vkRecord: keys.reduce((acc, key) => {
+      acc[definition[key].value] = key;
+      return acc;
+    }, {}),
+    toKeyRecord(prop) {
+      return keys.reduce((acc, key) => {
+        acc[key] = definition[key][prop];
+        return acc;
+      }, {});
+    },
+    toValueRecord(prop) {
+      return keys.reduce(
+        (acc, key) => {
+          acc[definition[key].value] = definition[key][prop];
+          return acc;
+        },
+        {}
+      );
+    }
+  };
+}
+function declareEnum() {
+  return {
+    define(definition) {
+      return defineEnum(definition);
+    }
+  };
+}
+export {
+  declareEnum
+};
+//# sourceMappingURL=enum.mjs.map

package/dist/enum.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.mjs","sources":["../src/enum.ts"],"sourcesContent":["import type { AnyObject, MergeIntersection, UnionToIntersection, UnionToTuple } from './types';\n\nexport type EnumKey = string;\nexport type EnumValue = number | string;\nexport type EnumMetaAppend = {\n  key?: string;\n  value?: string | number;\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  [key: string]: any;\n};\nexport type EnumMeta<A extends EnumMetaAppend> = A & {\n  value: EnumValue;\n};\nexport type EnumDescription<A extends EnumMetaAppend> = Record<EnumKey, EnumMeta<A>>;\n\nconst enumError = Symbol('enumKeyError');\n\ntype _StartWithDollarSign<T extends string> = T extends `$${infer R}` ? R : never;\n\ntype _CheckDefinition<O extends AnyObject> = {\n  // [K in keyof O & string]: K extends Capitalize<K> ? O[K] : `错误：枚举键名 ${K} 必须大写字母开头`;\n  [K in keyof O & string]: K extends Capitalize<K>\n    ? K extends `$${infer R}`\n      ? O[K] & { [enumError]: `错误：枚举键名 ${K} 不能以 $ 符号开头` }\n      : O[K]\n    : O[K] & { [enumError]: `错误：枚举键名 ${K} 必须以大写字母开头` };\n};\n\ntype _ToOriginDefProp<T extends AnyObject> = {\n  [K in keyof T as `$${K & string}`]: MergeIntersection<T[K] & { readonly key: K }>;\n};\n\ntype _KVRecord<T> = T extends Record<string, AnyObject>\n  ? {\n      readonly [K in keyof T]: T[K]['value'];\n    }\n  : never;\n\ntype _VKRecord<T> = T extends Record<string, AnyObject>\n  ? MergeIntersection<\n      UnionToIntersection<\n        {\n          [K in keyof T]: {\n            [P in keyof T[K] as P extends 'value' ? T[K][P] & (string | number) : never]: K;\n          };\n        }[keyof T]\n      >\n    >\n  : never;\n\nexport type EnumExpose<A extends EnumMetaAppend, E extends EnumDescription<A>> = _ToOriginDefProp<E> &\n  _KVRecord<E> & {\n    readonly definition: E;\n    readonly descriptions: MergeIntersection<A & { key: keyof E }>[];\n    readonly keys: UnionToTuple<keyof E>;\n    readonly length: UnionToTuple<keyof E>['length'];\n    readonly values: UnionToTuple<E[keyof E]['value']>;\n    readonly kvRecord: _KVRecord<E>;\n    readonly vkRecord: _VKRecord<E>;\n    toKeyRecord: <P extends keyof A>(prop: P) => Record<keyof E, A[P]>;\n    toValueRecord: <P extends keyof A>(prop: P) => Record<E[keyof E]['value'], A[P]>;\n  };\n\n/**\n * 定义一个枚举类型，如果需要类型提示，需要使用 declareEnum 函数定义枚举。\n * @template A - 枚举元数据附加类型，扩展自 EnumMetaAppend\n * @template E - 枚举描述类型，键为枚举键名，值为枚举元数据\n * @param {_CheckDefinition<E>} definition - 枚举定义对象\n * @returns {EnumExpose<A, E>} 返回枚举的完整暴露对象\n * @example\n * ```typescript\n * const Status = defineEnum({\n *   Pending: { value: 0, label: '待处理' },\n *   Approved: { value: 1, label: '已批准' }\n * });\n * ```\n *\n * @property {E} definition - 原始枚举定义对象\n * @property {Array<MergeIntersection<A & { key: keyof E }>>} descriptions - 枚举项的完整描述数组\n * @property {UnionToTuple<keyof E>} keys - 枚举键名的元组\n * @property {\"UnionToTuple<keyof E>[\\\"length\\\"]\"} length - 枚举项的数量\n * @property {UnionToTuple<E[keyof E][\"value\"]>} values - 枚举值的元组\n * @property {Record<keyof E, E[keyof E][\"value\"]>} kvRecord - 键到值的映射记录\n * @property {Record<E[keyof E][\"value\"], E[keyof E]>} vkRecord - 值到键的映射记录\n * @property {function} toKeyRecord - 根据属性名创建键到属性值的映射记录\n * @property {function} toValueRecord - 根据属性名创建值到属性值的映射记录\n */\nfunction defineEnum<A extends EnumMetaAppend, const E extends EnumDescription<A>>(\n  definition: _CheckDefinition<E>,\n): EnumExpose<A, E> {\n  const keys = Object.keys(definition);\n\n  return {\n    ...[...Object.entries(definition)].reduce((acc, [key, dfn]) => {\n      if (key[0].toUpperCase() !== key[0]) {\n        throw new Error(`错误：枚举键名 ${key} 必须以大写字母开头`);\n      }\n\n      if (key.startsWith('$')) {\n        throw new Error(`错误：枚举键名 ${key} 不能以 $ 符号开头`);\n      }\n\n      // @ts-ignore\n      acc[key] = dfn.value;\n      // @ts-ignore\n      acc[`$${key}`] = { key, ...dfn };\n      return acc;\n    }, {}),\n    definition,\n    descriptions: keys.map((key) => ({\n      key,\n      ...definition[key],\n    })),\n    keys,\n    length: keys.length,\n    values: keys.map((key) => definition[key as keyof E].value),\n    kvRecord: keys.reduce((acc, key) => {\n      // @ts-ignore\n      acc[key] = definition[key].value;\n      return acc;\n    }, {}),\n    vkRecord: keys.reduce((acc, key) => {\n      // @ts-ignore\n      acc[definition[key].value] = key;\n      return acc;\n    }, {}),\n    toKeyRecord<P extends keyof A>(prop: P) {\n      return keys.reduce((acc, key) => {\n        // @ts-ignore\n        acc[key] = definition[key][prop];\n        return acc;\n      }, {});\n    },\n    toValueRecord<P extends keyof A>(prop: P) {\n      return keys.reduce(\n        (acc, key) => {\n          // @ts-ignore\n          acc[definition[key].value] = definition[key][prop];\n          return acc;\n        },\n        {} as Record<E[keyof E]['value'], A[P]>,\n      );\n    },\n  } as unknown as EnumExpose<A, E>;\n}\n\n/**\n * 声明一个枚举工厂函数\n * @template A - 枚举元数据附加类型，扩展自 EnumMetaAppend\n * @returns {Object} 返回包含 define 方法的对象\n *\n * @property {function} define - 定义枚举的函数\n *   @template E - 枚举描述类型\n *   @param {_CheckDefinition<E>} definition - 枚举定义对象\n *   @returns {EnumExpose<A, E>} 返回枚举的完整暴露对象\n *   @example\n *   ```typescript\n *   const createStatusEnum = declareEnum<{ label: string }>();\n *   const Status = createStatusEnum.define({\n *     Pending: { value: 0, label: '待处理' },\n *     Approved: { value: 1, label: '已批准' }\n *   });\n *   ```\n */\nexport function declareEnum<A extends EnumMetaAppend>() {\n  return {\n    define<const E extends EnumDescription<A>>(definition: _CheckDefinition<E>): EnumExpose<A, E> {\n      return defineEnum(definition);\n    },\n  };\n}\n"],"names":[],"mappings":"AAuFA,SAAS,WACP,YACkB;AACZ,QAAA,OAAO,OAAO,KAAK,UAAU;AAE5B,SAAA;AAAA,IACL,GAAG,CAAC,GAAG,OAAO,QAAQ,UAAU,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,GAAG,MAAM;AAC7D,UAAI,IAAI,CAAC,EAAE,kBAAkB,IAAI,CAAC,GAAG;AACnC,cAAM,IAAI,MAAM,WAAW,GAAG,YAAY;AAAA,MAAA;AAGxC,UAAA,IAAI,WAAW,GAAG,GAAG;AACvB,cAAM,IAAI,MAAM,WAAW,GAAG,aAAa;AAAA,MAAA;AAIzC,UAAA,GAAG,IAAI,IAAI;AAEf,UAAI,IAAI,GAAG,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI;AACxB,aAAA;AAAA,IACT,GAAG,EAAE;AAAA,IACL;AAAA,IACA,cAAc,KAAK,IAAI,CAAC,SAAS;AAAA,MAC/B;AAAA,MACA,GAAG,WAAW,GAAG;AAAA,IAAA,EACjB;AAAA,IACF;AAAA,IACA,QAAQ,KAAK;AAAA,IACb,QAAQ,KAAK,IAAI,CAAC,QAAQ,WAAW,GAAc,EAAE,KAAK;AAAA,IAC1D,UAAU,KAAK,OAAO,CAAC,KAAK,QAAQ;AAElC,UAAI,GAAG,IAAI,WAAW,GAAG,EAAE;AACpB,aAAA;AAAA,IACT,GAAG,EAAE;AAAA,IACL,UAAU,KAAK,OAAO,CAAC,KAAK,QAAQ;AAElC,UAAI,WAAW,GAAG,EAAE,KAAK,IAAI;AACtB,aAAA;AAAA,IACT,GAAG,EAAE;AAAA,IACL,YAA+B,MAAS;AACtC,aAAO,KAAK,OAAO,CAAC,KAAK,QAAQ;AAE/B,YAAI,GAAG,IAAI,WAAW,GAAG,EAAE,IAAI;AACxB,eAAA;AAAA,MACT,GAAG,EAAE;AAAA,IACP;AAAA,IACA,cAAiC,MAAS;AACxC,aAAO,KAAK;AAAA,QACV,CAAC,KAAK,QAAQ;AAER,cAAA,WAAW,GAAG,EAAE,KAAK,IAAI,WAAW,GAAG,EAAE,IAAI;AAC1C,iBAAA;AAAA,QACT;AAAA,QACA,CAAA;AAAA,MACF;AAAA,IAAA;AAAA,EAEJ;AACF;AAoBO,SAAS,cAAwC;AAC/C,SAAA;AAAA,IACL,OAA2C,YAAmD;AAC5F,aAAO,WAAW,UAAU;AAAA,IAAA;AAAA,EAEhC;AACF;"}

package/dist/env.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("./type.cjs");
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function isNode() {
+  return typeof process !== "undefined" && !type.isNullish(process.versions) && !type.isNullish(process.versions.node);
+}
+function isWorker() {
+  return typeof self !== "undefined" && self.importScripts != null;
+}
+function isMacOS() {
+  return isBrowser() ? /^mac/i.test(navigator.platform) : isNode() ? /^darwin/i.test(process.platform) : false;
+}
+function isLinux() {
+  return isBrowser() ? /^linux/i.test(navigator.platform) : isNode() ? /^linux/i.test(process.platform) : false;
+}
+function isWindows() {
+  return isBrowser() ? /^win/i.test(navigator.platform) : isNode() ? /^win/i.test(process.platform) : false;
+}
+exports.isBrowser = isBrowser;
+exports.isLinux = isLinux;
+exports.isMacOS = isMacOS;
+exports.isNode = isNode;
+exports.isWindows = isWindows;
+exports.isWorker = isWorker;
+//# sourceMappingURL=env.cjs.map

package/dist/env.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.cjs","sources":["../src/env.ts"],"sourcesContent":["import { isNullish } from './type';\n\n/**\n * 判断当前环境是否为浏览器环境\n * @returns 如果是浏览器环境返回 true，否则返回 false\n */\nexport function isBrowser() {\n  if (IS_TEST) return TEST_MOCK.IS_BROWSER || false;\n\n  return typeof window !== 'undefined' && typeof document !== 'undefined';\n}\n\n/**\n * 判断当前环境是否为 Node.js 环境\n * @returns 如果是 Node.js 环境返回 true，否则返回 false\n */\nexport function isNode() {\n  if (IS_TEST) return TEST_MOCK.IS_NODE || false;\n\n  return typeof process !== 'undefined' && !isNullish(process.versions) && !isNullish(process.versions.node);\n}\n\n/**\n * 判断当前环境是否为 Web Worker 环境\n * @returns 如果是 Web Worker 环境返回 true，否则返回 false\n * @remarks\n * 使用 @ts-ignore 忽略 self 的类型检查，因为 self 在 Web Worker 中可用但在其他环境中可能未定义\n */\nexport function isWorker() {\n  // @ts-ignore\n  return typeof self !== 'undefined' && self.importScripts != null;\n}\n\n/**\n * 判断当前操作系统是否为 macOS\n * @returns 如果是 macOS 返回 true，否则返回 false\n * @remarks\n * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测\n */\nexport function isMacOS() {\n  return isBrowser() ? /^mac/i.test(navigator.platform) : isNode() ? /^darwin/i.test(process.platform) : false;\n}\n\n/**\n * 判断当前操作系统是否为 Linux\n * @returns 如果是 Linux 返回 true，否则返回 false\n * @remarks\n * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测\n */\nexport function isLinux() {\n  return isBrowser() ? /^linux/i.test(navigator.platform) : isNode() ? /^linux/i.test(process.platform) : false;\n}\n\n/**\n * 判断当前操作系统是否为 Windows\n * @returns 如果是 Windows 返回 true，否则返回 false\n * @remarks\n * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测\n */\nexport function isWindows() {\n  return isBrowser() ? /^win/i.test(navigator.platform) : isNode() ? /^win/i.test(process.platform) : false;\n}\n"],"names":["isNullish"],"mappings":";;;AAMO,SAAS,YAAY;AAG1B,SAAO,OAAO,WAAW,eAAe,OAAO,aAAa;AAC9D;AAMO,SAAS,SAAS;AAGvB,SAAO,OAAO,YAAY,eAAe,CAACA,KAAU,UAAA,QAAQ,QAAQ,KAAK,CAACA,KAAA,UAAU,QAAQ,SAAS,IAAI;AAC3G;AAQO,SAAS,WAAW;AAEzB,SAAO,OAAO,SAAS,eAAe,KAAK,iBAAiB;AAC9D;AAQO,SAAS,UAAU;AACxB,SAAO,UAAU,IAAI,QAAQ,KAAK,UAAU,QAAQ,IAAI,OAAA,IAAW,WAAW,KAAK,QAAQ,QAAQ,IAAI;AACzG;AAQO,SAAS,UAAU;AACxB,SAAO,UAAU,IAAI,UAAU,KAAK,UAAU,QAAQ,IAAI,OAAA,IAAW,UAAU,KAAK,QAAQ,QAAQ,IAAI;AAC1G;AAQO,SAAS,YAAY;AAC1B,SAAO,UAAU,IAAI,QAAQ,KAAK,UAAU,QAAQ,IAAI,OAAA,IAAW,QAAQ,KAAK,QAAQ,QAAQ,IAAI;AACtG;;;;;;;"}

package/{src/env.ts → dist/env.d.ts}

@@ -1,62 +1,38 @@
-import { isNullish } from './type';
-
 /**
  * 判断当前环境是否为浏览器环境
  * @returns 如果是浏览器环境返回 true，否则返回 false
  */
-export function isBrowser() {
-  if (IS_TEST) return TEST_MOCK.IS_BROWSER || false;
-
-  return typeof window !== 'undefined' && typeof document !== 'undefined';
-}
-
+export declare function isBrowser(): boolean;
 /**
  * 判断当前环境是否为 Node.js 环境
  * @returns 如果是 Node.js 环境返回 true，否则返回 false
  */
-export function isNode() {
-  if (IS_TEST) return TEST_MOCK.IS_NODE || false;
-
-  return typeof process !== 'undefined' && !isNullish(process.versions) && !isNullish(process.versions.node);
-}
-
+export declare function isNode(): boolean;
 /**
  * 判断当前环境是否为 Web Worker 环境
  * @returns 如果是 Web Worker 环境返回 true，否则返回 false
  * @remarks
  * 使用 @ts-ignore 忽略 self 的类型检查，因为 self 在 Web Worker 中可用但在其他环境中可能未定义
  */
-export function isWorker() {
-  // @ts-ignore
-  return typeof self !== 'undefined' && self.importScripts != null;
-}
-
+export declare function isWorker(): boolean;
 /**
  * 判断当前操作系统是否为 macOS
  * @returns 如果是 macOS 返回 true，否则返回 false
  * @remarks
  * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测
  */
-export function isMacOS() {
-  return isBrowser() ? /^mac/i.test(navigator.platform) : isNode() ? /^darwin/i.test(process.platform) : false;
-}
-
+export declare function isMacOS(): boolean;
 /**
  * 判断当前操作系统是否为 Linux
  * @returns 如果是 Linux 返回 true，否则返回 false
  * @remarks
  * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测
  */
-export function isLinux() {
-  return isBrowser() ? /^linux/i.test(navigator.platform) : isNode() ? /^linux/i.test(process.platform) : false;
-}
-
+export declare function isLinux(): boolean;
 /**
  * 判断当前操作系统是否为 Windows
  * @returns 如果是 Windows 返回 true，否则返回 false
  * @remarks
  * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测
  */
-export function isWindows() {
-  return isBrowser() ? /^win/i.test(navigator.platform) : isNode() ? /^win/i.test(process.platform) : false;
-}
+export declare function isWindows(): boolean;

package/dist/env.mjs

@@ -0,0 +1,28 @@
+import { isNullish } from "./type.mjs";
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function isNode() {
+  return typeof process !== "undefined" && !isNullish(process.versions) && !isNullish(process.versions.node);
+}
+function isWorker() {
+  return typeof self !== "undefined" && self.importScripts != null;
+}
+function isMacOS() {
+  return isBrowser() ? /^mac/i.test(navigator.platform) : isNode() ? /^darwin/i.test(process.platform) : false;
+}
+function isLinux() {
+  return isBrowser() ? /^linux/i.test(navigator.platform) : isNode() ? /^linux/i.test(process.platform) : false;
+}
+function isWindows() {
+  return isBrowser() ? /^win/i.test(navigator.platform) : isNode() ? /^win/i.test(process.platform) : false;
+}
+export {
+  isBrowser,
+  isLinux,
+  isMacOS,
+  isNode,
+  isWindows,
+  isWorker
+};
+//# sourceMappingURL=env.mjs.map

package/dist/env.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.mjs","sources":["../src/env.ts"],"sourcesContent":["import { isNullish } from './type';\n\n/**\n * 判断当前环境是否为浏览器环境\n * @returns 如果是浏览器环境返回 true，否则返回 false\n */\nexport function isBrowser() {\n  if (IS_TEST) return TEST_MOCK.IS_BROWSER || false;\n\n  return typeof window !== 'undefined' && typeof document !== 'undefined';\n}\n\n/**\n * 判断当前环境是否为 Node.js 环境\n * @returns 如果是 Node.js 环境返回 true，否则返回 false\n */\nexport function isNode() {\n  if (IS_TEST) return TEST_MOCK.IS_NODE || false;\n\n  return typeof process !== 'undefined' && !isNullish(process.versions) && !isNullish(process.versions.node);\n}\n\n/**\n * 判断当前环境是否为 Web Worker 环境\n * @returns 如果是 Web Worker 环境返回 true，否则返回 false\n * @remarks\n * 使用 @ts-ignore 忽略 self 的类型检查，因为 self 在 Web Worker 中可用但在其他环境中可能未定义\n */\nexport function isWorker() {\n  // @ts-ignore\n  return typeof self !== 'undefined' && self.importScripts != null;\n}\n\n/**\n * 判断当前操作系统是否为 macOS\n * @returns 如果是 macOS 返回 true，否则返回 false\n * @remarks\n * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测\n */\nexport function isMacOS() {\n  return isBrowser() ? /^mac/i.test(navigator.platform) : isNode() ? /^darwin/i.test(process.platform) : false;\n}\n\n/**\n * 判断当前操作系统是否为 Linux\n * @returns 如果是 Linux 返回 true，否则返回 false\n * @remarks\n * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测\n */\nexport function isLinux() {\n  return isBrowser() ? /^linux/i.test(navigator.platform) : isNode() ? /^linux/i.test(process.platform) : false;\n}\n\n/**\n * 判断当前操作系统是否为 Windows\n * @returns 如果是 Windows 返回 true，否则返回 false\n * @remarks\n * 在浏览器环境中通过 navigator.platform 检测，在 Node.js 环境中通过 process.platform 检测\n */\nexport function isWindows() {\n  return isBrowser() ? /^win/i.test(navigator.platform) : isNode() ? /^win/i.test(process.platform) : false;\n}\n"],"names":[],"mappings":";AAMO,SAAS,YAAY;AAG1B,SAAO,OAAO,WAAW,eAAe,OAAO,aAAa;AAC9D;AAMO,SAAS,SAAS;AAGvB,SAAO,OAAO,YAAY,eAAe,CAAC,UAAU,QAAQ,QAAQ,KAAK,CAAC,UAAU,QAAQ,SAAS,IAAI;AAC3G;AAQO,SAAS,WAAW;AAEzB,SAAO,OAAO,SAAS,eAAe,KAAK,iBAAiB;AAC9D;AAQO,SAAS,UAAU;AACxB,SAAO,UAAU,IAAI,QAAQ,KAAK,UAAU,QAAQ,IAAI,OAAA,IAAW,WAAW,KAAK,QAAQ,QAAQ,IAAI;AACzG;AAQO,SAAS,UAAU;AACxB,SAAO,UAAU,IAAI,UAAU,KAAK,UAAU,QAAQ,IAAI,OAAA,IAAW,UAAU,KAAK,QAAQ,QAAQ,IAAI;AAC1G;AAQO,SAAS,YAAY;AAC1B,SAAO,UAAU,IAAI,QAAQ,KAAK,UAAU,QAAQ,IAAI,OAAA,IAAW,QAAQ,KAAK,QAAQ,QAAQ,IAAI;AACtG;"}

package/dist/error.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("./type.cjs");
+function errorNormalize(throwError) {
+  return type.isError(throwError) ? throwError : new Error(String(type.isNullish(throwError) ? "" : throwError));
+}
+function errorAssign(error, source) {
+  return Object.assign(error, source);
+}
+exports.errorAssign = errorAssign;
+exports.errorNormalize = errorNormalize;
+//# sourceMappingURL=error.cjs.map

package/dist/error.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.cjs","sources":["../src/error.ts"],"sourcesContent":["import { isError, isNullish } from './type';\nimport type { AnyObject } from './types';\n\n/**\n * 标准化处理 Error 对象，适用于 try-catch\n * @param throwError 接收抛出的错误字符串或者 Error 对象或字符串\n * @returns {Error}\n * @example\n * const error = errorNormalize('这是一个错误');\n * console.log(error.message); // 输出: 这是一个错误\n */\nexport function errorNormalize<E extends Error | unknown = unknown>(throwError: E) {\n  return (\n    isError(throwError) ? throwError : new Error(String(isNullish(throwError) ? '' : throwError))\n  ) as E extends Error ? E : Error;\n}\n\n/**\n * 分配对象到 Error 对象上，适用于扩展 Error 实例，不影响原型和构造函数\n * @param {Error} error\n * @param {E} source\n * @returns {Error & E}\n * @example\n * const error = new Error('原始错误');\n * const extendedError = errorAssign(error, { code: 404, message: '未找到资源' });\n * console.log(extendedError.code); // 输出: 404\n * console.log(extendedError.message); // 输出: 未找到资源\n */\nexport function errorAssign<E extends AnyObject>(error: Error, source: E): Error & E {\n  return Object.assign(error, source) as Error & E;\n}\n"],"names":["isError","isNullish"],"mappings":";;;AAWO,SAAS,eAAoD,YAAe;AACjF,SACEA,aAAQ,UAAU,IAAI,aAAa,IAAI,MAAM,OAAOC,KAAAA,UAAU,UAAU,IAAI,KAAK,UAAU,CAAC;AAEhG;AAagB,SAAA,YAAiC,OAAc,QAAsB;AAC5E,SAAA,OAAO,OAAO,OAAO,MAAM;AACpC;;;"}

package/{src/error.ts → dist/error.d.ts}

@@ -1,6 +1,4 @@
-import { isError, isNullish } from './type';
-import type { AnyObject } from './types';
-
+import { AnyObject } from './types';
 /**
  * 标准化处理 Error 对象，适用于 try-catch
  * @param throwError 接收抛出的错误字符串或者 Error 对象或字符串
@@ -9,12 +7,7 @@ import type { AnyObject } from './types';
  * const error = errorNormalize('这是一个错误');
  * console.log(error.message); // 输出: 这是一个错误
  */
-export function errorNormalize<E extends Error | unknown = unknown>(throwError: E) {
-  return (
-    isError(throwError) ? throwError : new Error(String(isNullish(throwError) ? '' : throwError))
-  ) as E extends Error ? E : Error;
-}
-
+export declare function errorNormalize<E extends Error | unknown = unknown>(throwError: E): E extends Error ? E : Error;
 /**
  * 分配对象到 Error 对象上，适用于扩展 Error 实例，不影响原型和构造函数
  * @param {Error} error
@@ -26,6 +19,4 @@ export function errorNormalize<E extends Error | unknown = unknown>(throwError:
  * console.log(extendedError.code); // 输出: 404
  * console.log(extendedError.message); // 输出: 未找到资源
  */
-export function errorAssign<E extends AnyObject>(error: Error, source: E): Error & E {
-  return Object.assign(error, source) as Error & E;
-}
+export declare function errorAssign<E extends AnyObject>(error: Error, source: E): Error & E;

package/dist/error.mjs

@@ -0,0 +1,12 @@
+import { isError, isNullish } from "./type.mjs";
+function errorNormalize(throwError) {
+  return isError(throwError) ? throwError : new Error(String(isNullish(throwError) ? "" : throwError));
+}
+function errorAssign(error, source) {
+  return Object.assign(error, source);
+}
+export {
+  errorAssign,
+  errorNormalize
+};
+//# sourceMappingURL=error.mjs.map

package/dist/error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.mjs","sources":["../src/error.ts"],"sourcesContent":["import { isError, isNullish } from './type';\nimport type { AnyObject } from './types';\n\n/**\n * 标准化处理 Error 对象，适用于 try-catch\n * @param throwError 接收抛出的错误字符串或者 Error 对象或字符串\n * @returns {Error}\n * @example\n * const error = errorNormalize('这是一个错误');\n * console.log(error.message); // 输出: 这是一个错误\n */\nexport function errorNormalize<E extends Error | unknown = unknown>(throwError: E) {\n  return (\n    isError(throwError) ? throwError : new Error(String(isNullish(throwError) ? '' : throwError))\n  ) as E extends Error ? E : Error;\n}\n\n/**\n * 分配对象到 Error 对象上，适用于扩展 Error 实例，不影响原型和构造函数\n * @param {Error} error\n * @param {E} source\n * @returns {Error & E}\n * @example\n * const error = new Error('原始错误');\n * const extendedError = errorAssign(error, { code: 404, message: '未找到资源' });\n * console.log(extendedError.code); // 输出: 404\n * console.log(extendedError.message); // 输出: 未找到资源\n */\nexport function errorAssign<E extends AnyObject>(error: Error, source: E): Error & E {\n  return Object.assign(error, source) as Error & E;\n}\n"],"names":[],"mappings":";AAWO,SAAS,eAAoD,YAAe;AACjF,SACE,QAAQ,UAAU,IAAI,aAAa,IAAI,MAAM,OAAO,UAAU,UAAU,IAAI,KAAK,UAAU,CAAC;AAEhG;AAagB,SAAA,YAAiC,OAAc,QAAsB;AAC5E,SAAA,OAAO,OAAO,OAAO,MAAM;AACpC;"}

package/dist/exception.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const merge = require("./merge.cjs");
+const defaults = {
+  /**
+   * 默认消息格式函数
+   * @default (name, message) => `[${name}] ${message}`
+   */
+  format: (name, message) => `[${name}] ${message}`
+};
+function buildException(name, options) {
+  const { format } = merge.objectDefaults(options || {}, defaults);
+  return class extends Error {
+    constructor(message, extra) {
+      super(format(name, message));
+      this.name = name;
+      Object.assign(this, extra);
+    }
+  };
+}
+exports.buildException = buildException;
+//# sourceMappingURL=exception.cjs.map

package/dist/exception.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"exception.cjs","sources":["../src/exception.ts"],"sourcesContent":["import { objectDefaults } from './object';\nimport type { AnyObject } from './types';\n\n/**\n * 构建异常选项\n */\nexport type BuildExceptionOptions = {\n  /**\n   * 自定义错误消息格式函数\n   * @param name 错误名称\n   * @param message 原始错误消息\n   * @returns 格式化后的错误消息\n   * @example\n   * (name, message) => `${name}::${message}`\n   */\n  format?: (name: string, message: string) => string;\n};\n\n/**\n * 默认的异常构建选项\n */\nconst defaults: BuildExceptionOptions = {\n  /**\n   * 默认消息格式函数\n   * @default (name, message) => `[${name}] ${message}`\n   */\n  format: (name, message) => `[${name}] ${message}`,\n};\n\n/**\n * 构建自定义异常类\n * @template T 额外属性的类型\n * @param name 异常类名称\n * @param options 构建选项\n * @returns 自定义异常类\n * @example\n * const MyException = buildException<{ code: number }>('MyException');\n * const err = new MyException('error', { code: 404 });\n *\n * @example\n * const SimpleException = buildException('SimpleException');\n * const err = new SimpleException('error', undefined);\n */\nexport function buildException<T = void>(name: string, options?: BuildExceptionOptions) {\n  const { format } = objectDefaults(options || {}, defaults) as Required<BuildExceptionOptions>;\n\n  return class extends Error {\n    constructor(message: string, extra: T) {\n      super(format(name, message));\n      this.name = name;\n      Object.assign(this, extra);\n    }\n  } as unknown as {\n    new (message: string, extra: T): Error & T;\n  };\n}\n\n// const MyException = buildException<{ foo: string; bar: number }>('MyException: ');\n// const myException = new MyException('bar', { foo: '1', bar: 1 });\n// myException.foo;\n// myException.bar;\n// myException.name;\n// myException.message;\n// myException.stack;\n// myException.cause;\n\n// const MyException2 = buildException('MyException2: ');\n// const myException2 = new MyException2('bar');\n"],"names":["objectDefaults"],"mappings":";;;AAqBA,MAAM,WAAkC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKtC,QAAQ,CAAC,MAAM,YAAY,IAAI,IAAI,KAAK,OAAO;AACjD;AAgBgB,SAAA,eAAyB,MAAc,SAAiC;AACtF,QAAM,EAAE,OAAO,IAAIA,MAAAA,eAAe,WAAW,CAAA,GAAI,QAAQ;AAEzD,SAAO,cAAc,MAAM;AAAA,IACzB,YAAY,SAAiB,OAAU;AAC/B,YAAA,OAAO,MAAM,OAAO,CAAC;AAC3B,WAAK,OAAO;AACL,aAAA,OAAO,MAAM,KAAK;AAAA,IAAA;AAAA,EAE7B;AAGF;;"}