plain-ioc 1.0.0 → 1.1.0

package/README.md

@@ -1,4 +1,4 @@
-[![npm version](https://badge.fury.io/js/plain-ioc.svg?flush_cache=v1_0_0)](https://badge.fury.io/js/plain-ioc)
+[![npm version](https://badge.fury.io/js/plain-ioc.svg)](https://badge.fury.io/js/plain-ioc)
 
 # plain-ioc
 
@@ -186,7 +186,7 @@ import { Container } from "plain-ioc";
 const c = new Container({ circularDependencyDetect: true });
 ```
 
-When enabled, `resolve()` tracks a stack of keys being resolved. If the same key appears twice in the stack, a `CircularDependencyError` is thrown with a message that includes the dependency stack.
+When enabled, `resolve()` tracks a stack of keys being resolved. If the same key appears twice in the stack, a `PlainIocCircularDependencyError` is thrown with a message that includes the dependency stack.
 
 > Recommendation: Keep this enabled in development/test, and turn it off in production for minimal overhead.
 
@@ -204,26 +204,26 @@ Creates a container.
 
 Registers a **transient** factory.
 
-- Throws `FactoryAlreadyBoundError` if the key is already registered.
+- Throws `PlainIocFactoryAlreadyBoundError` if the key is already registered.
 
 ### `container.bindSingleton<T>(key, factory)`
 
 Registers a **singleton** factory.
 
-- Throws `FactoryAlreadyBoundError` if the key is already registered.
+- Throws `PlainIocFactoryAlreadyBoundError` if the key is already registered.
 
 ### `container.resolve<T>(key): T`
 
 Resolves an instance.
 
-- Throws `FactoryNotBoundError` if the key is not registered.
-- Throws `CircularDependencyError` when circular dependency detection is enabled and a cycle is detected.
+- Throws `PlainIocFactoryNotBoundError` if the key is not registered.
+- Throws `PlainIocCircularDependencyError` when circular dependency detection is enabled and a cycle is detected.
 
 ### `container.unbind(key)`
 
 Removes a registered factory and clears any cached singleton instance.
 
-- Throws `FactoryNotBoundError` if the key is not registered.
+- Throws `PlainIocFactoryNotBoundError` if the key is not registered.
 
 ### `container.isBound(key): boolean`
 
@@ -236,21 +236,21 @@ Returns `true` if a factory is registered for `key`.
 All library errors extend the base class `PlainIocError`:
 
 - `PlainIocError`
-- `FactoryNotBoundError`
-- `FactoryAlreadyBoundError`
-- `CircularDependencyError`
+- `PlainIocFactoryNotBoundError`
+- `PlainIocFactoryAlreadyBoundError`
+- `PlainIocCircularDependencyError`
 
 You can catch these specifically:
 
 ```ts
-import { Container, FactoryNotBoundError } from "plain-ioc";
+import { Container, PlainIocFactoryNotBoundError } from "plain-ioc";
 
 const c = new Container();
 
 try {
   c.resolve("missing");
 } catch (e) {
-  if (e instanceof FactoryNotBoundError) {
+  if (e instanceof PlainIocFactoryNotBoundError) {
     console.error("Not registered");
   }
 }

package/dist/Container.d.ts

@@ -11,9 +11,9 @@ export declare class Container {
     protected circularDependencyStackPush(key: DependencyKey): void;
     protected circularDependencyStackPop(): void;
     protected keyToString(key: DependencyKey): string;
-    bind<T>(key: DependencyKey, factory: DependencyFactory<T>): void;
-    unbind(key: DependencyKey): void;
-    bindSingleton<T>(key: DependencyKey, factory: DependencyFactory<T>): void;
+    bind<T>(key: DependencyKey, factory: DependencyFactory<T>): this;
+    bindSingleton<T>(key: DependencyKey, factory: DependencyFactory<T>): this;
+    unbind(key: DependencyKey): this;
     isBound(key: DependencyKey): boolean;
     resolve<T>(key: DependencyKey): T;
 }

package/dist/Container.js

@@ -22,7 +22,7 @@ class Container {
             errorMessage += this.circularDependencyStack.map((item, index) => {
                 return `>>> [${index}]: ${this.keyToString(item)}\n`;
             }).join('');
-            throw new errors_1.CircularDependencyError(errorMessage);
+            throw new errors_1.PlainIocCircularDependencyError(errorMessage);
         }
     }
     circularDependencyStackPop() {
@@ -31,63 +31,69 @@ class Container {
         }
     }
     keyToString(key) {
-        const type = typeof key;
+        const keyType = typeof key;
         try {
             if (typeof key === 'function') {
-                return `"${key.name || '<anonymous>'}" (${type})`;
+                return `[${keyType}] "${key.name || '<anonymous>'}"`;
             }
-            if (type === 'object') {
-                return `"${Object.prototype.toString.call(key)}" (${type})`;
+            else if (typeof key === 'symbol') {
+                return `[${keyType}] "${Symbol.prototype.toString.call(key)}"`;
             }
-            return `"${String(key)}" (${type})`;
+            else if (typeof key === 'object') {
+                return `[${keyType}] "${Object.prototype.toString.call(key)}"`;
+            }
+            return `[${keyType}] "${String(key)}"`;
         }
         catch (_a) {
-            return `"<unprintable>" (${type})`;
+            return `[${keyType}] "<unprintable>"`;
         }
     }
     bind(key, factory) {
         if (this.dependencies.has(key)) {
-            throw new errors_1.FactoryAlreadyBoundError(`Factory for ${this.keyToString(key)} already bound`);
+            throw new errors_1.PlainIocFactoryAlreadyBoundError(`Factory for ${this.keyToString(key)} already bound`);
         }
         this.dependencies.set(key, {
             factory
         });
-    }
-    unbind(key) {
-        if (!this.dependencies.has(key)) {
-            throw new errors_1.FactoryNotBoundError(`Factory not bound with ${this.keyToString(key)}`);
-        }
-        this.dependencies.delete(key);
-        this.initializedInstances.delete(key);
+        return this;
     }
     bindSingleton(key, factory) {
         if (this.dependencies.has(key)) {
-            throw new errors_1.FactoryAlreadyBoundError(`Factory for ${this.keyToString(key)} already bound`);
+            throw new errors_1.PlainIocFactoryAlreadyBoundError(`Factory for ${this.keyToString(key)} already bound`);
         }
         this.dependencies.set(key, {
             factory,
             singleton: true
         });
+        return this;
+    }
+    unbind(key) {
+        if (!this.dependencies.has(key)) {
+            throw new errors_1.PlainIocFactoryNotBoundError(`Factory not bound with ${this.keyToString(key)}`);
+        }
+        this.dependencies.delete(key);
+        this.initializedInstances.delete(key);
+        return this;
     }
     isBound(key) {
         return this.dependencies.has(key);
     }
     resolve(key) {
-        if (!this.dependencies.has(key)) {
-            throw new errors_1.FactoryNotBoundError(`Factory not bound with ${this.keyToString(key)}`);
-        }
         const dependency = this.dependencies.get(key);
+        if (!dependency) {
+            throw new errors_1.PlainIocFactoryNotBoundError(`Factory not bound with ${this.keyToString(key)}`);
+        }
         if (dependency.singleton && this.initializedInstances.has(key)) {
             return this.initializedInstances.get(key);
         }
         try {
             this.circularDependencyStackPush(key);
+            const { factory } = dependency;
+            const instance = factory(this);
             if (dependency.singleton) {
-                const instance = dependency.factory(this);
                 this.initializedInstances.set(key, instance);
-                return instance;
             }
-            return dependency.factory(this);
+            return instance;
         }
         finally {
             this.circularDependencyStackPop();

package/dist/errors/PlainIocCircularDependencyError.d.ts

@@ -0,0 +1,3 @@
+import { PlainIocError } from './PlainIocError';
+export declare class PlainIocCircularDependencyError extends PlainIocError {
+}

package/dist/errors/PlainIocCircularDependencyError.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlainIocCircularDependencyError = void 0;
+const PlainIocError_1 = require("./PlainIocError");
+class PlainIocCircularDependencyError extends PlainIocError_1.PlainIocError {
+}
+exports.PlainIocCircularDependencyError = PlainIocCircularDependencyError;

package/dist/errors/PlainIocFactoryAlreadyBoundError.d.ts

@@ -0,0 +1,3 @@
+import { PlainIocError } from './PlainIocError';
+export declare class PlainIocFactoryAlreadyBoundError extends PlainIocError {
+}

package/dist/errors/PlainIocFactoryAlreadyBoundError.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlainIocFactoryAlreadyBoundError = void 0;
+const PlainIocError_1 = require("./PlainIocError");
+class PlainIocFactoryAlreadyBoundError extends PlainIocError_1.PlainIocError {
+}
+exports.PlainIocFactoryAlreadyBoundError = PlainIocFactoryAlreadyBoundError;

package/dist/errors/PlainIocFactoryNotBoundError.d.ts

@@ -0,0 +1,3 @@
+import { PlainIocError } from './PlainIocError';
+export declare class PlainIocFactoryNotBoundError extends PlainIocError {
+}

package/dist/errors/PlainIocFactoryNotBoundError.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlainIocFactoryNotBoundError = void 0;
+const PlainIocError_1 = require("./PlainIocError");
+class PlainIocFactoryNotBoundError extends PlainIocError_1.PlainIocError {
+}
+exports.PlainIocFactoryNotBoundError = PlainIocFactoryNotBoundError;

package/dist/errors/index.d.ts

@@ -1,4 +1,4 @@
 export { PlainIocError } from './PlainIocError';
-export { FactoryNotBoundError } from './FactoryNotBoundError';
-export { CircularDependencyError } from './CircularDependencyError';
-export { FactoryAlreadyBoundError } from './FactoryAlreadyBoundError';
+export { PlainIocFactoryNotBoundError } from './PlainIocFactoryNotBoundError';
+export { PlainIocCircularDependencyError } from './PlainIocCircularDependencyError';
+export { PlainIocFactoryAlreadyBoundError } from './PlainIocFactoryAlreadyBoundError';

package/dist/errors/index.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FactoryAlreadyBoundError = exports.CircularDependencyError = exports.FactoryNotBoundError = exports.PlainIocError = void 0;
+exports.PlainIocFactoryAlreadyBoundError = exports.PlainIocCircularDependencyError = exports.PlainIocFactoryNotBoundError = exports.PlainIocError = void 0;
 var PlainIocError_1 = require("./PlainIocError");
 Object.defineProperty(exports, "PlainIocError", { enumerable: true, get: function () { return PlainIocError_1.PlainIocError; } });
-var FactoryNotBoundError_1 = require("./FactoryNotBoundError");
-Object.defineProperty(exports, "FactoryNotBoundError", { enumerable: true, get: function () { return FactoryNotBoundError_1.FactoryNotBoundError; } });
-var CircularDependencyError_1 = require("./CircularDependencyError");
-Object.defineProperty(exports, "CircularDependencyError", { enumerable: true, get: function () { return CircularDependencyError_1.CircularDependencyError; } });
-var FactoryAlreadyBoundError_1 = require("./FactoryAlreadyBoundError");
-Object.defineProperty(exports, "FactoryAlreadyBoundError", { enumerable: true, get: function () { return FactoryAlreadyBoundError_1.FactoryAlreadyBoundError; } });
+var PlainIocFactoryNotBoundError_1 = require("./PlainIocFactoryNotBoundError");
+Object.defineProperty(exports, "PlainIocFactoryNotBoundError", { enumerable: true, get: function () { return PlainIocFactoryNotBoundError_1.PlainIocFactoryNotBoundError; } });
+var PlainIocCircularDependencyError_1 = require("./PlainIocCircularDependencyError");
+Object.defineProperty(exports, "PlainIocCircularDependencyError", { enumerable: true, get: function () { return PlainIocCircularDependencyError_1.PlainIocCircularDependencyError; } });
+var PlainIocFactoryAlreadyBoundError_1 = require("./PlainIocFactoryAlreadyBoundError");
+Object.defineProperty(exports, "PlainIocFactoryAlreadyBoundError", { enumerable: true, get: function () { return PlainIocFactoryAlreadyBoundError_1.PlainIocFactoryAlreadyBoundError; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plain-ioc",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Plain inversion of control container",
   "type": "commonjs",
   "main": "./dist/index.js",
@@ -9,6 +9,7 @@
     ".": {
       "types": "./dist/index.d.ts",
       "require": "./dist/index.js",
+      "import": "./dist/index.js",
       "default": "./dist/index.js"
     }
   },

package/dist/errors/CircularDependencyError.d.ts

@@ -1,3 +0,0 @@
-import { PlainIocError } from './PlainIocError';
-export declare class CircularDependencyError extends PlainIocError {
-}

package/dist/errors/CircularDependencyError.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CircularDependencyError = void 0;
-const PlainIocError_1 = require("./PlainIocError");
-class CircularDependencyError extends PlainIocError_1.PlainIocError {
-}
-exports.CircularDependencyError = CircularDependencyError;

package/dist/errors/FactoryAlreadyBoundError.d.ts

@@ -1,3 +0,0 @@
-import { PlainIocError } from './PlainIocError';
-export declare class FactoryAlreadyBoundError extends PlainIocError {
-}

package/dist/errors/FactoryAlreadyBoundError.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FactoryAlreadyBoundError = void 0;
-const PlainIocError_1 = require("./PlainIocError");
-class FactoryAlreadyBoundError extends PlainIocError_1.PlainIocError {
-}
-exports.FactoryAlreadyBoundError = FactoryAlreadyBoundError;

package/dist/errors/FactoryNotBoundError.d.ts

@@ -1,3 +0,0 @@
-import { PlainIocError } from './PlainIocError';
-export declare class FactoryNotBoundError extends PlainIocError {
-}

package/dist/errors/FactoryNotBoundError.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FactoryNotBoundError = void 0;
-const PlainIocError_1 = require("./PlainIocError");
-class FactoryNotBoundError extends PlainIocError_1.PlainIocError {
-}
-exports.FactoryNotBoundError = FactoryNotBoundError;