danholibraryjs 1.5.0 → 1.8.0

package/docs/Interfaces.md

@@ -0,0 +1,34 @@
+# [DanhoLibraryJS](../README.md)
+
+## Interfaces
+
+```ts
+/**
+ * Construction options when creating an HTML element using:
+ * @see Document.createProperElement 
+ * @borrows IElement
+ * @borrows Arrayable
+ */
+interface ElementOptions<K extends keyof HTMLElementTagNameMap> {
+    /**css classes to give the element*/
+    classes?: Array<string>;
+    /**attributes to give the element*/
+    attributes?: Array<[string, string]>;
+    /**Children of the element*/
+    children?: Arrayable<IElement>;
+    /**Events for the element to listen to
+     * @use HTMLEvent<Event, RetrunType>(name: Event, handler: (e: Event) => ReturnType)
+    */
+    events?: Array<{ name: string, handler: (e: Event) => any }>
+}
+/**
+ * Replacement tool for 
+ * @see String.toSnakeCase 
+ * @see String.toKebabCase
+ * @borrows StringRegex
+*/
+interface IReplacement {
+    replacer?: StringRegex,
+    replacement?: string
+}
+```

package/docs/Types.md

@@ -0,0 +1,137 @@
+# [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>
+```
+
+### Store
+```ts
+/**
+ * Reducer function to map wanted parameters when using @see Store.on(action, reducer);
+ */
+export type Reducer<State, Types extends Record<string, any[]>, Action extends keyof Types> = (state: State, ...args: Types[Action]) => State
+```

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.5.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.8.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,11 +1,11 @@
-import BaseEvent from "../Interfaces/BaseEventInterface";
-import EventHandler from "../Types/EventHandler";
+import { BaseEvent, EventHandler } from "../../Types/Events";
 
-/**Base event for @see EventEmitter, @borrows EventHandler*/
+/**
+ * Base event for @see EventEmitter, @borrows EventHandler @borrows BaseEvent
+ */
 export class Event<
-    Events extends BaseEvent,
+    Events extends BaseEvent<string, Array<any>>,
     Name extends keyof Events = keyof Events,
-    Params = Events[Name],
 > {
     /**
      * Base event for @see EventEmitter, @borrows EventHandler
@@ -15,6 +15,7 @@ export class Event<
     constructor(name: Name, ...listeners: Array<EventHandler<Events, Name>>) {
         this.name = name;
         this._listeners = listeners;
+        this._lastEmitted = new Date();
     }
 
     /**Name of event*/
@@ -35,17 +36,17 @@ export class Event<
     /**@private Internal runs*/
     private _runs = 0;
     /**@private Internal lastEmitted*/
-    private _lastEmitted: Date = null;
+    private _lastEmitted: Date;
 
     /**
      * Emits event and returns array of responses
-     * @param params Arguments required for event listeners
+     * @param args Arguments required for event listeners
      * @returns Return values of listeners' returns
      */
-    public emit(params: Params) {
+    public emit(...args: Events[Name]) {
         this._runs++;
         this._lastEmitted = new Date();
-        return this._listeners.map(listener => (listener as any)(params))
+        return this._listeners.map(listener => (listener as any)(...args))
     }
     /**
      * Adds listener to listeners array and returns self with new listener added
@@ -74,8 +75,8 @@ export class Event<
      * @throws Limit error, if limit was reached
      */
     public once(listener: EventHandler<Events, Name>, prepend = false) {
-        const handler = (params: Params) => {
-            const result = (listener as any)(params);
+        const handler = (...params: Events[Name]) => {
+            const result = (listener as any)(...params);
             this.off(handler as any);
             return result;
         }
@@ -94,14 +95,18 @@ export class Event<
 
     /**
      * 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<Events, Name>, 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;
     }

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,13 +1,39 @@
 import EventCollection from "./EventCollection";
-import BaseEvent from '../Interfaces/BaseEventInterface';
-import EventHandler from '../Types/EventHandler';
+import { BaseEvent, EventHandler } from '../../Types';
 
 /**
  * Traditional Node.js EventEmitter for vanilla JavaScript
+ * @borrows EventCollection
+ * @borrows BaseEvent
+ * @borrows EventHandler
+ * 
+ * @example ```ts
+ * import { EventEmitter } from 'danholibraryjs';
+ * 
+ * type EventTypes = {
+ *  create: [username: string, password: string],
+ *  update: [id: string, user: User],
+ *  delete: [id: string, reason?: string],
+ * }
+ * 
+ * const emitter = new EventEmitter<EventTypes>(new Map([
+ *  ['create', (username, password) => {
+ *     return { username, password };
+ *  }],
+ *  ['update', (id, user) => {
+ *    return { id, ...user };
+ *  }]
+ * ]));
+ * 
+ * const onDelete = (id: string, reason?: string) => console.log(`User ${id} was deleted because ${reason}`);
+ * emitter.on('delete', onDelete);
+ * emitter.emit('delete', '1', 'No longer needed');
+ * emitter.off('delete', onDelete);
+ * ```
  */
-export class EventEmitter<Events extends BaseEvent> {
+export class EventEmitter<Events extends BaseEvent<string, Array<any>>> {
     /**@param events Map<name: string, handlers: EventHandler[]>*/
-    constructor(events?: Map<keyof Events, EventHandler<Events, keyof Events>[]>) {
+    constructor(events?: Map<keyof Events, EventHandler<Events>>) {
         this._events = new EventCollection(events);
     }
 
@@ -21,7 +47,7 @@ export class EventEmitter<Events extends BaseEvent> {
      * @returns this
      */
     public on<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): this {
-        this._events.add(event, listener);
+        this._events.add(event, listener as any);
         return this;
     }
     /**
@@ -30,8 +56,8 @@ export class EventEmitter<Events extends BaseEvent> {
      * @param listener Callback function to run, when event occurs
      * @returns this
      */
-    public once<Return extends any, Event extends keyof Events>(event: keyof Events, listener: EventHandler<Events, Event, Return>): 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;
     }
 
@@ -41,8 +67,8 @@ export class EventEmitter<Events extends BaseEvent> {
      * @param listener If left null, removes all listeners tied to event, else only removes listener from event
      * @returns this
      */
-    public off<Event extends keyof Events>(event: Event | string = "all", listener?: EventHandler<Events, Event>): this {
-        this._events.clear(event as any, listener);
+    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;
     }
 
@@ -53,8 +79,8 @@ export class EventEmitter<Events extends BaseEvent> {
      * @fires event
      * @returns Array of listeners' reponses
      */
-    public emit<ReturnType extends any, Event extends keyof Events>(event: Event, args: Events[Event]): ReturnType[] {
-        return this._events.emit(event as any, 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>;
     }
 
     /**

package/src/Classes/Events/index.ts

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