@thednp/shorty 2.0.0-alpha4 → 2.0.0-alpha6

package/src/is/isJSON.ts

@@ -6,7 +6,7 @@ import isString from './isString';
  * @param str the target string
  * @returns the query result
  */
-const isJSON = (str?: any): boolean => {
+const isJSON = (str?: string): boolean => {
   if (!isString(str)) return false;
 
   try {

package/src/is/isMap.ts

@@ -1,8 +1,11 @@
+import isObject from './isObject';
+
 /**
  * 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;
+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,16 +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 is SVGElement | HTMLImageElement | HTMLVideoElement | HTMLCanvasElement =>
-  (element &&
-    element.nodeType === 1 &&
-    ['SVG', 'Image', 'Video', 'Canvas'].some((s) => element.constructor.name.includes(s))) ||
+const isMedia = (
+  element?: unknown,
+): element is SVGElement | HTMLImageElement | HTMLVideoElement | HTMLCanvasElement =>
+  (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,6 +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

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

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

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

@@ -1,10 +1,12 @@
+import isNode from './isNode';
+
 /**
  * Check if target is a `ShadowRoot`.
  *
  * @param element target
  * @returns the query result
  */
-const isShadowRoot = (element?: any): element is ShadowRoot =>
-  (element && element.constructor.name === 'ShadowRoot') || false;
+const isShadowRoot = (element?: unknown): element is ShadowRoot =>
+  (isNode(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?: unknown): str is string => typeof str === 'string' || false;
 
 export default isString;

package/src/is/isTableElement.ts

@@ -1,3 +1,5 @@
+import isNode from './isNode';
+
 /**
  * Check if a target element is a `<table>`, `<td>` or `<th>`.
  * This specific check is important for determining
@@ -6,7 +8,7 @@
  * @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?: unknown): element is HTMLTableElement | HTMLTableCellElement =>
+  (isNode(element) && ['TABLE', 'TD', 'TH'].includes(element.nodeName)) || false;
 
 export default isTableElement;

package/src/is/isWeakMap.ts

@@ -1,8 +1,11 @@
+import isObject from './isObject';
+
 /**
  * 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;
+const isWeakMap = (obj?: unknown): obj is WeakMap<any, any> =>
+  (isObject(obj) && obj.constructor.name === 'WeakMap') || false;
 export default isWeakMap;

package/src/is/isWindow.ts

@@ -1,3 +1,5 @@
+import isObject from './isObject';
+
 /**
  * Check if a target object is `Window`.
  * => equivalent to `object instanceof Window`
@@ -5,6 +7,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?: unknown): obj is Window =>
+  (isObject(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,30 @@ 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 => {
   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 | Partial<HTMLElement>,
+): 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,18 +1,16 @@
 import isHTMLElement from '../is/isHTMLElement';
 
-type ComponentData = Record<string, any>;
-type ElementComponentMap = Map<HTMLElement, ComponentData>;
-type ComponentDataMap = Map<string, ElementComponentMap>;
-
-const componentData: ComponentDataMap = new Map();
+const componentData = new Map<string, Map<HTMLElement, 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
@@ -22,46 +20,54 @@ const Data = {
 
     /* istanbul ignore else */
     if (!componentData.has(component)) {
-      componentData.set(component, new Map());
+      componentData.set(component, new Map<HTMLElement, T>());
     }
 
-    const instanceMap = componentData.get(component);
+    const instanceMap = componentData.get(component) as Map<HTMLElement, 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>(component: string): Map<HTMLElement, T> | null => {
+    const instanceMap = componentData.get(component) as Map<HTMLElement, 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 => {
     if (!isHTMLElement(element) || !component) return null;
-    const instanceMap = Data.getAllFor(component);
+    const instanceMap = Data.getAllFor<T>(component);
+    // const instanceMap = componentData.get(component) as Map<HTMLElement, InstanceType<T>>;
+
     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>(element: HTMLElement, component: string): void => {
+    const instanceMap = Data.getAllFor<T>(component);
+    // const instanceMap = componentData.get(component) as Map<HTMLElement, InstanceType<T>>;
+
     if (!instanceMap || !isHTMLElement(element)) return;
 
     instanceMap.delete(element);
@@ -76,6 +82,7 @@ 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>(target: HTMLElement, component: string): T | null =>
+  Data.get(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/hasOwn.ts

@@ -0,0 +1,17 @@
+import isObject from '../is/isObject';
+
+/**
+ * A shortcut to `Object.hasOwn()` static method to work
+ * with regular `Object` elements.
+ *
+ * @see https://fettblog.eu/typescript-hasownproperty/
+ * @param obj the target object
+ * @param prop the property to check
+ * @returns the query result
+ */
+const hasOwn = <T extends object, K extends PropertyKey>(
+  obj: T,
+  prop: K,
+): obj is T & Record<K, unknown> => isObject(obj) && (Object.hasOwn(obj, prop) || prop in obj);
+
+export default hasOwn;

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;