Add isBound and isBoundCurrent methods to container

packages/bindbox/src/__tests__/container.test.ts

@@ -272,4 +272,67 @@ describe('Container', () => {
       container.get(A);
     }).toThrow();
   });
+
+  describe('isBoundCurrent', () => {
+    it('should be bound to current container', () => {
+      class Foo {}
+
+      const container = new Container();
+
+      container.bind(Foo).toSelf();
+
+      expect(container.isBoundCurrent(Foo)).toBe(true);
+    });
+
+    it('should not be bound to parent container', () => {
+      class Foo {}
+
+      const container = new Container();
+      const childContainer = container.createContainer();
+
+      container.bind(Foo).toSelf();
+
+      expect(container.isBoundCurrent(Foo)).toBe(true);
+      expect(childContainer.isBoundCurrent(Foo)).toBe(false);
+    });
+
+    it('should not be bound in container', () => {
+      class Foo {}
+
+      const container = new Container();
+
+      expect(container.isBoundCurrent(Foo)).toBe(false);
+    });
+  });
+
+  describe('isBound', () => {
+    it('should be bound to current container', () => {
+      class Foo {}
+
+      const container = new Container();
+
+      container.bind(Foo).toSelf();
+
+      expect(container.isBound(Foo)).toBe(true);
+    });
+
+    it('should be bound to parent container', () => {
+      class Foo {}
+
+      const container = new Container();
+      const childContainer = container.createContainer();
+
+      container.bind(Foo).toSelf();
+
+      expect(childContainer.isBound(Foo)).toBe(true);
+    });
+
+    it('should not be bound in container', () => {
+      class Foo {}
+
+      const container = new Container();
+
+      expect(container.isBound(Foo)).toBe(false);
+    });
+  });
 });

packages/bindbox/src/container.ts

@@ -63,6 +63,22 @@ export class Container implements ContainerContract {
     return this.bind(type);
   }
 
+  isBound<T>(type: Type<T>): boolean {
+    if (this.isBoundCurrent(type)) {
+      return true;
+    }
+
+    if (this.#parent) {
+      return this.#parent.isBound(type);
+    }
+
+    return false;
+  }
+
+  isBoundCurrent<T>(type: Type<T>): boolean {
+    return this.#bindings.has(type);
+  }
+
   resolve<T>(request: ResolutionRequestContract<T>): T | T[] {
     if (request.target.isArray()) {
       return this.#resolveCollection(request);