@stone-js/service-container 0.0.41 → 0.0.42

package/dist/{Container.d.ts → index.d.ts}

@@ -1,6 +1,105 @@
-import { Proxiable } from './Proxiable';
-import { Binding } from './models/Binding';
-import { BindingKey, BindingValue, Resolver } from './declarations';
+/**
+ * Class representing a Proxiable.
+ *
+ * This class allows instances to be wrapped in a Proxy, enabling custom behaviors for property access, assignment, etc.
+ *
+ * @author Mr. Stone <evensstone@gmail.com>
+ */
+declare abstract class Proxiable {
+    /**
+     * Creates a Proxiable instance wrapped in a Proxy.
+     *
+     * @param handler - A trap object for the proxy, which defines custom behavior for fundamental operations (e.g., property lookup, assignment, etc.).
+     * @returns A new proxy object for this instance.
+     */
+    constructor(handler: ProxyHandler<Proxiable>);
+}
+
+/**
+ * A resolver function that takes a container and returns a value of type V.
+ *
+ * @template V - The type of value that the resolver returns.
+ * @param container - The container used to resolve dependencies.
+ * @returns The resolved value of type V.
+ *
+ * @example
+ * ```typescript
+ * const myResolver: Resolver<number> = (container: Container) => {
+ *   // Use the container to resolve dependencies and return a number.
+ *   return 42;
+ * };
+ * ```
+ */
+type Resolver<V> = (container: Container) => V;
+/**
+ * A union type representing the possible keys that can be used to bind values in the container.
+ *
+ * Binding keys can be of various types, such as numbers, booleans, strings, functions, objects, or symbols.
+ * These types are used because they provide a broad range of ways to uniquely identify a binding.
+ *
+ * - `number`, `boolean`, `string`: These are basic types that are easy to use and uniquely identify a binding.
+ * - `Function`: Useful for identifying bindings by constructor or other functions.
+ * - `object`: Allows more complex key types, like instances of classes.
+ * - `symbol`: Guarantees a unique identifier, which can prevent conflicts.
+ *
+ * @example
+ * ```typescript
+ * const key1: BindingKey = 42; // Using a number as a key
+ * const key2: BindingKey = 'serviceName'; // Using a string as a key
+ * const key3: BindingKey = Symbol('uniqueKey'); // Using a symbol for uniqueness
+ * const key4: BindingKey = MyServiceClass; // Using a function (constructor) as a key
+ * const key5: BindingKey = { custom: 'objectKey' }; // Using an object as a key
+ * ```
+ */
+type BindingKey = number | boolean | string | Function | object | symbol;
+/**
+ * A union type representing the possible values that can be bound in the container.
+ *
+ * Binding values can be of various types, including numbers, booleans, strings, functions, objects, or symbols.
+ * Unlike `BindingKey`, `BindingValue` represents the actual data or instance being bound, while `BindingKey` represents the identifier used to access that data.
+ */
+type BindingValue = number | boolean | string | Function | object | symbol;
+
+/**
+ * Abstract class representing a Binding.
+ *
+ * This abstract class serves as the base class for all types of bindings in the service container. It holds a value and provides an abstract method
+ * to resolve and return that value, allowing different subclasses to implement their own resolution logic. Bindings are used to manage dependencies
+ * and control how objects are instantiated within the container.
+ *
+ * @template V - The type of value that this binding holds.
+ * @author Mr. Stone <evensstone@gmail.com>
+ */
+declare abstract class Binding<V extends BindingValue> {
+    /**
+     * The value held by the binding.
+     *
+     * This value is resolved at runtime, either directly or through a resolver function.
+     */
+    protected value?: V;
+    /**
+     * Create a new instance of Binding.
+     *
+     * @param value - The value to be held by the binding.
+     */
+    constructor(value?: V);
+    /**
+     * Check if the value has been resolved.
+     *
+     * @returns A boolean indicating whether the value has been resolved.
+     */
+    protected isResolved(): boolean;
+    /**
+     * Resolve and return the value of the binding.
+     *
+     * This abstract method must be implemented by subclasses to provide specific resolution logic.
+     *
+     * @param container - The container to resolve dependencies from.
+     * @returns The resolved value of the binding.
+     */
+    abstract resolve(container: Container): V | undefined;
+}
+
 /**
  * Class representing a Container.
  *
@@ -10,7 +109,7 @@ import { BindingKey, BindingValue, Resolver } from './declarations';
  *
  * @author Mr. Stone <evensstone@gmail.com>
  */
-export declare class Container extends Proxiable {
+declare class Container extends Proxiable {
     private readonly aliases;
     private readonly resolvingKeys;
     private readonly bindings;
@@ -176,3 +275,5 @@ export declare class Container extends Proxiable {
      */
     autoBinding<V extends BindingValue>(name: BindingKey, item?: V, singleton?: boolean, alias?: string | string[]): this;
 }
+
+export { type BindingKey, type BindingValue, Container, Proxiable, type Resolver };

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@stone-js/service-container",
-  "version": "0.0.41",
+  "version": "0.0.42",
   "description": "Vanilla Javascript IoC Service Container with proposal decorator, proxy resolver and destructuring injection",
   "author": "Mr. Stone <evensstone@gmail.com>",
   "license": "Apache-2.0",
-  "repository": "git@github.com:stonemjs/service-container.git",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/stonemjs/service-container.git"
+  },
   "homepage": "https://github.com/stonemjs/service-container#readme",
   "bugs": {
     "url": "https://github.com/stonemjs/service-container/issues"
@@ -25,12 +28,10 @@
     "/dist"
   ],
   "type": "module",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": [
-        "./dist/declarations.d.ts",
-        "./dist/Container.d.ts"
-      ],
+      "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     }
   },
@@ -63,25 +64,23 @@
     "@rollup/plugin-typescript": "^12.1.1",
     "@types/lodash-es": "^4.17.12",
     "@types/node": "^22.9.0",
-    "@types/validator": "^13.12.2",
     "@vitest/coverage-v8": "^2.1.4",
     "husky": "^9.1.6",
     "rimraf": "^5.0.5",
     "rollup": "^4.1.5",
+    "rollup-plugin-delete": "^2.1.0",
+    "rollup-plugin-dts": "^6.1.1",
     "rollup-plugin-node-externals": "^6.1.2",
     "ts-standard": "^12.0.2",
     "tslib": "^2.8.1",
     "typedoc": "^0.26.11",
     "typedoc-plugin-markdown": "^4.2.10",
     "typescript": "^5.6.3",
-    "validator": "^13.12.0",
     "vitest": "^2.1.4"
   },
   "ts-standard": {
     "globals": [
       "it",
-      "jest",
-      "test",
       "expect",
       "describe",
       "beforeEach"

package/dist/Proxiable.d.ts

@@ -1,16 +0,0 @@
-/**
- * Class representing a Proxiable.
- *
- * This class allows instances to be wrapped in a Proxy, enabling custom behaviors for property access, assignment, etc.
- *
- * @author Mr. Stone <evensstone@gmail.com>
- */
-export declare abstract class Proxiable {
-    /**
-     * Creates a Proxiable instance wrapped in a Proxy.
-     *
-     * @param handler - A trap object for the proxy, which defines custom behavior for fundamental operations (e.g., property lookup, assignment, etc.).
-     * @returns A new proxy object for this instance.
-     */
-    constructor(handler: ProxyHandler<Proxiable>);
-}

package/dist/declarations.d.ts

@@ -1,45 +0,0 @@
-import { Container } from './Container';
-/**
- * A resolver function that takes a container and returns a value of type V.
- *
- * @template V - The type of value that the resolver returns.
- * @param container - The container used to resolve dependencies.
- * @returns The resolved value of type V.
- *
- * @example
- * ```typescript
- * const myResolver: Resolver<number> = (container: Container) => {
- *   // Use the container to resolve dependencies and return a number.
- *   return 42;
- * };
- * ```
- */
-export type Resolver<V> = (container: Container) => V;
-/**
- * A union type representing the possible keys that can be used to bind values in the container.
- *
- * Binding keys can be of various types, such as numbers, booleans, strings, functions, objects, or symbols.
- * These types are used because they provide a broad range of ways to uniquely identify a binding.
- *
- * - `number`, `boolean`, `string`: These are basic types that are easy to use and uniquely identify a binding.
- * - `Function`: Useful for identifying bindings by constructor or other functions.
- * - `object`: Allows more complex key types, like instances of classes.
- * - `symbol`: Guarantees a unique identifier, which can prevent conflicts.
- *
- * @example
- * ```typescript
- * const key1: BindingKey = 42; // Using a number as a key
- * const key2: BindingKey = 'serviceName'; // Using a string as a key
- * const key3: BindingKey = Symbol('uniqueKey'); // Using a symbol for uniqueness
- * const key4: BindingKey = MyServiceClass; // Using a function (constructor) as a key
- * const key5: BindingKey = { custom: 'objectKey' }; // Using an object as a key
- * ```
- */
-export type BindingKey = number | boolean | string | Function | object | symbol;
-/**
- * A union type representing the possible values that can be bound in the container.
- *
- * Binding values can be of various types, including numbers, booleans, strings, functions, objects, or symbols.
- * Unlike `BindingKey`, `BindingValue` represents the actual data or instance being bound, while `BindingKey` represents the identifier used to access that data.
- */
-export type BindingValue = number | boolean | string | Function | object | symbol;

package/dist/errors/ContainerError.d.ts

@@ -1,62 +0,0 @@
-import { BindingKey } from '../declarations';
-/**
- * Class representing a ContainerError.
- *
- * @author Mr. Stone <evensstone@gmail.com>
- */
-export declare class ContainerError extends Error {
-    /**
-     * Error type indicating an alias conflict.
-     */
-    static readonly ALIAS_TYPE = "alias";
-    /**
-     * Error type indicating that the resolver is not a function.
-     */
-    static readonly RESOLVER_TYPE = "resolver";
-    /**
-     * Error type indicating a resolution failure.
-     */
-    static readonly RESOLUTION_TYPE = "resolution";
-    /**
-     * Error type indicating an attempt to alias an unbound value.
-     */
-    static readonly ALIAS_UNBOUND_TYPE = "alias_unbound";
-    /**
-     * Error type indicating that a value is not a service.
-     */
-    static readonly NOT_A_SERVICE_TYPE = "not_a_service";
-    /**
-     * Error type indicating an error thrown by the resolver function.
-     */
-    static readonly CANNOT_RESOLVE_TYPE = "cannot_resolve";
-    /**
-     * Error type indicating a circular dependency.
-     */
-    static readonly CIRCULAR_DEPENDENCY_TYPE = "circular_dependency";
-    /**
-     * The type of the error.
-     */
-    private readonly type;
-    /**
-     * Create a ContainerError.
-     *
-     * @param type - The type of the error.
-     * @param message - The error message or key related to the error.
-     */
-    constructor(type: string, message: BindingKey);
-    /**
-     * Retrieve the error message based on the type and provided message.
-     *
-     * @param type - The type of the error.
-     * @param message - The error message or key related to the error.
-     * @returns The formatted error message.
-     */
-    private getMessage;
-    /**
-     * Retrieve the resolution message based on the key.
-     *
-     * @param key - The key for which the resolution failed.
-     * @returns The formatted resolution error message.
-     */
-    private getResolutionMessage;
-}

package/dist/models/Binding.d.ts

@@ -1,41 +0,0 @@
-import { Container } from '../Container';
-import { BindingValue } from '../declarations';
-/**
- * Abstract class representing a Binding.
- *
- * This abstract class serves as the base class for all types of bindings in the service container. It holds a value and provides an abstract method
- * to resolve and return that value, allowing different subclasses to implement their own resolution logic. Bindings are used to manage dependencies
- * and control how objects are instantiated within the container.
- *
- * @template V - The type of value that this binding holds.
- * @author Mr. Stone <evensstone@gmail.com>
- */
-export declare abstract class Binding<V extends BindingValue> {
-    /**
-     * The value held by the binding.
-     *
-     * This value is resolved at runtime, either directly or through a resolver function.
-     */
-    protected value?: V;
-    /**
-     * Create a new instance of Binding.
-     *
-     * @param value - The value to be held by the binding.
-     */
-    constructor(value?: V);
-    /**
-     * Check if the value has been resolved.
-     *
-     * @returns A boolean indicating whether the value has been resolved.
-     */
-    protected isResolved(): boolean;
-    /**
-     * Resolve and return the value of the binding.
-     *
-     * This abstract method must be implemented by subclasses to provide specific resolution logic.
-     *
-     * @param container - The container to resolve dependencies from.
-     * @returns The resolved value of the binding.
-     */
-    abstract resolve(container: Container): V | undefined;
-}

package/dist/models/Factory.d.ts

@@ -1,25 +0,0 @@
-import { Container } from '../Container';
-import { BindingValue } from '../declarations';
-import { ResolverBinding } from './ResolverBinding';
-/**
- * Class representing a Factory.
- *
- * The Factory class extends the ResolverBinding class, providing a mechanism to resolve a new instance each time the binding is resolved.
- * This ensures that a fresh instance is created with each call to the `resolve` method.
- *
- * @template V - The type of value that this binding holds.
- * @author Mr. Stone <evensstone@gmail.com>
- */
-export declare class Factory<V extends BindingValue> extends ResolverBinding<V> {
-    /**
-     * Resolve and return the value of the binding.
-     *
-     * Each time this method is called, a new value is resolved using the resolver function.
-     * This is intended for cases where a fresh instance is required for each resolution, such as factories or transient dependencies.
-     *
-     * @param container - The container to resolve dependencies from.
-     * @returns The resolved value of the binding.
-     * @throws ContainerError if the value cannot be resolved.
-     */
-    resolve(container: Container): V;
-}

package/dist/models/Instance.d.ts

@@ -1,21 +0,0 @@
-import { Binding } from './Binding';
-import { Container } from '../Container';
-import { BindingValue } from '../declarations';
-/**
- * Class representing an Instance.
- *
- * This class extends the Binding class and directly holds an instance value.
- * It provides a straightforward resolution mechanism that simply returns the stored value.
- *
- * @template V - The type of value that this binding holds.
- * @author Mr. Stone <evensstone@gmail.com>
- */
-export declare class Instance<V extends BindingValue> extends Binding<V> {
-    /**
-     * Resolve and return the value of the binding.
-     *
-     * @param _container - Container to resolve dependencies (not used in this implementation).
-     * @returns The resolved value of the binding.
-     */
-    resolve(_container: Container): V | undefined;
-}

package/dist/models/ResolverBinding.d.ts

@@ -1,26 +0,0 @@
-import { Binding } from './Binding';
-import { BindingValue, Resolver } from '../declarations';
-/**
- * Class representing a ResolverBinding.
- *
- * This class extends the Binding class, using a resolver function to lazily resolve the value when needed.
- *
- * @template V - The type of value that this binding holds.
- * @author Mr. Stone <evensstone@gmail.com>
- */
-export declare abstract class ResolverBinding<V extends BindingValue> extends Binding<V> {
-    /**
-     * The resolver function used to provide the binding value.
-     *
-     * This function will be called when the value is needed, allowing for lazy instantiation
-     * and dependency resolution. It should return an instance of type `V`.
-     */
-    protected readonly resolver: Resolver<V>;
-    /**
-     * Create a new instance of ResolverBinding.
-     *
-     * @param resolver - The resolver function to provide the binding value.
-     * @throws ContainerError if the resolver is not a function.
-     */
-    constructor(resolver: Resolver<V>);
-}

package/dist/models/Singleton.d.ts

@@ -1,25 +0,0 @@
-import { Container } from '../Container';
-import { BindingValue } from '../declarations';
-import { ResolverBinding } from './ResolverBinding';
-/**
- * Class representing a Singleton.
- *
- * The Singleton class extends the ResolverBinding class, ensuring that the value is only resolved once.
- * Subsequent calls to the `resolve` method will return the previously resolved value, making it behave as a singleton.
- *
- * @template V - The type of value that this binding holds.
- * @author Mr. Stone <evensstone@gmail.com>
- */
-export declare class Singleton<V extends BindingValue> extends ResolverBinding<V> {
-    /**
-     * Resolve and return the value of the binding.
-     *
-     * If the value has already been resolved, return the cached value. Otherwise, use the resolver function
-     * to resolve the value, store it, and return it.
-     *
-     * @param container - The container to resolve dependencies from.
-     * @returns The resolved value of the binding.
-     * @throws ContainerError if the value cannot be resolved.
-     */
-    resolve(container: Container): V | undefined;
-}