@dipscope/type-manager 3.0.0 → 4.0.2

package/core/inject-metadata.d.ts

@@ -1,6 +1,7 @@
+import { InjectIndex } from './inject-index';
 import { InjectOptions } from './inject-options';
 import { Metadata } from './metadata';
-import { TypeCtor } from './type-ctor';
+import { TypeFn } from './type-fn';
 import { TypeMetadata } from './type-metadata';
 /**
  * Main class used to describe an injection.
@@ -15,19 +16,19 @@ export declare class InjectMetadata<TDeclaringType, TType> extends Metadata {
      */
     readonly declaringTypeMetadata: TypeMetadata<TDeclaringType>;
     /**
-     * Index of injection within a type constructor function.
+     * Type function defined using reflect metadata.
+     *
+     * Used as a fallback when type function is not defined.
      *
-     * @type {number}
+     * @type {TypeFn<TType>}
      */
-    readonly index: number;
+    readonly reflectTypeFn: TypeFn<TType>;
     /**
-     * Type constructor defined using reflect metadata.
-     *
-     * Used as a fallback when type constructor is not defined.
+     * Index of injection within a type constructor function.
      *
-     * @type {TypeCtor<TType>}
+     * @type {InjectIndex}
      */
-    readonly reflectTypeCtor: TypeCtor<TType>;
+    readonly injectIndex: InjectIndex;
     /**
      * Inject options.
      *
@@ -38,10 +39,10 @@ export declare class InjectMetadata<TDeclaringType, TType> extends Metadata {
      * Constructor.
      *
      * @param {TypeMetadata<TDeclaringType>} declaringTypeMetadata Type metadata to which inject metadata belongs to.
-     * @param {number} index Index of injection within a type constructor function.
+     * @param {InjectIndex} injectIndex Index of injection within a type constructor function.
      * @param {InjectOptions<TType>} injectOptions Inject options.
      */
-    constructor(declaringTypeMetadata: TypeMetadata<TDeclaringType>, index: number, injectOptions: InjectOptions<TType>);
+    constructor(declaringTypeMetadata: TypeMetadata<TDeclaringType>, injectIndex: InjectIndex, injectOptions: InjectOptions<TType>);
     /**
      * Gets key.
      *
@@ -49,11 +50,11 @@ export declare class InjectMetadata<TDeclaringType, TType> extends Metadata {
      */
     get key(): string | undefined;
     /**
-     * Gets type constructor.
+     * Gets type function.
      *
-     * @returns {TypeCtor<TType>|undefined} Type constructor or undefined.
+     * @returns {TypeFn<TType>|undefined} Type constructor or undefined.
      */
-    get typeCtor(): TypeCtor<TType> | undefined;
+    get typeFn(): TypeFn<TType> | undefined;
     /**
      * Gets inject type metadata.
      *

package/core/inject-options.d.ts

@@ -1,4 +1,4 @@
-import { TypeCtor } from './type-ctor';
+import { TypeFn } from './type-fn';
 /**
  * Inject options.
  *
@@ -6,8 +6,8 @@ import { TypeCtor } from './type-ctor';
  */
 export interface InjectOptions<TType> {
     /**
-     * Parameter key to inject within a type context. If specified
-     * type constructor will be ignored.
+     * Parameter key to inject within a type context. If specified then
+     * type function will be ignored.
      *
      * @type {string}
      */
@@ -16,7 +16,7 @@ export interface InjectOptions<TType> {
      * Type of injection. Used if key is not specified. Will be resolved using
      * type injector.
      *
-     * @type {TypeCtor<TType>}
+     * @type {TypeFn<TType>}
      */
-    typeCtor?: TypeCtor<TType>;
+    typeFn?: TypeFn<TType>;
 }

package/core/log.d.ts

@@ -39,27 +39,27 @@ export declare class Log {
      * Displays info message.
      *
      * @param {string} message Message to display.
-     * @param {any[]} optionalParams Optional data related to a message.
+     * @param {Array<any>} optionalParams Optional data related to a message.
      *
      * @returns {void}
      */
-    info(message: string, ...optionalParams: any[]): void;
+    info(message: string, ...optionalParams: Array<any>): void;
     /**
      * Displays warn message.
      *
      * @param {string} message Message to display.
-     * @param {any[]} optionalParams Optional data related to a message.
+     * @param {Array<any>} optionalParams Optional data related to a message.
      *
      * @returns {void}
      */
-    warn(message: any, ...optionalParams: any[]): void;
+    warn(message: any, ...optionalParams: Array<any>): void;
     /**
      * Displays error message.
      *
      * @param {string} message Message to display.
-     * @param {any[]} optionalParams Optional data related to a message.
+     * @param {Array<any>} optionalParams Optional data related to a message.
      *
      * @returns {void}
      */
-    error(message: string, ...optionalParams: any[]): void;
+    error(message: string, ...optionalParams: Array<any>): void;
 }

package/core/metadata.d.ts

@@ -34,9 +34,9 @@ export declare class Metadata {
     /**
      * Defines generic metadatas based on provided generic arguments.
      *
-     * @param {GenericArgument<any>[]} genericArguments Generic arguments.
+     * @param {Array<GenericArgument<any>>} genericArguments Generic arguments.
      *
-     * @returns {GenericMetadata<any>[]} Generics metadatas.
+     * @returns {Array<GenericMetadata<any>>} Generics metadatas.
      */
-    protected defineGenericMetadatas(genericArguments: GenericArgument<any>[]): GenericMetadata<any>[];
+    protected defineGenericMetadatas(genericArguments: Array<GenericArgument<any>>): Array<GenericMetadata<any>>;
 }

package/core/property-metadata.d.ts

@@ -1,17 +1,15 @@
 import { Alias } from './alias';
 import { CustomData } from './custom-data';
-import { Factory } from './factory';
 import { GenericArgument } from './generic-argument';
 import { GenericMetadata } from './generic-metadata';
-import { Injector } from './injector';
-import { Log } from './log';
 import { Metadata } from './metadata';
 import { NamingConvention } from './naming-convention';
+import { PropertyName } from './property-name';
 import { PropertyOptions } from './property-options';
 import { ReferenceHandler } from './reference-handler';
 import { Serializer } from './serializer';
 import { TypeArgument } from './type-argument';
-import { TypeCtor } from './type-ctor';
+import { TypeFn } from './type-fn';
 import { TypeMetadata } from './type-metadata';
 /**
  * Main class used to describe a certain property.
@@ -26,19 +24,19 @@ export declare class PropertyMetadata<TDeclaringType, TType> extends Metadata {
      */
     readonly declaringTypeMetadata: TypeMetadata<TDeclaringType>;
     /**
-     * Property name as declared in type.
+     * Type function defined using reflect metadata.
+     *
+     * Used as a fallback when type argument is not defined.
      *
-     * @type {string}
+     * @type {TypeFn<TType>}
      */
-    readonly name: string;
+    readonly reflectTypeFn: TypeFn<TType>;
     /**
-     * Type constructor defined using reflect metadata.
-     *
-     * Used as a fallback when type argument is not defined.
+     * Property name as declared in type.
      *
-     * @type {TypeCtor<TType>}
+     * @type {PropertyName}
      */
-    readonly reflectTypeCtor: TypeCtor<TType>;
+    readonly propertyName: PropertyName;
     /**
      * Property options.
      *
@@ -49,10 +47,10 @@ export declare class PropertyMetadata<TDeclaringType, TType> extends Metadata {
      * Constructor.
      *
      * @param {TypeMetadata<TDeclaringType>} declaringTypeMetadata Type metadata to which property metadata belongs to.
-     * @param {string} name Property name.
+     * @param {PropertyName} propertyName Property name.
      * @param {PropertyOptions<TType>} propertyOptions Property options.
      */
-    constructor(declaringTypeMetadata: TypeMetadata<TDeclaringType>, name: string, propertyOptions: PropertyOptions<TType>);
+    constructor(declaringTypeMetadata: TypeMetadata<TDeclaringType>, propertyName: PropertyName, propertyOptions: PropertyOptions<TType>);
     /**
      * Gets alias.
      *
@@ -77,36 +75,18 @@ export declare class PropertyMetadata<TDeclaringType, TType> extends Metadata {
      * @returns {boolean|undefined} Deserializable indicator or undefined.
      */
     get deserializable(): boolean | undefined;
-    /**
-     * Gets factory.
-     *
-     * @returns {Factory} Factory.
-     */
-    get factory(): Factory;
     /**
      * Gets generic arguments.
      *
-     * @returns {GenericArgument<any>[]|undefined} Generic arguments or undefined.
+     * @returns {Array<GenericArgument<any>>|undefined} Generic arguments or undefined.
      */
-    get genericArguments(): GenericArgument<any>[] | undefined;
+    get genericArguments(): Array<GenericArgument<any>> | undefined;
     /**
      * Gets generic metadatas.
      *
-     * @returns {GenericMetadata<any>[]|undefined} Generic metadatas.
-     */
-    get genericMetadatas(): GenericMetadata<any>[] | undefined;
-    /**
-     * Gets injector.
-     *
-     * @returns {Injector} Injector.
-     */
-    get injector(): Injector;
-    /**
-     * Gets log.
-     *
-     * @returns {Log} Log.
+     * @returns {Array<GenericMetadata<any>>|undefined} Generic metadatas.
      */
-    get log(): Log;
+    get genericMetadatas(): Array<GenericMetadata<any>> | undefined;
     /**
      * Gets naming convention.
      *
@@ -161,6 +141,14 @@ export declare class PropertyMetadata<TDeclaringType, TType> extends Metadata {
      * @returns {boolean} Use implicit conversion indicator.
      */
     get useImplicitConversion(): boolean;
+    /**
+     * Configures custom data.
+     *
+     * @param {CustomData} customData Custom data.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Instance of property metadata.
+     */
+    private configureCustomData;
     /**
      * Configures property metadata based on provided options.
      *

package/core/property-name.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Type to explicitly define a property name within a source code.
+ *
+ * @type {PropertyName}
+ */
+export declare type PropertyName = string;

package/core/property-options.d.ts

@@ -1,12 +1,16 @@
 import { Alias } from './alias';
+import { CustomData } from './custom-data';
+import { GenericArgument } from './generic-argument';
+import { NamingConvention } from './naming-convention';
+import { ReferenceHandler } from './reference-handler';
+import { Serializer } from './serializer';
 import { TypeArgument } from './type-argument';
-import { TypeOptionsBase } from './type-options-base';
 /**
  * Property options.
  *
  * @type {PropertyOptions<TType>}
  */
-export interface PropertyOptions<TType> extends Partial<TypeOptionsBase<TType>> {
+export interface PropertyOptions<TType> {
     /**
      * Property alias.
      *
@@ -15,22 +19,74 @@ export interface PropertyOptions<TType> extends Partial<TypeOptionsBase<TType>>
      * @type {Alias}
      */
     alias?: Alias;
+    /**
+     * Custom developer data.
+     *
+     * @type {CustomData}
+     */
+    customData?: CustomData;
+    /**
+     * Default value for undefined ones.
+     *
+     * Can be a lazy function which returns a value. Assigned only when
+     * use default value option is true.
+     *
+     * @type {any}
+     */
+    defaultValue?: any;
     /**
      * Deserializable from object?
      *
      * @type {boolean}
      */
     deserializable?: boolean;
+    /**
+     * Generic arguments.
+     *
+     * @type {Array<GenericArgument<any>>}
+     */
+    genericArguments?: Array<GenericArgument<any>>;
+    /**
+     * Naming convention.
+     *
+     * @type {NamingConvention}
+     */
+    namingConvention?: NamingConvention;
+    /**
+     * Reference handler.
+     *
+     * @type {ReferenceHandler}
+     */
+    referenceHandler?: ReferenceHandler;
     /**
      * Serializable to object?
      *
      * @type {boolean}
      */
     serializable?: boolean;
+    /**
+     * Serializer used to serialize and deserialize a property.
+     *
+     * @type {Serializer<TType>}
+     */
+    serializer?: Serializer<TType>;
     /**
      * Type argument.
      *
      * @type {TypeArgument<TType>}
      */
     typeArgument?: TypeArgument<TType>;
+    /**
+     * Use default value assignment for undefined values?
+     *
+     * @type {boolean}
+     */
+    useDefaultValue?: boolean;
+    /**
+     * Use implicit conversion when provided value can be converted
+     * to the target one?
+     *
+     * @type {boolean}
+     */
+    useImplicitConversion?: boolean;
 }

package/core/serializer-context-options.d.ts

@@ -21,9 +21,9 @@ export interface SerializerContextOptions<TType> {
     /**
      * Generic arguments.
      *
-     * @type {GenericArgument<any>[]}
+     * @type {Array<GenericArgument<any>>}
      */
-    genericArguments?: GenericArgument<any>[];
+    genericArguments?: Array<GenericArgument<any>>;
     /**
      * JSONPath from serializer context root.
      *
@@ -33,7 +33,7 @@ export interface SerializerContextOptions<TType> {
      */
     path: string;
     /**
-     * Property metadata attached to a context.
+     * Property metadata.
      *
      * @type {PropertyMetadata<any, TType>}
      */
@@ -43,9 +43,9 @@ export interface SerializerContextOptions<TType> {
      *
      * Used to assign object references in a later time due to circular dependency.
      *
-     * @type {WeakMap<ReferenceKey, ReferenceCallback[]>}
+     * @type {WeakMap<ReferenceKey, Array<ReferenceCallback>>}
      */
-    referenceCallbackMap: WeakMap<ReferenceKey, ReferenceCallback[]>;
+    referenceCallbackMap: WeakMap<ReferenceKey, Array<ReferenceCallback>>;
     /**
      * Reference map.
      *
@@ -55,7 +55,7 @@ export interface SerializerContextOptions<TType> {
      */
     referenceMap: WeakMap<ReferenceKey, ReferenceValue>;
     /**
-     * Type metadata attached to a context.
+     * Type metadata.
      *
      * @type {TypeMetadata<TType>}
      */

package/core/serializer-context.d.ts

@@ -1,4 +1,6 @@
 import { CustomData } from './custom-data';
+import { Discriminant } from './discriminant';
+import { Discriminator } from './discriminator';
 import { Factory } from './factory';
 import { GenericArgument } from './generic-argument';
 import { GenericMetadata } from './generic-metadata';
@@ -15,6 +17,7 @@ import { ReferenceValueInitializer } from './reference-value-initializer';
 import { ReferenceValueResolver } from './reference-value-resolver';
 import { Serializer } from './serializer';
 import { SerializerContextOptions } from './serializer-context-options';
+import { TypeFn } from './type-fn';
 import { TypeLike } from './type-like';
 import { TypeMetadata } from './type-metadata';
 /**
@@ -53,6 +56,24 @@ export declare class SerializerContext<TType> extends Metadata {
      * @returns {any|undefined} Resolved default value or undefined.
      */
     get defaultValue(): any | undefined;
+    /**
+     * Gets discriminant.
+     *
+     * @returns {Discriminant} Discriminant.
+     */
+    get discriminant(): Discriminant;
+    /**
+     * Gets discriminant map.
+     *
+     * @returns {Map<TypeFn<any>, Discriminant>} Discriminant map.
+     */
+    get discriminantMap(): Map<TypeFn<any>, Discriminant>;
+    /**
+     * Gets discriminator.
+     *
+     * @returns {Discriminator} Discriminator.
+     */
+    get discriminator(): Discriminator;
     /**
      * Gets factory.
      *
@@ -62,15 +83,15 @@ export declare class SerializerContext<TType> extends Metadata {
     /**
      * Gets generic arguments.
      *
-     * @returns {GenericArgument<any>[]|undefined} Generic arguments or undefined.
+     * @returns {Array<GenericArgument<any>>|undefined} Generic arguments or undefined.
      */
-    get genericArguments(): GenericArgument<any>[] | undefined;
+    get genericArguments(): Array<GenericArgument<any>> | undefined;
     /**
      * Gets generic metadatas.
      *
-     * @returns {GenericMetadata<any>[]|undefined} Generic metadatas.
+     * @returns {Array<GenericMetadata<any>>|undefined} Generic metadatas.
      */
-    get genericMetadatas(): GenericMetadata<any>[] | undefined;
+    get genericMetadatas(): Array<GenericMetadata<any>> | undefined;
     /**
      * Gets injector.
      *
@@ -101,12 +122,24 @@ export declare class SerializerContext<TType> extends Metadata {
      * @returns {string} Path.
      */
     get path(): string;
+    /**
+     * Gets indicator if context is polymorphic.
+     *
+     * @returns {boolean} True when context is polymorphic. False otherwise.
+     */
+    get polymorphic(): boolean;
     /**
      * Gets property metadata.
      *
      * @returns {PropertyMetadata<any, TType>|undefined} Property metadata or undefined.
      */
     get propertyMetadata(): PropertyMetadata<any, TType> | undefined;
+    /**
+     * Gets indicator if discriminator should be preserved.
+     *
+     * @returns {boolean} True when discriminator should be preserved. False otherwise.
+     */
+    get preserveDiscriminator(): boolean;
     /**
      * Gets reference handler.
      *
@@ -116,9 +149,9 @@ export declare class SerializerContext<TType> extends Metadata {
     /**
      * Gets reference callback map.
      *
-     * @returns {WeakMap<ReferenceKey, ReferenceCallback[]>} Reference callback map.
+     * @returns {WeakMap<ReferenceKey, Array<ReferenceCallback>>} Reference callback map.
      */
-    get referenceCallbackMap(): WeakMap<ReferenceKey, ReferenceCallback[]>;
+    get referenceCallbackMap(): WeakMap<ReferenceKey, Array<ReferenceCallback>>;
     /**
      * Gets reference map.
      *
@@ -228,4 +261,30 @@ export declare class SerializerContext<TType> extends Metadata {
      * @returns {SerializerContext<any>} Generic serializer context.
      */
     defineGenericSerializerContext(genericIndex: number): SerializerContext<any>;
+    /**
+     * Defines polymorphic serializer context by type function.
+     *
+     * @param {TypeFn<any>} typeFn Type function.
+     *
+     * @returns {SerializerContext<any>} Polymorphic serializer context.
+     */
+    private definePolymorphicSerializerContextByTypeFn;
+    /**
+     * Defines polymorphic serializer context by discriminant.
+     *
+     * @param {Record<string, any>} record Some record.
+     *
+     * @returns {SerializerContext<any>} Polymorphic serializer context.
+     */
+    private definePolymorphicSerializerContextByDiscriminant;
+    /**
+     * Defines polymorphic serializer context.
+     *
+     * Called by serializers which work with polymorphic types.
+     *
+     * @param {TypeFn<any>|Record<string, any>} x Type function or record.
+     *
+     * @returns {SerializerContext<any>} Polymorphic serializer context.
+     */
+    definePolymorphicSerializerContext(x: TypeFn<any> | Record<string, any>): SerializerContext<any>;
 }

package/core/type-abstraction.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Type abstraction.
+ *
+ * @type {TypeAbstraction<TType>}
+ */
+export declare type TypeAbstraction<TType> = Function & {
+    prototype: TType;
+};

package/core/type-argument.d.ts

@@ -1,9 +1,9 @@
 import { Alias } from './alias';
-import { TypeCtor } from './type-ctor';
+import { TypeFn } from './type-fn';
 import { TypeResolver } from './type-resolver';
 /**
  * Type argument represents a data which can be passed to define a certain type.
  *
  * @type {TypeArgument<TType>}
  */
-export declare type TypeArgument<TType> = Alias | TypeCtor<TType> | TypeResolver<TType>;
+export declare type TypeArgument<TType> = Alias | TypeFn<TType> | TypeResolver<TType>;

package/core/type-ctor.d.ts

@@ -3,4 +3,4 @@
  *
  * @type {TypeCtor<TType>}
  */
-export declare type TypeCtor<TType> = new (...args: any[]) => TType;
+export declare type TypeCtor<TType> = new (...args: Array<any>) => TType;

package/core/type-fn.d.ts

@@ -0,0 +1,8 @@
+import { TypeAbstraction } from './type-abstraction';
+import { TypeCtor } from './type-ctor';
+/**
+ * Type function.
+ *
+ * @type {TypeFn<TType>}
+ */
+export declare type TypeFn<TType> = TypeCtor<TType> | TypeAbstraction<TType>;

package/core/type-like.d.ts

@@ -1,5 +1,5 @@
 /**
- * Type to describe type including array, null and undefined variations of it. Used as a
+ * Type to describe type including null and undefined variations of it. Used as a
  * generic type for serializer input and output.
  *
  * @type {TypeLike<TType>}

package/core/type-metadata-symbol.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Unique symbol used to store type metadata.
+ *
+ * @type {unique symbol}
+ */
+export declare const typeMetadataSymbol: unique symbol;