danholibraryjs 1.7.0 → 1.10.0

package/src/Extensions/index.ts

@@ -1,6 +1,6 @@
-import ElementOptions from "../Interfaces/ElementOptions";
-import { EventHandler, IElement } from "../Types";
+
 export * from './Array';
+export * from './Document';
 export * from './Map';
 export * from './Object';
 export * from './String';
@@ -12,72 +12,13 @@ declare global {
          */
         parseBoolean(value: string): boolean
     }
-
-    interface Document {
-        /**
-         * Creates an element like Document#createElement, however with construction options to assign values in construction instead of after construction.
-         * @param tagName HTMLElement tag name
-         * @param options Construction options, instead of assigning values after construction
-         */
-        createProperElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementOptions, ...children: Array<IElement>): HTMLElementTagNameMap[K]
-        createFromHtml<K extends keyof HTMLElementTagNameMap>(html: string, parentTag?: K): HTMLElementTagNameMap[K]
-    }
-    interface HTMLCollection {
-        /**
-         * Converts HTMLCollection to Element[]
-         */
-        array(): Element[]
-    }
 }
 
-Boolean.parseBoolean = function(value: string) {
+function parseBoolean(value: string) {
     return value === "true";
 };
+Boolean.parseBoolean = parseBoolean;
 
-try {
-    Document.prototype.createProperElement = function<K extends keyof HTMLElementTagNameMap>(this: Document, tagName: K, options?: ElementOptions, ...children: Array<IElement>): HTMLElementTagNameMap[K] {
-        let baseElement = document.createElement(tagName);
-        if (!options) return baseElement;
-
-        const { id, class: className, dataset, ...rest } = options;
-        if (id) baseElement.id = id;
-        if (className) {
-            const classNames = Array.isArray(className) ? className : [className];
-            classNames.forEach(className => baseElement.classList.add(className));
-        }
-        children ?? options.children;
-        if (children) {
-            const childrenElements = Array.isArray(children) ? children : [children];
-            childrenElements.forEach(child => baseElement.append(child));
-        }
-        if (dataset) Object.entries(dataset).forEach(([key, value]) => baseElement.dataset[key] = value);
-        
-        for (const optionKey in rest) {
-            const optionValue = rest[optionKey as keyof typeof rest] as EventHandler | object;
-            if (optionValue === undefined) continue;
-
-            if (typeof optionValue === 'function') {
-                baseElement.addEventListener(optionKey.substring(2), rest[optionKey as keyof typeof rest] as EventListener);
-            } else {
-                baseElement.setAttribute(optionKey, optionValue.toString());
-            }
-        }
-
-        return baseElement;
-    }
-    Document.prototype.createFromHtml = function<K extends keyof HTMLElementTagNameMap>(this: Document, html: string, parentTag?: K): HTMLElementTagNameMap[K] {
-        return new DOMParser().parseFromString(html, 'text/html').body.firstChild as HTMLElementTagNameMap[K];
-    }
-
-    HTMLCollection.prototype.array = function(this: HTMLCollection) {
-        let result = new Array<Element>();
-
-        for (let i = 0; i < this.length; i++) {
-            const item = this.item(i);
-            if (item !== null) result.push(item);
-        }
-        return result;
-    }
-} catch {
-    // Used in node.js
-}
+export const BooleanExtensions = {
+    parseBoolean
+};

package/src/Functions/GetNestedProperty.ts

@@ -0,0 +1,29 @@
+export type GetNestedProperty<Parent, Key extends string> =
+    Key extends keyof Parent 
+        ? Parent[Key] 
+        : Key extends `${infer K}.${infer Rest}`
+            ? K extends keyof Parent
+                ? GetNestedProperty<Parent[K], Rest>
+                : never
+            : never;
+
+/**
+ * Gets a nested property from an object
+ * @param parent Parent object to search
+ * @param key Key to search for. Can be nested with dot notation
+ * @returns Value of key or null if not found
+ */
+export function GetNestedProperty<Parent extends object, Key extends string>(parent: Parent, key: Key): GetNestedProperty<Parent, Key> | null {
+    if (key in parent) return parent[key as any as keyof Parent] as any;
+
+    for (const prop in parent) {
+        if (typeof parent[prop] === 'object') {
+            const result = GetNestedProperty((parent as any)[prop], key);
+            if (result) return result as any;
+        }
+    }
+
+    return null;
+}
+
+export default GetNestedProperty;

package/src/Functions/index.ts

@@ -1,4 +1,5 @@
 export * from './CopyToClipboard';
 export * from './GetCSSProperty';
+export * from './GetNestedProperty';
 export * from './SetNavigationSelected';
 export * from './HTMLEvent';

package/src/Interfaces/ElementOptions.ts

@@ -7,14 +7,14 @@ type Events = Record<
 
 /**
  * Construction options when creating an HTML element using:
- * @see Document.createProperElement 
+ * @see Document.createElement 
  * @borwwos IElement
  * @borrows Arrayable
  */
 export type ElementOptions = Partial<
     Events & Record<string, any> & {
     id: string,
-    class: Arrayable<string>;
+    className: Arrayable<string>;
     children: Arrayable<IElement>;
     dataset: Record<string, string>
 }>

package/src/Types/index.ts

@@ -9,12 +9,17 @@ export * from './PropertiesWith';
  */
 export type Arrayable<T> = T | Array<T>;
 
+/**
+ * Item is function or T
+ */
+export type Functionable<T> = T | (() => T);
+
 /**
  * Used for HTMLElement.append in ElementOptions, Document.createProperElement.
  * IElement accepts HTML Elements or HTMl-like strings.
  * 
  * @see HTMLElement.append
- * @see Document.createProperElement
+ * @see Document.createElement
  */
 export type IElement = HTMLElement | string;
 
@@ -33,4 +38,24 @@ export type AllPropsAre<ReturnType> = {
 /**
  * string or RegExp.. pretty self-explanatory
  */
-export type StringRegex = string | RegExp;
+export type StringRegex = string | RegExp;
+
+export type If<Boolean extends boolean, True, False> = Boolean extends true ? True : False;
+
+/**
+ * GetRepeatedKeys<[
+ *  { username: string, password: string },
+ *  { username: number, email: string },
+ * ]> // { username: string | number }
+ */
+export type GetRepeatedKeys<Types extends Array<any>> = (
+    Types extends [infer First, infer Second, ...infer Rest]
+        ? First extends object
+            ? Second extends object
+                ? {
+                    [Key in Extract<keyof First, keyof Second>]: First[Key] | Second[Key]
+                } & GetRepeatedKeys<Rest>
+            : {}
+        : {}
+    : {}
+);

package/tsconfig.json

@@ -89,7 +89,7 @@
     // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
     // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
     // "noUncheckedIndexedAccess": true,                 /* Include 'undefined' in index signature results */
-    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
     // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type */
     // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
     // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
@@ -97,6 +97,6 @@
     /* Completeness */
     "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
     "skipLibCheck": true,                                /* Skip type checking all .d.ts files. */
-    "watch": true,
+    "keyofStringsOnly": false,                          /* Make keyof only return strings instead of string, numbers or symbols. */
   },
 }

package/dist/Extensions/Object.d.ts

@@ -1,16 +0,0 @@
-import { ValueOf } from "../Types";
-export {};
-declare global {
-    interface ObjectConstructor {
-        /**
-         * Destructures object into array of [property, value]
-         * @param from Object to destruct
-         */
-        array<From = {}>(from: From): Array<[keyof From, ValueOf<From>]>;
-        /**
-         * Destructures object into array of property keys
-         * @param from Object to destruct
-         */
-        keysOf<From = {}>(from: From): Array<keyof From>;
-    }
-}

package/dist/Extensions/Object.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-Object.keysOf = function (from) {
-    return Object.keys(from);
-};
-Object.array = function (from) {
-    return Object.keysOf(from).map(prop => [prop, from[prop]]);
-};

package/src/Extensions/Object.ts

@@ -1,25 +0,0 @@
-import { ValueOf } from "../Types";
-
-export {};
-
-declare global {
-    interface ObjectConstructor {
-        /**
-         * Destructures object into array of [property, value]
-         * @param from Object to destruct
-         */
-        array<From = {}>(from: From): Array<[keyof From, ValueOf<From>]>
-        /**
-         * Destructures object into array of property keys
-         * @param from Object to destruct
-         */
-        keysOf<From = {}>(from: From): Array<keyof From>
-    }
-}
-
-Object.keysOf = function<From = {}>(this: object, from: From): Array<keyof From> {
-    return Object.keys(from) as Array<keyof From>;
-}
-Object.array = function<From = {}>(this: object, from: From): Array<[keyof From, ValueOf<From>]> {
-    return Object.keysOf(from).map(prop => [prop, from[prop]]) as Array<[keyof From, ValueOf<From>]>;
-}