@thednp/shorty 1.0.0

package/src/get/getElementTransitionDelay.js

@@ -0,0 +1,21 @@
+import transitionDelay from '../strings/transitionDelay';
+import transitionProperty from '../strings/transitionProperty';
+import getElementStyle from './getElementStyle';
+
+/**
+ * Utility to get the computed `transitionDelay`
+ * from Element in miliseconds.
+ *
+ * @param {HTMLElement | Element} element target
+ * @return {number} the value in miliseconds
+ */
+export default function getElementTransitionDelay(element) {
+  const propertyValue = getElementStyle(element, transitionProperty);
+  const delayValue = getElementStyle(element, transitionDelay);
+
+  const delayScale = delayValue.includes('ms') ? 1 : 1000;
+  const duration = propertyValue && propertyValue !== 'none'
+    ? parseFloat(delayValue) * delayScale : 0;
+
+  return !Number.isNaN(duration) ? duration : 0;
+}

package/src/get/getElementTransitionDelayLegacy.js

@@ -0,0 +1,21 @@
+import supportTransition from '../boolean/supportTransition';
+import transitionDelay from '../strings/transitionDelayLegacy';
+import transitionProperty from '../strings/transitionPropertyLegacy';
+import getElementStyle from './getElementStyle';
+
+/**
+ * Utility to get the computed `transitionDelay`
+ * from Element in miliseconds.
+ *
+ * @param {HTMLElement | Element} element target
+ * @return {number} the value in miliseconds
+ */
+export default function getElementTransitionDelay(element) {
+  const propertyValue = getElementStyle(element, transitionProperty);
+  const delayValue = getElementStyle(element, transitionDelay);
+  const delayScale = delayValue.includes('ms') ? 1 : 1000;
+  const duration = supportTransition && propertyValue && propertyValue !== 'none'
+    ? parseFloat(delayValue) * delayScale : 0;
+
+  return !Number.isNaN(duration) ? duration : 0;
+}

package/src/get/getElementTransitionDuration.js

@@ -0,0 +1,20 @@
+import transitionDuration from '../strings/transitionDuration';
+import transitionProperty from '../strings/transitionProperty';
+import getElementStyle from './getElementStyle';
+
+/**
+ * Utility to get the computed `transitionDuration`
+ * from Element in miliseconds.
+ *
+ * @param {HTMLElement | Element} element target
+ * @return {number} the value in miliseconds
+ */
+export default function getElementTransitionDuration(element) {
+  const propertyValue = getElementStyle(element, transitionProperty);
+  const durationValue = getElementStyle(element, transitionDuration);
+  const durationScale = durationValue.includes('ms') ? 1 : 1000;
+  const duration = propertyValue && propertyValue !== 'none'
+    ? parseFloat(durationValue) * durationScale : 0;
+
+  return !Number.isNaN(duration) ? duration : 0;
+}

package/src/get/getElementTransitionDurationLegacy.js

@@ -0,0 +1,21 @@
+import supportTransition from '../boolean/supportTransition';
+import transitionDuration from '../strings/transitionDurationLegacy';
+import transitionProperty from '../strings/transitionPropertyLegacy';
+import getElementStyle from './getElementStyle';
+
+/**
+ * Utility to get the computed `transitionDuration`
+ * from Element in miliseconds.
+ *
+ * @param {HTMLElement | Element} element target
+ * @return {number} the value in miliseconds
+ */
+export default function getElementTransitionDuration(element) {
+  const propertyValue = getElementStyle(element, transitionProperty);
+  const durationValue = getElementStyle(element, transitionDuration);
+  const durationScale = durationValue.includes('ms') ? 1 : 1000;
+  const duration = supportTransition && propertyValue && propertyValue !== 'none'
+    ? parseFloat(durationValue) * durationScale : 0;
+
+  return !Number.isNaN(duration) ? duration : 0;
+}

package/src/get/getNodeScroll.js

@@ -0,0 +1,16 @@
+/**
+ * Returns an `{x,y}` object with the target
+ * `HTMLElement` / `Node` scroll position.
+ *
+ * @see https://github.com/floating-ui/floating-ui
+ *
+ * @param {HTMLElement | Element | Window} element target node / element
+ * @returns {{x: number, y: number}} the scroll tuple
+ */
+export default function getNodeScroll(element) {
+  const isWin = 'scrollX' in element;
+  const x = isWin ? element.scrollX : element.scrollLeft;
+  const y = isWin ? element.scrollY : element.scrollTop;
+
+  return { x, y };
+}

package/src/get/getParentNode.js

@@ -0,0 +1,24 @@
+import getDocumentElement from './getDocumentElement';
+import isShadowRoot from '../is/isShadowRoot';
+
+/**
+ * Returns the `parentNode` also going through `ShadowRoot`.
+ * @see https://github.com/floating-ui/floating-ui
+ *
+ * @param {Node | HTMLElement | Element} node the target node
+ * @returns {Node | HTMLElement | Element} the apropriate parent node
+ */
+export default function getParentNode(node) {
+  if (node.nodeName === 'HTML') {
+    return node;
+  }
+
+  // this is a quicker (but less type safe) way to save quite some bytes from the bundle
+  return (
+    // @ts-ignore
+    node.assignedSlot // step into the shadow DOM of the parent of a slotted node
+    || node.parentNode // @ts-ignore DOM Element detected
+    || (isShadowRoot(node) ? node.host : null) // ShadowRoot detected
+    || getDocumentElement(node) // fallback
+  );
+}

package/src/get/getRectRelativeToOffsetParent.js

@@ -0,0 +1,30 @@
+import isScaledElement from '../is/isScaledElement';
+import getBoundingClientRect from './getBoundingClientRect';
+
+/**
+ * Returns the rect relative to an offset parent.
+ * @see https://github.com/floating-ui/floating-ui
+ *
+ * @param {HTMLElement | Element} element target
+ * @param {HTMLElement | Element | Window} offsetParent the container / offset parent
+ * @param {{x: number, y: number}} scroll
+ * @returns {SHORTER.OffsetRect}
+ */
+export default function getRectRelativeToOffsetParent(element, offsetParent, scroll) {
+  const isParentAnElement = offsetParent instanceof HTMLElement;
+  const rect = getBoundingClientRect(element, isParentAnElement && isScaledElement(offsetParent));
+  const offsets = { x: 0, y: 0 };
+
+  if (isParentAnElement) {
+    const offsetRect = getBoundingClientRect(offsetParent, true);
+    offsets.x = offsetRect.x + offsetParent.clientLeft;
+    offsets.y = offsetRect.y + offsetParent.clientTop;
+  }
+
+  return {
+    x: rect.left + scroll.x - offsets.x,
+    y: rect.top + scroll.y - offsets.y,
+    width: rect.width,
+    height: rect.height,
+  };
+}

package/src/get/getUID.js

@@ -0,0 +1,34 @@
+let elementUID = 0;
+let elementMapUID = 0;
+const elementIDMap = new Map();
+
+/**
+ * Returns a unique identifier for popover, tooltip, scrollspy.
+ *
+ * @param {HTMLElement | Element} element target element
+ * @param {string=} key predefined key
+ * @returns {number} an existing or new unique ID
+ */
+export default function getUID(element, key) {
+  let result = key ? elementUID : elementMapUID;
+
+  if (key) {
+    const elID = getUID(element);
+    const elMap = elementIDMap.get(elID) || new Map();
+    if (!elementIDMap.has(elID)) {
+      elementIDMap.set(elID, elMap);
+    }
+    if (!elMap.has(key)) {
+      elMap.set(key, result);
+      elementUID += 1;
+    } else result = elMap.get(key);
+  } else {
+    const elkey = element.id || element;
+
+    if (!elementIDMap.has(elkey)) {
+      elementIDMap.set(elkey, result);
+      elementMapUID += 1;
+    } else result = elementIDMap.get(elkey);
+  }
+  return result;
+}

package/src/get/getWindow.js

@@ -0,0 +1,20 @@
+/**
+ * Returns the `Window` object of a target node.
+ * @see https://github.com/floating-ui/floating-ui
+ *
+ * @param {(Node | HTMLElement | Element | Window)=} node target node
+ * @returns {globalThis}
+ */
+export default function getWindow(node) {
+  if (node == null) {
+    return window;
+  }
+
+  if (!(node instanceof Window)) {
+    const { ownerDocument } = node;
+    return ownerDocument ? ownerDocument.defaultView || window : window;
+  }
+
+  // @ts-ignore
+  return node;
+}