@cloudcome/utils-core 1.1.1 → 1.2.0

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

@@ -1,158 +1,93 @@
-import type { AnyArray, AnyAsyncFunction, AnyFunction, AnyObject } from './types';
-
+import { AnyArray, AnyAsyncFunction, AnyFunction, AnyObject } from './types';
 /**
  * 获取未知类型的类型名称
  * @param unknown - 未知类型的值
  * @returns 类型名称字符串
  */
-export function typeIs(
-  unknown: unknown,
-):
-  | 'string'
-  | 'number'
-  | 'boolean'
-  | 'object'
-  | 'array'
-  | 'function'
-  | 'null'
-  | 'undefined'
-  | 'symbol'
-  | 'bigint'
-  | 'error'
-  | 'promise'
-  | string {
-  return Object.prototype.toString.call(unknown).slice(8, -1).toLowerCase();
-}
-
+export declare function typeIs(unknown: unknown): 'string' | 'number' | 'boolean' | 'object' | 'array' | 'function' | 'null' | 'undefined' | 'symbol' | 'bigint' | 'error' | 'promise' | string;
 /**
  * 检查值是否为字符串
  * @param unknown - 未知类型的值
  * @returns 如果值为字符串则返回 true，否则返回 false
  */
-export function isString(unknown: unknown): unknown is string {
-  return typeof unknown === 'string';
-}
-
+export declare function isString(unknown: unknown): unknown is string;
 /**
  * 检查值是否为布尔值
  * @param unknown - 未知类型的值
  * @returns 如果值为布尔值则返回 true，否则返回 false
  */
-export function isBoolean(unknown: unknown): unknown is boolean {
-  return typeof unknown === 'boolean';
-}
-
+export declare function isBoolean(unknown: unknown): unknown is boolean;
 /**
  * 检查值是否为符号
  * @param unknown - 未知类型的值
  * @returns 如果值为符号则返回 true，否则返回 false
  */
-export function isSymbol(unknown: unknown): unknown is symbol {
-  return typeof unknown === 'symbol';
-}
-
+export declare function isSymbol(unknown: unknown): unknown is symbol;
 /**
  * 检查值是否为大整数
  * @param unknown - 未知类型的值
  * @returns 如果值为大整数则返回 true，否则返回 false
  */
-export function isBigInt(unknown: unknown): unknown is bigint {
-  return typeof unknown === 'bigint';
-}
-
+export declare function isBigInt(unknown: unknown): unknown is bigint;
 /**
  * 检查值是否为数字
  * @param unknown - 未知类型的值
  * @returns 如果值为数字且不是 NaN 则返回 true，否则返回 false
  */
-export function isNumber(unknown: unknown): unknown is number {
-  return typeof unknown === 'number' && !Number.isNaN(unknown);
-}
-
+export declare function isNumber(unknown: unknown): unknown is number;
 /**
  * 检查值是否为 undefined
  * @param unknown - 未知类型的值
  * @returns 如果值为 undefined 则返回 true，否则返回 false
  */
-export function isUndefined(unknown: unknown): unknown is undefined {
-  return typeof unknown === 'undefined';
-}
-
+export declare function isUndefined(unknown: unknown): unknown is undefined;
 /**
  * 检查值是否为 void
  * @param unknown - 未知类型的值
  * @returns 如果值为 undefined 则返回 true，否则返回 false
  */
-// biome-ignore lint/suspicious/noConfusingVoidType: <explanation>
-export function isVoid(unknown: unknown): unknown is void {
-  return isUndefined(unknown);
-}
-
+export declare function isVoid(unknown: unknown): unknown is void;
 /**
  * 永不执行，用于 switch-case/if-else 类型断言
  * @param unknown - 永远不会执行的值
  */
-export function isNever(unknown: never) {
-  //
-}
-
+export declare function isNever(unknown: never): void;
 /**
  * 检查值是否为 null
  * @param unknown - 未知类型的值
  * @returns 如果值为 null 则返回 true，否则返回 false
  */
-export function isNull(unknown: unknown): unknown is null {
-  return unknown === null;
-}
-
+export declare function isNull(unknown: unknown): unknown is null;
 /**
  * 检查值是否为 nullish（null 或 undefined 或 void）
  * @param unknown - 未知类型的值
  * @returns 如果值为 null 或 undefined 或 void 则返回 true，否则返回 false
  */
-// biome-ignore lint/suspicious/noConfusingVoidType: <explanation>
-export function isNullish(unknown: unknown): unknown is null | undefined | void {
-  return isNull(unknown) || isUndefined(unknown) || isVoid(unknown);
-}
-
+export declare function isNullish(unknown: unknown): unknown is null | undefined | void;
 /**
  * 检查值是否为原始类型（null 或 非对象）
  * @param unknown - 未知类型的值
  * @returns 如果值为原始类型则返回 true，否则返回 false
  */
-export function isPrimitive(
-  unknown: unknown,
-): unknown is string | number | boolean | symbol | bigint | null | undefined {
-  return isNull(unknown) || !(typeof unknown === 'object' || typeof unknown === 'function');
-}
-
+export declare function isPrimitive(unknown: unknown): unknown is string | number | boolean | symbol | bigint | null | undefined;
 /**
  * 检查值是否为对象，但要注意，此时的对象类型是包含了数组和函数
  * @param unknown - 未知类型的值
  * @returns 如果值为对象则返回 true，否则返回 false
  */
-export function isObject(unknown: unknown): unknown is AnyObject {
-  return typeIs(unknown) === 'object';
-}
-
+export declare function isObject(unknown: unknown): unknown is AnyObject;
 /**
  * 检查值是否为数组
  * @param unknown - 未知类型的值
  * @returns 如果值为数组则返回 true，否则返回 false
  */
-export function isArray(unknown: unknown): unknown is AnyArray {
-  return Array.isArray(unknown);
-}
-
+export declare function isArray(unknown: unknown): unknown is AnyArray;
 /**
  * 检查值是否为函数
  * @param unknown - 未知类型的值
  * @returns 如果值为函数则返回 true，否则返回 false
  */
-export function isFunction(unknown: unknown): unknown is AnyFunction {
-  return typeof unknown === 'function';
-}
-
+export declare function isFunction(unknown: unknown): unknown is AnyFunction;
 /**
  * 检查值是否为异步函数
  * @param unknown - 需要检查的值
@@ -165,33 +100,22 @@ export function isFunction(unknown: unknown): unknown is AnyFunction {
  * isAsyncFunction(() => {}); // false
  * ```
  */
-export function isAsyncFunction(unknown: unknown): unknown is AnyAsyncFunction {
-  return isFunction(unknown) && unknown.constructor.name === 'AsyncFunction';
-}
-
+export declare function isAsyncFunction(unknown: unknown): unknown is AnyAsyncFunction;
 /**
  * 检查值是否为 Error 类型
  * @param unknown - 未知类型的值
  * @returns 如果值为 Error 类型则返回 true，否则返回 false
  */
-export function isError(unknown: unknown): unknown is Error {
-  return unknown instanceof Error;
-}
-
+export declare function isError(unknown: unknown): unknown is Error;
 /**
  * 检查值是否为 Promise 类型
  * @param unknown - 未知类型的值
  * @returns 如果值为 Promise 类型则返回 true，否则返回 false
  */
-export function isPromise<T>(unknown: unknown): unknown is Promise<T> {
-  return typeIs(unknown) === 'promise';
-}
-
+export declare function isPromise<T>(unknown: unknown): unknown is Promise<T>;
 /**
  * 检查值是否为 Date 类型
  * @param unknown - 未知类型的值
  * @returns 如果值为 Date 类型则返回 true，否则返回 false
  */
-export function isDate(unknown: unknown): unknown is Date {
-  return unknown instanceof Date;
-}
+export declare function isDate(unknown: unknown): unknown is Date;

package/dist/type.mjs

@@ -0,0 +1,78 @@
+function typeIs(unknown) {
+  return Object.prototype.toString.call(unknown).slice(8, -1).toLowerCase();
+}
+function isString(unknown) {
+  return typeof unknown === "string";
+}
+function isBoolean(unknown) {
+  return typeof unknown === "boolean";
+}
+function isSymbol(unknown) {
+  return typeof unknown === "symbol";
+}
+function isBigInt(unknown) {
+  return typeof unknown === "bigint";
+}
+function isNumber(unknown) {
+  return typeof unknown === "number" && !Number.isNaN(unknown);
+}
+function isUndefined(unknown) {
+  return typeof unknown === "undefined";
+}
+function isVoid(unknown) {
+  return isUndefined(unknown);
+}
+function isNever(unknown) {
+}
+function isNull(unknown) {
+  return unknown === null;
+}
+function isNullish(unknown) {
+  return isNull(unknown) || isUndefined(unknown) || isVoid(unknown);
+}
+function isPrimitive(unknown) {
+  return isNull(unknown) || !(typeof unknown === "object" || typeof unknown === "function");
+}
+function isObject(unknown) {
+  return typeIs(unknown) === "object";
+}
+function isArray(unknown) {
+  return Array.isArray(unknown);
+}
+function isFunction(unknown) {
+  return typeof unknown === "function";
+}
+function isAsyncFunction(unknown) {
+  return isFunction(unknown) && unknown.constructor.name === "AsyncFunction";
+}
+function isError(unknown) {
+  return unknown instanceof Error;
+}
+function isPromise(unknown) {
+  return typeIs(unknown) === "promise";
+}
+function isDate(unknown) {
+  return unknown instanceof Date;
+}
+export {
+  isArray,
+  isAsyncFunction,
+  isBigInt,
+  isBoolean,
+  isDate,
+  isError,
+  isFunction,
+  isNever,
+  isNull,
+  isNullish,
+  isNumber,
+  isObject,
+  isPrimitive,
+  isPromise,
+  isString,
+  isSymbol,
+  isUndefined,
+  isVoid,
+  typeIs
+};
+//# sourceMappingURL=type.mjs.map

package/dist/type.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.mjs","sources":["../src/type.ts"],"sourcesContent":["import type { AnyArray, AnyAsyncFunction, AnyFunction, AnyObject } from './types';\n\n/**\n * 获取未知类型的类型名称\n * @param unknown - 未知类型的值\n * @returns 类型名称字符串\n */\nexport function typeIs(\n  unknown: unknown,\n):\n  | 'string'\n  | 'number'\n  | 'boolean'\n  | 'object'\n  | 'array'\n  | 'function'\n  | 'null'\n  | 'undefined'\n  | 'symbol'\n  | 'bigint'\n  | 'error'\n  | 'promise'\n  | string {\n  return Object.prototype.toString.call(unknown).slice(8, -1).toLowerCase();\n}\n\n/**\n * 检查值是否为字符串\n * @param unknown - 未知类型的值\n * @returns 如果值为字符串则返回 true，否则返回 false\n */\nexport function isString(unknown: unknown): unknown is string {\n  return typeof unknown === 'string';\n}\n\n/**\n * 检查值是否为布尔值\n * @param unknown - 未知类型的值\n * @returns 如果值为布尔值则返回 true，否则返回 false\n */\nexport function isBoolean(unknown: unknown): unknown is boolean {\n  return typeof unknown === 'boolean';\n}\n\n/**\n * 检查值是否为符号\n * @param unknown - 未知类型的值\n * @returns 如果值为符号则返回 true，否则返回 false\n */\nexport function isSymbol(unknown: unknown): unknown is symbol {\n  return typeof unknown === 'symbol';\n}\n\n/**\n * 检查值是否为大整数\n * @param unknown - 未知类型的值\n * @returns 如果值为大整数则返回 true，否则返回 false\n */\nexport function isBigInt(unknown: unknown): unknown is bigint {\n  return typeof unknown === 'bigint';\n}\n\n/**\n * 检查值是否为数字\n * @param unknown - 未知类型的值\n * @returns 如果值为数字且不是 NaN 则返回 true，否则返回 false\n */\nexport function isNumber(unknown: unknown): unknown is number {\n  return typeof unknown === 'number' && !Number.isNaN(unknown);\n}\n\n/**\n * 检查值是否为 undefined\n * @param unknown - 未知类型的值\n * @returns 如果值为 undefined 则返回 true，否则返回 false\n */\nexport function isUndefined(unknown: unknown): unknown is undefined {\n  return typeof unknown === 'undefined';\n}\n\n/**\n * 检查值是否为 void\n * @param unknown - 未知类型的值\n * @returns 如果值为 undefined 则返回 true，否则返回 false\n */\n// biome-ignore lint/suspicious/noConfusingVoidType: <explanation>\nexport function isVoid(unknown: unknown): unknown is void {\n  return isUndefined(unknown);\n}\n\n/**\n * 永不执行，用于 switch-case/if-else 类型断言\n * @param unknown - 永远不会执行的值\n */\nexport function isNever(unknown: never) {\n  //\n}\n\n/**\n * 检查值是否为 null\n * @param unknown - 未知类型的值\n * @returns 如果值为 null 则返回 true，否则返回 false\n */\nexport function isNull(unknown: unknown): unknown is null {\n  return unknown === null;\n}\n\n/**\n * 检查值是否为 nullish（null 或 undefined 或 void）\n * @param unknown - 未知类型的值\n * @returns 如果值为 null 或 undefined 或 void 则返回 true，否则返回 false\n */\n// biome-ignore lint/suspicious/noConfusingVoidType: <explanation>\nexport function isNullish(unknown: unknown): unknown is null | undefined | void {\n  return isNull(unknown) || isUndefined(unknown) || isVoid(unknown);\n}\n\n/**\n * 检查值是否为原始类型（null 或 非对象）\n * @param unknown - 未知类型的值\n * @returns 如果值为原始类型则返回 true，否则返回 false\n */\nexport function isPrimitive(\n  unknown: unknown,\n): unknown is string | number | boolean | symbol | bigint | null | undefined {\n  return isNull(unknown) || !(typeof unknown === 'object' || typeof unknown === 'function');\n}\n\n/**\n * 检查值是否为对象，但要注意，此时的对象类型是包含了数组和函数\n * @param unknown - 未知类型的值\n * @returns 如果值为对象则返回 true，否则返回 false\n */\nexport function isObject(unknown: unknown): unknown is AnyObject {\n  return typeIs(unknown) === 'object';\n}\n\n/**\n * 检查值是否为数组\n * @param unknown - 未知类型的值\n * @returns 如果值为数组则返回 true，否则返回 false\n */\nexport function isArray(unknown: unknown): unknown is AnyArray {\n  return Array.isArray(unknown);\n}\n\n/**\n * 检查值是否为函数\n * @param unknown - 未知类型的值\n * @returns 如果值为函数则返回 true，否则返回 false\n */\nexport function isFunction(unknown: unknown): unknown is AnyFunction {\n  return typeof unknown === 'function';\n}\n\n/**\n * 检查值是否为异步函数\n * @param unknown - 需要检查的值\n * @returns 如果值为异步函数则返回 true，否则返回 false\n * @example\n * ```typescript\n * async function example() {}\n *\n * isAsyncFunction(example); // true\n * isAsyncFunction(() => {}); // false\n * ```\n */\nexport function isAsyncFunction(unknown: unknown): unknown is AnyAsyncFunction {\n  return isFunction(unknown) && unknown.constructor.name === 'AsyncFunction';\n}\n\n/**\n * 检查值是否为 Error 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Error 类型则返回 true，否则返回 false\n */\nexport function isError(unknown: unknown): unknown is Error {\n  return unknown instanceof Error;\n}\n\n/**\n * 检查值是否为 Promise 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Promise 类型则返回 true，否则返回 false\n */\nexport function isPromise<T>(unknown: unknown): unknown is Promise<T> {\n  return typeIs(unknown) === 'promise';\n}\n\n/**\n * 检查值是否为 Date 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Date 类型则返回 true，否则返回 false\n */\nexport function isDate(unknown: unknown): unknown is Date {\n  return unknown instanceof Date;\n}\n"],"names":[],"mappings":"AAOO,SAAS,OACd,SAcS;AACF,SAAA,OAAO,UAAU,SAAS,KAAK,OAAO,EAAE,MAAM,GAAG,EAAE,EAAE,YAAY;AAC1E;AAOO,SAAS,SAAS,SAAqC;AAC5D,SAAO,OAAO,YAAY;AAC5B;AAOO,SAAS,UAAU,SAAsC;AAC9D,SAAO,OAAO,YAAY;AAC5B;AAOO,SAAS,SAAS,SAAqC;AAC5D,SAAO,OAAO,YAAY;AAC5B;AAOO,SAAS,SAAS,SAAqC;AAC5D,SAAO,OAAO,YAAY;AAC5B;AAOO,SAAS,SAAS,SAAqC;AAC5D,SAAO,OAAO,YAAY,YAAY,CAAC,OAAO,MAAM,OAAO;AAC7D;AAOO,SAAS,YAAY,SAAwC;AAClE,SAAO,OAAO,YAAY;AAC5B;AAQO,SAAS,OAAO,SAAmC;AACxD,SAAO,YAAY,OAAO;AAC5B;AAMO,SAAS,QAAQ,SAAgB;AAExC;AAOO,SAAS,OAAO,SAAmC;AACxD,SAAO,YAAY;AACrB;AAQO,SAAS,UAAU,SAAsD;AAC9E,SAAO,OAAO,OAAO,KAAK,YAAY,OAAO,KAAK,OAAO,OAAO;AAClE;AAOO,SAAS,YACd,SAC2E;AACpE,SAAA,OAAO,OAAO,KAAK,EAAE,OAAO,YAAY,YAAY,OAAO,YAAY;AAChF;AAOO,SAAS,SAAS,SAAwC;AACxD,SAAA,OAAO,OAAO,MAAM;AAC7B;AAOO,SAAS,QAAQ,SAAuC;AACtD,SAAA,MAAM,QAAQ,OAAO;AAC9B;AAOO,SAAS,WAAW,SAA0C;AACnE,SAAO,OAAO,YAAY;AAC5B;AAcO,SAAS,gBAAgB,SAA+C;AAC7E,SAAO,WAAW,OAAO,KAAK,QAAQ,YAAY,SAAS;AAC7D;AAOO,SAAS,QAAQ,SAAoC;AAC1D,SAAO,mBAAmB;AAC5B;AAOO,SAAS,UAAa,SAAyC;AAC7D,SAAA,OAAO,OAAO,MAAM;AAC7B;AAOO,SAAS,OAAO,SAAmC;AACxD,SAAO,mBAAmB;AAC5B;"}

package/dist/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.cjs.map

package/dist/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

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

@@ -2,7 +2,6 @@
  * 任意对象
  */
 export type AnyObject = Record<PropertyKey, unknown>;
-
 /**
  * 返回对象的所有键名，并且键名都是字符串类型
  * @example
@@ -11,68 +10,48 @@ export type AnyObject = Record<PropertyKey, unknown>;
  * // 'a' | '2'
  * ```
  */
-export type KeysOf<T> = { [P in keyof T]: P extends string ? P : P extends number ? `${P}` : never }[keyof T];
-
+export type KeysOf<T> = {
+    [P in keyof T]: P extends string ? P : P extends number ? `${P}` : never;
+}[keyof T];
 /**
  * 任意数组
  */
 export type AnyArray = Array<unknown>;
-
 /**
  * 任意函数
  */
-// biome-ignore lint/suspicious/noExplicitAny: <explanation>
 export type AnyFunction = (...args: any[]) => any;
-
 /**
  * 任意异步函数
  */
-// biome-ignore lint/suspicious/noExplicitAny: <explanation>
 export type AnyAsyncFunction = (...args: any[]) => Promise<any>;
-
 /**
  * 可能是 Promise 的类型
  */
 export type MaybePromise<T> = T | Promise<T>;
-
 /**
  * 可能是可执行的类型
  */
 export type MaybeCallable<T> = T | (() => T);
-
 /**
  * 深度部分类型
  */
-export type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
-
-// https://juejin.cn/post/6994102811218673700#heading-24
-
-// biome-ignore lint/suspicious/noExplicitAny: <explanation>
-export type UnionToIntersection<T> = (T extends any ? (arg: T) => void : never) extends (arg: infer U) => void
-  ? U
-  : never;
-// type T0 = UnionToIntersection<{ key1: string } | { key2: number }>;
-
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type UnionToIntersection<T> = (T extends any ? (arg: T) => void : never) extends (arg: infer U) => void ? U : never;
 /**
  * 从联合类型中提取最后一个类型
  * @template U - 联合类型
  */
 type _UnionLast<U> = UnionToIntersection<U extends U ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
-
 /**
  * 将联合类型转换为元组类型
  * @template U - 联合类型
  * @template Last - 联合类型中的最后一个类型
  */
-export type UnionToTuple<U, Last = _UnionLast<U>> = [U] extends [never]
-  ? []
-  : [...UnionToTuple<Exclude<U, Last>>, Last];
-
-// type T2 = LastInUnion<'a' | 'b' | 'c' | 'd'>;
-// type T3 = UnionToTuple<'a' | 'b' | 'c' | 'd'>;
-// ['a', 'b', 'c', 'd']
-
-// https://juejin.cn/post/7187963986875252795#heading-4
-// type Merged = MergeIntersection<{ a: string } & { b: number }>;
-// { a: string; b: number }
-export type MergeIntersection<A> = A extends infer T ? { [Key in keyof T]: T[Key] } : never;
+export type UnionToTuple<U, Last = _UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, Last>>, Last];
+export type MergeIntersection<A> = A extends infer T ? {
+    [Key in keyof T]: T[Key];
+} : never;
+export {};

package/dist/types.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/unique.cjs

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const number = require("./string2.cjs");
+const type = require("./type.cjs");
+let lastTimestamp = 0;
+let lastSafePadding = 0;
+function uniqueBigInt(randomLength = 0) {
+  const now = Date.now();
+  if (now !== lastTimestamp) {
+    lastTimestamp = now;
+    lastSafePadding = 0;
+  }
+  let randomPart = "";
+  if (randomLength > 0) {
+    const randomMin = 10 ** (randomLength - 1);
+    const randomMax = 10 ** randomLength - 1;
+    randomPart = String(number.randomNumber(randomMin, randomMax));
+  }
+  return BigInt(randomPart + lastSafePadding++ + now);
+}
+const _randomChar = (dict) => {
+  const poolIndex = number.randomNumber(0, dict.length - 1);
+  return dict[poolIndex];
+};
+function uniqueString(minLength, dict) {
+  let finalLength = 0;
+  let finalDict = number.STRING_DICT;
+  if (type.isString(dict)) {
+    finalLength = minLength;
+    finalDict = dict;
+  } else if (type.isNumber(minLength)) {
+    finalLength = minLength;
+  } else if (type.isString(minLength)) {
+    finalDict = minLength;
+  }
+  let uniqueString2 = number.numberConvert(uniqueBigInt(), finalDict);
+  let insertLength = finalLength - uniqueString2.length;
+  if (insertLength <= 0) return uniqueString2;
+  while (insertLength--) {
+    uniqueString2 += _randomChar(finalDict);
+  }
+  return uniqueString2;
+}
+exports.uniqueBigInt = uniqueBigInt;
+exports.uniqueString = uniqueString;
+//# sourceMappingURL=unique.cjs.map

package/dist/unique.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique.cjs","sources":["../src/unique.ts"],"sourcesContent":["import { numberConvert, randomNumber } from './number';\nimport { STRING_DICT } from './string';\nimport { isNumber, isString } from './type';\n\nlet lastTimestamp = 0;\nlet lastSafePadding = 0;\n\n/**\n * 生成一个唯一的 BigInt 值。\n *\n * @param randomLength - 可选参数，指定随机部分的长度，默认为 0。\n *                        如果大于 0，则会在结果中附加指定长度的随机数。\n * @returns 返回一个唯一的 BigInt 值，包含时间戳、随机部分（如果有）以及递增的填充值。\n */\nexport function uniqueBigInt(randomLength = 0): bigint {\n  const now = Date.now();\n\n  if (now !== lastTimestamp) {\n    lastTimestamp = now;\n    lastSafePadding = 0;\n  }\n\n  let randomPart = '';\n\n  if (randomLength > 0) {\n    const randomMin = 10 ** (randomLength - 1);\n    const randomMax = 10 ** randomLength - 1;\n    randomPart = String(randomNumber(randomMin, randomMax));\n  }\n\n  return BigInt(randomPart + lastSafePadding++ + now);\n}\n\nconst _randomChar = (dict: string): string => {\n  const poolIndex = randomNumber(0, dict.length - 1);\n\n  return dict[poolIndex];\n};\n\n/**\n * 生成一个唯一的字符串。\n *\n * @param minLength - 可选参数，指定生成字符串的最小长度。\n *                 如果未提供或为字符串类型，则使用默认长度。\n * @param dict - 可选参数，指定生成字符串时使用的字符集。\n *               如果未提供，则使用默认字符集 `STRING_DICT`。\n * @returns 返回一个唯一的字符串，包含时间戳、随机部分（如果有）以及递增的填充值。\n *          如果指定了 `length`，则返回值的长度将被调整到指定长度。\n */\nexport function uniqueString(minLength: number, dict: string): string;\nexport function uniqueString(minLength: number): string;\nexport function uniqueString(dict: string): string;\nexport function uniqueString(): string;\nexport function uniqueString(minLength?: number | string, dict?: string) {\n  let finalLength = 0;\n  let finalDict = STRING_DICT;\n\n  if (isString(dict)) {\n    finalLength = minLength as number;\n    finalDict = dict;\n  } else if (isNumber(minLength)) {\n    finalLength = minLength;\n  } else if (isString(minLength)) {\n    finalDict = minLength;\n  }\n\n  let uniqueString = numberConvert(uniqueBigInt(), finalDict);\n  let insertLength = finalLength - uniqueString.length;\n\n  if (insertLength <= 0) return uniqueString;\n\n  while (insertLength--) {\n    uniqueString += _randomChar(finalDict);\n  }\n\n  return uniqueString;\n}\n"],"names":["randomNumber","STRING_DICT","isString","isNumber","uniqueString","numberConvert"],"mappings":";;;;AAIA,IAAI,gBAAgB;AACpB,IAAI,kBAAkB;AASN,SAAA,aAAa,eAAe,GAAW;AAC/C,QAAA,MAAM,KAAK,IAAI;AAErB,MAAI,QAAQ,eAAe;AACT,oBAAA;AACE,sBAAA;AAAA,EAAA;AAGpB,MAAI,aAAa;AAEjB,MAAI,eAAe,GAAG;AACd,UAAA,YAAY,OAAO,eAAe;AAClC,UAAA,YAAY,MAAM,eAAe;AACvC,iBAAa,OAAOA,OAAAA,aAAa,WAAW,SAAS,CAAC;AAAA,EAAA;AAGjD,SAAA,OAAO,aAAa,oBAAoB,GAAG;AACpD;AAEA,MAAM,cAAc,CAAC,SAAyB;AAC5C,QAAM,YAAYA,OAAAA,aAAa,GAAG,KAAK,SAAS,CAAC;AAEjD,SAAO,KAAK,SAAS;AACvB;AAgBgB,SAAA,aAAa,WAA6B,MAAe;AACvE,MAAI,cAAc;AAClB,MAAI,YAAYC,OAAA;AAEZ,MAAAC,KAAAA,SAAS,IAAI,GAAG;AACJ,kBAAA;AACF,gBAAA;AAAA,EAAA,WACHC,KAAAA,SAAS,SAAS,GAAG;AAChB,kBAAA;AAAA,EAAA,WACLD,KAAAA,SAAS,SAAS,GAAG;AAClB,gBAAA;AAAA,EAAA;AAGd,MAAIE,gBAAeC,OAAAA,cAAc,aAAa,GAAG,SAAS;AACtD,MAAA,eAAe,cAAcD,cAAa;AAE1C,MAAA,gBAAgB,EAAUA,QAAAA;AAE9B,SAAO,gBAAgB;AACrBA,qBAAgB,YAAY,SAAS;AAAA,EAAA;AAGhCA,SAAAA;AACT;;;"}

package/dist/unique.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 生成一个唯一的 BigInt 值。
+ *
+ * @param randomLength - 可选参数，指定随机部分的长度，默认为 0。
+ *                        如果大于 0，则会在结果中附加指定长度的随机数。
+ * @returns 返回一个唯一的 BigInt 值，包含时间戳、随机部分（如果有）以及递增的填充值。
+ */
+export declare function uniqueBigInt(randomLength?: number): bigint;
+/**
+ * 生成一个唯一的字符串。
+ *
+ * @param minLength - 可选参数，指定生成字符串的最小长度。
+ *                 如果未提供或为字符串类型，则使用默认长度。
+ * @param dict - 可选参数，指定生成字符串时使用的字符集。
+ *               如果未提供，则使用默认字符集 `STRING_DICT`。
+ * @returns 返回一个唯一的字符串，包含时间戳、随机部分（如果有）以及递增的填充值。
+ *          如果指定了 `length`，则返回值的长度将被调整到指定长度。
+ */
+export declare function uniqueString(minLength: number, dict: string): string;
+export declare function uniqueString(minLength: number): string;
+export declare function uniqueString(dict: string): string;
+export declare function uniqueString(): string;

package/dist/unique.mjs

@@ -0,0 +1,46 @@
+import { n as numberConvert, S as STRING_DICT, r as randomNumber } from "./string2.mjs";
+import { isString, isNumber } from "./type.mjs";
+let lastTimestamp = 0;
+let lastSafePadding = 0;
+function uniqueBigInt(randomLength = 0) {
+  const now = Date.now();
+  if (now !== lastTimestamp) {
+    lastTimestamp = now;
+    lastSafePadding = 0;
+  }
+  let randomPart = "";
+  if (randomLength > 0) {
+    const randomMin = 10 ** (randomLength - 1);
+    const randomMax = 10 ** randomLength - 1;
+    randomPart = String(randomNumber(randomMin, randomMax));
+  }
+  return BigInt(randomPart + lastSafePadding++ + now);
+}
+const _randomChar = (dict) => {
+  const poolIndex = randomNumber(0, dict.length - 1);
+  return dict[poolIndex];
+};
+function uniqueString(minLength, dict) {
+  let finalLength = 0;
+  let finalDict = STRING_DICT;
+  if (isString(dict)) {
+    finalLength = minLength;
+    finalDict = dict;
+  } else if (isNumber(minLength)) {
+    finalLength = minLength;
+  } else if (isString(minLength)) {
+    finalDict = minLength;
+  }
+  let uniqueString2 = numberConvert(uniqueBigInt(), finalDict);
+  let insertLength = finalLength - uniqueString2.length;
+  if (insertLength <= 0) return uniqueString2;
+  while (insertLength--) {
+    uniqueString2 += _randomChar(finalDict);
+  }
+  return uniqueString2;
+}
+export {
+  uniqueBigInt,
+  uniqueString
+};
+//# sourceMappingURL=unique.mjs.map

package/dist/unique.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique.mjs","sources":["../src/unique.ts"],"sourcesContent":["import { numberConvert, randomNumber } from './number';\nimport { STRING_DICT } from './string';\nimport { isNumber, isString } from './type';\n\nlet lastTimestamp = 0;\nlet lastSafePadding = 0;\n\n/**\n * 生成一个唯一的 BigInt 值。\n *\n * @param randomLength - 可选参数，指定随机部分的长度，默认为 0。\n *                        如果大于 0，则会在结果中附加指定长度的随机数。\n * @returns 返回一个唯一的 BigInt 值，包含时间戳、随机部分（如果有）以及递增的填充值。\n */\nexport function uniqueBigInt(randomLength = 0): bigint {\n  const now = Date.now();\n\n  if (now !== lastTimestamp) {\n    lastTimestamp = now;\n    lastSafePadding = 0;\n  }\n\n  let randomPart = '';\n\n  if (randomLength > 0) {\n    const randomMin = 10 ** (randomLength - 1);\n    const randomMax = 10 ** randomLength - 1;\n    randomPart = String(randomNumber(randomMin, randomMax));\n  }\n\n  return BigInt(randomPart + lastSafePadding++ + now);\n}\n\nconst _randomChar = (dict: string): string => {\n  const poolIndex = randomNumber(0, dict.length - 1);\n\n  return dict[poolIndex];\n};\n\n/**\n * 生成一个唯一的字符串。\n *\n * @param minLength - 可选参数，指定生成字符串的最小长度。\n *                 如果未提供或为字符串类型，则使用默认长度。\n * @param dict - 可选参数，指定生成字符串时使用的字符集。\n *               如果未提供，则使用默认字符集 `STRING_DICT`。\n * @returns 返回一个唯一的字符串，包含时间戳、随机部分（如果有）以及递增的填充值。\n *          如果指定了 `length`，则返回值的长度将被调整到指定长度。\n */\nexport function uniqueString(minLength: number, dict: string): string;\nexport function uniqueString(minLength: number): string;\nexport function uniqueString(dict: string): string;\nexport function uniqueString(): string;\nexport function uniqueString(minLength?: number | string, dict?: string) {\n  let finalLength = 0;\n  let finalDict = STRING_DICT;\n\n  if (isString(dict)) {\n    finalLength = minLength as number;\n    finalDict = dict;\n  } else if (isNumber(minLength)) {\n    finalLength = minLength;\n  } else if (isString(minLength)) {\n    finalDict = minLength;\n  }\n\n  let uniqueString = numberConvert(uniqueBigInt(), finalDict);\n  let insertLength = finalLength - uniqueString.length;\n\n  if (insertLength <= 0) return uniqueString;\n\n  while (insertLength--) {\n    uniqueString += _randomChar(finalDict);\n  }\n\n  return uniqueString;\n}\n"],"names":["uniqueString"],"mappings":";;AAIA,IAAI,gBAAgB;AACpB,IAAI,kBAAkB;AASN,SAAA,aAAa,eAAe,GAAW;AAC/C,QAAA,MAAM,KAAK,IAAI;AAErB,MAAI,QAAQ,eAAe;AACT,oBAAA;AACE,sBAAA;AAAA,EAAA;AAGpB,MAAI,aAAa;AAEjB,MAAI,eAAe,GAAG;AACd,UAAA,YAAY,OAAO,eAAe;AAClC,UAAA,YAAY,MAAM,eAAe;AACvC,iBAAa,OAAO,aAAa,WAAW,SAAS,CAAC;AAAA,EAAA;AAGjD,SAAA,OAAO,aAAa,oBAAoB,GAAG;AACpD;AAEA,MAAM,cAAc,CAAC,SAAyB;AAC5C,QAAM,YAAY,aAAa,GAAG,KAAK,SAAS,CAAC;AAEjD,SAAO,KAAK,SAAS;AACvB;AAgBgB,SAAA,aAAa,WAA6B,MAAe;AACvE,MAAI,cAAc;AAClB,MAAI,YAAY;AAEZ,MAAA,SAAS,IAAI,GAAG;AACJ,kBAAA;AACF,gBAAA;AAAA,EAAA,WACH,SAAS,SAAS,GAAG;AAChB,kBAAA;AAAA,EAAA,WACL,SAAS,SAAS,GAAG;AAClB,gBAAA;AAAA,EAAA;AAGd,MAAIA,gBAAe,cAAc,aAAa,GAAG,SAAS;AACtD,MAAA,eAAe,cAAcA,cAAa;AAE1C,MAAA,gBAAgB,EAAUA,QAAAA;AAE9B,SAAO,gBAAgB;AACrBA,qBAAgB,YAAY,SAAS;AAAA,EAAA;AAGhCA,SAAAA;AACT;"}

package/dist/url.cjs

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function urlParse(url) {
+  let result = null;
+  try {
+    result = new globalThis.URL(url);
+  } catch (e) {
+  }
+  const protocol = (result == null ? void 0 : result.protocol) || "";
+  const host = (result == null ? void 0 : result.host) || "";
+  return {
+    protocol,
+    host,
+    hostname: (result == null ? void 0 : result.hostname) || "",
+    port: (result == null ? void 0 : result.port) || "",
+    pathname: (result == null ? void 0 : result.pathname) || "",
+    search: (result == null ? void 0 : result.search) || "",
+    hash: (result == null ? void 0 : result.hash) || "",
+    username: (result == null ? void 0 : result.username) || "",
+    password: (result == null ? void 0 : result.password) || ""
+  };
+}
+function urlStringify(url) {
+  const { protocol, hostname, port, pathname, search, hash, username, password } = url;
+  return [
+    protocol ? `${protocol}//` : "",
+    username && password ? `${username}:${password}@` : "",
+    hostname,
+    port ? `:${port}` : "",
+    pathname,
+    search,
+    hash
+  ].filter(Boolean).join("");
+}
+exports.urlParse = urlParse;
+exports.urlStringify = urlStringify;
+//# sourceMappingURL=url.cjs.map

package/dist/url.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.cjs","sources":["../src/url.ts"],"sourcesContent":["/**\n * 表示解析后的 URL 组件。\n */\nexport type TURLMeta = {\n  /**\n   * 协议部分，包含冒号，例如 \"https:\"。\n   */\n  protocol: string;\n  /**\n   * 主机部分，包括主机名和端口。\n   */\n  host: string;\n  /**\n   * 主机名部分。\n   */\n  hostname: string;\n  /**\n   * 端口部分。\n   */\n  port: string;\n  /**\n   * 路径部分。\n   */\n  pathname: string;\n  /**\n   * 查询字符串部分。\n   */\n  search: string;\n  /**\n   * 哈希部分。\n   */\n  hash: string;\n  /**\n   * 用户名部分。\n   */\n  username: string;\n  /**\n   * 密码部分。\n   */\n  password: string;\n};\n\n/**\n * 解析 URL 字符串为组件对象。\n * @param url - 需要解析的 URL 字符串。\n * @returns 包含解析后 URL 组件的对象。\n */\nexport function urlParse(url: string): TURLMeta {\n  let result: URL | null = null;\n\n  try {\n    // 添加 globalThis 是便于对接外部环境 URL 的自行实现\n    // 例如在 uni-app、微信小程序等运行环境。\n    result = new globalThis.URL(url);\n  } catch (e) {\n    // ignore\n  }\n\n  const protocol = result?.protocol || '';\n  const host = result?.host || '';\n\n  return {\n    protocol,\n    host,\n    hostname: result?.hostname || '',\n    port: result?.port || '',\n    pathname: result?.pathname || '',\n    search: result?.search || '',\n    hash: result?.hash || '',\n    username: result?.username || '',\n    password: result?.password || '',\n  };\n}\n\n/**\n * 将 URLInfo 对象转换回 URL 字符串。\n * @param url - 需要转换的 URLInfo 对象。\n * @returns 转换后的 URL 字符串。\n */\nexport function urlStringify(url: TURLMeta) {\n  const { protocol, hostname, port, pathname, search, hash, username, password } = url;\n  return [\n    protocol ? `${protocol}//` : '',\n    username && password ? `${username}:${password}@` : '',\n    hostname,\n    port ? `:${port}` : '',\n    pathname,\n    search,\n    hash,\n  ]\n    .filter(Boolean)\n    .join('');\n}\n"],"names":[],"mappings":";;AA+CO,SAAS,SAAS,KAAuB;AAC9C,MAAI,SAAqB;AAErB,MAAA;AAGO,aAAA,IAAI,WAAW,IAAI,GAAG;AAAA,WACxB,GAAG;AAAA,EAAA;AAIN,QAAA,YAAW,iCAAQ,aAAY;AAC/B,QAAA,QAAO,iCAAQ,SAAQ;AAEtB,SAAA;AAAA,IACL;AAAA,IACA;AAAA,IACA,WAAU,iCAAQ,aAAY;AAAA,IAC9B,OAAM,iCAAQ,SAAQ;AAAA,IACtB,WAAU,iCAAQ,aAAY;AAAA,IAC9B,SAAQ,iCAAQ,WAAU;AAAA,IAC1B,OAAM,iCAAQ,SAAQ;AAAA,IACtB,WAAU,iCAAQ,aAAY;AAAA,IAC9B,WAAU,iCAAQ,aAAY;AAAA,EAChC;AACF;AAOO,SAAS,aAAa,KAAe;AACpC,QAAA,EAAE,UAAU,UAAU,MAAM,UAAU,QAAQ,MAAM,UAAU,SAAA,IAAa;AAC1E,SAAA;AAAA,IACL,WAAW,GAAG,QAAQ,OAAO;AAAA,IAC7B,YAAY,WAAW,GAAG,QAAQ,IAAI,QAAQ,MAAM;AAAA,IACpD;AAAA,IACA,OAAO,IAAI,IAAI,KAAK;AAAA,IACpB;AAAA,IACA;AAAA,IACA;AAAA,EAEC,EAAA,OAAO,OAAO,EACd,KAAK,EAAE;AACZ;;;"}

package/dist/url.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 表示解析后的 URL 组件。
+ */
+export type TURLMeta = {
+    /**
+     * 协议部分，包含冒号，例如 "https:"。
+     */
+    protocol: string;
+    /**
+     * 主机部分，包括主机名和端口。
+     */
+    host: string;
+    /**
+     * 主机名部分。
+     */
+    hostname: string;
+    /**
+     * 端口部分。
+     */
+    port: string;
+    /**
+     * 路径部分。
+     */
+    pathname: string;
+    /**
+     * 查询字符串部分。
+     */
+    search: string;
+    /**
+     * 哈希部分。
+     */
+    hash: string;
+    /**
+     * 用户名部分。
+     */
+    username: string;
+    /**
+     * 密码部分。
+     */
+    password: string;
+};
+/**
+ * 解析 URL 字符串为组件对象。
+ * @param url - 需要解析的 URL 字符串。
+ * @returns 包含解析后 URL 组件的对象。
+ */
+export declare function urlParse(url: string): TURLMeta;
+/**
+ * 将 URLInfo 对象转换回 URL 字符串。
+ * @param url - 需要转换的 URLInfo 对象。
+ * @returns 转换后的 URL 字符串。
+ */
+export declare function urlStringify(url: TURLMeta): string;