@vorplex/core 0.0.8 → 0.0.9

package/dist/modules/reflection/models/parameter-attribute.model.js

@@ -0,0 +1,21 @@
+import { Attribute } from './attribute.model';
+export class ParameterAttribute extends Attribute {
+    method;
+    name;
+    index;
+    constructor(prototype, method, index, data) {
+        super(prototype, data);
+        this.method = method;
+        this.name = (prototype[method] || prototype)
+            .toString()
+            .replace(/[/][/].*$/gm, '')
+            .replace(/\s+/g, '')
+            .replace(/[/][*][^/*]*[*][/]/g, '')
+            .split('){', 1)[0]
+            .replace(/^[^(]*[(]/, '')
+            .replace(/=[^,]+/g, '')
+            .split(',')
+            .filter(Boolean)[index];
+        this.index = index;
+    }
+}

package/dist/modules/reflection/models/property-attribute.model.d.ts

@@ -0,0 +1,5 @@
+import { Attribute } from './attribute.model';
+export declare abstract class PropertyAttribute<T = any> extends Attribute<T> {
+    property: string;
+    constructor(prototype: object, property: string, data?: T);
+}

package/dist/modules/reflection/models/property-attribute.model.js

@@ -0,0 +1,8 @@
+import { Attribute } from './attribute.model';
+export class PropertyAttribute extends Attribute {
+    property;
+    constructor(prototype, property, data) {
+        super(prototype, data);
+        this.property = property;
+    }
+}

package/dist/modules/reflection/models/property-proxy-attribute.model.d.ts

@@ -0,0 +1,15 @@
+import { PropertyAttribute } from './property-attribute.model';
+export declare abstract class PropertyProxyAttribute<T = any> extends PropertyAttribute<T> {
+    /**
+     * Acts as a proxy for the getter of the property.
+     * @param target The object containing the property.
+     */
+    get(target: object): object;
+    /**
+     * Acts as a proxy for the setter of the property.
+     * @param target The object containing the property.
+     * @param value The value to be assigned to the property.
+     * @returns The value to be assigned to the property.
+     */
+    set(target: object, value: unknown): unknown;
+}

package/dist/modules/reflection/models/property-proxy-attribute.model.js

@@ -0,0 +1,19 @@
+import { PropertyAttribute } from './property-attribute.model';
+export class PropertyProxyAttribute extends PropertyAttribute {
+    /**
+     * Acts as a proxy for the getter of the property.
+     * @param target The object containing the property.
+     */
+    get(target) {
+        return target;
+    }
+    /**
+     * Acts as a proxy for the setter of the property.
+     * @param target The object containing the property.
+     * @param value The value to be assigned to the property.
+     * @returns The value to be assigned to the property.
+     */
+    set(target, value) {
+        return value;
+    }
+}

package/dist/modules/reflection/types/constructor.type.d.ts

@@ -0,0 +1,2 @@
+export type Constructor<TType = any, TParams extends any[] = any[]> = new (...args: TParams) => TType;
+export type AbstractConstructor<TType = any, TParams extends any[] = any[]> = abstract new (...args: TParams) => TType;

package/dist/modules/reflection/types/instance.type.d.ts

@@ -0,0 +1,7 @@
+import { AbstractConstructor, Constructor } from './constructor.type';
+import { Type } from './type.type';
+export type Instance<T> = T extends Constructor<infer R> ? R : T extends AbstractConstructor<infer R> ? R : T extends Record<string, Type<any>> ? {
+    [K in keyof T]: Instance<T[K]>;
+} : T extends any[] ? {
+    [K in keyof T]: Instance<T[K]>;
+} : never;

package/dist/modules/reflection/types/type.type.d.ts

@@ -0,0 +1,2 @@
+import type { Constructor } from './constructor.type';
+export type Type<T = any> = Constructor<T> | Function;

package/dist/modules/reflection/utils/decorator.util.d.ts

@@ -0,0 +1,70 @@
+import type { Parameter } from '../interfaces/parameter.interface';
+import type { Type } from '../types/type.type';
+export declare abstract class Decorator<T = any> {
+    type: Type;
+    data: T;
+    constructor(type: Type, data: T);
+}
+export declare class ClassDecorator<T = any> extends Decorator<T> {
+    constructor(type: Type, data: T);
+}
+export declare class ConstructorParameterDecorator<T = any> extends Decorator<T> {
+    parameter: Parameter;
+    constructor(type: Type, parameter: Parameter, data: T);
+}
+export declare class PropertyDecorator<T = any> extends Decorator<T> {
+    property: string;
+    constructor(type: Type, property: string, data: T);
+}
+export declare class MethodDecorator<T = any> extends Decorator<T> {
+    method: string;
+    constructor(type: Type, method: string, data: T);
+}
+export declare class ParameterDecorator<T = any> extends Decorator<T> {
+    method: string;
+    parameter: Parameter;
+    constructor(type: Type, method: string, parameter: Parameter, data: T);
+}
+export interface DecoratorQuery<T extends Decorator> {
+    target: any;
+    type?: Type<T>;
+    first?: boolean;
+}
+export interface ClassDecoratorQuery<T extends Decorator> extends DecoratorQuery<T> {
+    kind: 'class';
+}
+export interface ConstructorParameterDecoratorQuery<T extends Decorator> extends DecoratorQuery<T> {
+    kind: 'ctor-parameter';
+    parameter?: string | number;
+}
+export interface PropertyDecoratorQuery<T extends Decorator> extends DecoratorQuery<T> {
+    kind: 'property';
+    property?: string;
+}
+export interface MethodDecoratorQuery<T extends Decorator> extends DecoratorQuery<T> {
+    kind: 'method';
+    method?: string;
+}
+export interface ParameterDecoratorQuery<T extends Decorator> extends DecoratorQuery<T> {
+    kind: 'parameter';
+    parameter?: string | number;
+}
+export type DecoratorQueries<T extends Decorator> = DecoratorQuery<T> | ClassDecoratorQuery<T> | ConstructorParameterDecoratorQuery<T> | PropertyDecoratorQuery<T> | MethodDecoratorQuery<T> | ParameterDecoratorQuery<T>;
+export declare class $Decorator {
+    private static decorators;
+    static createClassDecorator<T extends Type>(create: (type: T) => ClassDecorator): (target: T, _context: ClassDecoratorContext) => void;
+    static createConstructorParameterDecorator(create: (type: Type, parameter: Parameter) => ConstructorParameterDecorator): (_target: undefined, context: ClassFieldDecoratorContext) => (this: any, initialValue: any) => any;
+    static createPropertyDecorator(create: (type: Type, property: string) => PropertyDecorator): <T, V>(_target: ClassAccessorDecoratorTarget<T, V>, context: ClassAccessorDecoratorContext<T, V>) => {
+        init(this: T, initialValue: V): V;
+    };
+    static createMethodDecorator(create: (type: Type, method: string) => MethodDecorator): <T, A extends any[], R>(target: (this: T, ...args: A) => R, context: ClassMethodDecoratorContext<T, (this: T, ...args: A) => R>) => (this: T, ...args: A) => R;
+    static createParameterDecorator(create: (type: Type, method: string, parameter: Parameter) => ParameterDecorator): (methodName: string, parameterIndex: number, parameterName: string) => <T extends abstract new (...args: any) => any>(target: T, _context: ClassDecoratorContext<T>) => void;
+    static create(decorator: Decorator): void;
+    static destroy(decorator: Decorator): void;
+    static get<T extends Decorator>(query: DecoratorQueries<T> & {
+        first: true;
+    }): T;
+    static get<T extends Decorator>(query: DecoratorQueries<T> & {
+        first?: false;
+    }): T[];
+}

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

@@ -0,0 +1,135 @@
+import { $Array } from '../../array/array.util';
+import { $Reflection } from './reflection.util';
+export class Decorator {
+    type;
+    data;
+    constructor(type, data) {
+        this.type = type;
+        this.data = data;
+    }
+}
+export class ClassDecorator extends Decorator {
+    constructor(type, data) {
+        super(type, data);
+    }
+}
+export class ConstructorParameterDecorator extends Decorator {
+    parameter;
+    constructor(type, parameter, data) {
+        super(type, data);
+        this.parameter = parameter;
+    }
+}
+export class PropertyDecorator extends Decorator {
+    property;
+    constructor(type, property, data) {
+        super(type, data);
+        this.property = property;
+    }
+}
+export class MethodDecorator extends Decorator {
+    method;
+    constructor(type, method, data) {
+        super(type, data);
+        this.method = method;
+    }
+}
+export class ParameterDecorator extends Decorator {
+    method;
+    parameter;
+    constructor(type, method, parameter, data) {
+        super(type, data);
+        this.method = method;
+        this.parameter = parameter;
+    }
+}
+export class $Decorator {
+    static decorators = [];
+    static createClassDecorator(create) {
+        return (target, _context) => {
+            const decorator = create(target);
+            $Decorator.create(decorator);
+        };
+    }
+    static createConstructorParameterDecorator(create) {
+        return (_target, context) => {
+            return function (initialValue) {
+                const type = this.constructor;
+                const parameterNames = $Reflection.getParameterNames(type, 'constructor');
+                const index = parameterNames.indexOf(context.name);
+                const decorator = create(type, { index, name: context.name });
+                $Decorator.create(decorator);
+                return initialValue;
+            };
+        };
+    }
+    static createPropertyDecorator(create) {
+        return (_target, context) => {
+            return {
+                init(initialValue) {
+                    const type = this.constructor;
+                    const decorator = create(type, context.name);
+                    $Decorator.create(decorator);
+                    return initialValue;
+                },
+            };
+        };
+    }
+    static createMethodDecorator(create) {
+        return (target, context) => {
+            context.addInitializer(function () {
+                const decorator = create(this.constructor, context.name);
+                $Decorator.create(decorator);
+            });
+            return target;
+        };
+    }
+    static createParameterDecorator(create) {
+        return (methodName, parameterIndex, parameterName) => {
+            return (target, _context) => {
+                const decorator = create(target, methodName, { index: parameterIndex, name: parameterName });
+                $Decorator.create(decorator);
+            };
+        };
+    }
+    static create(decorator) {
+        $Decorator.decorators.push(decorator);
+    }
+    static destroy(decorator) {
+        $Decorator.decorators = $Array.remove($Decorator.decorators, decorator);
+    }
+    static get(query) {
+        const type = $Reflection.isType(query.target) ? query.target : $Reflection.getType(query.target);
+        const decorators = [];
+        for (const decorator of $Decorator.decorators) {
+            if (!$Reflection.extends(type, decorator.type))
+                continue;
+            if (query.type && !$Reflection.instanceOf(decorator, query.type))
+                continue;
+            if ('kind' in query) {
+                if (query.kind === 'class' && decorator instanceof ClassDecorator) {
+                }
+                else if (query.kind === 'ctor-parameter' && decorator instanceof ConstructorParameterDecorator) {
+                    if (query.parameter != null && decorator.parameter.index !== query.parameter && decorator.parameter.name !== query.parameter)
+                        continue;
+                }
+                else if (query.kind === 'method' && decorator instanceof MethodDecorator) {
+                    if (query.method && decorator.method !== query.method)
+                        continue;
+                }
+                else if (query.kind === 'parameter' && decorator instanceof ParameterDecorator) {
+                    if (query.parameter != null && decorator.parameter.index !== query.parameter && decorator.parameter.name !== query.parameter)
+                        continue;
+                }
+                else if (query.kind === 'property' && decorator instanceof PropertyDecorator) {
+                    if (query.property && decorator.property !== query.property)
+                        continue;
+                }
+            }
+            if (query.first)
+                return decorator;
+            decorators.push(decorator);
+        }
+        return query.first ? null : decorators;
+    }
+}

package/dist/modules/reflection/utils/reflection.util.d.ts

@@ -0,0 +1,140 @@
+import type { Constructor } from '../types/constructor.type';
+import type { Type } from '../types/type.type';
+export declare class $Reflection {
+    private 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<T extends Function>(func: T, name?: (keyof T['prototype'] & string) | 'constructor'): string[];
+    static combineClasses(...classes: Constructor[]): Constructor;
+    /**
+     * 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<T>(target: object | Type<T>, name: string): boolean;
+    /**
+     * Returns the type associate with the `prototype`.
+     * @param prototype The prototype which type to return.
+     */
+    static getProtoType(prototype: object): Type | null;
+    /**
+     * 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<T>(target: object | Type<T>, name: string, get: () => any, set: (value: any) => void): void;
+    /**
+     * Returns the type of the `value`.
+     * @param value The value which type to return.
+     */
+    static getType(value: any): Type | null | undefined;
+    /**
+     * 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: any): boolean;
+    /**
+     * Returns true if `value` is of type function, lambda or class.
+     * @param value The value to check.
+     */
+    static isFunction(value: any): value is Function;
+    /**
+     * Returns true if `value` is a type or function.
+     * @param value The value to check.
+     */
+    static isType<T = any>(value: any): value is Type<T>;
+    static isValidDate(value: any): value is Date;
+    /**
+     * Returns true if `value` is of type `Object`.
+     * @param value The value to check.
+     */
+    static isObject(value: any): value is Record<string, any>;
+    /**
+     * Returns true if `value` is of type `Symbol`.
+     * @param value The value to check.
+     */
+    static isSymbol(value: any): value is 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: any): boolean;
+    /**
+     * 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: Type): boolean;
+    /**
+     * 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: Type): boolean;
+    /**
+     * Returns all the properties of `object`.
+     * @param object The object which properties to return.
+     */
+    static getProperties(object: object): string[];
+    /**
+     * 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: Type): any;
+    /**
+     * 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: any, type: Type): any;
+    /**
+     * 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: any, type?: Type): boolean;
+    /**
+     * Returns true if `type` extends `base`.
+     * @param type The type to check.
+     * @param base The base of `type` to check.
+     */
+    static extends(type: Type, base: Type): boolean;
+    static instanceOf(value: any, type: Type): boolean;
+    /**
+     * Returns all the base types of `type`.
+     * @param type The type which base types to return.
+     */
+    static getTypeBases(type: Type): Type[];
+    /**
+     * Returns the base type of `value`.
+     * @param value The value which base type to return.
+     */
+    static getBaseType(value: any): Type;
+    /**
+     * Returns the base type of `type`.
+     * @param type The type which base type to return.
+     */
+    static getTypeBase(type: Type): Type;
+    static getTypeName(value: any): string;
+    static getSimpleTypeName(value: any): 'string' | 'number' | 'object' | 'array' | 'type' | 'null' | 'boolean' | 'bigint' | 'symbol' | 'function' | 'date';
+    static parsePrimitiveValue(value: string): string | number | boolean;
+}