@thednp/shorty 1.0.3 → 2.0.0-alpha10

package/src/boolean/supportTouch.ts

@@ -0,0 +1,7 @@
+/**
+ * A global `boolean` for touch events support.
+ */
+const supportTouch =
+  'ontouchstart' in window || /* istanbul ignore next */ 'msMaxTouchPoints' in navigator;
+
+export default supportTouch;

package/src/boolean/supportTransform.ts

@@ -0,0 +1,8 @@
+import documentHead from '../blocks/documentHead';
+
+/**
+ * A global `boolean` for CSS3 transform support.
+ */
+const supportTransform = ['webkitTransform', 'transform'].some(p => p in documentHead.style);
+
+export default supportTransform;

package/src/boolean/supportTransition.ts

@@ -0,0 +1,8 @@
+import documentHead from '../blocks/documentHead';
+
+/**
+ * A global `boolean` for CSS3 transition support.
+ */
+const supportTransition = ['webkitTransition', 'transition'].some(p => p in documentHead.style);
+
+export default supportTransition;

package/src/class/addClass.ts

@@ -0,0 +1,11 @@
+/**
+ * Add one or more CSS classes to `HTMLElement.classList`.
+ *
+ * @param element target
+ * @param classNAME to add
+ */
+const addClass = (element: HTMLElement, ...classNAME: string[]): void => {
+  element.classList.add(...classNAME);
+};
+
+export default addClass;

package/src/class/hasClass.ts

@@ -0,0 +1,11 @@
+/**
+ * Check class in `HTMLElement.classList`.
+ *
+ * @param element target
+ * @param classNAME to check
+ */
+const hasClass = (element: HTMLElement, classNAME: string): boolean => {
+  return element.classList.contains(classNAME);
+};
+
+export default hasClass;

package/src/class/removeClass.ts

@@ -0,0 +1,11 @@
+/**
+ * Remove one or more classes from `HTMLElement.classList`.
+ *
+ * @param element target
+ * @param classNAME to remove
+ */
+const removeClass = (element: HTMLElement, ...classNAME: string[]): void => {
+  element.classList.remove(...classNAME);
+};
+
+export default removeClass;

package/src/event/off.ts

@@ -0,0 +1,14 @@
+/**
+ * Remove eventListener from an `EventTarget` object.
+ */
+const off = (
+  element: EventTarget,
+  eventName: string,
+  listener: EventListener,
+  options?: AddEventListenerOptions,
+) => {
+  const ops = options || false;
+  element.removeEventListener(eventName, listener, ops);
+};
+
+export default off;

package/src/event/on.ts

@@ -0,0 +1,14 @@
+/**
+ * Add eventListener to an `EventTarget` object.
+ */
+const on = (
+  element: EventTarget,
+  eventName: string,
+  listener: EventListener,
+  options?: AddEventListenerOptions,
+) => {
+  const ops = options || false;
+  element.addEventListener(eventName, listener, ops);
+};
+
+export default on;

package/src/event/one.ts

@@ -0,0 +1,25 @@
+import on from './on';
+import off from './off';
+
+/**
+ * Add an `eventListener` to an `EventTarget`
+ * element and remove it once callback is called.
+ */
+const one = (
+  element: EventTarget,
+  eventName: string,
+  listener: EventListener,
+  options?: AddEventListenerOptions,
+) => {
+  /** Wrap the listener for easy on -> off */
+  const handlerWrapper = (e: Event): void => {
+    /* istanbul ignore else */
+    if (e.target === element || e.currentTarget === element) {
+      listener.apply(element, [e]);
+      off(element, eventName, handlerWrapper, options);
+    }
+  };
+  on(element, eventName, handlerWrapper, options);
+};
+
+export default one;

package/src/get/{getBoundingClientRect.js → getBoundingClientRect.ts}

@@ -1,27 +1,27 @@
 import isHTMLElement from '../is/isHTMLElement';
+import type { BoundingClientRect } from '../interface/boundingClientRect';
 
 /**
  * Returns the bounding client rect of a target `HTMLElement`.
  *
  * @see https://github.com/floating-ui/floating-ui
  *
- * @param {HTMLElement} element event.target
- * @param {boolean=} includeScale when *true*, the target scale is also computed
- * @returns {SHORTY.BoundingClientRect} the bounding client rect object
+ * @param element event.target
+ * @param includeScale when *true*, the target scale is also computed
+ * @returns the bounding client rect object
  */
-export default function getBoundingClientRect(element, includeScale) {
-  const {
-    width, height, top, right, bottom, left,
-  } = element.getBoundingClientRect();
+const getBoundingClientRect = (
+  element: HTMLElement,
+  includeScale?: boolean,
+): BoundingClientRect => {
+  const { width, height, top, right, bottom, left } = element.getBoundingClientRect();
   let scaleX = 1;
   let scaleY = 1;
 
   if (includeScale && isHTMLElement(element)) {
     const { offsetWidth, offsetHeight } = element;
-    scaleX = offsetWidth > 0 ? Math.round(width) / offsetWidth
-      : /* istanbul ignore next */1;
-    scaleY = offsetHeight > 0 ? Math.round(height) / offsetHeight
-      : /* istanbul ignore next */1;
+    scaleX = offsetWidth > 0 ? Math.round(width) / offsetWidth : /* istanbul ignore next */ 1;
+    scaleY = offsetHeight > 0 ? Math.round(height) / offsetHeight : /* istanbul ignore next */ 1;
   }
 
   return {
@@ -34,4 +34,6 @@ export default function getBoundingClientRect(element, includeScale) {
     x: left / scaleX,
     y: top / scaleY,
   };
-}
+};
+
+export default getBoundingClientRect;

package/src/get/{getDocument.js → getDocument.ts}

@@ -4,17 +4,21 @@ import isDocument from '../is/isDocument';
 
 /**
  * Returns the `document` or the `#document` element.
+ *
  * @see https://github.com/floating-ui/floating-ui
- * @param {(Node | Window)=} node
- * @returns {Document}
+ *
+ * @param node the reference node
+ * @returns the parent document of the given node
  */
-export default function getDocument(node) {
+const getDocument = (node?: Node | Document | Window): Document => {
+  // node instanceof Window
+  if (isWindow(node)) return node.document;
   // node instanceof Document
   if (isDocument(node)) return node;
   // node instanceof Node
-  if (isNode(node)) return node.ownerDocument;
-  // node instanceof Window
-  if (isWindow(node)) return node.document;
+  if (isNode(node)) return node.ownerDocument as Document;
   // node is undefined | NULL
   return window.document;
-}
+};
+
+export default getDocument;

package/src/get/getDocumentBody.ts

@@ -0,0 +1,13 @@
+import getDocument from './getDocument';
+
+/**
+ * Returns the `document.body` or the `<body>` element.
+ *
+ * @param node the reference node
+ * @returns the parent `<body>` of the specified node
+ */
+const getDocumentBody = (node?: Node | Document | Window): HTMLElement => {
+  return getDocument(node).body;
+};
+
+export default getDocumentBody;

package/src/get/getDocumentElement.ts

@@ -0,0 +1,13 @@
+import getDocument from './getDocument';
+
+/**
+ * Returns the `document.documentElement` or the `<HTML>` element.
+ *
+ * @param node the reference node
+ * @returns the parent `<HTML>` of the node's parent document
+ */
+const getDocumentElement = (node?: Node | Document | Window): HTMLElement => {
+  return getDocument(node).documentElement;
+};
+
+export default getDocumentElement;

package/src/get/getDocumentHead.ts

@@ -0,0 +1,12 @@
+import getDocument from './getDocument';
+/**
+ * Returns the `document.head` or the `<head>` element.
+ *
+ * @param node the reference node
+ * @returns the `<head>` of the node's parent document
+ */
+const getDocumentHead = (node?: Node | Document | Window): HTMLElement & HTMLHeadElement => {
+  return getDocument(node).head;
+};
+
+export default getDocumentHead;

package/src/get/{getElementAnimationDelay.js → getElementAnimationDelay.ts}

@@ -6,16 +6,17 @@ import getElementStyle from './getElementStyle';
  * Utility to get the computed `animationDelay`
  * from Element in miliseconds.
  *
- * @param {HTMLElement} element target
- * @return {number} the value in miliseconds
+ * @param element target
+ * @return the `animationDelay` value in miliseconds
  */
-export default function getElementAnimationDelay(element) {
+const getElementAnimationDelay = (element: HTMLElement): number => {
   const propertyValue = getElementStyle(element, animationName);
   const durationValue = getElementStyle(element, animationDelay);
-  const durationScale = durationValue.includes('ms') ? /* istanbul ignore next */1 : 1000;
-  const duration = propertyValue && propertyValue !== 'none'
-    ? parseFloat(durationValue) * durationScale : 0;
+  const durationScale = durationValue.includes('ms') ? /* istanbul ignore next */ 1 : 1000;
+  const duration =
+    propertyValue && propertyValue !== 'none' ? parseFloat(durationValue) * durationScale : 0;
 
-  /* istanbul ignore next */
-  return !Number.isNaN(duration) ? duration : 0;
-}
+  return !Number.isNaN(duration) ? duration : /* istanbul ignore next */ 0;
+};
+
+export default getElementAnimationDelay;

package/src/get/{getElementAnimationDuration.js → getElementAnimationDuration.ts}

@@ -6,15 +6,17 @@ import getElementStyle from './getElementStyle';
  * Utility to get the computed `animationDuration`
  * from `HTMLElement` in miliseconds.
  *
- * @param {HTMLElement} element target
- * @return {number} the value in miliseconds
+ * @param element target
+ * @return the `animationDuration` value in miliseconds
  */
-export default function getElementAnimationDuration(element) {
+const getElementAnimationDuration = (element: HTMLElement): number => {
   const propertyValue = getElementStyle(element, animationName);
   const durationValue = getElementStyle(element, animationDuration);
-  const durationScale = durationValue.includes('ms') ? /* istanbul ignore next */1 : 1000;
-  const duration = propertyValue && propertyValue !== 'none'
-    ? parseFloat(durationValue) * durationScale : 0;
+  const durationScale = durationValue.includes('ms') ? /* istanbul ignore next */ 1 : 1000;
+  const duration =
+    propertyValue && propertyValue !== 'none' ? parseFloat(durationValue) * durationScale : 0;
 
-  return !Number.isNaN(duration) ? duration : /* istanbul ignore next */0;
-}
+  return !Number.isNaN(duration) ? duration : /* istanbul ignore next */ 0;
+};
+
+export default getElementAnimationDuration;

package/src/get/getElementStyle.ts

@@ -0,0 +1,25 @@
+// import CSS4Declaration from "../interface/css4Declaration";
+
+/**
+ * Shortcut for `window.getComputedStyle(element).propertyName`
+ * static method.
+ *
+ * * If `element` parameter is not an `HTMLElement`, `getComputedStyle`
+ * throws a `ReferenceError`.
+ *
+ * @param element target
+ * @param property the css property
+ * @return the css property value
+ */
+const getElementStyle = (element: HTMLElement, property: string): string => {
+  const computedStyle = getComputedStyle(element);
+  const prop = property
+    .replace('webkit', 'Webkit')
+    .replace(/([A-Z])/g, '-$1')
+    .toLowerCase();
+
+  // modern browsers only
+  return computedStyle.getPropertyValue(prop);
+};
+
+export default getElementStyle;

package/src/get/{getElementTransitionDelay.js → getElementTransitionDelay.ts}

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

package/src/get/{getElementTransitionDuration.js → getElementTransitionDuration.ts}

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

package/src/get/{getNodeScroll.js → getNodeScroll.ts}

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

package/src/get/{getParentNode.js → getParentNode.ts}

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

package/src/get/{getRectRelativeToOffsetParent.js → getRectRelativeToOffsetParent.ts}

@@ -1,17 +1,23 @@
+import type { OffsetRect } from '../interface/offsetRect';
 import isScaledElement from '../is/isScaledElement';
 import isHTMLElement from '../is/isHTMLElement';
 import getBoundingClientRect from './getBoundingClientRect';
 
 /**
- * Returns the rect relative to an offset parent.
+ * Returns the rect relative to a given offset parent and its scroll position.
+ *
  * @see https://github.com/floating-ui/floating-ui
  *
- * @param {HTMLElement} element target
- * @param {ParentNode | Window} offsetParent the container / offset parent
- * @param {{x: number, y: number}} scroll the offsetParent scroll position
- * @returns {SHORTY.OffsetRect}
+ * @param element target
+ * @param offsetParent the container / offset parent
+ * @param scroll the offsetParent scroll position
+ * @returns a DOMRect like object
  */
-export default function getRectRelativeToOffsetParent(element, offsetParent, scroll) {
+const getRectRelativeToOffsetParent = (
+  element: HTMLElement,
+  offsetParent: HTMLElement,
+  scroll: { x: number; y: number },
+): OffsetRect => {
   const isParentAnElement = isHTMLElement(offsetParent);
   const rect = getBoundingClientRect(element, isParentAnElement && isScaledElement(offsetParent));
   const offsets = { x: 0, y: 0 };
@@ -29,4 +35,6 @@ export default function getRectRelativeToOffsetParent(element, offsetParent, scr
     width: rect.width,
     height: rect.height,
   };
-}
+};
+
+export default getRectRelativeToOffsetParent;

package/src/get/getUID.ts

@@ -0,0 +1,42 @@
+import isMap from '../is/isMap';
+
+let elementUID = 0;
+let elementMapUID = 0;
+
+type KeyIdMap = Map<string | number, number>;
+type IDMap = Map<number | string | HTMLElement, number | KeyIdMap>;
+
+const elementIDMap: IDMap = new Map();
+
+/**
+ * Returns a unique identifier for popover, tooltip, scrollspy.
+ *
+ * @param element target element
+ * @param key optional identifier key
+ * @returns an existing or new unique ID
+ */
+const getUID = (element: HTMLElement, key?: string): number => {
+  let result = key ? elementUID : elementMapUID;
+
+  if (key) {
+    const elID = getUID(element);
+    const elMap = elementIDMap.get(elID) || (new Map() as KeyIdMap);
+    if (!elementIDMap.has(elID)) {
+      elementIDMap.set(elID, elMap);
+    }
+    if (isMap(elMap as KeyIdMap) && !(elMap as KeyIdMap).has(key)) {
+      (elMap as KeyIdMap).set(key, result);
+      elementUID += 1;
+    } else result = (elMap as KeyIdMap).get(key) as number;
+  } else {
+    const elkey = element.id || element;
+
+    if (!elementIDMap.has(elkey)) {
+      elementIDMap.set(elkey, result);
+      elementMapUID += 1;
+    } else result = elementIDMap.get(elkey) as number;
+  }
+  return result;
+};
+
+export default getUID;

package/src/get/{getWindow.js → getWindow.ts}

@@ -3,18 +3,21 @@ import isNode from '../is/isNode';
 
 /**
  * Returns the `Window` object of a target node.
+ *
  * @see https://github.com/floating-ui/floating-ui
  *
- * @param {(Node | Window)=} node target node
- * @returns {Window} the `Window` object
+ * @param node target node
+ * @returns the `Window` object
  */
-export default function getWindow(node) {
+const getWindow = (node?: Node): Window => {
   // node is undefined | NULL
   if (!node) return window;
   // node instanceof Document
-  if (isDocument(node)) return node.defaultView;
+  if (isDocument(node)) return node.defaultView as Window;
   // node instanceof Node
-  if (isNode(node)) return node.ownerDocument.defaultView;
+  if (isNode(node)) return node?.ownerDocument?.defaultView as Window;
   // node is instanceof Window
   return node;
-}
+};
+
+export default getWindow;