@signe/di 1.0.2

package/dist/index.d.ts

@@ -0,0 +1,220 @@
+/**
+ * Type definitions for the dependency injection system
+ * @module @signe/di/types
+ */
+/**
+ * Context object used for dependency injection
+ */
+type ProviderContext = any;
+/**
+ * Token used to identify a provider. Can be either a class constructor or a string
+ */
+type ProviderToken = (new (...args: any[]) => any) | string;
+/**
+ * Factory function type that creates instances using the provided context
+ * @param context - The injection context
+ * @returns The created instance
+ */
+type FactoryFn = (context: ProviderContext) => any;
+/**
+ * Provider configuration for value-based injection
+ */
+interface ValueProvider {
+    /** Token to identify the provider */
+    provide: ProviderToken;
+    /** Value to be injected */
+    useValue: any;
+}
+/**
+ * Provider configuration for class-based injection
+ */
+interface ClassProvider {
+    /** Token to identify the provider */
+    provide: ProviderToken;
+    /** Class to be instantiated */
+    useClass: new (context: ProviderContext) => any;
+}
+/**
+ * Provider configuration for factory-based injection
+ */
+interface FactoryProvider {
+    /** Token to identify the provider */
+    provide: ProviderToken;
+    /** Optional metadata for the provider */
+    meta?: {
+        [key: string]: any;
+    };
+    /** Factory function to create the instance */
+    useFactory: FactoryFn;
+}
+/**
+ * Provider configuration for alias-based injection
+ */
+interface ExistingProvider {
+    /** Token to identify the provider */
+    provide: ProviderToken;
+    /** Token of the existing provider to use */
+    useExisting: ProviderToken;
+}
+/**
+ * Union type for all possible provider configurations
+ */
+type Provider = (new (...args: any[]) => any) | (ValueProvider & {
+    useClass?: never;
+    useFactory?: never;
+    useExisting?: never;
+}) | (ClassProvider & {
+    useValue?: never;
+    useFactory?: never;
+    useExisting?: never;
+}) | (FactoryProvider & {
+    useValue?: never;
+    useClass?: never;
+    useExisting?: never;
+}) | (ExistingProvider & {
+    useValue?: never;
+    useClass?: never;
+    useFactory?: never;
+});
+/**
+ * Array of providers that can be nested one level deep
+ */
+type Providers = (Provider | Providers)[];
+
+/**
+ * Context class for managing dependency injection state
+ * @module @signe/di/context
+ */
+/**
+ * Stores and manages the state of injected dependencies
+ */
+declare class Context {
+    /** Internal storage for injected values */
+    private values;
+    /**
+     * Sets a value in the context
+     * @param key - Unique identifier for the value
+     * @param value - Value to store
+     */
+    set(key: string, value: any): void;
+    /**
+     * Retrieves a value from the context
+     * @param key - Unique identifier for the value
+     * @returns The stored value or undefined if not found
+     */
+    get(key: string): any;
+}
+
+/**
+ * Core functionality for dependency injection
+ * @module @signe/di/inject
+ */
+
+/**
+ * Provides a value to the dependency injection context
+ * @template T - Type of the value being provided
+ * @param context - The injection context
+ * @param name - Identifier for the provided value
+ * @param value - The value to provide
+ * @returns The provided value
+ */
+declare function provide<T>(context: Context, name: string, value: T): T;
+/**
+ * Checks if a service has been injected into the context
+ * @param context - The injection context
+ * @param name - Name of the service to check
+ * @returns True if the service has been injected, false otherwise
+ */
+declare function isInjected(context: Context, name: string): boolean;
+/**
+ * Retrieves a service from the dependency injection context
+ * @template T - Type of the service to inject
+ * @param context - The injection context
+ * @param service - Class constructor or string identifier of the service
+ * @param args - Optional arguments for service instantiation
+ * @returns The injected service instance
+ * @throws {Error} If the requested service is not found in the context
+ */
+declare function inject<T>(context: Context, service: (new (...args: any[]) => T) | string, args?: any[]): T;
+/**
+ * Overrides or adds a provider in the providers array
+ * @param providers - Array of existing providers
+ * @param newProvider - Provider to add or replace with
+ * @param options - Configuration options
+ * @param options.upsert - If true, adds the provider when not found
+ * @param options.key - Custom key to identify the provider
+ * @returns Updated array of providers
+ */
+declare function override(providers: Providers, newProvider: Provider, options?: {
+    upsert?: boolean;
+    key?: string;
+}): (Provider | Providers)[];
+/**
+ * Finds all providers matching the given name or pattern
+ * @template T - Type of provider to return
+ * @param providers - Array of providers to search
+ * @param name - String or RegExp to match against provider names
+ * @returns Array of matching providers
+ */
+declare function findProviders<T extends Provider = Provider>(providers: Providers, name: string | RegExp): T[];
+/**
+ * Finds the first provider matching the given name or pattern
+ * @template T - Type of provider to return
+ * @param providers - Array of providers to search
+ * @param name - String or RegExp to match against provider names
+ * @returns Matching provider or null if not found
+ */
+declare function findProvider<T extends Provider = Provider>(providers: Providers, name: string | RegExp): T | null;
+
+/**
+ * Configuration merging functionality for dependency injection
+ * @module @signe/di/merge-config
+ */
+/**
+ * Application configuration interface
+ */
+interface AppConfig {
+    /** Array of dependency providers */
+    providers: any[];
+    /** Optional static files configuration */
+    staticFiles?: {
+        /** Path to static files */
+        path: string;
+        /** Static file serving configuration */
+        serve: any;
+    };
+}
+/**
+ * Merges two application configurations
+ * @param baseConfig - Base configuration to merge into
+ * @param config - Configuration to merge with base
+ * @returns Merged configuration with providers properly combined
+ */
+declare function mergeConfig(baseConfig: AppConfig, config: AppConfig): AppConfig;
+
+/**
+ * Provider system implementation for dependency injection
+ * @module @signe/di/provider
+ */
+
+/**
+ * Processes and instantiates all providers in the given context
+ * @param context - The injection context
+ * @param providers - Array of providers to process
+ * @returns Promise that resolves when all providers are processed
+ *
+ * @example
+ * ```typescript
+ * const context = new Context();
+ * const providers = [
+ *   UserService,
+ *   { provide: 'CONFIG', useValue: { apiUrl: 'http://api.example.com' } },
+ *   { provide: AuthService, useFactory: (ctx) => new AuthService(ctx) }
+ * ];
+ *
+ * await injector(context, providers);
+ * ```
+ */
+declare function injector(context: Context, providers: Providers): Promise<void>;
+
+export { type AppConfig, type ClassProvider, Context, type ExistingProvider, type FactoryFn, type FactoryProvider, type Provider, type ProviderContext, type ProviderToken, type Providers, type ValueProvider, findProvider, findProviders, inject, injector, isInjected, mergeConfig, override, provide };

package/dist/index.js

@@ -0,0 +1,182 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/inject.ts
+function provide(context, name, value) {
+  context.set("inject:" + name, value);
+  return value;
+}
+__name(provide, "provide");
+function isInjected(context, name) {
+  return context.get("injected:" + name) === true;
+}
+__name(isInjected, "isInjected");
+function inject(context, service, args = []) {
+  const isClass = typeof service === "function";
+  const name = isClass ? service.name : service;
+  const value = context.get("inject:" + name);
+  if (value) {
+    context.set("injected:" + name, true);
+    return value;
+  }
+  throw new Error(`Injection provider ${name} not found`);
+}
+__name(inject, "inject");
+function override(providers, newProvider, options) {
+  let { upsert = false, key } = options ?? {};
+  if (!key) {
+    key = typeof newProvider === "function" ? newProvider.name : newProvider.provide;
+  }
+  const flatProviders = providers.flat();
+  const exists = flatProviders.some((provider) => {
+    if (typeof provider === "function") {
+      return provider.name === key;
+    } else if (typeof provider === "object") {
+      return provider.provide === key;
+    }
+    return false;
+  });
+  const mappedProviders = flatProviders.map((provider) => {
+    if (typeof provider === "function" && provider.name === key) {
+      return newProvider;
+    } else if (typeof provider === "object" && provider.provide === key) {
+      return newProvider;
+    }
+    return provider;
+  });
+  if (upsert && !exists) {
+    mappedProviders.push(newProvider);
+  }
+  return mappedProviders;
+}
+__name(override, "override");
+function findProviders(providers, name) {
+  const results = [];
+  for (const provider of providers) {
+    if (Array.isArray(provider)) {
+      results.push(...findProviders(provider, name));
+    } else if (findProvider(provider, name)) {
+      results.push(provider);
+    }
+  }
+  return results;
+}
+__name(findProviders, "findProviders");
+function findProvider(providers, name) {
+  if (!Array.isArray(providers)) {
+    if (typeof providers === "object" && "provide" in providers) {
+      const provider = providers;
+      const providerName = typeof provider.provide === "function" ? provider.provide.name : provider.provide;
+      if (name instanceof RegExp) {
+        if (name.test(providerName)) return providers;
+      } else {
+        if (providerName === name) return providers;
+      }
+    }
+    return null;
+  }
+  for (const provider of providers) {
+    if (Array.isArray(provider)) {
+      const found = findProvider(provider, name);
+      if (found) return found;
+      continue;
+    }
+    if (typeof provider === "object" && "provide" in provider) {
+      const providerName = typeof provider.provide === "function" ? provider.provide.name : provider.provide;
+      if (name instanceof RegExp) {
+        if (name.test(providerName)) return provider;
+      } else {
+        if (providerName === name) return provider;
+      }
+    }
+  }
+  return null;
+}
+__name(findProvider, "findProvider");
+
+// src/merge-config.ts
+function mergeConfig(baseConfig, config) {
+  const mergedConfig = {
+    ...baseConfig,
+    ...config
+  };
+  for (let provider of config.providers) {
+    const isFound = findProvider(baseConfig.providers, provider.provide);
+    if (!isFound) {
+      mergedConfig.providers = override(baseConfig.providers, provider, {
+        upsert: true
+      });
+    }
+  }
+  return mergedConfig;
+}
+__name(mergeConfig, "mergeConfig");
+
+// src/provider.ts
+async function injector(context, providers) {
+  providers = providers.flat();
+  for (const provider of providers) {
+    let token;
+    let instance;
+    if (typeof provider === "function") {
+      token = provider;
+      instance = new provider(context);
+    } else {
+      token = provider.provide;
+      const provideUserClass = provider.useClass;
+      const isClass = typeof provideUserClass === "function";
+      if (isClass) {
+        instance = new provideUserClass(context);
+      } else if ("useValue" in provider) {
+        instance = provider.useValue;
+      } else if ("useFactory" in provider) {
+        instance = provider.useFactory?.(context);
+        if (instance instanceof Promise) {
+          instance = await instance;
+        }
+      } else if ("useExisting" in provider) {
+        instance = inject(context, provider.useExisting);
+      }
+    }
+    const name = typeof token === "function" ? token.name : token;
+    provide(context, name, instance);
+  }
+}
+__name(injector, "injector");
+
+// src/context.ts
+var Context = class {
+  static {
+    __name(this, "Context");
+  }
+  /** Internal storage for injected values */
+  values = {};
+  /**
+   * Sets a value in the context
+   * @param key - Unique identifier for the value
+   * @param value - Value to store
+   */
+  set(key, value) {
+    this.values[key] = value;
+  }
+  /**
+   * Retrieves a value from the context
+   * @param key - Unique identifier for the value
+   * @returns The stored value or undefined if not found
+   */
+  get(key) {
+    return this.values[key];
+  }
+};
+export {
+  Context,
+  findProvider,
+  findProviders,
+  inject,
+  injector,
+  isInjected,
+  mergeConfig,
+  override,
+  provide
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/inject.ts","../src/merge-config.ts","../src/provider.ts","../src/context.ts"],"sourcesContent":["/**\n * Core functionality for dependency injection\n * @module @signe/di/inject\n */\n\nimport { Provider, Providers } from \"./types\";\nimport { Context } from \"./context\";\n\n/**\n * Provides a value to the dependency injection context\n * @template T - Type of the value being provided\n * @param context - The injection context\n * @param name - Identifier for the provided value\n * @param value - The value to provide\n * @returns The provided value\n */\nexport function provide<T>(context: Context, name: string, value: T): T {\n  context.set(\"inject:\" + name, value);\n  return value;\n}\n\n/**\n * Checks if a service has been injected into the context\n * @param context - The injection context\n * @param name - Name of the service to check\n * @returns True if the service has been injected, false otherwise\n */\nexport function isInjected(context: Context, name: string): boolean {\n  return context.get('injected:' + name) === true;\n}\n\n/**\n * Retrieves a service from the dependency injection context\n * @template T - Type of the service to inject\n * @param context - The injection context\n * @param service - Class constructor or string identifier of the service\n * @param args - Optional arguments for service instantiation\n * @returns The injected service instance\n * @throws {Error} If the requested service is not found in the context\n */\nexport function inject<T>(\n  context: Context,\n  service: (new (...args: any[]) => T) | string,\n  args: any[] = []\n): T {\n  const isClass = typeof service === \"function\";\n  const name = isClass ? service.name : service;\n  const value = context.get(\"inject:\" + name);\n  if (value) {\n    context.set('injected:' + name, true)\n    return value as T;\n  }\n  throw new Error(`Injection provider ${name} not found`);\n}\n\n/**\n * Overrides or adds a provider in the providers array\n * @param providers - Array of existing providers\n * @param newProvider - Provider to add or replace with\n * @param options - Configuration options\n * @param options.upsert - If true, adds the provider when not found\n * @param options.key - Custom key to identify the provider\n * @returns Updated array of providers\n */\nexport function override(\n  providers: Providers,\n  newProvider: Provider,\n  options?: {\n    upsert?: boolean,\n    key?: string\n  }\n) {\n  let { upsert = false, key } = options ?? {};\n  if (!key) {\n    key = (\n      typeof newProvider === \"function\" ? newProvider.name : newProvider.provide\n    ) as string;\n  }\n\n  // Flatten the providers array\n  const flatProviders = providers.flat();\n  \n  // Check if provider exists\n  const exists = flatProviders.some(provider => {\n    if (typeof provider === \"function\") {\n      return provider.name === key;\n    } else if (typeof provider === \"object\") {\n      return (provider as any).provide === key;\n    }\n    return false;\n  });\n\n  // Map and replace if found\n  const mappedProviders = flatProviders.map((provider) => {\n    if (typeof provider === \"function\" && provider.name === key) {\n      return newProvider;\n    } else if (typeof provider === \"object\" && (provider as any).provide === key) {\n      return newProvider;\n    }\n    return provider;\n  });\n\n  // If upsert is true and provider wasn't found, add it to the end\n  if (upsert && !exists) {\n    mappedProviders.push(newProvider);\n  }\n\n  return mappedProviders;\n}\n\n/**\n * Finds all providers matching the given name or pattern\n * @template T - Type of provider to return\n * @param providers - Array of providers to search\n * @param name - String or RegExp to match against provider names\n * @returns Array of matching providers\n */\nexport function findProviders<T extends Provider = Provider>(providers: Providers, name: string | RegExp): T[] {\n  const results: any[] = [];\n  \n  for (const provider of providers) {\n    if (Array.isArray(provider)) {\n      // Recursively search in nested arrays and concat results\n      results.push(...findProviders(provider, name));\n    } else if (findProvider(provider as any, name)) {\n      // Add matching provider to results\n      results.push(provider as T);\n    }\n  }\n  \n  return results;\n}\n\n/**\n * Finds the first provider matching the given name or pattern\n * @template T - Type of provider to return\n * @param providers - Array of providers to search\n * @param name - String or RegExp to match against provider names\n * @returns Matching provider or null if not found\n */\nexport function findProvider<T extends Provider = Provider>(providers: Providers, name: string | RegExp): T | null {\n  // Handle single provider case\n  if (!Array.isArray(providers)) {\n    if (typeof providers === \"object\" && 'provide' in providers) {\n      const provider = providers as any\n      const providerName = typeof provider.provide === \"function\"\n        ? provider.provide.name \n        : provider.provide;\n\n      if (name instanceof RegExp) {\n        if (name.test(providerName)) return providers as T;\n      } else {\n        if (providerName === name) return providers as T;\n      }\n    }\n    return null;\n  }\n\n  // Original array handling logic\n  for (const provider of providers) {\n    // If provider is an array, recursively search in it\n    if (Array.isArray(provider)) {\n      const found = findProvider(provider, name);\n      if (found) return found as T;\n      continue;\n    }\n\n    // Check object provider\n    if (typeof provider === \"object\" && 'provide' in provider) {\n      const providerName = typeof provider.provide === \"function\" \n        ? provider.provide.name \n        : provider.provide;\n\n      // Handle RegExp matching\n      if (name instanceof RegExp) {\n        if (name.test(providerName)) return provider as T;\n      } else {\n        // Handle exact string matching\n        if (providerName === name) return provider as T;\n      }\n    }\n  }\n  return null;\n}\n","/**\n * Configuration merging functionality for dependency injection\n * @module @signe/di/merge-config\n */\n\nimport { findProvider, override } from \"./inject\";\n\n/**\n * Application configuration interface\n */\nexport interface AppConfig {\n    /** Array of dependency providers */\n    providers: any[];\n    /** Optional static files configuration */\n    staticFiles?: {\n        /** Path to static files */\n        path: string;\n        /** Static file serving configuration */\n        serve: any;\n    }\n}\n\n/**\n * Merges two application configurations\n * @param baseConfig - Base configuration to merge into\n * @param config - Configuration to merge with base\n * @returns Merged configuration with providers properly combined\n */\nexport function mergeConfig(baseConfig: AppConfig, config: AppConfig): AppConfig {\n    const mergedConfig: AppConfig = {\n        ...baseConfig,\n        ...config\n    }\n    for (let provider of config.providers) {\n        const isFound = findProvider(baseConfig.providers, provider.provide)\n        if (!isFound) {\n            mergedConfig.providers = override(baseConfig.providers, provider, { upsert: true })\n        }\n    }\n    return mergedConfig;\n}\n","/**\n * Provider system implementation for dependency injection\n * @module @signe/di/provider\n */\n\nimport { ClassProvider, Provider, Providers, ProviderToken } from \"./types\";\nimport { inject, provide } from \"./inject\";\nimport { Context } from \"./context\";\n\n/**\n * Type guard to check if a provider is a ClassProvider\n * @param provider - Provider to check\n * @returns True if the provider is a ClassProvider\n */\nfunction isClassProvider(provider: Provider): provider is ClassProvider {\n    if (typeof provider === 'string') {\n        return false;\n    }\n    return 'useClass' in provider && typeof provider.useClass === 'function';\n}\n\n/**\n * Processes and instantiates all providers in the given context\n * @param context - The injection context\n * @param providers - Array of providers to process\n * @returns Promise that resolves when all providers are processed\n * \n * @example\n * ```typescript\n * const context = new Context();\n * const providers = [\n *   UserService,\n *   { provide: 'CONFIG', useValue: { apiUrl: 'http://api.example.com' } },\n *   { provide: AuthService, useFactory: (ctx) => new AuthService(ctx) }\n * ];\n * \n * await injector(context, providers);\n * ```\n */\nexport async function injector(context: Context, providers: Providers) {\n    providers = providers.flat();\n    for (const provider of providers) {\n        let token: ProviderToken;\n        let instance: any;\n\n        if (typeof provider === 'function') {\n            // If provider is a class, treat it as a ClassProvider\n            token = provider;\n            instance = new provider(context);\n        } else {\n            token = (provider as any).provide;\n            const provideUserClass = (provider as any).useClass;\n            const isClass = typeof provideUserClass === 'function';\n            if (isClass) {\n                instance = new provideUserClass(context);\n            } else if ('useValue' in provider) {\n                instance = provider.useValue;\n            } else if ('useFactory' in provider) {\n                instance = provider.useFactory?.(context);\n                if (instance instanceof Promise) {\n                    instance = await instance;\n                }\n            } else if ('useExisting' in provider) {\n                instance = inject(context, provider.useExisting);\n            }\n        }\n\n        const name = typeof token === 'function' ? token.name : token;\n        provide(context, name, instance);\n    }\n}","/**\n * Context class for managing dependency injection state\n * @module @signe/di/context\n */\n\n/**\n * Stores and manages the state of injected dependencies\n */\nexport class Context {\n    /** Internal storage for injected values */\n    private values: { [key: string]: any } = {}\n\n    /**\n     * Sets a value in the context\n     * @param key - Unique identifier for the value\n     * @param value - Value to store\n     */\n    set(key: string, value: any) {\n        this.values[key] = value\n    }\n\n    /**\n     * Retrieves a value from the context\n     * @param key - Unique identifier for the value\n     * @returns The stored value or undefined if not found\n     */\n    get(key: string) {\n        return this.values[key]\n    }\n}"],"mappings":"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","names":["provide","context","name","value","set","isInjected","get","inject","service","args","isClass","Error","override","providers","newProvider","options","upsert","key","flatProviders","flat","exists","some","provider","mappedProviders","map","push","findProviders","results","Array","isArray","findProvider","providerName","RegExp","test","found","mergeConfig","baseConfig","config","mergedConfig","provider","providers","isFound","findProvider","provide","override","upsert","injector","context","providers","flat","provider","token","instance","provide","provideUserClass","useClass","isClass","useValue","useFactory","Promise","inject","useExisting","name","Context","values","set","key","value","get"]}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@signe/di",
+  "version": "1.0.2",
+  "description": "",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./*": "./*"
+  },
+  "keywords": [],
+  "author": "Samuel Ronce",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsup src/index.ts",
+    "dev": "tsup src/index.ts --watch"
+  }
+}

package/readme.md

@@ -0,0 +1,130 @@
+# @signe/di
+
+A lightweight and flexible dependency injection system for JavaScript/TypeScript applications.
+
+## Installation
+
+```bash
+npm install @signe/di
+# or
+yarn add @signe/di
+# or
+pnpm add @signe/di
+```
+
+## Features
+
+- Simple and intuitive API
+- Type-safe dependency injection
+- Provider system with multiple configuration options
+- Context-based injection
+- Override capabilities for testing and customization
+- Support for nested providers
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { provide, inject, Context, Providers } from '@signe/di';
+
+const context = new Context();
+
+class UserService {
+  getUser(id: string) {
+    return { id, name: 'John Doe' };
+  }
+}
+
+class AuthService {
+  constructor(private config: any) {}
+}
+
+const providers: Providers = [
+  UserService,
+  {
+    provide: 'CONFIG',
+    useValue: {
+      apiUrl: 'https://api.example.com'
+    }
+  },
+  {
+    provide: AuthService,
+    useFactory: (context) => {
+      const config = inject(context, 'CONFIG');
+      return new AuthService(config);
+    }
+  }
+];
+
+// Provide the service
+provide(context, providers);
+
+// Inject and use the service
+const userService = inject(context, UserService);
+const user = userService.getUser('123');
+```
+
+### Override Providers
+
+```typescript
+import { override } from '@signe/di';
+
+// Override existing provider
+const newProviders = override(providers, {
+  provide: UserService,
+  useValue: new MockUserService()
+});
+
+// Add new provider with upsert option
+const updatedProviders = override(providers, {
+  provide: 'NEW_SERVICE',
+  useValue: service
+}, { upsert: true });
+```
+
+### Check Injection Status
+
+```typescript
+import { isInjected } from '@signe/di';
+
+if (isInjected(context, UserService)) {
+  // Service is already injected
+}
+```
+
+### Find Providers
+
+```typescript
+import { findProvider, findProviders } from '@signe/di';
+
+// Find single provider
+const userProvider = findProvider(providers, UserService);
+
+// Find multiple providers by regex
+const allServices = findProviders(providers, /Service$/);
+```
+
+## API Reference
+
+### `provide(context, key, value)`
+Stores a value in the context for dependency injection.
+
+### `inject(context, key)`
+Retrieves an injected value from the context.
+
+### `isInjected(context, key)`
+Checks if a value has been injected.
+
+### `override(providers, newProvider, options?)`
+Overrides or adds new providers to the existing provider array.
+
+### `findProvider(providers, query)`
+Finds a single provider by name or regex.
+
+### `findProviders(providers, query)`
+Finds all providers matching the query.
+
+## License
+
+MIT © Samuel Ronce

package/src/context.ts

@@ -0,0 +1,30 @@
+/**
+ * Context class for managing dependency injection state
+ * @module @signe/di/context
+ */
+
+/**
+ * Stores and manages the state of injected dependencies
+ */
+export class Context {
+    /** Internal storage for injected values */
+    private values: { [key: string]: any } = {}
+
+    /**
+     * Sets a value in the context
+     * @param key - Unique identifier for the value
+     * @param value - Value to store
+     */
+    set(key: string, value: any) {
+        this.values[key] = value
+    }
+
+    /**
+     * Retrieves a value from the context
+     * @param key - Unique identifier for the value
+     * @returns The stored value or undefined if not found
+     */
+    get(key: string) {
+        return this.values[key]
+    }
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+/**
+ * @signe/di - A lightweight dependency injection system
+ * @module @signe/di
+ * 
+ * @description
+ * This package provides a complete dependency injection system with the following features:
+ * - Type-safe dependency injection
+ * - Provider system with multiple configuration options
+ * - Context-based injection
+ * - Override capabilities for testing
+ * - Support for nested providers
+ * 
+ * @example
+ * ```typescript
+ * import { Context, provide, inject } from '@signe/di';
+ * 
+ * const context = new Context();
+ * provide(context, 'config', { apiUrl: 'http://api.example.com' });
+ * const config = inject(context, 'config');
+ * ```
+ */
+
+export * from "./inject";
+export * from "./types";
+export * from "./merge-config";
+export * from "./provider";
+export * from "./context";

package/src/inject.ts

@@ -0,0 +1,184 @@
+/**
+ * Core functionality for dependency injection
+ * @module @signe/di/inject
+ */
+
+import { Provider, Providers } from "./types";
+import { Context } from "./context";
+
+/**
+ * Provides a value to the dependency injection context
+ * @template T - Type of the value being provided
+ * @param context - The injection context
+ * @param name - Identifier for the provided value
+ * @param value - The value to provide
+ * @returns The provided value
+ */
+export function provide<T>(context: Context, name: string, value: T): T {
+  context.set("inject:" + name, value);
+  return value;
+}
+
+/**
+ * Checks if a service has been injected into the context
+ * @param context - The injection context
+ * @param name - Name of the service to check
+ * @returns True if the service has been injected, false otherwise
+ */
+export function isInjected(context: Context, name: string): boolean {
+  return context.get('injected:' + name) === true;
+}
+
+/**
+ * Retrieves a service from the dependency injection context
+ * @template T - Type of the service to inject
+ * @param context - The injection context
+ * @param service - Class constructor or string identifier of the service
+ * @param args - Optional arguments for service instantiation
+ * @returns The injected service instance
+ * @throws {Error} If the requested service is not found in the context
+ */
+export function inject<T>(
+  context: Context,
+  service: (new (...args: any[]) => T) | string,
+  args: any[] = []
+): T {
+  const isClass = typeof service === "function";
+  const name = isClass ? service.name : service;
+  const value = context.get("inject:" + name);
+  if (value) {
+    context.set('injected:' + name, true)
+    return value as T;
+  }
+  throw new Error(`Injection provider ${name} not found`);
+}
+
+/**
+ * Overrides or adds a provider in the providers array
+ * @param providers - Array of existing providers
+ * @param newProvider - Provider to add or replace with
+ * @param options - Configuration options
+ * @param options.upsert - If true, adds the provider when not found
+ * @param options.key - Custom key to identify the provider
+ * @returns Updated array of providers
+ */
+export function override(
+  providers: Providers,
+  newProvider: Provider,
+  options?: {
+    upsert?: boolean,
+    key?: string
+  }
+) {
+  let { upsert = false, key } = options ?? {};
+  if (!key) {
+    key = (
+      typeof newProvider === "function" ? newProvider.name : newProvider.provide
+    ) as string;
+  }
+
+  // Flatten the providers array
+  const flatProviders = providers.flat();
+  
+  // Check if provider exists
+  const exists = flatProviders.some(provider => {
+    if (typeof provider === "function") {
+      return provider.name === key;
+    } else if (typeof provider === "object") {
+      return (provider as any).provide === key;
+    }
+    return false;
+  });
+
+  // Map and replace if found
+  const mappedProviders = flatProviders.map((provider) => {
+    if (typeof provider === "function" && provider.name === key) {
+      return newProvider;
+    } else if (typeof provider === "object" && (provider as any).provide === key) {
+      return newProvider;
+    }
+    return provider;
+  });
+
+  // If upsert is true and provider wasn't found, add it to the end
+  if (upsert && !exists) {
+    mappedProviders.push(newProvider);
+  }
+
+  return mappedProviders;
+}
+
+/**
+ * Finds all providers matching the given name or pattern
+ * @template T - Type of provider to return
+ * @param providers - Array of providers to search
+ * @param name - String or RegExp to match against provider names
+ * @returns Array of matching providers
+ */
+export function findProviders<T extends Provider = Provider>(providers: Providers, name: string | RegExp): T[] {
+  const results: any[] = [];
+  
+  for (const provider of providers) {
+    if (Array.isArray(provider)) {
+      // Recursively search in nested arrays and concat results
+      results.push(...findProviders(provider, name));
+    } else if (findProvider(provider as any, name)) {
+      // Add matching provider to results
+      results.push(provider as T);
+    }
+  }
+  
+  return results;
+}
+
+/**
+ * Finds the first provider matching the given name or pattern
+ * @template T - Type of provider to return
+ * @param providers - Array of providers to search
+ * @param name - String or RegExp to match against provider names
+ * @returns Matching provider or null if not found
+ */
+export function findProvider<T extends Provider = Provider>(providers: Providers, name: string | RegExp): T | null {
+  // Handle single provider case
+  if (!Array.isArray(providers)) {
+    if (typeof providers === "object" && 'provide' in providers) {
+      const provider = providers as any
+      const providerName = typeof provider.provide === "function"
+        ? provider.provide.name 
+        : provider.provide;
+
+      if (name instanceof RegExp) {
+        if (name.test(providerName)) return providers as T;
+      } else {
+        if (providerName === name) return providers as T;
+      }
+    }
+    return null;
+  }
+
+  // Original array handling logic
+  for (const provider of providers) {
+    // If provider is an array, recursively search in it
+    if (Array.isArray(provider)) {
+      const found = findProvider(provider, name);
+      if (found) return found as T;
+      continue;
+    }
+
+    // Check object provider
+    if (typeof provider === "object" && 'provide' in provider) {
+      const providerName = typeof provider.provide === "function" 
+        ? provider.provide.name 
+        : provider.provide;
+
+      // Handle RegExp matching
+      if (name instanceof RegExp) {
+        if (name.test(providerName)) return provider as T;
+      } else {
+        // Handle exact string matching
+        if (providerName === name) return provider as T;
+      }
+    }
+  }
+  return null;
+}

package/src/merge-config.ts

@@ -0,0 +1,41 @@
+/**
+ * Configuration merging functionality for dependency injection
+ * @module @signe/di/merge-config
+ */
+
+import { findProvider, override } from "./inject";
+
+/**
+ * Application configuration interface
+ */
+export interface AppConfig {
+    /** Array of dependency providers */
+    providers: any[];
+    /** Optional static files configuration */
+    staticFiles?: {
+        /** Path to static files */
+        path: string;
+        /** Static file serving configuration */
+        serve: any;
+    }
+}
+
+/**
+ * Merges two application configurations
+ * @param baseConfig - Base configuration to merge into
+ * @param config - Configuration to merge with base
+ * @returns Merged configuration with providers properly combined
+ */
+export function mergeConfig(baseConfig: AppConfig, config: AppConfig): AppConfig {
+    const mergedConfig: AppConfig = {
+        ...baseConfig,
+        ...config
+    }
+    for (let provider of config.providers) {
+        const isFound = findProvider(baseConfig.providers, provider.provide)
+        if (!isFound) {
+            mergedConfig.providers = override(baseConfig.providers, provider, { upsert: true })
+        }
+    }
+    return mergedConfig;
+}

package/src/provider.ts

@@ -0,0 +1,71 @@
+/**
+ * Provider system implementation for dependency injection
+ * @module @signe/di/provider
+ */
+
+import { ClassProvider, Provider, Providers, ProviderToken } from "./types";
+import { inject, provide } from "./inject";
+import { Context } from "./context";
+
+/**
+ * Type guard to check if a provider is a ClassProvider
+ * @param provider - Provider to check
+ * @returns True if the provider is a ClassProvider
+ */
+function isClassProvider(provider: Provider): provider is ClassProvider {
+    if (typeof provider === 'string') {
+        return false;
+    }
+    return 'useClass' in provider && typeof provider.useClass === 'function';
+}
+
+/**
+ * Processes and instantiates all providers in the given context
+ * @param context - The injection context
+ * @param providers - Array of providers to process
+ * @returns Promise that resolves when all providers are processed
+ * 
+ * @example
+ * ```typescript
+ * const context = new Context();
+ * const providers = [
+ *   UserService,
+ *   { provide: 'CONFIG', useValue: { apiUrl: 'http://api.example.com' } },
+ *   { provide: AuthService, useFactory: (ctx) => new AuthService(ctx) }
+ * ];
+ * 
+ * await injector(context, providers);
+ * ```
+ */
+export async function injector(context: Context, providers: Providers) {
+    providers = providers.flat();
+    for (const provider of providers) {
+        let token: ProviderToken;
+        let instance: any;
+
+        if (typeof provider === 'function') {
+            // If provider is a class, treat it as a ClassProvider
+            token = provider;
+            instance = new provider(context);
+        } else {
+            token = (provider as any).provide;
+            const provideUserClass = (provider as any).useClass;
+            const isClass = typeof provideUserClass === 'function';
+            if (isClass) {
+                instance = new provideUserClass(context);
+            } else if ('useValue' in provider) {
+                instance = provider.useValue;
+            } else if ('useFactory' in provider) {
+                instance = provider.useFactory?.(context);
+                if (instance instanceof Promise) {
+                    instance = await instance;
+                }
+            } else if ('useExisting' in provider) {
+                instance = inject(context, provider.useExisting);
+            }
+        }
+
+        const name = typeof token === 'function' ? token.name : token;
+        provide(context, name, instance);
+    }
+}

package/src/types.ts

@@ -0,0 +1,80 @@
+/**
+ * Type definitions for the dependency injection system
+ * @module @signe/di/types
+ */
+
+/**
+ * Context object used for dependency injection
+ */
+export type ProviderContext = any;
+
+/**
+ * Token used to identify a provider. Can be either a class constructor or a string
+ */
+export type ProviderToken = (new (...args: any[]) => any) | string;
+
+/**
+ * Factory function type that creates instances using the provided context
+ * @param context - The injection context
+ * @returns The created instance
+ */
+export type FactoryFn = (context: ProviderContext) => any;
+
+/**
+ * Provider configuration for value-based injection
+ */
+export interface ValueProvider {
+  /** Token to identify the provider */
+  provide: ProviderToken;
+  /** Value to be injected */
+  useValue: any;
+}
+
+/**
+ * Provider configuration for class-based injection
+ */
+export interface ClassProvider {
+  /** Token to identify the provider */
+  provide: ProviderToken;
+  /** Class to be instantiated */
+  useClass: new (context: ProviderContext) => any;
+}
+
+/**
+ * Provider configuration for factory-based injection
+ */
+export interface FactoryProvider {
+  /** Token to identify the provider */
+  provide: ProviderToken;
+  /** Optional metadata for the provider */
+  meta?: {
+    [key: string]: any;
+  };
+  /** Factory function to create the instance */
+  useFactory: FactoryFn;
+}
+
+/**
+ * Provider configuration for alias-based injection
+ */
+export interface ExistingProvider {
+  /** Token to identify the provider */
+  provide: ProviderToken;
+  /** Token of the existing provider to use */
+  useExisting: ProviderToken;
+}
+
+/**
+ * Union type for all possible provider configurations
+ */
+export type Provider = 
+  | (new (...args: any[]) => any) // Allow direct class usage
+  | (ValueProvider & { useClass?: never, useFactory?: never, useExisting?: never })
+  | (ClassProvider & { useValue?: never, useFactory?: never, useExisting?: never })
+  | (FactoryProvider & { useValue?: never, useClass?: never, useExisting?: never })
+  | (ExistingProvider & { useValue?: never, useClass?: never, useFactory?: never });
+
+/**
+ * Array of providers that can be nested one level deep
+ */
+export type Providers = (Provider | Providers)[];