danholibraryjs 1.11.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

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

package/src/Classes/DanhoLogger.ts

@@ -0,0 +1,78 @@
+type LogOptions = {
+  name?: string;
+  color?: string;
+  preferCollapsed?: boolean;
+}
+
+export default class DanhoLogger {
+  public name: string;
+  public color?: string
+  private _preferCollapsed: boolean;
+  
+  constructor(options: LogOptions = {}) {
+    this.name = options.name || 'DanhoLogger';
+    this.color = options.color;
+    this._preferCollapsed = options.preferCollapsed ?? false;
+  }
+
+  private _getPrefix() {
+    return {
+      prefix: `%c[${this.name}]`,
+      style: `color: ${this.color || 'inherit'}; font-weight: bold;`
+    };
+  }
+  private _log(
+    type: 'log' | 'warn' | 'error',
+    ...args: any[]
+  ) {
+    const { prefix, style } = this._getPrefix();
+    console[type](prefix, style, ...args);
+    return this;
+  }
+
+  public log(...args: any[]) {
+    return this._log('log', ...args);
+  }
+  public warn(...args: any[]) {
+    return this._log('warn', ...args);
+  }
+  public error(...args: any[]) {
+    return this._log('error', ...args);
+  }
+
+  public group(...args: any[]) {
+    const { prefix, style } = this._getPrefix();
+
+    const groupMethod = this._preferCollapsed ? console.groupCollapsed : console.group;
+    groupMethod(prefix, style, ...args);
+    
+    return this;
+  }
+  public groupCollapsed(...args: any[]) {
+    const { prefix, style } = this._getPrefix();
+    console.groupCollapsed(prefix, style, ...args);
+    return this;
+  }
+  public groupEnd(...args: any[]) {
+    if (args.length) console.log(...args);
+    console.groupEnd();
+    return this;
+  }
+
+  time(label: string) {
+    const { prefix } = this._getPrefix();
+    console.time(`${prefix} ${label}`);
+    return this;
+  }
+  timeEnd(label: string) {
+    const { prefix } = this._getPrefix();
+    console.timeEnd(`${prefix} ${label}`);
+    return this;
+  }
+
+  table(data: any, columns?: string[]) {
+    this.log();
+    console.table(data, columns);
+    return this;
+  }
+}

package/src/Classes/Events/Event.ts

@@ -4,111 +4,111 @@ import { BaseEvent, EventHandler } from "../../Types/Events";
  * Base event for @see EventEmitter, @borrows EventHandler @borrows BaseEvent
  */
 export class Event<
-    Events extends BaseEvent<string, Array<any>>,
-    Name extends keyof Events = keyof Events,
+  Events extends BaseEvent<string, Array<any>>,
+  Name extends keyof Events = keyof Events,
 > {
-    /**
-     * Base event for @see EventEmitter, @borrows EventHandler
-     * @param name Name of event
-     * @param listeners Listeners/Handlers to execute when emitted
-     */
-    constructor(name: Name, ...listeners: Array<EventHandler<Events, Name>>) {
-        this.name = name;
-        this._listeners = listeners;
-        this._lastEmitted = new Date();
-    }
+  /**
+   * Base event for @see EventEmitter, @borrows EventHandler
+   * @param name Name of event
+   * @param listeners Listeners/Handlers to execute when emitted
+   */
+  constructor(name: Name, ...listeners: Array<EventHandler<Events, Name>>) {
+    this.name = name;
+    this._listeners = listeners;
+    this._lastEmitted = new Date();
+  }
 
-    /**Name of event*/
-    public name: Name;
-    /**Listener limit - default: 0 */
-    public limit = 0;
-    /**Number of times event was emitted - default: 0*/
-    public get runs() {
-        return this._runs
-    }
-    /**Timestamp of last emit - default: null*/
-    public get lastEmitted() {
-        return this._lastEmitted;
-    }
+  /**Name of event*/
+  public name: Name;
+  /**Listener limit - default: 0 */
+  public limit = 0;
+  /**Number of times event was emitted - default: 0*/
+  public get runs() {
+    return this._runs;
+  }
+  /**Timestamp of last emit - default: null*/
+  public get lastEmitted() {
+    return this._lastEmitted;
+  }
 
-    /**@private Internal listeners array*/
-    private _listeners: Array<EventHandler<Events, Name>>;
-    /**@private Internal runs*/
-    private _runs = 0;
-    /**@private Internal lastEmitted*/
-    private _lastEmitted: Date;
+  /**@private Internal listeners array*/
+  private _listeners: Array<EventHandler<Events, Name>>;
+  /**@private Internal runs*/
+  private _runs = 0;
+  /**@private Internal lastEmitted*/
+  private _lastEmitted: Date;
 
-    /**
-     * Emits event and returns array of responses
-     * @param args Arguments required for event listeners
-     * @returns Return values of listeners' returns
-     */
-    public emit(...args: Events[Name]) {
-        this._runs++;
-        this._lastEmitted = new Date();
-        return this._listeners.map(listener => (listener as any)(...args))
+  /**
+   * Emits event and returns array of responses
+   * @param args Arguments required for event listeners
+   * @returns Return values of listeners' returns
+   */
+  public emit(...args: Events[Name]) {
+    this._runs++;
+    this._lastEmitted = new Date();
+    return this._listeners.map(listener => (listener as any)(...args));
+  }
+  /**
+   * Adds listener to listeners array and returns self with new listener added
+   * @param listener Listener to add
+   * @param prepend Add first (true) or last (false) - default: false
+   * @returns this with listener added
+   * 
+   * @throws Limit error, if limit was reached
+   */
+  public on(listener: EventHandler<Events, Name>, prepend = false) {
+    if (this.limit > 0 && this._listeners.length + 1 > this.limit) {
+      throw new Error(`Event limit, ${this.limit}, reached for event ${this.name.toString()}!`);
     }
-    /**
-     * Adds listener to listeners array and returns self with new listener added
-     * @param listener Listener to add
-     * @param prepend Add first (true) or last (false) - default: false
-     * @returns this with listener added
-     * 
-     * @throws Limit error, if limit was reached
-     */
-    public on(listener: EventHandler<Events, Name>, prepend = false) {
-        if (this.limit > 0 && this._listeners.length + 1 > this.limit) {
-            throw new Error(`Event limit, ${this.limit}, reached for event ${this.name.toString()}!`);
-        }
 
-        if (prepend) this._listeners = [listener, ...this._listeners]
-        else this._listeners.add(listener);
+    if (prepend) this._listeners = [listener, ...this._listeners];
+    else this._listeners.add(listener);
 
-        return this;
-    }
-    /**
-     * Like Event#on, adds listener to listeners array and returns self with new listener added, however removes listener once emitted
-     * @param listener Listener to add
-     * @param prepend Add first (true) or last (false) - default: false
-     * @returns this with listener added
-     * 
-     * @throws Limit error, if limit was reached
-     */
-    public once(listener: EventHandler<Events, Name>, prepend = false) {
-        const handler = (...params: Events[Name]) => {
-            const result = (listener as any)(...params);
-            this.off(handler as any);
-            return result;
-        }
-        this.on(handler as any, prepend);
-        return this;
-    }
+    return this;
+  }
+  /**
+   * Like Event#on, adds listener to listeners array and returns self with new listener added, however removes listener once emitted
+   * @param listener Listener to add
+   * @param prepend Add first (true) or last (false) - default: false
+   * @returns this with listener added
+   * 
+   * @throws Limit error, if limit was reached
+   */
+  public once(listener: EventHandler<Events, Name>, prepend = false) {
+    const handler = (...params: Events[Name]) => {
+      const result = (listener as any)(...params);
+      this.off(handler as any);
+      return result;
+    };
+    this.on(handler as any, prepend);
+    return this;
+  }
 
-    /**
-     * Returns true or false, depending if event includes listener
-     * @param listener Listener to test
-     * @returns True of false, depending if event includes listener
-     */
-    public includes(listener: EventHandler<Events, Name>) {
-        return this._listeners.includes(listener);
-    }
+  /**
+   * Returns true or false, depending if event includes listener
+   * @param listener Listener to test
+   * @returns True of false, depending if event includes listener
+   */
+  public includes(listener: EventHandler<Events, Name>) {
+    return this._listeners.includes(listener);
+  }
 
-    /**
-     * Removes listener from internal listeners array
-     * @param listener Listener to remove. If none specified, all will be removed
-     * @param throwNotFoundError Throw error if listener isn't in listeners array - default: false
-     * @returns this, without listener
-     * 
-     * @throws NotFound, if throwNotFoundError is true, and internal listeners array doesn't include listener provided
-     */
-    public off(listener?: EventHandler<Events, Name>, throwNotFoundError = false) {
-        try { 
-            if (!listener) this._listeners = new Array<EventHandler<Events, Name>>()
-            else if (!this._listeners.includes(listener)) return this;
-            else this._listeners.remove(listener);
-         } 
-        catch (err) { if (throwNotFoundError) throw err; }
-        return this;
+  /**
+   * Removes listener from internal listeners array
+   * @param listener Listener to remove. If none specified, all will be removed
+   * @param throwNotFoundError Throw error if listener isn't in listeners array - default: false
+   * @returns this, without listener
+   * 
+   * @throws NotFound, if throwNotFoundError is true, and internal listeners array doesn't include listener provided
+   */
+  public off(listener?: EventHandler<Events, Name>, throwNotFoundError = false) {
+    try {
+      if (!listener) this._listeners = new Array<EventHandler<Events, Name>>();
+      else if (!this._listeners.includes(listener)) return this;
+      else this._listeners.remove(listener);
     }
+    catch (err) { if (throwNotFoundError) throw err; }
+    return this;
+  }
 }
 export default Event;