@yamada-ui/utils 0.1.0

package/dist/index.mjs

@@ -0,0 +1,221 @@
+import {
+  assignAfter,
+  assignRef,
+  brightenColor,
+  createContext,
+  cx,
+  darkenColor,
+  filterObject,
+  filterUndefined,
+  findChildren,
+  flattenObject,
+  funcAll,
+  getColor,
+  getMemoizedObject,
+  getObject,
+  getValidChildren,
+  handlerAll,
+  includesChildren,
+  isDark,
+  isLight,
+  isRefObject,
+  isValidElement,
+  keysFormObject,
+  lightenColor,
+  memoizeObject,
+  merge,
+  mergeRefs,
+  noop,
+  objectFromEntries,
+  omitChildren,
+  omitObject,
+  pickChildren,
+  pickObject,
+  randomColor,
+  replaceObject,
+  runIfFunc,
+  shadeColor,
+  splitObject,
+  tintColor,
+  toneColor,
+  transparentizeColor,
+  useCallbackRef,
+  useIsMounted,
+  useMergeRefs,
+  useSafeLayoutEffect,
+  useUnmountEffect,
+  useUpdateEffect
+} from "./chunk-A6J4FUU7.mjs";
+import "./chunk-SLJ4M7XC.mjs";
+import {
+  clampNumber,
+  countDecimal,
+  percentToValue,
+  roundNumberToStep,
+  toPrecision,
+  valueToPercent
+} from "./chunk-VYMGBE25.mjs";
+import {
+  escape
+} from "./chunk-BZAW2D6U.mjs";
+import {
+  filterEmpty
+} from "./chunk-PURW64JE.mjs";
+import {
+  cast,
+  isArray,
+  isEmpty,
+  isFunction,
+  isNotNumber,
+  isNull,
+  isNumber,
+  isNumeric,
+  isObject,
+  isString,
+  isUndefined,
+  isUnit
+} from "./chunk-IVGIIDMV.mjs";
+import {
+  calc
+} from "./chunk-R5OUKGQ5.mjs";
+import {
+  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
+} from "./chunk-FW7XS4NH.mjs";
+import {
+  addDomEvent,
+  addPointerEvent,
+  getEventPoint,
+  getEventWindow,
+  isMouseEvent,
+  isMultiTouchEvent,
+  isTouchEvent,
+  pointFromMouse,
+  pointFromTouch
+} from "./chunk-PF7LRFIA.mjs";
+export {
+  addDomEvent,
+  addPointerEvent,
+  ariaAttr,
+  assignAfter,
+  assignRef,
+  brightenColor,
+  calc,
+  cast,
+  clampNumber,
+  countDecimal,
+  createContext,
+  createdDom,
+  cx,
+  darkenColor,
+  dataAttr,
+  escape,
+  filterEmpty,
+  filterObject,
+  filterUndefined,
+  findChildren,
+  flattenObject,
+  funcAll,
+  getActiveElement,
+  getAllFocusable,
+  getColor,
+  getEventPoint,
+  getEventRelatedTarget,
+  getEventWindow,
+  getMemoizedObject,
+  getObject,
+  getOwnerDocument,
+  getOwnerWindow,
+  getPlatform,
+  getValidChildren,
+  handlerAll,
+  hasNegativeTabIndex,
+  hasTabIndex,
+  includesChildren,
+  isActiveElement,
+  isApple,
+  isArray,
+  isContains,
+  isContentEditable,
+  isDark,
+  isDisabled,
+  isElement,
+  isEmpty,
+  isFocusable,
+  isFunction,
+  isHTMLElement,
+  isHidden,
+  isLight,
+  isMac,
+  isMouseEvent,
+  isMultiTouchEvent,
+  isNotNumber,
+  isNull,
+  isNumber,
+  isNumeric,
+  isObject,
+  isRefObject,
+  isSafari,
+  isString,
+  isTabbable,
+  isTouchEvent,
+  isUndefined,
+  isUnit,
+  isValidElement,
+  keysFormObject,
+  lightenColor,
+  memoizeObject,
+  merge,
+  mergeRefs,
+  noop,
+  objectFromEntries,
+  omitChildren,
+  omitObject,
+  percentToValue,
+  pickChildren,
+  pickObject,
+  platform,
+  pointFromMouse,
+  pointFromTouch,
+  randomColor,
+  replaceObject,
+  roundNumberToStep,
+  runIfFunc,
+  shadeColor,
+  splitObject,
+  tintColor,
+  toPrecision,
+  toneColor,
+  transparentizeColor,
+  useCallbackRef,
+  useIsMounted,
+  useMergeRefs,
+  useSafeLayoutEffect,
+  useUnmountEffect,
+  useUpdateEffect,
+  valueToPercent,
+  vendor
+};

package/dist/index.types.d.ts

@@ -0,0 +1,14 @@
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+type PathImpl<K extends string | number | symbol, V> = K extends string | number ? V extends Primitive ? `${K}` : `${K}.${Path<V>}` : ``;
+type Path<T> = {
+    [K in keyof T]-?: PathImpl<K, T[K]>;
+}[keyof T];
+type Dict<T = any> = Record<string, T>;
+type StringLiteral = string & {};
+type Union<T> = T | StringLiteral;
+type Length = string | 0 | number;
+type DynamicRecord<T> = {
+    [K in keyof T]-?: T[K] extends Primitive ? string | number : DynamicRecord<T[K]>;
+};
+
+export { Dict, DynamicRecord, Length, Path, StringLiteral, Union };

package/dist/index.types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/index.types.ts
+var index_types_exports = {};
+module.exports = __toCommonJS(index_types_exports);

package/dist/index.types.mjs

@@ -0,0 +1 @@
+import "./chunk-SLJ4M7XC.mjs";

package/dist/number.d.ts

@@ -0,0 +1,8 @@
+declare const toPrecision: (n: number, precision?: number) => string;
+declare const countDecimal: (n: number) => number;
+declare const roundNumberToStep: (n: number, from: number, step: number) => string;
+declare const valueToPercent: (n: number, min: number, max: number) => number;
+declare const percentToValue: (n: number, min: number, max: number) => number;
+declare const clampNumber: (n: number, min: number, max: number) => number;
+
+export { clampNumber, countDecimal, percentToValue, roundNumberToStep, toPrecision, valueToPercent };

package/dist/number.js

@@ -0,0 +1,68 @@
+"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/number.ts
+var number_exports = {};
+__export(number_exports, {
+  clampNumber: () => clampNumber,
+  countDecimal: () => countDecimal,
+  percentToValue: () => percentToValue,
+  roundNumberToStep: () => roundNumberToStep,
+  toPrecision: () => toPrecision,
+  valueToPercent: () => valueToPercent
+});
+module.exports = __toCommonJS(number_exports);
+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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clampNumber,
+  countDecimal,
+  percentToValue,
+  roundNumberToStep,
+  toPrecision,
+  valueToPercent
+});

package/dist/number.mjs

@@ -0,0 +1,16 @@
+import {
+  clampNumber,
+  countDecimal,
+  percentToValue,
+  roundNumberToStep,
+  toPrecision,
+  valueToPercent
+} from "./chunk-VYMGBE25.mjs";
+export {
+  clampNumber,
+  countDecimal,
+  percentToValue,
+  roundNumberToStep,
+  toPrecision,
+  valueToPercent
+};

package/dist/object.d.ts

@@ -0,0 +1,18 @@
+import { Dict } from './index.types.js';
+
+declare const omitObject: <T extends Dict<any>, K extends keyof T>(obj: T, keys: K[]) => Omit<T, K>;
+declare const pickObject: <T extends Dict<any>, K extends keyof T>(obj: T, keys: K[]) => { [P in K]: T[P]; };
+declare const splitObject: <T extends Dict<any>, K extends keyof T>(obj: T, keys: K[]) => [{ [P in K]: T[P]; }, Omit<T, K>];
+declare const filterObject: <T extends Dict<any>, K extends Dict<any>>(obj: T, func: (key: keyof T, value: T[keyof T], obj: T) => boolean) => K;
+declare const filterUndefined: <T extends Dict<any>>(obj: T) => T;
+declare const merge: <T extends Dict<any>>(target: any, source: any, overrideArray?: boolean) => T;
+declare const flattenObject: <T extends Dict<any>>(obj: any, maxDepth?: number) => T;
+declare const objectFromEntries: <T extends Dict<any>>(entries: any[][]) => T;
+declare const keysFormObject: <T extends Dict<any>>(obj: T) => (keyof T)[];
+declare const replaceObject: <T extends unknown>(objOrArray: T, callBack: (value: any) => any) => T;
+declare const getObject: (obj: Dict, path: string | number, fallback?: any, i?: number) => any;
+declare const memoizeObject: (func: typeof getObject) => (obj: Dict, path: string | number, fallback?: any, i?: number) => any;
+declare const getMemoizedObject: (obj: Dict, path: string | number, fallback?: any, i?: number) => any;
+declare const assignAfter: (target: Record<string, any>, ...sources: any[]) => Record<string, unknown>;
+
+export { assignAfter, filterObject, filterUndefined, flattenObject, getMemoizedObject, getObject, keysFormObject, memoizeObject, merge, objectFromEntries, omitObject, pickObject, replaceObject, splitObject };

package/dist/object.js

@@ -0,0 +1,192 @@
+"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/object.ts
+var object_exports = {};
+__export(object_exports, {
+  assignAfter: () => assignAfter,
+  filterObject: () => filterObject,
+  filterUndefined: () => filterUndefined,
+  flattenObject: () => flattenObject,
+  getMemoizedObject: () => getMemoizedObject,
+  getObject: () => getObject,
+  keysFormObject: () => keysFormObject,
+  memoizeObject: () => memoizeObject,
+  merge: () => merge,
+  objectFromEntries: () => objectFromEntries,
+  omitObject: () => omitObject,
+  pickObject: () => pickObject,
+  replaceObject: () => replaceObject,
+  splitObject: () => splitObject
+});
+module.exports = __toCommonJS(object_exports);
+
+// src/assertion.ts
+var isObject = (value) => value !== null && (typeof value === "object" || typeof value === "function") && !Array.isArray(value);
+var isArray = (value) => Array.isArray(value);
+var isFunction = (value) => typeof value === "function";
+
+// src/object.ts
+var omitObject = (obj, keys) => {
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    if (keys.includes(key))
+      return;
+    result[key] = obj[key];
+  });
+  return result;
+};
+var pickObject = (obj, keys) => {
+  const result = {};
+  keys.forEach((key) => {
+    if (key in obj)
+      result[key] = obj[key];
+  });
+  return result;
+};
+var splitObject = (obj, keys) => {
+  const picked = {};
+  const omitted = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (keys.includes(key)) {
+      picked[key] = value;
+    } else {
+      omitted[key] = value;
+    }
+  }
+  return [picked, omitted];
+};
+var filterObject = (obj, func) => {
+  const result = {};
+  Object.entries(obj).forEach(([key, value]) => {
+    const shouldPass = func(key, value, obj);
+    if (shouldPass)
+      result[key] = value;
+  });
+  return result;
+};
+var filterUndefined = (obj) => filterObject(obj, (_, val) => val !== null && val !== void 0);
+var merge = (target, source, overrideArray = false) => {
+  let result = Object.assign({}, target);
+  if (isObject(target) && isObject(source)) {
+    for (const [sourceKey, sourceValue] of Object.entries(source)) {
+      const targetValue = target[sourceKey];
+      if (overrideArray && Array.isArray(sourceValue) && Array.isArray(targetValue)) {
+        result[sourceKey] = targetValue.concat(...sourceValue);
+      } else if (!isFunction(sourceValue) && isObject(sourceValue) && target.hasOwnProperty(sourceKey)) {
+        result[sourceKey] = merge(targetValue, sourceValue, overrideArray);
+      } else {
+        Object.assign(result, { [sourceKey]: sourceValue });
+      }
+    }
+  }
+  return result;
+};
+var flattenObject = (obj, maxDepth = Infinity) => {
+  if (!isObject(obj) && !isArray(obj) || !maxDepth)
+    return obj;
+  return Object.entries(obj).reduce((result, [key, value]) => {
+    if (isObject(value)) {
+      Object.entries(flattenObject(value, maxDepth - 1)).forEach(([childKey, childValue]) => {
+        result[`${key}.${childKey}`] = childValue;
+      });
+    } else {
+      result[key] = value;
+    }
+    return result;
+  }, {});
+};
+var objectFromEntries = (entries) => entries.reduce((result, [key, value]) => {
+  result[key] = value;
+  return result;
+}, {});
+var keysFormObject = (obj) => Object.keys(obj);
+var replaceObject = (objOrArray, callBack) => {
+  if (isArray(objOrArray)) {
+    return objOrArray.map(callBack);
+  } else if (isObject(objOrArray)) {
+    return Object.entries(objOrArray).reduce((obj, [key, value]) => {
+      obj[key] = callBack(value);
+      return obj;
+    }, {});
+  } else {
+    return callBack(objOrArray);
+  }
+};
+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);
+var assignAfter = (target, ...sources) => {
+  if (target == null)
+    throw new TypeError("Cannot convert undefined or null to object");
+  const result = { ...target };
+  for (const nextSource of sources) {
+    if (nextSource == null)
+      continue;
+    for (const nextKey in nextSource) {
+      if (!Object.prototype.hasOwnProperty.call(nextSource, nextKey))
+        continue;
+      if (nextKey in result)
+        delete result[nextKey];
+      result[nextKey] = nextSource[nextKey];
+    }
+  }
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assignAfter,
+  filterObject,
+  filterUndefined,
+  flattenObject,
+  getMemoizedObject,
+  getObject,
+  keysFormObject,
+  memoizeObject,
+  merge,
+  objectFromEntries,
+  omitObject,
+  pickObject,
+  replaceObject,
+  splitObject
+});

package/dist/object.mjs

@@ -0,0 +1,40 @@
+import {
+  assignAfter,
+  filterObject,
+  filterUndefined,
+  flattenObject,
+  getMemoizedObject,
+  getObject,
+  keysFormObject,
+  memoizeObject,
+  merge,
+  objectFromEntries,
+  omitObject,
+  pickObject,
+  replaceObject,
+  splitObject
+} 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 {
+  assignAfter,
+  filterObject,
+  filterUndefined,
+  flattenObject,
+  getMemoizedObject,
+  getObject,
+  keysFormObject,
+  memoizeObject,
+  merge,
+  objectFromEntries,
+  omitObject,
+  pickObject,
+  replaceObject,
+  splitObject
+};

package/dist/react.d.ts

@@ -0,0 +1,44 @@
+import * as React from 'react';
+
+type DOMElement = Element & HTMLOrSVGElement;
+type DataAttributes = {
+    [dataAttr: string]: any;
+};
+type DOMAttributes<Y = DOMElement> = React.AriaAttributes & React.DOMAttributes<Y> & DataAttributes & {
+    id?: string;
+    role?: React.AriaRole;
+    tabIndex?: number;
+    style?: React.CSSProperties;
+};
+type Merge<Y, M> = M extends Record<string, unknown> ? Y : Omit<Y, keyof M> & M;
+type PropGetter<Y = Record<string, unknown>, M = DOMAttributes> = (props?: Merge<DOMAttributes, Y>, ref?: React.Ref<any>) => M & React.RefAttributes<any>;
+type RequiredPropGetter<Y = Record<string, unknown>, M = DOMAttributes> = (props: Merge<DOMAttributes, Y>, ref?: React.Ref<any>) => M & React.RefAttributes<any>;
+type MaybeRenderProp<Y> = React.ReactNode | ((props: Y) => React.ReactNode);
+type Options = {
+    strict?: boolean;
+    errorMessage?: string;
+    name?: string;
+};
+type CreateContextReturn<T> = [React.Provider<T>, () => T, React.Context<T>];
+declare const createContext: <ContextType extends unknown = any>({ strict, errorMessage, name, }?: Options) => CreateContextReturn<ContextType>;
+declare const useSafeLayoutEffect: typeof React.useLayoutEffect;
+declare const useUnmountEffect: (callback: () => void) => void;
+declare const useIsMounted: () => React.MutableRefObject<boolean>;
+declare const getValidChildren: (children: React.ReactNode) => React.ReactElement[];
+declare const isValidElement: (child: any) => child is React.ReactNode;
+declare const findChildren: (children: React.ReactElement<any, string | React.JSXElementConstructor<any>>[], ...types: React.JSXElementConstructor<any>[]) => [React.ReactElement | undefined, ...React.ReactElement[]];
+declare const includesChildren: (children: React.ReactElement<any, string | React.JSXElementConstructor<any>>[], ...types: React.JSXElementConstructor<any>[]) => boolean;
+declare const omitChildren: (children: React.ReactElement<any, string | React.JSXElementConstructor<any>>[], ...types: React.JSXElementConstructor<any>[]) => React.ReactElement[];
+declare const pickChildren: (children: React.ReactElement<any, string | React.JSXElementConstructor<any>>[], ...types: React.JSXElementConstructor<any>[]) => React.ReactElement[];
+declare const cx: (...classNames: (string | undefined)[]) => string;
+type ReactRef<T> = React.Ref<T> | React.MutableRefObject<T>;
+declare const isRefObject: (val: any) => val is {
+    current: any;
+};
+declare const assignRef: <T extends unknown = any>(ref: ReactRef<T> | undefined, value: T) => void;
+declare const mergeRefs: <T extends unknown = any>(...refs: (ReactRef<T> | undefined)[]) => (node: T | null) => void;
+declare const useMergeRefs: <T extends unknown = any>(...refs: (ReactRef<T> | undefined)[]) => (node: T | null) => void;
+declare const useCallbackRef: <T extends (...args: any[]) => any>(callback: T | undefined, deps?: React.DependencyList) => T;
+declare const useUpdateEffect: (callback: React.EffectCallback, deps: React.DependencyList) => void;
+
+export { DOMAttributes, MaybeRenderProp, PropGetter, RequiredPropGetter, assignRef, createContext, cx, findChildren, getValidChildren, includesChildren, isRefObject, isValidElement, mergeRefs, omitChildren, pickChildren, useCallbackRef, useIsMounted, useMergeRefs, useSafeLayoutEffect, useUnmountEffect, useUpdateEffect };