@vorplex/core 0.0.8 → 0.0.11

package/dist/modules/compression/compression.util.js

@@ -0,0 +1,52 @@
+export class Compression {
+    static compressString(string) {
+        if (string.length === 0)
+            return '';
+        const dict = new Map();
+        let dictSize = 256;
+        let w = string[0];
+        const codes = [];
+        for (let i = 1; i < string.length; i++) {
+            const c = string[i];
+            const wc = w + c;
+            if (dict.has(wc)) {
+                w = wc;
+            }
+            else {
+                codes.push(w.length > 1 ? dict.get(w) : w.charCodeAt(0));
+                dict.set(wc, dictSize++);
+                w = c;
+            }
+        }
+        codes.push(w.length > 1 ? dict.get(w) : w.charCodeAt(0));
+        return codes.map((code) => String.fromCharCode(code)).join('');
+    }
+    static decompressString(string) {
+        if (string.length === 0)
+            return '';
+        const dict = new Map();
+        let dictSize = 256;
+        const symbols = [...string];
+        let w = symbols[0];
+        let result = w;
+        for (let i = 1; i < symbols.length; i++) {
+            const k = symbols[i].charCodeAt(0);
+            let entry;
+            if (k < 256) {
+                entry = symbols[i];
+            }
+            else if (dict.has(k)) {
+                entry = dict.get(k);
+            }
+            else if (k === dictSize) {
+                entry = w + w[0];
+            }
+            else {
+                throw new Error('Corrupt LZW stream: unknown code encountered.');
+            }
+            result += entry;
+            dict.set(dictSize++, w + entry[0]);
+            w = entry;
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+export declare class $Date {
+    static addMilliseconds(date: Date, ms: number): Date;
+    static addSeconds(date: Date, seconds: number): Date;
+    static addMinutes(date: Date, minutes: number): Date;
+    static addHours(date: Date, hours: number): Date;
+    static addDays(date: Date, days: number): Date;
+    static addWeeks(date: Date, weeks: number): Date;
+    static addMonths(date: Date, months: number): Date;
+    static addYears(date: Date, years: number): Date;
+    /**
+     *
+     * @param date
+     * @param format
+     * @returns
+     * @example
+     * // 12 Jan 2025 11:50:15
+     * `YYYY` = 2025
+     * `YY` = 25
+     * `MM` = 01
+     * `DD` = 12
+     * `hh` = 11
+     * `mm` = 50
+     * `ss` = 15
+     */
+    static format(date: Date, format: string): string;
+    /**
+     *
+     * @param target
+     * @param compareTo
+     * @returns
+     * @example
+     * // 5 days ago
+     * // 1 minute from now
+     */
+    static toAgoString(target: Date, compareTo?: Date): string;
+    static isValid(date: unknown): date is Date;
+}

package/dist/modules/date/date.util.js

@@ -0,0 +1,84 @@
+export class $Date {
+    static addMilliseconds(date, ms) {
+        return new Date(date.getTime() + ms);
+    }
+    static addSeconds(date, seconds) {
+        return $Date.addMilliseconds(date, seconds * 1_000);
+    }
+    static addMinutes(date, minutes) {
+        return $Date.addMilliseconds(date, minutes * 60_000);
+    }
+    static addHours(date, hours) {
+        return $Date.addMilliseconds(date, hours * 3_600_000);
+    }
+    static addDays(date, days) {
+        return $Date.addMilliseconds(date, days * 86_400_000);
+    }
+    static addWeeks(date, weeks) {
+        return $Date.addDays(date, weeks * 7);
+    }
+    static addMonths(date, months) {
+        date = new Date(date.getTime());
+        date.setMonth(date.getMonth() + months);
+        return date;
+    }
+    static addYears(date, years) {
+        date = new Date(date.getTime());
+        date.setFullYear(date.getFullYear() + years);
+        return date;
+    }
+    /**
+     *
+     * @param date
+     * @param format
+     * @returns
+     * @example
+     * // 12 Jan 2025 11:50:15
+     * `YYYY` = 2025
+     * `YY` = 25
+     * `MM` = 01
+     * `DD` = 12
+     * `hh` = 11
+     * `mm` = 50
+     * `ss` = 15
+     */
+    static format(date, format) {
+        const year = String(date.getFullYear());
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        const hours = String(date.getHours()).padStart(2, '0');
+        const minutes = String(date.getMinutes()).padStart(2, '0');
+        const seconds = String(date.getSeconds()).padStart(2, '0');
+        return format.replace('YYYY', year).replace('YY', year.slice(-2)).replace('MM', month).replace('DD', day).replace('hh', hours).replace('mm', minutes).replace('ss', seconds);
+    }
+    /**
+     *
+     * @param target
+     * @param compareTo
+     * @returns
+     * @example
+     * // 5 days ago
+     * // 1 minute from now
+     */
+    static toAgoString(target, compareTo = new Date()) {
+        const msDiff = compareTo.getTime() - target.getTime();
+        const seconds = Math.floor(Math.abs(msDiff) / 1000);
+        const epochs = [
+            { name: 'year', seconds: 31_536_000 },
+            { name: 'month', seconds: 2_592_000 },
+            { name: 'week', seconds: 604_800 },
+            { name: 'day', seconds: 86_400 },
+            { name: 'hour', seconds: 3_600 },
+            { name: 'minute', seconds: 60 },
+            { name: 'second', seconds: 0 },
+        ];
+        const epoch = epochs.find((e) => e.seconds <= seconds);
+        const count = Math.floor(seconds / (epoch.seconds || 1));
+        const unit = count === 1 ? epoch.name : `${epoch.name}s`;
+        const when = msDiff > 0 ? 'ago' : 'from now';
+        return `${count} ${unit} ${when}`;
+    }
+    static isValid(date) {
+        return date instanceof Date && !Number.isNaN(date.getTime());
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { KeyValue } from '../../interfaces/key-value.interface';
+export declare class $Enum {
+    static getFlags(target: any, value: number): string[];
+    static addFlag(value: number, flag: number): number;
+    static removeFlag(value: number, flag: number): number;
+    static toggleFlag(value: number, flag: number): number;
+    static hasFlag(value: any, flag: number): boolean;
+    static switchFlags(value: any, ...cases: [...number[], (value: number) => void][]): void;
+    static isNumeric(target: any): boolean;
+    static isNonNumeric(target: any): boolean;
+    static isEnum(target: any): boolean;
+    static getItems<T extends string | number = string | number>(target: any): KeyValue<T>[];
+    static getValues(target: any): any[];
+    static getKeys(target: any): string[];
+    static getValueKey(target: any, value: number | string): string | number;
+    static getValue(target: any, name: string | number): number | string;
+}

package/dist/modules/enum/enum.util.js

@@ -0,0 +1,69 @@
+import { $Reflection } from '../reflection/utils/reflection.util';
+export class $Enum {
+    static getFlags(target, value) {
+        return $Enum
+            .getItems(target)
+            .filter((item) => $Enum.hasFlag(value, item.value))
+            .map((item) => item.key);
+    }
+    static addFlag(value, flag) {
+        return value | flag;
+    }
+    static removeFlag(value, flag) {
+        return value & ~flag;
+    }
+    static toggleFlag(value, flag) {
+        return $Enum.hasFlag(value, flag) ? $Enum.removeFlag(value, flag) : $Enum.addFlag(value, flag);
+    }
+    static hasFlag(value, flag) {
+        return value != null && flag != null && ((value === 0 && value === flag) || (value & flag) === flag);
+    }
+    static switchFlags(value, ...cases) {
+        for (const statement of cases) {
+            for (let i = 0; i < statement.length - 1; i++) {
+                if ($Enum.hasFlag(value, Number(statement[i]))) {
+                    statement[statement.length - 1](value);
+                    break;
+                }
+            }
+        }
+    }
+    static isNumeric(target) {
+        return $Reflection.isObject(target) && Object.keys(target).every((key) => (Number.isFinite(Number(key)) || typeof target[key] === 'number') && String(target[key]) in target);
+    }
+    static isNonNumeric(target) {
+        return $Reflection.isObject(target) && Object.keys(target).every((key) => !Number.isFinite(Number(key)) && typeof target[key] === 'string');
+    }
+    static isEnum(target) {
+        return $Enum.isNumeric(target) || $Enum.isNonNumeric(target);
+    }
+    static getItems(target) {
+        const items = [];
+        if ($Enum.isNumeric(target)) {
+            for (const key in target) {
+                if (typeof target[key] === 'number') {
+                    items.push({ key, value: target[key] });
+                }
+            }
+        }
+        else {
+            for (const key in target) {
+                items.push({ key, value: target[key] });
+            }
+        }
+        return items;
+    }
+    static getValues(target) {
+        return $Enum.getItems(target).map((iItem) => iItem.value);
+    }
+    static getKeys(target) {
+        return $Enum.getItems(target).map((iItem) => iItem.key);
+    }
+    static getValueKey(target, value) {
+        const item = $Enum.getItems(target).find((iEntry) => iEntry.value === value);
+        return item ? item.key : typeof value === 'number' ? value : null;
+    }
+    static getValue(target, name) {
+        return target[name];
+    }
+}

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

@@ -0,0 +1,3 @@
+export declare class $Hash {
+    static generateSha256Base64(value: any): Promise<string>;
+}

package/dist/modules/hash/hash.util.js

@@ -0,0 +1,9 @@
+import { $Value } from '../value/value.util';
+export class $Hash {
+    static async generateSha256Base64(value) {
+        const json = JSON.stringify($Value.orderProperties(value));
+        const buffer = new TextEncoder().encode(json);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', buffer);
+        return btoa(String.fromCharCode(...new Uint8Array(hashBuffer))).slice(0, 12);
+    }
+}

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

@@ -0,0 +1,7 @@
+export declare class $Id {
+    static guid(): string;
+    static uuid(): string;
+    static getUuidTimestamp(uuid: string): number;
+    static uid(): string;
+    static getUidTimestamp(uid: string): number;
+}

package/dist/modules/id/id.util.js

@@ -0,0 +1,33 @@
+export class $Id {
+    static guid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    static uuid() {
+        const timestamp = Date.now();
+        const bytes = new Uint8Array(16);
+        bytes[0] = (timestamp / 2 ** 40) & 0xff;
+        bytes[1] = (timestamp / 2 ** 32) & 0xff;
+        bytes[2] = (timestamp / 2 ** 24) & 0xff;
+        bytes[3] = (timestamp / 2 ** 16) & 0xff;
+        bytes[4] = (timestamp / 2 ** 8) & 0xff;
+        bytes[5] = timestamp & 0xff;
+        crypto.getRandomValues(bytes.subarray(6));
+        bytes[6] = (bytes[6] & 0x0f) | 0x70;
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        const hex = [...bytes].map(b => b.toString(16).padStart(2, '0')).join('');
+        return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    }
+    static getUuidTimestamp(uuid) {
+        const hex = uuid.slice(0, 8) + uuid.slice(9, 13);
+        return parseInt(hex, 16);
+    }
+    static uid() {
+        return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 5)}`;
+    }
+    static getUidTimestamp(uid) {
+        return parseInt(uid.slice(0, -3), 36);
+    }
+}

package/dist/modules/injector/decorators/inject-token.decorator.d.ts

@@ -0,0 +1,14 @@
+import type { Type } from '../../reflection/types/type.type';
+import { ConstructorParameterDecorator } from '../../reflection/utils/decorator.util';
+export type InjectDecoratorData = {
+    type: Type;
+    optional?: boolean;
+};
+export declare class InjectDecorator extends ConstructorParameterDecorator<InjectDecoratorData> {
+}
+export declare function Inject(args: {
+    type: Type;
+    optional?: boolean;
+    index: number;
+    name: string;
+}): (target: Type, _context: ClassDecoratorContext) => void;

package/dist/modules/injector/decorators/inject-token.decorator.js

@@ -0,0 +1,12 @@
+import { $Decorator, ConstructorParameterDecorator } from '../../reflection/utils/decorator.util';
+export class InjectDecorator extends ConstructorParameterDecorator {
+}
+export function Inject(args) {
+    return $Decorator.createClassDecorator((type) => {
+        const data = {
+            type: args.type,
+            optional: args.optional,
+        };
+        return new InjectDecorator(type, { index: args.index, name: args.name }, data);
+    });
+}

package/dist/modules/injector/decorators/injectable.decorator.d.ts

@@ -0,0 +1,9 @@
+import { ClassDecorator } from '../../reflection/utils/decorator.util';
+import { ProviderScopes } from '../provider-scopes.enum';
+export type InjectableDecoratorData = {
+    global?: boolean;
+    scope?: ProviderScopes;
+};
+export declare class InjectableDecorator extends ClassDecorator<InjectableDecoratorData> {
+}
+export declare function Injectable(data?: InjectableDecoratorData): (target: import("../../..").Type, _context: ClassDecoratorContext) => void;

package/dist/modules/injector/decorators/injectable.decorator.js

@@ -0,0 +1,7 @@
+import { $Decorator, ClassDecorator } from '../../reflection/utils/decorator.util';
+import { ProviderScopes } from '../provider-scopes.enum';
+export class InjectableDecorator extends ClassDecorator {
+}
+export function Injectable(data = { scope: ProviderScopes.Singleton }) {
+    return $Decorator.createClassDecorator((type) => new InjectableDecorator(type, data));
+}

package/dist/modules/injector/injector.model.d.ts

@@ -0,0 +1,25 @@
+import type { Constructor } from '../reflection/types/constructor.type';
+import { Instance } from '../reflection/types/instance.type';
+import type { Type } from '../reflection/types/type.type';
+import type { IProvider, Provider } from './provider.interface';
+export declare class InjectorError extends Error {
+}
+export declare class Injector {
+    static providers: IProvider[];
+    providers: IProvider[];
+    parentInjector: Injector;
+    constructor(providers?: Provider[], parentInjector?: Injector);
+    static parseProvider(value: Provider): IProvider;
+    private getProvider;
+    private getGlobalProvider;
+    create<T = any>(type: Constructor<T>): T;
+    private createProviderInstance;
+    get<T = any>(type: Type<T>, optional?: boolean): T;
+    map<T extends Record<string, Type<T>>>(map: T): {
+        [key in keyof T]: Instance<T[key]>;
+    };
+    add(...providers: Provider[]): Injector;
+    addInstance(...instances: any[]): Injector;
+    addDefault(...providers: Provider[]): Injector;
+    scope(...instances: any[]): Injector;
+}

package/dist/modules/injector/injector.model.js

@@ -0,0 +1,152 @@
+import { $Decorator } from '../reflection/utils/decorator.util';
+import { $Reflection } from '../reflection/utils/reflection.util';
+import { InjectableDecorator } from './decorators/injectable.decorator';
+import { ProviderScopes } from './provider-scopes.enum';
+export class InjectorError extends Error {
+}
+export class Injector {
+    static providers = [];
+    providers = [];
+    parentInjector;
+    constructor(providers = [], parentInjector) {
+        this.providers = providers.map((provider) => Injector.parseProvider(provider));
+        this.parentInjector = parentInjector;
+    }
+    static parseProvider(value) {
+        if ($Reflection.isType(value)) {
+            const decorator = $Decorator.get({
+                target: value,
+                type: InjectableDecorator,
+                first: true,
+            });
+            return {
+                scope: decorator?.data.scope ?? ProviderScopes.Singleton,
+                type: value,
+            };
+        }
+        else {
+            const provider = value;
+            const decorator = $Decorator.get({
+                target: provider.type,
+                type: InjectableDecorator,
+                first: true,
+            });
+            provider.scope ??= decorator?.data.scope ?? ProviderScopes.Singleton;
+            return provider;
+        }
+    }
+    getProvider(type) {
+        for (const provider of this.providers) {
+            if ($Reflection.extends(provider.type, type)) {
+                return provider;
+            }
+        }
+    }
+    getGlobalProvider(type) {
+        const injectable = $Decorator.get({
+            target: type,
+            type: InjectableDecorator,
+            first: true,
+        });
+        if (injectable?.data.global) {
+            let provider = Injector.providers.find((provider) => $Reflection.extends(provider.type, type));
+            if (!provider) {
+                provider = Injector.parseProvider(type);
+                Injector.providers.push(provider);
+            }
+            return provider;
+        }
+    }
+    create(type) {
+        if ('inject' in type && typeof type.inject === 'object' && type.inject != null) {
+            const tokens = {};
+            for (const [key, value] of Object.entries(type.inject)) {
+                try {
+                    tokens[key] = this.get(value);
+                }
+                catch (error) {
+                    if (error instanceof InjectorError) {
+                        throw new InjectorError(`Unable to create ${$Reflection.getTypeName(type)}, failed to resolve key (${key}). ${error.message}`);
+                    }
+                    throw error;
+                }
+            }
+            return new type(tokens);
+        }
+        return new type();
+    }
+    createProviderInstance(provider, scope = ProviderScopes.Singleton) {
+        if (provider.value == null || provider.scope === ProviderScopes.Transient || (scope === ProviderScopes.Transient && provider.scope !== ProviderScopes.Singleton) || (scope === ProviderScopes.Scoped && provider.scope !== ProviderScopes.Singleton)) {
+            if (provider.factory) {
+                return provider.factory(this);
+            }
+            else if ($Reflection.isType(provider.type)) {
+                return this.create(provider.type);
+            }
+            else {
+                throw new InjectorError(`Unable to create provider instance ${$Reflection.getTypeName(provider.type)}. Type is not constructable or factory is not provided`);
+            }
+        }
+        return provider.value;
+    }
+    get(type, optional) {
+        if (type === Injector) {
+            return this;
+        }
+        else if (type === Object) {
+            throw new InjectorError('Unable to resolve provider for anonymous type.');
+        }
+        else {
+            const provider = this.getProvider(type) ?? this.parentInjector?.getProvider(type) ?? this.getGlobalProvider(type);
+            if (provider) {
+                provider.value = this.createProviderInstance(provider);
+                return provider.value;
+            }
+            else if (!optional) {
+                throw new InjectorError(`No provider registered for type (${$Reflection.getTypeName(type)}).`);
+            }
+        }
+    }
+    map(map) {
+        return Object.keys(map).reduce((result, key) => ({ ...result, [key]: this.get(map[key]) }), {});
+    }
+    add(...providers) {
+        for (const provider of providers.map(Injector.parseProvider)) {
+            this.providers = [...this.providers.filter((_provider) => !$Reflection.extends(provider.type, _provider.type)), provider];
+        }
+        return this;
+    }
+    addInstance(...instances) {
+        for (const instance of instances) {
+            const type = $Reflection.getType(instance);
+            this.add({
+                scope: ProviderScopes.Singleton,
+                type,
+                value: instance,
+            });
+        }
+        return this;
+    }
+    addDefault(...providers) {
+        for (const provider of providers.map(Injector.parseProvider)) {
+            if (!this.getProvider(provider.type)) {
+                this.add(provider);
+            }
+        }
+        return this;
+    }
+    scope(...instances) {
+        const providers = [];
+        for (const provider of this.providers) {
+            if (provider.scope !== ProviderScopes.Singleton) {
+                providers.push({
+                    ...provider,
+                    value: this.createProviderInstance(provider, ProviderScopes.Scoped),
+                });
+            }
+        }
+        const scope = new Injector(providers, this.parentInjector ?? this);
+        scope.addInstance(...instances);
+        return scope;
+    }
+}

package/dist/modules/injector/provider-scopes.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum ProviderScopes {
+    Singleton = 0,
+    Scoped = 1,
+    Transient = 2
+}

package/dist/modules/injector/provider-scopes.enum.js

@@ -0,0 +1,6 @@
+export var ProviderScopes;
+(function (ProviderScopes) {
+    ProviderScopes[ProviderScopes["Singleton"] = 0] = "Singleton";
+    ProviderScopes[ProviderScopes["Scoped"] = 1] = "Scoped";
+    ProviderScopes[ProviderScopes["Transient"] = 2] = "Transient";
+})(ProviderScopes || (ProviderScopes = {}));

package/dist/modules/injector/provider.interface.d.ts

@@ -0,0 +1,10 @@
+import type { Type } from '../reflection/types/type.type';
+import type { Injector } from './injector.model';
+import type { ProviderScopes } from './provider-scopes.enum';
+export interface IProvider<T = any> {
+    type: Type<T>;
+    scope: ProviderScopes;
+    value?: T;
+    factory?: (injector: Injector) => T;
+}
+export type Provider<T = any> = Type<T> | IProvider<T>;

package/dist/modules/json-filter/json-filter.function.d.ts

@@ -0,0 +1,41 @@
+export type JsonFilter<T = any> = (value: T) => boolean;
+export type JsonFilterOperator<TArg = any, TValue = any> = (arg: TArg, options: JsonFilterOptions) => JsonFilter<TValue>;
+export type JsonFilterOperators = {
+    [operator: string]: JsonFilterOperator;
+};
+export declare const JsonFilters: {
+    query: <T = any, TT = any>(selector: (value: T) => TT, operator: JsonFilter<TT>) => (value: T) => boolean;
+    and: <T = any>(...operators: JsonFilter<T>[]) => (value: T) => boolean;
+    or: <T = any>(...operators: JsonFilter<T>[]) => (value: T) => boolean;
+    not: <T = any>(operator: JsonFilter<T>) => (value: T) => boolean;
+    equals: (arg: string | number | Date) => (value: any) => boolean;
+    length: (arg: number) => (value: any) => boolean;
+    contains: (arg: string | number) => (value: any) => boolean;
+    starts: (arg: string | number | Date) => (value: any) => boolean;
+    ends: (arg: string | number | Date) => (value: any) => boolean;
+    greater: (arg: number | Date) => (value: any) => boolean;
+    less: (arg: number | Date) => (value: any) => boolean;
+};
+export declare const JsonFilterOperators: JsonFilterOperators;
+export type JsonFilterOptions = {
+    operatorPrefix: string;
+    operator: 'or' | 'and';
+    operators: {
+        [operator: string]: JsonFilterOperator;
+    };
+};
+export declare const DefaultJsonFilterOptions: JsonFilterOptions;
+export type JsonFilterQuery = {
+    [property: string]: JsonFilterQuery;
+} | {
+    $and?: JsonFilterQuery[];
+    $or?: JsonFilterQuery[];
+    $not?: JsonFilterQuery;
+    $equals?: string | number | Date;
+    $contains?: string | number;
+    $starts?: string | number | Date;
+    $ends?: string | number | Date;
+    $greater?: number | Date;
+    $less?: number | Date;
+};
+export declare function jsonFilter<TQuery = JsonFilterQuery>(query: TQuery, options?: Partial<JsonFilterOptions>): JsonFilter;