@vorplex/core 0.0.8 → 0.0.11

package/dist/modules/reflection/utils/reflection.util.js

@@ -0,0 +1,311 @@
+export class $Reflection {
+    constructor() { }
+    /**
+     * Returns the names of the parameters of the given function
+     *
+     * @static
+     * @template T
+     * @param func The function definition
+     * @param [name=''] The name of the function
+     * @return {*} The names of the parameters
+     */
+    static getParameterNames(func, name = '') {
+        const data = func.toString();
+        const paramRegex = new RegExp(`(?:${name}|${func.name})\\(([^)]*)\\)`);
+        const match = data.match(paramRegex);
+        if (!match)
+            return [];
+        const paramsString = match[1].replace(/\/\*.*?\*\//g, '');
+        const params = paramsString
+            .split(',')
+            .map((param) => param
+            .trim()
+            .replace(/^\.\.\./, '')
+            .split('=')[0]
+            .trim()
+            .split(':')[0]
+            .replace(/@.*\(/, '')
+            .trim())
+            .filter(Boolean);
+        return params;
+    }
+    static combineClasses(...classes) {
+        class DynamicClass {
+        }
+        for (const class$ of classes) {
+            const keys = Object.getOwnPropertyNames(class$.prototype);
+            for (const key of keys) {
+                if (key !== 'constructor') {
+                    const descriptor = Object.getOwnPropertyDescriptor(class$.prototype, key);
+                    Object.defineProperty(DynamicClass.prototype, key, descriptor);
+                }
+            }
+        }
+        return DynamicClass;
+    }
+    /**
+     * Returns true if the `target` contains a property called `name`.
+     * @param target The object containing the property.
+     * @param name The name of the property to check.
+     */
+    static hasProperty(target, name) {
+        return target && $Reflection.isObject(target) && name in target;
+    }
+    /**
+     * Returns the type associate with the `prototype`.
+     * @param prototype The prototype which type to return.
+     */
+    static getProtoType(prototype) {
+        return $Reflection.getType(Object.setPrototypeOf({}, prototype));
+    }
+    /**
+     * Defines a property on `target` called `name` with the given `get` and `set`.
+     *
+     * @param target The object or type to define the property on.
+     * @param name The name of the property.
+     * @param get The getter of the property.
+     * @param set The setter of the property.
+     */
+    static defineProperty(target, name, get, set) {
+        target = $Reflection.isType(target) ? target.prototype : target;
+        Object.defineProperty(target, name, {
+            configurable: true,
+            enumerable: true,
+            get: get,
+            set: set,
+        });
+    }
+    /**
+     * Returns the type of the `value`.
+     * @param value The value which type to return.
+     */
+    static getType(value) {
+        return value?.__proto__?.constructor ?? value;
+    }
+    /**
+     * Returns true if `value` is of a primitive type.
+     * Primitive types are `undefined`, `null`, `String`, `Number`, `Boolean`.
+     * @param value The value to check for primitive type.
+     */
+    static isPrimitive(value) {
+        return [undefined, null, String, Number, Boolean].includes($Reflection.getType(value));
+    }
+    /**
+     * Returns true if `value` is of type function, lambda or class.
+     * @param value The value to check.
+     */
+    static isFunction(value) {
+        return $Reflection.getType(value) === Function && (!value.prototype || !`${$Reflection.getProtoType(value.prototype)}`.startsWith('class'));
+    }
+    /**
+     * Returns true if `value` is a type or function.
+     * @param value The value to check.
+     */
+    static isType(value) {
+        return $Reflection.getType(value) === Function && !!value.prototype && $Reflection.getType(value.prototype) !== Function;
+    }
+    static isValidDate(value) {
+        return new Date(value).toString() !== 'Invalid Date';
+    }
+    /**
+     * Returns true if `value` is of type `Object`.
+     * @param value The value to check.
+     */
+    static isObject(value) {
+        return value != null && !$Reflection.isArray(value) && typeof value === 'object' && !(value instanceof Date);
+    }
+    /**
+     * Returns true if `value` is of type `Symbol`.
+     * @param value The value to check.
+     */
+    static isSymbol(value) {
+        return typeof value === 'symbol';
+    }
+    /**
+     * Returns true if `value` is a reference type.
+     * Reference types are `Object`, `Function`, `Array`, `Symbol`, `Date`.
+     * @param value The value to check for reference type.
+     */
+    static isReference(value) {
+        return value && ['object', 'function', 'symbol'].includes(typeof value);
+    }
+    /**
+     * Returns true if `type` is a value type.
+     * Value types are `undefined`, `null`, `String`, `Number`, `Boolean`.
+     * @param type The type to check for value type.
+     */
+    static isValueType(type) {
+        return type == null || !![String, Boolean, Number].find((_type) => _type === type);
+    }
+    /**
+     * Returns true if `type` is a reference type.
+     * Reference types are `Object`, `Function`, `Array`, `Symbol`, `Date`.
+     * @param value The type to check for reference type.
+     */
+    static isReferenceType(type) {
+        return !$Reflection.isValueType(type);
+    }
+    /**
+     * Returns all the properties of `object`.
+     * @param object The object which properties to return.
+     */
+    static getProperties(object) {
+        return Object.keys(object).filter((key) => !$Reflection.isFunction(object[key]));
+    }
+    /**
+     * Returns the default value for `type`.
+     * @param type The type which default value to return.
+     * @example
+     * String: ''
+     * Number: 0
+     * Boolean: false
+     * Date: 0
+     * Array: []
+     * ...: null
+     */
+    static getDefault(type) {
+        switch (type) {
+            case String:
+                return '';
+            case Number:
+                return 0;
+            case Boolean:
+                return false;
+            case Date:
+                return 0;
+            case Array:
+                return [];
+            default:
+                return null;
+        }
+    }
+    /**
+     * Sets the type of `value` to `type`.
+     * @param value The value which type to set.
+     * @param type The type to apply to the value.
+     */
+    static setType(value, type) {
+        if (value == null || type == null) {
+            return value;
+        }
+        else if (type === Number) {
+            return Number(value);
+        }
+        else if (type === Boolean) {
+            return Boolean(value);
+        }
+        else if (type === String) {
+            return String(value);
+        }
+        else if (type === Date) {
+            return new Date(value);
+        }
+        else {
+            return Object.setPrototypeOf(value, type.prototype);
+        }
+    }
+    /**
+     * Returns true if `value` is of type `Array`.
+     * @param value The value to check.
+     * @param type The type of array to check for.
+     */
+    static isArray(value, type) {
+        if (Array.isArray(value)) {
+            if (type) {
+                if ($Reflection.isValueType(type)) {
+                    return value.every((item) => $Reflection.getType(item) === type);
+                }
+                else {
+                    return value.every((item) => item instanceof type);
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Returns true if `type` extends `base`.
+     * @param type The type to check.
+     * @param base The base of `type` to check.
+     */
+    static extends(type, base) {
+        return type === base || $Reflection.getTypeBases(type).includes(base);
+    }
+    static instanceOf(value, type) {
+        return value instanceof type || $Reflection.extends($Reflection.getType(value), type);
+    }
+    /**
+     * Returns all the base types of `type`.
+     * @param type The type which base types to return.
+     */
+    static getTypeBases(type) {
+        const types = [];
+        let base = $Reflection.getTypeBase(type);
+        while (base) {
+            types.push(base);
+            base = $Reflection.getTypeBase(base);
+        }
+        if ($Reflection.isReferenceType(type)) {
+            types.push(Object);
+        }
+        return types;
+    }
+    /**
+     * Returns the base type of `value`.
+     * @param value The value which base type to return.
+     */
+    static getBaseType(value) {
+        const type = $Reflection.getType(value);
+        if (type) {
+            return $Reflection.getTypeBase(type);
+        }
+    }
+    /**
+     * Returns the base type of `type`.
+     * @param type The type which base type to return.
+     */
+    static getTypeBase(type) {
+        if (type != null) {
+            const base = Object.getPrototypeOf(type);
+            return base !== Object.getPrototypeOf(Function) ? base : null;
+        }
+    }
+    static getTypeName(value) {
+        return $Reflection.isType(value) ? value.name : $Reflection.isSymbol(value) ? String(value) : String($Reflection.getType(value)?.name ?? value);
+    }
+    static getSimpleTypeName(value) {
+        if (value == null)
+            return 'null';
+        if (typeof value === 'string')
+            return 'string';
+        if (typeof value === 'number')
+            return 'number';
+        if (typeof value === 'boolean')
+            return 'boolean';
+        if (typeof value === 'symbol')
+            return 'symbol';
+        if (typeof value === 'bigint')
+            return 'bigint';
+        if (value instanceof Date)
+            return 'date';
+        if ($Reflection.isType(value))
+            return 'type';
+        if ($Reflection.isFunction(value))
+            return 'function';
+        if (Array.isArray(value))
+            return 'array';
+        if ($Reflection.isObject(value))
+            return 'object';
+    }
+    static parsePrimitiveValue(value) {
+        if (/^\d+$/.test(value))
+            return parseInt(value, 10);
+        if (/^\d+\.\d+$/.test(value))
+            return parseFloat(value);
+        if (value.toLowerCase() === 'true')
+            return true;
+        if (value.toLowerCase() === 'false')
+            return false;
+        return value;
+    }
+}

package/dist/modules/router/router.util.d.ts

@@ -0,0 +1,33 @@
+type RouteParamObject<P extends string> = P extends `...${infer Name}?` ? {
+    [K in Name]?: string;
+} : P extends `...${infer Name}` ? {
+    [K in Name]: string;
+} : P extends `${infer Name}?` ? {
+    [K in Name]?: string;
+} : {
+    [K in P]: string;
+};
+export type ExtractRouteParams<T extends string> = T extends `${string}{${infer P}}${infer Rest}` ? RouteParamObject<P> & ExtractRouteParams<Rest> : {};
+export interface RouteParameter {
+    name: string;
+    optional: boolean;
+    rest: boolean;
+}
+export declare class $Router {
+    /**
+     *
+     * @param route
+     * `/api/users/get/{name}/{surname?}`
+     *
+     * `/api/users/?`
+     *
+     * `/api/users/get/{...rest}`
+     * @param url
+     * @returns
+     */
+    static match(route: string, url: string): Record<string, string>;
+    static getParameters(route: string): RouteParameter[];
+    static getRouteRegex(route: string): RegExp;
+    static getQueryParameters(url: string): Record<string, string>;
+}
+export {};

package/dist/modules/router/router.util.js

@@ -0,0 +1,59 @@
+export class $Router {
+    /**
+     *
+     * @param route
+     * `/api/users/get/{name}/{surname?}`
+     *
+     * `/api/users/?`
+     *
+     * `/api/users/get/{...rest}`
+     * @param url
+     * @returns
+     */
+    static match(route, url) {
+        const regex = $Router.getRouteRegex(route);
+        const result = regex.exec(url.trim().split(/[?#]/, 1)[0]);
+        if (!result)
+            return null;
+        return result.groups ?? {};
+    }
+    static getParameters(route) {
+        const pattern = [
+            // check if the parameter starts with ...
+            '(?<rest>[.]{3})?',
+            // extract the name from the parameter
+            '(?<name>[^?}]*)',
+            // check if the parameter ends with a ?
+            '(?<optional>[?])?',
+        ];
+        const regex = new RegExp(`({${pattern.join('')}})`, 'gmi');
+        let match;
+        const variables = [];
+        while ((match = regex.exec(route))) {
+            variables.push({
+                name: match.groups['name'],
+                rest: match.groups['rest'] === '...',
+                optional: match.groups['optional'] === '?',
+            });
+        }
+        return variables;
+    }
+    static getRouteRegex(route) {
+        const variables = $Router.getParameters(route);
+        for (const variable of variables) {
+            if (variable.rest) {
+                route = route.replace(`{...${variable.name}}`, `(?<${variable.name}>(?:.*))`);
+            }
+            else if (variable.optional) {
+                route = route.replace(`{${variable.name}?}`, `(?<${variable.name}>(?:[^/]+)?)`);
+            }
+            else {
+                route = route.replace(`{${variable.name}}`, `(?<${variable.name}>(?:[^/]+))`);
+            }
+        }
+        return new RegExp(`^${route}$`, 'gmi');
+    }
+    static getQueryParameters(url) {
+        return Object.fromEntries(new URL(url, 'http://domain').searchParams);
+    }
+}

package/dist/modules/state/adaptors/array/array-adaptor.util.d.ts

@@ -0,0 +1,25 @@
+import type { KeysOfType } from '../../../../types/keys-of-type.type';
+import type { Predicate } from '../../../../types/predicate.type';
+import type { Selector } from '../../../../types/selector.type';
+import type { Update, UpdateFunc } from '../../update.type';
+export declare class ArrayAdaptor<TState, TItem, TString extends keyof KeysOfType<TState, TItem[]>> {
+    private key;
+    constructor(key: TString);
+    static updateWhere<T>(array: T[], query?: Predicate<T>, ...updates: Update<T>[]): T[];
+    static updateAtIndex<T>(array: T[], index: number, ...updates: Update<T>[]): T[];
+    static updateAll<T>(array: T[], ...updates: Update<T>[]): T[];
+    static upsert<T>(array: T[], ...items: T[]): T[];
+    static upsertBy<T>(array: T[], selector: Selector<T>, ...items: T[]): T[];
+    updateWhere(query?: Predicate<TItem>, ...updates: Update<TItem>[]): Update<TState>;
+    set(items: TItem[]): UpdateFunc<TState>;
+    updateAll(...updates: Update<TItem>[]): Update<TState>;
+    add(...items: TItem[]): Update<TState>;
+    insert(index: number, ...items: TItem[]): Update<TState>;
+    upsert(...items: TItem[]): Update<TState>;
+    toggle(item: TItem): Update<TState>;
+    remove(...items: TItem[]): Update<TState>;
+    removeWhere(query: Predicate<TItem>): Update<TState>;
+    removeAt(...indexes: number[]): Update<TState>;
+    move(item: TItem, index: number): Update<TState>;
+    moveAt(fromIndex: number, toIndex: number): Update<TState>;
+}

package/dist/modules/state/adaptors/array/array-adaptor.util.js

@@ -0,0 +1,97 @@
+import { $Array } from '../../../array/array.util';
+import { State } from '../../state.model';
+export class ArrayAdaptor {
+    key;
+    constructor(key) {
+        this.key = key;
+    }
+    static updateWhere(array, query, ...updates) {
+        array = [...array];
+        for (const [index, item] of array.entries()) {
+            if (!query || query(item)) {
+                array[index] = State.update(item, ...updates);
+            }
+        }
+        return array;
+    }
+    static updateAtIndex(array, index, ...updates) {
+        array = [...array];
+        array[index] = State.update(array[index], ...updates);
+        return array;
+    }
+    static updateAll(array, ...updates) {
+        return ArrayAdaptor.updateWhere(array, null, ...updates);
+    }
+    static upsert(array, ...items) {
+        return ArrayAdaptor.upsertBy(array, (item) => item, ...items);
+    }
+    static upsertBy(array, selector, ...items) {
+        array = [...array];
+        for (const item of items) {
+            const index = array.findIndex((existing) => selector(existing) === selector(item));
+            if (index > -1)
+                array[index] = item;
+            else
+                array.push(item);
+        }
+        return array;
+    }
+    updateWhere(query, ...updates) {
+        return (state) => ({
+            [this.key]: ArrayAdaptor.updateWhere(state[this.key], query, ...updates),
+        });
+    }
+    set(items) {
+        return (state) => ({
+            [this.key]: items,
+        });
+    }
+    updateAll(...updates) {
+        return this.updateWhere(null, ...updates);
+    }
+    add(...items) {
+        return (state) => ({
+            [this.key]: state[this.key].concat(...items),
+        });
+    }
+    insert(index, ...items) {
+        return (state) => ({
+            [this.key]: $Array.insert(state[this.key], index, ...items),
+        });
+    }
+    upsert(...items) {
+        return (state) => ({
+            [this.key]: $Array.upsert(state[this.key], ...items),
+        });
+    }
+    toggle(item) {
+        return (state) => ({
+            [this.key]: $Array.toggle(state[this.key], item),
+        });
+    }
+    remove(...items) {
+        return (state) => ({
+            [this.key]: $Array.remove(state[this.key], ...items),
+        });
+    }
+    removeWhere(query) {
+        return (state) => ({
+            [this.key]: $Array.removeWhere(state[this.key], query),
+        });
+    }
+    removeAt(...indexes) {
+        return (state) => ({
+            [this.key]: $Array.removeAt(state[this.key], ...indexes),
+        });
+    }
+    move(item, index) {
+        return (state) => ({
+            [this.key]: $Array.move(state[this.key], item, index),
+        });
+    }
+    moveAt(fromIndex, toIndex) {
+        return (state) => ({
+            [this.key]: $Array.moveAt(state[this.key], fromIndex, toIndex),
+        });
+    }
+}

package/dist/modules/state/adaptors/entity/entity-adaptor.util.d.ts

@@ -0,0 +1,35 @@
+import type { KeysOfType } from '../../../../types/keys-of-type.type';
+import type { Predicate } from '../../../../types/predicate.type';
+import type { Update } from '../../update.type';
+import type { EntityMap } from './entity-map.type';
+import type { IEntity } from './entity.interface';
+export declare class MapAdaptor {
+    private constructor();
+    static delete<T extends Record<string, any>>(records: T, ...keys: (keyof T)[]): T;
+    static set<T extends Record<string, any>>(records: T, items: Partial<T>): T;
+    static map<T extends Record<string, any>, TT>(records: T, map: (record: T[keyof T]) => [string, TT]): Record<string, TT>;
+    static fromArray<T, TT>(records: T[], map: (record: T) => [string, TT]): Record<string, TT>;
+}
+export declare class EntityAdaptor<TState, TEntity extends IEntity, TKey extends keyof KeysOfType<TState, EntityMap<TEntity>>> {
+    private key;
+    constructor(key: TKey);
+    static create<T extends IEntity>(items: EntityMap<T>, ...entities: T[]): EntityMap<T>;
+    create(...entities: TEntity[]): Update<TState>;
+    static updateAll<T extends IEntity>(items: EntityMap<T>, ...updates: Update<T>[]): EntityMap<T>;
+    updateAll(...updates: Update<TEntity>[]): Update<TState>;
+    static updateById<T extends IEntity>(items: EntityMap<T>, id: string, ...updates: Update<T>[]): EntityMap<T>;
+    updateById(id: string, ...updates: Update<TEntity>[]): Update<TState>;
+    static updateByIds<T extends IEntity>(items: EntityMap<T>, ids: string[], ...updates: Update<T>[]): EntityMap<T>;
+    updateByIds(ids: string[], ...updates: Update<TEntity>[]): Update<TState>;
+    static updateWhere<T extends IEntity>(items: EntityMap<T>, predicate: Predicate<T>, ...updates: Update<T>[]): EntityMap<T>;
+    updateWhere(predicate: Predicate<TEntity>, ...updates: Update<TEntity>[]): Update<TState>;
+    static upsert<T extends IEntity>(items: EntityMap<T>, ...entities: T[]): EntityMap<T>;
+    static upsertBy<T extends IEntity>(items: EntityMap<T>, predicate: (existing: T, entity: T) => boolean, ...entities: T[]): EntityMap<T>;
+    upsertBy(predicate: (existing: TEntity, entity: TEntity) => boolean, ...entities: TEntity[]): Update<TState>;
+    upsert(...entities: TEntity[]): Update<TState>;
+    static delete<T extends IEntity>(items: EntityMap<T>, ...ids: string[]): EntityMap<T>;
+    delete(...ids: string[]): Update<TState>;
+    static deleteWhere<T extends IEntity>(items: EntityMap<T>, predicate: Predicate<T>): EntityMap<T>;
+    deleteWhere(predicate: Predicate<TEntity>): Update<TState>;
+    static fromArray<T extends IEntity>(entities: T[]): EntityMap<T>;
+}