@unicom-cloud/utils 0.1.11 → 0.1.13

package/tinycolor/src/random.js

@@ -0,0 +1,221 @@
+import { TinyColor as l } from "./index.js";
+function g(e = {}) {
+  if (e.count !== void 0 && e.count !== null) {
+    const a = e.count, u = [];
+    for (e.count = void 0; a > u.length; )
+      e.count = null, e.seed && (e.seed += 1), u.push(g(e));
+    return e.count = a, u;
+  }
+  const n = w(e.hue, e.seed), o = R(n, e), r = B(n, o, e), t = { h: n, s: o, v: r };
+  return e.alpha !== void 0 && (t.a = e.alpha), new l(t);
+}
+function w(e, n) {
+  const o = M(e);
+  let r = s(o, n);
+  return r < 0 && (r = 360 + r), r;
+}
+function R(e, n) {
+  if (n.hue === "monochrome")
+    return 0;
+  if (n.luminosity === "random")
+    return s([0, 100], n.seed);
+  const { saturationRange: o } = i(e);
+  let r = o[0], t = o[1];
+  switch (n.luminosity) {
+    case "bright":
+      r = 55;
+      break;
+    case "dark":
+      r = t - 10;
+      break;
+    case "light":
+      t = 55;
+      break;
+  }
+  return s([r, t], n.seed);
+}
+function B(e, n, o) {
+  let r = k(e, n), t = 100;
+  switch (o.luminosity) {
+    case "dark":
+      t = r + 20;
+      break;
+    case "light":
+      r = (t + r) / 2;
+      break;
+    case "random":
+      r = 0, t = 100;
+      break;
+  }
+  return s([r, t], o.seed);
+}
+function k(e, n) {
+  const { lowerBounds: o } = i(e);
+  for (let r = 0; r < o.length - 1; r++) {
+    const t = o[r][0], a = o[r][1], u = o[r + 1][0], d = o[r + 1][1];
+    if (n >= t && n <= u) {
+      const c = (d - a) / (u - t), m = a - c * t;
+      return c * n + m;
+    }
+  }
+  return 0;
+}
+function M(e) {
+  const n = parseInt(e, 10);
+  if (!Number.isNaN(n) && n < 360 && n > 0)
+    return [n, n];
+  if (typeof e == "string") {
+    const o = f.find((t) => t.name === e);
+    if (o) {
+      const t = h(o);
+      if (t.hueRange)
+        return t.hueRange;
+    }
+    const r = new l(e);
+    if (r.isValid) {
+      const t = r.toHsv().h;
+      return [t, t];
+    }
+  }
+  return [0, 360];
+}
+function i(e) {
+  e >= 334 && e <= 360 && (e -= 360);
+  for (const n of f) {
+    const o = h(n);
+    if (o.hueRange && e >= o.hueRange[0] && e <= o.hueRange[1])
+      return o;
+  }
+  throw Error("Color not found");
+}
+function s(e, n) {
+  if (n === void 0)
+    return Math.floor(e[0] + Math.random() * (e[1] + 1 - e[0]));
+  const o = e[1] || 1, r = e[0] || 0;
+  n = (n * 9301 + 49297) % 233280;
+  const t = n / 233280;
+  return Math.floor(r + t * (o - r));
+}
+function h(e) {
+  const n = e.lowerBounds[0][0], o = e.lowerBounds[e.lowerBounds.length - 1][0], r = e.lowerBounds[e.lowerBounds.length - 1][1], t = e.lowerBounds[0][1];
+  return {
+    name: e.name,
+    hueRange: e.hueRange,
+    lowerBounds: e.lowerBounds,
+    saturationRange: [n, o],
+    brightnessRange: [r, t]
+  };
+}
+const f = [
+  {
+    name: "monochrome",
+    hueRange: null,
+    lowerBounds: [
+      [0, 0],
+      [100, 0]
+    ]
+  },
+  {
+    name: "red",
+    hueRange: [-26, 18],
+    lowerBounds: [
+      [20, 100],
+      [30, 92],
+      [40, 89],
+      [50, 85],
+      [60, 78],
+      [70, 70],
+      [80, 60],
+      [90, 55],
+      [100, 50]
+    ]
+  },
+  {
+    name: "orange",
+    hueRange: [19, 46],
+    lowerBounds: [
+      [20, 100],
+      [30, 93],
+      [40, 88],
+      [50, 86],
+      [60, 85],
+      [70, 70],
+      [100, 70]
+    ]
+  },
+  {
+    name: "yellow",
+    hueRange: [47, 62],
+    lowerBounds: [
+      [25, 100],
+      [40, 94],
+      [50, 89],
+      [60, 86],
+      [70, 84],
+      [80, 82],
+      [90, 80],
+      [100, 75]
+    ]
+  },
+  {
+    name: "green",
+    hueRange: [63, 178],
+    lowerBounds: [
+      [30, 100],
+      [40, 90],
+      [50, 85],
+      [60, 81],
+      [70, 74],
+      [80, 64],
+      [90, 50],
+      [100, 40]
+    ]
+  },
+  {
+    name: "blue",
+    hueRange: [179, 257],
+    lowerBounds: [
+      [20, 100],
+      [30, 86],
+      [40, 80],
+      [50, 74],
+      [60, 60],
+      [70, 52],
+      [80, 44],
+      [90, 39],
+      [100, 35]
+    ]
+  },
+  {
+    name: "purple",
+    hueRange: [258, 282],
+    lowerBounds: [
+      [20, 100],
+      [30, 87],
+      [40, 79],
+      [50, 70],
+      [60, 65],
+      [70, 59],
+      [80, 52],
+      [90, 45],
+      [100, 42]
+    ]
+  },
+  {
+    name: "pink",
+    hueRange: [283, 334],
+    lowerBounds: [
+      [20, 100],
+      [30, 90],
+      [40, 86],
+      [60, 84],
+      [80, 80],
+      [90, 75],
+      [100, 73]
+    ]
+  }
+];
+export {
+  f as bounds,
+  g as random
+};

package/tinycolor/src/readability.js

@@ -0,0 +1,37 @@
+import { TinyColor as a } from "./index.js";
+function i(n, t) {
+  const l = new a(n), e = new a(t);
+  return (Math.max(l.getLuminance(), e.getLuminance()) + 0.05) / (Math.min(l.getLuminance(), e.getLuminance()) + 0.05);
+}
+function f(n, t, l = { level: "AA", size: "small" }) {
+  const e = i(n, t);
+  switch ((l.level ?? "AA") + (l.size ?? "small")) {
+    case "AAsmall":
+    case "AAAlarge":
+      return e >= 4.5;
+    case "AAlarge":
+      return e >= 3;
+    case "AAAsmall":
+      return e >= 7;
+    default:
+      return !1;
+  }
+}
+function m(n, t, l = {
+  includeFallbackColors: !1,
+  level: "AA",
+  size: "small"
+}) {
+  let e = null, c = 0;
+  const { includeFallbackColors: o, level: u, size: A } = l;
+  for (const s of t) {
+    const r = i(n, s);
+    r > c && (c = r, e = new a(s));
+  }
+  return f(n, e, { level: u, size: A }) || !o ? e : (l.includeFallbackColors = !1, m(n, ["#fff", "#000"], l));
+}
+export {
+  f as isReadable,
+  m as mostReadable,
+  i as readability
+};

package/tinycolor/src/to-ms-filter.js

@@ -0,0 +1,15 @@
+import { rgbaToArgbHex as i } from "./conversion.js";
+import { TinyColor as g } from "./index.js";
+function d(s, o) {
+  const r = new g(s), e = `#${i(r.r, r.g, r.b, r.a)}`;
+  let n = e;
+  const a = r.gradientType ? "GradientType = 1, " : "";
+  if (o) {
+    const t = new g(o);
+    n = `#${i(t.r, t.g, t.b, t.a)}`;
+  }
+  return `progid:DXImageTransform.Microsoft.gradient(${a}startColorstr=${e},endColorstr=${n})`;
+}
+export {
+  d as toMsFilter
+};

package/tinycolor/src/util.js

@@ -0,0 +1,32 @@
+function o(t, r) {
+  i(t) && (t = "100%");
+  const e = n(t);
+  return t = r === 360 ? t : Math.min(r, Math.max(0, parseFloat(t))), e && (t = parseInt(String(t * r), 10) / 100), Math.abs(t - r) < 1e-6 ? 1 : (r === 360 ? t = (t < 0 ? t % r + r : t % r) / parseFloat(String(r)) : t = t % r / parseFloat(String(r)), t);
+}
+function u(t) {
+  return Math.min(1, Math.max(0, t));
+}
+function i(t) {
+  return typeof t == "string" && t.indexOf(".") !== -1 && parseFloat(t) === 1;
+}
+function n(t) {
+  return typeof t == "string" && t.indexOf("%") !== -1;
+}
+function f(t) {
+  return t = parseFloat(t), (isNaN(t) || t < 0 || t > 1) && (t = 1), t;
+}
+function s(t) {
+  return Number(t) <= 1 ? `${Number(t) * 100}%` : t;
+}
+function p(t) {
+  return t.length === 1 ? "0" + t : String(t);
+}
+export {
+  o as bound01,
+  f as boundAlpha,
+  u as clamp01,
+  s as convertToPercentage,
+  i as isOnePointZero,
+  n as isPercentage,
+  p as pad2
+};

package/tinycolor.js

@@ -0,0 +1,46 @@
+import { cmykToRgb as e, convertDecimalToHex as t, convertHexToDecimal as a, hslToRgb as n, hsvToRgb as b, numberInputToObject as m, parseIntFromHex as T, rgbToCmyk as i, rgbToHex as g, rgbToHsl as p, rgbToHsv as l, rgbToRgb as s, rgbaToArgbHex as x, rgbaToHex as c } from "./tinycolor/src/conversion.js";
+import { names as f } from "./tinycolor/src/css-color-names.js";
+import { inputToRGB as u, isValidCSSUnit as H, stringInputToObject as y } from "./tinycolor/src/format-input.js";
+import { fromRatio as C, legacyRandom as h } from "./tinycolor/src/from-ratio.js";
+import { TinyColor as O, TinyColor as P } from "./tinycolor/src/index.js";
+import { bounds as k, random as A } from "./tinycolor/src/random.js";
+import { isReadable as F, mostReadable as S, readability as B } from "./tinycolor/src/readability.js";
+import { toMsFilter as M } from "./tinycolor/src/to-ms-filter.js";
+import { bound01 as V, boundAlpha as Z, clamp01 as q, convertToPercentage as w, isOnePointZero as z, isPercentage as E, pad2 as J } from "./tinycolor/src/util.js";
+export {
+  O as TinyColor,
+  V as bound01,
+  Z as boundAlpha,
+  k as bounds,
+  q as clamp01,
+  e as cmykToRgb,
+  t as convertDecimalToHex,
+  a as convertHexToDecimal,
+  w as convertToPercentage,
+  P as default,
+  C as fromRatio,
+  n as hslToRgb,
+  b as hsvToRgb,
+  u as inputToRGB,
+  z as isOnePointZero,
+  E as isPercentage,
+  F as isReadable,
+  H as isValidCSSUnit,
+  h as legacyRandom,
+  S as mostReadable,
+  f as names,
+  m as numberInputToObject,
+  J as pad2,
+  T as parseIntFromHex,
+  A as random,
+  B as readability,
+  i as rgbToCmyk,
+  g as rgbToHex,
+  p as rgbToHsl,
+  l as rgbToHsv,
+  s as rgbToRgb,
+  x as rgbaToArgbHex,
+  c as rgbaToHex,
+  y as stringInputToObject,
+  M as toMsFilter
+};

package/tree/index.js

@@ -1,3 +1,4 @@
+import { default as I } from "./search/index.js";
 function a(e, r, f, l = "children") {
   if (Array.isArray(e) && (e = {
     [l]: e
@@ -31,7 +32,7 @@ function y(e, r, f, l = "children") {
   }
 }
 const d = a;
-function A(e, r, f, l = "children") {
+function h(e, r, f, l = "children") {
   if (!e) return;
   const t = Array.isArray(e) ? [...e] : [e];
   e: for (; t.length; ) {
@@ -50,14 +51,14 @@ function A(e, r, f, l = "children") {
         t.push(i[u - 1 - n]);
   }
 }
-function h(e, r) {
+function A(e, r) {
   return y(e, "id", r);
 }
-function g(e, r, f = !0) {
+function m(e, r, f = !0) {
   let l = y(e, "value", r)?.label;
   return !l && f && (l = r), l;
 }
-function m(e, r, f, l = "children") {
+function g(e, r, f, l = "children") {
   if (!e) return;
   let t = null;
   function i(n) {
@@ -77,10 +78,11 @@ function m(e, r, f, l = "children") {
 export {
   y as default,
   a as findNodeBy,
-  m as getChildWithParentBy,
+  g as getChildWithParentBy,
   y as getItemBy,
   d as getItemBy2,
-  A as getItemBy3,
-  h as getItemByID,
-  g as getLabelFromDictionaryByValue
+  h as getItemBy3,
+  A as getItemByID,
+  m as getLabelFromDictionaryByValue,
+  I as searchTree
 };

package/tree/search/index.js

@@ -0,0 +1,90 @@
+import "../../is/index.js";
+import A from "lodash/isArray";
+import z from "lodash/isObjectLike";
+import w from "lodash/isString";
+import T from "lodash/isFunction";
+function v(r, l, a, f) {
+  return l && r ? { shouldExit: !0, newMatch: !0 } : a && !r ? { shouldExit: !0, newMatch: !1 } : { shouldExit: !1, newMatch: f || r };
+}
+function q(r, l, a = {}) {
+  if (!A(r)) throw new TypeError("参数treeData必须是一个数组");
+  if (!z(l)) throw new TypeError("参数searchCondition必须是一个对象");
+  const f = {
+    strategy: "BFS",
+    childrenKey: "children",
+    strict: !1,
+    fuzzyMatch: !1,
+    returnAllMatches: !1,
+    caseSensitive: !1,
+    allowEmptyString: !1,
+    matchMode: "AND",
+    ...a
+    // 用户配置覆盖默认值
+  }, {
+    strategy: p,
+    childrenKey: S,
+    strict: x,
+    fuzzyMatch: O,
+    returnAllMatches: y,
+    caseSensitive: m,
+    allowEmptyString: B,
+    matchMode: E
+  } = f, M = E === "OR", g = E === "AND", h = p === "BFS";
+  if (!(h || p === "DFS")) throw new Error('配置 strategy 必须是 "BFS" 或 "DFS"');
+  if (!(M || g)) throw new Error('配置 matchMode 必须是 "AND" 或 "OR"');
+  if (!w(S)) throw new TypeError("配置 childrenKey 必须是字符串");
+  const c = [...r], F = [], D = Object.entries(l);
+  if (D.length) {
+    const N = (s) => {
+      let t = !1;
+      for (const [n, e] of D) {
+        const i = s[n];
+        if (e === "" && !B)
+          continue;
+        let o = !1;
+        try {
+          if (e instanceof RegExp)
+            o = w(i) ? e.test(i) : !1;
+          else if (T(e))
+            o = !!e(i);
+          else if (O && w(e)) {
+            const d = String(i), R = m ? e : e.toLowerCase();
+            o = (m ? d : d.toLowerCase()).includes(R);
+          } else
+            o = x ? i === e : i == e;
+        } catch {
+          o = !1;
+        }
+        const u = v(o, M, g, t);
+        if (u.shouldExit)
+          return u.newMatch;
+        t = u.newMatch;
+      }
+      return t;
+    };
+    for (; c.length > 0; ) {
+      const s = h ? c.shift() : c.pop();
+      if (!s) continue;
+      try {
+        if (N(s))
+          if (y)
+            F.push(s);
+          else
+            return s;
+      } catch {
+        continue;
+      }
+      const t = s[S];
+      if (A(t))
+        if (h)
+          c.push(...t);
+        else
+          for (let n = t.length - 1; n >= 0; n--)
+            c.push(t[n]);
+    }
+  }
+  return y ? F : null;
+}
+export {
+  q as default
+};

package/tree.js

@@ -1,11 +1,13 @@
-import { getItemBy as y, findNodeBy as B, getChildWithParentBy as g, getItemBy as m, getItemBy2 as a, getItemBy3 as I, getItemByID as i, getLabelFromDictionaryByValue as o } from "./tree/index.js";
+import { default as a } from "./tree/search/index.js";
+import { getItemBy as y, findNodeBy as m, getChildWithParentBy as B, getItemBy as g, getItemBy2 as o, getItemBy3 as I, getItemByID as d, getLabelFromDictionaryByValue as f } from "./tree/index.js";
 export {
   y as default,
-  B as findNodeBy,
-  g as getChildWithParentBy,
-  m as getItemBy,
-  a as getItemBy2,
+  m as findNodeBy,
+  B as getChildWithParentBy,
+  g as getItemBy,
+  o as getItemBy2,
   I as getItemBy3,
-  i as getItemByID,
-  o as getLabelFromDictionaryByValue
+  d as getItemByID,
+  f as getLabelFromDictionaryByValue,
+  a as searchTree
 };

package/types/date/index.d.ts

@@ -0,0 +1,4 @@
+export function convertToDurationBasedOnTimeUnits(duration: any, unit: any): string;
+export function dateFormat(date: any, template: any): any;
+export { default as convertTime } from "./convertTime";
+export { dateFormat as dayjsFormat };

package/types/filesize/src/constants.d.ts

@@ -1,24 +1,24 @@
-export const ARRAY: "array";
+export const INVALID_NUMBER: "Invalid number";
+export const INVALID_ROUND: "Invalid rounding method";
+export const IEC: "iec";
+export const JEDEC: "jedec";
+export const SI: "si";
 export const BIT: "bit";
 export const BITS: "bits";
 export const BYTE: "byte";
 export const BYTES: "bytes";
-export const EMPTY: "";
-export const EXPONENT: "exponent";
+export const SI_KBIT: "kbit";
+export const SI_KBYTE: "kB";
+export const ARRAY: "array";
 export const FUNCTION: "function";
-export const IEC: "iec";
-export const INVALID_NUMBER: "Invalid number";
-export const INVALID_ROUND: "Invalid rounding method";
-export const JEDEC: "jedec";
 export const OBJECT: "object";
-export const PERIOD: ".";
+export const STRING: "string";
+export const EXPONENT: "exponent";
 export const ROUND: "round";
+export const EMPTY: "";
+export const PERIOD: ".";
 export const S: "s";
-export const SI: "si";
-export const SI_KBIT: "kbit";
-export const SI_KBYTE: "kB";
 export const SPACE: " ";
-export const STRING: "string";
 export const ZERO: "0";
 export namespace STRINGS {
     namespace symbol {

package/types/filesize/src/filesize.d.ts

@@ -1,47 +1,88 @@
-export function filesize(arg: any, { bits, pad, base, round, locale, localeOptions, separator, spacer, symbols, standard, output, fullform, fullforms, exponent, roundingMethod, precision, }?: {
+/**
+ * Converts a file size in bytes to a human-readable string with appropriate units
+ * @param {number|string|bigint} arg - The file size in bytes to convert
+ * @param {Object} [options={}] - Configuration options for formatting
+ * @param {boolean} [options.bits=false] - If true, calculates bits instead of bytes
+ * @param {boolean} [options.pad=false] - If true, pads decimal places to match round parameter
+ * @param {number} [options.base=-1] - Number base (2 for binary, 10 for decimal, -1 for auto)
+ * @param {number} [options.round=2] - Number of decimal places to round to
+ * @param {string|boolean} [options.locale=""] - Locale for number formatting, true for system locale
+ * @param {Object} [options.localeOptions={}] - Additional options for locale formatting
+ * @param {string} [options.separator=""] - Custom decimal separator
+ * @param {string} [options.spacer=" "] - String to separate value and unit
+ * @param {Object} [options.symbols={}] - Custom unit symbols
+ * @param {string} [options.standard=""] - Unit standard to use (SI, IEC, JEDEC)
+ * @param {string} [options.output="string"] - Output format: "string", "array", "object", or "exponent"
+ * @param {boolean} [options.fullform=false] - If true, uses full unit names instead of abbreviations
+ * @param {Array} [options.fullforms=[]] - Custom full unit names
+ * @param {number} [options.exponent=-1] - Force specific exponent (-1 for auto)
+ * @param {string} [options.roundingMethod="round"] - Math rounding method to use
+ * @param {number} [options.precision=0] - Number of significant digits (0 for auto)
+ * @returns {string|Array|Object|number} Formatted file size based on output option
+ * @throws {TypeError} When arg is not a valid number or roundingMethod is invalid
+ * @example
+ * filesize(1024) // "1 KB"
+ * filesize(1024, {bits: true}) // "8 Kb"
+ * filesize(1024, {output: "object"}) // {value: 1, symbol: "KB", exponent: 1, unit: "KB"}
+ */
+export function filesize(arg: number | string | bigint, { bits, pad, base, round, locale, localeOptions, separator, spacer, symbols, standard, output, fullform, fullforms, exponent, roundingMethod, precision, }?: {
     bits?: boolean | undefined;
     pad?: boolean | undefined;
     base?: number | undefined;
     round?: number | undefined;
-    locale?: string | undefined;
-    localeOptions?: {} | undefined;
+    locale?: string | boolean | undefined;
+    localeOptions?: Object | undefined;
     separator?: string | undefined;
     spacer?: string | undefined;
-    symbols?: {} | undefined;
+    symbols?: Object | undefined;
     standard?: string | undefined;
     output?: string | undefined;
     fullform?: boolean | undefined;
-    fullforms?: never[] | undefined;
+    fullforms?: any[] | undefined;
     exponent?: number | undefined;
     roundingMethod?: string | undefined;
     precision?: number | undefined;
-}): string | number | any[] | {
-    value: any;
-    symbol: any;
-    exponent: number;
-    unit: string;
-};
+}): string | any[] | Object | number;
+/**
+ * Creates a partially applied version of filesize with preset options
+ * @param {Object} [options={}] - Default options to apply to the returned function
+ * @param {boolean} [options.bits=false] - If true, calculates bits instead of bytes
+ * @param {boolean} [options.pad=false] - If true, pads decimal places to match round parameter
+ * @param {number} [options.base=-1] - Number base (2 for binary, 10 for decimal, -1 for auto)
+ * @param {number} [options.round=2] - Number of decimal places to round to
+ * @param {string|boolean} [options.locale=""] - Locale for number formatting, true for system locale
+ * @param {Object} [options.localeOptions={}] - Additional options for locale formatting
+ * @param {string} [options.separator=""] - Custom decimal separator
+ * @param {string} [options.spacer=" "] - String to separate value and unit
+ * @param {Object} [options.symbols={}] - Custom unit symbols
+ * @param {string} [options.standard=""] - Unit standard to use (SI, IEC, JEDEC)
+ * @param {string} [options.output="string"] - Output format: "string", "array", "object", or "exponent"
+ * @param {boolean} [options.fullform=false] - If true, uses full unit names instead of abbreviations
+ * @param {Array} [options.fullforms=[]] - Custom full unit names
+ * @param {number} [options.exponent=-1] - Force specific exponent (-1 for auto)
+ * @param {string} [options.roundingMethod="round"] - Math rounding method to use
+ * @param {number} [options.precision=0] - Number of significant digits (0 for auto)
+ * @returns {Function} A function that takes a file size and returns formatted output
+ * @example
+ * const formatBytes = partial({round: 1, standard: "IEC"});
+ * formatBytes(1024) // "1.0 KiB"
+ * formatBytes(2048) // "2.0 KiB"
+ */
 export function partial({ bits, pad, base, round, locale, localeOptions, separator, spacer, symbols, standard, output, fullform, fullforms, exponent, roundingMethod, precision, }?: {
     bits?: boolean | undefined;
     pad?: boolean | undefined;
     base?: number | undefined;
     round?: number | undefined;
-    locale?: string | undefined;
-    localeOptions?: {} | undefined;
+    locale?: string | boolean | undefined;
+    localeOptions?: Object | undefined;
     separator?: string | undefined;
     spacer?: string | undefined;
-    symbols?: {} | undefined;
+    symbols?: Object | undefined;
     standard?: string | undefined;
     output?: string | undefined;
     fullform?: boolean | undefined;
-    fullforms?: never[] | undefined;
+    fullforms?: any[] | undefined;
     exponent?: number | undefined;
     roundingMethod?: string | undefined;
     precision?: number | undefined;
-}): (arg: any) => string | number | any[] | {
-    value: any;
-    symbol: any;
-    exponent: number;
-    unit: string;
-};
-export default filesize;
+}): Function;