@yamada-ui/utils 0.1.0

package/dist/chunk-FW7XS4NH.mjs

@@ -0,0 +1,120 @@
+// src/dom.ts
+var createdDom = () => !!(typeof window !== "undefined" && window.document && window.document.createElement);
+var getPlatform = () => {
+  var _a, _b;
+  return (_b = (_a = navigator.userAgentData) == null ? void 0 : _a.platform) != null ? _b : navigator.platform;
+};
+var vendor = (v) => createdDom() && v.test(navigator.vendor);
+var platform = (v) => createdDom() && v.test(getPlatform());
+var isMac = () => platform(/^mac/);
+var isApple = () => platform(/mac|iphone|ipad|ipod/i);
+var isSafari = () => isApple() && vendor(/apple/i);
+var isElement = (el) => el != null && typeof el == "object" && "nodeType" in el && el.nodeType === Node.ELEMENT_NODE;
+var isHTMLElement = (el) => {
+  var _a;
+  if (!isElement(el))
+    return false;
+  const win = (_a = el.ownerDocument.defaultView) != null ? _a : window;
+  return el instanceof win.HTMLElement;
+};
+var isHidden = (el) => {
+  if (el.parentElement && isHidden(el.parentElement))
+    return true;
+  return el.hidden;
+};
+var isDisabled = (el) => Boolean(el.getAttribute("disabled")) === true || Boolean(el.getAttribute("aria-disabled")) === true;
+var isVisible = (el) => el.offsetWidth > 0 && el.offsetHeight > 0;
+var hasTabIndex = (el) => el.hasAttribute("tabindex");
+var isContentEditable = (el) => {
+  const value = el.getAttribute("contenteditable");
+  return value !== "false" && value != null;
+};
+var isContains = (parent, child) => {
+  return parent === child || (parent == null ? void 0 : parent.contains(child));
+};
+var getEventRelatedTarget = (ev) => {
+  var _a;
+  return (_a = ev.relatedTarget) != null ? _a : ev.currentTarget.ownerDocument.activeElement;
+};
+var dataAttr = (condition) => condition ? "" : void 0;
+var ariaAttr = (condition) => condition ? true : void 0;
+var focusableElList = [
+  "input:not(:disabled):not([disabled])",
+  "select:not(:disabled):not([disabled])",
+  "textarea:not(:disabled):not([disabled])",
+  "embed",
+  "iframe",
+  "object",
+  "a[href]",
+  "area[href]",
+  "button:not(:disabled):not([disabled])",
+  "[tabindex]",
+  "audio[controls]",
+  "video[controls]",
+  "*[tabindex]:not([aria-disabled])",
+  "*[contenteditable]"
+];
+var focusableElSelector = focusableElList.join();
+var getAllFocusable = (container) => {
+  const focusableEls = Array.from(container.querySelectorAll(focusableElSelector));
+  focusableEls.unshift(container);
+  return focusableEls.filter((el) => isFocusable(el) && isVisible(el));
+};
+var isFocusable = (el) => {
+  if (!isHTMLElement(el) || isHidden(el) || isDisabled(el)) {
+    return false;
+  }
+  const { localName } = el;
+  const focusableTags = ["input", "select", "textarea", "button"];
+  if (focusableTags.indexOf(localName) >= 0)
+    return true;
+  const others = {
+    a: () => el.hasAttribute("href"),
+    audio: () => el.hasAttribute("controls"),
+    video: () => el.hasAttribute("controls")
+  };
+  if (localName in others)
+    return others[localName]();
+  if (isContentEditable(el))
+    return true;
+  return hasTabIndex(el);
+};
+var hasNegativeTabIndex = (el) => hasTabIndex(el) && el.tabIndex === -1;
+var isTabbable = (el) => el ? isHTMLElement(el) && isFocusable(el) && !hasNegativeTabIndex(el) : false;
+var getOwnerWindow = (node) => {
+  var _a, _b;
+  return (_b = (_a = getOwnerDocument(node)) == null ? void 0 : _a.defaultView) != null ? _b : window;
+};
+var getOwnerDocument = (el) => isElement(el) ? el.ownerDocument : document;
+var getActiveElement = (el) => getOwnerDocument(el).activeElement;
+var isActiveElement = (el) => {
+  return getActiveElement(el) === el;
+};
+
+export {
+  createdDom,
+  getPlatform,
+  vendor,
+  platform,
+  isMac,
+  isApple,
+  isSafari,
+  isElement,
+  isHTMLElement,
+  isHidden,
+  isDisabled,
+  hasTabIndex,
+  isContentEditable,
+  isContains,
+  getEventRelatedTarget,
+  dataAttr,
+  ariaAttr,
+  getAllFocusable,
+  isFocusable,
+  hasNegativeTabIndex,
+  isTabbable,
+  getOwnerWindow,
+  getOwnerDocument,
+  getActiveElement,
+  isActiveElement
+};

package/dist/chunk-IVGIIDMV.mjs

@@ -0,0 +1,28 @@
+// src/assertion.ts
+var isNumber = (value) => typeof value === "number";
+var isNotNumber = (value) => typeof value !== "number" || Number.isNaN(value) || !Number.isFinite(value);
+var isNumeric = (value) => value != null && parseFloat(value.toString()) - parseFloat(value.toString()) + 1 >= 0;
+var isString = (value) => Object.prototype.toString.call(value) === "[object String]";
+var isUndefined = (value) => typeof value === "undefined" && value === void 0;
+var isNull = (value) => value === null;
+var isObject = (value) => value !== null && (typeof value === "object" || typeof value === "function") && !Array.isArray(value);
+var isArray = (value) => Array.isArray(value);
+var isEmpty = (value) => !Array.isArray(value) || !value.length || value.every((v) => v == null);
+var isFunction = (value) => typeof value === "function";
+var isUnit = (value) => /[0-9].*[px|rem|em|%|vw|vh]$/.test(value);
+var cast = (value) => value;
+
+export {
+  isNumber,
+  isNotNumber,
+  isNumeric,
+  isString,
+  isUndefined,
+  isNull,
+  isObject,
+  isArray,
+  isEmpty,
+  isFunction,
+  isUnit,
+  cast
+};

package/dist/chunk-PF7LRFIA.mjs

@@ -0,0 +1,51 @@
+// src/event.ts
+var isMouseEvent = (ev) => {
+  const win = getEventWindow(ev);
+  if (typeof win.PointerEvent !== "undefined" && ev instanceof win.PointerEvent)
+    return !!(ev.pointerType === "mouse");
+  return ev instanceof win.MouseEvent;
+};
+var isTouchEvent = (ev) => !!ev.touches;
+var isMultiTouchEvent = (ev) => isTouchEvent(ev) && ev.touches.length > 1;
+var getEventWindow = (ev) => {
+  var _a;
+  return (_a = ev.view) != null ? _a : window;
+};
+var pointFromTouch = (e, type = "page") => {
+  const point = e.touches[0] || e.changedTouches[0];
+  return { x: point[`${type}X`], y: point[`${type}Y`] };
+};
+var pointFromMouse = (point, type = "page") => ({
+  x: point[`${type}X`],
+  y: point[`${type}Y`]
+});
+var getEventPoint = (ev, type = "page") => isTouchEvent(ev) ? pointFromTouch(ev, type) : pointFromMouse(ev, type);
+var addDomEvent = (target, type, cb, options) => {
+  target.addEventListener(type, cb, options);
+  return () => {
+    target.removeEventListener(type, cb, options);
+  };
+};
+var filter = (cb) => (event) => {
+  const isMouse = isMouseEvent(event);
+  if (!isMouse || isMouse && event.button === 0)
+    cb(event);
+};
+var wrap = (cb, filterPrimary = false) => {
+  const listener = (event) => cb(event, { point: getEventPoint(event) });
+  const fn = filterPrimary ? filter(listener) : listener;
+  return fn;
+};
+var addPointerEvent = (target, type, cb, options) => addDomEvent(target, type, wrap(cb, type === "pointerdown"), options);
+
+export {
+  isMouseEvent,
+  isTouchEvent,
+  isMultiTouchEvent,
+  getEventWindow,
+  pointFromTouch,
+  pointFromMouse,
+  getEventPoint,
+  addDomEvent,
+  addPointerEvent
+};

package/dist/chunk-PURW64JE.mjs

@@ -0,0 +1,6 @@
+// src/array.ts
+var filterEmpty = (array) => array.filter((value) => value != null);
+
+export {
+  filterEmpty
+};

package/dist/chunk-R5OUKGQ5.mjs

@@ -0,0 +1,31 @@
+// src/calc.ts
+var toExpression = (operator, ...args) => args.join(` ${operator} `).replace(/calc/g, "");
+var add = (...args) => `calc(${toExpression("+", ...args)})`;
+var subtract = (...args) => `calc(${toExpression("-", ...args)})`;
+var multiply = (...args) => `calc(${toExpression("*", ...args)})`;
+var divide = (...args) => `calc(${toExpression("/", ...args)})`;
+var negate = (value) => {
+  if (value != null && !isNaN(parseFloat(value.toString())))
+    return String(value).startsWith("-") ? String(value).slice(1) : `-${value}`;
+  return multiply(value, -1);
+};
+var calc = Object.assign(
+  (x) => ({
+    add: (...args) => calc(add(x, ...args)),
+    subtract: (...args) => calc(subtract(x, ...args)),
+    multiply: (...args) => calc(multiply(x, ...args)),
+    divide: (...args) => calc(divide(x, ...args)),
+    negate: () => calc(negate(x))
+  }),
+  {
+    add,
+    subtract,
+    multiply,
+    divide,
+    negate
+  }
+);
+
+export {
+  calc
+};

package/dist/chunk-VYMGBE25.mjs

@@ -0,0 +1,39 @@
+// src/number.ts
+var toNumber = (n) => {
+  const num = parseFloat(n);
+  return typeof num !== "number" || Number.isNaN(num) ? 0 : num;
+};
+var toPrecision = (n, precision) => {
+  n = toNumber(n);
+  const scale = 10 ** (precision != null ? precision : 10);
+  n = Math.round(n * scale) / scale;
+  return precision ? n.toFixed(precision) : n.toString();
+};
+var countDecimal = (n) => {
+  if (!Number.isFinite(n))
+    return 0;
+  let e = 1;
+  let p = 0;
+  while (Math.round(n * e) / e !== n) {
+    e *= 10;
+    p += 1;
+  }
+  return p;
+};
+var roundNumberToStep = (n, from, step) => {
+  const nextValue = Math.round((n - from) / step) * step + from;
+  const precision = countDecimal(step);
+  return toPrecision(nextValue, precision);
+};
+var valueToPercent = (n, min, max) => (n - min) * 100 / (max - min);
+var percentToValue = (n, min, max) => (max - min) * n + min;
+var clampNumber = (n, min, max) => Math.min(Math.max(n, min), max);
+
+export {
+  toPrecision,
+  countDecimal,
+  roundNumberToStep,
+  valueToPercent,
+  percentToValue,
+  clampNumber
+};

package/dist/color.d.ts

@@ -0,0 +1,19 @@
+import * as _ctrl_tinycolor from '@ctrl/tinycolor';
+import { Dict } from './index.types.js';
+
+declare const getColor: (color: string, fallback?: string) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string | number | _ctrl_tinycolor.RGB | _ctrl_tinycolor.HSL | _ctrl_tinycolor.HSV | undefined;
+declare const lightenColor: (color: string, amount: number) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string;
+declare const darkenColor: (color: string, amount: number) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string;
+declare const brightenColor: (color: string, amount: number) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string;
+declare const tintColor: (color: string, amount: number) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string;
+declare const shadeColor: (color: string, amount: number) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string;
+declare const transparentizeColor: (color: string, alpha: number) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string;
+declare const toneColor: (color: string, l: number) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string;
+declare const randomColor: ({ string, colors }?: {
+    string?: string | undefined;
+    colors?: string[] | undefined;
+}) => string;
+declare const isLight: (color: string) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => boolean;
+declare const isDark: (color: string) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => boolean;
+
+export { brightenColor, darkenColor, getColor, isDark, isLight, lightenColor, randomColor, shadeColor, tintColor, toneColor, transparentizeColor };

package/dist/color.js

@@ -0,0 +1,181 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/color.ts
+var color_exports = {};
+__export(color_exports, {
+  brightenColor: () => brightenColor,
+  darkenColor: () => darkenColor,
+  getColor: () => getColor,
+  isDark: () => isDark,
+  isLight: () => isLight,
+  lightenColor: () => lightenColor,
+  randomColor: () => randomColor,
+  shadeColor: () => shadeColor,
+  tintColor: () => tintColor,
+  toneColor: () => toneColor,
+  transparentizeColor: () => transparentizeColor
+});
+module.exports = __toCommonJS(color_exports);
+var import_tinycolor = require("@ctrl/tinycolor");
+
+// src/assertion.ts
+var isArray = (value) => Array.isArray(value);
+
+// src/object.ts
+var getObject = (obj, path, fallback, i) => {
+  const k = typeof path === "string" ? path.split(".") : [path];
+  for (i = 0; i < k.length; i += 1) {
+    if (!obj)
+      break;
+    obj = obj[k[i]];
+  }
+  return obj === void 0 ? fallback : obj;
+};
+var memoizeObject = (func) => {
+  const cache = /* @__PURE__ */ new WeakMap();
+  const memoizedFunc = (obj, path, fallback, i) => {
+    if (typeof obj === "undefined") {
+      return func(obj, path, fallback);
+    }
+    if (!cache.has(obj))
+      cache.set(obj, /* @__PURE__ */ new Map());
+    const map = cache.get(obj);
+    if (map.has(path))
+      return map.get(path);
+    const value = func(obj, path, fallback, i);
+    map.set(path, value);
+    return value;
+  };
+  return memoizedFunc;
+};
+var getMemoizedObject = memoizeObject(getObject);
+
+// src/color.ts
+var getColor = (color, fallback) => (theme, colorMode) => {
+  const hex = getMemoizedObject(
+    theme,
+    `colors.${color}`,
+    color
+  );
+  if (isArray(hex)) {
+    const [lightHex, darkHex] = hex;
+    const { isValid, originalInput } = new import_tinycolor.TinyColor(colorMode !== "dark" ? lightHex : darkHex);
+    return isValid ? originalInput : fallback;
+  } else {
+    const { isValid, originalInput } = new import_tinycolor.TinyColor(hex);
+    return isValid ? originalInput : fallback;
+  }
+};
+var lightenColor = (color, amount) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new import_tinycolor.TinyColor(raw).lighten(amount).toRgbString();
+};
+var darkenColor = (color, amount) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new import_tinycolor.TinyColor(raw).darken(amount).toRgbString();
+};
+var brightenColor = (color, amount) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new import_tinycolor.TinyColor(raw).brighten(amount).toRgbString();
+};
+var tintColor = (color, amount) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new import_tinycolor.TinyColor(raw).tint(amount).toRgbString();
+};
+var shadeColor = (color, amount) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new import_tinycolor.TinyColor(raw).shade(amount).toRgbString();
+};
+var transparentizeColor = (color, alpha) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new import_tinycolor.TinyColor(raw).setAlpha(alpha).toRgbString();
+};
+var toneColor = (color, l) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  if (l < 0 || 900 < l)
+    return color;
+  let n = (l - 500) / 10;
+  const isLighten = n <= 0;
+  if (isLighten)
+    n *= -1;
+  if (n !== 0)
+    n = n - 5 * (isLighten ? 1 : -1);
+  return new import_tinycolor.TinyColor(raw)[isLighten ? "lighten" : "shade"](n).toString();
+};
+var randomColor = ({ string, colors } = {}) => {
+  const fallback = randomHex();
+  if (string && colors)
+    return randomColorFromList(string, colors);
+  if (string && !colors)
+    return randomColorFromString(string);
+  if (colors && !string)
+    return randomFromList(colors);
+  return fallback;
+};
+var randomHex = () => `#${Math.floor(Math.random() * 16777215).toString(16).padEnd(6, "0")}`;
+var randomColorFromString = (str) => {
+  let hash = 0;
+  if (str.length === 0)
+    return hash.toString();
+  for (let i = 0; i < str.length; i += 1) {
+    hash = str.charCodeAt(i) + ((hash << 5) - hash);
+    hash = hash & hash;
+  }
+  let color = "#";
+  for (let j = 0; j < 3; j += 1) {
+    const value = hash >> j * 8 & 255;
+    color += `00${value.toString(16)}`.substr(-2);
+  }
+  return color;
+};
+var randomColorFromList = (str, list) => {
+  let index = 0;
+  if (str.length === 0)
+    return list[0];
+  for (let i = 0; i < str.length; i += 1) {
+    index = str.charCodeAt(i) + ((index << 5) - index);
+    index = index & index;
+  }
+  index = (index % list.length + list.length) % list.length;
+  return list[index];
+};
+var randomFromList = (list) => list[Math.floor(Math.random() * list.length)];
+var isLight = (color) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new import_tinycolor.TinyColor(raw).isLight();
+};
+var isDark = (color) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new import_tinycolor.TinyColor(raw).isDark();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  brightenColor,
+  darkenColor,
+  getColor,
+  isDark,
+  isLight,
+  lightenColor,
+  randomColor,
+  shadeColor,
+  tintColor,
+  toneColor,
+  transparentizeColor
+});

package/dist/color.mjs

@@ -0,0 +1,34 @@
+import {
+  brightenColor,
+  darkenColor,
+  getColor,
+  isDark,
+  isLight,
+  lightenColor,
+  randomColor,
+  shadeColor,
+  tintColor,
+  toneColor,
+  transparentizeColor
+} from "./chunk-A6J4FUU7.mjs";
+import "./chunk-SLJ4M7XC.mjs";
+import "./chunk-VYMGBE25.mjs";
+import "./chunk-BZAW2D6U.mjs";
+import "./chunk-PURW64JE.mjs";
+import "./chunk-IVGIIDMV.mjs";
+import "./chunk-R5OUKGQ5.mjs";
+import "./chunk-FW7XS4NH.mjs";
+import "./chunk-PF7LRFIA.mjs";
+export {
+  brightenColor,
+  darkenColor,
+  getColor,
+  isDark,
+  isLight,
+  lightenColor,
+  randomColor,
+  shadeColor,
+  tintColor,
+  toneColor,
+  transparentizeColor
+};

package/dist/dom.d.ts

@@ -0,0 +1,33 @@
+import React__default from 'react';
+
+declare const createdDom: () => boolean;
+declare const getPlatform: () => string;
+declare const vendor: (v: RegExp) => boolean;
+declare const platform: (v: RegExp) => boolean;
+declare const isMac: () => boolean;
+declare const isApple: () => boolean;
+declare const isSafari: () => boolean;
+declare const isElement: (el: any) => el is Element;
+declare const isHTMLElement: (el: any) => el is HTMLElement;
+declare const isHidden: (el: HTMLElement) => boolean;
+declare const isDisabled: (el: HTMLElement) => boolean;
+declare const hasTabIndex: (el: HTMLElement) => boolean;
+declare const isContentEditable: (el: HTMLElement) => boolean;
+declare const isContains: (parent: HTMLElement | null, child: HTMLElement | null) => boolean | undefined;
+declare const getEventRelatedTarget: (ev: React__default.FocusEvent | React__default.MouseEvent) => HTMLElement | null;
+type Booleanish = boolean | 'true' | 'false';
+declare const dataAttr: (condition: boolean | undefined) => Booleanish;
+declare const ariaAttr: (condition: boolean | undefined) => boolean | undefined;
+type FocusableElement = {
+    focus: (options?: FocusOptions) => void;
+};
+declare const getAllFocusable: <T extends HTMLElement>(container: T) => T[];
+declare const isFocusable: (el: HTMLElement) => boolean;
+declare const hasNegativeTabIndex: (el: HTMLElement) => boolean;
+declare const isTabbable: (el?: HTMLElement | null) => boolean;
+declare const getOwnerWindow: (node?: Element | null) => Window & typeof globalThis;
+declare const getOwnerDocument: (el?: Element | null) => Document;
+declare const getActiveElement: (el?: HTMLElement) => HTMLElement;
+declare const isActiveElement: (el: HTMLElement) => boolean;
+
+export { FocusableElement, ariaAttr, createdDom, dataAttr, getActiveElement, getAllFocusable, getEventRelatedTarget, getOwnerDocument, getOwnerWindow, getPlatform, hasNegativeTabIndex, hasTabIndex, isActiveElement, isApple, isContains, isContentEditable, isDisabled, isElement, isFocusable, isHTMLElement, isHidden, isMac, isSafari, isTabbable, platform, vendor };