danholibraryjs 1.7.0 → 1.10.0

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "danholibraryjs",
-  "version": "1.7.0",
+  
+  "version": "1.10.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"
+    "build-watch": "npx tsc --project tsconfig.json --watch true",
+    "login-github": "npm login --scope=@DanielSimonsen90 --registry=https://npm.pkg.github.com",
+    "login-npm": "npm login --scope@danhosaur --registry=https://registry.npmjs.org"
   },
   "repository": {
     "type": "git",
@@ -19,4 +22,4 @@
     "url": "https://github.com/DanielSimonsen90/DanhoLibraryJS/issues"
   },
   "homepage": "https://github.com/DanielSimonsen90/DanhoLibraryJS#readme"
-}
+}

package/src/Classes/Events/Event.ts

@@ -58,7 +58,7 @@ export class Event<
      */
     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}!`);
+            throw new Error(`Event limit, ${this.limit}, reached for event ${this.name.toString()}!`);
         }
 
         if (prepend) this._listeners = [listener, ...this._listeners]

package/src/Classes/Events/EventCollection.ts

@@ -99,7 +99,7 @@ import Event from './Event';
         }
         
         const event = this.get(eventName);
-        if (!event) throw new Error(`Unknown event, ${eventName}!`);
+        if (!event) throw new Error(`Unknown event, ${eventName.toString()}!`);
 
         event.limit = limit;
         this._events.set(eventName, event as any);

package/src/Classes/Events/EventEmitter.ts

@@ -6,6 +6,30 @@ import { BaseEvent, EventHandler } from '../../Types';
  * @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<string, Array<any>>> {
     /**@param events Map<name: string, handlers: EventHandler[]>*/
@@ -22,7 +46,10 @@ export class EventEmitter<Events extends BaseEvent<string, Array<any>>> {
      * @param listener Callback function to run, when event occurs
      * @returns this
      */
-    public on<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): this {
+    public on<Return extends any, Event extends keyof Events>(
+        event: Event, 
+        listener: EventHandler<Events, Event, Return>
+    ): EventEmitter<Events> {
         this._events.add(event, listener as any);
         return this;
     }
@@ -32,7 +59,10 @@ export class EventEmitter<Events extends BaseEvent<string, Array<any>>> {
      * @param listener Callback function to run, when event occurs
      * @returns this
      */
-    public once<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): this {
+    public once<Return extends any, Event extends keyof Events>(
+        event: Event, 
+        listener: EventHandler<Events, Event, Return>
+    ): EventEmitter<Events> {
         this._events.add(event, listener as any, true);
         return this;
     }
@@ -43,7 +73,10 @@ export class EventEmitter<Events extends BaseEvent<string, Array<any>>> {
      * @param listener If left null, removes all listeners tied to event, else only removes listener from event
      * @returns this
      */
-    public off<Return extends any, Event extends keyof Events>(event: Event | 'all' = "all", listener?: EventHandler<Events, Event, Return>): this {
+    public off<Return extends any, Event extends keyof Events>(
+        event: Event | 'all' = "all", 
+        listener?: EventHandler<Events, Event, Return>
+    ): EventEmitter<Events> {
         this._events.clear(event, listener);
         return this;
     }
@@ -55,7 +88,9 @@ export class EventEmitter<Events extends BaseEvent<string, Array<any>>> {
      * @fires event
      * @returns Array of listeners' reponses
      */
-    public emit<Return extends any, Event extends keyof Events>(event: Event, ...args: Events[Event]): Array<Return> {
+    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>;
     }
 
@@ -65,7 +100,7 @@ export class EventEmitter<Events extends BaseEvent<string, Array<any>>> {
      * @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 extends keyof Events>(event: 'all' | Event, limit: number) {
+    public limit<Event extends keyof Events>(event: 'all' | Event, limit: number): EventEmitter<Events> {
         this._events.limit<Event>(event, limit);
         return this;
     }

package/src/Classes/index.ts

@@ -1,2 +1,3 @@
 export * from './Events';
-export * from './Time';
+export * from './Time';
+export * from './store';

package/src/Classes/store.ts

@@ -0,0 +1,98 @@
+import { Arrayable, TransformType } from "../Types";
+import { EventEmitter } from "./Events";
+
+export type Reducer<State, Types extends Record<string, any[]>, Action extends keyof Types> = (state: State, ...args: Types[Action]) => State
+export type Actions<State, ActionTypes extends Record<string, any[]>> = { 
+    [Action in keyof ActionTypes]?: Arrayable<Reducer<State, ActionTypes, Action>> 
+};
+
+/**
+ * EventEmitter, but it stores state and handles state change with reducers
+ * 
+ * @Initialization Actions & initial state must be defined in type parameters. InitialState must be provided in constructor, whereas reducer is optional.
+ * The ActionType must have properties as strings and values as arrays.
+ * 
+ * @HandlingActions Reducers can be added through constructor or using Store.on('action', reducer) or Store.once('action', reducer).
+ * Every state change must return the next state, apart from 'stateChange', which returns void/any
+ * Emit/Dispatch an action using Store.dispatch('action', ...args), ...args being the parameters from the ActionType. 
+ * Store.emit should NOT be used, as it doesn't update the Store's state.
+ * 
+ * Reducer functions can be removed using Store.off('action', reducer);
+ * 
+ * @borrows EventEmitter
+ * @borrows Arrayable
+ * 
+ * @example ```ts
+ * import { Store } from 'danholibraryjs';
+ * 
+ * type Todo = {
+ *    id: string,
+ *    text: string,
+ *    completed: boolean
+ * }
+ * 
+ * type TodoActions = {
+ *    create: [text: string],
+ *    update: [id: string, text: string],
+ *    toggleComplete: [id: string, force?: boolean],
+ *    delete: [id: string],
+ * }
+ * 
+ * const store = new Store<Array<Todo>, TodoActions>(new Array<Todo>(), new Map([
+ *    create: (state, text) => {
+ *       return [...state, { 
+ *          id: Math.random().toString(), 
+ *          text, 
+ *          completed: false 
+ *      }];
+ *    },
+ *   toggleComplete: (state, id, force) => {
+ *      const todo = state.find(todo => todo.id === id);
+ *      if (!todo) return state;
+ * 
+ *      return state.map(todo => (
+ *          todo.id === id ? { 
+ *              ...todo, 
+ *              completed: force === undefined ? !todo.completed : force 
+ *          } : todo
+ *      ));
+ *   }
+ * ]));
+ * 
+ * store.on('delete', (state, id) => {
+ *     return state.filter(todo => todo.id !== id);
+ * });
+ * 
+ * store.on('stateChange', (prevState, currentState) => console.log('State change', prevState, currentState));
+ * 
+ * store.dispatch('create', 'Make store!');
+ * 
+ * ```
+ */
+export class Store<
+    State extends object,
+    ActionTypes extends Record<string, any[]>,
+    StoreActions extends Actions<State, ActionTypes> = Actions<State, ActionTypes>
+> extends EventEmitter<
+    Record<keyof StoreActions, ActionTypes[keyof ActionTypes]> 
+    & Record<'stateChange', [previous: State, current: State]>
+> {
+    constructor(state: State, actions: StoreActions = {} as StoreActions) {
+        super(new Map(...Object.entries(actions).map(([action, reducers]) => [action, reducers as any])));
+
+        this._state = state;
+    }
+
+    private _state: State;
+    public get state(): State {
+        return this._state;
+    }
+
+    public dispatch<Action extends keyof ActionTypes>(action: Action, ...args: ActionTypes[Action]): State {
+        const previous = { ...this._state };
+        this._state = super.emit<State, Action>(action, ...args as any).reduce((state, returned) => ({ ...state, ...returned }), this.state);
+
+        super.emit<void, 'stateChange'>('stateChange', ...[previous, this.state] as any);
+        return this.state;
+    }
+}

package/src/Extensions/Array.ts

@@ -1,6 +1,4 @@
-export {};
-
-type UpdateFinder<T> = (item: T, index: number, self: Array<T>) => boolean
+export type UpdateFinder<T> = (item: T, index: number, self: Array<T>) => boolean
 
 declare global {
     interface Array<T> {
@@ -28,30 +26,70 @@ declare global {
          * Returns item matching index. If negative number, subtracts number from length
          * @param i Index of item
          */
-        index(i: number): T
+        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>
     }
 }
 
-Array.prototype.add = function<T>(this: Array<T>, ...items: Array<T>) {
+function add<T>(this: Array<T>, ...items: Array<T>) {
     this.push(...items);
     return this;
 }
-Array.prototype.update = function<T>(this: Array<T>, old: T | number | UpdateFinder<T>, updated: T) {
-    const item = typeof old === 'number' ? this[old] : typeof old === 'function' ? this.find(old as UpdateFinder<T>) : old;
+Array.prototype.add = add;
+
+function update<T>(this: Array<T>, old: T | number | UpdateFinder<T>, updated: T) {
+    const item = typeof old === 'number' ? this[old] 
+        : typeof old === 'function' ? this.find(old as UpdateFinder<T>) 
+        : old;
     if (!item) throw new Error('Old was not found in array!');
 
     const index = this.indexOf(item);
     return this[index] = updated;
 }
-Array.prototype.remove = function<T>(this: Array<T>, value: T | number): Array<T> {
+Array.prototype.update = update;
+
+function remove<T>(this: Array<T>, value: T | number): Array<T> {
     const index = typeof value === 'number' ? value : this.indexOf(value);
     if (index > -1) this.splice(index, 1);
     return this;
 }
-Array.prototype.random = function<T>(this: Array<T>): T {
+Array.prototype.remove = remove;
+
+function random<T>(this: Array<T>): T {
     const randomIndex = Math.round(Math.random() * this.length);
     return this[randomIndex];
 }
-Array.prototype.index = function<T>(this: Array<T>, i: number): T {
+Array.prototype.random = random;
+
+function index<T>(this: Array<T>, i: number): T {
     return this[i < 0 ? this.length + i : i];
-}
+}
+Array.prototype.index = index;
+
+function nth<T, U>(this: Array<T>, every: number, callback: (item: T, index: number, collection: Array<T>, self: Array<T>) => U): Array<U> {
+    const result = new Array<U>();
+    let collection = new Array<T>();
+
+    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<T>();
+        }
+    }
+
+    return result;
+}
+Array.prototype.nth = nth;
+
+export const ArrayExtensions = {
+    add, update, remove, 
+    random, index, nth
+};

package/src/Extensions/Document.ts

@@ -0,0 +1,58 @@
+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[]
+    }
+}
+
+function createElement<Tag extends keyof HTMLElementTagNameMap>(
+    this: Document, tagName: Tag, 
+    options?: Partial<HTMLElementTagNameMap[Tag]> | string, 
+    ...children: Array<IElement>
+): HTMLElementTagNameMap[Tag] {
+    
+    const element = Object.assign(document.createElement(tagName), typeof options === 'string' ? {} : options);
+    children ??= typeof options === 'string' ? [options] as Array<IElement> : [];
+    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<Tag extends keyof HTMLElementTagNameMap>(this: Document, html: string, tag?: Tag): HTMLElementTagNameMap[Tag] {
+    if (!html.startsWith(`<${tag}`)) html = `<${tag}>${html}</${tag}>`;
+    return new DOMParser().parseFromString(html, 'text/html').body.firstElementChild as HTMLElementTagNameMap[Tag];
+}
+Document.prototype.createElementFromString = createElementFromString;
+
+HTMLCollection.prototype.array = function(this: HTMLCollection) {
+    return Array.from(this);
+};
+
+export const DocumentExtensions = {
+    createElement, createElementFromString
+};

package/src/Extensions/Function.ts

@@ -0,0 +1,18 @@
+declare global {
+    interface Function {
+        /**
+         * Checks if obj is a function
+         * @param obj Object to check
+         */
+        is(obj: any): obj is Function;
+    }
+}
+
+function is(obj: any): obj is Function {
+    return typeof obj === 'function';
+}
+Function.is = is;
+
+export const FunctionExtensions = {
+    is
+};

package/src/Extensions/Map.ts

@@ -1,5 +1,3 @@
-export {}
-
 declare global {
     interface Map<K, V> {
         /**
@@ -38,36 +36,53 @@ declare global {
     }
 }
 
-Map.prototype.array = function<K, V>(this: Map<K, V>): Array<[K, V]> {
+function array<K, V>(this: Map<K, V>): Array<[K, V]> {
     let result = new Array<[K, V]>();
     for (const kvp of this) {
         result.push(kvp);
     }
     return result;
 }
-Map.prototype.map = function<K, V, EK, EV>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => [EK, EV]): Map<EK, EV> {
+Map.prototype.array = array;
+
+function map<K, V, EK, EV>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => [EK, EV]): Map<EK, EV> {
     return this.array()
         .map(([k, v], i) => callback(v, k, i, this))
         .reduce((map, [key, value]) => 
             map.set(key, value), 
         new Map<EK, EV>())
 }
-Map.prototype.filter = function<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean): Map<K, V> {
+Map.prototype.map = map;
+
+function filter<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean): Map<K, V> {
     return this.array()
         .filter(([k, v], i) => callback(v, k, i, this))
         .reduce((map, [key, value]) => 
             map.set(key, value), 
         new Map<K, V>())
 }
-Map.prototype.keyArr = function<K, V>(this: Map<K, V>): Array<K> {
+Map.prototype.filter = filter;
+
+function keyArr<K, V>(this: Map<K, V>): Array<K> {
     return this.array().map(([k]) => k);
 }
-Map.prototype.valueArr = function<K, V>(this: Map<K, V>): Array<V> {
+Map.prototype.keyArr = keyArr;
+
+function valueArr<K, V>(this: Map<K, V>): Array<V> {
     return this.array().map(([_, v]) => v);
 }
-Map.prototype.find = function<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean) {
+Map.prototype.valueArr = valueArr;
+
+function find<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean) {
     return this.array().find(([k, v], i) => callback(v, k, i, this));
 }
-Map.prototype.includes = function<K, V>(this: Map<K, V>, item: V, fromIndex?: number) {
+Map.prototype.find = find;
+
+function includes<K, V>(this: Map<K, V>, item: V, fromIndex?: number) {
     return this.valueArr().includes(item, fromIndex);
+}
+Map.prototype.includes = includes;
+
+export const MapExtensions = {
+    array, map, filter, keyArr, valueArr, find, includes
 }

package/src/Extensions/Object/index.ts

@@ -0,0 +1,82 @@
+import { ValueOf } from "../../Types";
+import { Properties, properties } from "./properties";
+
+declare global {
+    interface ObjectConstructor {
+        /**
+         * Destructures object into array of [property, value]
+         * @param from Object to destruct
+         */
+        array<From extends {} = {}>(from: From): Array<[keyof From, ValueOf<From>]>
+
+        /**
+         * Omits properties from object, but for some reason the correct term is "extract"
+         * @param from Object to extract properties from
+         * @param props Properties to extract/Omit
+         */
+        extract<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props>
+
+        /**
+         * Pick properties from object, but for some reason the correct term is "exclude"
+         * @param from Object to exclude properties from
+         * @param props Properties to exclude/pick
+         */
+        exclude<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props>
+
+        /**
+         * Returns true if object is empty
+         * @param obj Object to check
+         */
+        isNullOrUndefined(obj: any): obj is null | undefined
+
+        /**
+         * Destructures object into array of property keys
+         * @param from Object to destruct
+         */
+        keysOf<From extends {} = {}>(from: From): Array<keyof From>
+
+        omit<From extends {}, Exclude extends keyof From>(from: From, ...exclude: Exclude[]): Omit<From, Exclude>;
+
+        properties: Properties
+    }
+}
+
+function array<From extends {} = {}>(this: object, from: From): Array<[keyof From, ValueOf<From>]> {
+    return Object.keysOf(from).map(prop => [prop, from[prop]]) as Array<[keyof From, ValueOf<From>]>;
+}
+Object.array = array;
+
+function extract<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props> {
+    // If props are Array<keyof From>, Array<Partial<From>>, or Array<keyof From | Partial<From>>, ensure _props as Array<keyof From> 
+    const _props = props.map(prop => typeof prop === "object" ? Object.keysOf(prop) : prop).flat();
+    _props.forEach(prop => delete from[prop as keyof From]);
+    return from;
+}
+Object.extract = extract;
+
+function exclude<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props> {
+    // If props are Array<keyof From>, Array<Partial<From>>, or Array<keyof From | Partial<From>>, ensure _props as Array<keyof From>
+    const _props = props.map(prop => typeof prop === "object" ? Object.keysOf(prop) : prop).flat();
+    return Object.keysOf(from).reduce((result, prop) => {
+        if (_props.includes(prop as Props)) delete result[prop];
+        return result;
+    }, from);
+}
+Object.exclude = exclude;
+
+function isNullOrUndefined(obj: any): obj is null | undefined {
+    return obj === null || obj === undefined;
+}
+Object.isNullOrUndefined = isNullOrUndefined;
+
+function keysOf<From extends {} = {}>(this: object, from: From): Array<keyof From> {
+    return Object.keys(from) as Array<keyof From>;
+}
+Object.keysOf = keysOf;
+
+Object.properties = properties;
+
+export const ObjectExtensions = {
+    properties,
+    array, extract, exclude, isNullOrUndefined, keysOf, 
+};

package/src/Extensions/Object/properties.ts

@@ -0,0 +1,51 @@
+import { PropertiesWith, If } from '../../Types';
+import { StringExtensions } from '../String';
+
+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>
+            >
+}
+
+export const properties: Properties = [
+    'string', 'number', 'boolean', 'undefined', 'null', 
+    'object', 'function', 'any', 
+    'Date', 'RegExp', 'Promise', 'Array', 'Map', 'Set'
+].reduce((result, primitive) => {
+    result[`get${StringExtensions.toPascalCase.bind(primitive)()}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);

package/src/Extensions/String.ts

@@ -1,5 +1,4 @@
 import IReplacement from "../Interfaces/IReplacement";
-export {}
 
 declare global {
     interface String {
@@ -26,18 +25,30 @@ declare global {
     }
 }
 
-String.prototype.toPascalCase = function(this: string) {
+function toPascalCase(this: string) {
     return this.substring(0, 1).toUpperCase() + this.substring(1);
 }
+String.prototype.toPascalCase = toPascalCase;
+
 function spaceReplacer(self: string, replacer: string | RegExp, replacement: string) {
     return self.replace(new RegExp(`${typeof replacer == 'string' ? replacer : replacer.source}+`), replacement);
 }
-String.prototype.toSnakeCase = function(this: string, replaceOptions: IReplacement) {
+
+function toSnakeCase(this: string, replaceOptions: IReplacement) {
     return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '_')
 }
-String.prototype.toKebabCase = function(this: string, replaceOptions: IReplacement) {
+String.prototype.toSnakeCase = toSnakeCase;
+
+function toKebabCase(this: string, replaceOptions: IReplacement) {
     return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '-');
 }
-String.prototype.clip = function(this: string, start: number, end?: number) {
+String.prototype.toKebabCase = toKebabCase;
+
+function clip(this: string, start: number, end?: number) {
     return this.substring(start < 0 ? this.length - start : start, end && end < 0 ? this.length + end : end);
-}
+}
+String.prototype.clip = clip;
+
+export const StringExtensions = {
+    toPascalCase, toSnakeCase, toKebabCase, clip
+};