@mmstack/di 19.3.0 → 20.5.0

package/fesm2022/mmstack-di.mjs

@@ -57,10 +57,10 @@ class RootInjectables {
     get(key) {
         return this.registry[key];
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: RootInjectables, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: RootInjectables, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: RootInjectables, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: RootInjectables, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: RootInjectables, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: RootInjectables, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',

package/index.d.ts

@@ -1,2 +1,73 @@
-export * from './lib/injectable';
-export { rootInjectable } from './lib/root-injectable';
+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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmstack/di",
-  "version": "19.3.0",
+  "version": "20.5.0",
   "keywords": [
     "angular",
     "dependency injection",
@@ -16,7 +16,7 @@
   },
   "homepage": "https://github.com/mihajm/mmstack/blob/master/packages/di",
   "peerDependencies": {
-    "@angular/core": ">=19 <20"
+    "@angular/core": ">=20 <21"
   },
   "sideEffects": false,
   "module": "fesm2022/mmstack-di.mjs",

package/lib/injectable.d.ts

@@ -1,61 +0,0 @@
-import { InjectionToken, type AbstractType, type InjectOptions, type Provider, type Type } 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
- */
-export 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
- */
-export 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
- */
-export 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
- */
-export declare function injectable<T>(token: string, opt: ErrorMessageInjectableOptions): InjectFns<T>;
-export {};

package/lib/root-injectable.d.ts

@@ -1,19 +0,0 @@
-import { Injector } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare class RootInjectables {
-    private readonly injector;
-    private readonly registry;
-    register<T>(register: (injector: Injector) => T): string;
-    get<T>(key: string): T;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RootInjectables, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<RootInjectables>;
-}
-/**
- * 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
- */
-export declare function rootInjectable<T>(register: (injector: Injector) => T): () => T;