tool-shack 0.0.9 → 0.0.13

package/src/dateTime/dateAsIso.ts

@@ -8,9 +8,15 @@ export const dateAsIso = (date: Date) => {
   const timezoneOffset = date.getTimezoneOffset();
 
   let isoFormat = '';
-  isoFormat += `${date.getFullYear()}-${padNumber(date.getMonth() + 1)}-${padNumber(date.getDate())}`;
-  isoFormat += `T${padNumber(date.getHours())}:${padNumber(date.getMinutes())}:${padNumber(date.getSeconds())}`;
-  isoFormat += `${timezoneOffset <= 0 ? '+' : '-'}${padNumber(Math.floor(Math.abs(timezoneOffset) / 60))}:${padNumber(Math.abs(timezoneOffset) % 60)}`;
+  isoFormat += `${date.getFullYear()}-${padNumber(date.getMonth() + 1)}-${padNumber(
+    date.getDate(),
+  )}`;
+  isoFormat += `T${padNumber(date.getHours())}:${padNumber(date.getMinutes())}:${padNumber(
+    date.getSeconds(),
+  )}`;
+  isoFormat += `${timezoneOffset <= 0 ? '+' : '-'}${padNumber(
+    Math.floor(Math.abs(timezoneOffset) / 60),
+  )}:${padNumber(Math.abs(timezoneOffset) % 60)}`;
 
   return isoFormat;
 };

package/src/dateTime/index.ts

@@ -1,4 +1,4 @@
-export * from './interfaces';
-
-export * from './dateAsIso';
-export * from './parseDuration';
+export * from './interfaces';
+
+export * from './dateAsIso';
+export * from './parseDuration';

package/src/dateTime/interfaces/index.ts

@@ -1 +1 @@
-export * from './parseDuration';
+export * from './parseDuration';

package/src/dateTime/interfaces/parseDuration.ts

@@ -1,7 +1,7 @@
-export interface IDuration {
-  days: number;
-  hours: number;
-  minutes: number;
-  seconds: number;
-  milliseconds: number;
-}
+export interface IDuration {
+  days: number;
+  hours: number;
+  minutes: number;
+  seconds: number;
+  milliseconds: number;
+}

package/src/dateTime/parseDuration.ts

@@ -16,4 +16,4 @@ export const parseDuration = (durationInMs: number): IDuration => {
     seconds: Math.floor(durationInMs / 1000) % 60,
     milliseconds: Math.floor(durationInMs) % 1000,
   };
-}
+};

package/src/dom/addAsyncEventListener.ts

@@ -9,24 +9,26 @@
 export const addAsyncEventListener = (
   elementSelector: string,
   listeners: Record<string, EventListener | EventListener[]>,
-  acceptBubbling = true
+  acceptBubbling = true,
 ): void => {
   for (let eventName in listeners) {
     const functionList = (
       listeners[eventName] instanceof Array ? listeners[eventName] : [listeners[eventName]]
     ) as EventListener[];
 
-    functionList.forEach((fn: EventListener) => document.addEventListener(eventName, (event: Event) => {
-      const target = event.target as HTMLElement;
-      if (!target) {
-        return;
-      }
+    functionList.forEach((fn: EventListener) =>
+      document.addEventListener(eventName, (event: Event) => {
+        const target = event.target as HTMLElement;
+        if (!target) {
+          return;
+        }
 
-      if (!acceptBubbling && target.matches(elementSelector)) {
-        fn.call(this, event);
-      } else if (acceptBubbling && target.closest(elementSelector)) {
-        fn.call(this, event);
-      }
-    }));
+        if (!acceptBubbling && target.matches(elementSelector)) {
+          fn.call(this, event);
+        } else if (acceptBubbling && target.closest(elementSelector)) {
+          fn.call(this, event);
+        }
+      }),
+    );
   }
-}
+};

package/src/dom/addClickOutsideListener.ts

@@ -1,16 +1,16 @@
-/**
- * Add event listener to listen to clicks outside of given element
- *
- * @param element Node element outside which to listen to clicks
- * @param fn Function to trigger when clicked outside
- * @returns void
- */
-export const addClickOutsideListener = (element: HTMLElement, fn: () => any): void => {
-  document.addEventListener('click', (event: Event) => {
-    const target = event.target as HTMLElement;
-
-    if (!!target && !element.contains(target)) {
-      fn.call(this);
-    }
-  });
-};
+/**
+ * Add event listener to listen to clicks outside of given element
+ *
+ * @param element Node element outside which to listen to clicks
+ * @param fn Function to trigger when clicked outside
+ * @returns void
+ */
+export const addClickOutsideListener = (element: HTMLElement, fn: () => any): void => {
+  document.addEventListener('click', (event: Event) => {
+    const target = event.target as HTMLElement;
+
+    if (!!target && !element.contains(target)) {
+      fn.call(this);
+    }
+  });
+};

package/src/dom/addEventListener.ts

@@ -7,13 +7,16 @@
  */
 export const addEventListener = (
   element: HTMLElement | HTMLElement[] | NodeListOf<HTMLElement> | HTMLCollectionOf<HTMLElement>,
-  listeners: Record<string, EventListenerOrEventListenerObject | EventListenerOrEventListenerObject[]>
+  listeners: Record<
+    string,
+    EventListenerOrEventListenerObject | EventListenerOrEventListenerObject[]
+  >,
 ): void => {
   const elementList = (
-    element instanceof Array || element instanceof HTMLCollection || element instanceof NodeList ?
-      Array.from(element) :
-      [element]
-    ) as HTMLElement[];
+    element instanceof Array || element instanceof HTMLCollection || element instanceof NodeList
+      ? Array.from(element)
+      : [element]
+  ) as HTMLElement[];
 
   elementList.forEach((element: HTMLElement) => {
     for (let eventName in listeners) {
@@ -21,7 +24,9 @@ export const addEventListener = (
         listeners[eventName] instanceof Array ? listeners[eventName] : [listeners[eventName]]
       ) as EventListenerOrEventListenerObject[];
 
-      functionList.forEach((fn: EventListenerOrEventListenerObject) => element.addEventListener(eventName, fn));
+      functionList.forEach((fn: EventListenerOrEventListenerObject) =>
+        element.addEventListener(eventName, fn),
+      );
     }
   });
-}
+};

package/src/dom/appendAfter.ts

@@ -1,9 +1,9 @@
-/**
- * Append given node after reference node in the DOM
- *
- * @param newNode New node element to be appended
- * @param referenceNode Reference node element
- * @returns Result of the action
- */
-export const appendAfter = (newNode: HTMLElement, referenceNode: HTMLElement): boolean =>
-  !!referenceNode.parentElement?.insertBefore(newNode, referenceNode.nextSibling);
+/**
+ * Append given node after reference node in the DOM
+ *
+ * @param newNode New node element to be appended
+ * @param referenceNode Reference node element
+ * @returns Result of the action
+ */
+export const appendAfter = (newNode: HTMLElement, referenceNode: HTMLElement): boolean =>
+  !!referenceNode.parentElement?.insertBefore(newNode, referenceNode.nextSibling);

package/src/dom/appendBefore.ts

@@ -1,9 +1,9 @@
-/**
- * Append given node before reference node in the DOM
- *
- * @param newNode New node element to be appended
- * @param referenceNode Reference node element
- * @returns Result of the action
- */
-export const appendBefore = (newNode: HTMLElement, referenceNode: HTMLElement): boolean =>
-  !!referenceNode.parentElement?.insertBefore(newNode, referenceNode);
+/**
+ * Append given node before reference node in the DOM
+ *
+ * @param newNode New node element to be appended
+ * @param referenceNode Reference node element
+ * @returns Result of the action
+ */
+export const appendBefore = (newNode: HTMLElement, referenceNode: HTMLElement): boolean =>
+  !!referenceNode.parentElement?.insertBefore(newNode, referenceNode);

package/src/dom/createElement.ts

@@ -1,51 +1,55 @@
-import { IExtendingElementProps } from './interfaces/createElement';
-
-/**
- * Method for creating Node element and assigning multiple parameters, event listeners & children in one method call
- *
- * @param tagName Node tag name
- * @param props List of attributes, event listeners or/and children to assign to the newly created element
- * @returns Resulting Node element
- */
-export const createElement = <T = HTMLElement>(
-  tagName: string,
-  props?: Partial<Omit<T, 'children' | 'dataset'>> & IExtendingElementProps,
-): T => {
-  const element: HTMLElement = document.createElement(tagName);
-
-  if (props) {
-    for (let key in props) {
-      const value = (props as any)[key];
-
-      if (key === 'role') {
-        element.setAttribute(key, value);
-      } else if (key === 'aria') {
-        for (let ariaKey in props.aria!) {
-          element.setAttribute(`aria-${ariaKey}`, value[ariaKey]);
-        }
-      } else if (key === 'children') {
-        props.children!.forEach((child: HTMLElement) => element.appendChild(child));
-      } else if (key === 'listeners') {
-        for (let eventName in props.listeners!) {
-          const functionList = (
-            props.listeners![eventName] instanceof Array
-              ? props.listeners![eventName]
-              : [props.listeners![eventName]]
-          ) as EventListenerOrEventListenerObject[];
-
-          functionList.forEach((fn: EventListenerOrEventListenerObject) =>
-            element.addEventListener(eventName, fn),
-          );
-        }
-      } else if (key === 'dataset') {
-        for (let datasetKey in props.dataset) {
-          element.dataset[datasetKey] = props.dataset[datasetKey];
-        }
-      } else {
-        (element as any)[key] = value;
-      }
-    }
-  }
-
-  return element as unknown as T;
-};
+import { IExtendingElementProps } from './interfaces/createElement';
+
+/**
+ * Method for creating Node element and assigning multiple parameters, event listeners & children in one method call
+ *
+ * @param tagName Node tag name
+ * @param props List of attributes, event listeners or/and children to assign to the newly created element
+ * @returns Resulting Node element
+ */
+export const createElement = <T = HTMLElement>(
+  tagName: string,
+  props?: Partial<Omit<T, 'children' | 'dataset' | 'style'>> & IExtendingElementProps,
+): T => {
+  const element: HTMLElement = document.createElement(tagName);
+
+  if (props) {
+    for (let key in props) {
+      const value = (props as any)[key];
+
+      if (key === 'role') {
+        element.setAttribute(key, value);
+      } else if (key === 'aria') {
+        for (let ariaKey in props.aria!) {
+          element.setAttribute(`aria-${ariaKey}`, value[ariaKey]);
+        }
+      } else if (key === 'style') {
+        for (let styleKey in props.style!) {
+          (element.style as any)[styleKey] = value[styleKey];
+        }
+      } else if (key === 'children') {
+        props.children!.forEach((child: HTMLElement) => element.appendChild(child));
+      } else if (key === 'listeners') {
+        for (let eventName in props.listeners!) {
+          const functionList = (
+            props.listeners![eventName] instanceof Array
+              ? props.listeners![eventName]
+              : [props.listeners![eventName]]
+          ) as EventListenerOrEventListenerObject[];
+
+          functionList.forEach((fn: EventListenerOrEventListenerObject) =>
+            element.addEventListener(eventName, fn),
+          );
+        }
+      } else if (key === 'dataset') {
+        for (let datasetKey in props.dataset) {
+          element.dataset[datasetKey] = props.dataset[datasetKey];
+        }
+      } else {
+        (element as any)[key] = value;
+      }
+    }
+  }
+
+  return element as unknown as T;
+};

package/src/dom/fireEvent.ts

@@ -5,4 +5,5 @@
  * @param eventType Type name of event that should be fired
  * @returns Result of the action
  */
-export const fireEvent = (element: HTMLElement, eventType: string): boolean => element.dispatchEvent(new Event(eventType));
+export const fireEvent = (element: HTMLElement, eventType: string): boolean =>
+  element.dispatchEvent(new Event(eventType));

package/src/dom/index.ts

@@ -1,9 +1,9 @@
-export * from './interfaces';
-
-export * from './addAsyncEventListener';
-export * from './addClickOutsideListener';
-export * from './addEventListener';
-export * from './appendAfter';
-export * from './appendBefore';
-export * from './createElement';
-export * from './fireEvent';
+export * from './interfaces';
+
+export * from './addAsyncEventListener';
+export * from './addClickOutsideListener';
+export * from './addEventListener';
+export * from './appendAfter';
+export * from './appendBefore';
+export * from './createElement';
+export * from './fireEvent';

package/src/dom/interfaces/createElement.ts

@@ -1,35 +1,36 @@
-export type TAriaLabelKey =
-  | 'atomic'
-  | 'busy'
-  | 'controls'
-  | 'current'
-  | 'describedby'
-  | 'details'
-  | 'disables'
-  | 'dropeffect'
-  | 'errormessage'
-  | 'expanded'
-  | 'flowto'
-  | 'grabbed'
-  | 'haspopup'
-  | 'hidden'
-  | 'invalid'
-  | 'keyshortcuts'
-  | 'label'
-  | 'labelledby'
-  | 'live'
-  | 'modal'
-  | 'owns'
-  | 'relevant'
-  | 'roledescription';
-
-export interface IExtendingElementProps {
-  children?: HTMLElement[];
-  listeners?: Record<
-    string,
-    EventListenerOrEventListenerObject | EventListenerOrEventListenerObject[]
-  >;
-  role?: string;
-  aria?: Partial<Record<TAriaLabelKey, string>>;
-  dataset: Record<string, string>;
-}
+export type TAriaLabelKey =
+  | 'atomic'
+  | 'busy'
+  | 'controls'
+  | 'current'
+  | 'describedby'
+  | 'details'
+  | 'disables'
+  | 'dropeffect'
+  | 'errormessage'
+  | 'expanded'
+  | 'flowto'
+  | 'grabbed'
+  | 'haspopup'
+  | 'hidden'
+  | 'invalid'
+  | 'keyshortcuts'
+  | 'label'
+  | 'labelledby'
+  | 'live'
+  | 'modal'
+  | 'owns'
+  | 'relevant'
+  | 'roledescription';
+
+export interface IExtendingElementProps {
+  children?: HTMLElement[];
+  listeners?: Record<
+    string,
+    EventListenerOrEventListenerObject | EventListenerOrEventListenerObject[]
+  >;
+  role?: string;
+  aria?: Partial<Record<TAriaLabelKey, string>>;
+  dataset?: Record<string, string>;
+  style?: Record<string, string | number>;
+}

package/src/dom/interfaces/index.ts

@@ -1 +1 @@
-export * from './createElement';
+export * from './createElement';

package/src/general/index.ts

@@ -1,3 +1,3 @@
-export * from './isEmpty';
-export * from './isNil';
-export * from './isValidJson';
+export * from './isEmpty';
+export * from './isNil';
+export * from './isValidJson';

package/src/general/isEmpty.ts

@@ -1,21 +1,21 @@
-import { isNil } from './isNil';
-
-/**
- * Check if given value is empty
- *
- * @param value Value to be checked
- * @returns Boolean indicating if given value is empty
- */
-export const isEmpty = (value: any): boolean => {
-  if (value instanceof Function) {
-    return false;
-  }
-
-  return (
-    isNil(value) ||
-    (value instanceof Object &&
-      !Object.keys(value).length &&
-      Object.getPrototypeOf(value) === Object.prototype) ||
-    !value.valueOf().toString().length
-  );
-};
+import { isNil } from './isNil';
+
+/**
+ * Check if given value is empty
+ *
+ * @param value Value to be checked
+ * @returns Boolean indicating if given value is empty
+ */
+export const isEmpty = (value: any): boolean => {
+  if (value instanceof Function) {
+    return false;
+  }
+
+  return (
+    isNil(value) ||
+    (value instanceof Object &&
+      !Object.keys(value).length &&
+      Object.getPrototypeOf(value) === Object.prototype) ||
+    !value.valueOf().toString().length
+  );
+};

package/src/general/isNil.ts

@@ -1,7 +1,7 @@
-/**
- * Check if value is equal to null or undefined
- *
- * @param value Value to be checked
- * @returns Boolean indicating if value is equal to null or undefined
- */
-export const isNil = (value: any): boolean => value === undefined || value === null;
+/**
+ * Check if value is equal to null or undefined
+ *
+ * @param value Value to be checked
+ * @returns Boolean indicating if value is equal to null or undefined
+ */
+export const isNil = (value: any): boolean => value === undefined || value === null;

package/src/general/isValidJson.ts

@@ -1,15 +1,15 @@
-/**
- * Check if string is valid JSON
- *
- * @param value String value to be checked
- * @returns Boolean indicating if string value is a valid JSON
- */
-export const isValidJson = (value: string): boolean => {
-  try {
-    JSON.parse(value);
-  } catch (error: any) {
-    return false;
-  }
-
-  return true;
-};
+/**
+ * Check if string is valid JSON
+ *
+ * @param value String value to be checked
+ * @returns Boolean indicating if string value is a valid JSON
+ */
+export const isValidJson = (value: string): boolean => {
+  try {
+    JSON.parse(value);
+  } catch (error: any) {
+    return false;
+  }
+
+  return true;
+};

package/src/index.ts

@@ -1,6 +1,6 @@
-export * from './browser';
-export * from './dateTime';
-export * from './dom';
-export * from './general';
-export * from './schedule';
-export * from './string';
+export * from './browser';
+export * from './dateTime';
+export * from './dom';
+export * from './general';
+export * from './schedule';
+export * from './string';

package/src/schedule/index.ts

@@ -1,2 +1,2 @@
-export * from './runAnimation';
-export * from './runAsync';
+export * from './runAnimation';
+export * from './runAsync';

package/src/schedule/runAnimation.ts

@@ -1,51 +1,51 @@
-/**
- * Run function as animation using requestAnimationFrame
- *
- * @param fn Function to be run as animation
- * @param autoStart If animation should start right away or just return callbacks
- * @returns Callbacks to start animation (startAnimation) and stop animation (stopAnimation)
- */
-export const runAnimation = (
-  fn: () => any,
-  autoStart = true,
-): { startAnimation: () => void; stopAnimation: () => void } => {
-  let isRunning = false;
-  let requestedAnimationFrame: number | null = null;
-
-  const runAnimation = (): void => {
-    requestedAnimationFrame = requestAnimationFrame((): void => {
-      fn.call(this);
-
-      if (isRunning) {
-        runAnimation();
-      }
-    });
-  };
-
-  const startAnimation = (): void => {
-    if (isRunning) {
-      return;
-    }
-
-    isRunning = true;
-    runAnimation();
-  };
-
-  const stopAnimation = (): void => {
-    if (!isRunning) {
-      return;
-    }
-
-    isRunning = false;
-
-    if (!!requestedAnimationFrame) {
-      cancelAnimationFrame(requestedAnimationFrame);
-    }
-  };
-
-  if (autoStart) {
-    startAnimation();
-  }
-
-  return { startAnimation, stopAnimation };
-};
+/**
+ * Run function as animation using requestAnimationFrame
+ *
+ * @param fn Function to be run as animation
+ * @param autoStart If animation should start right away or just return callbacks
+ * @returns Callbacks to start animation (startAnimation) and stop animation (stopAnimation)
+ */
+export const runAnimation = (
+  fn: () => any,
+  autoStart = true,
+): { startAnimation: () => void; stopAnimation: () => void } => {
+  let isRunning = false;
+  let requestedAnimationFrame: number | null = null;
+
+  const runAnimation = (): void => {
+    requestedAnimationFrame = requestAnimationFrame((): void => {
+      fn.call(this);
+
+      if (isRunning) {
+        runAnimation();
+      }
+    });
+  };
+
+  const startAnimation = (): void => {
+    if (isRunning) {
+      return;
+    }
+
+    isRunning = true;
+    runAnimation();
+  };
+
+  const stopAnimation = (): void => {
+    if (!isRunning) {
+      return;
+    }
+
+    isRunning = false;
+
+    if (!!requestedAnimationFrame) {
+      cancelAnimationFrame(requestedAnimationFrame);
+    }
+  };
+
+  if (autoStart) {
+    startAnimation();
+  }
+
+  return { startAnimation, stopAnimation };
+};