@splendidlabz/utils 1.11.3 → 1.11.4

package/{src/dom/focusable.js → dist/cjs/dom/focusable.cjs}

@@ -1,45 +1,29 @@
-/**
- * @typedef {Object} Focusables
- * @property {number} length - Number of keyboard focusable elements
- * @property {Array} all - All focusable elements that are visible and enabled
- * @property {Array} keyboard - Elements that can be focused via keyboard (tabIndex > -1)
- * @property {Array} keyboardOnly - Alias for keyboard focusable elements
- * @property {HTMLElement|null} first - First keyboard focusable element
- * @property {HTMLElement|null} last - Last keyboard focusable element
- * @property {function(number): HTMLElement|null} next - Get next focusable element after the given index
- * @property {function(number): HTMLElement|null} prev - Get previous focusable element before the given index
- */
+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);
 
-/**
- * Gets all focusable elements within a container and provides methods to navigate between them.
- * This is useful for implementing keyboard navigation, focus trapping, and accessibility features.
- * 
- * @param {HTMLElement} [container=document.body] - The container element to search within. Only elements inside this container will be included.
- * @returns {Focusables} Object containing focusable elements and navigation methods
- * @example
- * // Get focusable elements in a modal
- * const modal = document.querySelector('.modal')
- * const focusable = getFocusableElements(modal)
- * 
- * // Get all focusable elements in document
- * const allFocusable = getFocusableElements()
- * 
- * // Focus the first element when modal opens
- * focusable.first?.focus()
- * 
- * // Handle tab key to trap focus
- * modal.addEventListener('keydown', e => {
- *   if (e.key === 'Tab') {
- *     e.preventDefault()
- *     const currentIndex = focusable.keyboard.indexOf(document.activeElement)
- *     const nextElement = e.shiftKey 
- *       ? focusable.prev(currentIndex) 
- *       : focusable.next(currentIndex)
- *     nextElement?.focus()
- *   }
- * })
- */
-export function getFocusableElements(container = document.body) {
+// src/dom/focusable.js
+var focusable_exports = {};
+__export(focusable_exports, {
+  Focusable: () => Focusable,
+  getFocusableElements: () => getFocusableElements
+});
+module.exports = __toCommonJS(focusable_exports);
+function getFocusableElements(container = document.body) {
   return {
     /**
      * Gets the number of keyboard focusable elements.
@@ -49,9 +33,8 @@ export function getFocusableElements(container = document.body) {
      * @returns {number} The number of keyboard focusable elements
      */
     get length() {
-      return this.keyboard.length
+      return this.keyboard.length;
     },
-
     /**
      * Gets all focusable elements within the container that are visible and enabled.
      * This includes elements that can be focused via mouse or programmatically,
@@ -82,19 +65,16 @@ export function getFocusableElements(container = document.body) {
             video[controls], 
             [contenteditable], 
             [tabindex]
-          `,
-        ),
-      )
-      
-      // @ts-ignore - we check instanceof HTMLElement at runtime
-      return elements.filter(el => {
-        if (el.hasAttribute('disabled')) return false
-        if (el.hasAttribute('hidden')) return false
-        if (window.getComputedStyle(el).display === 'none') return false
-        return true
-      })
+          `
+        )
+      );
+      return elements.filter((el) => {
+        if (el.hasAttribute("disabled")) return false;
+        if (el.hasAttribute("hidden")) return false;
+        if (window.getComputedStyle(el).display === "none") return false;
+        return true;
+      });
     },
-
     /**
      * Gets elements that can be focused via keyboard (tabIndex > -1).
      * These are the elements that will be focused when using the Tab key.
@@ -102,9 +82,8 @@ export function getFocusableElements(container = document.body) {
      * @returns {HTMLElement[]} Array of keyboard focusable elements
      */
     get keyboard() {
-      return this.all.filter(el => el instanceof HTMLElement && el.tabIndex > -1)
+      return this.all.filter((el) => el instanceof HTMLElement && el.tabIndex > -1);
     },
-
     /**
      * Alias for keyboard focusable elements.
      * This is provided for semantic clarity in certain contexts.
@@ -112,9 +91,8 @@ export function getFocusableElements(container = document.body) {
      * @returns {HTMLElement[]} Array of keyboard focusable elements
      */
     get keyboardOnly() {
-      return this.keyboard
+      return this.keyboard;
     },
-
     /**
      * Gets the first keyboard focusable element.
      * This is useful for setting initial focus when opening a modal or dialog.
@@ -122,9 +100,8 @@ export function getFocusableElements(container = document.body) {
      * @returns {HTMLElement|null} The first focusable element or null if none exist
      */
     get first() {
-      return this.keyboard[0] || null
+      return this.keyboard[0] || null;
     },
-
     /**
      * Gets the last keyboard focusable element.
      * This is useful for focus trapping when using Shift+Tab.
@@ -132,9 +109,8 @@ export function getFocusableElements(container = document.body) {
      * @returns {HTMLElement|null} The last focusable element or null if none exist
      */
     get last() {
-      return this.keyboard[this.length - 1] || null
+      return this.keyboard[this.length - 1] || null;
     },
-
     /**
      * Gets the next focusable element after the given index.
      * This is useful for implementing custom tab order or focus management.
@@ -143,9 +119,8 @@ export function getFocusableElements(container = document.body) {
      * @returns {HTMLElement|null} The next focusable element or null if none exists
      */
     next(index) {
-      return this.keyboard[index + 1] || null
+      return this.keyboard[index + 1] || null;
     },
-
     /**
      * Gets the previous focusable element before the given index.
      * This is useful for implementing custom tab order or focus management.
@@ -154,12 +129,15 @@ export function getFocusableElements(container = document.body) {
      * @returns {HTMLElement|null} The previous focusable element or null if none exists
      */
     prev(index) {
-      return this.keyboard[index - 1] || null
-    },
-  }
+      return this.keyboard[index - 1] || null;
+    }
+  };
 }
-
-// Alias of getFocusableElements
-export function Focusable(container = document.body) {
-  return getFocusableElements(container)
-}
+function Focusable(container = document.body) {
+  return getFocusableElements(container);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Focusable,
+  getFocusableElements
+});

package/dist/cjs/dom/font-size.cjs

@@ -0,0 +1,80 @@
+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/dom/font-size.js
+var font_size_exports = {};
+__export(font_size_exports, {
+  em: () => em,
+  getUnit: () => getUnit,
+  lh: () => lh,
+  rem: () => rem,
+  rlh: () => rlh,
+  toPx: () => toPx
+});
+module.exports = __toCommonJS(font_size_exports);
+
+// src/lib/numbers/index.js
+function splitUnit(string) {
+  if (typeof string === "number") return [string, null];
+  const regex = /(-?\d*\.?\d+)\s*([a-z]+)/i;
+  const match = string.match(regex);
+  if (match) return [parseFloat(match[1]), match[2]];
+  return [parseFloat(string), null];
+}
+
+// src/dom/font-size.js
+function getUnit(value) {
+  const [, unit] = splitUnit(value);
+  return unit;
+}
+function rem(multiple = 1) {
+  const value = parseFloat(getComputedStyle(document.body)["font-size"]);
+  return Math.round(value * multiple);
+}
+function em(element = document.body, multiple = 1) {
+  const value = parseFloat(getComputedStyle(element)["font-size"]);
+  return Math.round(value * multiple);
+}
+function rlh(multiple = 1) {
+  const lineHeight = parseFloat(getComputedStyle(document.body)["line-height"]);
+  return Math.round(lineHeight * multiple);
+}
+function lh(element = document.body, multiple = 1) {
+  const lineHeight = getComputedStyle(element)["line-height"];
+  const value = parseFloat(lineHeight);
+  return Math.round(value * multiple);
+}
+function toPx(value, element = null) {
+  const [numeric, unit] = splitUnit(value);
+  let finalValue = 0;
+  if (unit === "rem") finalValue = rem(numeric);
+  if (unit === "em") finalValue = em(element, numeric);
+  if (unit === "lh") finalValue = lh(element, numeric);
+  if (unit === "px") finalValue = numeric;
+  if (!unit) finalValue = numeric;
+  return finalValue;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  em,
+  getUnit,
+  lh,
+  rem,
+  rlh,
+  toPx
+});

package/dist/cjs/dom/get-element.cjs

@@ -0,0 +1,98 @@
+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/dom/get-element.js
+var get_element_exports = {};
+__export(get_element_exports, {
+  getAncestorWithSiblings: () => getAncestorWithSiblings,
+  getChildrenElements: () => getChildrenElements,
+  getElement: () => getElement,
+  getNodeType: () => getNodeType,
+  getParentElement: () => getParentElement,
+  getSelfIndex: () => getSelfIndex,
+  getSiblingElements: () => getSiblingElements,
+  isAncestor: () => isAncestor
+});
+module.exports = __toCommonJS(get_element_exports);
+var astroNodes = ["ASTRO-SLOT", "ASTRO-ISLAND"];
+function getNodeType(node) {
+  if (node instanceof Element) return "element";
+  if (node instanceof NodeList) return "nodelist";
+  if (Array.isArray(node)) return "array";
+}
+function getElement(selector) {
+  if (!selector) return;
+  if (selector instanceof Element) return selector;
+  return document.querySelector(selector);
+}
+function getChildrenElements(node) {
+  let children = node.children;
+  if (children[0]?.nodeName === "ASTRO-SLOT") children = children[0].children;
+  return Array.from(children);
+}
+function getParentElement(element) {
+  const parent = element.parentElement;
+  if (astroNodes.includes(parent.nodeName)) return getParentElement(parent);
+  return parent;
+}
+function getSiblingElements(element) {
+  return Array.from(element.parentElement.children).filter(
+    (child) => child !== element
+  );
+}
+function getSelfIndex(element) {
+  return Array.from(element.parentElement.children).indexOf(element);
+}
+function isAncestor(ancestor, element, { searchLevels = 0 } = {}) {
+  if (ancestor === element) return true;
+  let parent = element.parentElement;
+  if (searchLevels === 0) {
+    while (parent) {
+      if (ancestor === parent) return true;
+      parent = parent.parentElement;
+    }
+  } else {
+    for (let i = 0; i < searchLevels; i++) {
+      if (ancestor === parent) return true;
+      parent = parent.parentElement;
+    }
+  }
+  return false;
+}
+function getAncestorWithSiblings(element, { limit = false } = {}) {
+  const ancestor = element.parentElement;
+  const siblings = getSiblingElements(ancestor);
+  if (siblings.length) return siblings;
+  if (!ancestor) return null;
+  if (limit === false) return getAncestorWithSiblings(ancestor);
+  if (typeof limit === "number" && limit > 0) {
+    return getAncestorWithSiblings(ancestor, { limit: limit - 1 });
+  }
+  if (limit === 0) return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAncestorWithSiblings,
+  getChildrenElements,
+  getElement,
+  getNodeType,
+  getParentElement,
+  getSelfIndex,
+  getSiblingElements,
+  isAncestor
+});

package/dist/cjs/dom/hash.cjs

@@ -0,0 +1,35 @@
+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/dom/hash.js
+var hash_exports = {};
+__export(hash_exports, {
+  sha256Hash: () => sha256Hash
+});
+module.exports = __toCommonJS(hash_exports);
+async function sha256Hash(string) {
+  const utf8 = new TextEncoder().encode(string);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", utf8);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((bytes) => bytes.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sha256Hash
+});