@spinajs/di 2.0.180 → 2.0.182

package/lib/mjs/root.d.ts

@@ -1,109 +1,109 @@
-import { IBind, IContainer, AsyncService, ResolvableObject } from './interfaces.js';
-import { Class, Factory } from './types.js';
-import { TypedArray } from './array.js';
-/**
- * App main DI container
- */
-export declare const RootContainer: IContainer;
-/***
- * EVENT LISTENER STUFF
- *
- * Allows to use event listener stuff on root container
- */
-export declare function setESMModuleSupport(): void;
-export declare function on(event: string, listener: (...args: unknown[]) => void): IContainer;
-export declare function addListener(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
-export declare function once(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
-export declare function removeListener(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
-export declare function off(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
-export declare function removeAllListeners(event?: string | symbol): IContainer;
-export declare function setMaxListeners(n: number): IContainer;
-export declare function getMaxListeners(): number;
-export declare function listeners(event: string | symbol): Function[];
-export declare function rawListeners(event: string | symbol): Function[];
-export declare function emit(event: string | symbol, ...args: unknown[]): boolean;
-export declare function listenerCount(type: string | symbol): number;
-export declare function prependListener(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
-export declare function prependOnceListener(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
-export declare function eventNames(): (string | symbol)[];
-/**
- * ===========================================================================
- */
-/**
- * Clears root container registry and cache.
- */
-export declare function clear(): void;
-/**
- * Clears out root registry ( registered types in root container )
- */
-export declare function clearRegistry(): void;
-/**
- * Cleart ous root cache ( all resolved types )
- */
-export declare function clearCache(): void;
-export declare function dispose(): Promise<void>;
-/**
- * Register class/interface to DI root container. If
- * @param type - interface object to register
- * @throws {@link InvalidArgument} if type is null or undefined
- */
-export declare function register<T>(type: Class<T> | Factory<T> | ResolvableObject): IBind;
-export declare function unregister<T>(type: string | Class<T> | Factory<T> | ResolvableObject): void;
-export declare function uncache<T>(type: string | Class<T> | TypedArray<T>, parent?: boolean): void;
-/**
- * Resolves specified type from root container.
- *
- * @param type - class to resolve
- * @param options - optional parameters passed to class constructor
- * @param check - use parent container to check when resolving
- * @throws {@link InvalidArgument} if type is null or undefined
- */
-export declare function resolve<T>(type: string, options?: unknown[], check?: boolean): T;
-export declare function resolve<T>(type: string, check?: boolean): T;
-export declare function resolve<T>(type: Class<T>, check?: boolean): T extends AsyncService ? Promise<T> : T;
-export declare function resolve<T>(type: TypedArray<T>, check?: boolean): T extends AsyncService ? Promise<T[]> : T[];
-export declare function resolve<T>(type: Class<T>, options?: unknown[] | boolean, check?: boolean): T extends AsyncService ? Promise<T> : T;
-export declare function resolve<T>(type: TypedArray<T>, options?: unknown[] | boolean, check?: boolean): T extends AsyncService ? Promise<T[]> : T[];
-/**
- * Gets already resolved service from root container.
- *
- * @param serviceName - name of service to get
- */
-export declare function get<T>(serviceName: TypedArray<T>): T[] | null;
-export declare function get<T>(serviceName: string | Class<T>): T | null;
-/**
- *
- * Returns list of types registered at given type, eg. all types/services registered under BaseService
- *
- * @param type - base type to check
- */
-export declare function getRegisteredTypes<T>(type: string | Class<T>): Class<T>[];
-/**
- * Checks if service is already resolved and exists in container cache.
- * NOTE: check is only valid for classes that are singletons.
- *
- * @param service - service name or class to check
- */
-export declare function has<T>(service: string | Class<T>): boolean;
-/**
- * Checks if service is registered in container.
- *
- * @param service - service class object to check
- */
-export declare function check<T>(service: Class<T> | string): boolean;
-/**
- * Checks if specific service is registered in container.
- * Eg. we can have multiple drivers registered for queue connections with different protocol implementations
- * and we want to check if specific driver is registered
- *
- * @param source - source class to check ( eg. base class )
- * @param type - specific type to check eg. base class implementation
- */
-export declare function checkType<T>(source: Class<any> | string | TypedArray<any>, type: Class<T> | string | TypedArray<T> | object): boolean;
-/**
- * Creates child DI container.
- *
- */
-export declare function child(): IContainer;
-export declare function __spinajs_require__(module: string): Promise<unknown>;
+import { IBind, IContainer, AsyncService, ResolvableObject } from './interfaces.js';
+import { Class, Factory } from './types.js';
+import { TypedArray } from './array.js';
+/**
+ * App main DI container
+ */
+export declare const RootContainer: IContainer;
+/***
+ * EVENT LISTENER STUFF
+ *
+ * Allows to use event listener stuff on root container
+ */
+export declare function setESMModuleSupport(): void;
+export declare function on(event: string, listener: (...args: unknown[]) => void): IContainer;
+export declare function addListener(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
+export declare function once(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
+export declare function removeListener(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
+export declare function off(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
+export declare function removeAllListeners(event?: string | symbol): IContainer;
+export declare function setMaxListeners(n: number): IContainer;
+export declare function getMaxListeners(): number;
+export declare function listeners(event: string | symbol): Function[];
+export declare function rawListeners(event: string | symbol): Function[];
+export declare function emit(event: string | symbol, ...args: unknown[]): boolean;
+export declare function listenerCount(type: string | symbol): number;
+export declare function prependListener(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
+export declare function prependOnceListener(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
+export declare function eventNames(): (string | symbol)[];
+/**
+ * ===========================================================================
+ */
+/**
+ * Clears root container registry and cache.
+ */
+export declare function clear(): void;
+/**
+ * Clears out root registry ( registered types in root container )
+ */
+export declare function clearRegistry(): void;
+/**
+ * Cleart ous root cache ( all resolved types )
+ */
+export declare function clearCache(): void;
+export declare function dispose(): Promise<void>;
+/**
+ * Register class/interface to DI root container. If
+ * @param type - interface object to register
+ * @throws {@link InvalidArgument} if type is null or undefined
+ */
+export declare function register<T>(type: Class<T> | Factory<T> | ResolvableObject): IBind;
+export declare function unregister<T>(type: string | Class<T> | Factory<T> | ResolvableObject): void;
+export declare function uncache<T>(type: string | Class<T> | TypedArray<T>, parent?: boolean): void;
+/**
+ * Resolves specified type from root container.
+ *
+ * @param type - class to resolve
+ * @param options - optional parameters passed to class constructor
+ * @param check - use parent container to check when resolving
+ * @throws {@link InvalidArgument} if type is null or undefined
+ */
+export declare function resolve<T>(type: string, options?: unknown[], check?: boolean): T;
+export declare function resolve<T>(type: string, check?: boolean): T;
+export declare function resolve<T>(type: Class<T>, check?: boolean): T extends AsyncService ? Promise<T> : T;
+export declare function resolve<T>(type: TypedArray<T>, check?: boolean): T extends AsyncService ? Promise<T[]> : T[];
+export declare function resolve<T>(type: Class<T>, options?: unknown[] | boolean, check?: boolean): T extends AsyncService ? Promise<T> : T;
+export declare function resolve<T>(type: TypedArray<T>, options?: unknown[] | boolean, check?: boolean): T extends AsyncService ? Promise<T[]> : T[];
+/**
+ * Gets already resolved service from root container.
+ *
+ * @param serviceName - name of service to get
+ */
+export declare function get<T>(serviceName: TypedArray<T>): T[] | null;
+export declare function get<T>(serviceName: string | Class<T>): T | null;
+/**
+ *
+ * Returns list of types registered at given type, eg. all types/services registered under BaseService
+ *
+ * @param type - base type to check
+ */
+export declare function getRegisteredTypes<T>(type: string | Class<T>): Class<T>[];
+/**
+ * Checks if service is already resolved and exists in container cache.
+ * NOTE: check is only valid for classes that are singletons.
+ *
+ * @param service - service name or class to check
+ */
+export declare function has<T>(service: string | Class<T>): boolean;
+/**
+ * Checks if service is registered in container.
+ *
+ * @param service - service class object to check
+ */
+export declare function check<T>(service: Class<T> | string): boolean;
+/**
+ * Checks if specific service is registered in container.
+ * Eg. we can have multiple drivers registered for queue connections with different protocol implementations
+ * and we want to check if specific driver is registered
+ *
+ * @param source - source class to check ( eg. base class )
+ * @param type - specific type to check eg. base class implementation
+ */
+export declare function checkType<T>(source: Class<any> | string | TypedArray<any>, type: Class<T> | string | TypedArray<T> | object): boolean;
+/**
+ * Creates child DI container.
+ *
+ */
+export declare function child(): IContainer;
+export declare function __spinajs_require__(module: string): Promise<unknown>;
 //# sourceMappingURL=root.d.ts.map

package/lib/mjs/root.js

@@ -1,160 +1,160 @@
-import { Container } from './container.js';
-/**
- * App main DI container
- */
-export const RootContainer = new Container();
-/***
- * EVENT LISTENER STUFF
- *
- * Allows to use event listener stuff on root container
- */
-export function setESMModuleSupport() {
-    RootContainer.register({
-        mjs: true,
-    }).asValue('__esmMode__');
-}
-export function on(event, listener) {
-    return RootContainer.on(event, listener);
-}
-export function addListener(event, listener) {
-    return RootContainer.addListener(event, listener);
-}
-export function once(event, listener) {
-    return RootContainer.once(event, listener);
-}
-export function removeListener(event, listener) {
-    return RootContainer.removeListener(event, listener);
-}
-export function off(event, listener) {
-    return RootContainer.off(event, listener);
-}
-export function removeAllListeners(event) {
-    return RootContainer.removeAllListeners(event);
-}
-export function setMaxListeners(n) {
-    return RootContainer.setMaxListeners(n);
-}
-export function getMaxListeners() {
-    return RootContainer.getMaxListeners();
-}
-export function listeners(event) {
-    return RootContainer.listeners(event);
-}
-export function rawListeners(event) {
-    return RootContainer.rawListeners(event);
-}
-export function emit(event, ...args) {
-    return RootContainer.emit(event, ...args);
-}
-export function listenerCount(type) {
-    return RootContainer.listenerCount(type);
-}
-export function prependListener(event, listener) {
-    return RootContainer.prependListener(event, listener);
-}
-export function prependOnceListener(event, listener) {
-    return RootContainer.prependOnceListener(event, listener);
-}
-export function eventNames() {
-    return RootContainer.eventNames();
-}
-/**
- * ===========================================================================
- */
-/**
- * Clears root container registry and cache.
- */
-export function clear() {
-    RootContainer.clearCache();
-    RootContainer.clearRegistry();
-}
-/**
- * Clears out root registry ( registered types in root container )
- */
-export function clearRegistry() {
-    RootContainer.clearRegistry();
-}
-/**
- * Cleart ous root cache ( all resolved types )
- */
-export function clearCache() {
-    RootContainer.clearCache();
-}
-export async function dispose() {
-    await RootContainer.dispose();
-}
-/**
- * Register class/interface to DI root container. If
- * @param type - interface object to register
- * @throws {@link InvalidArgument} if type is null or undefined
- */
-export function register(type) {
-    return RootContainer.register(type);
-}
-export function unregister(type) {
-    RootContainer.unregister(type);
-}
-export function uncache(type, parent) {
-    RootContainer.uncache(type, parent);
-}
-export function resolve(type, options, check) {
-    return RootContainer.resolve(type, options, check);
-}
-export function get(serviceName) {
-    return RootContainer.get(serviceName);
-}
-/**
- *
- * Returns list of types registered at given type, eg. all types/services registered under BaseService
- *
- * @param type - base type to check
- */
-export function getRegisteredTypes(type) {
-    return RootContainer.getRegisteredTypes(type);
-}
-/**
- * Checks if service is already resolved and exists in container cache.
- * NOTE: check is only valid for classes that are singletons.
- *
- * @param service - service name or class to check
- */
-export function has(service) {
-    return RootContainer.isResolved(service);
-}
-/**
- * Checks if service is registered in container.
- *
- * @param service - service class object to check
- */
-export function check(service) {
-    return RootContainer.hasRegistered(service);
-}
-/**
- * Checks if specific service is registered in container.
- * Eg. we can have multiple drivers registered for queue connections with different protocol implementations
- * and we want to check if specific driver is registered
- *
- * @param source - source class to check ( eg. base class )
- * @param type - specific type to check eg. base class implementation
- */
-export function checkType(source, type) {
-    return RootContainer.hasRegisteredType(source, type);
-}
-/**
- * Creates child DI container.
- *
- */
-export function child() {
-    return RootContainer.child();
-}
-export async function __spinajs_require__(module) {
-    const isESM = RootContainer.get('__esmMode__');
-    if (isESM && isESM.mjs) {
-        const result = await import(`file://${module}`);
-        return result.default ?? result;
-    }
-    else {
-        return Promise.resolve(require(module));
-    }
-}
+import { Container } from './container.js';
+/**
+ * App main DI container
+ */
+export const RootContainer = new Container();
+/***
+ * EVENT LISTENER STUFF
+ *
+ * Allows to use event listener stuff on root container
+ */
+export function setESMModuleSupport() {
+    RootContainer.register({
+        mjs: true,
+    }).asValue('__esmMode__');
+}
+export function on(event, listener) {
+    return RootContainer.on(event, listener);
+}
+export function addListener(event, listener) {
+    return RootContainer.addListener(event, listener);
+}
+export function once(event, listener) {
+    return RootContainer.once(event, listener);
+}
+export function removeListener(event, listener) {
+    return RootContainer.removeListener(event, listener);
+}
+export function off(event, listener) {
+    return RootContainer.off(event, listener);
+}
+export function removeAllListeners(event) {
+    return RootContainer.removeAllListeners(event);
+}
+export function setMaxListeners(n) {
+    return RootContainer.setMaxListeners(n);
+}
+export function getMaxListeners() {
+    return RootContainer.getMaxListeners();
+}
+export function listeners(event) {
+    return RootContainer.listeners(event);
+}
+export function rawListeners(event) {
+    return RootContainer.rawListeners(event);
+}
+export function emit(event, ...args) {
+    return RootContainer.emit(event, ...args);
+}
+export function listenerCount(type) {
+    return RootContainer.listenerCount(type);
+}
+export function prependListener(event, listener) {
+    return RootContainer.prependListener(event, listener);
+}
+export function prependOnceListener(event, listener) {
+    return RootContainer.prependOnceListener(event, listener);
+}
+export function eventNames() {
+    return RootContainer.eventNames();
+}
+/**
+ * ===========================================================================
+ */
+/**
+ * Clears root container registry and cache.
+ */
+export function clear() {
+    RootContainer.clearCache();
+    RootContainer.clearRegistry();
+}
+/**
+ * Clears out root registry ( registered types in root container )
+ */
+export function clearRegistry() {
+    RootContainer.clearRegistry();
+}
+/**
+ * Cleart ous root cache ( all resolved types )
+ */
+export function clearCache() {
+    RootContainer.clearCache();
+}
+export async function dispose() {
+    await RootContainer.dispose();
+}
+/**
+ * Register class/interface to DI root container. If
+ * @param type - interface object to register
+ * @throws {@link InvalidArgument} if type is null or undefined
+ */
+export function register(type) {
+    return RootContainer.register(type);
+}
+export function unregister(type) {
+    RootContainer.unregister(type);
+}
+export function uncache(type, parent) {
+    RootContainer.uncache(type, parent);
+}
+export function resolve(type, options, check) {
+    return RootContainer.resolve(type, options, check);
+}
+export function get(serviceName) {
+    return RootContainer.get(serviceName);
+}
+/**
+ *
+ * Returns list of types registered at given type, eg. all types/services registered under BaseService
+ *
+ * @param type - base type to check
+ */
+export function getRegisteredTypes(type) {
+    return RootContainer.getRegisteredTypes(type);
+}
+/**
+ * Checks if service is already resolved and exists in container cache.
+ * NOTE: check is only valid for classes that are singletons.
+ *
+ * @param service - service name or class to check
+ */
+export function has(service) {
+    return RootContainer.isResolved(service);
+}
+/**
+ * Checks if service is registered in container.
+ *
+ * @param service - service class object to check
+ */
+export function check(service) {
+    return RootContainer.hasRegistered(service);
+}
+/**
+ * Checks if specific service is registered in container.
+ * Eg. we can have multiple drivers registered for queue connections with different protocol implementations
+ * and we want to check if specific driver is registered
+ *
+ * @param source - source class to check ( eg. base class )
+ * @param type - specific type to check eg. base class implementation
+ */
+export function checkType(source, type) {
+    return RootContainer.hasRegisteredType(source, type);
+}
+/**
+ * Creates child DI container.
+ *
+ */
+export function child() {
+    return RootContainer.child();
+}
+export async function __spinajs_require__(module) {
+    const isESM = RootContainer.get('__esmMode__');
+    if (isESM && isESM.mjs) {
+        const result = await import(`file://${module}`);
+        return result.default ?? result;
+    }
+    else {
+        return Promise.resolve(require(module));
+    }
+}
 //# sourceMappingURL=root.js.map

package/lib/mjs/types.d.ts

@@ -1,14 +1,14 @@
-import { IContainer } from './interfaces.js';
-export type Abstract<T> = Function & {
-    prototype: T;
-};
-export type Constructor<T> = new (...args: any[]) => T;
-export type Class<T> = Abstract<T> | Constructor<T>;
-/**
- * Factory functions should not be normal functions,
- * but arrow functions. Its is by js limitation
- * to detect if object is constructable
- */
-export type Factory<T> = (container: IContainer, ...args: any[]) => T;
-export type ClassArray<T> = Class<T>[];
+import { IContainer } from './interfaces.js';
+export type Abstract<T> = Function & {
+    prototype: T;
+};
+export type Constructor<T> = new (...args: any[]) => T;
+export type Class<T> = Abstract<T> | Constructor<T>;
+/**
+ * Factory functions should not be normal functions,
+ * but arrow functions. Its is by js limitation
+ * to detect if object is constructable
+ */
+export type Factory<T> = (container: IContainer, ...args: any[]) => T;
+export type ClassArray<T> = Class<T>[];
 //# sourceMappingURL=types.d.ts.map

package/lib/mjs/types.js

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