syrinject 0.0.1

package/README.md

@@ -0,0 +1,5 @@
+<p align="center">
+	<img src="assets/logo-without-background.png" alt="Syrinject Logo" width="500" />
+</p>
+
+<hr>

package/dist/container/Container.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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;
+/**
+ * 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.
+ *
+ * @example
+ * // Create a new container instance
+ * const container = new Container();
+ *
+ * // Register a class dependency
+ * class MyService {}
+ * container.register(MyService, new MyService());
+ *
+ * // Register a value with a string token
+ * container.register('config', { port: 3000 });
+ *
+ * // Resolve dependencies
+ * const service = container.resolve(MyService);
+ * const config = container.resolve<{ port: number }>('config');
+ */
+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?: {
+        singleton?: boolean;
+        deps?: Token[];
+    }): void;
+    /**
+     * Resolves a dependency by its token.
+     *
+     * @typeParam T - The expected type of the dependency.
+     * @param token - The token associated with the dependency.
+     * @returns The resolved dependency instance or value.
+     * @throws If the dependency is not found for the given token.
+     */
+    resolve<T>(token: Token<T>): T;
+    private createInstance;
+}
+export {};

package/dist/container/Container.js

@@ -0,0 +1,74 @@
+/**
+ * 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.
+ *
+ * @example
+ * // Create a new container instance
+ * const container = new Container();
+ *
+ * // Register a class dependency
+ * class MyService {}
+ * container.register(MyService, new MyService());
+ *
+ * // Register a value with a string token
+ * container.register('config', { port: 3000 });
+ *
+ * // Resolve dependencies
+ * const service = container.resolve(MyService);
+ * const config = container.resolve<{ port: number }>('config');
+ */
+export class Container {
+    constructor() {
+        this.registry = new Map();
+        this.singletons = new Map();
+    }
+    /**
+     * 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(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 : []
+        });
+    }
+    /**
+     * Resolves a dependency by its token.
+     *
+     * @typeParam T - The expected type of the dependency.
+     * @param token - The token associated with the dependency.
+     * @returns The resolved dependency instance or value.
+     * @throws If the dependency is not found for the given token.
+     */
+    resolve(token) {
+        const entry = this.registry.get(token);
+        if (!entry) {
+            throw new Error('Dependência não registrada');
+        }
+        if (entry.singleton) {
+            if (!this.singletons.has(token)) {
+                this.singletons.set(token, {
+                    ...entry,
+                    value: this.createInstance(entry.useClass, entry.deps)
+                });
+            }
+            return this.singletons.get(token).value;
+        }
+        return this.createInstance(entry.useClass, entry.deps);
+    }
+    createInstance(ClassRef, deps = []) {
+        const resolvedDeps = deps.map(dep => this.resolve(dep));
+        return new ClassRef(...resolvedDeps);
+    }
+}

package/dist/decorators/logger.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Class decorator that logs instantiation and method calls of the decorated class.
+ *
+ * When applied, this decorator will:
+ * - 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 { ... }
+* ```
+ * When instantiated or when myMethod is called, logs will be printed to the console.
+ */
+export declare function Logger(): ClassDecorator;

package/dist/decorators/logger.js

@@ -0,0 +1,49 @@
+/**
+ * Class decorator that logs instantiation and method calls of the decorated class.
+ *
+ * When applied, this decorator will:
+ * - 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 { ... }
+* ```
+ * When instantiated or when myMethod is called, logs will be printed to the console.
+ */
+export function Logger() {
+    return (target) => {
+        const original = target;
+        function construct(constructor, args) {
+            // Recupera metadados se existirem
+            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);
+            const instance = new constructor(...args);
+            // Intercepta métodos públicos
+            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);
+                        return originalMethod.apply(this, methodArgs);
+                    };
+                }
+            });
+            return instance;
+        }
+        const newConstructor = function (...args) {
+            return construct(original, args);
+        };
+        newConstructor.prototype = original.prototype;
+        return newConstructor;
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { Container } from './container/Container';
+import { Logger } from './decorators/logger';
+export { type Container, type Logger };

package/dist/index.js

@@ -0,0 +1 @@
+export {};

package/dist/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "simple-di-container",
+  "description": "Simple dependency injection container",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc -w",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [],
+  "author": "andersonreges",
+  "license": "ISC",
+  "type": "commonjs",
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "syrinject",
+  "description": "Simple dependency injection container",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc -w",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [],
+  "author": "andersonreges",
+  "license": "ISC",
+  "type": "commonjs",
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}