@dipscope/type-manager 4.1.0 → 5.0.0-beta.1

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

@@ -4,7 +4,7 @@ import { TypeFn } from './type-fn';
  *
  * @type {InjectOptions<TType>}
  */
-export interface InjectOptions<TType> {
+export declare type InjectOptions<TType> = {
     /**
      * Parameter key to inject within a type context. If specified then
      * type function will be ignored.
@@ -19,4 +19,4 @@ export interface InjectOptions<TType> {
      * @type {TypeFn<TType>}
      */
     typeFn?: TypeFn<TType>;
-}
+};

package/inject.d.ts

@@ -1,5 +1,5 @@
-import { InjectOptions } from './core/inject-options';
-import { TypeFn } from './core/type-fn';
+import { InjectOptions } from './inject-options';
+import { TypeFn } from './type-fn';
 /**
  * Inject decorator.
  *

package/injector.d.ts

@@ -1,11 +1,16 @@
-import { Injector } from './core/injector';
+import { TypeMetadata } from './type-metadata';
 /**
- * Injector decorator.
+ * Injector used to resolve dependent types.
  *
- * Used to define custom injector for a type.
- *
- * @param {Injector} injector Injector.
- *
- * @returns {ClassDecorator} Class decorator.
+ * @type {Injector}
  */
-export declare function Injector(injector: Injector): ClassDecorator;
+export interface Injector {
+    /**
+     * Method to get instance described by type metadata.
+     *
+     * @param {TypeMetadata<TType>} typeMetadata Type metadata.
+     *
+     * @returns {TType|undefined} Instance of type described by type metadata or undefined.
+     */
+    get<TType>(typeMetadata: TypeMetadata<TType>): TType | undefined;
+}

package/injectors/singleton-injector.d.ts

@@ -1,5 +1,5 @@
-import { Injector } from '../core/injector';
-import { TypeMetadata } from '../core/type-metadata';
+import { Injector } from '../injector';
+import { TypeMetadata } from '../type-metadata';
 /**
  * Singleton injector.
  *

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,8 +1,11 @@
 {
   "author": "DipScope authors and contributors",
-  "dependencies": {},
+  "dependencies": {
+    "lodash": "^4.17.21"
+  },
   "description": "A package which will help you to transform your JSON strings or plain objects into JS object instances.",
   "devDependencies": {
+    "@types/lodash": "^4.14.182",
     "@types/jasmine": "^3.6.3",
     "@typescript-eslint/eslint-plugin": "^4.14.2",
     "@typescript-eslint/parser": "^4.14.2",
@@ -39,10 +42,10 @@
   "scripts": {
     "build": "npm run clean && npx webpack --config=webpack.config.js && npm run copy",
     "clean": "shx rm -rf dist",
-    "copy": "shx cp CHANGELOG.md dist && shx cp LICENSE.txt dist && shx cp package.json dist && shx cp README.md dist",
+    "copy": "shx cp CHANGELOG.md dist && shx cp LICENSE.md dist && shx cp package.json dist && shx cp README.md dist",
     "test": "jasmine-ts --config=jasmine.json",
     "lint": "eslint . --ext .ts"
   },
   "types": "index.d.ts",
-  "version": "4.1.0"
+  "version": "5.0.0-beta.1"
 }

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

@@ -63,12 +63,24 @@ export declare class PropertyMetadata<TDeclaringType, TType> extends Metadata {
      * @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.
      *
@@ -147,6 +159,12 @@ export declare class PropertyMetadata<TDeclaringType, TType> extends 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.
      *

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;
 }

package/reference-handlers/lead-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';
 /**
  * Lead reference handler preserves references except circular. If circular reference is detected the it will
  * be setted to undefined so only first occurance is handled.
@@ -16,19 +15,19 @@ export declare class LeadReferenceHandler 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;
 }

package/reference-handlers/path-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';
 /**
  * Path reference handler preserves references using JSONPath.
  *
@@ -21,21 +20,21 @@ export declare class PathReferenceHandler 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;
     /**
      * Defines reference target based on reference key.
      *

package/reference-value-getter.d.ts

@@ -0,0 +1,7 @@
+import { ReferenceValue } from './reference-value';
+/**
+ * Callback to get a reference value when one is not yet present for a reference key.
+ *
+ * @type {ReferenceValueGetter}
+ */
+export declare type ReferenceValueGetter = () => ReferenceValue;

package/reference-value-setter.d.ts

@@ -0,0 +1,7 @@
+import { ReferenceValue } from './reference-value';
+/**
+ * Callback to set a reference value when one may be resolved for a reference key.
+ *
+ * @type {ReferenceValueSetter}
+ */
+export declare type ReferenceValueSetter = (referenceValue: ReferenceValue) => void;

package/serializer-context-options.d.ts

@@ -0,0 +1,43 @@
+import { GenericArgument } from './generic-argument';
+import { PropertyMetadata } from './property-metadata';
+import { ReferenceValueSetter } from './reference-value-setter';
+import { TypeMetadata } from './type-metadata';
+/**
+ * Serializer context options.
+ *
+ * @type {SerializerContextOptions<TType>}
+ */
+export declare type SerializerContextOptions<TType> = {
+    /**
+     * Json path key of current serializer context. It equals to $ for
+     * root serializer context. Read about JSONPath for more info.
+     *
+     * @type {string|number}
+     */
+    jsonPathKey: string | number;
+    /**
+     * Reference value setter if serialization may result in circular dependency
+     * which must be resolved.
+     *
+     * @type {ReferenceValueSetter}
+     */
+    referenceValueSetter?: ReferenceValueSetter;
+    /**
+     * Generic arguments.
+     *
+     * @type {Array<GenericArgument<any>>}
+     */
+    genericArguments?: Array<GenericArgument<any>>;
+    /**
+     * Property metadata.
+     *
+     * @type {PropertyMetadata<any, TType>}
+     */
+    propertyMetadata?: PropertyMetadata<any, TType>;
+    /**
+     * Type metadata.
+     *
+     * @type {TypeMetadata<TType>}
+     */
+    typeMetadata: TypeMetadata<TType>;
+};