danholibraryjs 2.0.0 → 2.0.1

package/docs/Types.md

@@ -4,115 +4,244 @@
 
 ### General
 
-``` ts
+```ts
 /**
- * Type's properties are ReturnType
+ * Used for HTMLElement.append in ElementOptions, Document.createElement.
+ * IElement accepts HTML Elements or HTML-like strings.
  */
-type AllPropsAre<ReturnType> = {
-    [key: string]: ReturnType
-}
+type IElement = HTMLElement | string;
 
 /**
- * Item is single or multiple
+ * string or RegExp
  */
-type Arrayable<T> = T | Array<T>;
+type StringRegex = string | RegExp;
 
 /**
- * If Condition is true, Then, Else... pretty self-explanatory
+ * Conditional type - If Boolean is true, returns True, otherwise False
  */
-type If<Condition, Then, Else> = Condition extends true ? Then : Else;
+type If<Boolean extends boolean, True, False> = Boolean extends true ? True : False;
 
 /**
- * Used for HTMLElement.append in ElementOptions, Document.createProperElement.
- * IElement accepts HTML Elements or HTMl-like strings.
- * 
- * @see HTMLElement.append
- * @see Document.createProperElement
+ * Return types of T
  */
-type IElement = HTMLElement | string;
+type ValueOf<T> = T[keyof T];
+```
 
+### Able
+
+```ts
 /**
- * string or RegExp.. pretty self-explanatory
+ * Value can be either T or a function that returns T
  */
-type StringRegex = string | RegExp;
+type Functionable<T, Args extends any[] = []> = T | ((...args: Args) => T);
 
 /**
- * Return types of T
+ * Value can be either T or a Promise that resolves to T
  */
-type ValueOf<T> = T[keyof T];
+type Promisable<T> = T | Promise<T>;
+
+/**
+ * Value can be T or null
+ */
+type Nullable<T> = T | null;
+
+/**
+ * Removes null and undefined from T
+ */
+type NonNullable<T> = T extends null | undefined ? never : T;
+```
+
+### Array
+
+```ts
+/**
+ * Item is single or multiple (T or Array<T>)
+ */
+type Arrayable<T> = T | Array<T>;
+
+/**
+ * Item is single or wrapped in single-element array
+ */
+type SingleArrayable<T> = T | [T];
+
+/**
+ * Extracts type from Array<T>
+ */
+type TFromArray<T> = T extends Array<infer U> ? U : never;
 ```
 
 ### BetterTypes
 
 ```ts
 /**
- * Construct a type with the properties of Type except for those in type Properties.
+ * Construct a type with the properties of Type except for those in Properties
  */
 type BetterOmit<Type, Properties extends keyof Type> = Omit<Type, Properties>;
+
 /**
  * Extract from From those types that are assignable to Properties
  */
 type BetterExtract<From, Properties extends From> = Extract<From, Properties>;
+
+/**
+ * Partial type but with required properties
+ */
+type PartialExcept<From, Properties extends keyof From> = Partial<From> & Required<Pick<From, Properties>>;
+```
+
+### C# Types
+
+```ts
+/**
+ * GUID string
+ */
+type Guid = string;
+
+/**
+ * TimeSpan string format
+ */
+type TimeSpanType = string;
+```
+
+### Date
+
+```ts
+/**
+ * Long month names
+ */
+type LongMonth = 'January' | 'February' | 'March' | 'April' | 'May' | 'June' | 'July' | 'August' | 'September' | 'October' | 'November' | 'December';
+
+/**
+ * Short month names
+ */
+type ShortMonth = 'Jan' | 'Feb' | 'Mar' | 'Apr' | 'May' | 'Jun' | 'Jul' | 'Aug' | 'Sep' | 'Oct' | 'Nov' | 'Dec';
+
+/**
+ * Month name (long or short)
+ */
+type Month = LongMonth | ShortMonth;
+
+/**
+ * Short day names
+ */
+type ShortDay = 'Mon' | 'Tue' | 'Wed' | 'Thu' | 'Fri' | 'Sat' | 'Sun';
+
+/**
+ * Long day names
+ */
+type LongDay = `${'Mon' | 'Tues' | 'Wednes' | 'Thurs' | 'Fri' | 'Satur' | 'Sun'}day`;
+
+/**
+ * Day name (long or short)
+ */
+type Day = ShortDay | LongDay;
+
+/**
+ * Constructor type for DanhoDate
+ */
+type DanhoDateConstructor = TimeProperties | string | number | Date;
+
+/**
+ * Time properties object
+ */
+type TimeProperties<Plural extends boolean = false> = Record<Plural extends true ? `${TimeKeys}s` : TimeKeys, number>;
+
+/**
+ * What properties to include when using TimeSpan.toString()
+ */
+type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number, boolean>>;
 ```
 
 ### Events
 
 ```ts
 /**
- * Default eventhandler mapper. Object with properties that are arrays
+ * Default event handler mapper. Object with properties that are arrays
  */
- type BaseEvent<Keys extends string, Types extends Array<any>> = Record<Keys, Types>;
+type BaseEvent<Keys extends string, Types extends Array<any>> = Record<Keys, Types>;
 
- /**
-  * Eventhandler type for:
-  * @see EventCollection
-  * @borrows BaseEvent
-  */
- type EventHandler<
-     Events extends BaseEvent<string, Array<any>> = BaseEvent<string, Array<any>>,
-     Event extends keyof Events = keyof Events,
-     ReturnType = any
- > = (...args: Events[Event]) => ReturnType;
+/**
+ * Event handler type
+ */
+type EventHandler<
+    Events extends BaseEvent<string, Array<any>> = BaseEvent<string, Array<any>>,
+    Event extends keyof Events = keyof Events,
+    ReturnType = any
+> = (...args: Events[Event]) => ReturnType;
 ```
 
-### PropertiesWith
+### Function
 
 ```ts
 /**
- * Filters all properties from From that has the return type of Type
+ * Changes return type of a function
  */
-type PropertiesWith<Type, From> = {
-    [Key in keyof From as From[Key] extends Type ? Key : never]: From[Key]
-}
-default PropertiesWith;
+type NewReturnType<Func extends (...args: any[]) => any, NewReturn> = 
+    Func extends (...args: infer Args) => any ? (...args: Args) => NewReturn : never;
 
 /**
- * Fitlers all properties from From that don't have the return type of Type
+ * Wraps function return type in Promise
  */
-type PropertiesWithout<Type, From> = {
-    [Key in keyof From as From[Key] extends Type ? never : Key]: From[Key]
-}
+type PromisedReturn<Func extends (...args: any[]) => any> = 
+    Func extends (...args: infer Args) => infer Return ? (...args: Args) => Promise<Return> : never;
+
+/**
+ * Removes all function properties from type
+ */
+type NoFunctions<T> = { [K in keyof T]: T[K] extends Function ? never : T[K] };
 ```
 
-### Time
+### Object
 
 ```ts
 /**
- * Type used to construct DanhoDate.
- * @Data Partial TimeProperties except years & months
- * @DateFormat string as dd/MM/yyyy
+ * Type's properties are all ReturnType
+ */
+type AllPropsAre<ReturnType> = {
+    [key: string]: ReturnType;
+};
+```
+
+### PropertiesWith
+
+```ts
+/**
+ * Filters all properties from From that have the return type of Type
+ */
+type PropertiesWith<Type, From> = {
+    [Key in keyof From as From[Key] extends Type ? Key : never]: From[Key];
+};
+
+/**
+ * Filters all properties from From that don't have the return type of Type
  */
-type DanhoDateConstructor = Data | DateFormat | number | Date;
+type PropertiesWithout<Type, From> = {
+    [Key in keyof From as From[Key] extends Type ? never : Key]: From[Key];
+};
 
 /**
- * Object interface with keys above to number values. If Plural is true, all properties ends with 's'
+ * Gets keys that appear in all types in the array
  */
-type TimeProperties<Plural extends boolean = false> = Record<Plural extends true ? `${TimeKeys}s` : TimeKeys, number>
+type GetRepeatedKeys<Types extends Array<any>> = 
+    Types extends [infer First, ...infer Rest]
+        ? Rest extends Array<any>
+            ? keyof First & GetRepeatedKeys<Rest>
+            : keyof First
+        : never;
 
 /**
- * What properties to include when using TimeSpan.toString(format: TimeSpanFormat): string
+ * Filters types that have specific properties
  */
-type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number, boolean>>
+type ModelWithProps<T, TProps extends (keyof T | string)> = T extends Record<TProps, any> ? T : never;
+```
+
+### String
+
+```ts
+/**
+ * Autocomplete type - allows string literal autocomplete while still accepting any string
+ */
+type Autocomplete<T> = T | (string & {});
 ```
 
 ### TransformTypes
@@ -122,21 +251,36 @@ type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number, boolea
  * Converts Start types to Switch types in From type
  */
 type TransformType<From, Start, Switch> = {
-    [Key in keyof From]: From[Key] extends Start ? Switch : From[Key]
-}
+    [Key in keyof From]: From[Key] extends Start ? Switch : From[Key];
+};
 
 /**
  * Returns object with properties matching BaseType with types of NewType
  */
-type TransformTypes<From, BaseType, NewType> = Record<keyof { 
-    [Key in keyof From as From[Key] extends BaseType ? Key : never]: Key 
-}, NewType>
+type TransformTypes<From, BaseType, NewType> = Record<keyof {
+    [Key in keyof From as From[Key] extends BaseType ? Key : never]: Key;
+}, NewType>;
+
+/**
+ * Converts object to JSON-serializable type (removes functions, Date -> string, etc.)
+ */
+type Json<T> = {
+    [K in keyof T]: T[K] extends Function
+        ? never
+        : T[K] extends Date
+        ? string
+        : T[K] extends object
+        ? Json<T[K]>
+        : T[K];
+};
 ```
 
 ### Store
+
 ```ts
 /**
- * Reducer function to map wanted parameters when using @see Store.on(action, reducer);
+ * Reducer function for Store state updates
  */
-type Reducer<State, Types extends Record<string, any[]>, Action extends keyof Types> = (state: State, ...args: Types[Action]) => State
+type Reducer<State, Types extends Record<string, any[]>, Action extends keyof Types> = 
+    (state: State, ...args: Types[Action]) => State;
 ```

package/docs/index.md

@@ -24,6 +24,5 @@ import { ... } from 'DanhoLibraryJS';
 
 * [Classes](./Classes.md)
 * [Extensions](./Extensions.md)
-* [Functions](./Functions.md)
 * [Interfaces](./Interfaces.md)
 * [Types](./Types.md)

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Library for Javascript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/Extensions/Array/index.ts

@@ -1,15 +1,6 @@
-import * as Array from './array.extension';
-import * as CRUD from './crud.extension';
-import * as Loop from './loop.extension';
-import * as Random from './random.extension';
-import * as Sort from './sort.extension';
-import * as String from './string.extension';
-
-export const ArrayExtensions = {
-  ...Array,
-  ...CRUD,
-  ...Loop,
-  ...Random,
-  ...Sort,
-  ...String,
-};
+export * from './array.extension';
+export * from './crud.extension';
+export * from './loop.extension';
+export * from './random.extension';
+export * from './sort.extension';
+export * from './string.extension';

package/src/Extensions/Object/index.ts

@@ -1,11 +1,4 @@
-import * as Array from './arrays.extension';
-import * as Booleans from './booleans.extension';
-import * as Extracts from './extracts.extension';
-import * as Properties from './properties.extension';
-
-export const ObjectExtensions = {
-  ...Array,
-  ...Booleans,
-  ...Extracts,
-  ...Properties
-};
+export * from './arrays.extension';
+export * from './booleans.extension';
+export * from './extracts.extension';
+export * from './properties.extension';

package/src/Extensions/Object/properties.extension.ts

@@ -1,4 +1,37 @@
-import { Properties, properties } from "./properties";
+import { PropertiesWith, If } from '../../Types';
+import { convertCase } from '../String/case.extension';
+
+type PrimitiveMap = {
+  string: string;
+  number: number;
+  boolean: boolean;
+  undefined: undefined;
+  null: null;
+  object: object;
+  function: Function;
+  any: any;
+  Date: Date;
+  RegExp: RegExp;
+  Promise: Promise<any>;
+  Array: Array<any>;
+  Map: Map<any, any>;
+  Set: Set<any>;
+};
+
+/**
+ * Object with getPrimitiveTypes<Source, AllowFunctions extends boolean>(
+ *  source: Source,
+ *  allowFunctions: AllowFunctions = false
+ * ): Object with properties from source that matches primitive type
+ */
+export type Properties = {
+  [Key in keyof PrimitiveMap as `get${Capitalize<Key>}s`]:
+  <Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions) =>
+    If<AllowFunctions,
+      PropertiesWith<PrimitiveMap[Key] | ((...args: any[]) => PrimitiveMap[Key]), Source>,
+      PropertiesWith<PrimitiveMap[Key], Source>
+    >
+};
 
 declare global {
   interface ObjectConstructor {
@@ -6,6 +39,21 @@ declare global {
   }
 }
 
-
+export const properties: Properties = [
+  'string', 'number', 'boolean', 'undefined', 'null',
+  'object', 'function', 'any',
+  'Date', 'RegExp', 'Promise', 'Array', 'Map', 'Set'
+].reduce((result, primitive) => {
+  result[`get${convertCase('camel', 'pascal')}s` as keyof Properties] = function <Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions: AllowFunctions = false as AllowFunctions) {
+    return Object.keysOf<Source>(source).reduce((result, key) => {
+      if ((source[key] as any).constructor.name === primitive ||
+        (withFunctions && typeof source[key] === 'function' && source[key] as any).constructor.name === primitive) {
+        result[key] = source[key];
+      }
+      return result;
+    }, {} as any);
+  };
+  return result;
+}, {} as Properties);
 
 Object.properties = properties;

package/src/Extensions/Object/properties.ts

@@ -1,4 +1,5 @@
 import { PropertiesWith, If } from '../../Types';
+import { convertCase } from '../String/case.extension';
 
 type PrimitiveMap = {
   string: string;
@@ -37,7 +38,7 @@ export const properties: Properties = [
   'object', 'function', 'any',
   'Date', 'RegExp', 'Promise', 'Array', 'Map', 'Set'
 ].reduce((result, primitive) => {
-  result[`get${primitive.convertCase('camel', 'pascal')}s` as keyof Properties] = function <Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions: AllowFunctions = false as AllowFunctions) {
+  result[`get${convertCase('camel', 'pascal')}s` as keyof Properties] = function <Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions: AllowFunctions = false as AllowFunctions) {
     return Object.keysOf<Source>(source).reduce((result, key) => {
       if ((source[key] as any).constructor.name === primitive ||
         (withFunctions && typeof source[key] === 'function' && source[key] as any).constructor.name === primitive) {

package/src/Extensions/String/index.ts

@@ -1,5 +1 @@
-import * as Case from './case.extension';
-
-export const StringUtils = {
-  ...Case,
-}
+export * from './case.extension';

package/src/Extensions/index.ts

@@ -1,6 +1,6 @@
 export * from './Array';
-export * from './Document';
+export * from './Function';
 export * from './Map';
-export * from './Object';
 export * from './Number';
+export * from './Object';
 export * from './String';

package/src/index.ts

@@ -1,5 +1,4 @@
 export * from './Classes';
 export * from './Extensions';
-export * from './Functions';
 export * from './Interfaces';
 export * from './Types';

package/dist/Extensions/Array.d.ts

@@ -1,52 +0,0 @@
-export type UpdateFinder<T> = (item: T, index: number, self: Array<T>) => boolean;
-declare global {
-    interface Array<T> {
-        /**
-         * Pushes items to array and returns self with new items
-         * @param items Items to add to array
-         */
-        add(...items: Array<T>): this;
-        /**
-         * Update an item in array
-         * @param old The old value or index to update
-         * @param updated Updated value
-         */
-        update(old: T | number | UpdateFinder<T>, updated: T): T;
-        /**
-         * Removes item from array and returns self without item
-         * @param item Item or index to remove
-         */
-        remove(item: T | number): this;
-        /**
-         * Returns a random element from array
-         */
-        random(): T;
-        /**
-         * Returns item matching index. If negative number, subtracts number from length
-         * @param i Index of item
-         */
-        index(i: number): T;
-        /**
-         * For every x in array, execute callback
-         * @param every i.e every 2nd item in array
-         * @param callback Function to execute
-         * @returns Array of results
-         */
-        nth<U>(every: number, callback: (item: T, index: number, collection: Array<T>, self: this) => U): Array<U>;
-    }
-}
-declare function add<T>(this: Array<T>, ...items: Array<T>): T[];
-declare function update<T>(this: Array<T>, old: T | number | UpdateFinder<T>, updated: T): T;
-declare function remove<T>(this: Array<T>, value: T | number): Array<T>;
-declare function random<T>(this: Array<T>): T;
-declare function index<T>(this: Array<T>, i: number): T;
-declare function nth<T, U>(this: Array<T>, every: number, callback: (item: T, index: number, collection: Array<T>, self: Array<T>) => U): Array<U>;
-export declare const ArrayExtensions: {
-    add: typeof add;
-    update: typeof update;
-    remove: typeof remove;
-    random: typeof random;
-    index: typeof index;
-    nth: typeof nth;
-};
-export {};

package/dist/Extensions/Array.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayExtensions = void 0;
-function add(...items) {
-    this.push(...items);
-    return this;
-}
-Array.prototype.add = add;
-function update(old, updated) {
-    const item = typeof old === 'number' ? this[old]
-        : typeof old === 'function' ? this.find(old)
-            : old;
-    if (!item)
-        throw new Error('Old was not found in array!');
-    const index = this.indexOf(item);
-    return this[index] = updated;
-}
-Array.prototype.update = update;
-function remove(value) {
-    const index = typeof value === 'number' ? value : this.indexOf(value);
-    if (index > -1)
-        this.splice(index, 1);
-    return this;
-}
-Array.prototype.remove = remove;
-function random() {
-    const randomIndex = Math.round(Math.random() * this.length);
-    return this[randomIndex];
-}
-Array.prototype.random = random;
-function index(i) {
-    return this[i < 0 ? this.length + i : i];
-}
-Array.prototype.index = index;
-function nth(every, callback) {
-    const result = new Array();
-    let collection = new Array();
-    for (let i = 0; i < this.length; i++) {
-        collection.push(this[i]);
-        if (i % every === 0) {
-            result.push(callback(this[i], i, collection, this));
-            collection = new Array();
-        }
-    }
-    return result;
-}
-Array.prototype.nth = nth;
-exports.ArrayExtensions = {
-    add, update, remove,
-    random, index, nth
-};

package/dist/Extensions/Document.d.ts

@@ -1,27 +0,0 @@
-import { IElement } from "../Types";
-declare global {
-    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
-         * @param children Child elements
-         */
-        createProperElement<Tag extends keyof HTMLElementTagNameMap>(tagName: Tag, options?: Partial<HTMLElementTagNameMap[Tag]>, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
-        createProperElement<Tag extends keyof HTMLElementTagNameMap>(tagName: Tag, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
-        createElementFromString<K extends keyof HTMLElementTagNameMap>(html: string, parentTag?: K): HTMLElementTagNameMap[K];
-    }
-    interface HTMLCollection {
-        /**
-         * Converts HTMLCollection to Element[]
-         */
-        array(): Element[];
-    }
-}
-declare function createElement<Tag extends keyof HTMLElementTagNameMap>(this: Document, tagName: Tag, options?: Partial<HTMLElementTagNameMap[Tag]> | string, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
-declare function createElementFromString<Tag extends keyof HTMLElementTagNameMap>(this: Document, html: string, tag?: Tag): HTMLElementTagNameMap[Tag];
-export declare const DocumentExtensions: {
-    createElement: typeof createElement;
-    createElementFromString: typeof createElementFromString;
-};
-export {};

package/dist/Extensions/Document.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentExtensions = void 0;
-function createElement(tagName, options, ...children) {
-    const element = Object.assign(document.createElement(tagName), typeof options === 'string' ? {} : options);
-    children ??= typeof options === 'string' ? [options] : [];
-    typeof options === 'string' && children.unshift(options);
-    if (!children.length)
-        return element;
-    else if (typeof children === 'string')
-        element.innerHTML = children;
-    else if (children instanceof Array)
-        children.forEach(child => (typeof child === 'string' ?
-            element.innerHTML += child :
-            element.appendChild(child)));
-    else
-        element.appendChild(children);
-    return element;
-}
-Document.prototype.createProperElement = createElement;
-function createElementFromString(html, tag) {
-    if (!html.startsWith(`<${tag}`))
-        html = `<${tag}>${html}</${tag}>`;
-    return new DOMParser().parseFromString(html, 'text/html').body.firstElementChild;
-}
-Document.prototype.createElementFromString = createElementFromString;
-HTMLCollection.prototype.array = function () {
-    return Array.from(this);
-};
-exports.DocumentExtensions = {
-    createElement, createElementFromString
-};