@tsed/core 6.95.7 → 6.96.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsed/core",
-  "version": "6.95.7",
+  "version": "6.96.0",
   "description": "Core module for Ts.ED Framework",
   "private": false,
   "source": "./src/index.ts",

package/lib/cjs/decorators/configurable.d.ts

@@ -1,2 +0,0 @@
-/** */
-export declare function Configurable(value?: boolean): Function;

package/lib/cjs/decorators/deprecated.d.ts

@@ -1,32 +0,0 @@
-/**
- * The `@Deprecated()` decorators wraps the given method in such a way that it is marked as deprecated.
- *
- * ```typescript
- * provide Foo {
- *
- * @Deprecated("Foo.method: Use Foo.method2 instead")
- * public method() {
- *
- * }
- * ```
- *
- * When called, @Deprecated() will return a function that will emit a `DeprecationWarning` using the `process.on('warning')` event.
- * By default, this warning will be emitted and printed to `stderr` exactly once, the first time it is called. After the warning is emitted, the wrapped method is called.
- *
- * If either the `--no-deprecation` or `--no-warnings` command line flags are used, or if the `process.noDeprecation`
- * property is set to `true` prior to the first deprecation warning, the `@Deprecated()` decorators does nothing.
- *
- * If the `--trace-deprecation` or `--trace-warnings` command line flags are set, or the `process.traceDeprecation`
- * property is set to `true`, a warning and a stack trace are printed to stderr the first time the deprecated function is called.
- *
- * If the `--throw-deprecation` command line flag is set, or the `process.throwDeprecation` property is set to `true`,
- * then an exception will be thrown when the deprecated function is called.
- *
- * The `--throw-deprecation` command line flag and `process.throwDeprecation` property take precedence over `--trace-deprecation`
- * and `process.traceDeprecation`.
- *
- * @param message
- * @returns {Function}
- * @decorator
- */
-export declare function Deprecated(message: string): Function;

package/lib/cjs/decorators/enumerable.d.ts

@@ -1,2 +0,0 @@
-/** */
-export declare function Enumerable(value?: boolean): Function;

package/lib/cjs/decorators/index.d.ts

@@ -1,14 +0,0 @@
-/**
- * @module common/core
- */
-/** */
-export * from "./deprecated";
-export * from "./configurable";
-export * from "./enumerable";
-export * from "./writable";
-export * from "./readOnly";
-export * from "./notConfigurable";
-export * from "./notEnumerable";
-export * from "./storeSet";
-export * from "./storeMerge";
-export * from "./storeFn";

package/lib/cjs/decorators/notConfigurable.d.ts

@@ -1,2 +0,0 @@
-/** */
-export declare function NotConfigurable(): Function;

package/lib/cjs/decorators/notEnumerable.d.ts

@@ -1,2 +0,0 @@
-/** */
-export declare function NotEnumerable(): Function;

package/lib/cjs/decorators/readOnly.d.ts

@@ -1,2 +0,0 @@
-/** */
-export declare function Readonly(): Function;

package/lib/cjs/decorators/storeFn.d.ts

@@ -1,9 +0,0 @@
-import { Store } from "../domain/Store";
-import { DecoratorParameters } from "../interfaces/DecoratorParameters";
-/**
- * Create a store correctly configured from the parameters given by the decorator.
- * The `fn` can return a decorator that will be initialized with the parameters (target, propertyKey, descriptor).
- * @param {(store: Store, parameters: DecoratorParameters) => void} fn
- * @returns {Function}
- */
-export declare function StoreFn(fn: (store: Store, parameters: DecoratorParameters) => void): Function;

package/lib/cjs/decorators/storeMerge.d.ts

@@ -1 +0,0 @@
-export declare function StoreMerge(key: any, value: any): Function;

package/lib/cjs/decorators/storeSet.d.ts

@@ -1 +0,0 @@
-export declare function StoreSet(key: any, value: any): Function;

package/lib/cjs/decorators/writable.d.ts

@@ -1,2 +0,0 @@
-/** */
-export declare function Writable(value?: boolean): Function;

package/lib/cjs/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/cjs/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/cjs/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/cjs/domain/Hooks.d.ts

@@ -1,45 +0,0 @@
-export declare class Hooks {
-    private listeners;
-    /**
-     * 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(event: string, value: any, args?: any[], callThis?: any): any;
-    /**
-     * 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(event: string, value: any, args?: string[], callThis?: any): Promise<any>;
-}

package/lib/cjs/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[];
-}