@unicom-cloud/utils 0.1.42 → 0.1.43

package/filesize/index.d.ts

@@ -1,2 +1,4 @@
-export * from "./filesize";
-export { filesize as default } from "./filesize";
+export * from "./src/constants";
+export * from "./src/helpers";
+export * from "./src/filesize";
+export { filesize as default } from "./src/filesize";

package/filesize/index.js

@@ -1,4 +1,6 @@
-/* 潘启宝 2026-04-23 09:23:17 星期四 */
-import { filesize as e, partial as t } from "./filesize.js";
-export { e as default, e as filesize, t as partial };
+/* 潘启宝 2026-05-08 09:02:42 星期五 */
+import { ARRAY as e, BINARY_POWERS as t, BIT as n, BITS as r, BYTE as i, BYTES as a, DECIMAL_POWERS as o, E as s, EMPTY as c, EXPONENT as l, FUNCTION as u, IEC as d, INVALID_NUMBER as f, INVALID_ROUND as p, JEDEC as m, LOG_10_1000 as h, LOG_2_1024 as g, OBJECT as _, PERIOD as v, ROUND as y, S as b, SI as x, SI_KBIT as S, SI_KBYTE as C, SPACE as w, STRING as T, STRINGS as E, ZERO as D } from "./src/constants.js";
+import { applyNumberFormatting as O, applyPrecisionHandling as k, applyRounding as A, calculateExponent as j, calculateOptimizedValue as M, decorateResult as N, formatOutput as P, getBaseConfiguration as F, handleZeroValue as I, resolveSymbol as L } from "./src/helpers.js";
+import { filesize as R, partial as z } from "./src/filesize.js";
+export { e as ARRAY, t as BINARY_POWERS, n as BIT, r as BITS, i as BYTE, a as BYTES, o as DECIMAL_POWERS, s as E, c as EMPTY, l as EXPONENT, u as FUNCTION, d as IEC, f as INVALID_NUMBER, p as INVALID_ROUND, m as JEDEC, h as LOG_10_1000, g as LOG_2_1024, _ as OBJECT, v as PERIOD, y as ROUND, b as S, x as SI, S as SI_KBIT, C as SI_KBYTE, w as SPACE, T as STRING, E as STRINGS, D as ZERO, O as applyNumberFormatting, k as applyPrecisionHandling, A as applyRounding, j as calculateExponent, M as calculateOptimizedValue, N as decorateResult, R as default, R as filesize, P as formatOutput, F as getBaseConfiguration, I as handleZeroValue, z as partial, L as resolveSymbol };
 /* 独立思考，明辨是非 */

package/filesize/{constants.js → src/constants.js}

@@ -1,5 +1,5 @@
-/* 潘启宝 2026-04-23 09:23:17 星期四 */
-//#region utils/filesize/constants.js
+/* 潘启宝 2026-05-08 09:02:42 星期五 */
+//#region utils/filesize/src/constants.js
 var e = "Invalid number", t = "Invalid rounding method", n = "iec", r = "jedec", i = "si", a = "bit", o = "bits", s = "byte", c = "bytes", l = "kbit", u = "kB", d = "array", f = "function", p = "object", m = "string", h = "exponent", g = "round", _ = "e", v = "", y = ".", b = "s", x = " ", S = "0", C = {
 	symbol: {
 		iec: {

package/filesize/{filesize.d.ts → src/filesize.d.ts}

@@ -69,7 +69,7 @@ export function filesize(arg: number | string | bigint, { bits, pad, base, round
  * formatBytes(2048) // "2 KiB"
  * formatBytes(1536) // "1.5 KiB"
  */
-export function partial({ bits, pad, base, round, locale, localeOptions, separator, spacer, symbols, standard, output, fullform, fullforms, exponent, roundingMethod, precision, }?: {
+export function partial({ bits, pad, base, round, locale, separator, spacer, standard, output, fullform, exponent, roundingMethod, precision, localeOptions, symbols, fullforms, }?: {
     bits?: boolean | undefined;
     pad?: boolean | undefined;
     base?: number | undefined;

package/filesize/src/filesize.js

@@ -0,0 +1,52 @@
+/* 潘启宝 2026-05-08 09:02:42 星期五 */
+import { INVALID_NUMBER as e, INVALID_ROUND as t, ROUND as n, STRING as r } from "./constants.js";
+import { applyPrecisionHandling as i, applyRounding as a, calculateExponent as o, calculateOptimizedValue as s, decorateResult as c, formatOutput as l, getBaseConfiguration as u, handleZeroValue as d, resolveSymbol as f } from "./helpers.js";
+//#region utils/filesize/src/filesize.js
+function p(p, { bits: m = !1, pad: h = !1, base: g = -1, round: _ = 2, locale: v = "", localeOptions: y = {}, separator: b = "", spacer: x = " ", symbols: S = {}, standard: C = "", output: w = r, fullform: T = !1, fullforms: E = [], exponent: D = -1, roundingMethod: O = n, precision: k = 0 } = {}) {
+	let A = D, j, M = [], N = 0, P = "";
+	if (typeof p == "bigint") j = Number(p);
+	else if (j = Number(p), isNaN(p) || !isFinite(j)) throw TypeError(e);
+	let { isDecimal: F, ceil: I, actualStandard: L } = u(C, g), R = T === !0, z = j < 0, B = Math[O];
+	if (typeof B != "function") throw TypeError(t);
+	if (z && (j = -j), j === 0) return d(k, L, m, S, R, E, w, x);
+	let { e: V, precision: H } = o(j, A, D, F, k);
+	A = V;
+	let U = D === -1 || isNaN(D);
+	if (w === "exponent") return A;
+	let { result: W, e: G } = s(j, A, F, m, I, U);
+	N = W, A = G;
+	let K = a(N, I, A, _, B, U);
+	if (M[0] = K.value, A = K.e, H > 0) {
+		let e = i(M[0], H, A, j, F, m, I, B, _, D);
+		M[0] = e.value, A = e.e;
+	}
+	return P = f(L, m, A, F), M[1] = P, c(M, z, S, v, y, b, h, _, R, E, L, A, m), l(M, A, P, w, x);
+}
+function m({ bits: e = !1, pad: t = !1, base: i = -1, round: a = 2, locale: o = "", separator: s = "", spacer: c = " ", standard: l = "", output: u = r, fullform: d = !1, exponent: f = -1, roundingMethod: m = n, precision: h = 0, localeOptions: g = {}, symbols: _ = {}, fullforms: v = [] } = {}) {
+	let y = {
+		localeOptions: JSON.parse(JSON.stringify(g)),
+		symbols: JSON.parse(JSON.stringify(_)),
+		fullforms: JSON.parse(JSON.stringify(v))
+	};
+	return (n) => p(n, {
+		bits: e,
+		pad: t,
+		base: i,
+		round: a,
+		locale: o,
+		localeOptions: y.localeOptions,
+		separator: s,
+		spacer: c,
+		symbols: y.symbols,
+		standard: l,
+		output: u,
+		fullform: d,
+		fullforms: y.fullforms,
+		exponent: f,
+		roundingMethod: m,
+		precision: h
+	});
+}
+//#endregion
+export { p as filesize, m as partial };
+/* 独立思考，明辨是非 */

package/filesize/src/helpers.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Optimized base configuration lookup
+ * @param {string} standard - Standard type
+ * @param {number} base - Base number
+ * @returns {Object} Configuration object
+ */
+export function getBaseConfiguration(standard: string, base: number): Object;
+/**
+ * Optimized zero value handling
+ * @param {number} precision - Precision value
+ * @param {string} actualStandard - Standard to use
+ * @param {boolean} bits - Whether to use bits
+ * @param {Object} symbols - Custom symbols
+ * @param {boolean} full - Whether to use full form
+ * @param {Array} fullforms - Custom full forms
+ * @param {string} output - Output format
+ * @param {string} spacer - Spacer character
+ * @param {string} [symbol] - Symbol to use (defaults based on bits/standard)
+ * @returns {string|Array|Object|number} Formatted result
+ */
+export function handleZeroValue(precision: number, actualStandard: string, bits: boolean, symbols: Object, full: boolean, fullforms: any[], output: string, spacer: string, symbol?: string): string | any[] | Object | number;
+/**
+ * Optimized value calculation with bits handling
+ * @param {number} num - Input number
+ * @param {number} e - Exponent
+ * @param {boolean} isDecimal - Whether to use decimal powers
+ * @param {boolean} bits - Whether to calculate bits
+ * @param {number} ceil - Ceiling value for auto-increment
+ * @param {boolean} autoExponent - Whether exponent is auto (-1 or NaN)
+ * @returns {Object} Object with result and e properties
+ */
+export function calculateOptimizedValue(num: number, e: number, isDecimal: boolean, bits: boolean, ceil: number, autoExponent?: boolean): Object;
+/**
+ * Optimized precision handling with scientific notation correction
+ * @param {number} value - Current value
+ * @param {number} precision - Precision to apply
+ * @param {number} e - Current exponent
+ * @param {number} num - Original number
+ * @param {boolean} isDecimal - Whether using decimal base
+ * @param {boolean} bits - Whether calculating bits
+ * @param {number} ceil - Ceiling value
+ * @param {Function} roundingFunc - Rounding function
+ * @param {number} round - Round value
+ * @param {number} exponent - Forced exponent (-1 for auto)
+ * @returns {Object} Object with value and e properties
+ */
+export function applyPrecisionHandling(value: number, precision: number, e: number, num: number, isDecimal: boolean, bits: boolean, ceil: number, roundingFunc: Function, round: number, exponent: number): Object;
+/**
+ * Optimized number formatting with locale, separator, and padding
+ * @param {number|string} value - Value to format
+ * @param {string|boolean} locale - Locale setting
+ * @param {Object} localeOptions - Locale options
+ * @param {string} separator - Custom separator
+ * @param {boolean} pad - Whether to pad
+ * @param {number} round - Round value
+ * @returns {string|number} Formatted value
+ */
+export function applyNumberFormatting(value: number | string, locale: string | boolean, localeOptions: Object, separator: string, pad: boolean, round: number): string | number;
+/**
+ * Calculates exponent from the input value using pre-computed log values and clamps to supported range
+ * Also adjusts precision when exponent exceeds the lookup table bounds
+ * @param {number} num - Input file size in bytes
+ * @param {number} e - Current exponent value
+ * @param {number} exponent - Original user-provided exponent option (-1 for auto)
+ * @param {boolean} isDecimal - Whether to use decimal (SI) base
+ * @param {number} precision - Current precision value (modified when e > 8)
+ * @returns {Object} Object with computed e value and possibly adjusted precision
+ */
+export function calculateExponent(num: number, e: number, exponent: number, isDecimal: boolean, precision: number): Object;
+/**
+ * Applies rounding to the raw calculated value and handles auto-increment ceiling
+ * @param {number} val - Raw value before rounding
+ * @param {number} ceil - Ceiling threshold (1000 for SI, 1024 for IEC)
+ * @param {number} e - Current exponent value
+ * @param {number} round - Number of decimal places
+ * @param {Function} roundingFunc - Rounding method (Math.round, Math.floor, Math.ceil)
+ * @param {boolean} autoExponent - Whether exponent is auto-calculated (-1 or NaN)
+ * @returns {Object} Object with rounded value and possibly incremented exponent
+ */
+export function applyRounding(val: number, ceil: number, e: number, round: number, roundingFunc: Function, autoExponent: boolean): Object;
+/**
+ * Resolves the unit symbol for the given standard, bits mode, and exponent
+ * Handles SI standard special case where exponent 1 always uses "kB" or "kbit"
+ * @param {string} actualStandard - The resolved standard (iec, jedec)
+ * @param {boolean} bits - Whether formatting bit values
+ * @param {number} e - Current exponent index
+ * @param {boolean} isDecimal - Whether using decimal (SI) base
+ * @returns {string} The resolved unit symbol string
+ */
+export function resolveSymbol(actualStandard: string, bits: boolean, e: number, isDecimal: boolean): string;
+/**
+ * Decorates the result: applies negation, custom symbols, number formatting, and full form names
+ * Mutates the result array in-place for both value (index 0) and symbol (index 1)
+ * @param {Array} result - Result array with numeric value at [0] and string symbol at [1]
+ * @param {boolean} neg - Whether the original input was negative
+ * @param {Object} symbols - Custom symbol override map
+ * @param {string|boolean} locale - Locale string for formatting
+ * @param {Object} localeOptions - Additional locale formatting options
+ * @param {string} separator - Custom decimal separator
+ * @param {boolean} pad - Whether zero-pad decimals
+ * @param {number} round - Target decimal count for padding
+ * @param {boolean} full - Whether to use full unit names
+ * @param {Array} fullforms - Custom full unit name overrides
+ * @param {string} actualStandard - Unit standard for full form lookup
+ * @param {number} e - Current exponent index
+ * @param {boolean} bits - Whether formatting bit values
+ * @returns {void} Mutates result array in place
+ */
+export function decorateResult(result: any[], neg: boolean, symbols: Object, locale: string | boolean, localeOptions: Object, separator: string, pad: boolean, round: number, full: boolean, fullforms: any[], actualStandard: string, e: number, bits: boolean): void;
+/**
+ * Formats the computed result array into the requested output type
+ * @param {Array} result - Result array with formatted value at [0] and symbol at [1]
+ * @param {number} e - Current exponent
+ * @param {string} u - Original resolved symbol (before custom override)
+ * @param {string} output - Output type (ARRAY, OBJECT, STRING)
+ * @param {string} spacer - String separator between value and unit
+ * @returns {string|Array|Object|number} Formatted result in requested type
+ */
+export function formatOutput(result: any[], e: number, u: string, output: string, spacer: string): string | any[] | Object | number;

package/filesize/src/helpers.js

@@ -0,0 +1,118 @@
+/* 潘启宝 2026-05-08 09:02:42 星期五 */
+import { BINARY_POWERS as e, BITS as t, BYTE as n, BYTES as r, DECIMAL_POWERS as i, JEDEC as a, LOG_10_1000 as o, LOG_2_1024 as s, SI_KBIT as c, STRINGS as l } from "./constants.js";
+//#region utils/filesize/src/helpers.js
+var u = {
+	si: {
+		isDecimal: !0,
+		ceil: 1e3,
+		actualStandard: a
+	},
+	iec: {
+		isDecimal: !1,
+		ceil: 1024,
+		actualStandard: "iec"
+	},
+	[a]: {
+		isDecimal: !1,
+		ceil: 1024,
+		actualStandard: a
+	}
+};
+function d(e, t) {
+	return u[e] ? u[e] : t === 2 ? {
+		isDecimal: !1,
+		ceil: 1024,
+		actualStandard: "iec"
+	} : {
+		isDecimal: !0,
+		ceil: 1e3,
+		actualStandard: a
+	};
+}
+function f(e, t, r, i, a, o, s, c, u) {
+	let d;
+	return d = e > 0 ? 0 .toPrecision(e) : 0, s === "exponent" ? 0 : (u ||= r ? l.symbol[t].bits[0] : l.symbol[t].bytes[0], i[u] && (u = i[u]), a && (o[0] ? u = o[0] : (u = l.fullform[t][0], r ? u += "bit" : u += n)), s === "array" ? [d, u] : s === "object" ? {
+		value: d,
+		symbol: u,
+		exponent: 0,
+		unit: u
+	} : d + c + u);
+}
+function p(t, n, r, a, o, s = !0) {
+	let c;
+	c = r ? i[n] : e[n];
+	let l = t / c;
+	return a && (l *= 8, s && l >= o && n < 8 && (l /= o, n++)), {
+		result: l,
+		e: n
+	};
+}
+function m(e, t, n, r, i, a, o, s, c, l) {
+	typeof e == "string" && (e = parseFloat(e));
+	let u = e.toPrecision(t), d = l === -1 || isNaN(l);
+	if (u.includes("e") && n < 8 && d) {
+		n++;
+		let { result: e } = p(r, n, i, a, o), l;
+		l = c > 0 ? 10 ** c : 1;
+		let d;
+		d = l === 1 ? s(e) : s(e * l) / l, u = d.toPrecision(t);
+	}
+	return {
+		value: u,
+		e: n
+	};
+}
+function h(e, t, n, r, i, a) {
+	let o = e;
+	if (t === !0 ? o = o.toLocaleString() : t.length > 0 ? o = o.toLocaleString(t, n) : r.length > 0 && (o = o.toString().replace(".", r)), i && a > 0) {
+		let e = o.toString(), t = r || (e.slice(1).match(/[.,]/g) || []).pop() || ".", n = e.split(t), i = n[1] || "", s = i.length, c = a - s;
+		o = `${n[0]}${t}${i.padEnd(s + c, "0")}`;
+	}
+	return o;
+}
+function g(e, t, n, r, i) {
+	return (t === -1 || isNaN(t)) && (t = Math.floor(r ? Math.log(e) / o : Math.log(e) / s), t < 0 && (t = 0)), t > 8 ? (i > 0 && (i += 8 - t), {
+		e: 8,
+		precision: i
+	}) : {
+		e: t,
+		precision: i
+	};
+}
+function _(e, t, n, r, i, a) {
+	let o;
+	o = n > 0 && r > 0 ? 10 ** r : 1;
+	let s;
+	return s = o === 1 ? i(e) : i(e * o) / o, s === t && n < 8 && a && (s = 1, n++), {
+		value: s,
+		e: n
+	};
+}
+function v(e, n, i, a) {
+	let o = l.symbol[e][n ? t : r], s;
+	return s = a && i === 1 ? n ? c : "kB" : o[i], s;
+}
+function y(e, t, r, i, a, o, s, c, u, d, f, p, m) {
+	if (t && (e[0] = -e[0]), r[e[1]] && (e[1] = r[e[1]]), e[0] = h(e[0], i, a, o, s, c), u) {
+		let t;
+		t = m ? "bit" : n;
+		let r;
+		r = typeof e[0] == "string" ? parseFloat(e[0]) : e[0];
+		let i;
+		i = r === 1 ? "" : "s", d[p] ? e[1] = d[p] : e[1] = l.fullform[f][p] + t + i;
+	}
+}
+function b(e, t, n, r, i) {
+	if (r === "array") return e;
+	if (r === "object") return {
+		value: e[0],
+		symbol: e[1],
+		exponent: t,
+		unit: n
+	};
+	let a;
+	return a = i === " " ? `${e[0]} ${e[1]}` : e.join(i), a;
+}
+//#endregion
+export { h as applyNumberFormatting, m as applyPrecisionHandling, _ as applyRounding, g as calculateExponent, p as calculateOptimizedValue, y as decorateResult, b as formatOutput, d as getBaseConfiguration, f as handleZeroValue, v as resolveSymbol };
+/* 独立思考，明辨是非 */

package/function/index.js

@@ -1,4 +1,4 @@
-/* 潘启宝 2026-04-23 09:23:17 星期四 */
+/* 潘启宝 2026-05-08 09:02:42 星期五 */
 import { isFunction as e } from "../is/index.js";
 //#region utils/function/index.ts
 function t(t, ...n) {

package/idb/async-iterators.js

@@ -1,4 +1,4 @@
-/* 潘启宝 2026-04-23 09:23:17 星期四 */
+/* 潘启宝 2026-05-08 09:02:42 星期五 */
 import { instanceOfAny as e } from "./util.js";
 import { replaceTraps as t, reverseTransformCache as n, unwrap as r } from "./wrap-idb-value.js";
 //#region utils/idb/async-iterators.ts

package/idb/database-extras.js

@@ -1,4 +1,4 @@
-/* 潘启宝 2026-04-23 09:23:17 星期四 */
+/* 潘启宝 2026-05-08 09:02:42 星期五 */
 import { replaceTraps as e } from "./wrap-idb-value.js";
 //#region utils/idb/database-extras.ts
 var t = [

package/idb/entry.js

@@ -1,4 +1,4 @@
-/* 潘启宝 2026-04-23 09:23:17 星期四 */
+/* 潘启宝 2026-05-08 09:02:42 星期五 */
 import { unwrap as e, wrap as t } from "./wrap-idb-value.js";
 //#region utils/idb/entry.ts
 function n(e, n, { blocked: r, upgrade: i, blocking: a, terminated: o } = {}) {

package/idb/index-.js

@@ -1,4 +1,4 @@
-/* 潘启宝 2026-04-23 09:23:17 星期四 */
+/* 潘启宝 2026-05-08 09:02:42 星期五 */
 //#region utils/idb/index-.ts
 function e(e) {
 	return new Promise((t, n) => {

package/idb/index.js

@@ -1,4 +1,4 @@
-/* 潘启宝 2026-04-23 09:23:17 星期四 */
+/* 潘启宝 2026-05-08 09:02:42 星期五 */
 import { unwrap as e, wrap as t } from "./wrap-idb-value.js";
 import "./async-iterators.js";
 import "./database-extras.js";

package/idb/util.js

@@ -1,4 +1,4 @@
-/* 潘启宝 2026-04-23 09:23:17 星期四 */
+/* 潘启宝 2026-05-08 09:02:42 星期五 */
 //#region utils/idb/util.ts
 var e = (e, t) => t.some((t) => e instanceof t);
 //#endregion

package/idb/wrap-idb-value.js

@@ -1,4 +1,4 @@
-/* 潘启宝 2026-04-23 09:23:17 星期四 */
+/* 潘启宝 2026-05-08 09:02:42 星期五 */
 import { instanceOfAny as e } from "./util.js";
 //#region utils/idb/wrap-idb-value.ts
 var t, n;

package/index.js

@@ -1,4 +1,4 @@
-/* 潘启宝 2026-04-23 09:23:17 星期四 */
+/* 潘启宝 2026-05-08 09:02:42 星期五 */
 import { VERSION as e } from "./version/index.js";
 export { e as version };
 /* 独立思考，明辨是非 */

package/invariant/index.js

@@ -1,4 +1,4 @@
-/* 潘启宝 2026-04-23 09:23:17 星期四 */
+/* 潘启宝 2026-05-08 09:02:42 星期五 */
 import { isUndefined as e } from "../is/index.js";
 //#region utils/invariant/index.ts
 function t(t, n, ...r) {

package/is/index.d.ts

@@ -63,6 +63,7 @@ import isURL from './lib/isURL.ts';
 import isUUID from './lib/isUUID.ts';
 import isVariableWidth from './lib/isVariableWidth.ts';
 export declare function isPromise(value: unknown, instance?: boolean): value is Promise<unknown>;
+export declare function isThenable<T>(value: unknown): value is PromiseLike<T>;
 export declare function isFile(value: unknown, instance?: boolean): value is File;
 export declare function isBlob(value: unknown, instance?: boolean): value is Blob;
 export declare function isReadableStream(value: unknown, instance?: boolean): value is ReadableStream;
@@ -112,6 +113,7 @@ export declare function isExist(value: unknown): value is NonNullable<unknown>;
 export declare function isWindow(value: unknown): value is Window;
 export declare function isTrue(value: unknown): value is true;
 export declare function isFalse(value: unknown): value is false;
-export declare function isPresent(value: unknown): value is NonNullable<unknown>;
+export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
+export declare const isPresent: typeof isNonNullable;
 declare function isPrimitive(value: unknown): value is string | number | bigint | boolean | undefined | symbol | null;
 export { isAllChinese, isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isAscii, isBase64, isBoolean, isBuffer, isChinese, isDataURI, isDate, isElement, isEmail, isEmpty, isEqual, isEqualWith, isError, isFinite, isFullWidth, isFunction, isHalfWidth, isHash, isHexColor, isHSL, isIdentityCard, isIMEI, isInteger, isIP, isIPRange, isJWT, isLength, isMACAddress, isMap, isMatch, isMatchWith, isMD5, isMimeType, isMobilePhone, isMobilePhoneLocales, isNaN, isNative, isNil, isNull, isNumber, isObject, isObjectLike, isPlainObject, isPort, isPrimitive, isRegExp, isRgbColor, isSafeInteger, isSemVer, isSet, isSlug, isString, isStrongPassword, isSymbol, isTypedArray, isUndefined, isURL, isUUID, isVariableWidth, isWeakMap, isWeakSet, };