ts-ioc-container 32.19.2 → 33.0.0

package/README.md

@@ -151,6 +151,7 @@ import {
   by,
   scope,
   register,
+  Tag,
 } from 'ts-ioc-container';
 
 @register(key('ILogger'), scope((s) => s.hasTag('child')))
@@ -178,6 +179,23 @@ describe('Scopes', function () {
     expect(app.scope).not.toBe(root);
     expect(app.scope.hasTag('child')).toBe(true);
   });
+
+  it('should get path by reduceToRoot', () => {
+    const root = new Container(new MetadataInjector(), { tags: ['root'] });
+    const child = root.createScope('child');
+    const grandChild = child.createScope('grandChild');
+    const collectTags = (acc: Array<Tag[]>, c: IContainer) => [...acc, Array.from(c.tags)];
+
+    const tagsPath = grandChild.reduceToRoot(collectTags, []);
+    expect(tagsPath).toEqual([['root'], ['child'], ['grandChild']]);
+    const actual = root.findChild((s) => {
+      const current = tagsPath.shift() ?? [];
+      const a = current.every((t) => s.hasTag(t));
+      const b = tagsPath.length === 0;
+      return a && b;
+    });
+    expect(actual).toBe(grandChild);
+  });
 });
 
 ```

package/cjm/container/AutoMockedContainer.js

@@ -10,10 +10,10 @@ class AutoMockedContainer {
         this.level = 0;
         this.isDisposed = false;
     }
-    getPath() {
-        return [];
+    findChild(matchFn) {
+        return undefined;
     }
-    findScopeByPath(path, matchTags) {
+    findParent(matchFn) {
         return undefined;
     }
     hasDependency(key) {
@@ -29,6 +29,9 @@ class AutoMockedContainer {
     getInstances() {
         return [];
     }
+    reduceToRoot(fn, initial) {
+        return initial;
+    }
     removeScope() { }
     use() {
         return this;

package/cjm/container/Container.js

@@ -61,18 +61,14 @@ class Container {
         this.registrations.splice(0, this.registrations.length);
     }
     getInstances(direction = 'child') {
-        switch (direction) {
-            case 'parent': {
-                return [...this.instances.values(), ...this.parent.getInstances('parent')];
-            }
-            case 'child': {
-                const instances = [...this.instances.values()];
-                for (const scope of this.scopes) {
-                    instances.push(...scope.getInstances('child'));
-                }
-                return instances;
-            }
+        if (direction === 'parent') {
+            return this.parent.getInstances('parent').concat([...this.instances.values()]);
+        }
+        const instances = [...this.instances.values()];
+        for (const scope of this.scopes) {
+            instances.push(...scope.getInstances('child'));
         }
+        return instances;
     }
     hasTag(tag) {
         return this.tags.has(tag);
@@ -100,25 +96,24 @@ class Container {
         }
         return this.parent.resolveOneByAlias(predicate, { args, child, lazy });
     }
-    getPath() {
-        return [...this.parent.getPath(), Array.from(this.tags)];
+    reduceToRoot(fn, initial) {
+        return fn(this.parent.reduceToRoot(fn, initial), this);
     }
-    findScopeByPath(tags, matchTags) {
-        const [currentTags, ...rest] = tags;
-        if (!matchTags(this, currentTags)) {
-            return undefined;
+    findChild(matchFn) {
+        if (matchFn(this)) {
+            return this;
         }
         for (const scope of this.scopes) {
-            const found = scope.findScopeByPath(rest, matchTags);
-            if (found) {
-                return found;
+            const child = scope.findChild(matchFn);
+            if (child) {
+                return child;
             }
         }
-        if (rest.length === 0) {
-            return this;
-        }
         return undefined;
     }
+    findParent(matchFn) {
+        return matchFn(this) ? this : this.parent.findParent(matchFn);
+    }
     /**
      * @private
      */

package/cjm/container/EmptyContainer.js

@@ -16,10 +16,13 @@ class EmptyContainer {
     hasOwnInstance(value) {
         throw new Error('Method not implemented.');
     }
-    getPath() {
-        return [];
+    reduceToRoot(fn, initial) {
+        return initial;
+    }
+    findChild(matchFn) {
+        return undefined;
     }
-    findScopeByPath(path, matchTags) {
+    findParent(matchFn) {
         return undefined;
     }
     hasDependency(key) {

package/esm/container/AutoMockedContainer.js

@@ -7,10 +7,10 @@ export class AutoMockedContainer {
         this.level = 0;
         this.isDisposed = false;
     }
-    getPath() {
-        return [];
+    findChild(matchFn) {
+        return undefined;
     }
-    findScopeByPath(path, matchTags) {
+    findParent(matchFn) {
         return undefined;
     }
     hasDependency(key) {
@@ -26,6 +26,9 @@ export class AutoMockedContainer {
     getInstances() {
         return [];
     }
+    reduceToRoot(fn, initial) {
+        return initial;
+    }
     removeScope() { }
     use() {
         return this;

package/esm/container/Container.js

@@ -58,18 +58,14 @@ export class Container {
         this.registrations.splice(0, this.registrations.length);
     }
     getInstances(direction = 'child') {
-        switch (direction) {
-            case 'parent': {
-                return [...this.instances.values(), ...this.parent.getInstances('parent')];
-            }
-            case 'child': {
-                const instances = [...this.instances.values()];
-                for (const scope of this.scopes) {
-                    instances.push(...scope.getInstances('child'));
-                }
-                return instances;
-            }
+        if (direction === 'parent') {
+            return this.parent.getInstances('parent').concat([...this.instances.values()]);
+        }
+        const instances = [...this.instances.values()];
+        for (const scope of this.scopes) {
+            instances.push(...scope.getInstances('child'));
         }
+        return instances;
     }
     hasTag(tag) {
         return this.tags.has(tag);
@@ -97,25 +93,24 @@ export class Container {
         }
         return this.parent.resolveOneByAlias(predicate, { args, child, lazy });
     }
-    getPath() {
-        return [...this.parent.getPath(), Array.from(this.tags)];
+    reduceToRoot(fn, initial) {
+        return fn(this.parent.reduceToRoot(fn, initial), this);
     }
-    findScopeByPath(tags, matchTags) {
-        const [currentTags, ...rest] = tags;
-        if (!matchTags(this, currentTags)) {
-            return undefined;
+    findChild(matchFn) {
+        if (matchFn(this)) {
+            return this;
         }
         for (const scope of this.scopes) {
-            const found = scope.findScopeByPath(rest, matchTags);
-            if (found) {
-                return found;
+            const child = scope.findChild(matchFn);
+            if (child) {
+                return child;
             }
         }
-        if (rest.length === 0) {
-            return this;
-        }
         return undefined;
     }
+    findParent(matchFn) {
+        return matchFn(this) ? this : this.parent.findParent(matchFn);
+    }
     /**
      * @private
      */

package/esm/container/EmptyContainer.js

@@ -13,10 +13,13 @@ export class EmptyContainer {
     hasOwnInstance(value) {
         throw new Error('Method not implemented.');
     }
-    getPath() {
-        return [];
+    reduceToRoot(fn, initial) {
+        return initial;
+    }
+    findChild(matchFn) {
+        return undefined;
     }
-    findScopeByPath(path, matchTags) {
+    findParent(matchFn) {
         return undefined;
     }
     hasDependency(key) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "32.19.2",
+  "version": "33.0.0",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -59,5 +59,5 @@
     "ts-node": "^10.9.1",
     "typescript": "5.4.3"
   },
-  "gitHead": "6079839647755cc6b4797f3abff6932de4a23d92"
+  "gitHead": "9fa774ef445611ecf1b7c08c450c3d251e2e2171"
 }

package/typings/container/AutoMockedContainer.d.ts

@@ -1,18 +1,19 @@
-import { AliasPredicate, DependencyKey, IContainer, InjectionToken, MatchTags, ResolveOptions, TagPath } from './IContainer';
+import { AliasPredicate, DependencyKey, IContainer, InjectionToken, ReduceFn, ResolveOptions } from './IContainer';
 import { IRegistration } from '../registration/IRegistration';
 export declare abstract class AutoMockedContainer implements IContainer {
     tags: Set<string>;
     id: string;
     level: number;
     isDisposed: boolean;
-    getPath(): TagPath;
-    findScopeByPath(path: TagPath, matchTags: MatchTags): IContainer | undefined;
+    findChild(matchFn: (s: IContainer) => boolean): IContainer | undefined;
+    findParent(matchFn: (s: IContainer) => boolean): IContainer | undefined;
     hasDependency(key: string): boolean;
     createScope(): IContainer;
     abstract resolve<T>(key: InjectionToken<T>, options?: ResolveOptions): T;
     dispose(): void;
     register(): this;
     getInstances(): object[];
+    reduceToRoot<TResult>(fn: ReduceFn<TResult>, initial: TResult): TResult;
     removeScope(): void;
     use(): this;
     getRegistrations(): never[];

package/typings/container/Container.d.ts

@@ -1,4 +1,4 @@
-import { AliasPredicate, DependencyKey, IContainer, IContainerModule, InjectionToken, MatchTags, ResolveOptions, Tag, TagPath } from './IContainer';
+import { AliasPredicate, DependencyKey, IContainer, IContainerModule, InjectionToken, ReduceFn, ResolveOptions, Tag } from './IContainer';
 import { IInjector } from '../injector/IInjector';
 import { IProvider } from '../provider/IProvider';
 import { IRegistration } from '../registration/IRegistration';
@@ -31,8 +31,9 @@ export declare class Container implements IContainer {
     hasDependency(key: DependencyKey): boolean;
     resolveManyByAlias(predicate: AliasPredicate, { args, child, lazy }?: ResolveOptions, result?: Map<DependencyKey, unknown>): Map<DependencyKey, unknown>;
     resolveOneByAlias<T>(predicate: AliasPredicate, { args, child, lazy }?: ResolveOptions): [DependencyKey, T];
-    getPath(): TagPath;
-    findScopeByPath(tags: TagPath, matchTags: MatchTags): IContainer | undefined;
+    reduceToRoot<TResult>(fn: ReduceFn<TResult>, initial: TResult): TResult;
+    findChild(matchFn: (s: IContainer) => boolean): IContainer | undefined;
+    findParent(matchFn: (s: IContainer) => boolean): IContainer | undefined;
     /**
      * @private
      */

package/typings/container/EmptyContainer.d.ts

@@ -1,4 +1,4 @@
-import { AliasPredicate, DependencyKey, IContainer, IContainerModule, InjectionToken, MatchTags, ResolveOptions, TagPath } from './IContainer';
+import { AliasPredicate, DependencyKey, IContainer, IContainerModule, InjectionToken, ReduceFn, ResolveOptions } from './IContainer';
 import { IProvider } from '../provider/IProvider';
 import { IRegistration } from '../registration/IRegistration';
 export declare class EmptyContainer implements IContainer {
@@ -8,8 +8,9 @@ export declare class EmptyContainer implements IContainer {
     level: number;
     id: string;
     tags: Set<string>;
-    getPath(): TagPath;
-    findScopeByPath(path: TagPath, matchTags: MatchTags): IContainer | undefined;
+    reduceToRoot<TResult>(fn: ReduceFn<TResult>, initial: TResult): TResult;
+    findChild(matchFn: (s: IContainer) => boolean): IContainer | undefined;
+    findParent(matchFn: (s: IContainer) => boolean): IContainer | undefined;
     hasDependency(key: string): boolean;
     hasTag(): boolean;
     createScope(): IContainer;

package/typings/container/IContainer.d.ts

@@ -22,10 +22,9 @@ export interface Tagged {
     readonly level: number;
     hasTag(tag: Tag): boolean;
 }
-export type TagPath = Array<Tag[]>;
-export type MatchTags = (scope: IContainer, tags: Tag[]) => boolean;
 export type Alias = string;
 export type AliasPredicate = (aliases: Set<Alias>) => boolean;
+export type ReduceFn<TResult> = (acc: TResult, container: IContainer) => TResult;
 export interface IContainer extends Resolvable, Tagged {
     readonly isDisposed: boolean;
     tags: Set<Tag>;
@@ -38,8 +37,9 @@ export interface IContainer extends Resolvable, Tagged {
     use(module: IContainerModule): this;
     getRegistrations(): IRegistration[];
     hasDependency(key: DependencyKey): boolean;
-    getPath(): TagPath;
-    findScopeByPath(path: TagPath, matchTags: MatchTags): IContainer | undefined;
+    reduceToRoot<TResult>(fn: ReduceFn<TResult>, initial: TResult): TResult;
+    findChild(matchFn: (s: IContainer) => boolean): IContainer | undefined;
+    findParent(matchFn: (s: IContainer) => boolean): IContainer | undefined;
     resolveManyByAlias(predicate: AliasPredicate, options?: ResolveOptions, result?: Map<DependencyKey, unknown>): Map<DependencyKey, unknown>;
     resolveOneByAlias<T>(predicate: AliasPredicate, options?: ResolveOptions): [DependencyKey, T];
     hasInstance(value: object): boolean;

package/typings/index.d.ts

@@ -1,4 +1,4 @@
-export { IContainer, Resolvable, IContainerModule, isDependencyKey, DependencyKey, InjectionToken, Tag, Tagged, TagPath, } from './container/IContainer';
+export { IContainer, Resolvable, IContainerModule, isDependencyKey, DependencyKey, InjectionToken, Tag, Tagged, } from './container/IContainer';
 export { Container } from './container/Container';
 export { EmptyContainer } from './container/EmptyContainer';
 export { AutoMockedContainer } from './container/AutoMockedContainer';

package/typings/provider/IProvider.d.ts

@@ -12,7 +12,7 @@ export type ChildrenVisibilityPredicate = (options: {
 export type ArgsFn = (l: IContainer, ...args: unknown[]) => unknown[];
 export declare function args<T = unknown>(...extraArgs: unknown[]): MapFn<IProvider<T>>;
 export declare function argsFn<T = unknown>(fn: ArgsFn): MapFn<IProvider<T>>;
-export interface IProvider<T = unknown> {
+export interface IProvider<T = any> {
     key?: DependencyKey;
     resolve(container: IContainer, options: ProviderResolveOptions): T;
     isVisible(parent: Tagged, child: Tagged): boolean;

package/typings/provider/Provider.d.ts

@@ -1,7 +1,7 @@
 import { ArgsFn, ChildrenVisibilityPredicate, IProvider, ProviderResolveOptions, ResolveDependency } from './IProvider';
 import { Alias, AliasPredicate, DependencyKey, IContainer, Tagged } from '../container/IContainer';
 import { constructor, MapFn } from '../utils';
-export declare class Provider<T> implements IProvider<T> {
+export declare class Provider<T = any> implements IProvider<T> {
     private readonly resolveDependency;
     static fromClass<T>(Target: constructor<T>): IProvider<T>;
     static fromValue<T>(value: T): IProvider<T>;

package/typings/registration/IRegistration.d.ts

@@ -2,7 +2,7 @@ import { DependencyKey, IContainer, IContainerModule } from '../container/IConta
 import { constructor, MapFn } from '../utils';
 import { IProvider } from '../provider/IProvider';
 export type ScopePredicate = (s: IContainer) => boolean;
-export interface IRegistration<T = unknown> extends IContainerModule {
+export interface IRegistration<T = any> extends IContainerModule {
     when(isValidWhen: ScopePredicate): this;
     to(key: DependencyKey): this;
     pipe(...mappers: MapFn<IProvider<T>>[]): this;
@@ -10,5 +10,5 @@ export interface IRegistration<T = unknown> extends IContainerModule {
 export type ReturnTypeOfRegistration<T> = T extends IRegistration<infer R> ? R : never;
 export declare const key: (key: DependencyKey) => MapFn<IRegistration>;
 export declare const scope: (predicate: ScopePredicate) => MapFn<IRegistration>;
-export declare const getTransformers: (Target: constructor<unknown>) => MapFn<IRegistration<unknown>>[];
+export declare const getTransformers: (Target: constructor<unknown>) => MapFn<IRegistration<any>>[];
 export declare const register: (...mappers: MapFn<IRegistration>[]) => ClassDecorator;

package/typings/registration/Registration.d.ts

@@ -2,12 +2,12 @@ import { DependencyKey, IContainer } from '../container/IContainer';
 import { constructor, MapFn } from '../utils';
 import { IProvider, ResolveDependency } from '../provider/IProvider';
 import { IRegistration, ScopePredicate } from './IRegistration';
-export declare class Registration<T = unknown> implements IRegistration<T> {
+export declare class Registration<T = any> implements IRegistration<T> {
     private createProvider;
     private key?;
     private matchScope;
-    static fromClass<T>(Target: constructor<T>): IRegistration<unknown>;
-    static fromValue<T>(value: T): IRegistration<unknown>;
+    static fromClass<T>(Target: constructor<T>): IRegistration<any>;
+    static fromValue<T>(value: T): IRegistration<any>;
     static fromFn<T>(fn: ResolveDependency<T>): Registration<T>;
     private mappers;
     constructor(createProvider: (key: DependencyKey) => IProvider<T>, key?: DependencyKey | undefined, matchScope?: ScopePredicate);