@thednp/shorty 2.0.0-alpha2 → 2.0.0-alpha21

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,9 +1,11 @@
-/**
- * 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;
+import isObject from './isObject';
+
+/**
+ * Checks if an element is a `WeakMap`.
+ *
+ * @param obj the target object
+ * @returns the query result
+ */
+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,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/ObjectFromEntries.ts

@@ -0,0 +1,11 @@
+/**
+ * Shortcut for `Object.fromEntries()` static method.
+ *
+ * @param entries a target entries object
+ * @returns a new Object created from the specified entries in array format [key, value][]
+ * @see https://github.com/devinrhode2/ObjectTyped/blob/master/src/index.ts
+ */
+const ObjectFromEntries = <K extends string, V>(entries: [K, V][]) =>
+  Object.fromEntries(entries) as Record<K, V>;
+
+export default ObjectFromEntries;

package/src/misc/ObjectHasOwn.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 ObjectHasOwn = <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 ObjectHasOwn;

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 type { 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

@@ -1,39 +1,34 @@
 import isString from '../is/isString';
-import setAttribute from '../attr/setAttribute';
 import getDocument from '../get/getDocument';
-import ObjectEntries from './ObjectEntries';
+import ObjectAssign from './ObjectAssign';
 
 /**
  * Shortie for `document.createElement` method
  * 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 = <T extends HTMLElement>(param?: string | Partial<T>): T | undefined => {
   if (!param) return undefined;
 
-  if (typeof param === 'string') {
-    return getDocument().createElement(param);
+  if (isString(param)) {
+    return getDocument().createElement(param) as T;
   }
 
   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);
-    }
-  });
-  return newElement;
+  return ObjectAssign(newElement, attr) as unknown as T;
 };
 
 export default createElement;

package/src/misc/createElementNS.ts

@@ -1,6 +1,5 @@
 import getDocument from '../get/getDocument';
-import ObjectEntries from './ObjectEntries';
-import setAttribute from '../attr/setAttribute';
+import ObjectAssign from './ObjectAssign';
 import isString from '../is/isString';
 
 /**
@@ -8,37 +7,34 @@ 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.
+ * Note: some elements resulted from this function call may not be compatible with
+ * some attributes.
+ *
  * @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 => {
-  if (!ns && !param) return undefined;
-
-  if (typeof param === 'string') {
-    return getDocument().createElementNS(ns, param) as HTMLElement;
+const createElementNS = <T extends HTMLElement>(
+  ns: string,
+  param?: string | Partial<T>,
+): T | undefined => {
+  if (!ns || !param) return undefined;
+
+  if (isString(param)) {
+    return getDocument().createElementNS(ns, param) as T;
   }
 
   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);
-    }
-  });
-
-  return newElement;
+  return ObjectAssign(newElement, attr) as unknown as T;
 };
 
 export default createElementNS;

package/src/misc/data.ts

@@ -1,67 +1,74 @@
 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 = {
+  data: componentData,
   /**
    * 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>(element: HTMLElement, component: string, instance: T): void => {
     if (!isHTMLElement(element)) return;
 
     /* 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.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: (element: HTMLElement, component: string): ComponentData | null => {
+  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 || 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>(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);
@@ -73,9 +80,4 @@ const Data = {
   },
 };
 
-/**
- * An alias for `Data.get()`.
- */
-export const getInstance = (target: HTMLElement, component: string) => 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/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/getInstance.ts

@@ -0,0 +1,9 @@
+import Data from './data';
+
+/**
+ * An alias for `Data.get()`.
+ */
+const getInstance = <T>(target: HTMLElement, component: string): T | null =>
+  Data.get(target, component);
+
+export default getInstance;

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];
     }

package/src/misc/normalizeValue.ts

@@ -1,4 +1,4 @@
-import { optionValues } from '../types';
+type NormalValue = boolean | number | string | ((...args: any[]) => any) | null;
 
 /**
  * Utility to normalize component options
@@ -6,25 +6,25 @@ import { optionValues } from '../types';
  * @param value the input value
  * @return the normalized value
  */
-const normalizeValue = (value?: any): optionValues => {
-  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

@@ -1,16 +1,18 @@
 import ObjectAssign from './ObjectAssign';
 import ObjectEntries from './ObjectEntries';
-import CSS4Declaration from '../interface/css4Declaration';
+import isString from '../is/isString';
+import type { CSS4Declaration } from '../interface/css4Declaration';
 
 /**
  * Shortcut for multiple uses of `HTMLElement.style.propertyName` method.
+ *
  * @param element target element
  * @param styles attribute value
  */
-const setElementStyle = (element: HTMLElement, styles: CSS4Declaration): void => {
-  ObjectEntries(styles).forEach(([key, value]: [string, string]) => {
-    if (key.includes('--')) {
-      element.style.setProperty(key, value);
+const setElementStyle = (element: HTMLElement, styles: Partial<CSS4Declaration>): void => {
+  ObjectEntries(styles).forEach(([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;