@thednp/shorty 2.0.0-alpha2 → 2.0.0-alpha21

package/src/interface/event.d.ts

@@ -0,0 +1,247 @@
+/**
+ * Type definitions addapted from React 18.2
+ * Project: https://react.dev/
+ */
+
+type NativeAnimationEvent = AnimationEvent;
+type NativeClipboardEvent = ClipboardEvent;
+type NativeCompositionEvent = CompositionEvent;
+type NativeDragEvent = DragEvent;
+type NativeFocusEvent = FocusEvent;
+type NativeKeyboardEvent = KeyboardEvent;
+type NativeMouseEvent = MouseEvent;
+type NativeTouchEvent = TouchEvent;
+type NativePointerEvent = PointerEvent;
+type NativeTransitionEvent = TransitionEvent;
+type NativeUIEvent = UIEvent;
+type NativeWheelEvent = WheelEvent;
+
+interface AbstractView {
+  styleMedia: StyleMedia;
+  document: Document;
+}
+
+//
+// Event System
+// ----------------------------------------------------------------------
+// E = EventObject, C = e.currentTarget, T = e.target
+interface BaseEvent<E = Event, C = unknown, T = unknown> {
+  nativeEvent: E;
+  currentTarget: C | null;
+  target: T & EventTarget;
+  bubbles: boolean;
+  cancelable: boolean;
+  defaultPrevented: boolean;
+  eventPhase: number;
+  isTrusted: boolean;
+  preventDefault(): void;
+  isDefaultPrevented(): boolean;
+  stopPropagation(): void;
+  isPropagationStopped(): boolean;
+  persist(): void;
+  timeStamp: number;
+  type: string;
+}
+
+/**
+ * currentTarget - a reference to the element on which the event listener is registered.
+ *
+ * target - a reference to the element from which the event was originally dispatched.
+ * This might be a child element to the element on which the event listener is registered.
+ * If you thought this should be `EventTarget & T`, see https://github.com/DefinitelyTyped/DefinitelyTyped/issues/11508#issuecomment-256045682
+ */
+type NativeEvent<T = Element, E = Event> = BaseEvent<E, T, T>;
+
+interface ClipboardEvent<T = Element> extends NativeEvent<T, NativeClipboardEvent> {
+  clipboardData: DataTransfer;
+}
+
+interface CompositionEvent<T = Element> extends NativeEvent<T, NativeCompositionEvent> {
+  data: string;
+}
+
+interface DragEvent<T = Element> extends MouseEvent<T, NativeDragEvent> {
+  dataTransfer: DataTransfer;
+}
+
+interface PointerEvent<T = Element> extends MouseEvent<T, NativePointerEvent> {
+  pointerId: number;
+  pressure: number;
+  tangentialPressure: number;
+  tiltX: number;
+  tiltY: number;
+  twist: number;
+  width: number;
+  height: number;
+  pointerType: 'mouse' | 'pen' | 'touch';
+  isPrimary: boolean;
+}
+
+interface FocusEvent<T = Element, R = Element> extends NativeEvent<T, NativeFocusEvent> {
+  relatedTarget: (EventTarget & R) | null;
+  target: EventTarget & T;
+}
+
+type FormControl = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
+type FormEvent<T = FormControl> = NativeEvent<T>;
+
+interface ChangeEvent<T = FormControl> extends FormEvent<T> {
+  target: EventTarget & T;
+}
+
+type ModifierKey =
+  | 'Alt'
+  | 'AltGraph'
+  | 'CapsLock'
+  | 'Control'
+  | 'Fn'
+  | 'FnLock'
+  | 'Hyper'
+  | 'Meta'
+  | 'NumLock'
+  | 'ScrollLock'
+  | 'Shift'
+  | 'Super'
+  | 'Symbol'
+  | 'SymbolLock';
+
+interface KeyboardEvent<T = Element> extends UIEvent<T, NativeKeyboardEvent> {
+  altKey: boolean;
+  /** @deprecated */
+  charCode: number;
+  ctrlKey: boolean;
+  code: string;
+  /**
+   * See [DOM Level 3 Events spec](https://www.w3.org/TR/uievents-key/#keys-modifier). for a list of valid (case-sensitive) arguments to this method.
+   */
+  getModifierState(key: ModifierKey): boolean;
+  /**
+   * See the [DOM Level 3 Events spec](https://www.w3.org/TR/uievents-key/#named-key-attribute-values). for possible values
+   */
+  key: string;
+  /** @deprecated */
+  keyCode: number;
+  locale: string;
+  location: number;
+  metaKey: boolean;
+  repeat: boolean;
+  shiftKey: boolean;
+  /** @deprecated */
+  which: number;
+}
+
+interface MouseEvent<T = Element, E = NativeMouseEvent> extends UIEvent<T, E> {
+  altKey: boolean;
+  button: number;
+  buttons: number;
+  clientX: number;
+  clientY: number;
+  ctrlKey: boolean;
+  /**
+   * See [DOM Level 3 Events spec](https://www.w3.org/TR/uievents-key/#keys-modifier). for a list of valid (case-sensitive) arguments to this method.
+   */
+  getModifierState(key: ModifierKey): boolean;
+  metaKey: boolean;
+  movementX: number;
+  movementY: number;
+  pageX: number;
+  pageY: number;
+  relatedTarget: EventTarget | null;
+  screenX: number;
+  screenY: number;
+  shiftKey: boolean;
+}
+
+interface TouchEvent<T = Element> extends UIEvent<T, NativeTouchEvent> {
+  altKey: boolean;
+  changedTouches: TouchList;
+  ctrlKey: boolean;
+  /**
+   * See [DOM Level 3 Events spec](https://www.w3.org/TR/uievents-key/#keys-modifier). for a list of valid (case-sensitive) arguments to this method.
+   */
+  getModifierState(key: ModifierKey): boolean;
+  metaKey: boolean;
+  shiftKey: boolean;
+  targetTouches: TouchList;
+  touches: TouchList;
+}
+
+interface UIEvent<T = Element, E = NativeUIEvent> extends NativeEvent<T, E> {
+  detail: number;
+  view: AbstractView;
+}
+
+interface WheelEvent<T = Element> extends MouseEvent<T, NativeWheelEvent> {
+  deltaMode: number;
+  deltaX: number;
+  deltaY: number;
+  deltaZ: number;
+}
+
+interface AnimationEvent<T = Element> extends NativeEvent<T, NativeAnimationEvent> {
+  animationName: string;
+  elapsedTime: number;
+  pseudoElement: string;
+}
+
+interface TransitionEvent<T = Element> extends NativeEvent<T, NativeTransitionEvent> {
+  elapsedTime: number;
+  propertyName: string;
+  pseudoElement: string;
+}
+
+//
+// Event Handler Types
+// ----------------------------------------------------------------------
+// (this: unknown & EventTarget, event: E): void;
+type EventHandler<T = Element, E = Event | NativeEvent<T>> = (event: E) => void;
+type NativeEventHandler<T = Element> = EventHandler<T, NativeEvent<T>>;
+type ClipboardEventHandler<T = Element> = EventHandler<T, ClipboardEvent<T>>;
+type CompositionEventHandler<T = Element> = EventHandler<T, CompositionEvent<T>>;
+type DragEventHandler<T = Element> = EventHandler<T, DragEvent<T>>;
+type FocusEventHandler<T = Element> = EventHandler<T, FocusEvent<T>>;
+type FormEventHandler<T = Element> = EventHandler<T, FormEvent<T>>;
+type ChangeEventHandler<T = Element> = EventHandler<T, ChangeEvent<T>>;
+type KeyboardEventHandler<T = Element> = EventHandler<T, KeyboardEvent<T>>;
+type MouseEventHandler<T = Element> = EventHandler<T, MouseEvent<T>>;
+type TouchEventHandler<T = Element> = EventHandler<T, TouchEvent<T>>;
+type PointerEventHandler<T = Element> = EventHandler<T, PointerEvent<T>>;
+type UIEventHandler<T = Element> = EventHandler<T, UIEvent<T>>;
+type WheelEventHandler<T = Element> = EventHandler<T, WheelEvent<T>>;
+type AnimationEventHandler<T = Element> = EventHandler<T, AnimationEvent<T>>;
+type TransitionEventHandler<T = Element> = EventHandler<T, TransitionEvent<T>>;
+type PossibleEventTarget = EventTarget & (Element | Document | Window);
+
+export {
+  NativeEvent,
+  ClipboardEvent,
+  CompositionEvent,
+  DragEvent,
+  FocusEvent,
+  FormEvent,
+  ChangeEvent,
+  KeyboardEvent,
+  MouseEvent,
+  TouchEvent,
+  PointerEvent,
+  UIEvent,
+  WheelEvent,
+  AnimationEvent,
+  TransitionEvent,
+  NativeEventHandler,
+  ClipboardEventHandler,
+  CompositionEventHandler,
+  DragEventHandler,
+  FocusEventHandler,
+  FormEventHandler,
+  ChangeEventHandler,
+  KeyboardEventHandler,
+  MouseEventHandler,
+  TouchEventHandler,
+  PointerEventHandler,
+  UIEventHandler,
+  WheelEventHandler,
+  AnimationEventHandler,
+  TransitionEventHandler,
+  PossibleEventTarget,
+};

package/src/interface/{navigatorUA.ts → navigatorUA.d.ts}

@@ -1,15 +1,15 @@
-// https://github.com/lukewarlow/user-agent-data-types/blob/master/index.d.ts
-export interface NavigatorUABrand {
-  readonly brand: string;
-  readonly version: string;
-}
-
-export interface NavigatorUAData {
-  readonly brands: NavigatorUABrand[];
-  readonly mobile: boolean;
-  readonly platform: string;
-}
-
-export default interface NavigatorUA extends Navigator {
-  readonly userAgentData: NavigatorUAData;
-}
+// https://github.com/lukewarlow/user-agent-data-types/blob/master/index.d.ts
+export declare interface NavigatorUABrand {
+  readonly brand: string;
+  readonly version: string;
+}
+
+export declare interface NavigatorUAData {
+  readonly brands: NavigatorUABrand[];
+  readonly mobile: boolean;
+  readonly platform: string;
+}
+
+export declare interface NavigatorUA extends Navigator {
+  readonly userAgentData: NavigatorUAData;
+}

package/src/interface/{offsetRect.ts → offsetRect.d.ts}

@@ -1,6 +1,6 @@
-export default interface OffsetRect {
-  width: number;
-  height: number;
-  x: number;
-  y: number;
-}
+export declare interface OffsetRect {
+  width: number;
+  height: number;
+  x: number;
+  y: number;
+}

package/src/interface/originalEvent.d.ts

@@ -0,0 +1,4 @@
+export declare interface OriginalEvent extends CustomEvent<any> {
+  readonly type: string;
+  relatedTarget?: EventTarget;
+}

package/src/is/isArray.ts

@@ -4,6 +4,6 @@
  * @param obj array-like iterable object
  * @returns the query result
  */
-const isArray = (obj?: any): obj is any[] => Array.isArray(obj) || false;
+const isArray = (obj?: unknown): obj is any[] => Array.isArray(obj) || false;
 
 export default isArray;

package/src/is/isCanvas.ts

@@ -1,3 +1,5 @@
+import isNode from './isNode';
+
 /**
  * Checks if an element is an `HTMLCanvasElement` or `<canvas>`.
  *
@@ -5,7 +7,7 @@
  * @returns the query result
  */
 
-const isCanvas = (element?: any): element is HTMLCanvasElement =>
-  (element && element.constructor.name === "HTMLCanvasElement") || false;
+const isCanvas = (element?: unknown): element is HTMLCanvasElement =>
+  (isNode(element) && element.nodeName === 'CANVAS') || false;
 
 export default isCanvas;

package/src/is/isCustomElement.ts

@@ -1,4 +1,5 @@
-import CustomElement from "../interface/customElement";
+import isHTMLElement from './isHTMLElement';
+import type { CustomElement } from '../interface/customElement';
 
 /**
  * Checks if an object is a `CustomElement`.
@@ -6,7 +7,7 @@ import CustomElement from "../interface/customElement";
  * @param element the target object
  * @returns the query result
  */
-const isCustomElement = <T extends CustomElement>(element?: any): element is T =>
-  (element && !!element.shadowRoot) || false;
+const isCustomElement = <T extends CustomElement>(element?: unknown): element is T =>
+  (isHTMLElement(element) && !!(element as T).shadowRoot) || false;
 
 export default isCustomElement;

package/src/is/isDocument.ts

@@ -1,10 +1,13 @@
+import isNode from './isNode';
+
 /**
  * Checks if an object is a `Document`.
+ *
  * @see https://dom.spec.whatwg.org/#node
  *
  * @param obj the target object
  * @returns the query result
  */
-const isDocument = (obj?: any): obj is Document => (obj && obj.nodeType === 9) || false;
+const isDocument = (obj?: unknown): obj is Document => (isNode(obj) && obj.nodeType === 9) || false;
 
 export default isDocument;

package/src/is/isElement.ts

@@ -1,6 +1,11 @@
+import isNode from './isNode';
+
 /**
  * Checks if an object is an `Element`.
+ *
  * @see https://dom.spec.whatwg.org/#node
+ *
+ * ```
  * ELEMENT_NODE = 1;
  * ATTRIBUTE_NODE = 2;
  * TEXT_NODE = 3;
@@ -12,11 +17,11 @@
  * DOCUMENT_NODE = 9;
  * DOCUMENT_TYPE_NODE = 10;
  * DOCUMENT_FRAGMENT_NODE = 11;
- *
+ * ```
  * @param element the target object
  * @returns the query result
  */
-const isElement = (element?: any): element is Element =>
-  (element && [1, 2, 3, 4, 5, 6, 7, 8].some((x) => element.nodeType === x)) || false;
+const isElement = (element?: unknown): element is Element =>
+  (isNode(element) && [1, 2, 3, 4, 5, 6, 7, 8].some(x => element.nodeType === x)) || false;
 
 export default isElement;

package/src/is/isElementInScrollRange.ts

@@ -1,6 +1,6 @@
-import getBoundingClientRect from "../get/getBoundingClientRect";
-import getDocumentElement from "../get/getDocumentElement";
-import isNode from "./isNode";
+import getBoundingClientRect from '../get/getBoundingClientRect';
+import getDocumentElement from '../get/getDocumentElement';
+import isNode from './isNode';
 
 /**
  * Utility to determine if an `HTMLElement`

package/src/is/isElementInViewport.ts

@@ -1,6 +1,6 @@
-import getBoundingClientRect from "../get/getBoundingClientRect";
-import getDocumentElement from "../get/getDocumentElement";
-import isNode from "./isNode";
+import getBoundingClientRect from '../get/getBoundingClientRect';
+import getDocumentElement from '../get/getDocumentElement';
+import isNode from './isNode';
 
 /**
  * Utility to determine if an `HTMLElement`

package/src/is/isElementsArray.ts

@@ -1,5 +1,5 @@
-import isHTMLElement from "./isHTMLElement";
-import isArray from "./isArray";
+import isHTMLElement from './isHTMLElement';
+import isArray from './isArray';
 
 /**
  * Checks if an object is an `Array` in which all items are `Element`.
@@ -7,7 +7,7 @@ import isArray from "./isArray";
  * @param obj the target object
  * @returns the query result
  */
-const isElementsArray = (obj?: any): obj is HTMLElement[] =>
+const isElementsArray = (obj?: unknown): obj is HTMLElement[] =>
   (isArray(obj) && obj.every(isHTMLElement)) || false;
 
 export default isElementsArray;

package/src/is/isFunction.ts

@@ -4,7 +4,7 @@
  * @param fn the target object
  * @returns the query result
  */
-const isFunction = (fn?: any): fn is Function =>
-  (fn && fn.constructor.name === "Function") || false;
+const isFunction = (fn?: unknown): fn is (...arg0: any[]) => any =>
+  typeof fn === 'function' || false;
 
 export default isFunction;

package/src/is/isHTMLCollection.ts

@@ -1,10 +1,12 @@
+import isObject from './isObject';
+
 /**
  * Checks if an object is an `HTMLCollection`.
  *
  * @param obj the target object
  * @returns the query result
  */
-const isHTMLCollection = (obj?: any): obj is HTMLCollection =>
-  (obj && obj.constructor.name === "HTMLCollection") || false;
+const isHTMLCollection = (obj?: unknown): obj is HTMLCollection =>
+  (isObject(obj) && obj.constructor.name === 'HTMLCollection') || false;
 
 export default isHTMLCollection;

package/src/is/isHTMLElement.ts

@@ -1,10 +1,13 @@
+import isNode from './isNode';
+
 /**
  * Checks if an element is an `HTMLElement`.
+ *
  * @see https://dom.spec.whatwg.org/#node
  *
  * @param element the target object
  * @returns the query result
  */
-const isHTMLElement = (element?: any): element is HTMLElement =>
-  (element && element.nodeType === 1) || false;
+const isHTMLElement = (element?: unknown): element is HTMLElement =>
+  (isNode(element) && element.nodeType === 1) || false;
 export default isHTMLElement;

package/src/is/isHTMLImageElement.ts

@@ -1,9 +1,12 @@
+import isHTMLElement from './isHTMLElement';
+
 /**
  * Check if a target element is an `<img>`.
+ *
  * @param element the target element
  * @returns the query result
  */
-const isHTMLImageElement = (element?: any): element is HTMLImageElement =>
-  (element && element.tagName === "IMG") || false;
+const isHTMLImageElement = (element?: unknown): element is HTMLImageElement =>
+  (isHTMLElement(element) && element.tagName === 'IMG') || false;
 
 export default isHTMLImageElement;

package/src/is/isJSON.ts

@@ -0,0 +1,20 @@
+import isString from './isString';
+
+/**
+ * Checks if a string is a `JSON` string.
+ *
+ * @param str the target string
+ * @returns the query result
+ */
+const isJSON = (str?: string): boolean => {
+  if (!isString(str)) return false;
+
+  try {
+    JSON.parse(str);
+  } catch (e) {
+    return false;
+  }
+  return true;
+};
+
+export default isJSON;

package/src/is/isMap.ts

@@ -1,8 +1,11 @@
-/**
- * Checks if an element is a `Map`.
- *
- * @param obj the target object
- * @returns the query result
- */
-const isMap = (obj?: any): obj is Map<any, any> => (obj && obj.constructor.name === 'Map') || false;
-export default isMap;
+import isObject from './isObject';
+
+/**
+ * Checks if an element is a `Map`.
+ *
+ * @param obj the target object
+ * @returns the query result
+ */
+const isMap = (obj?: unknown): obj is Map<any, any> =>
+  (isObject(obj) && obj.constructor.name === 'Map') || false;
+export default isMap;

package/src/is/isMedia.ts

@@ -1,18 +1,20 @@
+import isNode from './isNode';
+
 /**
  * Checks if an element is an `<svg>` (or any type of SVG element),
  * `<img>`, `<video>` or `<canvas>`.
  *
  * *Tooltip* / *Popover* works different with media elements.
+ *
  * @param element the target element
  * @returns the query result
  */
 
 const isMedia = (
-  element?: any
+  element?: unknown,
 ): element is SVGElement | HTMLImageElement | HTMLVideoElement | HTMLCanvasElement =>
-  (element &&
-    element.nodeType === 1 &&
-    ["SVG", "Image", "Video", "Canvas"].some((s) => element.constructor.name.includes(s))) ||
+  (isNode(element) &&
+    ['SVG', 'Image', 'Video', 'Canvas'].some(s => element.constructor.name.includes(s))) ||
   false;
 
 export default isMedia;

package/src/is/isNode.ts

@@ -1,11 +1,17 @@
+import isObject from './isObject';
+
+type NodeObject = object & { nodeType: number };
+
 /**
  * Checks if an object is a `Node`.
  *
  * @param node the target object
  * @returns the query result
  */
-
-const isNode = (node?: any): node is Node =>
-  (node && [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].some((x) => node.nodeType === x)) || false;
+const isNode = (node?: unknown): node is Node =>
+  (isObject(node) &&
+    typeof (node as NodeObject).nodeType === 'number' &&
+    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].some(x => (node as NodeObject).nodeType === x)) ||
+  false;
 
 export default isNode;

package/src/is/isNodeList.ts

@@ -1,3 +1,5 @@
+import isObject from './isObject';
+
 /**
  * Checks if an object is a `NodeList`.
  * => equivalent to `object instanceof NodeList`
@@ -5,7 +7,7 @@
  * @param obj the target object
  * @returns the query result
  */
-const isNodeList = (obj?: any): obj is NodeList =>
-  (obj && obj.constructor.name === "NodeList") || false;
+const isNodeList = (obj?: unknown): obj is NodeList =>
+  (isObject(obj) && obj.constructor.name === 'NodeList') || false;
 
 export default isNodeList;

package/src/is/isNumber.ts

@@ -4,6 +4,6 @@
  * @param num input value
  * @returns the query result
  */
-const isNumber = (num?: any): num is number => typeof num === "number" || false;
+const isNumber = (num?: unknown): num is number => typeof num === 'number' || false;
 
 export default isNumber;

package/src/is/isObject.ts

@@ -4,6 +4,7 @@
  * @param obj the target object
  * @returns the query result
  */
-const isObject = (obj?: any): obj is object => typeof obj === "object" || false;
+const isObject = (obj?: unknown): obj is object =>
+  (obj !== null && obj !== undefined && typeof obj === 'object') || false;
 
 export default isObject;

package/src/is/isRTL.ts

@@ -1,10 +1,11 @@
-import getDocumentElement from "../get/getDocumentElement";
+import getDocumentElement from '../get/getDocumentElement';
 
 /**
  * Checks if a page is Right To Left.
+ *
  * @param node the target
  * @returns the query result
  */
-const isRTL = (node?: Node): boolean => getDocumentElement(node).dir === "rtl";
+const isRTL = (node?: Node): boolean => getDocumentElement(node).dir === 'rtl';
 
 export default isRTL;

package/src/is/isSVGElement.ts

@@ -1,3 +1,5 @@
+import isNode from './isNode';
+
 /**
  * Check if an element is an `<svg>` or any other SVG element,
  * an equivalent to `SOMETHING instanceof SVGElement`.
@@ -5,7 +7,7 @@
  * @param element the target element
  * @returns the query result
  */
-const isSVGElement = (element?: any): element is SVGElement =>
-  (element && element.constructor.name.includes("SVG")) || false;
+const isSVGElement = (element?: unknown): element is SVGElement =>
+  (isNode(element) && element.constructor.name.includes('SVG')) || false;
 
 export default isSVGElement;

package/src/is/isScaledElement.ts

@@ -1,16 +1,19 @@
-import isHTMLElement from "./isHTMLElement";
-import getBoundingClientRect from "../get/getBoundingClientRect";
+import isHTMLElement from './isHTMLElement';
+import getBoundingClientRect from '../get/getBoundingClientRect';
 
 /**
  * Checks if a target `HTMLElement` is affected by scale.
+ *
  * @see https://github.com/floating-ui/floating-ui
  *
  * @param element target
  * @returns the query result
  */
-export default function isScaledElement(element?: HTMLElement): boolean {
+const isScaledElement = (element?: HTMLElement): boolean => {
   if (!isHTMLElement(element)) return false;
   const { width, height } = getBoundingClientRect(element);
   const { offsetWidth, offsetHeight } = element;
   return Math.round(width) !== offsetWidth || Math.round(height) !== offsetHeight;
-}
+};
+
+export default isScaledElement;