@yamada-ui/utils 0.0.0-dev-20230606151107

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Hirotomo Yamada
+
+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,31 @@
+# @yamada-ui/utils
+
+> This is an internal utility, not intended for public usage.
+
+## Installation
+
+```sh
+$ pnpm add @yamada-ui/utils
+```
+
+or
+
+```sh
+$ yarn add @yamada-ui/utils
+```
+
+or
+
+```sh
+$ npm install @yamada-ui/utils
+```
+
+## Contribution
+
+Wouldn't you like to contribute? That's amazing! We have prepared a [contribution guide](https://github.com/hirotomoyamada/yamada-ui/blob/main/CONTRIBUTING.md) to assist you.
+
+## Licence
+
+This package is licensed under the terms of the
+
+[MIT license](https://github.com/hirotomoyamada/yamada-ui/blob/main/LICENSE).

package/dist/array.d.ts

@@ -0,0 +1,3 @@
+declare const filterEmpty: <T extends any[]>(array: T) => any[];
+
+export { filterEmpty };

package/dist/array.js

@@ -0,0 +1,30 @@
+"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/array.ts
+var array_exports = {};
+__export(array_exports, {
+  filterEmpty: () => filterEmpty
+});
+module.exports = __toCommonJS(array_exports);
+var filterEmpty = (array) => array.filter((value) => value != null);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterEmpty
+});

package/dist/array.mjs

@@ -0,0 +1,6 @@
+import {
+  filterEmpty
+} from "./chunk-PURW64JE.mjs";
+export {
+  filterEmpty
+};

package/dist/assertion.d.ts

@@ -0,0 +1,16 @@
+import { Dict } from './index.types.js';
+
+declare const isNumber: (value: any) => value is number;
+declare const isNotNumber: (value: any) => boolean;
+declare const isNumeric: (value: any) => boolean;
+declare const isString: (value: any) => value is string;
+declare const isUndefined: (value: any) => value is undefined;
+declare const isNull: (value: any) => value is null;
+declare const isObject: <T extends Dict<any>>(value: any) => value is T;
+declare const isArray: <T extends any[]>(value: any) => value is T;
+declare const isEmpty: (value: any) => boolean;
+declare const isFunction: <T extends Function = Function>(value: any) => value is T;
+declare const isUnit: (value: any) => boolean;
+declare const cast: <T>(value: any) => T;
+
+export { cast, isArray, isEmpty, isFunction, isNotNumber, isNull, isNumber, isNumeric, isObject, isString, isUndefined, isUnit };

package/dist/assertion.js

@@ -0,0 +1,63 @@
+"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/assertion.ts
+var assertion_exports = {};
+__export(assertion_exports, {
+  cast: () => cast,
+  isArray: () => isArray,
+  isEmpty: () => isEmpty,
+  isFunction: () => isFunction,
+  isNotNumber: () => isNotNumber,
+  isNull: () => isNull,
+  isNumber: () => isNumber,
+  isNumeric: () => isNumeric,
+  isObject: () => isObject,
+  isString: () => isString,
+  isUndefined: () => isUndefined,
+  isUnit: () => isUnit
+});
+module.exports = __toCommonJS(assertion_exports);
+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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cast,
+  isArray,
+  isEmpty,
+  isFunction,
+  isNotNumber,
+  isNull,
+  isNumber,
+  isNumeric,
+  isObject,
+  isString,
+  isUndefined,
+  isUnit
+});

package/dist/assertion.mjs

@@ -0,0 +1,28 @@
+import {
+  cast,
+  isArray,
+  isEmpty,
+  isFunction,
+  isNotNumber,
+  isNull,
+  isNumber,
+  isNumeric,
+  isObject,
+  isString,
+  isUndefined,
+  isUnit
+} from "./chunk-IVGIIDMV.mjs";
+export {
+  cast,
+  isArray,
+  isEmpty,
+  isFunction,
+  isNotNumber,
+  isNull,
+  isNumber,
+  isNumeric,
+  isObject,
+  isString,
+  isUndefined,
+  isUnit
+};

package/dist/calc.d.ts

@@ -0,0 +1,17 @@
+type Operand = string | number;
+type Calc = {
+    add: (...args: Operand[]) => Calc;
+    subtract: (...args: Operand[]) => Calc;
+    multiply: (...args: Operand[]) => Calc;
+    divide: (...args: Operand[]) => Calc;
+    negate: () => Calc;
+};
+declare const calc: ((x: Operand) => Calc) & {
+    add: (...args: Operand[]) => string;
+    subtract: (...args: Operand[]) => string;
+    multiply: (...args: Operand[]) => string;
+    divide: (...args: Operand[]) => string;
+    negate: (value: Operand) => string;
+};
+
+export { Operand, calc };

package/dist/calc.js

@@ -0,0 +1,55 @@
+"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/calc.ts
+var calc_exports = {};
+__export(calc_exports, {
+  calc: () => calc
+});
+module.exports = __toCommonJS(calc_exports);
+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
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calc
+});

package/dist/calc.mjs

@@ -0,0 +1,6 @@
+import {
+  calc
+} from "./chunk-R5OUKGQ5.mjs";
+export {
+  calc
+};

package/dist/chunk-BZAW2D6U.mjs

@@ -0,0 +1,6 @@
+// src/string.ts
+var escape = (value, replaceValue = "") => value.replace(/\s+/g, replaceValue);
+
+export {
+  escape
+};

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
+};