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

package/dist/es5/injectors/singleton-injector.js

@@ -1,45 +1,45 @@
-import { __read, __spreadArray, __values } from "tslib";
-import { isNil } from 'lodash';
-import { isCtorFunction } from '../functions/is-ctor-function';
-var SingletonInjector = (function () {
-    function SingletonInjector() {
-        this.instanceMap = new WeakMap();
-    }
-    SingletonInjector.prototype.get = function (typeMetadata) {
-        if (!typeMetadata.injectable) {
-            throw new Error("".concat(typeMetadata.typeName, ": cannot resolve type! Have you registered it as injectable?"));
-        }
-        var instance = this.instanceMap.get(typeMetadata);
-        if (isNil(instance)) {
-            return this.init(typeMetadata);
-        }
-        return instance;
-    };
-    SingletonInjector.prototype.init = function (typeMetadata) {
-        var e_1, _a;
-        var typeCtor = isCtorFunction(typeMetadata.typeFn) ? typeMetadata.typeFn : undefined;
-        if (isNil(typeCtor)) {
-            throw new Error("".concat(typeMetadata.typeName, ": cannot inject instance of abstract type."));
-        }
-        var args = new Array();
-        try {
-            for (var _b = __values(typeMetadata.injectMetadataMap.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var injectMetadata = _c.value;
-                args[injectMetadata.injectIndex] = this.get(injectMetadata.typeMetadata);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        var instance = new (typeCtor.bind.apply(typeCtor, __spreadArray([void 0], __read(args), false)))();
-        this.instanceMap.set(typeMetadata, instance);
-        return instance;
-    };
-    return SingletonInjector;
-}());
-export { SingletonInjector };
+import { __read, __spreadArray, __values } from "tslib";
+import { isNil } from 'lodash';
+import { isCtorFunction } from '../functions/is-ctor-function';
+var SingletonInjector = (function () {
+    function SingletonInjector() {
+        this.instanceMap = new WeakMap();
+    }
+    SingletonInjector.prototype.get = function (typeMetadata) {
+        if (!typeMetadata.injectable) {
+            throw new Error("".concat(typeMetadata.typeName, ": cannot resolve type! Have you registered it as injectable?"));
+        }
+        var instance = this.instanceMap.get(typeMetadata);
+        if (isNil(instance)) {
+            return this.init(typeMetadata);
+        }
+        return instance;
+    };
+    SingletonInjector.prototype.init = function (typeMetadata) {
+        var e_1, _a;
+        var typeCtor = isCtorFunction(typeMetadata.typeFn) ? typeMetadata.typeFn : undefined;
+        if (isNil(typeCtor)) {
+            throw new Error("".concat(typeMetadata.typeName, ": cannot inject instance of abstract type."));
+        }
+        var args = new Array();
+        try {
+            for (var _b = __values(typeMetadata.injectMetadataMap.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var injectMetadata = _c.value;
+                args[injectMetadata.injectIndex] = this.get(injectMetadata.typeMetadata);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var instance = new (typeCtor.bind.apply(typeCtor, __spreadArray([void 0], __read(args), false)))();
+        this.instanceMap.set(typeMetadata, instance);
+        return instance;
+    };
+    return SingletonInjector;
+}());
+export { SingletonInjector };
 //# sourceMappingURL=singleton-injector.js.map

package/dist/es5/log-level.js

@@ -1,8 +1,8 @@
-export var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["Info"] = 0] = "Info";
-    LogLevel[LogLevel["Warn"] = 1] = "Warn";
-    LogLevel[LogLevel["Error"] = 2] = "Error";
-    LogLevel[LogLevel["None"] = 3] = "None";
-})(LogLevel || (LogLevel = {}));
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["Info"] = 0] = "Info";
+    LogLevel[LogLevel["Warn"] = 1] = "Warn";
+    LogLevel[LogLevel["Error"] = 2] = "Error";
+    LogLevel[LogLevel["None"] = 3] = "None";
+})(LogLevel || (LogLevel = {}));
 //# sourceMappingURL=log-level.js.map

package/dist/es5/log.js

@@ -1,65 +1,65 @@
-import { __read, __spreadArray } from "tslib";
-import { isFunction, isObject } from 'lodash';
-import { LogLevel } from './log-level';
-var Log = (function () {
-    function Log(logLevel) {
-        this.logLevel = logLevel;
-        this.infoEnabled = this.logLevel <= LogLevel.Info;
-        this.warnEnabled = this.logLevel <= LogLevel.Warn;
-        this.errorEnabled = this.logLevel <= LogLevel.Error;
-        this.supportsConsole = isObject(console);
-        this.supportsConsoleLog = this.supportsConsole && isFunction(console.log);
-        this.supportsConsoleInfo = this.supportsConsole && isFunction(console.info);
-        this.supportsConsoleWarn = this.supportsConsole && isFunction(console.warn);
-        this.supportsConsoleError = this.supportsConsole && isFunction(console.error);
-        return;
-    }
-    Log.prototype.info = function (message) {
-        var optionalParams = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            optionalParams[_i - 1] = arguments[_i];
-        }
-        if (this.supportsConsoleInfo) {
-            console.info.apply(console, __spreadArray([message], __read(optionalParams), false));
-            return;
-        }
-        if (this.supportsConsoleLog) {
-            console.log.apply(console, __spreadArray(["INFO: ".concat(message)], __read(optionalParams), false));
-            return;
-        }
-        return;
-    };
-    Log.prototype.warn = function (message) {
-        var optionalParams = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            optionalParams[_i - 1] = arguments[_i];
-        }
-        if (this.supportsConsoleWarn) {
-            console.warn.apply(console, __spreadArray([message], __read(optionalParams), false));
-            return;
-        }
-        if (this.supportsConsoleLog) {
-            console.log.apply(console, __spreadArray(["WARN: ".concat(message)], __read(optionalParams), false));
-            return;
-        }
-        return;
-    };
-    Log.prototype.error = function (message) {
-        var optionalParams = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            optionalParams[_i - 1] = arguments[_i];
-        }
-        if (this.supportsConsoleError) {
-            console.error.apply(console, __spreadArray([message], __read(optionalParams), false));
-            return;
-        }
-        if (this.supportsConsoleLog) {
-            console.log.apply(console, __spreadArray(["ERROR: ".concat(message)], __read(optionalParams), false));
-            return;
-        }
-        return;
-    };
-    return Log;
-}());
-export { Log };
+import { __read, __spreadArray } from "tslib";
+import { isFunction, isObject } from 'lodash';
+import { LogLevel } from './log-level';
+var Log = (function () {
+    function Log(logLevel) {
+        this.logLevel = logLevel;
+        this.infoEnabled = this.logLevel <= LogLevel.Info;
+        this.warnEnabled = this.logLevel <= LogLevel.Warn;
+        this.errorEnabled = this.logLevel <= LogLevel.Error;
+        this.supportsConsole = isObject(console);
+        this.supportsConsoleLog = this.supportsConsole && isFunction(console.log);
+        this.supportsConsoleInfo = this.supportsConsole && isFunction(console.info);
+        this.supportsConsoleWarn = this.supportsConsole && isFunction(console.warn);
+        this.supportsConsoleError = this.supportsConsole && isFunction(console.error);
+        return;
+    }
+    Log.prototype.info = function (message) {
+        var optionalParams = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            optionalParams[_i - 1] = arguments[_i];
+        }
+        if (this.supportsConsoleInfo) {
+            console.info.apply(console, __spreadArray([message], __read(optionalParams), false));
+            return;
+        }
+        if (this.supportsConsoleLog) {
+            console.log.apply(console, __spreadArray(["INFO: ".concat(message)], __read(optionalParams), false));
+            return;
+        }
+        return;
+    };
+    Log.prototype.warn = function (message) {
+        var optionalParams = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            optionalParams[_i - 1] = arguments[_i];
+        }
+        if (this.supportsConsoleWarn) {
+            console.warn.apply(console, __spreadArray([message], __read(optionalParams), false));
+            return;
+        }
+        if (this.supportsConsoleLog) {
+            console.log.apply(console, __spreadArray(["WARN: ".concat(message)], __read(optionalParams), false));
+            return;
+        }
+        return;
+    };
+    Log.prototype.error = function (message) {
+        var optionalParams = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            optionalParams[_i - 1] = arguments[_i];
+        }
+        if (this.supportsConsoleError) {
+            console.error.apply(console, __spreadArray([message], __read(optionalParams), false));
+            return;
+        }
+        if (this.supportsConsoleLog) {
+            console.log.apply(console, __spreadArray(["ERROR: ".concat(message)], __read(optionalParams), false));
+            return;
+        }
+        return;
+    };
+    return Log;
+}());
+export { Log };
 //# sourceMappingURL=log.js.map

package/dist/es5/metadata.js

@@ -1,106 +1,106 @@
-import { __values } from "tslib";
-import { isArray, isNil, isString } from 'lodash';
-import { isArrowFunction } from './functions/is-arrow-function';
-import { Unknown } from './unknown';
-var Metadata = (function () {
-    function Metadata(typeManager) {
-        this.typeManager = typeManager;
-        this.typeFnMap = typeManager.typeFnMap;
-        return;
-    }
-    Metadata.prototype.defineTypeMetadataResolver = function (typeArgument) {
-        if (isNil(typeArgument)) {
-            return this.resolveTypeMetadataUsingUnknownTypeFn.bind(this);
-        }
-        if (isString(typeArgument)) {
-            return this.resolveTypeMetadataUsingAlias.bind(this);
-        }
-        if (isArrowFunction(typeArgument)) {
-            return this.resolveTypeMetadataUsingTypeResolver.bind(this);
-        }
-        return this.resolveTypeMetadataUsingTypeFn.bind(this);
-    };
-    Metadata.prototype.resolveTypeMetadataUsingUnknownTypeFn = function () {
-        var typeFn = Unknown;
-        return this.typeManager.extractTypeMetadata(typeFn);
-    };
-    Metadata.prototype.resolveTypeMetadataUsingAlias = function (typeArgument) {
-        var alias = typeArgument;
-        var typeFn = this.typeFnMap.get(alias);
-        if (isNil(typeFn)) {
-            throw new Error("Cannot resolve type metadata for provided type alias: ".concat(alias, ". This is usually caused by invalid configuration."));
-        }
-        return this.typeManager.extractTypeMetadata(typeFn);
-    };
-    Metadata.prototype.resolveTypeMetadataUsingTypeFn = function (typeArgument) {
-        var typeFn = typeArgument;
-        return this.typeManager.extractTypeMetadata(typeFn);
-    };
-    Metadata.prototype.resolveTypeMetadataUsingTypeResolver = function (typeArgument) {
-        var typeResolver = typeArgument;
-        return this.typeManager.extractTypeMetadata(typeResolver());
-    };
-    Metadata.prototype.defineGenericStructures = function (genericArguments) {
-        var e_1, _a;
-        var genericStructures = new Array();
-        try {
-            for (var genericArguments_1 = __values(genericArguments), genericArguments_1_1 = genericArguments_1.next(); !genericArguments_1_1.done; genericArguments_1_1 = genericArguments_1.next()) {
-                var genericArgument = genericArguments_1_1.value;
-                var genericTypeArgument = isArray(genericArgument) ? genericArgument[0] : genericArgument;
-                var genericGenericArguments = isArray(genericArgument) ? genericArgument[1] : new Array();
-                genericStructures.push([
-                    genericTypeArgument,
-                    this.defineGenericStructures(genericGenericArguments)
-                ]);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (genericArguments_1_1 && !genericArguments_1_1.done && (_a = genericArguments_1.return)) _a.call(genericArguments_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return genericStructures;
-    };
-    Metadata.prototype.defineGenericMetadataResolvers = function (genericStructures) {
-        var e_2, _a;
-        var genericMetadataResolvers = new Array();
-        try {
-            for (var genericStructures_1 = __values(genericStructures), genericStructures_1_1 = genericStructures_1.next(); !genericStructures_1_1.done; genericStructures_1_1 = genericStructures_1.next()) {
-                var genericStructure = genericStructures_1_1.value;
-                var genericTypeArgument = genericStructure[0];
-                var genericGenericStructures = genericStructure[1];
-                genericMetadataResolvers.push([
-                    this.defineTypeMetadataResolver(genericTypeArgument),
-                    this.defineGenericMetadataResolvers(genericGenericStructures)
-                ]);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (genericStructures_1_1 && !genericStructures_1_1.done && (_a = genericStructures_1.return)) _a.call(genericStructures_1);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        return genericMetadataResolvers;
-    };
-    Metadata.prototype.defineGenericMetadatas = function (genericStructures, genericMetadataResolvers) {
-        var genericMetadatas = new Array();
-        for (var i = 0; i < genericStructures.length; i++) {
-            var genericTypeArgument = genericStructures[i][0];
-            var genericMetadataResolver = genericMetadataResolvers[i][0];
-            var genericGenericStructures = genericStructures[i][1];
-            var genericGenericMetadataResolvers = genericMetadataResolvers[i][1];
-            genericMetadatas.push([
-                genericMetadataResolver(genericTypeArgument),
-                this.defineGenericMetadatas(genericGenericStructures, genericGenericMetadataResolvers)
-            ]);
-        }
-        return genericMetadatas;
-    };
-    return Metadata;
-}());
-export { Metadata };
+import { __values } from "tslib";
+import { isArray, isNil, isString } from 'lodash';
+import { isArrowFunction } from './functions/is-arrow-function';
+import { Unknown } from './unknown';
+var Metadata = (function () {
+    function Metadata(typeManager) {
+        this.typeManager = typeManager;
+        this.typeFnMap = typeManager.typeFnMap;
+        return;
+    }
+    Metadata.prototype.defineTypeMetadataResolver = function (typeArgument) {
+        if (isNil(typeArgument)) {
+            return this.resolveTypeMetadataUsingUnknownTypeFn.bind(this);
+        }
+        if (isString(typeArgument)) {
+            return this.resolveTypeMetadataUsingAlias.bind(this);
+        }
+        if (isArrowFunction(typeArgument)) {
+            return this.resolveTypeMetadataUsingTypeResolver.bind(this);
+        }
+        return this.resolveTypeMetadataUsingTypeFn.bind(this);
+    };
+    Metadata.prototype.resolveTypeMetadataUsingUnknownTypeFn = function () {
+        var typeFn = Unknown;
+        return this.typeManager.extractTypeMetadata(typeFn);
+    };
+    Metadata.prototype.resolveTypeMetadataUsingAlias = function (typeArgument) {
+        var alias = typeArgument;
+        var typeFn = this.typeFnMap.get(alias);
+        if (isNil(typeFn)) {
+            throw new Error("Cannot resolve type metadata for provided type alias: ".concat(alias, ". This is usually caused by invalid configuration."));
+        }
+        return this.typeManager.extractTypeMetadata(typeFn);
+    };
+    Metadata.prototype.resolveTypeMetadataUsingTypeFn = function (typeArgument) {
+        var typeFn = typeArgument;
+        return this.typeManager.extractTypeMetadata(typeFn);
+    };
+    Metadata.prototype.resolveTypeMetadataUsingTypeResolver = function (typeArgument) {
+        var typeResolver = typeArgument;
+        return this.typeManager.extractTypeMetadata(typeResolver());
+    };
+    Metadata.prototype.defineGenericStructures = function (genericArguments) {
+        var e_1, _a;
+        var genericStructures = new Array();
+        try {
+            for (var genericArguments_1 = __values(genericArguments), genericArguments_1_1 = genericArguments_1.next(); !genericArguments_1_1.done; genericArguments_1_1 = genericArguments_1.next()) {
+                var genericArgument = genericArguments_1_1.value;
+                var genericTypeArgument = isArray(genericArgument) ? genericArgument[0] : genericArgument;
+                var genericGenericArguments = isArray(genericArgument) ? genericArgument[1] : new Array();
+                genericStructures.push([
+                    genericTypeArgument,
+                    this.defineGenericStructures(genericGenericArguments)
+                ]);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (genericArguments_1_1 && !genericArguments_1_1.done && (_a = genericArguments_1.return)) _a.call(genericArguments_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return genericStructures;
+    };
+    Metadata.prototype.defineGenericMetadataResolvers = function (genericStructures) {
+        var e_2, _a;
+        var genericMetadataResolvers = new Array();
+        try {
+            for (var genericStructures_1 = __values(genericStructures), genericStructures_1_1 = genericStructures_1.next(); !genericStructures_1_1.done; genericStructures_1_1 = genericStructures_1.next()) {
+                var genericStructure = genericStructures_1_1.value;
+                var genericTypeArgument = genericStructure[0];
+                var genericGenericStructures = genericStructure[1];
+                genericMetadataResolvers.push([
+                    this.defineTypeMetadataResolver(genericTypeArgument),
+                    this.defineGenericMetadataResolvers(genericGenericStructures)
+                ]);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (genericStructures_1_1 && !genericStructures_1_1.done && (_a = genericStructures_1.return)) _a.call(genericStructures_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return genericMetadataResolvers;
+    };
+    Metadata.prototype.defineGenericMetadatas = function (genericStructures, genericMetadataResolvers) {
+        var genericMetadatas = new Array();
+        for (var i = 0; i < genericStructures.length; i++) {
+            var genericTypeArgument = genericStructures[i][0];
+            var genericMetadataResolver = genericMetadataResolvers[i][0];
+            var genericGenericStructures = genericStructures[i][1];
+            var genericGenericMetadataResolvers = genericMetadataResolvers[i][1];
+            genericMetadatas.push([
+                genericMetadataResolver(genericTypeArgument),
+                this.defineGenericMetadatas(genericGenericStructures, genericGenericMetadataResolvers)
+            ]);
+        }
+        return genericMetadatas;
+    };
+    return Metadata;
+}());
+export { Metadata };
 //# sourceMappingURL=metadata.js.map

package/dist/es5/naming-convention.js

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

package/dist/es5/naming-conventions/camel-case-naming-convention.js

@@ -1,21 +1,21 @@
-import { getWords } from '../functions/get-words';
-var CamelCaseNamingConvention = (function () {
-    function CamelCaseNamingConvention() {
-    }
-    CamelCaseNamingConvention.prototype.convert = function (name) {
-        return getWords(name).reduce(this.reduce, '');
-    };
-    CamelCaseNamingConvention.prototype.reduce = function (result, word, index) {
-        if (word.length === 0) {
-            return result;
-        }
-        var wordLowerCased = word.toLowerCase();
-        if (index === 0) {
-            return wordLowerCased;
-        }
-        return "".concat(result).concat(wordLowerCased[0].toUpperCase()).concat(wordLowerCased.slice(1));
-    };
-    return CamelCaseNamingConvention;
-}());
-export { CamelCaseNamingConvention };
+import { getWords } from '../functions/get-words';
+var CamelCaseNamingConvention = (function () {
+    function CamelCaseNamingConvention() {
+    }
+    CamelCaseNamingConvention.prototype.convert = function (name) {
+        return getWords(name).reduce(this.reduce, '');
+    };
+    CamelCaseNamingConvention.prototype.reduce = function (result, word, index) {
+        if (word.length === 0) {
+            return result;
+        }
+        var wordLowerCased = word.toLowerCase();
+        if (index === 0) {
+            return wordLowerCased;
+        }
+        return "".concat(result).concat(wordLowerCased[0].toUpperCase()).concat(wordLowerCased.slice(1));
+    };
+    return CamelCaseNamingConvention;
+}());
+export { CamelCaseNamingConvention };
 //# sourceMappingURL=camel-case-naming-convention.js.map

package/dist/es5/naming-conventions/flat-case-naming-convention.js

@@ -1,17 +1,17 @@
-import { getWords } from '../functions/get-words';
-var FlatCaseNamingConvention = (function () {
-    function FlatCaseNamingConvention() {
-    }
-    FlatCaseNamingConvention.prototype.convert = function (name) {
-        return getWords(name).reduce(this.reduce, '');
-    };
-    FlatCaseNamingConvention.prototype.reduce = function (result, word) {
-        if (word.length === 0) {
-            return result;
-        }
-        return "".concat(result).concat(word.toLowerCase());
-    };
-    return FlatCaseNamingConvention;
-}());
-export { FlatCaseNamingConvention };
+import { getWords } from '../functions/get-words';
+var FlatCaseNamingConvention = (function () {
+    function FlatCaseNamingConvention() {
+    }
+    FlatCaseNamingConvention.prototype.convert = function (name) {
+        return getWords(name).reduce(this.reduce, '');
+    };
+    FlatCaseNamingConvention.prototype.reduce = function (result, word) {
+        if (word.length === 0) {
+            return result;
+        }
+        return "".concat(result).concat(word.toLowerCase());
+    };
+    return FlatCaseNamingConvention;
+}());
+export { FlatCaseNamingConvention };
 //# sourceMappingURL=flat-case-naming-convention.js.map

package/dist/es5/naming-conventions/flat-upper-case-naming-convention.js

@@ -1,17 +1,17 @@
-import { getWords } from '../functions/get-words';
-var FlatUpperCaseNamingConvention = (function () {
-    function FlatUpperCaseNamingConvention() {
-    }
-    FlatUpperCaseNamingConvention.prototype.convert = function (name) {
-        return getWords(name).reduce(this.reduce, '');
-    };
-    FlatUpperCaseNamingConvention.prototype.reduce = function (result, word) {
-        if (word.length === 0) {
-            return result;
-        }
-        return "".concat(result).concat(word.toUpperCase());
-    };
-    return FlatUpperCaseNamingConvention;
-}());
-export { FlatUpperCaseNamingConvention };
+import { getWords } from '../functions/get-words';
+var FlatUpperCaseNamingConvention = (function () {
+    function FlatUpperCaseNamingConvention() {
+    }
+    FlatUpperCaseNamingConvention.prototype.convert = function (name) {
+        return getWords(name).reduce(this.reduce, '');
+    };
+    FlatUpperCaseNamingConvention.prototype.reduce = function (result, word) {
+        if (word.length === 0) {
+            return result;
+        }
+        return "".concat(result).concat(word.toUpperCase());
+    };
+    return FlatUpperCaseNamingConvention;
+}());
+export { FlatUpperCaseNamingConvention };
 //# sourceMappingURL=flat-upper-case-naming-convention.js.map

package/dist/es5/naming-conventions/index.js

@@ -1,9 +1,9 @@
-export * from './camel-case-naming-convention';
-export * from './flat-case-naming-convention';
-export * from './flat-upper-case-naming-convention';
-export * from './kebab-case-naming-convention';
-export * from './kebab-upper-case-naming-convention';
-export * from './pascal-case-naming-convention';
-export * from './snake-case-naming-convention';
-export * from './snake-upper-case-naming-convention';
+export * from './camel-case-naming-convention';
+export * from './flat-case-naming-convention';
+export * from './flat-upper-case-naming-convention';
+export * from './kebab-case-naming-convention';
+export * from './kebab-upper-case-naming-convention';
+export * from './pascal-case-naming-convention';
+export * from './snake-case-naming-convention';
+export * from './snake-upper-case-naming-convention';
 //# sourceMappingURL=index.js.map

package/dist/es5/naming-conventions/kebab-case-naming-convention.js

@@ -1,21 +1,21 @@
-import { getWords } from '../functions/get-words';
-var KebabCaseNamingConvention = (function () {
-    function KebabCaseNamingConvention() {
-    }
-    KebabCaseNamingConvention.prototype.convert = function (name) {
-        return getWords(name).reduce(this.reduce, '');
-    };
-    KebabCaseNamingConvention.prototype.reduce = function (result, word, index) {
-        if (word.length === 0) {
-            return result;
-        }
-        var wordLowerCased = word.toLowerCase();
-        if (index === 0) {
-            return wordLowerCased;
-        }
-        return "".concat(result, "-").concat(wordLowerCased);
-    };
-    return KebabCaseNamingConvention;
-}());
-export { KebabCaseNamingConvention };
+import { getWords } from '../functions/get-words';
+var KebabCaseNamingConvention = (function () {
+    function KebabCaseNamingConvention() {
+    }
+    KebabCaseNamingConvention.prototype.convert = function (name) {
+        return getWords(name).reduce(this.reduce, '');
+    };
+    KebabCaseNamingConvention.prototype.reduce = function (result, word, index) {
+        if (word.length === 0) {
+            return result;
+        }
+        var wordLowerCased = word.toLowerCase();
+        if (index === 0) {
+            return wordLowerCased;
+        }
+        return "".concat(result, "-").concat(wordLowerCased);
+    };
+    return KebabCaseNamingConvention;
+}());
+export { KebabCaseNamingConvention };
 //# sourceMappingURL=kebab-case-naming-convention.js.map