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

package/CHANGELOG.md

@@ -5,7 +5,30 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [5.0.0] - 2022-**-**
+## [6.0.0] - 2023-03-22
+
+### Added
+
+- Fluent api for declarative configuration.
+- Property metadata sorters.
+- Inject metadata sorters.
+- Stable json stringify and parse functions.
+- Any and unknown type serializers.
+- Modules support.
+- Performance improvements.
+
+### Changed
+
+- If property type argument is not configured then no error will be thrown and property will be serialized as unknown.
+- Weak reference maps changed to regular maps to allow more extension points.
+- Reference handler names to be more self descriptive.
+
+### Migrating from previous version
+
+- Replace old declarative configuration calls with newly introduced fluent api.
+- You can still use raw declarative api through the options by adapting method calls.
+
+## [5.0.0] - 2022-07-31
 
 ### Added
 

package/CONTRIBUTING.md

@@ -0,0 +1,58 @@
+# Contributing
+
+## Introduction
+
+First off, thank you for considering contributing to `TypeManager.TS`. It's people like you that make `TypeManager.TS` such a great tool.
+
+Following these guidelines helps to communicate that you respect the time of the developers managing and developing this open source project. In return, they should reciprocate that respect in addressing your issue, assessing changes, and helping you finalize your pull requests.
+
+## What kinds of contributions we are looking for
+
+`TypeManager.TS` is an open source project and we love to receive contributions from our community — you! There are many ways to contribute, from writing tutorials or blog posts, improving the documentation, submitting bug reports and feature requests or writing code which can be incorporated into `TypeManager.TS` itself.
+
+## Ground Rules
+
+Please read our [CODE_OF_CONDUCT.md](https://github.com/dipscope/TypeManager.TS/blob/master/CODE_OF_CONDUCT.md) file to facilitate healthy and constructive community behavior.
+
+* Ensure that code that goes into core meets our code style.
+* Create issues for any major changes and enhancements that you wish to make. Discuss things transparently and get community feedback.
+* Don't add any new classes to the codebase unless absolutely needed.
+* Keep feature versions as small as possible, preferably one new feature per version.
+* Be welcoming to newcomers and encourage diverse new contributors from all backgrounds.
+
+## Your First Contribution
+
+Unsure where to begin contributing to `TypeManager.TS`? You can start by looking through the beginner and help-wanted issues. Beginner issues - issues which should only require a few lines of code, and a test or two. Help wanted issues - issues which should be a bit more involved than beginner issues.
+
+## How to report a bug
+
+If you find a security vulnerability, do NOT open an issue. Email dipscope@gmail.com instead. In order to determine whether you are dealing with a security issue, ask yourself these two questions:
+
+* Can I access something that's not mine, or something I shouldn't have access to?
+* Can I disable something for other people?
+
+If the answer to either of those two questions are «yes», then you're probably dealing with a security issue. Note that even if you answer «no» to both questions, you may still be dealing with a security issue, so if you're unsure, just email us at dipscope@gmail.com.
+
+When filing an issue, make sure to answer these five questions:
+
+1. What version of `TypeManager.TS` are you using?
+2. What browser are you using?
+3. What did you do?
+4. What did you expect to see?
+5. What did you see instead?
+
+## How to suggest a feature
+
+If you find yourself wishing for a feature that doesn't exist in `TypeManager.TS`, you are probably not alone. There are bound to be others out there with similar needs. Many of the features that `TypeManager.TS` has today have been added because our users saw the need. Open an issue on our issues list on GitHub which describes the feature you would like to see, why you need it, and how it should work.
+
+## Running the tests
+
+If you are going to contribute make sure that all tests are passed by running `npm run test` command in the root project folder.
+
+## Deployment
+
+This project representing a library and can be built by running `npm run build` command. All compiled production files will be available under `dist` folder.
+
+## Notes
+
+We are continuously working on this file. If you have not found interesting information feel free to open an issue.

package/README.md

@@ -155,7 +155,18 @@ for (const user of users)
 }
 ```
 
-Now we can use all power provided by `JavaScript` class instances. Want to know more? Let's dive into the details.
+Now we can use all power provided by `JavaScript` class instances. 
+
+Furthermore `TypeManager.TS` provides you:
+
+* Reflection abilities at runtime;
+* Support for generic types;
+* Handling of cyclic object references and different ways of serialization when they appear;
+* Ability to configure serialization of 3rd party classes;
+* Support for polymorphic types;
+* Great alternative for similar packages like [class-transformer](https://github.com/typestack/class-transformer), [TypedJSON](https://github.com/JohnWeisz/TypedJSON) and [jackson-js](https://github.com/pichillilorenzo/jackson-js);
+
+Want to know more? Let's dive into the details.
 
 ## Installation
 
@@ -196,7 +207,7 @@ Here we have a `User` class with `Type` and `Property` decorators assigned to it
 The same configuration can be rewritten using declarative style.
 
 ```typescript
-import { TypeManager, PropertyName, PropertyOptions } from '@dipscope/type-manager';
+import { TypeManager, TypeMetadata, TypeConfiguration } from '@dipscope/type-manager';
 
 export class User
 {
@@ -204,15 +215,24 @@ export class User
     public email: string;
 }
 
-TypeManager.configureTypeOptions(User, {
-    propertyOptionsMap: new Map<PropertyName, PropertyOptions<any>>([
-        ['name', { typeArgument: String }],
-        ['email', { typeArgument: String }],
-    ])
-});
+export class UserConfiguration implements TypeConfiguration<User>
+{
+    public configure(typeMetadata: TypeMetadata<User>): void 
+    {
+        typeMetadata.configurePropertyMetadata('name')
+            .hasTypeArgument(String);
+
+        typeMetadata.configurePropertyMetadata('email')
+            .hasTypeArgument(String);
+
+        return;    
+    }
+}
+
+TypeManager.applyTypeConfiguration(User, new UserConfiguration());
 ```
 
-As you can see now our `User` class defined without decorators. Instead you have to call `TypeManager` configure method and provide `TypeOptions` related to `User` type.
+As you can see now our `User` class defined without decorators. Instead you have to call `TypeManager` method and provide `TypeConfiguration` related to `User` type.
 
 No matter what style of configuration you have chosen the next step is to call serialize methods of `TypeManager` with providing a type and data you want to process.
 
@@ -243,14 +263,14 @@ Static functions are not the only way to work with a `TypeManager`. You can also
 ```typescript
 import { TypeManager } from '@dipscope/type-manager';
 
-const userManager = new TypeManager(User);
-const userObject = userManager.serialize(new User());
-const user = userManager.deserialize(userObject);
+const typeManager = new TypeManager();
+const userObject = userManager.serialize(User, new User());
+const user = userManager.deserialize(User, userObject);
 
 user instanceof User; // True.
 ```
 
-At first glance, it may seems that there is no difference but creating an instance of `TypeManager` preserves a configuration state. You can work with different configurations at the same time by providing type manager options as a second optional constructor argument. If it is not required then it is better to use static methods. They are not invoking state control which results in better performance.
+At first glance, it may seems that there is no difference but creating an instance of `TypeManager` preserves a configuration state. You can work with different configurations at the same time and have different serialization groups. By default all decorator based configurations and static calls are applied to the singleton type manager instance which is automatically created under the hood.
 
 ## Defining decorators
 
@@ -304,7 +324,7 @@ export class User
 }
 ```
 
-This will register a `name` property for a `User`. Each property has a type associated with it. In our case this is a `String`. By default if no configure options are provided decorator will try to resolve a property type using [reflect-metadata](https://github.com/rbuckton/reflect-metadata). If you are not using reflect metadata then such configuration will result a property type to be `unknown` and you will get an error during serialization. For such a case you have to explicitly define a property type.
+This will register a `name` property for a `User`. Each property has a type associated with it. In our case this is a `String`. By default if no configure options are provided decorator will try to resolve a property type using [reflect-metadata](https://github.com/rbuckton/reflect-metadata). If you are not using reflect metadata then such configuration will result a property type to be `unknown` and it will result in direct serialization. For such a case you have to explicitly define a property type.
 
 ```typescript
 import { Type, Property } from '@dipscope/type-manager';
@@ -427,7 +447,7 @@ export class UserStatus
 @Type()
 export class User
 {
-    @Property([UserStatus]) public userStatuses: UserStatus[];
+    @Property([UserStatus]) public userStatuses: Array<UserStatus>;
 }
 ```
 
@@ -463,7 +483,7 @@ export class UserStatus
 @Type()
 export class User
 {
-    @Property(Array, [UserStatus]) public userStatuses: UserStatus[];
+    @Property(Array, [UserStatus]) public userStatuses: Array<UserStatus>;
 }
 ```
 
@@ -695,7 +715,7 @@ This will affect both serialized and deserialized default value. This will fit p
 import { Type, Property } from '@dipscope/type-manager';
 
 @Type({
-    serializedDefaultValue: () => new User(),
+    serializedDefaultValue: () => {},
     deserializedDefaultValue: () => new User()
 })
 export class User
@@ -973,7 +993,7 @@ With this any value which can be converted to `String` will be converted properl
 
 ## Defining configuration manually
 
-There are circumstances when decorators cannot be used or you don't want to. For example you are using a 3rd party package and cannot decorate classes from it. Another use case when you want to configure some options globally. In such scenarios you can define the complete configuration through special static configure methods.
+There are circumstances when decorators cannot be used or you don't want to. For example you are using a 3rd party package and cannot decorate classes from it. Another use case when you want to configure some options globally. In such scenarios you can define the complete configuration through special configure methods.
 
 We have separate methods to configure each type manager option, so the provided examples can be simplified to avoid creating additional object. It is useful when you need to configure only one option. In our examples we are always use the main one to give you a general overview.
 
@@ -999,33 +1019,44 @@ For the full list of available global options check `TypeOptionsBase` definition
 
 ### Configuring options per type
 
-Here is an example of declarative configuration which can be used for 3rd party or your own classes in addition to decorators.
+Here is an example of declarative configuration which can be used for 3rd party or your own classes. Basically you have exact same options as with decorators but configuration is done using method calls.
 
 ```typescript
 import { DateTime } from '@external-library';
-import { TypeManagerOptions, TypeFn, TypeOptions, PropertyName, PropertyOptions } from '@dipscope/type-manager';
+import { TypeConfiguration, TypeMetadata, TypeManager } from '@dipscope/type-manager';
 
-const dateTimeOptions: TypeOptions<DateTime> = {
-    alias: 'DateTime',
-    serializer: new DateTimeSerializer()
-};
+export class DateTimeConfiguration implements TypeConfiguration<DateTime>
+{
+    public configure(typeMetadata: TypeMetadata<DateTime>): void
+    {
+        typeMetadata.hasAlias('DateTime')
+            .hasSerializer(new DateTimeSerializer());
 
-const userOptions: TypeOptions<User> = {
-    alias: 'User',
-    propertyOptionsMap: new Map<PropertyName, PropertyOptions<any>>(
-        ['name', { typeArgument: String, serializable: true, alias: 'username' }],
-        ['createdAt', { typeArgument: DateTime }]
-    )
-};
+        return;
+    }
+}
 
-const typeManagerOptions: TypeManagerOptions = {
-    typeOptionsMap: new Map<TypeFn<any>, TypeOptions<any>>(
-        [DateTime, dateTimeOptions],
-        [User, userOptions]
-    )
-};
+export class UserConfiguration implements TypeConfiguration<User>
+{
+    public configure(typeMetadata: TypeMetadata<User>): void
+    {
+        typeMetadata.hasAlias('User')
+            .hasSerializer(new DateTimeSerializer());
 
-TypeManager.configure(typeManagerOptions);
+        typeMetadata.configurePropertyMetadata('name')
+            .isSerializable()
+            .hasAlias('username')
+            .hasTypeArgument(String);
+
+        typeMetadata.configurePropertyMetadata('createdAt')
+            .hasTypeArgument(DateTime);
+
+        return;
+    }
+}
+
+TypeManager.applyTypeConfiguration(DateTime, new DateTimeConfiguration())
+    .applyTypeConfiguration(User, new UserConfiguration());
 ```
 
 There is a well defined order to how type options are applied when using configure methods on one type. One should remember this when combining and overriding options in different places.
@@ -1035,7 +1066,7 @@ There is a well defined order to how type options are applied when using configu
 3. Declarative type options are applied;
 4. Property type options are applied;
 
-Declarative configuration supports the same options as decorators. With such a configuration you can declare types like the following.
+With declarative configuration you can declare types like the following and keep metadata in another place.
 
 ```typescript
 export class User
@@ -1113,7 +1144,7 @@ import { Type, Property } from '@dipscope/type-manager';
 @Type()
 export class Plot
 {
-    @Property(Array, [Shape]) public shapes: Shape[];
+    @Property(Array, [Shape]) public shapes: Array<Shape>;
 }
 ```
 
@@ -1411,11 +1442,11 @@ Now all property names will be converted to snake case while reading them from J
 
 ### Configuring reference handler
 
-Reference handler defines how references to the same objects including a circular one should be treated. We have several reference handlers: direct, lead and path. Each of them can be used globally or per type.
+Reference handler defines how references to the same objects including a circular one should be treated. We have several reference handlers: circular, json path and plain. Each of them can be used globally or per type.
 
-* Direct reference handler preserves object references without making any special changes;
-* Path reference handler preserves object references using JSONPath notation;
-* Lead reference handler preserves object references excluding a circular one. When circular reference is detected it will be set to undefined;
+* Circular reference handler preserves object references without making any special changes;
+* Json path reference handler preserves object references using JSONPath notation;
+* Plain reference handler preserves object references excluding a circular one. When circular reference is detected it will be set to undefined;
 
 There is nothing better to show the difference than code. For example we have two classes which reference each other:
 
@@ -1452,23 +1483,23 @@ const result = TypeManager.serialize(User, user);
 Here are results returned by different reference handlers:
 
 ```typescript
-// Direct reference handler...
+// Circular reference handler...
 { company: { user: result } };
 
-// Path reference handler...
+// Json path reference handler...
 { company: { user: { $ref: '$' } } };
 
-// Lead reference handler...
+// Plain reference handler...
 { company: { user: undefined };
 ```
 
-As you can see `DirectReferenceHandler` does not make changes to your data and completely fine until you have to convert circular reference structure to a string. `JSON.stringify` method which we are using under the hood does not support such conversions so you will encounter an error. In this case you can select another reference handler. For example `PathReferenceHandler` which produces JSON string using JSONPath format for circular references supported by many libraries. Or you can simply ignore circular reference when it should be converted to a string and use `LeadReferenceHandler`. To change default reference handler you have to use `TypeManager` configure methods.
+As you can see `CircularReferenceHandler` does not make changes to your data and completely fine until you have to convert circular reference structure to a string. `JSON.stringify` method which we are using under the hood does not support such conversions so you will encounter an error. In this case you can select another reference handler. For example `JsonPathReferenceHandler` which produces JSON string using JSONPath format for circular references supported by many libraries. Or you can simply ignore circular reference when it should be converted to a string and use `PlainReferenceHandler`. To change default reference handler you have to use `TypeManager` configure methods.
 
 ```typescript
-import { TypeManagerOptions, TypeOptionsBase, PathReferenceHandler } from '@dipscope/type-manager';
+import { TypeManagerOptions, TypeOptionsBase, JsonPathReferenceHandler } from '@dipscope/type-manager';
 
 const typeOptionsBase: TypeOptionsBase<any> = {
-    referenceHandler: new PathReferenceHandler()
+    referenceHandler: new JsonPathReferenceHandler()
 };
 
 const typeManagerOptions: TypeManagerOptions = {
@@ -1601,12 +1632,20 @@ export class DateTime
 Or declarative configuration.
 
 ```typescript
-import { TypeManager } from '@dipscope/type-manager';
+import { TypeManager, TypeConfiguration, TypeMetadata } from '@dipscope/type-manager';
 
-TypeManager.configureTypeOptions(DateTime, {
-    alias: 'DateTime',
-    serializer: new DateTimeSerializer()
-});
+export class DateTimeConfiguration implements TypeConfiguration<DateTime>
+{
+    public configure(typeMetadata: TypeMetadata<DateTime>): void
+    {
+        typeMetadata.hasAlias('DateTime')
+            .hasSerializer(new DateTimeSerializer());
+
+        return;
+    }
+}
+
+TypeManager.applyTypeConfiguration(DateTime, new DateTimeConfiguration());
 ```
 
 With declarative configuration it is possible to override built in serializers if it's behaviour not suitable for your use cases. Also you can register serializers for types we not yet cover.
@@ -1645,7 +1684,7 @@ import { Injector as AngularInjector } from '@angular/core';
 
 const angularInjector: AngularInjector = ...; // Get framework injector in core module for example.
 
-TypeManager.configureTypeOptionsBase({
+TypeManager.applyTypeOptionsBase({
     injector: new CustomInjector(angularInjector)
 });
 ```
@@ -1702,13 +1741,13 @@ Or declarative configuration.
 import { TypeManager } from '@dipscope/type-manager';
 
 // Overriding only for user type.
-TypeManager.configureTypeOptions(User, {
+TypeManager.applyTypeOptions(User, {
     customData: { rank: 1 },
     factory: new CustomTypeFactory()
 });
 
 // Overriding for any type.
-TypeManager.configureTypeOptionsBase({
+TypeManager.applyTypeOptionsBase({
     factory: new CustomTypeFactory()
 });
 ```
@@ -1751,7 +1790,7 @@ Public `convert` method receives a property name as it declared in a class. You
 ```typescript
 import { TypeManager } from '@dipscope/type-manager';
 
-TypeManager.configureTypeOptionsBase({
+TypeManager.applyTypeOptionsBase({
     namingConvention: new CamelCaseNamingConvention()
 });
 ```
@@ -1766,6 +1805,7 @@ This section describes certain use cases to separate them from the main document
 
 Here is a list of types with built in serializers. 
 
+* Any;
 * Array;
 * ArrayBuffer;
 * Boolean;
@@ -1784,6 +1824,7 @@ Here is a list of types with built in serializers.
 * Uint8ClampedArray;
 * Uint16Array;
 * Uint32Array;
+* Unknown;
 
 For these you don't have to do anything to make them work. You are free to [create a custom serializer](#defining-custom-serializer) or override built in one if it does not cover your use case.
 

package/dist/es2015/alias.js

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

package/dist/es2015/alias.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alias.js","sourceRoot":"","sources":["../../src/alias.ts"],"names":[],"mappings":""}

package/dist/es2015/any.js

@@ -0,0 +1,3 @@
+export class Any {
+}
+//# sourceMappingURL=any.js.map

package/dist/es2015/any.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"any.js","sourceRoot":"","sources":["../../src/any.ts"],"names":[],"mappings":"AAOA,MAAM,OAAO,GAAG;CAGf"}

package/dist/es2015/custom-data.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=custom-data.js.map

package/dist/es2015/custom-data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-data.js","sourceRoot":"","sources":["../../src/custom-data.ts"],"names":[],"mappings":""}

package/dist/es2015/default-value-resolver.js

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

package/dist/es2015/default-value-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-value-resolver.js","sourceRoot":"","sources":["../../src/default-value-resolver.ts"],"names":[],"mappings":""}

package/dist/es2015/default-value.js

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

package/dist/es2015/default-value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-value.js","sourceRoot":"","sources":["../../src/default-value.ts"],"names":[],"mappings":""}

package/dist/es2015/discriminant.js

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

package/dist/es2015/discriminant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discriminant.js","sourceRoot":"","sources":["../../src/discriminant.ts"],"names":[],"mappings":""}

package/dist/es2015/discriminator.js

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

package/dist/es2015/discriminator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discriminator.js","sourceRoot":"","sources":["../../src/discriminator.ts"],"names":[],"mappings":""}

package/dist/es2015/factories/index.js

@@ -0,0 +1,2 @@
+export * from './type-factory';
+//# sourceMappingURL=index.js.map

package/dist/es2015/factories/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/factories/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/es2015/factories/type-factory.js

@@ -0,0 +1,34 @@
+import { isNil, isUndefined } from 'lodash';
+import { isCtorFunction } from '../functions/is-ctor-function';
+export class TypeFactory {
+    build(typeContext, injector) {
+        var _a;
+        const typeMetadata = typeContext.typeMetadata;
+        const typeCtor = isCtorFunction(typeMetadata.typeFn) ? typeMetadata.typeFn : undefined;
+        if (isNil(typeCtor)) {
+            throw new Error(`${typeMetadata.typeName}: cannot build instance of abstract type.`);
+        }
+        const injectedKeys = new Array();
+        const args = new Array(typeCtor.length).fill(undefined);
+        for (const injectMetadata of typeMetadata.sortedInjectMetadatas) {
+            const argKey = injectMetadata.key;
+            if (!isNil(argKey)) {
+                args[injectMetadata.injectIndex] = (_a = typeContext.get(argKey)) === null || _a === void 0 ? void 0 : _a.value;
+                injectedKeys.push(argKey);
+                continue;
+            }
+            args[injectMetadata.injectIndex] = injector.get(injectMetadata.typeMetadata);
+        }
+        const type = new typeCtor(...args);
+        for (const typeContextEntry of typeContext.values()) {
+            const propertyMetadata = typeContextEntry.propertyMetadata;
+            if (!isNil(propertyMetadata)
+                && !isUndefined(typeContextEntry.value)
+                && !injectedKeys.includes(propertyMetadata.propertyName)) {
+                type[propertyMetadata.propertyName] = typeContextEntry.value;
+            }
+        }
+        return type;
+    }
+}
+//# sourceMappingURL=type-factory.js.map

package/dist/es2015/factories/type-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-factory.js","sourceRoot":"","sources":["../../../src/factories/type-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE5C,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAS/D,MAAM,OAAO,WAAW;IAUb,KAAK,CAAQ,WAA+B,EAAE,QAAkB;;QAEnE,MAAM,YAAY,GAAG,WAAW,CAAC,YAAY,CAAC;QAC9C,MAAM,QAAQ,GAAG,cAAc,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;QAEvF,IAAI,KAAK,CAAC,QAAQ,CAAC,EACnB;YACI,MAAM,IAAI,KAAK,CAAC,GAAG,YAAY,CAAC,QAAQ,2CAA2C,CAAC,CAAC;SACxF;QAED,MAAM,YAAY,GAAG,IAAI,KAAK,EAAO,CAAC;QACtC,MAAM,IAAI,GAAG,IAAI,KAAK,CAAM,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAE7D,KAAK,MAAM,cAAc,IAAI,YAAY,CAAC,qBAAqB,EAC/D;YACI,MAAM,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC;YAElC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAClB;gBACI,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,GAAG,MAAA,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,0CAAE,KAAK,CAAC;gBAElE,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAE1B,SAAS;aACZ;YAED,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;SAChF;QAED,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,GAAG,IAAI,CAAQ,CAAC;QAE1C,KAAK,MAAM,gBAAgB,IAAI,WAAW,CAAC,MAAM,EAAE,EACnD;YACI,MAAM,gBAAgB,GAAG,gBAAgB,CAAC,gBAAgB,CAAC;YAE3D,IACI,CAAC,KAAK,CAAC,gBAAgB,CAAC;mBACrB,CAAC,WAAW,CAAC,gBAAgB,CAAC,KAAK,CAAC;mBACpC,CAAC,YAAY,CAAC,QAAQ,CAAC,gBAAgB,CAAC,YAAY,CAAC,EAE5D;gBACI,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,GAAG,gBAAgB,CAAC,KAAK,CAAC;aAChE;SACJ;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ"}

package/dist/es2015/factory.js

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

package/dist/es2015/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../src/factory.ts"],"names":[],"mappings":""}

package/dist/es2015/functions/get-own-reflect-metadata.js

@@ -0,0 +1,8 @@
+import { isFunction, isObject } from 'lodash';
+export function getOwnReflectMetadata(metadataKey, target) {
+    if (isObject(Reflect) && isFunction(Reflect.getOwnMetadata)) {
+        return Reflect.getOwnMetadata(metadataKey, target);
+    }
+    return undefined;
+}
+//# sourceMappingURL=get-own-reflect-metadata.js.map

package/dist/es2015/functions/get-own-reflect-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-own-reflect-metadata.js","sourceRoot":"","sources":["../../../src/functions/get-own-reflect-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AA4B9C,MAAM,UAAU,qBAAqB,CAAC,WAAmB,EAAE,MAAW;IAElE,IAAI,QAAQ,CAAC,OAAO,CAAC,IAAI,UAAU,CAAC,OAAO,CAAC,cAAc,CAAC,EAC3D;QACI,OAAO,OAAO,CAAC,cAAc,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;KACtD;IAED,OAAO,SAAS,CAAC;AACrB,CAAC"}

package/dist/es2015/functions/get-reflect-metadata.js

@@ -0,0 +1,8 @@
+import { isFunction, isObject } from 'lodash';
+export function getReflectMetadata(metadataKey, target, propertyKey) {
+    if (isObject(Reflect) && isFunction(Reflect.getMetadata)) {
+        return Reflect.getMetadata(metadataKey, target, propertyKey);
+    }
+    return undefined;
+}
+//# sourceMappingURL=get-reflect-metadata.js.map

package/dist/es2015/functions/get-reflect-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-reflect-metadata.js","sourceRoot":"","sources":["../../../src/functions/get-reflect-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AA8B9C,MAAM,UAAU,kBAAkB,CAAC,WAAmB,EAAE,MAAW,EAAE,WAA4B;IAE7F,IAAI,QAAQ,CAAC,OAAO,CAAC,IAAI,UAAU,CAAC,OAAO,CAAC,WAAW,CAAC,EACxD;QACI,OAAO,OAAO,CAAC,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;KAChE;IAED,OAAO,SAAS,CAAC;AACrB,CAAC"}

package/dist/es2015/functions/get-words.js

@@ -0,0 +1,5 @@
+import { words } from 'lodash';
+export function getWords(x) {
+    return words(x);
+}
+//# sourceMappingURL=get-words.js.map

package/dist/es2015/functions/get-words.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-words.js","sourceRoot":"","sources":["../../../src/functions/get-words.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAS/B,MAAM,UAAU,QAAQ,CAAC,CAAS;IAE9B,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;AACpB,CAAC"}

package/{functions/index.d.ts → dist/es2015/functions/index.js}

@@ -1,5 +1,5 @@
-export * from './get-reflect-metadata';
 export * from './get-own-reflect-metadata';
+export * from './get-reflect-metadata';
 export * from './get-words';
 export * from './is-arrow-function';
 export * from './is-ctor-function';
@@ -13,4 +13,7 @@ export * from './is-uint-8-array';
 export * from './is-uint-8-clamped-array';
 export * from './is-uint-16-array';
 export * from './is-uint-32-array';
+export * from './json-parse';
+export * from './json-stringify';
 export * from './name-of';
+//# sourceMappingURL=index.js.map

package/dist/es2015/functions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC;AAC5B,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC"}

package/dist/es2015/functions/is-arrow-function.js

@@ -0,0 +1,5 @@
+import { isFunction } from 'lodash';
+export function isArrowFunction(x) {
+    return isFunction(x) && x.prototype && x.prototype.constructor === x && x.name === '';
+}
+//# sourceMappingURL=is-arrow-function.js.map

package/dist/es2015/functions/is-arrow-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-arrow-function.js","sourceRoot":"","sources":["../../../src/functions/is-arrow-function.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AASpC,MAAM,UAAU,eAAe,CAAC,CAAM;IAElC,OAAO,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,SAAS,CAAC,WAAW,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC;AAC1F,CAAC"}

package/dist/es2015/functions/is-ctor-function.js

@@ -0,0 +1,5 @@
+import { isFunction } from 'lodash';
+export function isCtorFunction(x) {
+    return isFunction(x) && x.prototype && x.prototype.constructor === x && x.name !== '';
+}
+//# sourceMappingURL=is-ctor-function.js.map

package/dist/es2015/functions/is-ctor-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-ctor-function.js","sourceRoot":"","sources":["../../../src/functions/is-ctor-function.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AASpC,MAAM,UAAU,cAAc,CAAC,CAAM;IAEjC,OAAO,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,SAAS,CAAC,WAAW,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC;AAC1F,CAAC"}

package/dist/es2015/functions/is-data-view.js

@@ -0,0 +1,4 @@
+export function isDataView(x) {
+    return x instanceof DataView;
+}
+//# sourceMappingURL=is-data-view.js.map

package/dist/es2015/functions/is-data-view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-data-view.js","sourceRoot":"","sources":["../../../src/functions/is-data-view.ts"],"names":[],"mappings":"AAOA,MAAM,UAAU,UAAU,CAAC,CAAM;IAE7B,OAAO,CAAC,YAAY,QAAQ,CAAC;AACjC,CAAC"}

package/dist/es2015/functions/is-float-32-array.js

@@ -0,0 +1,4 @@
+export function isFloat32Array(x) {
+    return x instanceof Float32Array;
+}
+//# sourceMappingURL=is-float-32-array.js.map

package/dist/es2015/functions/is-float-32-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-float-32-array.js","sourceRoot":"","sources":["../../../src/functions/is-float-32-array.ts"],"names":[],"mappings":"AAOA,MAAM,UAAU,cAAc,CAAC,CAAM;IAEjC,OAAO,CAAC,YAAY,YAAY,CAAC;AACrC,CAAC"}

package/dist/es2015/functions/is-float-64-array.js

@@ -0,0 +1,4 @@
+export function isFloat64Array(x) {
+    return x instanceof Float64Array;
+}
+//# sourceMappingURL=is-float-64-array.js.map