@dipscope/type-manager 4.1.1 → 5.0.0

package/{core/log.d.ts → log.d.ts}

@@ -1,6 +1,6 @@
 import { LogLevel } from './log-level';
 /**
- * Main logger class.
+ * Main logger class used by serializers for displaying messages.
  *
  * @type {Log}
  */
@@ -10,31 +10,61 @@ export declare class Log {
      *
      * @type {LogLevel}
      */
-    logLevel: LogLevel;
+    readonly logLevel: LogLevel;
     /**
-     * Constructor.
+     * Info enabled?
      *
-     * @param {LogLevel} logLevel Log level.
+     * @type {boolean}
      */
-    constructor(logLevel: LogLevel);
+    readonly infoEnabled: boolean;
+    /**
+     * Warn enabled?
+     *
+     * @type {boolean}
+     */
+    readonly warnEnabled: boolean;
+    /**
+     * Error enabled?
+     *
+     * @type {boolean}
+     */
+    readonly errorEnabled: boolean;
+    /**
+     * Supports console?
+     *
+     * @type {boolean}
+     */
+    readonly supportsConsole: boolean;
+    /**
+     * Supports console log?
+     *
+     * @type {boolean}
+     */
+    readonly supportsConsoleLog: boolean;
     /**
-     * Info log level is enabled?
+     * Supports console info?
      *
      * @type {boolean}
      */
-    get infoEnabled(): boolean;
+    readonly supportsConsoleInfo: boolean;
     /**
-     * Warn log level is enabled?
+     * Supports console warn?
      *
      * @type {boolean}
      */
-    get warnEnabled(): boolean;
+    readonly supportsConsoleWarn: boolean;
     /**
-     * Error log level is enabled?
+     * Supports console error?
      *
      * @type {boolean}
      */
-    get errorEnabled(): boolean;
+    readonly supportsConsoleError: boolean;
+    /**
+     * Constructor.
+     *
+     * @param {LogLevel} logLevel Log level.
+     */
+    constructor(logLevel: LogLevel);
     /**
      * Displays info message.
      *

package/naming-convention.d.ts

@@ -1,11 +1,15 @@
-import { NamingConvention } from './core/naming-convention';
 /**
- * Naming convention decorator.
+ * Represents naming convention.
  *
- * Used to define custom naming convention for type and property.
- *
- * @param {NamingConvention} namingConvention Naming convention.
- *
- * @returns {ClassDecorator&PropertyDecorator} Class and property decorator.
+ * @type {NamingConvention}
  */
-export declare function NamingConvention(namingConvention: NamingConvention): ClassDecorator & PropertyDecorator;
+export interface NamingConvention {
+    /**
+     * Converts name from provided to target one.
+     *
+     * @param {string} name Name.
+     *
+     * @returns {string} Converted name.
+     */
+    convert(name: string): string;
+}

package/naming-conventions/camel-case-naming-convention.d.ts

@@ -1,4 +1,4 @@
-import { NamingConvention } from '../core/naming-convention';
+import { NamingConvention } from '../naming-convention';
 /**
  * Camel case naming convention.
  *

package/naming-conventions/flat-case-naming-convention.d.ts

@@ -1,4 +1,4 @@
-import { NamingConvention } from '../core/naming-convention';
+import { NamingConvention } from '../naming-convention';
 /**
  * Flat case naming convention.
  *

package/naming-conventions/flat-upper-case-naming-convention.d.ts

@@ -1,4 +1,4 @@
-import { NamingConvention } from '../core/naming-convention';
+import { NamingConvention } from '../naming-convention';
 /**
  * Flat upper case naming convention.
  *

package/naming-conventions/kebab-case-naming-convention.d.ts

@@ -1,4 +1,4 @@
-import { NamingConvention } from '../core/naming-convention';
+import { NamingConvention } from '../naming-convention';
 /**
  * Kebab case naming convention.
  *

package/naming-conventions/kebab-upper-case-naming-convention.d.ts

@@ -1,4 +1,4 @@
-import { NamingConvention } from '../core/naming-convention';
+import { NamingConvention } from '../naming-convention';
 /**
  * Kebab upper naming case.
  *

package/naming-conventions/pascal-case-naming-convention.d.ts

@@ -1,4 +1,4 @@
-import { NamingConvention } from '../core/naming-convention';
+import { NamingConvention } from '../naming-convention';
 /**
  * Pascal case naming convention.
  *

package/naming-conventions/snake-case-naming-convention.d.ts

@@ -1,4 +1,4 @@
-import { NamingConvention } from '../core/naming-convention';
+import { NamingConvention } from '../naming-convention';
 /**
  * Snake case naming convention.
  *

package/naming-conventions/snake-upper-case-naming-convention.d.ts

@@ -1,4 +1,4 @@
-import { NamingConvention } from '../core/naming-convention';
+import { NamingConvention } from '../naming-convention';
 /**
  * Snake upper case naming convention.
  *

package/package.json

@@ -1,9 +1,12 @@
 {
   "author": "DipScope authors and contributors",
-  "dependencies": {},
-  "description": "A package which will help you to transform your JSON strings or plain objects into JS object instances.",
+  "dependencies": {
+    "lodash": "^4.17.21"
+  },
+  "description": "Transform JSON strings or plain objects into JS class instances.",
   "devDependencies": {
     "@types/jasmine": "^3.6.3",
+    "@types/lodash": "^4.14.182",
     "@typescript-eslint/eslint-plugin": "^4.14.2",
     "@typescript-eslint/parser": "^4.14.2",
     "circular-dependency-plugin": "^5.2.2",
@@ -16,18 +19,22 @@
     "ts-loader": "^8.0.15",
     "ts-node": "^8.10.2",
     "typescript": "^4.1.3",
-    "webpack": "^5.21.1",
-    "webpack-cli": "^4.5.0",
-    "webpack-dev-server": "^3.11.2"
+    "webpack": "^5.74.0",
+    "webpack-cli": "^4.10.0",
+    "webpack-dev-server": "^4.9.3"
   },
   "keywords": [
     "json",
     "object",
-    "entity",
     "class",
     "converter",
     "transformer",
-    "manager"
+    "type",
+    "manager",
+    "serializer",
+    "deserializer",
+    "reflection",
+    "metadata"
   ],
   "license": "Apache-2.0",
   "main": "index.js",
@@ -44,5 +51,5 @@
     "lint": "eslint . --ext .ts"
   },
   "types": "index.d.ts",
-  "version": "4.1.1"
+  "version": "5.0.0"
 }

package/property-metadata.d.ts

@@ -0,0 +1,309 @@
+import { Alias } from './alias';
+import { CustomData } from './custom-data';
+import { DefaultValue } from './default-value';
+import { GenericArgument } from './generic-argument';
+import { GenericMetadata } from './generic-metadata';
+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 { TypeFn } from './type-fn';
+import { TypeMetadata } from './type-metadata';
+/**
+ * Main class used to describe a certain property.
+ *
+ * @type {PropertyMetadata<TDeclaringType, TType>}
+ */
+export declare class PropertyMetadata<TDeclaringType, TType> extends Metadata {
+    /**
+     * Type metadata to which property metadata belongs to.
+     *
+     * @type {TypeMetadata<TDeclaringType>}
+     */
+    readonly declaringTypeMetadata: TypeMetadata<TDeclaringType>;
+    /**
+     * Type function defined using reflect metadata.
+     *
+     * Used as a fallback when type argument is not defined.
+     *
+     * @type {TypeFn<TType>}
+     */
+    readonly reflectTypeFn: TypeFn<TType>;
+    /**
+     * Property name as declared in type.
+     *
+     * @type {PropertyName}
+     */
+    readonly propertyName: PropertyName;
+    /**
+     * Property options.
+     *
+     * @type {PropertyOptions<TType>}
+     */
+    readonly propertyOptions: PropertyOptions<TType>;
+    /**
+     * Constructor.
+     *
+     * @param {TypeMetadata<TDeclaringType>} declaringTypeMetadata Type metadata to which property metadata belongs to.
+     * @param {PropertyName} propertyName Property name.
+     * @param {PropertyOptions<TType>} propertyOptions Property options.
+     */
+    constructor(declaringTypeMetadata: TypeMetadata<TDeclaringType>, propertyName: PropertyName, propertyOptions: PropertyOptions<TType>);
+    /**
+     * Gets alias.
+     *
+     * @returns {Alias|undefined} Alias or undefined.
+     */
+    get alias(): Alias | undefined;
+    /**
+     * Gets custom data.
+     *
+     * @returns {CustomData} Custom data.
+     */
+    get customData(): CustomData;
+    /**
+     * Gets serialized null value.
+     *
+     * @returns {any|undefined} Resolved serialized null value or undefined.
+     */
+    get serializedNullValue(): any | undefined;
+    /**
+     * Gets serialized default value.
+     *
+     * @returns {any|undefined} Resolved serialized default value or undefined.
+     */
+    get serializedDefaultValue(): any | undefined;
+    /**
+     * Gets deserialized null value.
+     *
+     * @returns {any|undefined} Resolved deserialized null value or undefined.
+     */
+    get deserializedNullValue(): any | undefined;
+    /**
+     * Gets deserialized default value.
+     *
+     * @returns {any|undefined} Resolved deserialized default value or undefined.
+     */
+    get deserializedDefaultValue(): any | undefined;
+    /**
+     * Gets serialized property name.
+     *
+     * @returns {string} Serialized property name.
+     */
+    get serializedPropertyName(): string;
+    /**
+     * Gets deserialized property name.
+     *
+     * @returns {string} Deserialized property name.
+     */
+    get deserializedPropertyName(): string;
+    /**
+     * Gets deserializable value.
+     *
+     * @returns {boolean|undefined} Deserializable indicator or undefined.
+     */
+    get deserializable(): boolean | undefined;
+    /**
+     * Gets generic arguments.
+     *
+     * @returns {Array<GenericArgument<any>>|undefined} Generic arguments or undefined.
+     */
+    get genericArguments(): Array<GenericArgument<any>> | undefined;
+    /**
+     * Gets generic metadatas.
+     *
+     * @returns {Array<GenericMetadata<any>>|undefined} Generic metadatas.
+     */
+    get genericMetadatas(): Array<GenericMetadata<any>> | undefined;
+    /**
+     * Gets naming convention.
+     *
+     * @returns {NamingConvention|undefined} Naming convention or undefined.
+     */
+    get namingConvention(): NamingConvention | undefined;
+    /**
+     * Gets reference handler.
+     *
+     * @returns {ReferenceHandler} Reference handler.
+     */
+    get referenceHandler(): ReferenceHandler;
+    /**
+     * Gets serializable value.
+     *
+     * @returns {boolean|undefined} Serializable indicator or undefined.
+     */
+    get serializable(): boolean | undefined;
+    /**
+     * Checks if serialization configured.
+     *
+     * @returns {boolean} True when serialization configured. False otherwise.
+     */
+    get serializationConfigured(): boolean;
+    /**
+     * Gets serializer.
+     *
+     * @returns {Serializer<TType>} Serializer.
+     */
+    get serializer(): Serializer<TType>;
+    /**
+     * Gets type argument.
+     *
+     * @returns {TypeArgument|undefined} Type argument or undefined.
+     */
+    get typeArgument(): TypeArgument<TType> | undefined;
+    /**
+     * Gets type metadata.
+     *
+     * @returns {TypeMetadata<TType>} Type metadata.
+     */
+    get typeMetadata(): TypeMetadata<TType>;
+    /**
+     * Gets indicator if null value should be preserved.
+     *
+     * @returns {boolean} True when null value should be preserved. False otherwise.
+     */
+    get preserveNull(): boolean;
+    /**
+     * Gets indicator if default value should be used.
+     *
+     * @returns {boolean} Use default value indicator.
+     */
+    get useDefaultValue(): boolean;
+    /**
+     * Gets indicator if implicit conversion should be used.
+     *
+     * @returns {boolean} Use implicit conversion indicator.
+     */
+    get useImplicitConversion(): boolean;
+    /**
+     * Configures alias.
+     *
+     * @param {Alias} alias Alias.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configureAlias(alias: Alias): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures custom data.
+     *
+     * @param {CustomData} customData Custom data.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configureCustomData(customData: CustomData): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures default value.
+     *
+     * @param {DefaultValue} defaultValue Default value.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configureDefaultValue(defaultValue: DefaultValue): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures serialized default value.
+     *
+     * @param {DefaultValue} serializedDefaultValue Serialized default value.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configureSerializedDefaultValue(serializedDefaultValue: DefaultValue): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures deserialized default value.
+     *
+     * @param {DefaultValue} deserializedDefaultValue Deserialized default value.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configureDeserializedDefaultValue(deserializedDefaultValue: DefaultValue): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures deserializable.
+     *
+     * @param {boolean} deserializable Deserializable.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configureDeserializable(deserializable: boolean): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures serializable.
+     *
+     * @param {boolean} serializable Serializable.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configureSerializable(serializable: boolean): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures generic arguments.
+     *
+     * @param {Array<GenericArgument<any>>|undefined} genericArguments Generic arguments.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configureGenericArguments(genericArguments: Array<GenericArgument<any>> | undefined): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures naming convention.
+     *
+     * @param {NamingConvention} namingConvention Naming convention.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configureNamingConvention(namingConvention: NamingConvention): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures reference handler.
+     *
+     * @param {ReferenceHandler} referenceHandler Reference handler.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configureReferenceHandler(referenceHandler: ReferenceHandler): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures serializer.
+     *
+     * @param {Serializer<TType>} serializer Serializer.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configureSerializer(serializer: Serializer<TType>): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures type argument.
+     *
+     * @param {TypeArgument<TType>} typeArgument Type argument.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configureTypeArgument(typeArgument: TypeArgument<TType>): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures preserve null.
+     *
+     * @param {boolean} preserveNull Preserve null.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configurePreserveNull(preserveNull: boolean): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures use default value.
+     *
+     * @param {boolean} useDefaultValue Use default value.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configureUseDefaultValue(useDefaultValue: boolean): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures use implicit convertion.
+     *
+     * @param {boolean} useImplicitConversion Use implicit convertion.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configureUseImplicitConversion(useImplicitConversion: boolean): PropertyMetadata<TDeclaringType, TType>;
+    /**
+     * Configures property metadata based on provided options.
+     *
+     * @param {PropertyOptions<TType>} propertyOptions Property options.
+     *
+     * @returns {PropertyMetadata<TDeclaringType, TType>} Current instance of property metadata.
+     */
+    configure(propertyOptions: PropertyOptions<TType>): PropertyMetadata<TDeclaringType, TType>;
+}

package/{core/property-options.d.ts → property-options.d.ts}

@@ -11,7 +11,7 @@ import { TypeArgument } from './type-argument';
  *
  * @type {PropertyOptions<TType>}
  */
-export interface PropertyOptions<TType> {
+export declare type PropertyOptions<TType> = {
     /**
      * Property alias.
      *
@@ -26,6 +26,15 @@ export interface PropertyOptions<TType> {
      * @type {CustomData}
      */
     customData?: CustomData;
+    /**
+     * Default value for undefined ones.
+     *
+     * Used to set both serialized and deserialized default values and
+     * only when use default value option is true.
+     *
+     * @type {DefaultValue}
+     */
+    defaultValue?: DefaultValue;
     /**
      * Serialized default value for undefined ones.
      *
@@ -84,6 +93,13 @@ export interface PropertyOptions<TType> {
      * @type {TypeArgument<TType>}
      */
     typeArgument?: TypeArgument<TType>;
+    /**
+     * If set to true then null values are preserved. Otherwise they will be
+     * treated as undefined.
+     *
+     * @type {boolean}
+     */
+    preserveNull?: boolean;
     /**
      * Use default value assignment for undefined values?
      *
@@ -97,4 +113,4 @@ export interface PropertyOptions<TType> {
      * @type {boolean}
      */
     useImplicitConversion?: boolean;
-}
+};

package/property.d.ts

@@ -1,5 +1,6 @@
-import { GenericArgument, TypeArgument } from './core';
-import { PropertyOptions } from './core/property-options';
+import { GenericArgument } from './generic-argument';
+import { PropertyOptions } from './property-options';
+import { TypeArgument } from './type-argument';
 /**
  * Property decorator.
  *

package/{core/reference-callback.d.ts → reference-callback.d.ts}

@@ -1,6 +1,6 @@
 /**
  * Reference callback function which is called when circular references can be resolved for
- * a certain object. May be created by serializers for serializer contexts.
+ * a certain object.
  *
  * @type {ReferenceCallback}
  */

package/reference-handler.d.ts

@@ -1,11 +1,31 @@
-import { ReferenceHandler } from './core/reference-handler';
+import { ReferenceKey } from './reference-key';
+import { ReferenceValue } from './reference-value';
+import { ReferenceValueGetter } from './reference-value-getter';
+import { SerializerContext } from './serializer-context';
 /**
- * Reference handler decorator.
+ * Reference handler to resolve object references.
  *
- * Used to define custom reference handler for type and property.
- *
- * @param {ReferenceHandler} referenceHandler Reference handler.
- *
- * @returns {ClassDecorator&PropertyDecorator} Class and property decorator.
+ * @type {ReferenceHandler}
  */
-export declare function ReferenceHandler(referenceHandler: ReferenceHandler): ClassDecorator & PropertyDecorator;
+export interface ReferenceHandler {
+    /**
+     * Defines reference. Called during serialization.
+     *
+     * @param {SerializerContext<any>} serializerContext Serializer context.
+     * @param {ReferenceKey} referenceKey Reference which acts as a key. This is basically a serializing object.
+     * @param {ReferenceValueGetter} referenceValueGetter Function to get a reference value when one is not yet present for a key.
+     *
+     * @returns {ReferenceValue} Resolved reference value.
+     */
+    define(serializerContext: SerializerContext<any>, referenceKey: ReferenceKey, referenceValueGetter: ReferenceValueGetter): ReferenceValue;
+    /**
+     * Restores reference. Called during deserialization.
+     *
+     * @param {SerializerContext<any>} serializerContext Serializer context.
+     * @param {ReferenceKey} referenceKey Reference which acts as a key. This is basically a deserializing object.
+     * @param {ReferenceValueGetter} referenceValueGetter Function to get a reference value when one is not yet present for a key.
+     *
+     * @returns {ReferenceValue} Resolved reference value.
+     */
+    restore(serializerContext: SerializerContext<any>, referenceKey: ReferenceKey, referenceValueGetter: ReferenceValueGetter): ReferenceValue;
+}

package/reference-handlers/direct-reference-handler.d.ts

@@ -1,9 +1,8 @@
-import { ReferenceHandler } from '../core/reference-handler';
-import { ReferenceKey } from '../core/reference-key';
-import { ReferenceValue } from '../core/reference-value';
-import { ReferenceValueInitializer } from '../core/reference-value-initializer';
-import { ReferenceValueResolver } from '../core/reference-value-resolver';
-import { SerializerContext } from '../core/serializer-context';
+import { ReferenceHandler } from '../reference-handler';
+import { ReferenceKey } from '../reference-key';
+import { ReferenceValue } from '../reference-value';
+import { ReferenceValueGetter } from '../reference-value-getter';
+import { SerializerContext } from '../serializer-context';
 /**
  * Direct reference handler which preserves references as is.
  *
@@ -15,19 +14,19 @@ export declare class DirectReferenceHandler implements ReferenceHandler {
      *
      * @param {SerializerContext<any>} serializerContext Serializer context.
      * @param {ReferenceKey} referenceKey Reference which acts as a key. This is basically a serializing object.
-     * @param {ReferenceValueInitializer} referenceValueInitializer Function to initialize a reference value when one is not yet present for a key.
+     * @param {ReferenceValueGetter} referenceValueGetter Function to get a reference value when one is not yet present for a key.
      *
-     * @returns {ReferenceValue|ReferenceValueResolver} Resolved reference value or reference resolver when circular dependency is detected.
+     * @returns {ReferenceValue} Resolved reference value.
      */
-    define(serializerContext: SerializerContext<any>, referenceKey: ReferenceKey, referenceValueInitializer: ReferenceValueInitializer): ReferenceValue | ReferenceValueResolver;
+    define(serializerContext: SerializerContext<any>, referenceKey: ReferenceKey, referenceValueGetter: ReferenceValueGetter): ReferenceValue;
     /**
      * Restores reference. Called during deserialization.
      *
      * @param {SerializerContext<any>} serializerContext Serializer context.
      * @param {ReferenceKey} referenceKey Reference which acts as a key. This is basically a deserializing object.
-     * @param {ReferenceValueInitializer} referenceValueInitializer Function to initialize a reference value when one is not yet present for a key.
+     * @param {ReferenceValueGetter} referenceValueGetter Function to get a reference value when one is not yet present for a key.
      *
-     * @returns {ReferenceValue|ReferenceValueResolver} Resolved reference value or reference resolver when circular dependency is detected.
+     * @returns {ReferenceValue} Resolved reference value.
      */
-    restore(serializerContext: SerializerContext<any>, referenceKey: ReferenceKey, referenceValueInitializer: ReferenceValueInitializer): ReferenceValue | ReferenceValueResolver;
+    restore(serializerContext: SerializerContext<any>, referenceKey: ReferenceKey, referenceValueGetter: ReferenceValueGetter): ReferenceValue;
 }