@venok/core 1.1.0 → 2.0.1-next.1

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

@@ -1,142 +0,0 @@
-import { Scope, Type } from "@venok/core/interfaces";
-import { InjectionToken, OptionalFactoryDependency } from "@venok/core/interfaces/modules";
-/**
- *
- * @publicApi
- */
-export type Provider<T = any> = Type | 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

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

package/interfaces/scope.interface.d.ts

@@ -1,35 +0,0 @@
-/**
- * @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

@@ -1,23 +0,0 @@
-"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

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

package/interfaces/type.interface.js

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

package/metadata-scanner.d.ts

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

package/metadata-scanner.js

@@ -1,34 +0,0 @@
-"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

@@ -1,93 +0,0 @@
-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

@@ -1,204 +0,0 @@
-"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

@@ -1,4 +0,0 @@
-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

@@ -1,7 +0,0 @@
-"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

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

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

@@ -1,9 +0,0 @@
-"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

@@ -1,8 +0,0 @@
-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

@@ -1,36 +0,0 @@
-"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

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

package/module/helpers/index.js

@@ -1,18 +0,0 @@
-"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

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