@mmstack/di 21.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present Miha J. Mulec
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,386 @@
+# @mmstack/di
+
+A collection of dependency injection utilities for Angular that simplify working with InjectionTokens and provide type-safe patterns for creating injectable services.
+
+[![npm version](https://badge.fury.io/js/%40mmstack%2Fdi.svg)](https://badge.fury.io/js/%40mmstack%2Fdi)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/mihajm/mmstack/blob/master/packages/di/LICENSE)
+
+## Installation
+
+```bash
+npm install @mmstack/di
+```
+
+## Utilities
+
+This library provides the following utilities:
+
+- `injectable` - Creates a typed InjectionToken with inject and provide helper functions for type-safe dependency injection.
+- `rootInjectable` - Creates a lazily-initialized root-level injectable that maintains a singleton instance.
+
+---
+
+## injectable
+
+Creates a typed InjectionToken with convenient, type-safe inject and provider functions, eliminating boilerplate and ensuring type safety throughout your dependency injection flow. It returns a tuple of `[injectFn, provideFn]` that work together seamlessly.
+
+The `injectable` function supports three patterns:
+
+1. **Basic** - Returns `T | null` when not provided
+2. **With Fallback** - Returns a default value when not provided, can be either
+3. **With Lazy Fallback** - Same as with fallback, but the fallback iz lazily evaluated, useful for expensive fallbacks or ones that require injection
+4. **With Error** - Throws a custom error message when not provided
+
+### Basic Usage
+
+```typescript
+import { Component, Injectable } from '@angular/core';
+import { injectable } from '@mmstack/di';
+
+// Create a typed injectable
+const [injectLogger, provideLogger] = injectable<Logger>('Logger');
+
+// Provide the value in a component or module
+@Component({
+  selector: 'app-root',
+  providers: [
+    provideLogger({
+      log: (msg) => console.log(`[LOG]: ${msg}`),
+      error: (msg) => console.error(`[ERROR]: ${msg}`),
+    }),
+  ],
+})
+export class AppComponent {}
+
+// Inject it anywhere in the component tree
+@Injectable()
+export class DataService {
+  private logger = injectLogger(); // Logger | null
+
+  fetchData() {
+    this.logger?.log('Fetching data...');
+  }
+}
+```
+
+### With Factory Dependencies
+
+```typescript
+import { HttpClient } from '@angular/common/http';
+import { injectable } from '@mmstack/di';
+
+interface ApiConfig {
+  baseUrl: string;
+  timeout: number;
+}
+
+const [injectApiConfig, provideApiConfig] = injectable<ApiConfig>('ApiConfig');
+
+// Provide using a factory with dependencies
+@Component({
+  providers: [
+    provideApiConfig(
+      (http: HttpClient) => ({
+        baseUrl: 'https://api.example.com',
+        timeout: 5000,
+      }),
+      [HttpClient], // Dependencies array
+    ),
+  ],
+})
+export class AppComponent {}
+```
+
+### With Fallback Value
+
+When you want to provide a default value instead of returning `null`:
+
+```typescript
+import { injectable } from '@mmstack/di';
+
+interface Theme {
+  primary: string;
+  secondary: string;
+}
+
+const [injectTheme, provideTheme] = injectable<Theme>('Theme', {
+  fallback: {
+    primary: '#007bff',
+    secondary: '#6c757d',
+  },
+});
+
+// or if you need inject/lazy evaluation
+const [injectTheme, provideTheme] = injectable<Theme>('Theme', {
+  lazyFallback: () => {
+    return {
+      primary: inject(APP_PRIMARY),
+      secondary: '#6c757d',
+    },
+  }
+});
+
+@Injectable()
+export class ThemeService {
+  // Always returns a Theme, never null
+  private theme = injectTheme();
+
+  getPrimaryColor() {
+    return this.theme.primary; // Safe to access
+  }
+}
+```
+
+### With Error Message
+
+When you want to enforce that the value must be provided:
+
+```typescript
+import { injectable } from '@mmstack/di';
+
+const [injectApiKey, provideApiKey] = injectable<string>('ApiKey', {
+  errorMessage: 'API Key is required! Please provide it using provideApiKey().',
+});
+
+@Injectable()
+export class ApiService {
+  // Throws error if not provided
+  private apiKey = injectApiKey();
+
+  makeRequest() {
+    // apiKey is guaranteed to exist here
+    return fetch(`https://api.example.com?key=${this.apiKey}`);
+  }
+}
+```
+
+### Providing Functions as Values
+
+The `provideFn` correctly handles functions as values (not factories):
+
+```typescript
+import { injectable } from '@mmstack/di';
+
+type Validator = (value: string) => boolean;
+
+const [injectValidator, provideValidator] = injectable<Validator>('Validator');
+
+@Component({
+  providers: [
+    // Providing a function as a value (not a factory)
+    provideValidator((value: string) => value.length > 5),
+  ],
+})
+export class FormComponent {
+  private validator = injectValidator();
+
+  validate(input: string) {
+    return this.validator?.(input) ?? false;
+  }
+}
+```
+
+### Advanced: Scoped Context Pattern
+
+Create context-like dependency injection patterns:
+
+```typescript
+import { Component, Injectable } from '@angular/core';
+import { injectable } from '@mmstack/di';
+
+interface FormContext {
+  formId: string;
+  isDirty: boolean;
+  submit: () => void;
+}
+
+const [injectFormContext, provideFormContext] = injectable<FormContext>('FormContext', {
+  errorMessage: 'FormContext must be provided by a parent form component',
+});
+
+@Component({
+  selector: 'app-form',
+  providers: [
+    provideFormContext({
+      formId: 'user-form',
+      isDirty: false,
+      submit: () => console.log('Submitting form...'),
+    }),
+  ],
+  template: `
+    <form>
+      <app-form-field></app-form-field>
+      <app-form-actions></app-form-actions>
+    </form>
+  `,
+})
+export class FormComponent {}
+
+@Component({
+  selector: 'app-form-field',
+  template: `<input [id]="formContext.formId + '-input'" />`,
+})
+export class FormFieldComponent {
+  // Automatically gets the context from parent
+  formContext = injectFormContext();
+}
+
+@Component({
+  selector: 'app-form-actions',
+  template: `<button (click)="formContext.submit()">Submit</button>`,
+})
+export class FormActionsComponent {
+  formContext = injectFormContext();
+}
+```
+
+---
+
+## rootInjectable
+
+Creates a lazily-initialized root-level injectable that maintains a singleton instance across your entire application. The factory function runs in the root injection context on first access, allowing you to inject other dependencies.
+
+**Important:** This should only be used for pure singletons. If you need scoped instances, use regular `@Injectable` services with `providedIn` or component-level providers.
+
+### Basic Usage
+
+```typescript
+import { Injectable } from '@angular/core';
+import { rootInjectable } from '@mmstack/di';
+
+interface Logger {
+  log: (message: string) => void;
+}
+
+// Create a root-level injectable
+const injectLogger = rootInjectable<Logger>(() => ({
+  log: (message) => console.log(`[${new Date().toISOString()}] ${message}`),
+}));
+
+@Injectable()
+export class DataService {
+  private logger = injectLogger();
+
+  fetchData() {
+    this.logger.log('Fetching data...');
+  }
+}
+
+@Injectable()
+export class UserService {
+  private logger = injectLogger(); // Same instance as above
+
+  saveUser() {
+    this.logger.log('Saving user...');
+  }
+}
+```
+
+### With Dependencies
+
+The factory function receives the root injector, allowing you to inject other services:
+
+```typescript
+import { HttpClient } from '@angular/common/http';
+import { rootInjectable } from '@mmstack/di';
+
+interface ApiClient {
+  get: (url: string) => Promise<any>;
+  post: (url: string, data: any) => Promise<any>;
+}
+
+const injectApiClient = rootInjectable<ApiClient>((injector) => {
+  const http = injector.get(HttpClient); // or just inject(HttpClient)
+
+  return {
+    get: (url) => fetch(url).then((r) => r.json()),
+    post: (url, data) =>
+      fetch(url, {
+        method: 'POST',
+        body: JSON.stringify(data),
+      }).then((r) => r.json()),
+  };
+});
+
+@Injectable()
+export class ProductService {
+  private api = injectApiClient(); // Singleton instance
+
+  loadProducts() {
+    return this.api.get('/api/products');
+  }
+}
+```
+
+### State Management Example
+
+Create a simple global state manager:
+
+```typescript
+import { signal, computed } from '@angular/core';
+import { rootInjectable } from '@mmstack/di';
+
+interface User {
+  id: string;
+  name: string;
+  email: string;
+}
+
+interface AuthState {
+  user: User | null;
+  isAuthenticated: boolean;
+}
+
+const injectAuthStore = rootInjectable(() => {
+  const user = signal<User | null>(null);
+  const isAuthenticated = computed(() => user() !== null);
+
+  return {
+    user: user.asReadonly(),
+    isAuthenticated,
+    login: (userData: User) => user.set(userData),
+    logout: () => user.set(null),
+  };
+});
+
+@Injectable()
+export class AuthService {
+  private store = injectAuthStore(); // Singleton across app
+
+  login(email: string, password: string) {
+    // Perform authentication...
+    this.store.login({
+      id: '123',
+      name: 'John Doe',
+      email,
+    });
+  }
+
+  logout() {
+    this.store.logout();
+  }
+}
+
+@Component({
+  selector: 'app-navbar',
+  template: `
+    @if (authStore.isAuthenticated()) {
+      <span>{{ authStore.user()?.name }}</span>
+      <button (click)="logout()">Logout</button>
+    }
+  `,
+})
+export class NavbarComponent {
+  authStore = injectAuthStore(); // Same instance
+
+  logout() {
+    this.authStore.logout();
+  }
+}
+```
+
+---
+
+## License
+
+MIT © [Miha Mulec](https://github.com/mihajm)

package/fesm2022/mmstack-di.mjs

@@ -0,0 +1,93 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injector, runInInjectionContext, Injectable } from '@angular/core';
+
+function injectable(token, opt) {
+    const injectionToken = new InjectionToken(token);
+    const options = opt;
+    let fallback = options?.fallback;
+    const initFallback = options?.lazyFallback ?? (() => options?.fallback ?? null);
+    const fallbackFn = () => {
+        if (fallback === undefined)
+            fallback = initFallback();
+        return fallback;
+    };
+    const injectFn = (iOpt) => {
+        const injected = inject(injectionToken, {
+            ...iOpt,
+            optional: true,
+        }) ?? fallbackFn();
+        if (injected === null && options?.errorMessage)
+            throw new Error(options.errorMessage);
+        return injected;
+    };
+    const provideFn = (fnOrValue, deps) => {
+        if (deps !== undefined)
+            return {
+                provide: injectionToken,
+                useFactory: fnOrValue,
+                deps,
+            };
+        return {
+            provide: injectionToken,
+            useValue: fnOrValue,
+        };
+    };
+    return [injectFn, provideFn];
+}
+
+function generateID() {
+    if (globalThis.crypto?.randomUUID) {
+        return globalThis.crypto.randomUUID();
+    }
+    return Math.random().toString(36).substring(2);
+}
+class RootInjectables {
+    injector = inject(Injector);
+    registry = {};
+    register(register) {
+        let key = generateID();
+        while (this.registry[key]) {
+            key = generateID();
+        }
+        const injector = this.injector;
+        const value = runInInjectionContext(this.injector, () => register(injector));
+        this.registry[key] = value;
+        return key;
+    }
+    get(key) {
+        return this.registry[key];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.8", ngImport: i0, type: RootInjectables, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.8", ngImport: i0, type: RootInjectables, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.8", ngImport: i0, type: RootInjectables, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+/**
+ * Creates a lazily-initialized root-level injectable that maintains a singleton instance.
+ * The factory function runs in the root injection context on first access.
+ * This should only be used for pure singletons, if you need scoped instances use regular @Injectable services.
+ *
+ * @param register - Factory function that creates the injectable instance using the root injector
+ * @returns An inject function that returns the singleton instance
+ */
+function rootInjectable(register) {
+    let key = null;
+    return () => {
+        const registry = inject(RootInjectables);
+        if (!key) {
+            key = registry.register(register);
+        }
+        return registry.get(key);
+    };
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { injectable, rootInjectable };
+//# sourceMappingURL=mmstack-di.mjs.map

package/fesm2022/mmstack-di.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mmstack-di.mjs","sources":["../../../../packages/di/src/lib/injectable.ts","../../../../packages/di/src/lib/root-injectable.ts","../../../../packages/di/src/mmstack-di.ts"],"sourcesContent":["import {\n  inject,\n  InjectionToken,\n  type AbstractType,\n  type InjectOptions,\n  type Provider,\n  type Type,\n} from '@angular/core';\n\ntype ServiceType<T> =\n  T extends Type<infer U>\n    ? U\n    : T extends AbstractType<infer U>\n      ? U\n      : T extends InjectionToken<infer U>\n        ? U\n        : never;\n\ntype MapDeps<T extends readonly any[]> = {\n  [K in keyof T]: ServiceType<T[K]>;\n};\n\ntype ProviderFn<T> = {\n  (value: T): Provider;\n  <const TDeps extends any[]>(\n    fn: (...deps: MapDeps<TDeps>) => T,\n    deps: TDeps,\n  ): Provider;\n};\n\ntype InjectFns<T> = [\n  (opt?: Omit<InjectOptions, 'optional'>) => T,\n  ProviderFn<T>,\n];\n\ntype FallbackInjectableOptions<T> = {\n  /** Default value returned when the injectable is not provided */\n  fallback: T;\n};\n\ntype LazyFallbackInjectableOptions<T> = {\n  /** Function that returns a default value when the injectable is not provided. Useful for expensive defaults. */\n  lazyFallback: () => T;\n};\n\ntype ErrorMessageInjectableOptions = {\n  /** Error message thrown when the injectable is not provided */\n  errorMessage: string;\n};\n\ntype InjectableOptions<T> =\n  | FallbackInjectableOptions<T>\n  | LazyFallbackInjectableOptions<T>\n  | ErrorMessageInjectableOptions;\n\n/**\n * Creates a typed InjectionToken with inject and provide helper functions.\n *\n * @param token - Unique token identifier\n * @param opt - Optional configuration for fallback value or error message\n * @returns A tuple of [injectFn, provideFn] for type-safe dependency injection\n */\nexport function injectable<T>(token: string): InjectFns<T | null>;\n\n/**\n * Creates a typed InjectionToken with inject and provide helper functions.\n * Returns a fallback value when the injectable is not provided.\n *\n * @param token - Unique token identifier\n * @param opt - Configuration with fallback value\n * @returns A tuple of [injectFn, provideFn] for type-safe dependency injection\n */\nexport function injectable<T>(\n  token: string,\n  opt: FallbackInjectableOptions<T>,\n): InjectFns<T>;\n\n/**\n *\n * Creates a typed InjectionToken with inject and provide helper functions.\n * Returns a lazily evaluated fallback value when the injectable is not provided.\n *\n * @param token\n * @param opt\n */\nexport function injectable<T>(\n  token: string,\n  opt: LazyFallbackInjectableOptions<T>,\n): InjectFns<T>;\n\n/**\n * Creates a typed InjectionToken with inject and provide helper functions.\n * Throws an error with a custom message when the injectable is not provided.\n *\n * @param token - Unique token identifier\n * @param opt - Configuration with error message\n * @returns A tuple of [injectFn, provideFn] for type-safe dependency injection\n */\nexport function injectable<T>(\n  token: string,\n  opt: ErrorMessageInjectableOptions,\n): InjectFns<T>;\n\nexport function injectable<T>(\n  token: string,\n  opt?: InjectableOptions<T>,\n): InjectFns<T> {\n  const injectionToken = new InjectionToken<T>(token);\n\n  const options = opt as\n    | Partial<\n        FallbackInjectableOptions<T> &\n          LazyFallbackInjectableOptions<T> &\n          ErrorMessageInjectableOptions\n      >\n    | undefined;\n\n  let fallback: T | undefined | null = options?.fallback;\n\n  const initFallback =\n    options?.lazyFallback ?? (() => options?.fallback ?? null);\n\n  const fallbackFn = () => {\n    if (fallback === undefined) fallback = initFallback();\n    return fallback;\n  };\n\n  const injectFn = (iOpt?: Omit<InjectOptions, 'optional'>) => {\n    const injected =\n      inject(injectionToken, {\n        ...iOpt,\n        optional: true,\n      }) ?? fallbackFn();\n\n    if (injected === null && options?.errorMessage)\n      throw new Error(options.errorMessage);\n\n    return injected as T;\n  };\n\n  const provideFn = (\n    fnOrValue: T | ((...deps: any[]) => T),\n    deps?: any[],\n  ): Provider => {\n    if (deps !== undefined)\n      return {\n        provide: injectionToken,\n        useFactory: fnOrValue as (...args: any[]) => T,\n        deps,\n      };\n\n    return {\n      provide: injectionToken,\n      useValue: fnOrValue,\n    };\n  };\n\n  return [injectFn, provideFn];\n}\n","import {\n  inject,\n  Injectable,\n  Injector,\n  runInInjectionContext,\n} from '@angular/core';\n\nfunction generateID() {\n  if (globalThis.crypto?.randomUUID) {\n    return globalThis.crypto.randomUUID();\n  }\n  return Math.random().toString(36).substring(2);\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class RootInjectables {\n  private readonly injector = inject(Injector);\n  private readonly registry: Record<string, any> = {};\n\n  register<T>(register: (injector: Injector) => T): string {\n    let key = generateID();\n\n    while (this.registry[key]) {\n      key = generateID();\n    }\n\n    const injector = this.injector;\n\n    const value = runInInjectionContext(this.injector, () =>\n      register(injector),\n    );\n    this.registry[key] = value;\n\n    return key;\n  }\n\n  get<T>(key: string): T {\n    return this.registry[key];\n  }\n}\n\n/**\n * Creates a lazily-initialized root-level injectable that maintains a singleton instance.\n * The factory function runs in the root injection context on first access.\n * This should only be used for pure singletons, if you need scoped instances use regular @Injectable services.\n *\n * @param register - Factory function that creates the injectable instance using the root injector\n * @returns An inject function that returns the singleton instance\n */\nexport function rootInjectable<T>(\n  register: (injector: Injector) => T,\n): () => T {\n  let key: string | null = null;\n  return () => {\n    const registry = inject(RootInjectables);\n    if (!key) {\n      key = registry.register(register);\n    }\n    return registry.get<T>(key);\n  };\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@mmstack/di",
+  "version": "21.0.0",
+  "peerDependencies": {
+    "@angular/core": ">=21 <22"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/mmstack-di.mjs",
+  "typings": "types/mmstack-di.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/mmstack-di.d.ts",
+      "default": "./fesm2022/mmstack-di.mjs"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}

package/types/mmstack-di.d.ts

@@ -0,0 +1,73 @@
+import { InjectOptions, Provider, Type, AbstractType, InjectionToken, Injector } from '@angular/core';
+
+type ServiceType<T> = T extends Type<infer U> ? U : T extends AbstractType<infer U> ? U : T extends InjectionToken<infer U> ? U : never;
+type MapDeps<T extends readonly any[]> = {
+    [K in keyof T]: ServiceType<T[K]>;
+};
+type ProviderFn<T> = {
+    (value: T): Provider;
+    <const TDeps extends any[]>(fn: (...deps: MapDeps<TDeps>) => T, deps: TDeps): Provider;
+};
+type InjectFns<T> = [
+    (opt?: Omit<InjectOptions, 'optional'>) => T,
+    ProviderFn<T>
+];
+type FallbackInjectableOptions<T> = {
+    /** Default value returned when the injectable is not provided */
+    fallback: T;
+};
+type LazyFallbackInjectableOptions<T> = {
+    /** Function that returns a default value when the injectable is not provided. Useful for expensive defaults. */
+    lazyFallback: () => T;
+};
+type ErrorMessageInjectableOptions = {
+    /** Error message thrown when the injectable is not provided */
+    errorMessage: string;
+};
+/**
+ * Creates a typed InjectionToken with inject and provide helper functions.
+ *
+ * @param token - Unique token identifier
+ * @param opt - Optional configuration for fallback value or error message
+ * @returns A tuple of [injectFn, provideFn] for type-safe dependency injection
+ */
+declare function injectable<T>(token: string): InjectFns<T | null>;
+/**
+ * Creates a typed InjectionToken with inject and provide helper functions.
+ * Returns a fallback value when the injectable is not provided.
+ *
+ * @param token - Unique token identifier
+ * @param opt - Configuration with fallback value
+ * @returns A tuple of [injectFn, provideFn] for type-safe dependency injection
+ */
+declare function injectable<T>(token: string, opt: FallbackInjectableOptions<T>): InjectFns<T>;
+/**
+ *
+ * Creates a typed InjectionToken with inject and provide helper functions.
+ * Returns a lazily evaluated fallback value when the injectable is not provided.
+ *
+ * @param token
+ * @param opt
+ */
+declare function injectable<T>(token: string, opt: LazyFallbackInjectableOptions<T>): InjectFns<T>;
+/**
+ * Creates a typed InjectionToken with inject and provide helper functions.
+ * Throws an error with a custom message when the injectable is not provided.
+ *
+ * @param token - Unique token identifier
+ * @param opt - Configuration with error message
+ * @returns A tuple of [injectFn, provideFn] for type-safe dependency injection
+ */
+declare function injectable<T>(token: string, opt: ErrorMessageInjectableOptions): InjectFns<T>;
+
+/**
+ * Creates a lazily-initialized root-level injectable that maintains a singleton instance.
+ * The factory function runs in the root injection context on first access.
+ * This should only be used for pure singletons, if you need scoped instances use regular @Injectable services.
+ *
+ * @param register - Factory function that creates the injectable instance using the root injector
+ * @returns An inject function that returns the singleton instance
+ */
+declare function rootInjectable<T>(register: (injector: Injector) => T): () => T;
+
+export { injectable, rootInjectable };