@thednp/shorty 2.0.0-alpha4 → 2.0.0-alpha5

package/src/is/isObject.ts

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

package/src/is/isRTL.ts

@@ -2,6 +2,7 @@ import getDocumentElement from '../get/getDocumentElement';
 
 /**
  * Checks if a page is Right To Left.
+ *
  * @param node the target
  * @returns the query result
  */

package/src/is/isSVGElement.ts

@@ -5,7 +5,7 @@
  * @param element the target element
  * @returns the query result
  */
-const isSVGElement = (element?: any): element is SVGElement =>
+const isSVGElement = (element?: SVGElement): element is SVGElement =>
   (element && element.constructor.name.includes('SVG')) || false;
 
 export default isSVGElement;

package/src/is/isScaledElement.ts

@@ -3,14 +3,17 @@ 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;

package/src/is/isShadowRoot.ts

@@ -4,7 +4,7 @@
  * @param element target
  * @returns the query result
  */
-const isShadowRoot = (element?: any): element is ShadowRoot =>
+const isShadowRoot = (element?: Node | ShadowRoot): element is ShadowRoot =>
   (element && element.constructor.name === 'ShadowRoot') || false;
 
 export default isShadowRoot;

package/src/is/isString.ts

@@ -4,6 +4,6 @@
  * @param str input value
  * @returns the query result
  */
-const isString = (str?: any): str is string => typeof str === 'string' || false;
+const isString = (str?: string): str is string => typeof str === 'string' || false;
 
 export default isString;

package/src/is/isTableElement.ts

@@ -6,7 +6,9 @@
  * @param element the target element
  * @returns the query result
  */
-const isTableElement = (element?: any): element is HTMLTableElement | HTMLTableCellElement =>
+const isTableElement = (
+  element?: HTMLTableElement | HTMLTableCellElement,
+): element is HTMLTableElement | HTMLTableCellElement =>
   (element && ['TABLE', 'TD', 'TH'].includes(element.tagName)) || false;
 
 export default isTableElement;

package/src/is/isWeakMap.ts

@@ -4,5 +4,6 @@
  * @param obj the target object
  * @returns the query result
  */
-const isWeakMap = (obj?: any): obj is WeakMap<any, any> => (obj && obj.constructor.name === 'WeakMap') || false;
+const isWeakMap = <T extends WeakMap<any, unknown>>(obj?: T): obj is T =>
+  (obj && obj.constructor.name === 'WeakMap') || false;
 export default isWeakMap;

package/src/is/isWindow.ts

@@ -5,6 +5,7 @@
  * @param obj the target object
  * @returns the query result
  */
-const isWindow = (obj?: any): obj is Window => (obj && obj.constructor.name === 'Window') || false;
+const isWindow = (obj?: Node | Window): obj is Window =>
+  (obj && obj.constructor.name === 'Window') || false;
 
 export default isWindow;

package/src/misc/Float32ArrayFrom.ts

@@ -1,5 +1,6 @@
 /**
  * Shortcut for `Float32Array.from()` static method.
+ *
  * @param arr array-like iterable object
  * @returns a new Float32Array
  */

package/src/misc/Float64ArrayFrom.ts

@@ -1,5 +1,6 @@
 /**
  * Shortcut for `Float64Array.from()` static method.
+ *
  * @param arr array-like iterable object
  * @returns a new Float64Array
  */

package/src/misc/ObjectAssign.ts

@@ -1,11 +1,43 @@
+/**
+ * Overloads for Object.assign.
+ *
+ * @see https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/object-assign/index.d.ts
+ */
+declare function ObjectAssignTyped<T, U>(target: T, source: U): T & U;
+declare function ObjectAssignTyped<T, U, V>(target: T, source1: U, source2: V): T & U & V;
+declare function ObjectAssignTyped<T, U, V, W>(
+  target: T,
+  source1: U,
+  source2: V,
+  source3: W,
+): T & U & V & W;
+declare function ObjectAssignTyped<T, U, V, W, Q>(
+  target: T,
+  source1: U,
+  source2: V,
+  source3: W,
+  source4: Q,
+): T & U & V & W & Q;
+declare function ObjectAssignTyped<T, U, V, W, Q, R>(
+  target: T,
+  source1: U,
+  source2: V,
+  source3: W,
+  source4: Q,
+  source5: R,
+): T & U & V & W & Q & R;
+declare function ObjectAssignTyped(target: any, ...sources: any[]): any;
+
 /**
  * Shortcut for `Object.assign()` static method.
+ *
  * @param obj a target object
  * @param source source object(s)
  * @see https://github.com/devinrhode2/ObjectTyped/blob/master/src/index.ts
  */
-
-const ObjectAssign = <A extends {}, B>(obj: A, ...source: B[]): B extends any[] ? any : A & B =>
-  Object.assign(obj, ...source);
+const ObjectAssign: typeof ObjectAssignTyped = <A extends Record<string, any>, B>(
+  obj: A,
+  ...source: B[]
+): B extends Record<string, any>[] ? any : A & B => Object.assign(obj, ...source);
 
 export default ObjectAssign;

package/src/misc/ObjectEntries.ts

@@ -1,9 +1,11 @@
 /**
  * Shortcut for `Object.entries()` static method.
+ *
  * @param obj a target object
  * @returns the entries of an object in an array format [key, value][]
  * @see https://github.com/devinrhode2/ObjectTyped/blob/master/src/index.ts
  */
-const ObjectEntries = <O extends {}>(obj: O) => Object.entries(obj) as [keyof O, O[keyof O]][];
+const ObjectEntries = <O extends Record<string, any>>(obj: O) =>
+  Object.entries(obj) as [keyof O, O[keyof O]][];
 
 export default ObjectEntries;

package/src/misc/ObjectKeys.ts

@@ -1,9 +1,10 @@
 /**
  * Shortcut for `Object.keys()` static method.
+ *
  * @param obj a target object
  * @returns an array with object keys
  * @see https://github.com/devinrhode2/ObjectTyped/blob/master/src/index.ts
  */
-const ObjectKeys = <O extends {}>(obj: O) => Object.keys(obj) as (keyof O)[];
+const ObjectKeys = <O extends Record<string, any>>(obj: O) => Object.keys(obj) as (keyof O)[];
 
 export default ObjectKeys;

package/src/misc/ObjectValues.ts

@@ -1,9 +1,11 @@
 /**
  * Shortcut for `Object.values()` static method.
+ *
  * @param obj a target object
  * @returns an array with the object values
  * @see https://github.com/devinrhode2/ObjectTyped/blob/master/src/index.ts
  */
-const ObjectValues = <O extends {}>(obj: O) => Object.values(obj) as (O[keyof O])[];
+const ObjectValues = <O extends Record<string, unknown>>(obj: O): O[keyof O][] =>
+  Object.values(obj) as O[keyof O][];
 
 export default ObjectValues;

package/src/misc/{OriginalEvent.ts → createCustomEvent.ts}

@@ -4,15 +4,19 @@ import ObjectAssign from './ObjectAssign';
 
 /**
  * Returns a namespaced `CustomEvent` specific to each component.
- * @param EventType Event.type
+ *
+ * @param eventType Event.type
  * @param config Event.options | Event.properties
  * @returns a new namespaced event
  */
-const OriginalEvent = <T>(EventType: string, config?: CustomEventInit<T>): OriginalEvent<T> => {
-  const OriginalCustomEvent = new CustomEvent<T>(EventType, {
+const createCustomEvent = <T extends OriginalEvent>(
+  eventType: string,
+  config?: CustomEventInit<any>,
+): T => {
+  const OriginalCustomEvent = new CustomEvent<any>(eventType, {
     cancelable: true,
     bubbles: true,
-  } as CustomEventInit<T>);
+  } as CustomEventInit<any>) as T;
 
   /* istanbul ignore else */
   if (isObject(config)) {
@@ -21,4 +25,4 @@ const OriginalEvent = <T>(EventType: string, config?: CustomEventInit<T>): Origi
   return OriginalCustomEvent;
 };
 
-export default OriginalEvent;
+export default createCustomEvent;

package/src/misc/createElement.ts

@@ -8,29 +8,32 @@ import ObjectEntries from './ObjectEntries';
  * which allows you to create a new `HTMLElement` for a given `tagName`
  * or based on an object with specific non-readonly attributes with string values:
  * `id`, `className`, `textContent`, `style`, etc.
+ *
  * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/createElement
  *
  * @param param `tagName` or object
- * @return a new `HTMLElement` or `Element`
+ * @return a new `HTMLElement`
  */
-const createElement = (param?: string | Partial<HTMLElement>): HTMLElement | undefined => {
+const createElement = (
+  param?: string | Exclude<HTMLElement, ((...args: any[]) => any) | object>,
+): HTMLElement | undefined => {
   if (!param) return undefined;
 
-  if (typeof param === 'string') {
+  if (isString(param)) {
     return getDocument().createElement(param);
   }
 
   const { tagName } = param;
-  const newElement = createElement(tagName);
+  const newElement = createElement(tagName as string);
 
   if (!newElement) return undefined;
 
-  const attr = { ...param };
+  const attr = { ...(param as Record<string, unknown>) };
   delete attr.tagName;
 
   ObjectEntries(attr).forEach(([key, value]) => {
-    if (isString(value)) {
-      setAttribute(newElement, key, value);
+    if (isString(key as string) && isString(value as string)) {
+      setAttribute(newElement, key as string, value as string);
     }
   });
   return newElement;

package/src/misc/createElementNS.ts

@@ -8,16 +8,20 @@ import isString from '../is/isString';
  * which allows you to create a new `HTMLElement` for a given `tagName`
  * or based on an object with specific non-readonly attributes with string values:
  * `id`, `className`, `textContent`, `style`, etc.
+ *
  * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/createElementNS
  *
  * @param ns `namespaceURI` to associate with the new `HTMLElement`
  * @param param `tagName` or object
  * @return a new `HTMLElement`
  */
-const createElementNS = (ns: string, param?: string | Partial<HTMLElement>): HTMLElement | undefined => {
+const createElementNS = (
+  ns: string,
+  param?: string | Exclude<HTMLElement, ((...args: any[]) => any) | object>,
+): HTMLElement | undefined => {
   if (!ns || !param) return undefined;
 
-  if (typeof param === 'string') {
+  if (isString(param)) {
     return getDocument().createElementNS(ns, param) as HTMLElement;
   }
 
@@ -26,12 +30,12 @@ const createElementNS = (ns: string, param?: string | Partial<HTMLElement>): HTM
 
   if (!newElement) return undefined;
 
-  const attr = { ...param };
+  const attr = { ...(param as Record<string, unknown>) };
   delete attr.tagName;
 
   ObjectEntries(attr).forEach(([key, value]) => {
-    if (isString(value)) {
-      setAttribute(newElement, key, value);
+    if (isString(key as string) && isString(value as string)) {
+      setAttribute(newElement, key as string, value as string);
     }
   });
 

package/src/misc/data.ts

@@ -1,67 +1,79 @@
 import isHTMLElement from '../is/isHTMLElement';
 
-type ComponentData = Record<string, any>;
-type ElementComponentMap = Map<HTMLElement, ComponentData>;
-type ComponentDataMap = Map<string, ElementComponentMap>;
+type MConstructor<T extends new (...args: any[]) => any> = new (
+  ...args: ConstructorParameters<T>
+) => InstanceType<T>;
 
-const componentData: ComponentDataMap = new Map();
+const componentData = new Map<MConstructor<any>, Map<HTMLElement, InstanceType<any>>>();
 
 /**
  * An interface for web components background data.
+ *
  * @see https://github.com/thednp/bootstrap.native/blob/master/src/components/base-component.js
  */
 const Data = {
   /**
    * Sets web components data.
+   *
    * @param element target element
    * @param component the component's name or a unique key
    * @param instance the component instance
    */
-  set: <T>(element: HTMLElement, component: string, instance: T): void => {
+  set: <T extends MConstructor<T>>(
+    element: HTMLElement,
+    component: T,
+    instance: InstanceType<T>,
+  ): void => {
     if (!isHTMLElement(element)) return;
 
     /* istanbul ignore else */
     if (!componentData.has(component)) {
-      componentData.set(component, new Map());
+      componentData.set(component, new Map<HTMLElement, InstanceType<T>>());
     }
 
-    const instanceMap = componentData.get(component);
+    const instanceMap = componentData.get(component) as Map<HTMLElement, InstanceType<T>>;
     // not undefined, but defined right above
-    (instanceMap as ElementComponentMap).set(element, instance);
+    instanceMap.set(element, instance);
   },
 
   /**
    * Returns all instances for specified component.
+   *
    * @param component the component's name or a unique key
    * @returns all the component instances
    */
-  getAllFor: (component: string): ElementComponentMap | null => {
-    const instanceMap = componentData.get(component);
+  getAllFor: <T extends MConstructor<T>>(
+    component: T,
+  ): Map<HTMLElement, InstanceType<T>> | null => {
+    const instanceMap = componentData.get(component) as Map<HTMLElement, InstanceType<T>>;
 
     return instanceMap || null;
   },
 
   /**
    * Returns the instance associated with the target.
+   *
    * @param element target element
    * @param component the component's name or a unique key
    * @returns the instance
    */
-  get: <T>(element: HTMLElement, component: string): T | null => {
+  get: <T extends MConstructor<T>>(element: HTMLElement, component: T): InstanceType<T> | null => {
     if (!isHTMLElement(element) || !component) return null;
-    const instanceMap = Data.getAllFor(component);
+    const instanceMap = Data.getAllFor<T>(component);
     const instance = element && instanceMap && instanceMap.get(element);
 
-    return (instance as T) || null;
+    // return (instance as T) || null;
+    return instance || null;
   },
 
   /**
    * Removes web components data.
+   *
    * @param element target element
    * @param component the component's name or a unique key
    */
-  remove: (element: HTMLElement, component: string): void => {
-    const instanceMap = Data.getAllFor(component);
+  remove: <T extends MConstructor<T>>(element: HTMLElement, component: T): void => {
+    const instanceMap = Data.getAllFor<T>(component);
     if (!instanceMap || !isHTMLElement(element)) return;
 
     instanceMap.delete(element);
@@ -76,6 +88,9 @@ const Data = {
 /**
  * An alias for `Data.get()`.
  */
-export const getInstance = <T>(target: HTMLElement, component: string): T | null => Data.get<T>(target, component);
+export const getInstance = <T extends MConstructor<T>>(
+  target: HTMLElement,
+  component: T,
+): InstanceType<T> | null => Data.get<T>(target, component);
 
 export default Data;

package/src/misc/distinct.ts

@@ -1,5 +1,6 @@
 /**
  * JavaScript `Array` distinct.
+ *
  * @see https://codeburst.io/javascript-array-distinct-5edc93501dc4
  *
  * @example

package/src/misc/normalizeValue.ts

@@ -1,28 +1,30 @@
+type NormalValue = boolean | number | string | ((...args: any[]) => any) | null;
+
 /**
  * Utility to normalize component options
  *
  * @param value the input value
  * @return the normalized value
  */
-const normalizeValue = (value?: any): any => {
-  if (['true', true].includes(value)) {
+const normalizeValue = (value?: boolean | number | string): NormalValue => {
+  if (['true', true].includes(value as boolean)) {
     return true;
   }
 
-  if (['false', false].includes(value)) {
+  if (['false', false].includes(value as boolean)) {
     return false;
   }
 
-  if (['null', '', null].includes(value)) {
+  if (['null', '', null, undefined].includes(value as string | undefined)) {
     return null;
   }
 
-  if (value !== '' && !Number.isNaN(+value)) {
-    return +value;
+  if (value !== '' && !Number.isNaN(+(value as string))) {
+    return +(value as string);
   }
 
   // string / function / HTMLElement / object / undefined
-  return value;
+  return value as NormalValue;
 };
 
 export default normalizeValue;

package/src/misc/setElementStyle.ts

@@ -5,13 +5,14 @@ import isString from '../is/isString';
 
 /**
  * Shortcut for multiple uses of `HTMLElement.style.propertyName` method.
+ *
  * @param element target element
  * @param styles attribute value
  */
 const setElementStyle = (element: HTMLElement, styles: Partial<CSS4Declaration>): void => {
   ObjectEntries(styles).forEach(([key, value]) => {
-    if (value && isString(key) && key.includes('--')) {
-      element.style.setProperty(key, value);
+    if (value && isString(key as string) && (key as string).includes('--')) {
+      element.style.setProperty(key as string, value);
     } else {
       const propObject: Partial<CSS4Declaration> = {};
       propObject[key] = value;

package/src/misc/timer.ts

@@ -5,14 +5,16 @@ import isNumber from '../is/isNumber';
 type KeyMap = Map<string, number>;
 type TimeMap = Map<HTMLElement, number | KeyMap>;
 
-const TimeCache: TimeMap = new Map();
+const TimeCache: TimeMap = new Map() as TimeMap;
 /**
  * An interface for one or more `TimerHandler`s per `Element`.
+ *
  * @see https://github.com/thednp/navbar/
  */
 const Timer = {
   /**
    * Sets a new timeout timer for an element, or element -> key association.
+   *
    * @param element target element
    * @param callback the callback
    * @param delay the execution delay
@@ -27,14 +29,17 @@ const Timer = {
       if (!TimeCache.has(element)) {
         TimeCache.set(element, new Map());
       }
+      // eslint-disable-next-line @typescript-eslint/no-implied-eval
       (TimeCache.get(element) as KeyMap).set(key, setTimeout(callback, delay));
     } else {
+      // eslint-disable-next-line @typescript-eslint/no-implied-eval
       TimeCache.set(element, setTimeout(callback, delay));
     }
   },
 
   /**
    * Returns the timer associated with the target.
+   *
    * @param element target element
    * @param key a unique
    * @returns the timer
@@ -43,16 +48,17 @@ const Timer = {
     if (!isHTMLElement(element)) return null;
     const keyTimers = TimeCache.get(element);
 
-    if (key && isMap(keyTimers)) {
-      return keyTimers.get(key) || /* istanbul ignore next */ null;
-    } else if (isNumber(keyTimers)) {
-      return keyTimers;
+    if (key && keyTimers && isMap(keyTimers as KeyMap)) {
+      return (keyTimers as KeyMap).get(key) || /* istanbul ignore next */ null;
+    } else if (isNumber(keyTimers as number)) {
+      return keyTimers as number;
     }
     return null;
   },
 
   /**
    * Clears the element's timer.
+   *
    * @param element target element
    * @param key a unique key
    */
@@ -61,15 +67,12 @@ const Timer = {
 
     const keyTimers = TimeCache.get(element);
 
-    if (key && key.length && isMap(keyTimers)) {
+    if (key && key.length && isMap(keyTimers as KeyMap)) {
+      clearTimeout((keyTimers as KeyMap).get(key));
+      (keyTimers as KeyMap).delete(key);
       /* istanbul ignore else */
-      if (isMap(keyTimers)) {
-        clearTimeout(keyTimers.get(key));
-        keyTimers.delete(key);
-        /* istanbul ignore else */
-        if (keyTimers.size === 0) {
-          TimeCache.delete(element);
-        }
+      if ((keyTimers as KeyMap).size === 0) {
+        TimeCache.delete(element);
       }
     } else {
       clearTimeout(keyTimers as number);

package/src/selectors/getCustomElements.ts

@@ -5,6 +5,7 @@ import getElementsByTagName from './getElementsByTagName';
 /**
  * Returns an `Array` of `Node` elements that are registered as
  * `CustomElement`.
+ *
  * @see https://stackoverflow.com/questions/27334365/how-to-get-list-of-registered-custom-elements
  *
  * @param parent parent to look into

package/src/selectors/getElementsByClassName.ts

@@ -9,9 +9,14 @@ import isNode from '../is/isNode';
  * @param parent optional Element to look into
  * @return the 'HTMLCollection'
  */
-const getElementsByClassName = (selector: string, parent?: ParentNode): HTMLCollectionOf<HTMLElement> => {
+const getElementsByClassName = (
+  selector: string,
+  parent?: ParentNode,
+): HTMLCollectionOf<HTMLElement> => {
   const lookUp = parent && isNode(parent) ? parent : getDocument();
-  return (lookUp as HTMLElement | Document).getElementsByClassName(selector) as HTMLCollectionOf<HTMLElement>;
+  return (lookUp as HTMLElement | Document).getElementsByClassName(
+    selector,
+  ) as HTMLCollectionOf<HTMLElement>;
 };
 
 export default getElementsByClassName;

package/src/selectors/getElementsByTagName.ts

@@ -9,7 +9,10 @@ import isNode from '../is/isNode';
  * @param parent optional Element to look into
  * @return the 'HTMLCollection'
  */
-const getElementsByTagName = (selector: string, parent?: ParentNode): HTMLCollectionOf<HTMLElement> => {
+const getElementsByTagName = (
+  selector: string,
+  parent?: ParentNode,
+): HTMLCollectionOf<HTMLElement> => {
   const lookUp = isNode(parent) ? parent : getDocument();
   return (lookUp as Document).getElementsByTagName(selector) as HTMLCollectionOf<HTMLElement>;
 };

package/src/selectors/querySelector.ts

@@ -10,12 +10,12 @@ import isNode from '../is/isNode';
  * @return the `HTMLElement` or `querySelector` result
  */
 const querySelector = (selector: Node | string, parent?: ParentNode): HTMLElement | null => {
-  if (isNode(selector)) {
+  if (isNode(selector as Node)) {
     return selector as HTMLElement;
   }
   const lookUp = parent && isNode(parent) ? parent : getDocument();
 
-  return lookUp.querySelector(selector);
+  return lookUp.querySelector(selector as string);
 };
 
 export default querySelector;

package/src/strings/mouseHoverEvents.ts

@@ -2,5 +2,7 @@
  * A global namespace for mouse hover events.
  */
 const mouseHoverEvents =
-  'onmouseleave' in document ? ['mouseenter', 'mouseleave'] : /* istanbul ignore next */ ['mouseover', 'mouseout'];
+  'onmouseleave' in document
+    ? ['mouseenter', 'mouseleave']
+    : /* istanbul ignore next */ ['mouseover', 'mouseout'];
 export default mouseHoverEvents;