syrinject 0.0.4 → 0.1.0

package/dist/container/Container.d.ts

@@ -1,19 +1,10 @@
-/**
- * Represents a unique identifier for a dependency in the container.
- *
- * A `Token` can be:
- * - A class constructor (used for class-based dependency injection)
- * - A string (used as a named token)
- * - A symbol (used for unique, non-colliding tokens)
- *
- * @typeParam T - The type of the dependency associated with the token.
- */
-type Token<T = any> = new (...args: any[]) => T | string | symbol;
+import type { Provider } from '../types/Provider';
+import type { Newable, Token } from '../types/Token';
 /**
  * A simple and lightweight dependency injection container.
  *
  * The `Container` class provides methods to register and resolve dependencies using unique tokens.
- * Tokens can be class constructors, strings, or symbols, allowing for flexible and type-safe dependency management.
+ * Tokens can be class constructors, strings, or symbols, allowing flexible and type-safe dependency management.
  *
  * @example
  * // Create a new container instance
@@ -21,10 +12,10 @@ type Token<T = any> = new (...args: any[]) => T | string | symbol;
  *
  * // Register a class dependency
  * class MyService {}
- * container.register(MyService, new MyService());
+ * container.register(MyService, MyService, { singleton: true });
  *
  * // Register a value with a string token
- * container.register('config', { port: 3000 });
+ * container.registerValue('config', { port: 3000 });
  *
  * // Resolve dependencies
  * const service = container.resolve(MyService);
@@ -32,30 +23,92 @@ type Token<T = any> = new (...args: any[]) => T | string | symbol;
  */
 export declare class Container {
     private registry;
-    private singletons;
     /**
      * Registers a dependency with a class constructor and optional dependencies.
      *
-     * @typeParam T - The type of the dependency.
-     * @param token - The unique token to associate with the dependency.
-     * @param useClass - The class constructor to use for creating instances.
-     * @param options - Optional configuration object.
-     * @param options.singleton - If true, the instance will be singleton.
-     * @param options.deps - Optional array of tokens for dependencies.
-     */
-    register<T>(token: Token<T>, useClass: new (...args: any[]) => T, options?: {
+     * @typeParam T - The dependency type.
+     * @param token - Unique token associated with the dependency.
+     * @param useClass - Class constructor used to create instances.
+     * @param options - Optional configuration.
+     * @param options.singleton - Whether to cache a single instance.
+     * @param options.deps - Optional array of dependency tokens.
+     */
+    register<T>(token: Token<T>, useClass: Newable<T>, options?: {
         singleton?: boolean;
         deps?: Token[];
     }): void;
+    register<T>(token: Token<T>, provider: Provider<T>): void;
+    /**
+     * Registers a class provider (syntactic sugar for `register` with a class).
+     *
+     * @typeParam T - The dependency type.
+     * @param token - Unique token associated with the dependency.
+     * @param useClass - Class constructor used to create instances.
+     * @param options - Optional configuration.
+     * @param options.singleton - Whether to cache a single instance.
+     * @param options.deps - Optional array of dependency tokens.
+     */
+    registerClass<T>(token: Token<T>, useClass: Newable<T>, options?: {
+        singleton?: boolean;
+        deps?: Token[];
+    }): void;
+    registerClass<T>(useClass: Newable<T>, options?: {
+        singleton?: boolean;
+        deps?: Token[];
+    }): void;
+    /**
+     * Registers a value provider.
+     *
+     * @typeParam T - The dependency type.
+     * @param token - Unique token associated with the dependency.
+     * @param useValue - Value to be returned on resolve.
+     */
+    registerValue<T>(token: Token<T>, useValue: T): void;
+    /**
+     * Registers a factory provider.
+     *
+     * @typeParam T - The dependency type.
+     * @param token - Unique token associated with the dependency.
+     * @param useFactory - Factory function that builds the dependency.
+     * @param options - Optional configuration.
+     * @param options.singleton - Whether to cache a single instance.
+     */
+    registerFactory<T>(token: Token<T>, useFactory: (container: Container) => T, options?: {
+        singleton?: boolean;
+    }): void;
+    /**
+     * Unregisters a token.
+     *
+     * @param token - Token to remove from the registry.
+     */
+    unregister(token: Token): void;
+    /**
+     * Clears all registrations and cached singletons.
+     */
+    clear(): void;
+    /**
+     * Checks if a token is registered.
+     *
+     * @param token - Token to check.
+     * @returns True if the token is registered, otherwise false.
+     */
+    has(token: Token): boolean;
     /**
      * Resolves a dependency by its token.
      *
-     * @typeParam T - The expected type of the dependency.
-     * @param token - The token associated with the dependency.
+     * @typeParam T - Expected dependency type.
+     * @param token - Token associated with the dependency.
      * @returns The resolved dependency instance or value.
-     * @throws If the dependency is not found for the given token.
+     * @throws DependencyNotFoundError when the token is not registered.
+     * @throws CircularDependencyError when a dependency cycle is detected.
      */
     resolve<T>(token: Token<T>): T;
+    private resolveInternal;
     private createInstance;
+    private normalizeProvider;
+    private isProvider;
+    private isClassProvider;
+    private isValueProvider;
+    private isFactoryProvider;
+    private getDepsFromClass;
 }
-export {};

package/dist/container/Container.js

@@ -1,8 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Container = void 0;
+const CircularDependencyError_1 = require("../errors/CircularDependencyError");
+const DependencyNotFoundError_1 = require("../errors/DependencyNotFoundError");
+const InvalidProviderError_1 = require("../errors/InvalidProviderError");
 /**
  * A simple and lightweight dependency injection container.
  *
  * The `Container` class provides methods to register and resolve dependencies using unique tokens.
- * Tokens can be class constructors, strings, or symbols, allowing for flexible and type-safe dependency management.
+ * Tokens can be class constructors, strings, or symbols, allowing flexible and type-safe dependency management.
  *
  * @example
  * // Create a new container instance
@@ -10,65 +16,157 @@
  *
  * // Register a class dependency
  * class MyService {}
- * container.register(MyService, new MyService());
+ * container.register(MyService, MyService, { singleton: true });
  *
  * // Register a value with a string token
- * container.register('config', { port: 3000 });
+ * container.registerValue('config', { port: 3000 });
  *
  * // Resolve dependencies
  * const service = container.resolve(MyService);
  * const config = container.resolve<{ port: number }>('config');
  */
-export class Container {
+class Container {
     constructor() {
         this.registry = new Map();
-        this.singletons = new Map();
+    }
+    register(token, providerOrClass, options = {}) {
+        const provider = this.normalizeProvider(providerOrClass, options);
+        this.registry.set(token, { provider });
+    }
+    registerClass(tokenOrClass, useClassOrOptions, options = {}) {
+        var _a;
+        if (typeof tokenOrClass === 'function') {
+            const inferredToken = tokenOrClass.name;
+            this.register(inferredToken, tokenOrClass, (_a = useClassOrOptions) !== null && _a !== void 0 ? _a : {});
+            return;
+        }
+        this.register(tokenOrClass, useClassOrOptions, options);
     }
     /**
-     * Registers a dependency with a class constructor and optional dependencies.
+     * Registers a value provider.
      *
-     * @typeParam T - The type of the dependency.
-     * @param token - The unique token to associate with the dependency.
-     * @param useClass - The class constructor to use for creating instances.
-     * @param options - Optional configuration object.
-     * @param options.singleton - If true, the instance will be singleton.
-     * @param options.deps - Optional array of tokens for dependencies.
+     * @typeParam T - The dependency type.
+     * @param token - Unique token associated with the dependency.
+     * @param useValue - Value to be returned on resolve.
      */
-    register(token, useClass, options = {}) {
-        var _a, _b;
-        this.registry.set(token, {
-            useClass,
-            value: null,
-            singleton: (_a = options.singleton) !== null && _a !== void 0 ? _a : false,
-            deps: (_b = options.deps) !== null && _b !== void 0 ? _b : []
-        });
+    registerValue(token, useValue) {
+        this.register(token, { useValue });
+    }
+    /**
+     * Registers a factory provider.
+     *
+     * @typeParam T - The dependency type.
+     * @param token - Unique token associated with the dependency.
+     * @param useFactory - Factory function that builds the dependency.
+     * @param options - Optional configuration.
+     * @param options.singleton - Whether to cache a single instance.
+     */
+    registerFactory(token, useFactory, options = {}) {
+        var _a;
+        this.register(token, { useFactory, singleton: (_a = options.singleton) !== null && _a !== void 0 ? _a : false });
+    }
+    /**
+     * Unregisters a token.
+     *
+     * @param token - Token to remove from the registry.
+     */
+    unregister(token) {
+        this.registry.delete(token);
+    }
+    /**
+     * Clears all registrations and cached singletons.
+     */
+    clear() {
+        this.registry.clear();
+    }
+    /**
+     * Checks if a token is registered.
+     *
+     * @param token - Token to check.
+     * @returns True if the token is registered, otherwise false.
+     */
+    has(token) {
+        return this.registry.has(token);
     }
     /**
      * Resolves a dependency by its token.
      *
-     * @typeParam T - The expected type of the dependency.
-     * @param token - The token associated with the dependency.
+     * @typeParam T - Expected dependency type.
+     * @param token - Token associated with the dependency.
      * @returns The resolved dependency instance or value.
-     * @throws If the dependency is not found for the given token.
+     * @throws DependencyNotFoundError when the token is not registered.
+     * @throws CircularDependencyError when a dependency cycle is detected.
      */
     resolve(token) {
+        return this.resolveInternal(token, []);
+    }
+    resolveInternal(token, resolving) {
+        var _a;
+        if (resolving.includes(token)) {
+            throw new CircularDependencyError_1.CircularDependencyError([...resolving, token]);
+        }
         const entry = this.registry.get(token);
         if (!entry) {
-            throw new Error('Dependência não registrada');
+            throw new DependencyNotFoundError_1.DependencyNotFoundError(token);
+        }
+        const provider = entry.provider;
+        if (this.isValueProvider(provider)) {
+            return provider.useValue;
+        }
+        if (this.isClassProvider(provider)) {
+            if (provider.singleton && entry.value !== undefined) {
+                return entry.value;
+            }
+            const deps = (_a = provider.deps) !== null && _a !== void 0 ? _a : this.getDepsFromClass(provider.useClass);
+            const instance = this.createInstance(provider.useClass, deps, [...resolving, token]);
+            if (provider.singleton) {
+                entry.value = instance;
+            }
+            return instance;
         }
-        if (entry.singleton) {
-            if (!this.singletons.has(token)) {
-                this.singletons.set(token, {
-                    ...entry,
-                    value: this.createInstance(entry.useClass, entry.deps)
-                });
+        if (this.isFactoryProvider(provider)) {
+            if (provider.singleton && entry.value !== undefined) {
+                return entry.value;
+            }
+            const instance = provider.useFactory(this);
+            if (provider.singleton) {
+                entry.value = instance;
             }
-            return this.singletons.get(token).value;
+            return instance;
         }
-        return this.createInstance(entry.useClass, entry.deps);
+        throw new InvalidProviderError_1.InvalidProviderError(token);
     }
-    createInstance(ClassRef, deps = []) {
-        const resolvedDeps = deps.map(dep => this.resolve(dep));
+    createInstance(ClassRef, deps = [], resolving = []) {
+        const resolvedDeps = deps.map(dep => this.resolveInternal(dep, resolving));
         return new ClassRef(...resolvedDeps);
     }
+    normalizeProvider(providerOrClass, options) {
+        var _a, _b;
+        if (this.isProvider(providerOrClass)) {
+            return providerOrClass;
+        }
+        return {
+            useClass: providerOrClass,
+            singleton: (_a = options.singleton) !== null && _a !== void 0 ? _a : false,
+            deps: (_b = options.deps) !== null && _b !== void 0 ? _b : []
+        };
+    }
+    isProvider(value) {
+        return typeof value === 'object' && value !== null;
+    }
+    isClassProvider(provider) {
+        return 'useClass' in provider;
+    }
+    isValueProvider(provider) {
+        return 'useValue' in provider;
+    }
+    isFactoryProvider(provider) {
+        return 'useFactory' in provider;
+    }
+    getDepsFromClass(useClass) {
+        var _a, _b;
+        const classRef = useClass;
+        return (_b = (_a = classRef.deps) !== null && _a !== void 0 ? _a : classRef.dependencies) !== null && _b !== void 0 ? _b : [];
+    }
 }
+exports.Container = Container;

package/dist/decorators/logger.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Logger decorator options.
+ */
+export type LoggerOptions = {
+    /**
+     * Custom logger function. Defaults to `console.log`.
+     */
+    logger?: (message: string, ...args: any[]) => void;
+};
 /**
  * Class decorator that logs instantiation and method calls of the decorated class.
  *
@@ -5,14 +14,15 @@
  * - Log the class name, dependencies (if any), singleton status, and constructor arguments when the class is instantiated.
  * - Intercept all public method calls and log the method name and arguments whenever a method is called.
  *
- * To display dependencies and singleton status, ensure these are set as static properties on the class (e.g., `MyClass.deps`, `MyClass.singleton`).
-*
-* @example
-* ```typescript
-* // Decorate your class:
-* // Use: "@Logger()"
-* class MyService { ... }
-* ```
+ * To display dependencies and singleton status, ensure these are set as static properties on the class
+ * (e.g., `MyClass.deps`, `MyClass.singleton`).
+ *
+ * @example
+ * ```typescript
+ * // Decorate your class:
+ * // Use: "@Logger()"
+ * class MyService { ... }
+ * ```
  * When instantiated or when myMethod is called, logs will be printed to the console.
  */
-export declare function Logger(): ClassDecorator;
+export declare function Logger(options?: LoggerOptions): ClassDecorator;

package/dist/decorators/logger.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = Logger;
 /**
  * Class decorator that logs instantiation and method calls of the decorated class.
  *
@@ -5,35 +8,38 @@
  * - Log the class name, dependencies (if any), singleton status, and constructor arguments when the class is instantiated.
  * - Intercept all public method calls and log the method name and arguments whenever a method is called.
  *
- * To display dependencies and singleton status, ensure these are set as static properties on the class (e.g., `MyClass.deps`, `MyClass.singleton`).
-*
-* @example
-* ```typescript
-* // Decorate your class:
-* // Use: "@Logger()"
-* class MyService { ... }
-* ```
+ * To display dependencies and singleton status, ensure these are set as static properties on the class
+ * (e.g., `MyClass.deps`, `MyClass.singleton`).
+ *
+ * @example
+ * ```typescript
+ * // Decorate your class:
+ * // Use: "@Logger()"
+ * class MyService { ... }
+ * ```
  * When instantiated or when myMethod is called, logs will be printed to the console.
  */
-export function Logger() {
+function Logger(options = {}) {
     return (target) => {
+        var _a;
         const original = target;
+        const log = (_a = options.logger) !== null && _a !== void 0 ? _a : console.log;
         function construct(constructor, args) {
-            // Recupera metadados se existirem
+            // Read metadata when available
             const deps = constructor.deps || constructor.dependencies || [];
             const singleton = constructor.singleton || false;
-            console.log(`[Logger] Instanciando: ${constructor.name}`);
-            console.log(`[Logger] Dependências:`, deps.map((d) => (d === null || d === void 0 ? void 0 : d.name) || d));
-            console.log(`[Logger] Singleton:`, singleton);
-            console.log(`[Logger] Parâmetros:`, args);
+            log(`[Logger] Instanciando: ${constructor.name}`);
+            log(`[Logger] Dependências:`, deps.map((d) => (d === null || d === void 0 ? void 0 : d.name) || d));
+            log(`[Logger] Singleton:`, singleton);
+            log(`[Logger] Parâmetros:`, args);
             const instance = new constructor(...args);
-            // Intercepta métodos públicos
+            // Intercept public methods
             const proto = constructor.prototype;
             Object.getOwnPropertyNames(proto).forEach((prop) => {
                 if (prop !== 'constructor' && typeof proto[prop] === 'function') {
                     const originalMethod = instance[prop];
                     instance[prop] = function (...methodArgs) {
-                        console.log(`[Logger] ${constructor.name}.${prop} chamado com:`, methodArgs);
+                        log(`[Logger] ${constructor.name}.${prop} chamado com:`, methodArgs);
                         return originalMethod.apply(this, methodArgs);
                     };
                 }
@@ -44,6 +50,21 @@ export function Logger() {
             return construct(original, args);
         };
         newConstructor.prototype = original.prototype;
+        copyStaticProps(original, newConstructor);
         return newConstructor;
     };
 }
+/**
+ * Copies static properties from the original constructor to the wrapped one.
+ */
+function copyStaticProps(source, target) {
+    Object.getOwnPropertyNames(source).forEach((key) => {
+        if (key === 'prototype' || key === 'length' || key === 'name') {
+            return;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(source, key);
+        if (descriptor) {
+            Object.defineProperty(target, key, descriptor);
+        }
+    });
+}

package/dist/errors/CircularDependencyError.d.ts

@@ -0,0 +1,13 @@
+import type { Token } from '../types/Token';
+/**
+ * Error thrown when a circular dependency is detected.
+ */
+export declare class CircularDependencyError extends Error {
+    readonly path: Token[];
+    /**
+     * @param path - Dependency resolution path that caused the cycle.
+     */
+    constructor(path: Token[]);
+    private static formatPath;
+    private static formatToken;
+}

package/dist/errors/CircularDependencyError.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircularDependencyError = void 0;
+/**
+ * Error thrown when a circular dependency is detected.
+ */
+class CircularDependencyError extends Error {
+    /**
+     * @param path - Dependency resolution path that caused the cycle.
+     */
+    constructor(path) {
+        super(`Dependência circular detectada: ${CircularDependencyError.formatPath(path)}`);
+        this.name = 'CircularDependencyError';
+        this.path = path;
+    }
+    static formatPath(path) {
+        return path.map(CircularDependencyError.formatToken).join(' -> ');
+    }
+    static formatToken(token) {
+        var _a;
+        if (typeof token === 'string') {
+            return token;
+        }
+        if (typeof token === 'symbol') {
+            return token.toString();
+        }
+        return (_a = token === null || token === void 0 ? void 0 : token.name) !== null && _a !== void 0 ? _a : 'UnknownToken';
+    }
+}
+exports.CircularDependencyError = CircularDependencyError;

package/dist/errors/DependencyNotFoundError.d.ts

@@ -0,0 +1,12 @@
+import type { Token } from '../types/Token';
+/**
+ * Error thrown when a dependency token is not registered.
+ */
+export declare class DependencyNotFoundError extends Error {
+    readonly token: Token;
+    /**
+     * @param token - Token that could not be resolved.
+     */
+    constructor(token: Token);
+    private static formatToken;
+}

package/dist/errors/DependencyNotFoundError.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyNotFoundError = void 0;
+/**
+ * Error thrown when a dependency token is not registered.
+ */
+class DependencyNotFoundError extends Error {
+    /**
+     * @param token - Token that could not be resolved.
+     */
+    constructor(token) {
+        super(`Dependência não registrada: ${DependencyNotFoundError.formatToken(token)}`);
+        this.name = 'DependencyNotFoundError';
+        this.token = token;
+    }
+    static formatToken(token) {
+        var _a;
+        if (typeof token === 'string') {
+            return token;
+        }
+        if (typeof token === 'symbol') {
+            return token.toString();
+        }
+        return (_a = token === null || token === void 0 ? void 0 : token.name) !== null && _a !== void 0 ? _a : 'UnknownToken';
+    }
+}
+exports.DependencyNotFoundError = DependencyNotFoundError;

package/dist/errors/InvalidProviderError.d.ts

@@ -0,0 +1,12 @@
+import type { Token } from '../types/Token';
+/**
+ * Error thrown when a token is registered with an invalid provider configuration.
+ */
+export declare class InvalidProviderError extends Error {
+    readonly token: Token;
+    /**
+     * @param token - Token with invalid provider configuration.
+     */
+    constructor(token: Token);
+    private static formatToken;
+}

package/dist/errors/InvalidProviderError.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidProviderError = void 0;
+/**
+ * Error thrown when a token is registered with an invalid provider configuration.
+ */
+class InvalidProviderError extends Error {
+    /**
+     * @param token - Token with invalid provider configuration.
+     */
+    constructor(token) {
+        super(`Provider inválido para o token: ${InvalidProviderError.formatToken(token)}`);
+        this.name = 'InvalidProviderError';
+        this.token = token;
+    }
+    static formatToken(token) {
+        var _a;
+        if (typeof token === 'string') {
+            return token;
+        }
+        if (typeof token === 'symbol') {
+            return token.toString();
+        }
+        return (_a = token === null || token === void 0 ? void 0 : token.name) !== null && _a !== void 0 ? _a : 'UnknownToken';
+    }
+}
+exports.InvalidProviderError = InvalidProviderError;

package/dist/index.d.ts

@@ -1,3 +1,9 @@
-import { Container } from './container/Container';
-import { Logger } from './decorators/logger';
-export { type Container, type Logger };
+export { Container } from './container/Container';
+export { Logger } from './decorators/logger';
+export { CircularDependencyError } from './errors/CircularDependencyError';
+export { DependencyNotFoundError } from './errors/DependencyNotFoundError';
+export { InvalidProviderError } from './errors/InvalidProviderError';
+export type { Container as ContainerType } from './container/Container';
+export type { Logger as LoggerType, LoggerOptions } from './decorators/logger';
+export type { Token, Newable } from './types/Token';
+export type { Provider, ClassProvider, ValueProvider, FactoryProvider } from './types/Provider';

package/dist/index.js

@@ -1 +1,13 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidProviderError = exports.DependencyNotFoundError = exports.CircularDependencyError = exports.Logger = exports.Container = void 0;
+var Container_1 = require("./container/Container");
+Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return Container_1.Container; } });
+var logger_1 = require("./decorators/logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
+var CircularDependencyError_1 = require("./errors/CircularDependencyError");
+Object.defineProperty(exports, "CircularDependencyError", { enumerable: true, get: function () { return CircularDependencyError_1.CircularDependencyError; } });
+var DependencyNotFoundError_1 = require("./errors/DependencyNotFoundError");
+Object.defineProperty(exports, "DependencyNotFoundError", { enumerable: true, get: function () { return DependencyNotFoundError_1.DependencyNotFoundError; } });
+var InvalidProviderError_1 = require("./errors/InvalidProviderError");
+Object.defineProperty(exports, "InvalidProviderError", { enumerable: true, get: function () { return InvalidProviderError_1.InvalidProviderError; } });

package/dist/types/Provider.d.ts

@@ -0,0 +1,31 @@
+import type { Container } from '../container/Container';
+import type { Newable, Token } from './Token';
+/**
+ * Provider that resolves dependencies by instantiating a class.
+ */
+export type ClassProvider<T = any> = {
+    /** Class constructor used to create instances. */
+    useClass: Newable<T>;
+    /** Optional dependency tokens for constructor injection. */
+    deps?: Token[];
+    /** Whether to cache a single instance. */
+    singleton?: boolean;
+};
+/**
+ * Provider that returns a pre-built value.
+ */
+export type ValueProvider<T = any> = {
+    useValue: T;
+};
+/**
+ * Provider that resolves dependencies via a factory function.
+ */
+export type FactoryProvider<T = any> = {
+    useFactory: (container: Container) => T;
+    /** Whether to cache a single instance. */
+    singleton?: boolean;
+};
+/**
+ * Union of all supported providers.
+ */
+export type Provider<T = any> = ClassProvider<T> | ValueProvider<T> | FactoryProvider<T>;

package/dist/types/Provider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/Token.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Constructor signature for class-based providers.
+ */
+export type Newable<T = any> = new (...args: any[]) => T;
+/**
+ * Token used to register and resolve dependencies.
+ * Can be a class constructor, string, or symbol.
+ */
+export type Token<T = any> = string | symbol | Newable<T>;

package/dist/types/Token.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "syrinject",
   "description": "Simple dependency injection container",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [