static-injector 1.0.9 → 2.0.0

package/import/typings/di/create_injector.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Injector } from './injector';
+import { StaticProvider } from './interface/provider';
+import { R3Injector } from './r3_injector';
+import { InjectorScope } from './scope';
+/**
+ * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
+ *
+ * @publicApi
+ */
+export declare function createInjector(defType: any, parent?: Injector | null, additionalProviders?: StaticProvider[] | null, name?: string): Injector;
+/**
+ * Creates a new injector without eagerly resolving its injector types. Can be used in places
+ * where resolving the injector types immediately can lead to an infinite loop. The injector types
+ * should be resolved at a later point by calling `_resolveInjectorDefTypes`.
+ */
+export declare function createInjectorWithoutInjectorInstances(defType: any, parent?: Injector | null, additionalProviders?: StaticProvider[] | null, name?: string, scopes?: Set<InjectorScope>): R3Injector;

package/import/typings/di/initializer_token.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { InjectionToken } from './injection_token';
+/**
+ * A multi-provider token for initialization functions that will run upon construction of an
+ * environment injector.
+ *
+ * @publicApi
+ */
+export declare const ENVIRONMENT_INITIALIZER: InjectionToken<() => void>;

package/import/typings/di/inject_switch.d.ts

@@ -5,8 +5,13 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { InjectFlags } from "./interface/injector";
-import { ProviderToken } from "./provider_token";
+import { InjectFlags } from './interface/injector';
+import { ProviderToken } from './provider_token';
+export declare function getInjectImplementation(): <T>(token: ProviderToken<T>, flags?: InjectFlags) => T;
+/**
+ * Sets the current inject implementation.
+ */
+export declare function setInjectImplementation(impl: (<T>(token: ProviderToken<T>, flags?: InjectFlags) => T | null) | undefined): (<T>(token: ProviderToken<T>, flags?: InjectFlags) => T | null) | undefined;
 /**
  * Injects `root` tokens in limp mode.
  *

package/import/typings/{decorator → di}/injectable.d.ts

@@ -5,9 +5,9 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+import { ValueSansProvider, ExistingSansProvider, StaticClassSansProvider, ConstructorSansProvider, FactorySansProvider, ClassSansProvider } from './interface/provider';
 import { Type } from '../interface/type';
 import { TypeDecorator } from '../util/decorators';
-import { ClassSansProvider, ConstructorSansProvider, ExistingSansProvider, FactorySansProvider, StaticClassSansProvider, ValueSansProvider } from './interface/provider';
 /**
  * Injectable providers used in `@Injectable` decorator.
  *

package/import/typings/di/injection_token.d.ts

@@ -53,5 +53,9 @@ export declare class InjectionToken<T> {
         providedIn?: Type<any> | 'root' | 'platform' | 'any' | null;
         factory: () => T;
     });
+    /**
+     * @internal
+     */
+    get multi(): InjectionToken<Array<T>>;
     toString(): string;
 }

package/import/typings/di/injector.d.ts

@@ -6,11 +6,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { InjectorMarkers } from './injector_marker';
-import { InjectFlags } from './interface/injector';
+import { InjectFlags, InjectOptions } from './interface/injector';
 import { StaticProvider } from './interface/provider';
 import { ProviderToken } from './provider_token';
-export declare function INJECTOR_IMPL__POST_R3__(providers: StaticProvider[], parent: Injector | undefined, name: string): Injector;
-export declare const INJECTOR_IMPL: typeof INJECTOR_IMPL__POST_R3__;
 /**
  * Concrete injectors implement this interface. Injectors are configured
  * with [providers](guide/glossary#provider) that associate
@@ -38,17 +36,32 @@ export declare const INJECTOR_IMPL: typeof INJECTOR_IMPL__POST_R3__;
 export declare abstract class Injector {
     static THROW_IF_NOT_FOUND: {};
     static NULL: Injector;
+    /**
+     * Internal note on the `options?: InjectOptions|InjectFlags` override of the `get`
+     * method: consider dropping the `InjectFlags` part in one of the major versions.
+     * It can **not** be done in minor/patch, since it's breaking for custom injectors
+     * that only implement the old `InjectorFlags` interface.
+     */
+    /**
+     * Retrieves an instance from the injector based on the provided token.
+     * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
+     * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
+     */
+    abstract get<T>(token: ProviderToken<T>, notFoundValue: undefined, options: InjectOptions & {
+        optional?: false;
+    }): T;
     /**
      * Retrieves an instance from the injector based on the provided token.
      * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
      * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
      */
-    abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
+    abstract get<T>(token: ProviderToken<T>, notFoundValue: null | undefined, options: InjectOptions): T | null;
     /**
-     * @deprecated from v4.0.0 use ProviderToken<T>
-     * @suppress {duplicate}
+     * Retrieves an instance from the injector based on the provided token.
+     * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
+     * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
      */
-    abstract get(token: any, notFoundValue?: any): any;
+    abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions | InjectFlags): T;
     /**
      * Creates a new injector instance that provides one or more dependencies,
      * according to a given type or types of `StaticProvider`.

package/import/typings/di/injector_compatibility.d.ts

@@ -5,9 +5,9 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { Injector } from "./injector";
-import { DecoratorFlags, InjectFlags, InternalInjectFlags } from "./interface/injector";
-import { ProviderToken } from "./provider_token";
+import { Injector } from './injector';
+import { DecoratorFlags, InjectFlags, InjectOptions, InternalInjectFlags } from './interface/injector';
+import { ProviderToken } from './provider_token';
 export declare const THROW_IF_NOT_FOUND: {};
 export declare const NG_TEMP_TOKEN_PATH = "ngTempTokenPath";
 export declare const SOURCE = "__source";
@@ -31,30 +31,51 @@ export declare function injectInjectorOnly<T>(token: ProviderToken<T>, flags?: I
 export declare function ɵɵinject<T>(token: ProviderToken<T>): T;
 export declare function ɵɵinject<T>(token: ProviderToken<T>, flags?: InjectFlags): T | null;
 /**
- * Injects a token from the currently active injector.
+ * @param token A token that represents a dependency that should be injected.
+ * @returns the injected value if operation is successful, `null` otherwise.
+ * @throws if called outside of a supported context.
  *
- * Must be used in the context of a factory function such as one defined for an
- * `InjectionToken`. Throws an error if not called from such a context.
- *
- * Within such a factory function, using this function to request injection of a dependency
- * is faster and more type-safe than providing an additional array of dependencies
- * (as has been common with `useFactory` providers).
- *
- * @param token The injection token for the dependency to be injected.
- * @param flags Optional flags that control how injection is executed.
- * The flags correspond to injection strategies that can be specified with
- * parameter decorators `@Host`, `@Self`, `@SkipSef`, and `@Optional`.
- * @returns the injected value if injection is successful, `null` otherwise.
- *
- * @usageNotes
+ * @publicApi
+ */
+export declare function inject<T>(token: ProviderToken<T>): T;
+/**
+ * @param token A token that represents a dependency that should be injected.
+ * @param flags Control how injection is executed. The flags correspond to injection strategies that
+ *     can be specified with parameter decorators `@Host`, `@Self`, `@SkipSelf`, and `@Optional`.
+ * @returns the injected value if operation is successful, `null` otherwise.
+ * @throws if called outside of a supported context.
  *
- * ### Example
+ * @publicApi
+ * @deprecated prefer an options object instead of `InjectFlags`
+ */
+export declare function inject<T>(token: ProviderToken<T>, flags?: InjectFlags): T | null;
+/**
+ * @param token A token that represents a dependency that should be injected.
+ * @param options Control how injection is executed. Options correspond to injection strategies
+ *     that can be specified with parameter decorators `@Host`, `@Self`, `@SkipSelf`, and
+ *     `@Optional`.
+ * @returns the injected value if operation is successful.
+ * @throws if called outside of a supported context, or if the token is not found.
  *
- * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}
+ * @publicApi
+ */
+export declare function inject<T>(token: ProviderToken<T>, options: InjectOptions & {
+    optional?: false;
+}): T;
+/**
+ * @param token A token that represents a dependency that should be injected.
+ * @param options Control how injection is executed. Options correspond to injection strategies
+ *     that can be specified with parameter decorators `@Host`, `@Self`, `@SkipSelf`, and
+ *     `@Optional`.
+ * @returns the injected value if operation is successful,  `null` if the token is not
+ *     found and optional injection has been requested.
+ * @throws if called outside of a supported context, or if the token is not found and optional
+ *     injection was not requested.
  *
  * @publicApi
  */
-export declare const inject: typeof ɵɵinject;
+export declare function inject<T>(token: ProviderToken<T>, options: InjectOptions): T | null;
+export declare function convertToBitFlags(flags: InjectOptions | InjectFlags | undefined): InjectFlags | undefined;
 export declare function injectArgs(types: (ProviderToken<any> | any[])[]): any[];
 /**
  * Attaches a given InjectFlag to a given decorator using monkey-patching.

package/import/typings/di/interface/defs.d.ts

@@ -153,3 +153,13 @@ export declare function ɵɵdefineInjector(options: {
  */
 export declare function getInjectableDef<T>(type: any): ɵɵInjectableDeclaration<T> | null;
 export declare const NG_PROV_DEF: string;
+/**
+ * Read the injectable def (`ɵprov`) for `type` or read the `ɵprov` from one of its ancestors.
+ *
+ * @param type A type which may have `ɵprov`, via inheritance.
+ *
+ * @deprecated Will be removed in a future version of Angular, where an error will occur in the
+ *     scenario if we find the `ɵprov` on an ancestor only.
+ */
+export declare function getInheritedInjectableDef<T>(type: any): ɵɵInjectableDeclaration<T> | null;
+export declare const NG_INJECTABLE_DEF: string;

package/import/typings/di/interface/injector.d.ts

@@ -17,6 +17,7 @@ export declare const enum DecoratorFlags {
  * Injection flags for DI.
  *
  * @publicApi
+ * @deprecated use an options object for `inject` instead.
  */
 export declare enum InjectFlags {
     /** Check self and check parent injector if needed */
@@ -46,3 +47,28 @@ export declare const enum InternalInjectFlags {
     /** Inject `defaultValue` instead if token not found. */
     Optional = 8
 }
+/**
+ * Type of the options argument to `inject`.
+ *
+ * @publicApi
+ */
+export interface InjectOptions {
+    /**
+     * Use optional injection, and return `null` if the requested token is not found.
+     */
+    optional?: boolean;
+    /**
+     * Start injection at the parent of the current injector.
+     */
+    skipSelf?: boolean;
+    /**
+     * Only query the current injector for the token, and don't fall back to the parent injector if
+     * it's not found.
+     */
+    self?: boolean;
+    /**
+     * Stop injection at the host component's injector. Only relevant when injecting from an element
+     * injector, and a no-op for environment injectors.
+     */
+    host?: boolean;
+}

package/import/typings/di/interface/provider.d.ts

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { Type } from "../../interface/type";
+import { Type } from '../../interface/type';
 /**
  * Configures the `Injector` to return a value for a token.
  * Base for `ValueProvider` decorator.
@@ -305,8 +305,3 @@ export interface ClassProvider extends ClassSansProvider {
  * @publicApi
  */
 export declare type Provider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | any[];
-/**
- * Describes a function that is used to process provider lists (such as provider
- * overrides).
- */
-export declare type ProcessProvidersFunction = (providers: Provider[]) => Provider[];

package/import/typings/di/internal_tokens.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Type } from '../interface/type';
+import { InjectionToken } from './injection_token';
+export declare const INJECTOR_DEF_TYPES: InjectionToken<Type<unknown>>;

package/import/typings/di/provider_collection.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Type } from '../interface/type';
+import { InjectorTypeWithProviders } from './interface/defs';
+import { ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, TypeProvider, ValueProvider } from './interface/provider';
+/**
+ * Internal type for a single provider in a deep provider array.
+ */
+export declare type SingleProvider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | StaticClassProvider;
+/**
+ * The logic visits an `InjectorType`, an `InjectorTypeWithProviders`, or a standalone
+ * `ComponentType`, and all of its transitive providers and collects providers.
+ *
+ * If an `InjectorTypeWithProviders` that declares providers besides the type is specified,
+ * the function will return "true" to indicate that the providers of the type definition need
+ * to be processed. This allows us to process providers of injector types after all imports of
+ * an injector definition are processed. (following View Engine semantics: see FW-1349)
+ */
+export declare function walkProviderTree(container: Type<unknown> | InjectorTypeWithProviders<unknown>, providersOut: SingleProvider[], parents: Type<unknown>[], dedup: Set<Type<unknown>>): container is InjectorTypeWithProviders<unknown>;
+export declare const USE_VALUE: string;
+export declare function isValueProvider(value: SingleProvider): value is ValueProvider;
+export declare function isExistingProvider(value: SingleProvider): value is ExistingProvider;
+export declare function isFactoryProvider(value: SingleProvider): value is FactoryProvider;
+export declare function isTypeProvider(value: SingleProvider): value is TypeProvider;
+export declare function isClassProvider(value: SingleProvider): value is ClassProvider;

package/import/typings/di/r3_injector.d.ts

@@ -7,53 +7,91 @@
  */
 import { Injector } from './injector';
 import { InjectorType } from './interface/defs';
-import { InjectFlags } from './interface/injector';
-import { ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, StaticProvider, TypeProvider, ValueProvider } from './interface/provider';
+import { InjectFlags, InjectOptions } from './interface/injector';
+import { ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, Provider, StaticClassProvider, TypeProvider, ValueProvider } from './interface/provider';
 import { ProviderToken } from './provider_token';
+import { InjectorScope } from './scope';
 /**
  * Internal type for a single provider in a deep provider array.
  */
 declare type SingleProvider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | StaticClassProvider;
+export declare function getNullInjector(): Injector;
 /**
- * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
- *
- * @publicApi
- */
-export declare function createInjector(defType: any, parent?: Injector | null, additionalProviders?: StaticProvider[] | null, name?: string): Injector;
-/**
- * Creates a new injector without eagerly resolving its injector types. Can be used in places
- * where resolving the injector types immediately can lead to an infinite loop. The injector types
- * should be resolved at a later point by calling `_resolveInjectorDefTypes`.
+ * An `Injector` that's part of the environment injector hierarchy, which exists outside of the
+ * component tree.
  */
-export declare function createInjectorWithoutInjectorInstances(defType: any, parent?: Injector | null, additionalProviders?: StaticProvider[] | null, name?: string): R3Injector;
-export declare class R3Injector {
+export declare abstract class EnvironmentInjector implements Injector {
+    /**
+     * Retrieves an instance from the injector based on the provided token.
+     * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
+     * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
+     */
+    abstract get<T>(token: ProviderToken<T>, notFoundValue: undefined, options: InjectOptions & {
+        optional?: false;
+    }): T;
+    /**
+     * Retrieves an instance from the injector based on the provided token.
+     * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
+     * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
+     */
+    abstract get<T>(token: ProviderToken<T>, notFoundValue: null | undefined, options: InjectOptions): T | null;
+    /**
+     * Retrieves an instance from the injector based on the provided token.
+     * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
+     * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
+     */
+    abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions): T;
+    /**
+     * Retrieves an instance from the injector based on the provided token.
+     * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
+     * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
+     * @deprecated use object-based flags (`InjectOptions`) instead.
+     */
+    abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
+    /**
+     * @deprecated from v4.0.0 use ProviderToken<T>
+     * @suppress {duplicate}
+     */
+    abstract get(token: any, notFoundValue?: any): any;
+    /**
+     * Runs the given function in the context of this `EnvironmentInjector`.
+     *
+     * Within the function's stack frame, `inject` can be used to inject dependencies from this
+     * injector. Note that `inject` is only usable synchronously, and cannot be used in any
+     * asynchronous callbacks or after any `await` points.
+     *
+     * @param fn the closure to be run in the context of this injector
+     * @returns the return value of the function, if any
+     */
+    abstract runInContext<ReturnT>(fn: () => ReturnT): ReturnT;
+    abstract destroy(): void;
+    /**
+     * @internal
+     */
+    abstract onDestroy(callback: () => void): void;
+}
+export declare class R3Injector extends EnvironmentInjector {
     readonly parent: Injector;
+    readonly source: string | null;
+    readonly scopes: Set<InjectorScope>;
     /**
      * Map of tokens to records which contain the instances of those tokens.
      * - `null` value implies that we don't have the record. Used by tree-shakable injectors
      * to prevent further searches.
      */
     private records;
-    /**
-     * The transitive set of `InjectorType`s which define this injector.
-     */
-    private injectorDefTypes;
     /**
      * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.
      */
-    private onDestroy;
-    /**
-     * Flag indicating this injector provides the APP_ROOT_SCOPE token, and thus counts as the
-     * root scope.
-     */
-    private readonly scope;
-    readonly source: string | null;
+    private _ngOnDestroyHooks;
+    private _onDestroyHooks;
     /**
      * Flag indicating that this injector was previously destroyed.
      */
     get destroyed(): boolean;
     private _destroyed;
-    constructor(def: InjectorType<any>, additionalProviders: StaticProvider[] | null, parent: Injector, source?: string | null);
+    private injectorDefTypes;
+    constructor(providers: Array<Provider>, parent: Injector, source: string | null, scopes: Set<InjectorScope>);
     /**
      * Destroy the injector and release references to every instance or provider associated with it.
      *
@@ -61,20 +99,13 @@ export declare class R3Injector {
      * hook was found.
      */
     destroy(): void;
-    get<T>(token: ProviderToken<T>, notFoundValue?: any, flags?: InjectFlags): T;
+    onDestroy(callback: () => void): void;
+    runInContext<ReturnT>(fn: () => ReturnT): ReturnT;
+    get<T>(token: ProviderToken<T>, notFoundValue?: any, flags?: InjectFlags | InjectOptions): T;
     /** @internal */
-    _resolveInjectorDefTypes(): void;
+    resolveInjectorInitializers(): void;
     toString(): string;
     private assertNotDestroyed;
-    /**
-     * Add an `InjectorType` or `InjectorTypeWithProviders` and all of its transitive providers
-     * to this injector.
-     *
-     * If an `InjectorTypeWithProviders` that declares providers besides the type is specified,
-     * the function will return "true" to indicate that the providers of the type definition need
-     * to be processed. This allows us to process providers of injector types after all imports of
-     * an injector definition are processed. (following View Engine semantics: see FW-1349)
-     */
     /**
      * Process a `SingleProvider` and add it.
      */

package/import/typings/di/scope.d.ts

@@ -5,10 +5,11 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { InjectionToken } from "./injection_token";
+import { InjectionToken } from './injection_token';
+export declare type InjectorScope = 'root' | 'platform' | 'environment';
 /**
  * An internal token whose presence in an injector indicates that the injector should treat itself
  * as a root scoped injector when processing requests for unknown tokens which may indicate
  * they are provided in the root scope.
  */
-export declare const INJECTOR_SCOPE: InjectionToken<"root" | "platform">;
+export declare const INJECTOR_SCOPE: InjectionToken<InjectorScope>;

package/import/typings/index.d.ts

@@ -1,4 +1,4 @@
-export * from './decorator/injectable';
+export * from './di/injectable';
 export * from './di/metadata';
 export * from './di/r3_injector';
 export * from './di/interface/defs';

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "static-injector",
-  "version": "1.0.9",
+  "version": "2.0.0",
   "description": "Angular的静态注入器独立使用版本",
   "keywords": [
     "angular",
     "injector",
     "typescript",
-    "injectable"
+    "typescript 4.8",
+    "injectable",
+    "static-inject"
   ],
   "repository": {
     "type": "git",

package/transform/compiler/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/transform/compiler/src/injectable_compiler_2.d.ts

@@ -5,49 +5,20 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import * as o from "./output/output_ast";
-import { R3DependencyMetadata } from "./render3/r3_factory";
-import { R3CompiledExpression, R3Reference } from "./render3/util";
+import * as o from './output/output_ast';
+import { R3DependencyMetadata } from './render3/r3_factory';
+import { MaybeForwardRefExpression, R3CompiledExpression, R3Reference } from './render3/util';
 export interface R3InjectableMetadata {
     name: string;
     type: R3Reference;
     internalType: o.Expression;
     typeArgumentCount: number;
-    providedIn: R3ProviderExpression;
-    useClass?: R3ProviderExpression;
+    providedIn: MaybeForwardRefExpression;
+    useClass?: MaybeForwardRefExpression;
     useFactory?: o.Expression;
-    useExisting?: R3ProviderExpression;
-    useValue?: R3ProviderExpression;
+    useExisting?: MaybeForwardRefExpression;
+    useValue?: MaybeForwardRefExpression;
     deps?: R3DependencyMetadata[];
 }
-/**
- * An expression used when instantiating an injectable.
- *
- * This is the type of the `useClass`, `useExisting` and `useValue` properties of
- * `R3InjectableMetadata` since those can refer to types that may eagerly reference types that have
- * not yet been defined.
- */
-export interface R3ProviderExpression<T extends o.Expression = o.Expression> {
-    /**
-     * The expression that is used to instantiate the Injectable.
-     */
-    expression: T;
-    /**
-     * If true, then the `expression` contains a reference to something that has not yet been
-     * defined.
-     *
-     * This means that the expression must not be eagerly evaluated. Instead it must be wrapped in a
-     * function closure that will be evaluated lazily to allow the definition of the expression to be
-     * evaluated first.
-     *
-     * In some cases the expression will naturally be placed inside such a function closure, such as
-     * in a fully compiled factory function. In those case nothing more needs to be done.
-     *
-     * But in other cases, such as partial-compilation the expression will be located in top level
-     * code so will need to be wrapped in a function that is passed to a `forwardRef()` call.
-     */
-    isForwardRef: boolean;
-}
-export declare function createR3ProviderExpression<T extends o.Expression>(expression: T, isForwardRef: boolean): R3ProviderExpression<T>;
 export declare function compileInjectable(meta: R3InjectableMetadata, resolveForwardRefs: boolean): R3CompiledExpression;
 export declare function createInjectableType(meta: R3InjectableMetadata): o.ExpressionType;