@thednp/shorty 2.0.0-alpha2 → 2.0.0-alpha5

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,9 @@
-/**
- * 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;
+/**
+ * Checks if an element is a `Map`.
+ *
+ * @param obj the target object
+ * @returns the query result
+ */
+const isMap = <T extends Map<any, any>>(obj?: T): obj is T =>
+  (obj && obj.constructor.name === 'Map') || false;
+export default isMap;

package/src/is/isMedia.ts

@@ -3,16 +3,17 @@
  * `<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?: SVGElement | HTMLImageElement | HTMLVideoElement | HTMLCanvasElement,
 ): element is SVGElement | HTMLImageElement | HTMLVideoElement | HTMLCanvasElement =>
   (element &&
     element.nodeType === 1 &&
-    ["SVG", "Image", "Video", "Canvas"].some((s) => element.constructor.name.includes(s))) ||
+    ['SVG', 'Image', 'Video', 'Canvas'].some(s => element.constructor.name.includes(s))) ||
   false;
 
 export default isMedia;

package/src/is/isNode.ts

@@ -5,7 +5,7 @@
  * @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?: Node): node is Node =>
+  (node && [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].some(x => node.nodeType === x)) || false;
 
 export default isNode;

package/src/is/isNodeList.ts

@@ -5,7 +5,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?: NodeList): obj is NodeList =>
+  (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?: number): num is number => typeof num === 'number' || false;
 
 export default isNumber;

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

@@ -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

@@ -5,7 +5,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?: SVGElement): element is SVGElement =>
+  (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;

package/src/is/isShadowRoot.ts

@@ -4,7 +4,7 @@
  * @param element target
  * @returns the query result
  */
-const isShadowRoot = (element?: any): element is ShadowRoot =>
-  (element && element.constructor.name === "ShadowRoot") || false;
+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 =>
-  (element && ["TABLE", "TD", "TH"].includes(element.tagName)) || false;
+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

@@ -1,9 +1,9 @@
-/**
- * Checks if an element is a `WeakMap`.
- *
- * @param obj the target object
- * @returns the query result
- */
-const isWeakMap = (obj?: any): obj is WeakMap<any, any> =>
-  (obj && obj.constructor.name === 'WeakMap') || false;
-export default isWeakMap;
+/**
+ * Checks if an element is a `WeakMap`.
+ *
+ * @param obj the target object
+ * @returns the query result
+ */
+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,8 +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 Array<[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,8 +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 = (obj: Record<string, any>): string[] => Object.keys(obj);
+const ObjectKeys = <O extends Record<string, any>>(obj: O) => Object.keys(obj) as (keyof O)[];
 
 export default ObjectKeys;

package/src/misc/ObjectValues.ts

@@ -1,8 +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): Array<[O[keyof O]]> => Object.values(obj);
+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}

@@ -1,18 +1,22 @@
-import OriginalEvent from '../interface/originalEvent';
+import { OriginalEvent } from '../interface/originalEvent';
 import isObject from '../is/isObject';
 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,6 +8,7 @@ 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`
@@ -15,26 +16,26 @@ import isString from '../is/isString';
  * @return a new `HTMLElement`
  */
 const createElementNS = (
-  ns?: string,
-  param?: string | Partial<HTMLElement>
+  ns: string,
+  param?: string | Exclude<HTMLElement, ((...args: any[]) => any) | object>,
 ): HTMLElement | undefined => {
-  if (!ns && !param) return undefined;
+  if (!ns || !param) return undefined;
 
-  if (typeof param === 'string') {
+  if (isString(param)) {
     return getDocument().createElementNS(ns, param) as HTMLElement;
   }
 
   const { tagName } = param;
-  const newElement = createElementNS(ns, tagName as string);
+  const newElement = createElementNS(ns, tagName);
 
   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 extends ComponentData>(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.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: (element: HTMLElement, component: string): ComponentData | 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 || null;
   },
 
   /**
    * Removes web components data.
+   *
    * @param element target element
    * @param component the component's name or a unique key
    */
-  remove: <S extends string, E extends HTMLElement>(element: E, component: S): 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 = (target: HTMLElement, component: string) => Data.get(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/emulateAnimationEnd.ts

@@ -1,7 +1,7 @@
-import animationEndEvent from "../strings/animationEndEvent";
-import getElementAnimationDelay from "../get/getElementAnimationDelay";
-import getElementAnimationDuration from "../get/getElementAnimationDuration";
-import dispatchEvent from "./dispatchEvent";
+import animationEndEvent from '../strings/animationEndEvent';
+import getElementAnimationDelay from '../get/getElementAnimationDelay';
+import getElementAnimationDuration from '../get/getElementAnimationDuration';
+import dispatchEvent from './dispatchEvent';
 
 /**
  * Utility to make sure callbacks are consistently

package/src/misc/emulateTransitionEnd.ts

@@ -1,7 +1,7 @@
-import transitionEndEvent from "../strings/transitionEndEvent";
-import getElementTransitionDelay from "../get/getElementTransitionDelay";
-import getElementTransitionDuration from "../get/getElementTransitionDuration";
-import dispatchEvent from "./dispatchEvent";
+import transitionEndEvent from '../strings/transitionEndEvent';
+import getElementTransitionDelay from '../get/getElementTransitionDelay';
+import getElementTransitionDuration from '../get/getElementTransitionDuration';
+import dispatchEvent from './dispatchEvent';
 
 /**
  * Utility to make sure callbacks are consistently

package/src/misc/noop.ts

@@ -1,4 +1,6 @@
 /** A generic function with empty body. */
-const noop = () => {};
+const noop = () => {
+  // this is a noop
+};
 
 export default noop;

package/src/misc/normalizeOptions.ts

@@ -2,7 +2,7 @@ import getAttribute from '../attr/getAttribute';
 import normalizeValue from './normalizeValue';
 import ObjectEntries from './ObjectEntries';
 import toLowerCase from './toLowerCase';
-import { optionValues } from '../types';
+// import { optionValues } from '../types';
 
 /**
  * Utility to normalize component options.
@@ -13,14 +13,14 @@ import { optionValues } from '../types';
  * @param ns component namespace
  * @return normalized component options object
  */
-const normalizeOptions = <T extends { [key: string]: optionValues }>(
+const normalizeOptions = <T extends { [key: string]: any }>(
   element: HTMLElement,
   defaultOps: T,
   inputOps: Partial<T>,
-  ns?: string
+  ns?: string,
 ): T => {
   const INPUT = { ...inputOps };
-  const data = { ...element.dataset } as Partial<T> & { [key: string]: any };
+  const data = { ...element.dataset };
   const normalOps = { ...defaultOps };
   const dataOps: Partial<T> = {};
   const title = 'title';
@@ -41,9 +41,9 @@ const normalizeOptions = <T extends { [key: string]: optionValues }>(
   ObjectEntries(defaultOps).forEach(([k, v]) => {
     /* istanbul ignore else */
     if (k in INPUT) {
-      normalOps[k] = INPUT[k];
+      normalOps[k] = INPUT[k] as T[keyof T];
     } else if (k in dataOps) {
-      normalOps[k] = dataOps[k];
+      normalOps[k] = dataOps[k] as T[keyof T];
     } else {
       normalOps[k] = (k === title ? getAttribute(element, title) : v) as T[keyof T];
     }