refactor(di): keep the deferred-loader provider internal to the container

A record carrying only a lazy-require loader resolves to an error until the
loader registers something onto it, so the form is not one callers should be
offered: drop ILazyRequireProvider from the exported Provider union and keep it
in an InternalProvider alias the container accepts.

Add hasResolver() so the deferred paths can tell a record that a loader has
filled in from one it left empty.

Author: edusperoni

lib/common/di/index.ts

@@ -12,6 +12,7 @@ export type { IContractOptions } from "./contract";
 export { provide, provideLazy } from "./providers";
 export type {
 	Provider,
+	InternalProvider,
 	ProviderToken,
 	Type,
 	AbstractType,

lib/common/di/injector.ts

@@ -2,7 +2,12 @@ import { annotate } from "../helpers";
 import { getContractName } from "./contract";
 import { resolveForwardRef } from "./forward-ref";
 import { runInInjectionContext } from "./inject";
-import type { Provider, ProviderToken, Type } from "./providers";
+import type {
+	InternalProvider,
+	Provider,
+	ProviderToken,
+	Type,
+} from "./providers";
 
 type TokenKey = string | Function;
 
@@ -131,7 +136,7 @@ export class Injector {
 	}
 
 	/** Merge-mutate: re-registering a key updates the existing record in place. */
-	public register(providers: Provider | Provider[]): void {
+	public register(providers: InternalProvider | InternalProvider[]): void {
 		const list = Array.isArray(providers) ? providers : [providers];
 		for (const provider of list) {
 			const keys = this.keysFor(provider.provide);
@@ -172,6 +177,16 @@ export class Injector {
 		return !!this.findRecord(token);
 	}
 
+	/**
+	 * Whether the token can actually produce a value. A record carrying only a
+	 * pending loader answers `has()` but resolves to an error, so the deferred
+	 * paths use this to tell "loaded and registered" from "loaded and silent".
+	 */
+	protected hasResolver(token: ProviderToken): boolean {
+		const found = this.findRecord(token);
+		return !!found && found.record.kind !== undefined;
+	}
+
 	/** First cached instance for a token, without triggering construction. */
 	public peek(token: ProviderToken): any {
 		const found = this.findRecord(token);
@@ -230,7 +245,10 @@ export class Injector {
 		return name !== undefined ? [token, name] : [token];
 	}
 
-	private applyProvider(record: IProviderRecord, provider: Provider): void {
+	private applyProvider(
+		record: IProviderRecord,
+		provider: InternalProvider,
+	): void {
 		record.shared = provider.shared === undefined ? true : provider.shared;
 
 		if ("useLazyRequire" in provider) {

lib/common/di/providers.ts

@@ -37,7 +37,9 @@ export interface ILegacyClassProvider extends IBaseProvider<any> {
 
 /**
  * Deferred side-effect loader (Yok's `require(name, path)`): running it is
- * expected to register the real resolver onto this same record.
+ * expected to register the real resolver onto this same record. Container
+ * internals only — a record left with nothing but a loader resolves to an
+ * error, so it is deliberately kept out of `Provider`.
  */
 export interface ILazyRequireProvider extends IBaseProvider<any> {
 	useLazyRequire: () => void;
@@ -48,8 +50,10 @@ export type Provider<T = any> =
 	| IValueProvider<T>
 	| IFactoryProvider<T>
 	| ILazyClassProvider<T>
-	| ILegacyClassProvider
-	| ILazyRequireProvider;
+	| ILegacyClassProvider;
+
+/** The provider forms the container accepts, including the unpublished ones. */
+export type InternalProvider<T = any> = Provider<T> | ILazyRequireProvider;
 
 /** Enforces at compile time that the implementation satisfies the token. */
 export const provide = <T>(