danholibraryjs 1.3.0 → 1.7.0

package/docs/Types.md

@@ -0,0 +1,129 @@
+# [DanhoLibraryJS](../README.md)
+
+## Types
+
+### General
+
+``` ts
+/**
+ * Type's properties are ReturnType
+ */
+export type AllPropsAre<ReturnType> = {
+    [key: string]: ReturnType
+}
+
+/**
+ * Item is single or multiple
+ */
+export type Arrayable<T> = T | Array<T>;
+
+/**
+ * Used for HTMLElement.append in ElementOptions, Document.createProperElement.
+ * IElement accepts HTML Elements or HTMl-like strings.
+ * 
+ * @see HTMLElement.append
+ * @see Document.createProperElement
+ */
+export type IElement = HTMLElement | string;
+
+/**
+ * string or RegExp.. pretty self-explanatory
+ */
+export type StringRegex = string | RegExp;
+
+/**
+ * Return types of T
+ */
+export type ValueOf<T> = T[keyof T];
+```
+
+### BetterTypes
+
+```ts
+/**
+ * Construct a type with the properties of Type except for those in type Properties.
+ */
+export type BetterOmit<Type, Properties extends keyof Type> = Omit<Type, Properties>;
+/**
+ * Extract from From those types that are assignable to Properties
+ */
+export type BetterExtract<From, Properties extends From> = Extract<From, Properties>;
+```
+
+### Events
+
+```ts
+/**
+ * Default eventhandler mapper. Object with properties that are arrays
+ */
+ export type BaseEvent<Keys extends string, Types extends Array<any>> = Record<Keys, Types>;
+
+ /**
+  * Eventhandler type for:
+  * @see EventCollection
+  * @borrows BaseEvent
+  */
+ export 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
+
+```ts
+/**
+ * Filters all properties from From that has the return type of Type
+ */
+export type PropertiesWith<Type, From> = {
+    [Key in keyof From as From[Key] extends Type ? Key : never]: From[Key]
+}
+export default PropertiesWith;
+
+/**
+ * Fitlers all properties from From that don't have the return type of Type
+ */
+export type PropertiesWithout<Type, From> = {
+    [Key in keyof From as From[Key] extends Type ? never : Key]: From[Key]
+}
+```
+
+### Time
+
+```ts
+/**
+ * Type used to construct DanhoDate.
+ * @Data Partial TimeProperties except years & months
+ * @DateFormat string as dd/MM/yyyy
+ */
+export type DanhoDateConstructor = Data | DateFormat | number | Date;
+
+/**
+ * Object interface with keys above to number values. If Plural is true, all properties ends with 's'
+ */
+export type TimeProperties<Plural extends boolean = false> = Record<Plural extends true ? `${TimeKeys}s` : TimeKeys, number>
+
+/**
+ * What properties to include when using TimeSpan.toString(format: TimeSpanFormat): string
+ */
+export type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number, boolean>>
+```
+
+### TransformTypes
+
+```ts
+/**
+ * Converts Start types to Switch types in From type
+ */
+export type TransformType<From, Start, Switch> = {
+    [Key in keyof From]: From[Key] extends Start ? Switch : From[Key]
+}
+
+/**
+ * Returns object with properties matching BaseType with types of NewType
+ */
+export type TransformTypes<From, BaseType, NewType> = Record<keyof { 
+    [Key in keyof From as From[Key] extends BaseType ? Key : never]: Key 
+}, NewType>
+```

package/docs/index.md

@@ -0,0 +1,29 @@
+# [DanhoLibraryJS](../README.md)
+
+[By DanielSimonsen90 // Danhosaur](https://github.com/DanielSimonsen90)
+
+## Installation
+
+### Vanilla
+
+```html
+<script src="https://cdn.jsdelivr.net/gh/DanielSimonsen90/DanhoLibraryJS@latest/dist/index.js"></script>
+```
+
+### Node
+
+```cmd
+npm install danholibraryjs
+```
+
+```js
+import { ... } from 'DanhoLibraryJS';
+```
+
+## Documentation
+
+* [Classes](./Classes.md)
+* [Extensions](./Extensions.md)
+* [Functions](./Functions.md)
+* [Interfaces](./Interfaces.md)
+* [Types](./Types.md)

package/package.json

@@ -1,21 +1,22 @@
-{
-  "name": "danholibraryjs",
-  "version": "1.3.0",
-  "description": "Library for Javascript.",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/DanielSimonsen90/DanhoLibraryJS.git"
-  },
-  "keywords": ["library", "javascript"],
-  "author": "DanielSimonsen90 | Danhosaur | Daniel Simonsen",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/DanielSimonsen90/DanhoLibraryJS/issues"
-  },
-  "homepage": "https://github.com/DanielSimonsen90/DanhoLibraryJS#readme"
-}
+{
+  "name": "danholibraryjs",
+  "version": "1.7.0",
+  "description": "Library for Javascript.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "npx tsc --project tsconfig.json",
+    "build-watch": "npx tsc --project tsconfig.json --watch true"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DanielSimonsen90/DanhoLibraryJS.git"
+  },
+  "keywords": ["library", "javascript"],
+  "author": "DanielSimonsen90 | Danhosaur | Daniel Simonsen",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/DanielSimonsen90/DanhoLibraryJS/issues"
+  },
+  "homepage": "https://github.com/DanielSimonsen90/DanhoLibraryJS#readme"
+}

package/src/Classes/{Event.ts → Events/Event.ts}

@@ -1,19 +1,25 @@
-import EventHandler from "../Types/EventHandler";
+import { BaseEvent, EventHandler } from "../../Types/Events";
 
-/**Base event for @see EventEmitter, @borrows EventHandler*/
-export default class Event<ReturnType = any> {
+/**
+ * Base event for @see EventEmitter, @borrows EventHandler @borrows BaseEvent
+ */
+export class Event<
+    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: string, ...listeners: Array<EventHandler<ReturnType>>) {
+    constructor(name: Name, ...listeners: Array<EventHandler<Events, Name>>) {
         this.name = name;
         this._listeners = listeners;
+        this._lastEmitted = new Date();
     }
 
     /**Name of event*/
-    public name: string;
+    public name: Name;
     /**Listener limit - default: 0 */
     public limit = 0;
     /**Number of times event was emitted - default: 0*/
@@ -26,21 +32,21 @@ export default class Event<ReturnType = any> {
     }
 
     /**@private Internal listeners array*/
-    private _listeners: Array<EventHandler<ReturnType>>;
+    private _listeners: Array<EventHandler<Events, Name>>;
     /**@private Internal runs*/
     private _runs = 0;
     /**@private Internal lastEmitted*/
-    private _lastEmitted: Date = null;
+    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: any[]) {
+    public emit(...args: Events[Name]) {
         this._runs++;
         this._lastEmitted = new Date();
-        return this._listeners.map(listener => listener(...args))
+        return this._listeners.map(listener => (listener as any)(...args))
     }
     /**
      * Adds listener to listeners array and returns self with new listener added
@@ -50,7 +56,7 @@ export default class Event<ReturnType = any> {
      * 
      * @throws Limit error, if limit was reached
      */
-    public on(listener: EventHandler<ReturnType>, prepend = false) {
+    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}!`);
         }
@@ -68,13 +74,13 @@ export default class Event<ReturnType = any> {
      * 
      * @throws Limit error, if limit was reached
      */
-    public once(listener: EventHandler<ReturnType>, prepend = false) {
-        const handler = (...args: any[]) => {
-            const result = listener(...args);
-            this.off(handler);
+    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, prepend);
+        this.on(handler as any, prepend);
         return this;
     }
 
@@ -83,21 +89,26 @@ export default class Event<ReturnType = any> {
      * @param listener Listener to test
      * @returns True of false, depending if event includes listener
      */
-    public includes(listener: EventHandler<ReturnType>) {
+    public includes(listener: EventHandler<Events, Name>) {
         return this._listeners.includes(listener);
     }
 
     /**
      * Removes listener from internal listeners array
-     * @param listener Listener to remove
+     * @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<ReturnType>, throwNotFoundError = false) {
-        try { this._listeners.remove(listener); } 
+    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;

package/src/Classes/Events/EventCollection.ts

@@ -0,0 +1,109 @@
+import { BaseEvent, EventHandler } from "../../Types/Events";
+import Event from './Event';
+
+/**
+ * Collection of Events from @see EventEmitter
+ * @borrows EventHandler
+ * @borrows Event
+ * @borrows BaseEvent
+ */
+ export class EventCollection<Events extends BaseEvent<string, Array<any>>> {
+    constructor(events?: Map<keyof Events, EventHandler<Events>>) {
+        this._events = !events ? 
+            new Map<keyof Events, Event<Events>>() : 
+            events.array().reduce((result, [event, handlers]) => 
+                result.set(event, new Event<Events>(event, handlers)), 
+            new Map<keyof Events, Event<Events>>());
+    }
+
+    /**Amount of events stored*/
+    public get size() {
+        return this._events.size;
+    }
+    /**@private Internal event collection*/
+    private _events = new Map<keyof Events, Event<Events>>();
+    /**@private limit of events*/
+    private _limit = 0;
+    
+    /**
+     * Returns true if event is in collection
+     * @param event Event name
+     * @returns true if event is in collection
+     */
+    public has<EventName extends keyof Events>(event: EventName): boolean { 
+        return this._events.has(event); 
+    }
+    /**
+     * Returns event matching event parameter
+     * @param event Event name
+     * @returns Event
+     */
+    public get<EventName extends keyof Events>(event: EventName): Event<Events, EventName> { 
+        return this._events.get(event) as any; 
+    }
+    /**
+     * Adds handler to event collection with name as key
+     * @param name Event name
+     * @param handler Handler for event
+     * @returns this
+     */
+    public add<EventName extends keyof Events>(name: EventName, handler: EventHandler<Events, keyof Events>, once = false): this {
+        if (this._limit > 0 && this._limit + 1 > this._events.size) {
+            throw new Error(`Listener limit, ${this._limit}, reached!`);
+        }
+
+        const event = (this.has(name) && this.get(name)) || new Event(name);
+        this._events.set(name, event.on(handler, once) as any); 
+        return this;
+    }
+    /**
+     * @summary clear(): Clears all events
+     * @summary clear("all", myEventHandler): Removes myEventHandler from all events that have it
+     * @summary clear("myEvent"): Clears all handlers tied to "myEvent"
+     * @summary clear("myEvent", myEventHandler): Removes myEventHandler from "myEvent"
+     * 
+     * @param name Event name | "all"
+     * @param handler Specific handler to remove. If left blank, all handlers in name will be removed
+     * @returns this
+     */
+    public clear<EventName extends keyof Events>(name: EventName | 'all' = 'all', handler?: EventHandler): this {
+        const _name = name as string;
+
+        if (_name.toLowerCase() == 'all' && handler == null) this._events.clear();                                      //clear(): Clears all events
+        else if (_name.toLowerCase() == 'all' && handler) this._events = (() => {                                       //clear("all", myEventHandler): Removes the "myEventHandler" handler from all events
+            this._events.forEach(e => e.off(handler))
+            return this._events;
+        })();
+        else if (_name.toLowerCase() != "all" && handler == null) this._events.delete(name);                            //clear("myEvent"): Clears All handlers tied to "myEvent"
+        else if (_name.toLowerCase() != 'all' && handler) this._events.set(name, this._events.get(name)!.off(handler));  //clear("myEvent", myEventHandler): Removes the "myEventsHandler" handler from "myEvent"
+        return this;
+    }
+
+    public emit<Event extends keyof Events>(name: Event, ...args: Events[Event]) {
+        return this.get(name)?.emit(...args);
+    }
+
+    /**
+     * Limits how many events to accept using EventEmitter#on or EventEmitter#once
+     * @param limit Limit of events to keep
+     * @returns this with the new limit
+     * 
+     * @throws Unknown event, if event name isn't recognized
+     */
+     public limit<Event extends keyof Events>(eventName: 'all' | Event, limit: number) {
+        if (limit <= 0) return;
+        
+        if (eventName == 'all') {
+            this._limit = limit;
+            return this;
+        }
+        
+        const event = this.get(eventName);
+        if (!event) throw new Error(`Unknown event, ${eventName}!`);
+
+        event.limit = limit;
+        this._events.set(eventName, event as any);
+        return this;
+    }
+}
+export default EventCollection;

package/src/Classes/{EventEmitter.ts → Events/EventEmitter.ts}

@@ -1,17 +1,20 @@
 import EventCollection from "./EventCollection";
-import EventHandler from "../Types/EventHandler";
+import { BaseEvent, EventHandler } from '../../Types';
 
 /**
  * Traditional Node.js EventEmitter for vanilla JavaScript
+ * @borrows EventCollection
+ * @borrows BaseEvent
+ * @borrows EventHandler
  */
-export class EventEmitter {
+export class EventEmitter<Events extends BaseEvent<string, Array<any>>> {
     /**@param events Map<name: string, handlers: EventHandler[]>*/
-    constructor(events?: Map<string, EventHandler[]>) {
+    constructor(events?: Map<keyof Events, EventHandler<Events>>) {
         this._events = new EventCollection(events);
     }
 
     /**@private Internal event collection*/
-    private _events = new EventCollection();
+    private _events = new EventCollection<Events>();
     
     /**
      * Adds listener to event collection, and runs listener when event is emitted
@@ -19,8 +22,8 @@ export class EventEmitter {
      * @param listener Callback function to run, when event occurs
      * @returns this
      */
-    public on<ReturnType = any>(event: string, listener: EventHandler<ReturnType>): this {
-        this._events.add(event, listener);
+    public on<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): this {
+        this._events.add(event, listener as any);
         return this;
     }
     /**
@@ -29,8 +32,8 @@ export class EventEmitter {
      * @param listener Callback function to run, when event occurs
      * @returns this
      */
-    public once<ReturnType = any>(event: string, listener: EventHandler<ReturnType>): this {
-        this._events.add(event, listener, true);
+    public once<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): this {
+        this._events.add(event, listener as any, true);
         return this;
     }
 
@@ -40,7 +43,7 @@ export class EventEmitter {
      * @param listener If left null, removes all listeners tied to event, else only removes listener from event
      * @returns this
      */
-    public off<ReturnType = any>(event: string = "all", listener?: EventHandler<ReturnType>): this {
+    public off<Return extends any, Event extends keyof Events>(event: Event | 'all' = "all", listener?: EventHandler<Events, Event, Return>): this {
         this._events.clear(event, listener);
         return this;
     }
@@ -52,8 +55,8 @@ export class EventEmitter {
      * @fires event
      * @returns Array of listeners' reponses
      */
-    public emit<ReturnType = any>(event: string, ...args: any[]): ReturnType[] {
-        return this._events.emit(event, ...args);
+    public emit<Return extends any, Event extends keyof Events>(event: Event, ...args: Events[Event]): Array<Return> {
+        return this._events.emit(event, ...args) as Array<Return>;
     }
 
     /**
@@ -62,8 +65,8 @@ export class EventEmitter {
      * @param limit Limit of events to keep. If you want to limit amount of events saved, use 'all'.
      * @returns this with the new limit
      */
-    public limit(event: 'all' | string, limit: number) {
-        this._events.limit(event, limit);
+    public limit<Event extends keyof Events>(event: 'all' | Event, limit: number) {
+        this._events.limit<Event>(event, limit);
         return this;
     }
 }

package/src/Classes/Events/index.ts

@@ -0,0 +1,3 @@
+export * from './Event';
+export * from './EventCollection';
+export * from './EventEmitter';