@hairy/utils 1.0.20 → 1.5.0

package/{LICENSE → LICENSE.md}

@@ -1,23 +1,21 @@
-MIT License
-
-Copyright (c) 2019-PRESENT Anthony Fu<https://github.com/TuiMao233>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-
+MIT License
+
+Copyright (c) 2025-PRESENT Hairyf <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# @hairy/utils
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![bundle][bundle-src]][bundle-href]
+[![JSDocs][jsdocs-src]][jsdocs-href]
+[![License][license-src]][license-href]
+
+## Install
+
+```
+ni @hairy/utils
+```
+
+## CDN
+
+```html
+<script src="https://unpkg.com/@hairy/utils"></script>
+```
+
+## License
+
+[MIT](./LICENSE) License © [Hairyf](https://github.com/hairyf)
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/@hairy/utils?style=flat&colorA=080f12&colorB=1fa669
+[npm-version-href]: https://npmjs.com/package/@hairy/utils
+[npm-downloads-src]: https://img.shields.io/npm/dm/@hairy/utils?style=flat&colorA=080f12&colorB=1fa669
+[npm-downloads-href]: https://npmjs.com/package/@hairy/utils
+[bundle-src]: https://img.shields.io/bundlephobia/minzip/@hairy/utils?style=flat&colorA=080f12&colorB=1fa669&label=minzip
+[bundle-href]: https://bundlephobia.com/result?p=@hairy/utils
+[license-src]: https://img.shields.io/github/license/hairyf/hairylib.svg?style=flat&colorA=080f12&colorB=1fa669
+[license-href]: https://github.com/hairyf/hairylib/blob/main/LICENSE
+[jsdocs-src]: https://img.shields.io/badge/jsdocs-reference-080f12?style=flat&colorA=080f12&colorB=1fa669
+[jsdocs-href]: https://www.jsdocs.io/package/@hairy/utils

package/dist/index.cjs

@@ -0,0 +1,405 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BIG_INTS: () => BIG_INTS,
+  Bignumber: () => import_bignumber.default,
+  Deferred: () => Deferred,
+  UA: () => UA,
+  arange: () => arange,
+  average: () => average,
+  compose: () => compose,
+  cover: () => cover,
+  decimal: () => decimal,
+  delay: () => delay,
+  formToObject: () => formToObject,
+  formatNumeric: () => formatNumeric,
+  formatSize: () => formatSize,
+  formatUnit: () => formatUnit,
+  getTypeof: () => getTypeof,
+  gt: () => gt,
+  gte: () => gte,
+  integer: () => integer,
+  isAndroid: () => isAndroid,
+  isArray: () => isArray,
+  isBrowser: () => isBrowser,
+  isChrome: () => isChrome,
+  isEdge: () => isEdge,
+  isFF: () => isFF,
+  isFormData: () => isFormData,
+  isIE: () => isIE,
+  isIE11: () => isIE11,
+  isIE9: () => isIE9,
+  isIOS: () => isIOS,
+  isMobile: () => isMobile,
+  isNull: () => isNull,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isPhantomJS: () => isPhantomJS,
+  isPlainObject: () => isPlainObject,
+  isString: () => isString,
+  isTypeof: () => isTypeof,
+  isWeex: () => isWeex,
+  isWindow: () => isWindow,
+  loop: () => loop,
+  lt: () => lt,
+  lte: () => lte,
+  noop: () => noop,
+  numerfix: () => numerfix,
+  objectToForm: () => objectToForm,
+  pPipe: () => pPipe,
+  parseNumeric: () => parseNumeric,
+  percentage: () => percentage,
+  pipe: () => pipe,
+  plus: () => plus,
+  riposte: () => riposte,
+  unum: () => unum,
+  unwrap: () => unwrap,
+  weexPlatform: () => weexPlatform,
+  whenever: () => whenever,
+  zerofill: () => zerofill,
+  zeromove: () => zeromove
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/number/index.ts
+var import_bignumber = __toESM(require("bignumber.js"), 1);
+var BIG_INTS = {
+  t: { v: 10 ** 12, d: 13, n: "t" },
+  b: { v: 10 ** 9, d: 10, n: "b" },
+  m: { v: 10 ** 6, d: 7, n: "m" },
+  k: { v: 10 ** 3, d: 4, n: "k" }
+};
+function unum(num = "0") {
+  return new import_bignumber.default(numerfix(num));
+}
+function gte(num, n) {
+  return unum(num).gte(unum(n));
+}
+function gt(num, n) {
+  return unum(num).gt(unum(n));
+}
+function lte(num, n) {
+  return unum(num).lte(unum(n));
+}
+function lt(num, n) {
+  return unum(num).lt(unum(n));
+}
+function plus(array, options) {
+  const rounding = options?.r || import_bignumber.default.ROUND_DOWN;
+  const decimal2 = options?.d || 0;
+  return array.filter((v) => unum(v).gt(0)).reduce((t, v) => t.plus(unum(v)), unum(0)).toFixed(decimal2, rounding);
+}
+function average(array, options) {
+  const rounding = options?.r || import_bignumber.default.ROUND_DOWN;
+  const decimal2 = options?.d || 0;
+  if (array.length === 0)
+    return "0";
+  return unum(plus(array)).div(array.length).toFixed(decimal2, rounding);
+}
+function percentage(total, count, options) {
+  options ??= { d: 3, r: import_bignumber.default.ROUND_DOWN };
+  const rounding = options?.r || import_bignumber.default.ROUND_DOWN;
+  const decimal2 = options?.d || 3;
+  if (unum(total).lte(0) || unum(count).lte(0))
+    return "0";
+  return unum(count).div(unum(total)).times(100).toFixed(decimal2, rounding);
+}
+function zerofill(value, n = 2, type = "positive") {
+  const _value = integer(value);
+  if (_value.length >= n)
+    return value;
+  const zero = "0".repeat(n - _value.length);
+  if (type === "positive")
+    return zero + value;
+  if (type === "reverse")
+    return zero + value;
+  return "";
+}
+function zeromove(value) {
+  return value.toString().replace(/\.?0+$/, "");
+}
+function numerfix(value) {
+  const _isNaN = Number.isNaN(Number(value)) || value.toString() === "NaN";
+  if (_isNaN)
+    console.warn(`numerfix(${value}): value is not the correct value. To ensure the normal operation of the program, it will be converted to zero`);
+  return _isNaN ? "0" : String(value);
+}
+function integer(value) {
+  return new import_bignumber.default(numerfix(value)).toFixed(0);
+}
+function decimal(value, n = 2) {
+  let [integer2, decimal2] = numerfix(value).split(".");
+  if (n <= 0)
+    return integer2;
+  if (!decimal2)
+    decimal2 = "0";
+  decimal2 = decimal2.slice(0, n);
+  decimal2 = decimal2 + "0".repeat(n - decimal2.length);
+  return `${integer2}.${decimal2}`;
+}
+function parseNumeric(num, delimiters = ["t", "b", "m"]) {
+  const mappings = [
+    delimiters.includes("t") && ((n) => gte(n, BIG_INTS.t.v) && BIG_INTS.t),
+    delimiters.includes("b") && ((n) => gte(n, BIG_INTS.b.v) && lt(n, BIG_INTS.t.v) && BIG_INTS.b),
+    delimiters.includes("m") && ((n) => gte(n, BIG_INTS.m.v) && lt(n, BIG_INTS.b.v) && BIG_INTS.m),
+    delimiters.includes("k") && ((n) => gte(n, BIG_INTS.k.v) && lt(n, BIG_INTS.m.v) && BIG_INTS.k)
+  ];
+  let options;
+  for (const analy of mappings) {
+    const opts = analy && analy(unum(num).toFixed(0));
+    opts && (options = opts);
+  }
+  return options || { v: 1, d: 0, n: "" };
+}
+function formatNumeric(value = "0", options) {
+  const {
+    rounding = import_bignumber.default.ROUND_DOWN,
+    delimiters,
+    format,
+    decimals = 2
+  } = options || {};
+  const config = parseNumeric(value, delimiters || []);
+  let number = unum(value).div(config.v).toFormat(decimals, rounding, {
+    decimalSeparator: ".",
+    groupSeparator: ",",
+    groupSize: 3,
+    secondaryGroupSize: 0,
+    fractionGroupSeparator: " ",
+    fractionGroupSize: 0,
+    ...format
+  });
+  number = options?.zeromove ? zeromove(number) : number;
+  return `${number}${config.n}`;
+}
+
+// src/util/compose.ts
+var compose = (...fns) => fns.reduceRight((v, f) => f(v));
+
+// src/util/converts.ts
+function formToObject(formData) {
+  return Object.fromEntries(formData.entries());
+}
+function objectToForm(object) {
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(object)) formData.append(key, value);
+  return formData;
+}
+
+// src/util/deferred.ts
+var Deferred = class extends Promise {
+  resolve;
+  reject;
+  constructor() {
+    let _resolve, _reject;
+    super((resolve_, reject_) => {
+      _resolve = resolve_;
+      _reject = reject_;
+    });
+    this.resolve = (value) => {
+      _resolve(value);
+      return this;
+    };
+    this.reject = (reason) => {
+      _reject(reason);
+      return this;
+    };
+  }
+};
+
+// src/util/delay.ts
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/util/is.ts
+var isBrowser = () => typeof window !== "undefined";
+var isWeex = () => typeof WXEnvironment !== "undefined" && !!WXEnvironment.platform;
+var weexPlatform = () => isWeex() && WXEnvironment.platform.toLowerCase();
+var UA = () => isBrowser() && window.navigator.userAgent.toLowerCase() || "";
+var isIE = () => UA() && /msie|trident/.test(UA());
+var isIE9 = () => UA() && UA().indexOf("msie 9.0") > 0;
+var isIE11 = () => isBrowser() && navigator.userAgent.includes("Trident") && navigator.userAgent.includes("rv:11.0");
+var isEdge = () => UA() && UA().indexOf("edge/") > 0;
+var isAndroid = () => UA() && UA().indexOf("android") > 0 || weexPlatform() === "android";
+var isIOS = () => UA() && /iphone|ipad|ipod|ios/.test(UA()) || weexPlatform() === "ios";
+var isChrome = () => UA() && /chrome\/\d+/.test(UA()) && !isEdge();
+var isPhantomJS = () => UA() && /phantomjs/.test(UA());
+var isFF = () => typeof UA() === "string" && UA().match(/firefox\/(\d+)/);
+var isMobile = () => isBrowser() && navigator.userAgent.toLowerCase().includes("mobile");
+var isObject = (value) => typeof value === "object" && !Array.isArray(value);
+var isNumber = (value) => typeof value === "number";
+var isString = (value) => typeof value === "string";
+var isArray = (value) => Array.isArray(value);
+var isNull = (value) => value === null;
+var isPlainObject = (value) => typeof value === "object" && value !== null && value.constructor === Object;
+var isFormData = (value) => isObject(value) && isBrowser() && value instanceof FormData;
+var isWindow = (value) => typeof window !== "undefined" && toString.call(value) === "[object Window]";
+
+// src/util/noop.ts
+var noop = () => {
+};
+
+// src/util/p-pipe.ts
+function pPipe(...functions) {
+  if (functions.length === 0)
+    throw new Error("Expected at least one argument");
+  return async (input) => {
+    let currentValue = input;
+    for (const function_ of functions)
+      currentValue = await function_(currentValue);
+    return currentValue;
+  };
+}
+
+// src/util/pipe.ts
+var pipe = (...fns) => fns.reduce((v, f) => f(v));
+
+// src/util/util.ts
+function arange(x1, x2, stp = 1, z = [], z0 = z.length) {
+  if (!x2)
+    x1 -= x2 = x1;
+  for (let z1 = z0 + Math.max(Math.ceil((++x2 - x1) / stp), 0); z0 < z1; x1 += stp)
+    z[z0++] = x1;
+  return z;
+}
+function loop(fn) {
+  async function next(ms) {
+    await delay(ms);
+    return fn(next);
+  }
+  return fn(next);
+}
+function riposte(...args) {
+  for (const [cond, value] of args) {
+    if (cond)
+      return value;
+  }
+  return void 0;
+}
+function unwrap(value) {
+  return typeof value === "function" ? value() : value;
+}
+function whenever(value, callback) {
+  return value ? callback(value) : void 0;
+}
+
+// src/size/index.ts
+function formatUnit(value, unit = "px") {
+  if (!(isString(value) || isNumber(value)))
+    return "";
+  value = String(value);
+  return /\D/.test(value) ? value : value + unit;
+}
+function formatSize(dimension, unit) {
+  const _formatUnit = (value) => formatUnit(value, unit);
+  if (typeof dimension === "string" || typeof dimension === "number")
+    return { width: _formatUnit(dimension), height: _formatUnit(dimension) };
+  if (Array.isArray(dimension))
+    return { width: _formatUnit(dimension[0]), height: _formatUnit(dimension[1]) };
+  if (typeof dimension === "object")
+    return { width: _formatUnit(dimension.width), height: _formatUnit(dimension.height) };
+  return { width: "", height: "" };
+}
+
+// src/string/index.ts
+function cover(value, mode, symbol = "*") {
+  return value.slice(0, mode[0]) + symbol.repeat(mode[1]) + value.slice(-mode[2]);
+}
+
+// src/typeof/index.ts
+function getTypeof(target) {
+  const value = Object.prototype.toString.call(target).slice(8, -1).toLocaleLowerCase();
+  return value;
+}
+function isTypeof(target, type) {
+  return getTypeof(target) === type;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BIG_INTS,
+  Bignumber,
+  Deferred,
+  UA,
+  arange,
+  average,
+  compose,
+  cover,
+  decimal,
+  delay,
+  formToObject,
+  formatNumeric,
+  formatSize,
+  formatUnit,
+  getTypeof,
+  gt,
+  gte,
+  integer,
+  isAndroid,
+  isArray,
+  isBrowser,
+  isChrome,
+  isEdge,
+  isFF,
+  isFormData,
+  isIE,
+  isIE11,
+  isIE9,
+  isIOS,
+  isMobile,
+  isNull,
+  isNumber,
+  isObject,
+  isPhantomJS,
+  isPlainObject,
+  isString,
+  isTypeof,
+  isWeex,
+  isWindow,
+  loop,
+  lt,
+  lte,
+  noop,
+  numerfix,
+  objectToForm,
+  pPipe,
+  parseNumeric,
+  percentage,
+  pipe,
+  plus,
+  riposte,
+  unum,
+  unwrap,
+  weexPlatform,
+  whenever,
+  zerofill,
+  zeromove
+});