@tsed/core 8.0.0-alpha.1 → 8.0.0-alpha.10

package/lib/types-esm/domain/AnyToPromise.d.ts

@@ -1,42 +0,0 @@
-/**
- * @ignore
- */
-export declare enum AnyToPromiseStatus {
-    PENDING = "PENDING",
-    CANCELED = "CANCELED",
-    RESOLVED = "RESOLVED",
-    REJECTED = "REJECTED"
-}
-export declare enum AnyToPromiseResponseTypes {
-    STREAM = "STREAM",
-    BUFFER = "BUFFER",
-    DATA = "DATA"
-}
-export interface AnyPromiseResult<T = any> {
-    state: AnyToPromiseStatus;
-    type: AnyToPromiseResponseTypes;
-    status?: number;
-    headers?: Record<string, any>;
-    data: T;
-}
-export declare class AnyToPromise<T = any> {
-    #private;
-    status: AnyToPromiseStatus;
-    args: any[];
-    constructor({ hasNextFunction }?: {
-        hasNextFunction?: boolean;
-    });
-    isDone(): boolean;
-    get next(): (error?: any) => void;
-    /**
-     *
-     */
-    call(cb: Function): Promise<AnyPromiseResult<T>>;
-    reject(er: any): void;
-    resolve(response?: any): void;
-    destroy(): void;
-    cancel(): any;
-    done(status: AnyToPromiseStatus): void;
-    handle(process: any, additionalProps?: {}): any;
-    protected isCanceledResponse(process: any): boolean;
-}

package/lib/types-esm/domain/DecoratorTypes.d.ts

@@ -1,10 +0,0 @@
-export declare enum DecoratorTypes {
-    PARAM = "parameter",
-    PARAM_CTOR = "parameter.constructor",
-    PARAM_STC = "parameter.static",
-    PROP = "property",
-    PROP_STC = "property.static",
-    METHOD = "method",
-    METHOD_STC = "method.static",
-    CLASS = "class"
-}

package/lib/types-esm/domain/Env.d.ts

@@ -1,13 +0,0 @@
-/**
- *
- */
-export declare enum Env {
-    PROD = "production",
-    DEV = "development",
-    TEST = "test"
-}
-/**
- * Fallback
- * @type {Env}
- */
-export declare const EnvTypes: typeof Env;

package/lib/types-esm/domain/Hooks.d.ts

@@ -1,47 +0,0 @@
-export declare class Hooks {
-    #private;
-    has(event: string): boolean;
-    /**
-     * Listen a hook event
-     * @param event
-     * @param cb
-     */
-    on(event: string, cb: Function): this;
-    /**
-     * Remove a listener attached to an event
-     * @param event
-     * @param cb
-     */
-    off(event: string, cb: Function): this;
-    /**
-     * Trigger an event and call listener.
-     * @param event
-     * @param args
-     * @param callThis
-     */
-    emit(event: string, args?: any[], callThis?: any): void;
-    /**
-     * Trigger an event, listener alter given value and return it.
-     * @param event
-     * @param value
-     * @param args
-     * @param callThis
-     */
-    alter<Arg = any, AlteredArg = Arg>(event: string, value: Arg, args?: any[], callThis?: any): AlteredArg;
-    /**
-     * Trigger an event and call async listener.
-     * @param event
-     * @param args
-     * @param callThis
-     */
-    asyncEmit(event: string, args?: any[], callThis?: any): Promise<void>;
-    /**
-     * Trigger an event, async listener alter given value and return it.
-     * @param event
-     * @param value
-     * @param args
-     * @param callThis
-     */
-    asyncAlter<Arg = any, AlteredArg = Arg>(event: string, value: Arg, args?: any[], callThis?: any): Promise<AlteredArg>;
-    destroy(): void;
-}

package/lib/types-esm/domain/Metadata.d.ts

@@ -1,442 +0,0 @@
-import "reflect-metadata";
-/**
- * @stable
- */
-export declare class Metadata {
-    /**
-     * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
-     * @param key A key used to store and retrieve metadata.
-     * @param target The target object on which the metadata is defined.
-     * @param propertyKey The property key for the target.
-     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-     * @example
-     *
-     * ```typescript
-     * class Example {
-     *     // property declarations are not part of ES6, though they are valid in TypeScript:
-     *     // static staticProperty;
-     *     // property;
-     *
-     *     static staticMethod(p) { }
-     *     method(p) { }
-     * }
-     *
-     * // constructor
-     * result = Metadata.get("custom:annotation", Example);
-     *
-     * // property (on constructor)
-     * result = Metadata.get("custom:annotation", Example, "staticProperty");
-     *
-     * // property (on prototype)
-     * result = Metadata.get("custom:annotation", Example.prototype, "property");
-     *
-     * // method (on constructor)
-     * result = Metadata.get("custom:annotation", Example, "staticMethod");
-     *
-     * // method (on prototype)
-     * result = Metadata.get("custom:annotation", Example.prototype, "method");
-     * ```
-     *
-     */
-    static get(key: string, target: any, propertyKey?: string | symbol): any;
-    /**
-     * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
-     * @param key A key used to store and retrieve metadata.
-     * @param target The target object on which the metadata is defined.
-     * @param propertyKey The property key for the target.
-     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-     * @example
-     *
-     * ```typescript
-     * class Example {
-     *     // property declarations are not part of ES6, though they are valid in TypeScript:
-     *     // static staticProperty;
-     *     // property;
-     *
-     *     static staticMethod(p) { }
-     *     method(p) { }
-     * }
-     *
-     * // constructor
-     * result = Metadata.getOwn("custom:annotation", Example);
-     *
-     * // property (on constructor)
-     * result = Metadata.getOwn("custom:annotation", Example, "staticProperty");
-     *
-     * // property (on prototype)
-     * result = Metadata.getOwn("custom:annotation", Example.prototype, "property");
-     *
-     * // method (on constructor)
-     * result = Metadata.getOwn("custom:annotation", Example, "staticMethod");
-     *
-     * // method (on prototype)
-     * result = Metadata.getOwn("custom:annotation", Example.prototype, "method");
-     * ```
-     *
-     */
-    static getOwn(key: string, target: any, propertyKey?: string | symbol): any;
-    /**
-     * Gets the metadata value for the provided metadata DESIGN_TYPE on the target object or its prototype chain.
-     * @param target The target object on which the metadata is defined.
-     * @param propertyKey The property key for the target.
-     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-     * @example
-     *
-     * ```typescript
-     * class Example {
-     *     // property declarations are not part of ES6, though they are valid in TypeScript:
-     *     // static staticProperty;
-     *     // property;
-     *
-     *     static staticMethod(p) { }
-     *     method(p) { }
-     * }
-     *
-     * // on contructor
-     * result = Metadata.getType(Example);
-     *
-     * // property (on constructor)
-     * result = Metadata.getType(Example, "staticProperty");
-     *
-     * // method (on constructor)
-     * result = Metadata.getType(Example, "staticMethod");
-     * ```
-     *
-     */
-    static getType(target: any, propertyKey?: string | symbol): any;
-    /**
-     * Gets the metadata value for the provided metadata DESIGN_TYPE on the target object or its prototype chain.
-     * @param target The target object on which the metadata is defined.
-     * @param propertyKey The property key for the target.
-     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-     * @example
-     *
-     * ```typescript
-     * class Example {
-     *     // property declarations are not part of ES6, though they are valid in TypeScript:
-     *     // static staticProperty;
-     *     // property;
-     *
-     *     static staticMethod(p) { }
-     *     method(p) { }
-     * }
-     *
-     * // on contructor
-     * result = Metadata.getOwnType(Example);
-     *
-     * // property (on constructor)
-     * result = Metadata.getOwnType(Example, "staticProperty");
-     *
-     * // method (on constructor)
-     * result = Metadata.getOwnType(Example, "staticMethod");
-     * ```
-     *
-     */
-    static getOwnType(target: any, propertyKey?: string | symbol): any;
-    /**
-     * Gets the metadata value for the provided metadata DESIGN_RETURN_TYPE on the target object or its prototype chain.
-     * @param target The target object on which the metadata is defined.
-     * @param propertyKey The property key for the target.
-     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-     * @example
-     *
-     * ```typescript
-     * class Example {
-     *     // property declarations are not part of ES6, though they are valid in TypeScript:
-     *     // static staticProperty;
-     *     // property;
-     *
-     *     static staticMethod(p) { }
-     *     method(p) { }
-     * }
-     *
-     * // on contructor
-     * result = Metadata.getReturnType(Example);
-     *
-     * // property (on constructor)
-     * result = Metadata.getReturnType(Example, "staticProperty");
-     *
-     * // method (on constructor)
-     * result = Metadata.getReturnType(Example, "staticMethod");
-     * ```
-     *
-     */
-    static getReturnType(target: any, propertyKey?: string | symbol): any;
-    /**
-     * Gets the metadata value for the provided metadata DESIGN_RETURN_TYPE on the target object or its prototype chain.
-     * @param target The target object on which the metadata is defined.
-     * @param propertyKey The property key for the target.
-     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-     * @example
-     *
-     * ```typescript
-     * class Example {
-     *     // property declarations are not part of ES6, though they are valid in TypeScript:
-     *     // static staticProperty;
-     *     // property;
-     *
-     *     static staticMethod(p) { }
-     *     method(p) { }
-     * }
-     *
-     * // on contructor
-     * result = Metadata.getOwnReturnType(Example);
-     *
-     * // property (on constructor)
-     * result = Metadata.getOwnReturnType(Example, "staticProperty");
-     *
-     * // method (on constructor)
-     * result = Metadata.getOwnReturnType(Example, "staticMethod");
-     * ```
-     *
-     */
-    static getOwnReturnType(target: any, propertyKey?: string | symbol): any;
-    /**
-     * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
-     * @param key A key used to store and retrieve metadata.
-     * @param target The target object on which the metadata is defined.
-     * @param propertyKey The property key for the target.
-     * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
-     * @example
-     *
-     * ```typescript
-     * class Example {
-     *     // property declarations are not part of ES6, though they are valid in TypeScript:
-     *     // static staticProperty;
-     *     // property;
-     *
-     *     static staticMethod(p) { }
-     *     method(p) { }
-     * }
-     *
-     * // constructor
-     * result = Metadata.has("custom:annotation", Example);
-     *
-     * // property (on constructor)
-     * result = Metadata.has("custom:annotation", Example, "staticProperty");
-     *
-     * // property (on prototype)
-     * result = Metadata.has("custom:annotation", Example.prototype, "property");
-     *
-     * // method (on constructor)
-     * result = Metadata.has("custom:annotation", Example, "staticMethod");
-     *
-     * // method (on prototype)
-     * result = Metadata.has("custom:annotation", Example.prototype, "method");
-     * ```
-     *
-     */
-    static has(key: string, target: any, propertyKey?: string | symbol): boolean;
-    /**
-     * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
-     * @param key A key used to store and retrieve metadata.
-     * @param target The target object on which the metadata is defined.
-     * @param propertyKey The property key for the target.
-     * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
-     * @example
-     *
-     * ```typescript
-     * class Example {
-     *     // property declarations are not part of ES6, though they are valid in TypeScript:
-     *     // static staticProperty;
-     *     // property;
-     *
-     *     static staticMethod(p) { }
-     *     method(p) { }
-     * }
-     *
-     * // constructor
-     * result = Metadata.has("custom:annotation", Example);
-     *
-     * // property (on constructor)
-     * result = Metadata.hasOwn("custom:annotation", Example, "staticProperty");
-     *
-     * // property (on prototype)
-     * result = Metadata.hasOwn("custom:annotation", Example.prototype, "property");
-     *
-     * // method (on constructor)
-     * result = Metadata.hasOwn("custom:annotation", Example, "staticMethod");
-     *
-     * // method (on prototype)
-     * result = Metadata.hasOwn("custom:annotation", Example.prototype, "method");
-     * ```
-     *
-     */
-    static hasOwn(key: string, target: any, propertyKey?: string | symbol): boolean;
-    /**
-     * Deletes the metadata entry from the target object with the provided key.
-     * @param key A key used to store and retrieve metadata.
-     * @param target The target object on which the metadata is defined.
-     * @param propertyKey The property key for the target.
-     * @returns `true` if the metadata entry was found and deleted; otherwise, false.
-     * @example
-     *
-     * ```typescript
-     * class Example {
-     *     // property declarations are not part of ES6, though they are valid in TypeScript:
-     *     // static staticProperty;
-     *     // property;
-     *
-     *     static staticMethod(p) { }
-     *     method(p) { }
-     * }
-     *
-     * // constructor
-     * result = Metadata.delete("custom:annotation", Example);
-     *
-     * // property (on constructor)
-     * result = Metadata.delete("custom:annotation", Example, "staticProperty");
-     *
-     * // property (on prototype)
-     * result = Metadata.delete("custom:annotation", Example.prototype, "property");
-     *
-     * // method (on constructor)
-     * result = Metadata.delete("custom:annotation", Example, "staticMethod");
-     *
-     * // method (on prototype)
-     * result = Metadata.delete("custom:annotation", Example.prototype, "method");
-     * ```
-     *
-     */
-    static delete(key: string, target: any, propertyKey?: string | symbol): boolean;
-    /**
-     * Set the metadata value for the provided metadata DESIGN_PARAM_TYPES on the target object or its prototype chain.
-     * @param target The target object on which the metadata is defined.
-     * @param propertyKey The property key for the target.
-     * @param value A value that contains attached metadata.
-     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-     * @example
-     *
-     * ```typescript
-     * class Example {
-     *     // property declarations are not part of ES6, though they are valid in TypeScript:
-     *     // static staticProperty;
-     *     // property;
-     *
-     *     static staticMethod(p) { }
-     *     method(p) { }
-     * }
-     *
-     * // on contructor
-     * result = Metadata.setParamTypes(Example, undefined, [Object]);
-     *
-     * // property (on constructor)
-     * result = Metadata.setParamTypes(Example, "staticProperty", [Object]);
-     *
-     * // property (on prototype)
-     * result = Metadata.setParamTypes(Example.prototype, "property", [Object]);
-     *
-     * // method (on constructor)
-     * result = Metadata.setParamTypes(Example, "staticMethod", [Object]);
-     *
-     * // method (on prototype)
-     * result = Metadata.setParamTypes(Example.prototype, "method", [Object]);
-     * ```
-     *
-     */
-    static setParamTypes(target: any, propertyKey: string | symbol, value: any): void;
-    /**
-     * Get all metadata for a metadataKey.
-     * @param metadataKey
-     */
-    static getTargetsFromPropertyKey: (metadataKey: string | symbol) => any[];
-    /**
-     * Define a unique metadata entry on the target.
-     * @param key A key used to store and retrieve metadata.
-     * @param value A value that contains attached metadata.
-     * @param target The target object on which to define metadata.
-     * @param propertyKey The property key for the target.
-     * @example
-     *
-     * ```typescript
-     * class Example {
-     *     // property declarations are not part of ES6, though they are valid in TypeScript:
-     *     // static staticProperty;
-     *     // property;
-     *
-     *     static staticMethod(p) { }
-     *     method(p) { }
-     * }
-     *
-     * // constructor
-     * Reflect.defineMetadata("custom:annotation", options, Example);
-     *
-     * // property (on constructor)
-     * Reflect.defineMetadata("custom:annotation", Number, Example, "staticProperty");
-     *
-     * // property (on prototype)
-     * Reflect.defineMetadata("custom:annotation", Number, Example.prototype, "property");
-     *
-     * // method (on constructor)
-     * Reflect.defineMetadata("custom:annotation", Number, Example, "staticMethod");
-     *
-     * // method (on prototype)
-     * Reflect.defineMetadata("custom:annotation", Number, Example.prototype, "method");
-     *
-     * // decorator factory as metadata-producing annotation.
-     * function MyAnnotation(options): PropertyDecorator {
-     *     return (target, key) => Reflect.defineMetadata("custom:annotation", options, target, key);
-     * }
-     * ```
-     *
-     */
-    static set(key: string, value: any, target: any, propertyKey?: string | symbol): void;
-    /**
-     * Gets the metadata value for the provided metadata DESIGN_PARAM_TYPES on the target object or its prototype chain.
-     * @param targetPrototype
-     * @param propertyKey The property key for the target.
-     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-     * @example
-     *
-     * ```typescript
-     * class Example {
-     *     // property declarations are not part of ES6, though they are valid in TypeScript:
-     *     // static staticProperty;
-     *     // property;
-     *
-     *     static staticMethod(p) { }
-     *     method(p) { }
-     * }
-     *
-     * // on contructor
-     * result = Metadata.getParamTypes(Example.prototype);
-     *
-     * // property (on constructor)
-     * result = Metadata.getParamTypes(Example.prototype, "staticProperty");
-     *
-     * // method (on constructor)
-     * result = Metadata.getParamTypes(Example.prototype, "staticMethod");
-     * ```
-     *
-     */
-    static getParamTypes(targetPrototype: any, propertyKey?: string | symbol): any[];
-    /**
-     * Gets the metadata value for the provided metadata DESIGN_PARAM_TYPES on the target object or its prototype chain.
-     * @param target The target object on which the metadata is defined.
-     * @param propertyKey The property key for the target.
-     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-     * @example
-     *
-     * ```typescript
-     * class Example {
-     *     // property declarations are not part of ES6, though they are valid in TypeScript:
-     *     // static staticProperty;
-     *     // property;
-     *
-     *     static staticMethod(p) { }
-     *     method(p) { }
-     * }
-     *
-     * // on contructor
-     * result = Metadata.getParamTypes(Example);
-     *
-     * // property (on constructor)
-     * result = Metadata.getParamTypes(Example, "staticProperty");
-     *
-     * // method (on constructor)
-     * result = Metadata.getParamTypes(Example, "staticMethod");
-     * ```
-     *
-     */
-    static getOwnParamTypes(target: any, propertyKey?: string | symbol): any[];
-}

package/lib/types-esm/domain/Store.d.ts

@@ -1,69 +0,0 @@
-import type { Type } from "./Type.js";
-/**
- * @ignore
- */
-export declare const CLASS_STORE = "tsed:class:store";
-/**
- * @ignore
- */
-export declare const METHOD_STORE = "tsed:method:store";
-/**
- * @ignore
- */
-export declare const PROPERTY_STORE = "tsed:property:store";
-/**
- * @ignore
- */
-export declare const PARAM_STORE = "tsed:param:store";
-export declare class Store {
-    private _entries;
-    /**
-     * Create or get a Store from args {target + methodName + descriptor}
-     * @param args
-     * @returns {Store}
-     */
-    static from(...args: any[]): Store;
-    /**
-     * Create store on the method.
-     * @param target
-     * @param {string} propertyKey
-     * @returns {Store}
-     */
-    static fromMethod(target: any, propertyKey: string | symbol): Store;
-    static mergeStoreFrom(target: Type<any>, source: Type<any>, ...args: any[]): Store;
-    static mergeStoreMethodFrom(target: Type<any>, source: Type<any>, propertyKey: string | symbol): Store;
-    /**
-     * The get() method returns a specified element from a Map object.
-     * @param key Required. The key of the element to return from the Map object.
-     * @param defaultValue
-     * @returns {T} Returns the element associated with the specified key or undefined if the key can't be found in the Map object.
-     */
-    get<T = any>(key: any, defaultValue?: any): T;
-    /**
-     * The has() method returns a boolean indicating whether an element with the specified key exists or not.
-     * @param key
-     * @returns {boolean}
-     */
-    has(key: any): boolean;
-    /**
-     * The set() method adds or updates an element with a specified key and value to a Map object.
-     * @param key Required. The key of the element to add to the Map object.
-     * @param metadata Required. The value of the element to add to the Map object.
-     */
-    set(key: any, metadata: any): Store;
-    /**
-     * The delete() method removes the specified element from a Map object.
-     * @param key Required. The key of the element to remove from the Map object.
-     * @returns {boolean} Returns true if an element in the Map object existed and has been removed, or false if the element does not exist.
-     */
-    delete(key: string): boolean;
-    /**
-     * Merge given value with existing value.
-     * @param key
-     * @param value
-     * @param inverse Change the merge order. Get the existing value and apply over given value
-     * @returns {Store}
-     */
-    merge(key: any, value: any, inverse?: boolean): Store;
-    toJson(): {};
-}

package/lib/types-esm/domain/Type.d.ts

@@ -1,14 +0,0 @@
-/**
- * An example of a `Type` is `MyCustomComponent` filters, which in JavaScript is represented by
- * the `MyCustomComponent` constructor function.
- */
-/**
- *
- */
-export interface Type<T = any> extends Function {
-    new (...args: any[]): T;
-}
-export declare const Type: FunctionConstructor;
-export interface AbstractType<T> extends Function {
-    prototype: T;
-}

package/lib/types-esm/errors/UnsupportedDecoratorType.d.ts

@@ -1,5 +0,0 @@
-export declare class UnsupportedDecoratorType extends Error {
-    name: "UNSUPPORTED_DECORATOR_TYPE";
-    constructor(decorator: any, args: any[]);
-    private static buildMessage;
-}