danholibraryjs 1.7.0 → 1.10.0

package/dist/Extensions/Object/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectExtensions = void 0;
+const properties_1 = require("./properties");
+function array(from) {
+    return Object.keysOf(from).map(prop => [prop, from[prop]]);
+}
+Object.array = array;
+function extract(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]);
+    return from;
+}
+Object.extract = extract;
+function exclude(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))
+            delete result[prop];
+        return result;
+    }, from);
+}
+Object.exclude = exclude;
+function isNullOrUndefined(obj) {
+    return obj === null || obj === undefined;
+}
+Object.isNullOrUndefined = isNullOrUndefined;
+function keysOf(from) {
+    return Object.keys(from);
+}
+Object.keysOf = keysOf;
+Object.properties = properties_1.properties;
+exports.ObjectExtensions = {
+    properties: properties_1.properties,
+    array, extract, exclude, isNullOrUndefined, keysOf,
+};

package/dist/Extensions/Object/properties.d.ts

@@ -0,0 +1,28 @@
+import { PropertiesWith, If } from '../../Types';
+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 declare const properties: Properties;
+export {};

package/dist/Extensions/Object/properties.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.properties = void 0;
+const String_1 = require("../String");
+exports.properties = [
+    'string', 'number', 'boolean', 'undefined', 'null',
+    'object', 'function', 'any',
+    'Date', 'RegExp', 'Promise', 'Array', 'Map', 'Set'
+].reduce((result, primitive) => {
+    result[`get${String_1.StringExtensions.toPascalCase.bind(primitive)()}s`] = function (source, withFunctions = false) {
+        return Object.keysOf(source).reduce((result, key) => {
+            if (source[key].constructor.name === primitive ||
+                (withFunctions && typeof source[key] === 'function' && source[key]).constructor.name === primitive) {
+                result[key] = source[key];
+            }
+            return result;
+        }, {});
+    };
+    return result;
+}, {});

package/dist/Extensions/String.d.ts

@@ -1,5 +1,4 @@
 import IReplacement from "../Interfaces/IReplacement";
-export {};
 declare global {
     interface String {
         /**
@@ -24,3 +23,14 @@ declare global {
         clip(start: number, end?: number): string;
     }
 }
+declare function toPascalCase(this: string): string;
+declare function toSnakeCase(this: string, replaceOptions: IReplacement): string;
+declare function toKebabCase(this: string, replaceOptions: IReplacement): string;
+declare function clip(this: string, start: number, end?: number): string;
+export declare const StringExtensions: {
+    toPascalCase: typeof toPascalCase;
+    toSnakeCase: typeof toSnakeCase;
+    toKebabCase: typeof toKebabCase;
+    clip: typeof clip;
+};
+export {};

package/dist/Extensions/String.js

@@ -1,17 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-String.prototype.toPascalCase = function () {
+exports.StringExtensions = void 0;
+function toPascalCase() {
     return this.substring(0, 1).toUpperCase() + this.substring(1);
-};
+}
+String.prototype.toPascalCase = toPascalCase;
 function spaceReplacer(self, replacer, replacement) {
     return self.replace(new RegExp(`${typeof replacer == 'string' ? replacer : replacer.source}+`), replacement);
 }
-String.prototype.toSnakeCase = function (replaceOptions) {
+function toSnakeCase(replaceOptions) {
     return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '_');
-};
-String.prototype.toKebabCase = function (replaceOptions) {
+}
+String.prototype.toSnakeCase = toSnakeCase;
+function toKebabCase(replaceOptions) {
     return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '-');
-};
-String.prototype.clip = function (start, end) {
+}
+String.prototype.toKebabCase = toKebabCase;
+function clip(start, end) {
     return this.substring(start < 0 ? this.length - start : start, end && end < 0 ? this.length + end : end);
+}
+String.prototype.clip = clip;
+exports.StringExtensions = {
+    toPascalCase, toSnakeCase, toKebabCase, clip
 };

package/dist/Extensions/index.d.ts

@@ -1,6 +1,5 @@
-import ElementOptions from "../Interfaces/ElementOptions";
-import { IElement } from "../Types";
 export * from './Array';
+export * from './Document';
 export * from './Map';
 export * from './Object';
 export * from './String';
@@ -11,19 +10,8 @@ declare global {
          */
         parseBoolean(value: string): boolean;
     }
-    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
-         */
-        createProperElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementOptions, ...children: Array<IElement>): HTMLElementTagNameMap[K];
-        createFromHtml<K extends keyof HTMLElementTagNameMap>(html: string, parentTag?: K): HTMLElementTagNameMap[K];
-    }
-    interface HTMLCollection {
-        /**
-         * Converts HTMLCollection to Element[]
-         */
-        array(): Element[];
-    }
 }
+declare function parseBoolean(value: string): boolean;
+export declare const BooleanExtensions: {
+    parseBoolean: typeof parseBoolean;
+};

package/dist/Extensions/index.js

@@ -14,58 +14,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanExtensions = void 0;
 __exportStar(require("./Array"), exports);
+__exportStar(require("./Document"), exports);
 __exportStar(require("./Map"), exports);
 __exportStar(require("./Object"), exports);
 __exportStar(require("./String"), exports);
-Boolean.parseBoolean = function (value) {
+function parseBoolean(value) {
     return value === "true";
-};
-try {
-    Document.prototype.createProperElement = function (tagName, options, ...children) {
-        let baseElement = document.createElement(tagName);
-        if (!options)
-            return baseElement;
-        const { id, class: className, dataset, ...rest } = options;
-        if (id)
-            baseElement.id = id;
-        if (className) {
-            const classNames = Array.isArray(className) ? className : [className];
-            classNames.forEach(className => baseElement.classList.add(className));
-        }
-        children ?? options.children;
-        if (children) {
-            const childrenElements = Array.isArray(children) ? children : [children];
-            childrenElements.forEach(child => baseElement.append(child));
-        }
-        if (dataset)
-            Object.entries(dataset).forEach(([key, value]) => baseElement.dataset[key] = value);
-        for (const optionKey in rest) {
-            const optionValue = rest[optionKey];
-            if (optionValue === undefined)
-                continue;
-            if (typeof optionValue === 'function') {
-                baseElement.addEventListener(optionKey.substring(2), rest[optionKey]);
-            }
-            else {
-                baseElement.setAttribute(optionKey, optionValue.toString());
-            }
-        }
-        return baseElement;
-    };
-    Document.prototype.createFromHtml = function (html, parentTag) {
-        return new DOMParser().parseFromString(html, 'text/html').body.firstChild;
-    };
-    HTMLCollection.prototype.array = function () {
-        let result = new Array();
-        for (let i = 0; i < this.length; i++) {
-            const item = this.item(i);
-            if (item !== null)
-                result.push(item);
-        }
-        return result;
-    };
-}
-catch {
-    // Used in node.js
 }
+;
+Boolean.parseBoolean = parseBoolean;
+exports.BooleanExtensions = {
+    parseBoolean
+};

package/dist/Functions/GetCSSProperty.d.ts

@@ -1,4 +1,4 @@
-declare type CSSReturnTypes = {
+type CSSReturnTypes = {
     string: string;
     number: number;
 };

package/dist/Functions/GetNestedProperty.d.ts

@@ -0,0 +1,9 @@
+export type GetNestedProperty<Parent, Key extends string> = Key extends keyof Parent ? Parent[Key] : Key extends `${infer K}.${infer Rest}` ? K extends keyof Parent ? GetNestedProperty<Parent[K], Rest> : never : never;
+/**
+ * Gets a nested property from an object
+ * @param parent Parent object to search
+ * @param key Key to search for. Can be nested with dot notation
+ * @returns Value of key or null if not found
+ */
+export declare function GetNestedProperty<Parent extends object, Key extends string>(parent: Parent, key: Key): GetNestedProperty<Parent, Key> | null;
+export default GetNestedProperty;

package/dist/Functions/GetNestedProperty.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetNestedProperty = void 0;
+/**
+ * Gets a nested property from an object
+ * @param parent Parent object to search
+ * @param key Key to search for. Can be nested with dot notation
+ * @returns Value of key or null if not found
+ */
+function GetNestedProperty(parent, key) {
+    if (key in parent)
+        return parent[key];
+    for (const prop in parent) {
+        if (typeof parent[prop] === 'object') {
+            const result = GetNestedProperty(parent[prop], key);
+            if (result)
+                return result;
+        }
+    }
+    return null;
+}
+exports.GetNestedProperty = GetNestedProperty;
+exports.default = GetNestedProperty;

package/dist/Functions/index.d.ts

@@ -1,4 +1,5 @@
 export * from './CopyToClipboard';
 export * from './GetCSSProperty';
+export * from './GetNestedProperty';
 export * from './SetNavigationSelected';
 export * from './HTMLEvent';

package/dist/Functions/index.js

@@ -16,5 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./CopyToClipboard"), exports);
 __exportStar(require("./GetCSSProperty"), exports);
+__exportStar(require("./GetNestedProperty"), exports);
 __exportStar(require("./SetNavigationSelected"), exports);
 __exportStar(require("./HTMLEvent"), exports);

package/dist/Interfaces/ElementOptions.d.ts

@@ -1,14 +1,14 @@
 import { Arrayable, IElement } from "../Types";
-declare type Events = Record<`on${Capitalize<keyof HTMLElementEventMap>}`, (event: Event) => void>;
+type Events = Record<`on${Capitalize<keyof HTMLElementEventMap>}`, (event: Event) => void>;
 /**
  * Construction options when creating an HTML element using:
- * @see Document.createProperElement
+ * @see Document.createElement
  * @borwwos IElement
  * @borrows Arrayable
  */
-export declare type ElementOptions = Partial<Events & Record<string, any> & {
+export type ElementOptions = Partial<Events & Record<string, any> & {
     id: string;
-    class: Arrayable<string>;
+    className: Arrayable<string>;
     children: Arrayable<IElement>;
     dataset: Record<string, string>;
 }>;

package/dist/Types/BetterTypes.d.ts

@@ -1,9 +1,9 @@
 /**
  * Construct a type with the properties of Type except for those in type Properties.
  */
-export declare type BetterOmit<Type, Properties extends keyof Type> = Omit<Type, Properties>;
+export type BetterOmit<Type, Properties extends keyof Type> = Omit<Type, Properties>;
 /**
  * Extract from From those types that are assignable to Properties
  */
-export declare type BetterExtract<From, Properties extends From> = Extract<From, Properties>;
-export declare type PartialExcept<From, Properties extends keyof From> = Partial<From> & Required<Pick<From, Properties>>;
+export type BetterExtract<From, Properties extends From> = Extract<From, Properties>;
+export type PartialExcept<From, Properties extends keyof From> = Partial<From> & Required<Pick<From, Properties>>;

package/dist/Types/Date.d.ts

@@ -1,6 +1,6 @@
-export declare type LongMonth = 'Janurary' | 'February' | 'March' | 'April' | 'May' | 'June' | 'July' | 'August' | 'September' | 'October' | 'November' | 'December';
-export declare type ShortMonth = 'Jan' | 'Feb' | 'Mar' | 'Apr' | 'May' | 'Jun' | 'Jul' | 'Aug' | 'Sep' | 'Oct' | 'Nov' | 'Dec';
-export declare type Month = LongMonth | ShortMonth;
-export declare type ShortDay = 'Mon' | 'Tue' | 'Wed' | 'Thu' | 'Fri' | 'Sat' | 'Sun';
-export declare type LongDay = `${'Mon' | 'Tues' | 'Wednes' | 'Thurs' | 'Fri' | 'Satur' | 'Sun'}day`;
-export declare type Day = ShortDay | LongDay;
+export type LongMonth = 'Janurary' | 'February' | 'March' | 'April' | 'May' | 'June' | 'July' | 'August' | 'September' | 'October' | 'November' | 'December';
+export type ShortMonth = 'Jan' | 'Feb' | 'Mar' | 'Apr' | 'May' | 'Jun' | 'Jul' | 'Aug' | 'Sep' | 'Oct' | 'Nov' | 'Dec';
+export type Month = LongMonth | ShortMonth;
+export type ShortDay = 'Mon' | 'Tue' | 'Wed' | 'Thu' | 'Fri' | 'Sat' | 'Sun';
+export type LongDay = `${'Mon' | 'Tues' | 'Wednes' | 'Thurs' | 'Fri' | 'Satur' | 'Sun'}day`;
+export type Day = ShortDay | LongDay;

package/dist/Types/Events.d.ts

@@ -1,10 +1,10 @@
 /**
  * Default eventhandler mapper. Object with properties that are arrays
  */
-export declare type BaseEvent<Keys extends string, Types extends Array<any>> = Record<Keys, Types>;
+export type BaseEvent<Keys extends string, Types extends Array<any>> = Record<Keys, Types>;
 /**
  * Eventhandler type for:
  * @see EventCollection
  * @borrows BaseEvent
  */
-export declare type EventHandler<Events extends BaseEvent<string, Array<any>> = BaseEvent<string, Array<any>>, Event extends keyof Events = keyof Events, ReturnType = any> = (...args: Events[Event]) => ReturnType;
+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;

package/dist/Types/PropertiesWith.d.ts

@@ -1,13 +1,13 @@
 /**
  * Filters all properties from From that has the return type of Type
  */
-export declare type PropertiesWith<Type, From> = {
+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 declare type PropertiesWithout<Type, From> = {
+export type PropertiesWithout<Type, From> = {
     [Key in keyof From as From[Key] extends Type ? never : Key]: From[Key];
 };

package/dist/Types/TransformTypes.d.ts

@@ -1,13 +1,13 @@
 /**
  * Converts Start types to Switch types in From type
  */
-export declare type TransformType<From, Start, Switch> = {
+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 declare type TransformTypes<From, BaseType, NewType> = Record<keyof {
+export type TransformTypes<From, BaseType, NewType> = Record<keyof {
     [Key in keyof From as From[Key] extends BaseType ? Key : never]: Key;
 }, NewType>;
 export default TransformTypes;

package/dist/Types/index.d.ts

@@ -6,26 +6,41 @@ export * from './PropertiesWith';
 /**
  * Item is single or multiple
  */
-export declare type Arrayable<T> = T | Array<T>;
+export type Arrayable<T> = T | Array<T>;
+/**
+ * Item is function or T
+ */
+export type Functionable<T> = T | (() => T);
+
 /**
  * Used for HTMLElement.append in ElementOptions, Document.createProperElement.
  * IElement accepts HTML Elements or HTMl-like strings.
  *
  * @see HTMLElement.append
- * @see Document.createProperElement
+ * @see Document.createElement
  */
-export declare type IElement = HTMLElement | string;
+export type IElement = HTMLElement | string;
 /**
  * Return types of T
  */
-export declare type ValueOf<T> = T[keyof T];
+export type ValueOf<T> = T[keyof T];
 /**
  * Type's properties are ReturnType
  */
-export declare type AllPropsAre<ReturnType> = {
+export type AllPropsAre<ReturnType> = {
     [key: string]: ReturnType;
 };
 /**
  * string or RegExp.. pretty self-explanatory
  */
-export declare type StringRegex = string | RegExp;
+export type StringRegex = string | RegExp;
+export type If<Boolean extends boolean, True, False> = Boolean extends true ? True : False;
+/**
+ * GetRepeatedKeys<[
+ *  { username: string, password: string },
+ *  { username: number, email: string },
+ * ]> // { username: string | number }
+ */
+export type GetRepeatedKeys<Types extends Array<any>> = (Types extends [infer First, infer Second, ...infer Rest] ? First extends object ? Second extends object ? {
+    [Key in Extract<keyof First, keyof Second>]: First[Key] | Second[Key];
+} & GetRepeatedKeys<Rest> : {} : {} : {});

package/docs/Classes.md

@@ -2,6 +2,39 @@
 
 ## Classes
 
+```ts
+/**
+ * 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
+ */
+class Store<
+    State extends object,
+    ActionTypes extends Record<string, any[]>,
+    Actions extends 
+    { [Action in keyof ActionTypes]: Array<Reducer<State, ActionTypes, Action>> } = 
+    { [Action in keyof ActionTypes]: Array<Reducer<State, ActionTypes, Action>> }
+> extends EventEmitter<Record<keyof Actions, ActionTypes[keyof ActionTypes]> & Record<'stateChange', [previous: State, current: State]>> {
+    constructor(state: State, actions: { [Action in keyof ActionTypes]?: Arrayable<Reducer<State, ActionTypes, Action>> } = {});
+
+    private _state: State;
+    public get state(): State;
+
+    public dispatch<Action extends keyof ActionTypes>(action: Action, ...args: ActionTypes[Action]): State;
+}
+```
+
 ### Events
 
 ```ts

package/docs/Extensions.md

@@ -58,6 +58,13 @@ interface Array<T> {
      * @param i Index of item
      */
     index(i: number): T
+    /**
+     * For every number in array, do callback
+     * @param every For every x in array
+     * @param callback Do this for every x in array
+     * @returns Mapped array
+     */
+    nth<U>(every: number, callback: (collection: Array<T>, index: number, self: this) => U): Array<U>
 }
 ```
 

package/docs/Functions.md

@@ -21,6 +21,14 @@ async function CopyToClipboard(value: string, response?: string): Promise<void>;
 */
 function GetCSSProperty<Type extends keyof CSSReturnTypes>(property: string, type: Type, query = ":root"): CSSReturnTypes[Type];
 
+/**
+ * Gets a nested property from an object
+ * @param parent Parent object to search
+ * @param key Key to search for. Can be nested with dot notation
+ * @returns Value of key or null if not found
+ */
+function GetNestedProperty<Parent, Key extends string>(parent: Parent, key: Key): GetNestedProperty<Parent, Key> | null;
+
 /**
  * Create HTMLEvent object from function
  * @param name Name of the event

package/docs/Types.md

@@ -8,14 +8,19 @@
 /**
  * Type's properties are ReturnType
  */
-export type AllPropsAre<ReturnType> = {
+type AllPropsAre<ReturnType> = {
     [key: string]: ReturnType
 }
 
 /**
  * Item is single or multiple
  */
-export type Arrayable<T> = T | Array<T>;
+type Arrayable<T> = T | Array<T>;
+
+/**
+ * If Condition is true, Then, Else... pretty self-explanatory
+ */
+type If<Condition, Then, Else> = Condition extends true ? Then : Else;
 
 /**
  * Used for HTMLElement.append in ElementOptions, Document.createProperElement.
@@ -24,17 +29,17 @@ export type Arrayable<T> = T | Array<T>;
  * @see HTMLElement.append
  * @see Document.createProperElement
  */
-export type IElement = HTMLElement | string;
+type IElement = HTMLElement | string;
 
 /**
  * string or RegExp.. pretty self-explanatory
  */
-export type StringRegex = string | RegExp;
+type StringRegex = string | RegExp;
 
 /**
  * Return types of T
  */
-export type ValueOf<T> = T[keyof T];
+type ValueOf<T> = T[keyof T];
 ```
 
 ### BetterTypes
@@ -43,11 +48,11 @@ export type ValueOf<T> = T[keyof T];
 /**
  * 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>;
+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>;
+type BetterExtract<From, Properties extends From> = Extract<From, Properties>;
 ```
 
 ### Events
@@ -56,14 +61,14 @@ export type BetterExtract<From, Properties extends From> = Extract<From, Propert
 /**
  * Default eventhandler mapper. Object with properties that are arrays
  */
- export 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
   */
- export type EventHandler<
+ type EventHandler<
      Events extends BaseEvent<string, Array<any>> = BaseEvent<string, Array<any>>,
      Event extends keyof Events = keyof Events,
      ReturnType = any
@@ -76,15 +81,15 @@ export type BetterExtract<From, Properties extends From> = Extract<From, Propert
 /**
  * Filters all properties from From that has the return type of Type
  */
-export type PropertiesWith<Type, From> = {
+type PropertiesWith<Type, From> = {
     [Key in keyof From as From[Key] extends Type ? Key : never]: From[Key]
 }
-export default PropertiesWith;
+default PropertiesWith;
 
 /**
  * Fitlers all properties from From that don't have the return type of Type
  */
-export type PropertiesWithout<Type, From> = {
+type PropertiesWithout<Type, From> = {
     [Key in keyof From as From[Key] extends Type ? never : Key]: From[Key]
 }
 ```
@@ -97,17 +102,17 @@ export type PropertiesWithout<Type, From> = {
  * @Data Partial TimeProperties except years & months
  * @DateFormat string as dd/MM/yyyy
  */
-export type DanhoDateConstructor = Data | DateFormat | number | Date;
+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>
+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>>
+type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number, boolean>>
 ```
 
 ### TransformTypes
@@ -116,14 +121,22 @@ export type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number,
 /**
  * Converts Start types to Switch types in From type
  */
-export type TransformType<From, Start, Switch> = {
+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 { 
+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);
+ */
+type Reducer<State, Types extends Record<string, any[]>, Action extends keyof Types> = (state: State, ...args: Types[Action]) => State
+```