zhiaiwan-utils 1.0.3

package/dist/esm/array/some.js

@@ -0,0 +1,60 @@
+import baseIteratee from '../_internal/baseIteratee';
+import isArrayLike from '../_internal/isArrayLike';
+/**
+ * 检查 collection 中是否存在 predicate 为真值的元素。
+ *
+ * @param collection - 待检查的集合
+ * @param predicate - 每次迭代调用的断言函数或简写
+ * @returns 若存在匹配元素返回 true，否则返回 false
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.some([null, 0, 1], Boolean);
+ * // => true
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function some(collection, predicate = baseIteratee()) {
+    var _a;
+    const resolvedPredicate = baseIteratee(predicate);
+    if (collection == null) {
+        return false;
+    }
+    if (typeof collection === 'string') {
+        const chars = [...collection];
+        for (let index = 0; index < chars.length; index++) {
+            if (resolvedPredicate(chars[index], index, collection)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    if (Array.isArray(collection)) {
+        for (let index = 0; index < collection.length; index++) {
+            if (resolvedPredicate(collection[index], index, collection)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    if (isArrayLike(collection)) {
+        const arrayLike = collection;
+        const length = (_a = arrayLike.length) !== null && _a !== void 0 ? _a : 0;
+        for (let index = 0; index < length; index++) {
+            if (resolvedPredicate(arrayLike[index], index, collection)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    if (typeof collection === 'object') {
+        for (const key of Object.keys(collection)) {
+            if (resolvedPredicate(collection[key], key, collection)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/dist/esm/array/sortBy.js

@@ -0,0 +1,21 @@
+import orderBy from './orderBy';
+import baseIteratee from '../_internal/baseIteratee';
+/**
+ * 按 iteratee 升序排序 collection 并返回新数组。
+ *
+ * @param collection - 待排序的集合
+ * @param iteratees - 排序依据的函数、简写或数组
+ * @returns 排序后的新数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.sortBy([{ x: 2 }, { x: 1 }], 'x');
+ * // => [{ x: 1 }, { x: 2 }]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function sortBy(collection, iteratees = baseIteratee()) {
+    return orderBy(collection, iteratees, 'asc');
+}

package/dist/esm/array/sum.js

@@ -0,0 +1,19 @@
+import baseSum from '../_internal/baseSum';
+/**
+ * 对 array 中的值求和（使用 `+` 做 Lodash 式数值 coercion）。
+ *
+ * @param array - 待求和的数组
+ * @returns 总和
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.sum([4, 2, 8, 6]);
+ * // => 20
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function sum(array) {
+    return baseSum(array);
+}

package/dist/esm/array/sumBy.js

@@ -0,0 +1,25 @@
+import baseIteratee from '../_internal/baseIteratee';
+import baseSum from '../_internal/baseSum';
+/**
+ * 对 array 中 iteratee 返回值求和。
+ *
+ * @param array - 待求和的数组
+ * @param iteratee - 每次迭代调用的函数或简写
+ * @returns 总和
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.sumBy([{ n: 4 }, { n: 2 }, { n: 8 }], 'n');
+ * // => 14
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function sumBy(array, iteratee = baseIteratee()) {
+    if (array == null) {
+        return 0;
+    }
+    const resolvedIteratee = baseIteratee(iteratee);
+    return baseSum(array, (value, index, collection) => resolvedIteratee(value, index, collection));
+}

package/dist/esm/array/take.js

@@ -0,0 +1,25 @@
+import toInteger from '../_internal/toInteger';
+/**
+ * 从 array 头部截取 n 个元素。
+ *
+ * @param array - 待截取的数组
+ * @param n - 截取数量，默认 1
+ * @returns 截取后的新数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.take([1, 2, 3], 2);
+ * // => [1, 2]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function take(array, n = 1) {
+    if (!(array === null || array === void 0 ? void 0 : array.length)) {
+        return [];
+    }
+    const resolved = n === undefined ? 1 : toInteger(n);
+    const end = resolved < 0 ? 0 : resolved;
+    return array.slice(0, end);
+}

package/dist/esm/array/union.js

@@ -0,0 +1,32 @@
+/**
+ * 创建一个按 SameValueZero 去重后的并集数组。
+ *
+ * @param arrays - 一个或多个数组
+ * @returns 去重并集
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.union([2], [1, 2], [2, 3]);
+ * // => [2, 1, 3]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function union(...arrays) {
+    const seen = new Set();
+    const result = [];
+    for (const array of arrays) {
+        if (!Array.isArray(array)) {
+            continue;
+        }
+        for (const value of array) {
+            if (seen.has(value)) {
+                continue;
+            }
+            seen.add(value);
+            result.push(value);
+        }
+    }
+    return result;
+}

package/dist/esm/array/uniq.js

@@ -0,0 +1,30 @@
+/**
+ * 使用 SameValueZero 比较对 array 去重，保留首次出现的元素。
+ *
+ * @param array - 待去重的数组
+ * @returns 去重后的新数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.uniq([2, 1, 2]);
+ * // => [2, 1]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function uniq(array) {
+    if (!(array === null || array === void 0 ? void 0 : array.length)) {
+        return [];
+    }
+    const seen = new Set();
+    const result = [];
+    for (const value of array) {
+        if (seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        result.push(value);
+    }
+    return result;
+}

package/dist/esm/array/uniqBy.js

@@ -0,0 +1,35 @@
+import baseIteratee from '../_internal/baseIteratee';
+/**
+ * 按 iteratee 返回值对 collection 去重，保留首次出现的元素。
+ *
+ * @param array - 待去重的数组
+ * @param iteratee - 唯一性依据的函数或简写
+ * @returns 去重后的新数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.uniqBy([2.1, 1.2, 2.3], Math.floor);
+ * // => [2.1, 1.2]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function uniqBy(array, iteratee = baseIteratee()) {
+    if (!Array.isArray(array)) {
+        return [];
+    }
+    const resolvedIteratee = baseIteratee(iteratee);
+    const seen = new Set();
+    const result = [];
+    for (let index = 0; index < array.length; index++) {
+        const value = array[index];
+        const computed = resolvedIteratee(value, index, array);
+        if (seen.has(computed)) {
+            continue;
+        }
+        seen.add(computed);
+        result.push(value);
+    }
+    return result;
+}

package/dist/esm/array/without.js

@@ -0,0 +1,24 @@
+import baseDifference from '../_internal/baseDifference';
+import isArrayLikeObject from '../_internal/isArrayLikeObject';
+/**
+ * 创建排除指定值后的新数组，使用 SameValueZero 比较。
+ *
+ * @param array - 待处理的数组
+ * @param values - 要排除的值
+ * @returns 过滤后的新数组
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.without([2, 1, 2, 3], 1, 2);
+ * // => [3]
+ * ```
+ *
+ * @since 1.0.0
+ * @category Array
+ */
+export default function without(array, ...values) {
+    if (!isArrayLikeObject(array)) {
+        return [];
+    }
+    return baseDifference(array, values);
+}

package/dist/esm/color/getCssVariable.js

@@ -0,0 +1,28 @@
+/**
+ * 读取元素上的 CSS 自定义属性（变量）值。
+ *
+ * @param element - DOM 元素；浏览器环境默认 `document.body`
+ * @param property - CSS 变量名，如 `--primary-color`
+ * @param fallback - 无法读取时的回退值
+ * @returns 变量值或回退值
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.getCssVariable(document.body, '--primary-color', '#3370FF');
+ * // => '#3370FF'
+ * ```
+ *
+ * @since 1.0.0
+ * @category Color
+ */
+export default function getCssVariable(element, property = '--ed-color-primary', fallback = '#3370FF') {
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+        return fallback;
+    }
+    const target = element !== null && element !== void 0 ? element : document.body;
+    if (!target) {
+        return fallback;
+    }
+    const value = window.getComputedStyle(target).getPropertyValue(property).trim();
+    return value || fallback;
+}

package/dist/esm/color/getThemePalette.js

@@ -0,0 +1,53 @@
+import { formatRgbString, mixHexColorsToRgb, parseHexColor, rgbComponentsToHex, tintHexColor, } from '../_internal/colorMath';
+const DARK_TARGET = '#141414';
+/**
+ * 根据单个主色生成 Element Plus 风格的主题色板（primary + light/dark 各 9 档）。
+ *
+ * @param primaryColor - 十六进制主色，支持 `#RGB`、`#RRGGBB` 及不带 `#` 的写法
+ * @returns 色板对象；无效输入返回 `null`
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.getThemePalette('#405189');
+ * // => {
+ * //   primary: '#405189',
+ * //   light: ['rgb(83, 98, 149)', ...],
+ * //   dark: ['rgb(60, 75, 125)', ...],
+ * // }
+ * ```
+ *
+ * @since 1.0.0
+ * @category Color
+ */
+export default function getThemePalette(primaryColor) {
+    const parsed = parseHexColor(primaryColor);
+    if (!parsed) {
+        return null;
+    }
+    const primary = rgbComponentsToHex(parsed.r, parsed.g, parsed.b);
+    const light = [];
+    for (let i = 1; i <= 9; i++) {
+        const tinted = tintHexColor(primary, Number((i / 10).toFixed(2)));
+        if (!tinted) {
+            return null;
+        }
+        const rgb = parseHexColor(tinted);
+        if (!rgb) {
+            return null;
+        }
+        light.push(formatRgbString(rgb.r, rgb.g, rgb.b));
+    }
+    const dark = [];
+    for (let i = 1; i <= 9; i++) {
+        const mixed = mixHexColorsToRgb(primary, DARK_TARGET, i * 10);
+        if (!mixed) {
+            return null;
+        }
+        dark.push(mixed);
+    }
+    return {
+        primary,
+        light,
+        dark,
+    };
+}

package/dist/esm/color/hexToRgb.js

@@ -0,0 +1,23 @@
+import { parseHexColor } from '../_internal/colorMath';
+/**
+ * 将十六进制颜色转换为 CSS `rgb(r, g, b)` 字符串。
+ *
+ * @param hex - 十六进制颜色，支持 `#RGB`、`#RRGGBB` 及不带 `#` 的写法
+ * @returns 解析成功返回 `rgb(r, g, b)`；无效输入返回 `null`
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.hexToRgb('#f03');
+ * // => 'rgb(255, 0, 51)'
+ * ```
+ *
+ * @since 1.0.0
+ * @category Color
+ */
+export default function hexToRgb(hex) {
+    const rgb = parseHexColor(hex);
+    if (!rgb) {
+        return null;
+    }
+    return `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})`;
+}

package/dist/esm/color/index.js

@@ -0,0 +1,5 @@
+export { default as rgbToHex } from './rgbToHex';
+export { default as hexToRgb } from './hexToRgb';
+export { default as rgbStringToHex } from './rgbStringToHex';
+export { default as getCssVariable } from './getCssVariable';
+export { default as getThemePalette } from './getThemePalette';

package/dist/esm/color/rgbStringToHex.js

@@ -0,0 +1,36 @@
+import rgbToHex from './rgbToHex';
+const RGBA_REGEX = /^(rgb|rgba)\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)$/i;
+/**
+ * 将 `rgb()` / `rgba()` 字符串转换为十六进制颜色。
+ *
+ * @param rgbString - CSS rgb/rgba 字符串
+ * @returns 转换成功返回 `#RRGGBB` 或 `#RRGGBBAA`；无法解析时返回 `null`
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.rgbStringToHex('rgb(255, 0, 51)');
+ * // => '#FF0033'
+ * ```
+ *
+ * @since 1.0.0
+ * @category Color
+ */
+export default function rgbStringToHex(rgbString) {
+    const match = rgbString.trim().match(RGBA_REGEX);
+    if (!match) {
+        return null;
+    }
+    const r = parseInt(match[2], 10);
+    const g = parseInt(match[3], 10);
+    const b = parseInt(match[4], 10);
+    const alpha = match[5] !== undefined ? parseFloat(match[5]) : undefined;
+    const hex = rgbToHex(r, g, b);
+    if (alpha === undefined) {
+        return hex;
+    }
+    const alphaHex = Math.round(Math.max(0, Math.min(1, alpha)) * 255)
+        .toString(16)
+        .padStart(2, '0')
+        .toUpperCase();
+    return `${hex}${alphaHex}`;
+}

package/dist/esm/color/rgbToHex.js

@@ -0,0 +1,21 @@
+import { rgbComponentsToHex } from '../_internal/colorMath';
+/**
+ * 将 RGB 分量转换为 `#RRGGBB` 十六进制颜色字符串。
+ *
+ * @param r - 红色分量（0–255）
+ * @param g - 绿色分量（0–255）
+ * @param b - 蓝色分量（0–255）
+ * @returns 大写十六进制颜色，如 `#FF0033`
+ *
+ * @example
+ * ```ts
+ * zhiaiwanUtils.rgbToHex(255, 0, 51);
+ * // => '#FF0033'
+ * ```
+ *
+ * @since 1.0.0
+ * @category Color
+ */
+export default function rgbToHex(r, g, b) {
+    return rgbComponentsToHex(r, g, b);
+}

package/dist/esm/convert/index.js

@@ -0,0 +1,13 @@
+export { default as toArray } from './toArray';
+export { default as toFinite } from './toFinite';
+export { default as toInteger } from './toInteger';
+export { default as toLength } from './toLength';
+export { default as toNumber } from './toNumber';
+export { default as toSafeInteger } from './toSafeInteger';
+export { default as toString } from './toString';
+export { default as toPath } from './toPath';
+export { default as toPlainObject } from './toPlainObject';
+export { default as toPairs } from './toPairs';
+export { default as toPairsIn } from './toPairsIn';
+export { default as toLower } from './toLower';
+export { default as toUpper } from './toUpper';

package/dist/esm/convert/toArray.js

@@ -0,0 +1,50 @@
+import isArrayLike from '../_internal/isArrayLike';
+function arrayLikeToArray(value, length) {
+    const result = new Array(length);
+    for (let index = 0; index < length; index++) {
+        result[index] = value[index];
+    }
+    return result;
+}
+/**
+ * 将 value 转为数组。
+ *
+ * @param value - 待转换的值
+ * @returns 新数组
+ *
+ * @example
+ * ```ts
+ * toArray({ a: 1, b: 2 });
+ * // => [1, 2]
+ *
+ * toArray('abc');
+ * // => ['a', 'b', 'c']
+ * ```
+ *
+ * @since 1.0.0
+ * @category Convert
+ */
+export default function toArray(value) {
+    if (value == null) {
+        return [];
+    }
+    if (isArrayLike(value)) {
+        const arrayLike = value;
+        return arrayLikeToArray(arrayLike, arrayLike.length);
+    }
+    if (typeof value === 'object') {
+        const tag = Object.prototype.toString.call(value);
+        if (tag === '[object Map]') {
+            const result = [];
+            value.forEach((item) => {
+                result.push(item);
+            });
+            return result;
+        }
+        if (tag === '[object Set]') {
+            return Array.from(value);
+        }
+        return Object.values(value);
+    }
+    return [value];
+}

package/dist/esm/convert/toFinite.js

@@ -0,0 +1,28 @@
+import toNumber from './toNumber';
+const INFINITY = 1 / 0;
+const MAX_FLOAT = Number.MAX_VALUE;
+/**
+ * 将 value 转为有限数值；`Infinity` 截断为 `Number.MAX_VALUE`，`NaN` 转为 `0`。
+ *
+ * @param value - 待转换的值
+ * @returns 有限数值
+ *
+ * @example
+ * ```ts
+ * toFinite('3.2');
+ * // => 3.2
+ *
+ * toFinite(Infinity);
+ * // => 1.7976931348623157e+308
+ * ```
+ *
+ * @since 1.0.0
+ * @category Convert
+ */
+export default function toFinite(value) {
+    const result = toNumber(value);
+    if (result === INFINITY || result === -INFINITY) {
+        return result < 0 ? -MAX_FLOAT : MAX_FLOAT;
+    }
+    return result === result ? result : 0;
+}

package/dist/esm/convert/toInteger.js

@@ -0,0 +1,27 @@
+import toFinite from './toFinite';
+/**
+ * 将 value 转为整数（向 0 取整）；`NaN` / 非有限值转为 `0`。
+ *
+ * @param value - 待转换的值
+ * @returns 整数
+ *
+ * @example
+ * ```ts
+ * toInteger(3.7);
+ * // => 3
+ *
+ * toInteger('3.7');
+ * // => 3
+ * ```
+ *
+ * @since 1.0.0
+ * @category Convert
+ */
+export default function toInteger(value) {
+    const result = toFinite(value);
+    if (result === 0) {
+        return result;
+    }
+    const remainder = result % 1;
+    return remainder ? result - remainder : result;
+}

package/dist/esm/convert/toLength.js

@@ -0,0 +1,24 @@
+import toInteger from './toInteger';
+const MAX_ARRAY_LENGTH = 4294967295;
+/**
+ * 将 value 转为合法类数组长度（`0` 到 `2^32 - 1`）。
+ *
+ * @param value - 待转换的值
+ * @returns 合法长度
+ *
+ * @example
+ * ```ts
+ * toLength(3.7);
+ * // => 3
+ *
+ * toLength(-1);
+ * // => 0
+ * ```
+ *
+ * @since 1.0.0
+ * @category Convert
+ */
+export default function toLength(value) {
+    const result = toInteger(value);
+    return result < 0 ? 0 : Math.min(result, MAX_ARRAY_LENGTH);
+}

package/dist/esm/convert/toLower.js

@@ -0,0 +1,19 @@
+import toString from './toString';
+/**
+ * 将 value 转为小写字符串。
+ *
+ * @param value - 待转换的值
+ * @returns 小写字符串
+ *
+ * @example
+ * ```ts
+ * toLower('--Foo-Bar--');
+ * // => '--foo-bar--'
+ * ```
+ *
+ * @since 1.0.0
+ * @category Convert
+ */
+export default function toLower(value) {
+    return toString(value).toLowerCase();
+}

package/dist/esm/convert/toNumber.js

@@ -0,0 +1,52 @@
+const NAN = 0 / 0;
+const RE_IS_BAD_HEX = /^[-+]0x[0-9a-f]+$/i;
+const RE_IS_BINARY = /^0b[01]+$/i;
+const RE_IS_OCTAL = /^0o[0-7]+$/i;
+/**
+ * 将 value 转为数值，对齐 Lodash `toNumber` 的解析规则。
+ *
+ * @param value - 待转换的值
+ * @returns 转换后的数值
+ *
+ * @example
+ * ```ts
+ * toNumber('3.2');
+ * // => 3.2
+ *
+ * toNumber('0b101');
+ * // => 5
+ * ```
+ *
+ * @since 1.0.0
+ * @category Convert
+ */
+export default function toNumber(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'symbol') {
+        return NAN;
+    }
+    if (value != null && typeof value === 'object') {
+        const other = typeof value.valueOf === 'function'
+            ? value.valueOf()
+            : value;
+        value = typeof other === 'object' && other !== null ? String(other) : other;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed === '') {
+            return trimmed.length ? NAN : 0;
+        }
+        if (RE_IS_BAD_HEX.test(trimmed)) {
+            return NAN;
+        }
+        if (RE_IS_BINARY.test(trimmed)) {
+            return parseInt(trimmed.slice(2), 2);
+        }
+        if (RE_IS_OCTAL.test(trimmed)) {
+            return parseInt(trimmed.slice(2), 8);
+        }
+    }
+    return Number(value);
+}