@dipscope/type-manager 7.0.0-beta.0 → 7.0.1

package/dist/es2015/property.js

@@ -1,39 +1,39 @@
-import { isArray, isFunction, isObject, isString, isSymbol, merge } from 'lodash';
-import { isCtorFunction } from './functions/is-ctor-function';
-import { nameOf } from './functions/name-of';
-import { TypeManager } from './type-manager';
-export function Property(x, y, z) {
-    const propertyOptions = {};
-    if (isObject(z)) {
-        merge(propertyOptions, z);
-    }
-    if (isObject(y) && !isArray(y)) {
-        merge(propertyOptions, y);
-    }
-    if (isObject(x) && !isArray(x)) {
-        merge(propertyOptions, x);
-    }
-    if (isArray(y)) {
-        propertyOptions.genericArguments = y;
-    }
-    if (isArray(x)) {
-        propertyOptions.genericArguments = x;
-    }
-    if (isString(x) || isFunction(x) || isCtorFunction(x)) {
-        propertyOptions.typeArgument = x;
-    }
-    return function (target, propertyName) {
-        if (isCtorFunction(target)) {
-            throw new Error(`${nameOf(target)}.${String(propertyName)}: property decorator cannot be applied to a static member.`);
-        }
-        if (isSymbol(propertyName)) {
-            throw new Error(`${nameOf(target.constructor)}.${String(propertyName)}: property decorator cannot be applied to a symbol.`);
-        }
-        if (isFunction(target[propertyName])) {
-            throw new Error(`${nameOf(target.constructor)}.${String(propertyName)}: property decorator cannot be applied to a method.`);
-        }
-        TypeManager.configureTypeMetadata(target.constructor).configurePropertyMetadata(propertyName, propertyOptions);
-        return;
-    };
-}
+import { isArray, isFunction, isObject, isString, isSymbol, merge } from 'lodash';
+import { isCtorFunction } from './functions/is-ctor-function';
+import { nameOf } from './functions/name-of';
+import { TypeManager } from './type-manager';
+export function Property(x, y, z) {
+    const propertyOptions = {};
+    if (isObject(z)) {
+        merge(propertyOptions, z);
+    }
+    if (isObject(y) && !isArray(y)) {
+        merge(propertyOptions, y);
+    }
+    if (isObject(x) && !isArray(x)) {
+        merge(propertyOptions, x);
+    }
+    if (isArray(y)) {
+        propertyOptions.genericArguments = y;
+    }
+    if (isArray(x)) {
+        propertyOptions.genericArguments = x;
+    }
+    if (isString(x) || isFunction(x) || isCtorFunction(x)) {
+        propertyOptions.typeArgument = x;
+    }
+    return function (target, propertyName) {
+        if (isCtorFunction(target)) {
+            throw new Error(`${nameOf(target)}.${String(propertyName)}: property decorator cannot be applied to a static member.`);
+        }
+        if (isSymbol(propertyName)) {
+            throw new Error(`${nameOf(target.constructor)}.${String(propertyName)}: property decorator cannot be applied to a symbol.`);
+        }
+        if (isFunction(target[propertyName])) {
+            throw new Error(`${nameOf(target.constructor)}.${String(propertyName)}: property decorator cannot be applied to a method.`);
+        }
+        TypeManager.configureTypeMetadata(target.constructor).configurePropertyMetadata(propertyName, propertyOptions);
+        return;
+    };
+}
 //# sourceMappingURL=property.js.map

package/dist/es2015/reference-callback.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=reference-callback.js.map

package/dist/es2015/reference-handler.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=reference-handler.js.map

package/dist/es2015/reference-handlers/circular-reference-handler.js

@@ -1,36 +1,36 @@
-import { isNil } from 'lodash';
-export class CircularReferenceHandler {
-    define(serializerContext, referenceKey, referenceValueGetter) {
-        const referenceMap = serializerContext.referenceMap;
-        const referenceValue = referenceMap.get(referenceKey);
-        if (isNil(referenceValue)) {
-            referenceMap.set(referenceKey, referenceKey);
-            const value = referenceValueGetter();
-            referenceMap.set(referenceKey, value);
-            serializerContext.resolveReferenceCallbacks(referenceKey);
-            return value;
-        }
-        if (referenceValue === referenceKey) {
-            serializerContext.registerReferenceCallback(referenceKey);
-            return undefined;
-        }
-        return referenceValue;
-    }
-    restore(serializerContext, referenceKey, referenceValueGetter) {
-        const referenceMap = serializerContext.referenceMap;
-        const referenceValue = referenceMap.get(referenceKey);
-        if (isNil(referenceValue)) {
-            referenceMap.set(referenceKey, referenceKey);
-            const value = referenceValueGetter();
-            referenceMap.set(referenceKey, value);
-            serializerContext.resolveReferenceCallbacks(referenceKey);
-            return value;
-        }
-        if (referenceValue === referenceKey) {
-            serializerContext.registerReferenceCallback(referenceKey);
-            return undefined;
-        }
-        return referenceValue;
-    }
-}
+import { isNil } from 'lodash';
+export class CircularReferenceHandler {
+    define(serializerContext, referenceKey, referenceValueGetter) {
+        const referenceMap = serializerContext.referenceMap;
+        const referenceValue = referenceMap.get(referenceKey);
+        if (isNil(referenceValue)) {
+            referenceMap.set(referenceKey, referenceKey);
+            const value = referenceValueGetter();
+            referenceMap.set(referenceKey, value);
+            serializerContext.resolveReferenceCallbacks(referenceKey);
+            return value;
+        }
+        if (referenceValue === referenceKey) {
+            serializerContext.registerReferenceCallback(referenceKey);
+            return undefined;
+        }
+        return referenceValue;
+    }
+    restore(serializerContext, referenceKey, referenceValueGetter) {
+        const referenceMap = serializerContext.referenceMap;
+        const referenceValue = referenceMap.get(referenceKey);
+        if (isNil(referenceValue)) {
+            referenceMap.set(referenceKey, referenceKey);
+            const value = referenceValueGetter();
+            referenceMap.set(referenceKey, value);
+            serializerContext.resolveReferenceCallbacks(referenceKey);
+            return value;
+        }
+        if (referenceValue === referenceKey) {
+            serializerContext.registerReferenceCallback(referenceKey);
+            return undefined;
+        }
+        return referenceValue;
+    }
+}
 //# sourceMappingURL=circular-reference-handler.js.map

package/dist/es2015/reference-handlers/index.js

@@ -1,4 +1,4 @@
-export * from './circular-reference-handler';
-export * from './json-path-reference-handler';
-export * from './plain-reference-handler';
+export * from './circular-reference-handler';
+export * from './json-path-reference-handler';
+export * from './plain-reference-handler';
 //# sourceMappingURL=index.js.map

package/dist/es2015/reference-handlers/json-path-reference-handler.js

@@ -1,69 +1,69 @@
-import { isNil, isObject, isString } from 'lodash';
-export class JsonPathReferenceHandler {
-    constructor() {
-        this.arrayKeyRegExp = new RegExp('\\[\\\'?([^\\\'\\[\\]]+)\\\'?\\]', 'g');
-    }
-    define(serializerContext, referenceKey, referenceValueGetter) {
-        const referenceMap = serializerContext.referenceMap;
-        const referencePath = referenceMap.get(referenceKey);
-        if (isNil(referencePath)) {
-            referenceMap.set(referenceKey, serializerContext.jsonPath);
-            const value = referenceValueGetter();
-            return value;
-        }
-        return { $ref: referencePath };
-    }
-    restore(serializerContext, referenceKey, referenceValueGetter) {
-        const referenceMap = serializerContext.referenceMap;
-        const referenceTarget = this.defineReferenceTarget(serializerContext, referenceKey);
-        const referenceValue = referenceMap.get(referenceTarget);
-        if (isNil(referenceValue)) {
-            referenceMap.set(referenceTarget, referenceTarget);
-            const value = referenceValueGetter();
-            referenceMap.set(referenceTarget, value);
-            serializerContext.resolveReferenceCallbacks(referenceTarget);
-            return value;
-        }
-        if (referenceTarget !== referenceKey) {
-            serializerContext.pushReferenceCallback(referenceTarget, () => {
-                serializerContext.resolveReferenceCallbacks(referenceKey);
-            });
-        }
-        if (referenceTarget === referenceValue) {
-            serializerContext.registerReferenceCallback(referenceTarget);
-            return undefined;
-        }
-        return referenceValue;
-    }
-    defineReferenceTarget(serializerContext, referenceKey) {
-        const $ = serializerContext.$;
-        const referencePath = referenceKey.$ref;
-        if (!isString(referencePath) || !isObject($)) {
-            return referenceKey;
-        }
-        if (referencePath === '$') {
-            return $;
-        }
-        const referencePathArray = this.convertReferencePathToArray(referencePath);
-        referencePathArray.shift();
-        let referenceTarget = $;
-        for (let i = 0; i < referencePathArray.length; i++) {
-            referenceTarget = referenceTarget[referencePathArray[i]];
-        }
-        return referenceTarget;
-    }
-    convertReferencePathToArray(referencePath) {
-        const array = new Array();
-        const parts = referencePath.split('.');
-        for (const part of parts) {
-            const keys = part.split(this.arrayKeyRegExp);
-            for (const key of keys) {
-                if (key.length > 0) {
-                    array.push(key);
-                }
-            }
-        }
-        return array;
-    }
-}
+import { isNil, isObject, isString } from 'lodash';
+export class JsonPathReferenceHandler {
+    constructor() {
+        this.arrayKeyRegExp = new RegExp('\\[\\\'?([^\\\'\\[\\]]+)\\\'?\\]', 'g');
+    }
+    define(serializerContext, referenceKey, referenceValueGetter) {
+        const referenceMap = serializerContext.referenceMap;
+        const referencePath = referenceMap.get(referenceKey);
+        if (isNil(referencePath)) {
+            referenceMap.set(referenceKey, serializerContext.jsonPath);
+            const value = referenceValueGetter();
+            return value;
+        }
+        return { $ref: referencePath };
+    }
+    restore(serializerContext, referenceKey, referenceValueGetter) {
+        const referenceMap = serializerContext.referenceMap;
+        const referenceTarget = this.defineReferenceTarget(serializerContext, referenceKey);
+        const referenceValue = referenceMap.get(referenceTarget);
+        if (isNil(referenceValue)) {
+            referenceMap.set(referenceTarget, referenceTarget);
+            const value = referenceValueGetter();
+            referenceMap.set(referenceTarget, value);
+            serializerContext.resolveReferenceCallbacks(referenceTarget);
+            return value;
+        }
+        if (referenceTarget !== referenceKey) {
+            serializerContext.pushReferenceCallback(referenceTarget, () => {
+                serializerContext.resolveReferenceCallbacks(referenceKey);
+            });
+        }
+        if (referenceTarget === referenceValue) {
+            serializerContext.registerReferenceCallback(referenceTarget);
+            return undefined;
+        }
+        return referenceValue;
+    }
+    defineReferenceTarget(serializerContext, referenceKey) {
+        const $ = serializerContext.$;
+        const referencePath = referenceKey.$ref;
+        if (!isString(referencePath) || !isObject($)) {
+            return referenceKey;
+        }
+        if (referencePath === '$') {
+            return $;
+        }
+        const referencePathArray = this.convertReferencePathToArray(referencePath);
+        referencePathArray.shift();
+        let referenceTarget = $;
+        for (let i = 0; i < referencePathArray.length; i++) {
+            referenceTarget = referenceTarget[referencePathArray[i]];
+        }
+        return referenceTarget;
+    }
+    convertReferencePathToArray(referencePath) {
+        const array = new Array();
+        const parts = referencePath.split('.');
+        for (const part of parts) {
+            const keys = part.split(this.arrayKeyRegExp);
+            for (const key of keys) {
+                if (key.length > 0) {
+                    array.push(key);
+                }
+            }
+        }
+        return array;
+    }
+}
 //# sourceMappingURL=json-path-reference-handler.js.map

package/dist/es2015/reference-handlers/plain-reference-handler.js

@@ -1,32 +1,32 @@
-import { isNil } from 'lodash';
-export class PlainReferenceHandler {
-    define(serializerContext, referenceKey, referenceValueGetter) {
-        const referenceMap = serializerContext.referenceMap;
-        const referenceValue = referenceMap.get(referenceKey);
-        if (isNil(referenceValue)) {
-            referenceMap.set(referenceKey, referenceKey);
-            const value = referenceValueGetter();
-            referenceMap.set(referenceKey, value);
-            return value;
-        }
-        if (referenceValue === referenceKey) {
-            return undefined;
-        }
-        return referenceValue;
-    }
-    restore(serializerContext, referenceKey, referenceValueGetter) {
-        const referenceMap = serializerContext.referenceMap;
-        const referenceValue = referenceMap.get(referenceKey);
-        if (isNil(referenceValue)) {
-            referenceMap.set(referenceKey, referenceKey);
-            const value = referenceValueGetter();
-            referenceMap.set(referenceKey, value);
-            return value;
-        }
-        if (referenceValue === referenceKey) {
-            return undefined;
-        }
-        return referenceValue;
-    }
-}
+import { isNil } from 'lodash';
+export class PlainReferenceHandler {
+    define(serializerContext, referenceKey, referenceValueGetter) {
+        const referenceMap = serializerContext.referenceMap;
+        const referenceValue = referenceMap.get(referenceKey);
+        if (isNil(referenceValue)) {
+            referenceMap.set(referenceKey, referenceKey);
+            const value = referenceValueGetter();
+            referenceMap.set(referenceKey, value);
+            return value;
+        }
+        if (referenceValue === referenceKey) {
+            return undefined;
+        }
+        return referenceValue;
+    }
+    restore(serializerContext, referenceKey, referenceValueGetter) {
+        const referenceMap = serializerContext.referenceMap;
+        const referenceValue = referenceMap.get(referenceKey);
+        if (isNil(referenceValue)) {
+            referenceMap.set(referenceKey, referenceKey);
+            const value = referenceValueGetter();
+            referenceMap.set(referenceKey, value);
+            return value;
+        }
+        if (referenceValue === referenceKey) {
+            return undefined;
+        }
+        return referenceValue;
+    }
+}
 //# sourceMappingURL=plain-reference-handler.js.map

package/dist/es2015/reference-key.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=reference-key.js.map

package/dist/es2015/reference-value-getter.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=reference-value-getter.js.map

package/dist/es2015/reference-value-setter.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=reference-value-setter.js.map

package/dist/es2015/reference-value.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=reference-value.js.map

package/dist/es2015/serializer-context-options.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=serializer-context-options.js.map