@venok/core 1.0.0

package/interfaces/modules/provider.interface.d.ts

@@ -0,0 +1,142 @@
+import { Scope, Type } from "@venok/core/interfaces";
+import { InjectionToken, OptionalFactoryDependency } from "@venok/core/interfaces/modules";
+/**
+ *
+ * @publicApi
+ */
+export type Provider<T = any> = Type<any> | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | ExistingProvider<T>;
+/**
+ * Interface defining a *Class* type provider.
+ *
+ * For example:
+ * ```typescript
+ * const configServiceProvider = {
+ * provide: ConfigService,
+ * useClass:
+ *   process.env.NODE_ENV === 'development'
+ *     ? DevelopmentConfigService
+ *     : ProductionConfigService,
+ * };
+ * ```
+ *
+ * @publicApi
+ */
+export interface ClassProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Type (class name) of provider (instance to be injected).
+     */
+    useClass: Type<T>;
+    /**
+     * Optional enum defining lifetime of the provider that is injected.
+     */
+    scope?: Scope;
+    /**
+     * This option is only available on factory providers!
+     *
+     */
+    inject?: never;
+    /**
+     * Flags provider as durable. This flag can be used in combination with custom context id
+     * factory strategy to construct lazy DI subtrees.
+     *
+     * This flag can be used only in conjunction with scope = Scope.REQUEST.
+     */
+    durable?: boolean;
+}
+/**
+ * Interface defining a *Value* type provider.
+ *
+ * For example:
+ * ```typescript
+ * const connectionProvider = {
+ *   provide: 'CONNECTION',
+ *   useValue: connection,
+ * };
+ * ```
+ *
+ * @publicApi
+ */
+export interface ValueProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Instance of a provider to be injected.
+     */
+    useValue: T;
+    /**
+     * This option is only available on factory providers!
+     *
+     */
+    inject?: never;
+}
+/**
+ * Interface defining a *Factory* type provider.
+ *
+ * For example:
+ * ```typescript
+ * const connectionFactory = {
+ *   provide: 'CONNECTION',
+ *   useFactory: (optionsProvider: OptionsProvider) => {
+ *     const options = optionsProvider.get();
+ *     return new DatabaseConnection(options);
+ *   },
+ *   inject: [OptionsProvider],
+ * };
+ * ```
+ *
+ * @publicApi
+ */
+export interface FactoryProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Factory function that returns an instance of the provider to be injected.
+     */
+    useFactory: (...args: any[]) => T | Promise<T>;
+    /**
+     * Optional list of providers to be injected into the context of the Factory function.
+     */
+    inject?: Array<InjectionToken | OptionalFactoryDependency>;
+    /**
+     * Optional enum defining lifetime of the provider that is returned by the Factory function.
+     */
+    scope?: Scope;
+    /**
+     * Flags provider as durable. This flag can be used in combination with custom context id
+     * factory strategy to construct lazy DI subtrees.
+     *
+     * This flag can be used only in conjunction with scope = Scope.REQUEST.
+     */
+    durable?: boolean;
+}
+/**
+ * Interface defining an *Existing* (aliased) type provider.
+ *
+ * For example:
+ * ```typescript
+ * const loggerAliasProvider = {
+ *   provide: 'AliasedLoggerService',
+ *   useExisting: LoggerService
+ * };
+ * ```
+ *
+ * @publicApi
+ */
+export interface ExistingProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Provider to be aliased by the Injection token.
+     */
+    useExisting: any;
+}

package/interfaces/modules/provider.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/scope.interface.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @publicApi
+ */
+export declare enum Scope {
+    /**
+     * The provider can be shared across multiple classes. The provider lifetime
+     * is strictly tied to the application lifecycle. Once the application has
+     * bootstrapped, all providers have been instantiated.
+     */
+    DEFAULT = 0,
+    /**
+     * A new private instance of the provider is instantiated for every use
+     */
+    TRANSIENT = 1,
+    /**
+     * A new instance is instantiated for each request processing pipeline
+     */
+    REQUEST = 2
+}
+/**
+ * @publicApi
+ */
+export interface ScopeOptions {
+    /**
+     * Specifies the lifetime of an injected Provider or Controller.
+     */
+    scope?: Scope;
+    /**
+     * Flags provider as durable. This flag can be used in combination with custom context id
+     * factory strategy to construct lazy DI subtrees.
+     *
+     * This flag can be used only in conjunction with scope = Scope.REQUEST.
+     */
+    durable?: boolean;
+}

package/interfaces/scope.interface.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scope = void 0;
+/**
+ * @publicApi
+ */
+var Scope;
+(function (Scope) {
+    /**
+     * The provider can be shared across multiple classes. The provider lifetime
+     * is strictly tied to the application lifecycle. Once the application has
+     * bootstrapped, all providers have been instantiated.
+     */
+    Scope[Scope["DEFAULT"] = 0] = "DEFAULT";
+    /**
+     * A new private instance of the provider is instantiated for every use
+     */
+    Scope[Scope["TRANSIENT"] = 1] = "TRANSIENT";
+    /**
+     * A new instance is instantiated for each request processing pipeline
+     */
+    Scope[Scope["REQUEST"] = 2] = "REQUEST";
+})(Scope || (exports.Scope = Scope = {}));

package/interfaces/type.interface.d.ts

@@ -0,0 +1,3 @@
+export interface Type<T = any> extends Function {
+    new (...args: any[]): T;
+}

package/interfaces/type.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/metadata-scanner.d.ts

@@ -0,0 +1,4 @@
+export declare class MetadataScanner {
+    private readonly cachedScannedPrototypes;
+    getAllMethodNames(prototype: object | null): string[];
+}

package/metadata-scanner.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataScanner = void 0;
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+class MetadataScanner {
+    constructor() {
+        this.cachedScannedPrototypes = new Map();
+    }
+    getAllMethodNames(prototype) {
+        if (!prototype)
+            return [];
+        if (this.cachedScannedPrototypes.has(prototype)) {
+            return this.cachedScannedPrototypes.get(prototype);
+        }
+        const visitedNames = new Map();
+        const result = [];
+        this.cachedScannedPrototypes.set(prototype, result);
+        do {
+            for (const property of Object.getOwnPropertyNames(prototype)) {
+                if (visitedNames.has(property))
+                    continue;
+                visitedNames.set(property, true);
+                const descriptor = Object.getOwnPropertyDescriptor(prototype, property);
+                if (descriptor?.set || descriptor?.get)
+                    continue;
+                if ((0, shared_helper_1.isConstructor)(property) || !(0, shared_helper_1.isFunction)(prototype[property]))
+                    continue;
+                result.push(property);
+            }
+        } while ((prototype = Reflect.getPrototypeOf(prototype)) && prototype !== Object.prototype);
+        return result;
+    }
+}
+exports.MetadataScanner = MetadataScanner;

package/module/configurable-module.builder.d.ts

@@ -0,0 +1,93 @@
+import { DEFAULT_FACTORY_CLASS_METHOD_KEY, DEFAULT_METHOD_KEY } from "@venok/core/module/constants";
+import { DynamicModule } from "@venok/core/interfaces";
+import { Logger } from "@venok/core/services/logger.service";
+import { ConfigurableModuleHost } from "@venok/core/interfaces/modules/configurable";
+/**
+ * @publicApi
+ */
+export interface ConfigurableModuleBuilderOptions {
+    /**
+     * Specified what injection token should be used for the module options provider.
+     * By default, an auto-generated UUID will be used.
+     */
+    optionsInjectionToken?: string | symbol;
+    /**
+     * By default, a UUID will be used as a module options provider token.
+     * Explicitly specifying the "moduleName" will instruct the "ConfigurableModuleBuilder"
+     * to use a more descriptive provider token.
+     *
+     * For example, if `moduleName: "Cache"` then auto-generated provider token will be "CACHE_MODULE_OPTIONS".
+     */
+    moduleName?: string;
+    /**
+     * Indicates whether module should always be "transient", meaning,
+     * every time you call the static method to construct a dynamic module,
+     * regardless of what arguments you pass in, a new "unique" module will be created.
+     *
+     * @default false
+     */
+    alwaysTransient?: boolean;
+}
+/**
+ * Factory that lets you create configurable module and
+ * provides a way to reduce the majority of dynamic module boilerplate.
+ *
+ * @publicApi
+ */
+export declare class ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey extends string = typeof DEFAULT_METHOD_KEY, FactoryClassMethodKey extends string = typeof DEFAULT_FACTORY_CLASS_METHOD_KEY, ExtraModuleDefinitionOptions = {}> {
+    protected readonly options: ConfigurableModuleBuilderOptions;
+    protected staticMethodKey: StaticMethodKey;
+    protected factoryClassMethodKey: FactoryClassMethodKey;
+    protected extras: ExtraModuleDefinitionOptions;
+    protected transformModuleDefinition: (definition: DynamicModule, extraOptions: ExtraModuleDefinitionOptions) => DynamicModule;
+    protected readonly logger: Logger;
+    constructor(options?: ConfigurableModuleBuilderOptions, parentBuilder?: ConfigurableModuleBuilder<ModuleOptions>);
+    /**
+     * Registers the "extras" object (a set of extra options that can be used to modify the dynamic module definition).
+     * Values you specify within the "extras" object will be used as default values (that can be overridden by module consumers).
+     *
+     * This method also applies the so-called "module definition transform function" that takes the auto-generated
+     * dynamic module object ("DynamicModule") and the actual consumer "extras" object as input parameters.
+     * The "extras" object consists of values explicitly specified by module consumers and default values.
+     *
+     * @example
+     * ```typescript
+     * .setExtras<{ isGlobal?: boolean }>({ isGlobal: false }, (definition, extras) =>
+     *    ({ ...definition, global: extras.isGlobal })
+     * )
+     * ```
+     */
+    setExtras<ExtraModuleDefinitionOptions>(extras: ExtraModuleDefinitionOptions, transformDefinition?: (definition: DynamicModule, extras: ExtraModuleDefinitionOptions) => DynamicModule): ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * Dynamic module must expose public static methods that let you pass in
+     * configuration parameters (control the module's behavior from the outside).
+     * Some frequently used names that you may have seen in other module are:
+     * "forRoot", "forFeature", "register", "configure".
+     *
+     * This method "setClassMethodName" lets you specify the name of the
+     * method that will be auto-generated.
+     *
+     * @param key name of the method
+     */
+    setClassMethodName<StaticMethodKey extends string>(key: StaticMethodKey): ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * Asynchronously configured module (that rely on other module, i.e. "ConfigModule")
+     * let you pass the configuration factory class that will be registered and instantiated as a provider.
+     * This provider then will be used to retrieve the module's configuration. To provide the configuration,
+     * the corresponding factory method must be implemented.
+     *
+     * This method ("setFactoryMethodName") lets you control what method name will have to be
+     * implemented by the config factory (default is "create").
+     *
+     * @param key name of the method
+     */
+    setFactoryMethodName<FactoryClassMethodKey extends string>(key: FactoryClassMethodKey): ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * Returns an object consisting of multiple properties that lets you
+     * easily construct dynamic configurable module. See "ConfigurableModuleHost" interface for more details.
+     */
+    build(): ConfigurableModuleHost<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    private constructInjectionTokenString;
+    private createConfigurableModuleCls;
+    private createTypeProxy;
+}

package/module/configurable-module.builder.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurableModuleBuilder = void 0;
+const constants_1 = require("@venok/core/module/constants");
+const logger_service_1 = require("@venok/core/services/logger.service");
+const helpers_1 = require("@venok/core/module/helpers");
+const random_string_generator_helper_1 = require("@venok/core/helpers/random-string-generator.helper");
+/**
+ * Factory that lets you create configurable module and
+ * provides a way to reduce the majority of dynamic module boilerplate.
+ *
+ * @publicApi
+ */
+class ConfigurableModuleBuilder {
+    constructor(options = {}, parentBuilder) {
+        this.options = options;
+        this.logger = new logger_service_1.Logger(ConfigurableModuleBuilder.name);
+        if (parentBuilder) {
+            this.staticMethodKey = parentBuilder.staticMethodKey;
+            this.factoryClassMethodKey = parentBuilder.factoryClassMethodKey;
+            this.transformModuleDefinition = parentBuilder.transformModuleDefinition;
+            this.extras = parentBuilder.extras;
+        }
+    }
+    /**
+     * Registers the "extras" object (a set of extra options that can be used to modify the dynamic module definition).
+     * Values you specify within the "extras" object will be used as default values (that can be overridden by module consumers).
+     *
+     * This method also applies the so-called "module definition transform function" that takes the auto-generated
+     * dynamic module object ("DynamicModule") and the actual consumer "extras" object as input parameters.
+     * The "extras" object consists of values explicitly specified by module consumers and default values.
+     *
+     * @example
+     * ```typescript
+     * .setExtras<{ isGlobal?: boolean }>({ isGlobal: false }, (definition, extras) =>
+     *    ({ ...definition, global: extras.isGlobal })
+     * )
+     * ```
+     */
+    setExtras(extras, transformDefinition = (def) => def) {
+        const builder = new ConfigurableModuleBuilder(this.options, this);
+        builder.extras = extras;
+        builder.transformModuleDefinition = transformDefinition;
+        return builder;
+    }
+    /**
+     * Dynamic module must expose public static methods that let you pass in
+     * configuration parameters (control the module's behavior from the outside).
+     * Some frequently used names that you may have seen in other module are:
+     * "forRoot", "forFeature", "register", "configure".
+     *
+     * This method "setClassMethodName" lets you specify the name of the
+     * method that will be auto-generated.
+     *
+     * @param key name of the method
+     */
+    setClassMethodName(key) {
+        const builder = new ConfigurableModuleBuilder(this.options, this);
+        builder.staticMethodKey = key;
+        return builder;
+    }
+    /**
+     * Asynchronously configured module (that rely on other module, i.e. "ConfigModule")
+     * let you pass the configuration factory class that will be registered and instantiated as a provider.
+     * This provider then will be used to retrieve the module's configuration. To provide the configuration,
+     * the corresponding factory method must be implemented.
+     *
+     * This method ("setFactoryMethodName") lets you control what method name will have to be
+     * implemented by the config factory (default is "create").
+     *
+     * @param key name of the method
+     */
+    setFactoryMethodName(key) {
+        const builder = new ConfigurableModuleBuilder(this.options, this);
+        builder.factoryClassMethodKey = key;
+        return builder;
+    }
+    /**
+     * Returns an object consisting of multiple properties that lets you
+     * easily construct dynamic configurable module. See "ConfigurableModuleHost" interface for more details.
+     */
+    build() {
+        this.staticMethodKey ??= constants_1.DEFAULT_METHOD_KEY;
+        this.factoryClassMethodKey ??= constants_1.DEFAULT_FACTORY_CLASS_METHOD_KEY;
+        this.options.optionsInjectionToken ??= this.options.moduleName
+            ? this.constructInjectionTokenString()
+            : (0, helpers_1.generateOptionsInjectionToken)();
+        this.transformModuleDefinition ??= (definition) => definition;
+        return {
+            ConfigurableModuleClass: this.createConfigurableModuleCls(),
+            MODULE_OPTIONS_TOKEN: this.options.optionsInjectionToken,
+            ASYNC_OPTIONS_TYPE: this.createTypeProxy("ASYNC_OPTIONS_TYPE"),
+            OPTIONS_TYPE: this.createTypeProxy("OPTIONS_TYPE"),
+        };
+    }
+    constructInjectionTokenString() {
+        const moduleNameInSnakeCase = (this.options.moduleName ?? (0, random_string_generator_helper_1.randomStringGenerator)())
+            .trim()
+            .split(/(?=[A-Z])/)
+            .join("_")
+            .toUpperCase();
+        return `${moduleNameInSnakeCase}_MODULE_OPTIONS`;
+    }
+    createConfigurableModuleCls() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const asyncMethodKey = this.staticMethodKey + constants_1.ASYNC_METHOD_SUFFIX;
+        class InternalModuleClass {
+            static [self.staticMethodKey](options) {
+                const providers = [
+                    {
+                        provide: self.options.optionsInjectionToken,
+                        useValue: this.omitExtras(options, self.extras),
+                    },
+                ];
+                if (self.options.alwaysTransient) {
+                    providers.push({
+                        provide: constants_1.CONFIGURABLE_MODULE_ID,
+                        useValue: (0, random_string_generator_helper_1.randomStringGenerator)(),
+                    });
+                }
+                return self.transformModuleDefinition({
+                    module: this,
+                    providers,
+                }, {
+                    ...self.extras,
+                    ...options,
+                });
+            }
+            static [asyncMethodKey](options) {
+                const providers = this.createAsyncProviders(options);
+                if (self.options.alwaysTransient) {
+                    providers.push({
+                        provide: constants_1.CONFIGURABLE_MODULE_ID,
+                        useValue: (0, random_string_generator_helper_1.randomStringGenerator)(),
+                    });
+                }
+                return self.transformModuleDefinition({
+                    module: this,
+                    imports: options.imports || [],
+                    providers,
+                }, {
+                    ...self.extras,
+                    ...options,
+                });
+            }
+            static omitExtras(input, extras) {
+                if (!extras)
+                    return input;
+                const moduleOptions = {};
+                const extrasKeys = Object.keys(extras);
+                Object.keys(input)
+                    .filter((key) => !extrasKeys.includes(key))
+                    .forEach((key) => {
+                    // @ts-ignore
+                    moduleOptions[key] = input[key];
+                });
+                return moduleOptions;
+            }
+            static createAsyncProviders(options) {
+                if (options.useExisting || options.useFactory) {
+                    if (options.inject && options.provideInjectionTokensFrom) {
+                        return [
+                            this.createAsyncOptionsProvider(options),
+                            ...(0, helpers_1.getInjectionProviders)(options.provideInjectionTokensFrom, options.inject),
+                        ];
+                    }
+                    return [this.createAsyncOptionsProvider(options)];
+                }
+                return [
+                    this.createAsyncOptionsProvider(options),
+                    {
+                        provide: options.useClass,
+                        useClass: options.useClass,
+                    },
+                ];
+            }
+            static createAsyncOptionsProvider(options) {
+                if (options.useFactory) {
+                    return {
+                        provide: self.options.optionsInjectionToken,
+                        useFactory: options.useFactory,
+                        inject: options.inject || [],
+                    };
+                }
+                return {
+                    provide: self.options.optionsInjectionToken,
+                    useFactory: async (optionsFactory) => await optionsFactory[self.factoryClassMethodKey](),
+                    inject: [options.useExisting || options.useClass],
+                };
+            }
+        }
+        return InternalModuleClass;
+    }
+    createTypeProxy(typeName) {
+        const proxy = new Proxy({}, {
+            get: () => {
+                throw new Error(`"${typeName}" is not supposed to be used as a value.`);
+            },
+        });
+        return proxy;
+    }
+}
+exports.ConfigurableModuleBuilder = ConfigurableModuleBuilder;

package/module/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_METHOD_KEY = "register";
+export declare const DEFAULT_FACTORY_CLASS_METHOD_KEY = "create";
+export declare const ASYNC_METHOD_SUFFIX = "Async";
+export declare const CONFIGURABLE_MODULE_ID = "CONFIGURABLE_MODULE_ID";

package/module/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIGURABLE_MODULE_ID = exports.ASYNC_METHOD_SUFFIX = exports.DEFAULT_FACTORY_CLASS_METHOD_KEY = exports.DEFAULT_METHOD_KEY = void 0;
+exports.DEFAULT_METHOD_KEY = 'register';
+exports.DEFAULT_FACTORY_CLASS_METHOD_KEY = 'create';
+exports.ASYNC_METHOD_SUFFIX = 'Async';
+exports.CONFIGURABLE_MODULE_ID = 'CONFIGURABLE_MODULE_ID';

package/module/helpers/generate-options-injection-token.helper.d.ts

@@ -0,0 +1 @@
+export declare function generateOptionsInjectionToken(): string;

package/module/helpers/generate-options-injection-token.helper.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOptionsInjectionToken = void 0;
+const random_string_generator_helper_1 = require("@venok/core/helpers/random-string-generator.helper");
+function generateOptionsInjectionToken() {
+    const hash = (0, random_string_generator_helper_1.randomStringGenerator)();
+    return `CONFIGURABLE_MODULE_OPTIONS[${hash}]`;
+}
+exports.generateOptionsInjectionToken = generateOptionsInjectionToken;

package/module/helpers/get-injection-providers.helper.d.ts

@@ -0,0 +1,8 @@
+import { FactoryProvider, Provider } from "@venok/core/interfaces";
+/**
+ *
+ * @param providers List of a module's providers
+ * @param tokens Injection tokens needed for a useFactory function (usually the module's options' token)
+ * @returns All the providers needed for the tokens' injection (searched recursively)
+ */
+export declare function getInjectionProviders(providers: Provider[], tokens: FactoryProvider["inject"]): Provider[];

package/module/helpers/get-injection-providers.helper.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInjectionProviders = void 0;
+/**
+ * check if x is OptionalFactoryDependency, based on prototype presence
+ * (to avoid classes with a static 'token' field)
+ * @param x
+ * @returns x is OptionalFactoryDependency
+ */
+function isOptionalFactoryDependency(x) {
+    return !!(x?.token && !x?.prototype);
+}
+const mapInjectToTokens = (t) => isOptionalFactoryDependency(t) ? t.token : t;
+/**
+ *
+ * @param providers List of a module's providers
+ * @param tokens Injection tokens needed for a useFactory function (usually the module's options' token)
+ * @returns All the providers needed for the tokens' injection (searched recursively)
+ */
+function getInjectionProviders(providers, tokens) {
+    const result = [];
+    let search = tokens.map(mapInjectToTokens);
+    while (search.length > 0) {
+        const match = (providers ?? []).filter((p) => !result.includes(p) && // this prevents circular loops and duplication
+            (search.includes(p) || search.includes(p?.provide)));
+        result.push(...match);
+        // get injection tokens of the matched providers, if any
+        search = match
+            .filter((p) => p?.inject)
+            .map((p) => p.inject)
+            .flat()
+            .map(mapInjectToTokens);
+    }
+    return result;
+}
+exports.getInjectionProviders = getInjectionProviders;

package/module/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./generate-options-injection-token.helper";
+export * from "./get-injection-providers.helper";

package/module/helpers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./generate-options-injection-token.helper"), exports);
+__exportStar(require("./get-injection-providers.helper"), exports);

package/module/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./configurable-module.builder";
+export * from "../interfaces/modules/configurable";