From 2c09b707ce2c185cf617050a7b0ab1ff9b587be0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mis=CC=8Cko=20Hevery?= Date: Fri, 13 Apr 2018 13:34:39 -0700 Subject: [PATCH] refactor(ivy): make return value of define(Component|Directive|Pipe|Injector|Injectable) private (#23371) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ivy definition looks something like this: ``` class MyService { static ngInjectableDef = defineInjectable({ … }); } ``` Here the argument to `defineInjectable` is well known public contract which needs to be honored in backward compatible way between versions. The type of the return value of `defineInjectable` on the other hand is private and can change shape drastically between versions without effecting backwards compatibility of libraries publish to NPM. To our users it is effectively an `OpaqueToken`. By prefixing the type with `ɵ` we are communicating the the outside world that the value is not public API and is subject to change without backward compatibility. PR Close #23371 --- .../src/largetable/render3/table.ts | 4 +- modules/benchmarks/src/tree/render3/tree.ts | 6 +-- packages/compiler-cli/test/ngc_spec.ts | 10 ++-- .../differs/iterable_differs.ts | 5 +- .../core/src/core_render3_private_export.ts | 6 +-- packages/core/src/di/defs.ts | 33 ++++++------ packages/core/src/di/injectable.ts | 4 +- packages/core/src/di/injection_token.ts | 7 +-- packages/core/src/di/injector.ts | 4 +- packages/core/src/di/r3_injector.ts | 8 +-- packages/core/src/metadata/ng_module.ts | 3 +- packages/core/src/render3/component.ts | 8 +-- packages/core/src/render3/definition.ts | 24 ++++----- packages/core/src/render3/di.ts | 10 ++-- packages/core/src/render3/hooks.ts | 10 ++-- packages/core/src/render3/index.ts | 8 +-- packages/core/src/render3/instructions.ts | 40 +++++++-------- .../core/src/render3/interfaces/definition.ts | 51 ++++++++++++------- packages/core/src/render3/interfaces/view.ts | 6 +-- packages/core/src/render3/pipe.ts | 13 ++--- packages/core/src/render3/query.ts | 4 +- packages/core/src/view/ng_module.ts | 6 +-- .../core/test/bundling/injection/usage.ts | 2 +- packages/core/test/bundling/todo/index.ts | 2 +- packages/core/test/di/r3_injector_spec.ts | 2 +- .../back_patch_types_specs.ts | 8 +-- .../compiler_canonical/injection_spec.ts | 2 +- .../compiler_canonical/patch_types_spec.ts | 3 +- .../compiler_canonical/small_app_spec.ts | 2 +- packages/core/test/render3/render_util.ts | 10 ++-- packages/core/test/view/ng_module_spec.ts | 22 ++++---- tools/public_api_guard/core/core.d.ts | 28 +++------- 32 files changed, 179 insertions(+), 172 deletions(-) diff --git a/modules/benchmarks/src/largetable/render3/table.ts b/modules/benchmarks/src/largetable/render3/table.ts index 85b43102ce..6270aaf244 100644 --- a/modules/benchmarks/src/largetable/render3/table.ts +++ b/modules/benchmarks/src/largetable/render3/table.ts @@ -7,7 +7,7 @@ */ import {ɵC as C, ɵE as E, ɵRenderFlags as RenderFlags, ɵT as T, ɵV as V, ɵb as b, ɵcR as cR, ɵcr as cr, ɵdefineComponent as defineComponent, ɵdetectChanges as detectChanges, ɵe as e, ɵsn as sn, ɵt as t, ɵv as v} from '@angular/core'; -import {ComponentDef} from '@angular/core/src/render3/interfaces/definition'; +import {ɵComponentDef} from '@angular/core/src/render3/interfaces/definition'; import {TableCell, buildTable, emptyTable} from '../util'; @@ -15,7 +15,7 @@ export class LargeTableComponent { data: TableCell[][] = emptyTable; /** @nocollapse */ - static ngComponentDef: ComponentDef = defineComponent({ + static ngComponentDef: ɵComponentDef = defineComponent({ type: LargeTableComponent, selectors: [['largetable']], template: function(rf: RenderFlags, ctx: LargeTableComponent) { diff --git a/modules/benchmarks/src/tree/render3/tree.ts b/modules/benchmarks/src/tree/render3/tree.ts index 61bd0955e0..7517b51258 100644 --- a/modules/benchmarks/src/tree/render3/tree.ts +++ b/modules/benchmarks/src/tree/render3/tree.ts @@ -7,7 +7,7 @@ */ import {ɵC as C, ɵE as E, ɵRenderFlags as RenderFlags, ɵT as T, ɵV as V, ɵb as b, ɵcR as cR, ɵcr as cr, ɵdefineComponent as defineComponent, ɵdetectChanges as _detectChanges, ɵe as e, ɵi1 as i1, ɵp as p, ɵsn as sn, ɵt as t, ɵv as v} from '@angular/core'; -import {ComponentDef} from '@angular/core/src/render3/interfaces/definition'; +import {ɵComponentDef} from '@angular/core/src/render3/interfaces/definition'; import {TreeNode, buildTree, emptyTree} from '../util'; @@ -35,7 +35,7 @@ export class TreeComponent { data: TreeNode = emptyTree; /** @nocollapse */ - static ngComponentDef: ComponentDef = defineComponent({ + static ngComponentDef: ɵComponentDef = defineComponent({ type: TreeComponent, selectors: [['tree']], template: function(rf: RenderFlags, ctx: TreeComponent) { @@ -95,7 +95,7 @@ export class TreeFunction { data: TreeNode = emptyTree; /** @nocollapse */ - static ngComponentDef: ComponentDef = defineComponent({ + static ngComponentDef: ɵComponentDef = defineComponent({ type: TreeFunction, selectors: [['tree']], template: function(rf: RenderFlags, ctx: TreeFunction) { diff --git a/packages/compiler-cli/test/ngc_spec.ts b/packages/compiler-cli/test/ngc_spec.ts index 14845f2c07..5bfe95c4d2 100644 --- a/packages/compiler-cli/test/ngc_spec.ts +++ b/packages/compiler-cli/test/ngc_spec.ts @@ -2151,7 +2151,7 @@ describe('ngc transformer command-line', () => { }); }); - it('compiles a basic InjectableDef', () => { + it('compiles a basic ɵInjectableDef', () => { const source = compileService(` import {Injectable} from '@angular/core'; import {Module} from './module'; @@ -2187,7 +2187,7 @@ describe('ngc transformer command-line', () => { expect(source).toMatch(/\/\*\* @nocollapse \*\/ Service\.ngInjectableDef =/); }); - it('compiles a useValue InjectableDef', () => { + it('compiles a useValue ɵInjectableDef', () => { const source = compileService(` import {Injectable} from '@angular/core'; import {Module} from './module'; @@ -2203,7 +2203,7 @@ describe('ngc transformer command-line', () => { expect(source).toMatch(/ngInjectableDef.*return CONST_SERVICE/); }); - it('compiles a useExisting InjectableDef', () => { + it('compiles a useExisting ɵInjectableDef', () => { const source = compileService(` import {Injectable} from '@angular/core'; import {Module} from './module'; @@ -2220,7 +2220,7 @@ describe('ngc transformer command-line', () => { expect(source).toMatch(/ngInjectableDef.*return ..\.inject\(Existing\)/); }); - it('compiles a useFactory InjectableDef with optional dep', () => { + it('compiles a useFactory ɵInjectableDef with optional dep', () => { const source = compileService(` import {Injectable, Optional} from '@angular/core'; import {Module} from './module'; @@ -2240,7 +2240,7 @@ describe('ngc transformer command-line', () => { expect(source).toMatch(/ngInjectableDef.*return ..\(..\.inject\(Existing, 8\)/); }); - it('compiles a useFactory InjectableDef with skip-self dep', () => { + it('compiles a useFactory ɵInjectableDef with skip-self dep', () => { const source = compileService(` import {Injectable, SkipSelf} from '@angular/core'; import {Module} from './module'; diff --git a/packages/core/src/change_detection/differs/iterable_differs.ts b/packages/core/src/change_detection/differs/iterable_differs.ts index 912bfe7b7c..1292c983e8 100644 --- a/packages/core/src/change_detection/differs/iterable_differs.ts +++ b/packages/core/src/change_detection/differs/iterable_differs.ts @@ -6,12 +6,13 @@ * found in the LICENSE file at https://angular.io/license */ -import {InjectableDef, defineInjectable} from '../../di/defs'; +import {defineInjectable, ɵInjectableDef} from '../../di/defs'; import {Optional, SkipSelf} from '../../di/metadata'; import {StaticProvider} from '../../di/provider'; import {DefaultIterableDifferFactory} from '../differs/default_iterable_differ'; + /** * A type describing supported iterable types. * @@ -137,7 +138,7 @@ export interface IterableDifferFactory { * */ export class IterableDiffers { - static ngInjectableDef: InjectableDef = defineInjectable({ + static ngInjectableDef: ɵInjectableDef = defineInjectable({ providedIn: 'root', factory: () => new IterableDiffers([new DefaultIterableDifferFactory()]) }); diff --git a/packages/core/src/core_render3_private_export.ts b/packages/core/src/core_render3_private_export.ts index 136b4fd3e4..016a6931eb 100644 --- a/packages/core/src/core_render3_private_export.ts +++ b/packages/core/src/core_render3_private_export.ts @@ -75,9 +75,9 @@ export { st as ɵst, ld as ɵld, Pp as ɵPp, - ComponentDef as ɵComponentDef, - DirectiveDef as ɵDirectiveDef, - PipeDef as ɵPipeDef, + ɵComponentDef, + ɵDirectiveDef, + ɵPipeDef, whenRendered as ɵwhenRendered, } from './render3/index'; export { diff --git a/packages/core/src/di/defs.ts b/packages/core/src/di/defs.ts index 9cfa828cbd..362b5431c8 100644 --- a/packages/core/src/di/defs.ts +++ b/packages/core/src/di/defs.ts @@ -17,14 +17,15 @@ import {ClassProvider, ClassSansProvider, ConstructorProvider, ConstructorSansPr * requesting injection of other types if necessary. * * Optionally, a `providedIn` parameter specifies that the given type belongs to a particular - * `InjectorDef`, `NgModule`, or a special scope (e.g. `'root'`). A value of `null` indicates + * `ɵInjectorDef`, `NgModule`, or a special scope (e.g. `'root'`). A value of `null` indicates * that the injectable does not belong to any scope. * - * This type is typically generated by the Angular compiler, but can be hand-written if needed. + * NOTE: This is a semi public API, and there are no guaranties that the shape of this API will + * remain consistent between version. Use with caution. * * @experimental */ -export interface InjectableDef { +export interface ɵInjectableDef { /** * Specifies that the given type belongs to a particular injector: * - `InjectorType` such as `NgModule`, @@ -50,13 +51,13 @@ export interface InjectableDef { * Information about the providers to be included in an `Injector` as well as how the given type * which carries the information should be created by the DI system. * - * An `InjectorDef` can import other types which have `InjectorDefs`, forming a deep nested + * An `ɵInjectorDef` can import other types which have `InjectorDefs`, forming a deep nested * structure of providers with a defined priority (identically to how `NgModule`s also have * an import/dependency structure). * * @experimental */ -export interface InjectorDef { +export interface ɵInjectorDef { factory: () => T; // TODO(alxhub): Narrow down the type here once decorators properly change the return type of the @@ -68,29 +69,29 @@ export interface InjectorDef { } /** - * A `Type` which has an `InjectableDef` static field. + * A `Type` which has an `ɵInjectableDef` static field. * * `InjectableDefType`s contain their own Dependency Injection metadata and are usable in an - * `InjectorDef`-based `StaticInjector. + * `ɵInjectorDef`-based `StaticInjector. * * @experimental */ -export interface InjectableType extends Type { ngInjectableDef: InjectableDef; } +export interface InjectableType extends Type { ngInjectableDef: ɵInjectableDef; } /** - * A type which has an `InjectorDef` static field. + * A type which has an `ɵInjectorDef` static field. * * `InjectorDefTypes` can be used to configure a `StaticInjector`. * * @experimental */ -export interface InjectorType extends Type { ngInjectorDef: InjectorDef; } +export interface InjectorType extends Type { ngInjectorDef: ɵInjectorDef; } /** - * Describes the `InjectorDef` equivalent of a `ModuleWithProviders`, an `InjectorDefType` with an + * Describes the `ɵInjectorDef` equivalent of a `ModuleWithProviders`, an `InjectorDefType` with an * associated array of providers. * - * Objects of this type can be listed in the imports section of an `InjectorDef`. + * Objects of this type can be listed in the imports section of an `ɵInjectorDef`. * * @experimental */ @@ -102,7 +103,7 @@ export interface InjectorTypeWithProviders { /** - * Construct an `InjectableDef` which defines how a token will be constructed by the DI system, and + * Construct an `ɵInjectableDef` which defines how a token will be constructed by the DI system, and * in which injectors (if any) it will be available. * * This should be assigned to a static `ngInjectableDef` field on a type, which will then be an @@ -120,7 +121,7 @@ export interface InjectorTypeWithProviders { export function defineInjectable(opts: { providedIn?: Type| 'root' | 'any' | null, factory: () => T, -}): InjectableDef { +}): ɵInjectableDef { return { providedIn: opts.providedIn as any || null, factory: opts.factory, @@ -129,7 +130,7 @@ export function defineInjectable(opts: { } /** - * Construct an `InjectorDef` which configures an injector. + * Construct an `ɵInjectorDef` which configures an injector. * * This should be assigned to a static `ngInjectorDef` field on a type, which will then be an * `InjectorType`. @@ -149,7 +150,7 @@ export function defineInjectable(opts: { * @experimental */ export function defineInjector(options: {factory: () => any, providers?: any[], imports?: any[]}): - InjectorDef { + ɵInjectorDef { return { factory: options.factory, providers: options.providers || [], diff --git a/packages/core/src/di/injectable.ts b/packages/core/src/di/injectable.ts index 507623051a..c7fdbc407d 100644 --- a/packages/core/src/di/injectable.ts +++ b/packages/core/src/di/injectable.ts @@ -11,7 +11,7 @@ import {Type} from '../type'; import {makeDecorator, makeParamDecorator} from '../util/decorators'; import {getClosureSafeProperty} from '../util/property'; -import {InjectableDef, InjectableType, defineInjectable} from './defs'; +import {InjectableType, defineInjectable, ɵInjectableDef} from './defs'; import {inject, injectArgs} from './injector'; import {ClassSansProvider, ConstructorProvider, ConstructorSansProvider, ExistingProvider, ExistingSansProvider, FactoryProvider, FactorySansProvider, StaticClassProvider, StaticClassSansProvider, ValueProvider, ValueSansProvider} from './provider'; @@ -134,4 +134,4 @@ export const Injectable: InjectableDecorator = makeDecorator( * * @experimental */ -export interface InjectableType extends Type { ngInjectableDef: InjectableDef; } +export interface InjectableType extends Type { ngInjectableDef: ɵInjectableDef; } diff --git a/packages/core/src/di/injection_token.ts b/packages/core/src/di/injection_token.ts index 080ee0188e..bbe432aa0a 100644 --- a/packages/core/src/di/injection_token.ts +++ b/packages/core/src/di/injection_token.ts @@ -8,7 +8,8 @@ import {Type} from '../type'; -import {InjectableDef, defineInjectable} from './defs'; +import {defineInjectable, ɵInjectableDef} from './defs'; + /** * Creates a token that can be used in a DI Provider. @@ -52,7 +53,7 @@ export class InjectionToken { /** @internal */ readonly ngMetadataName = 'InjectionToken'; - readonly ngInjectableDef: InjectableDef|undefined; + readonly ngInjectableDef: ɵInjectableDef|undefined; constructor(protected _desc: string, options?: { providedIn?: Type| 'root' | null, @@ -72,5 +73,5 @@ export class InjectionToken { } export interface InjectableDefToken extends InjectionToken { - ngInjectableDef: InjectableDef; + ngInjectableDef: ɵInjectableDef; } diff --git a/packages/core/src/di/injector.ts b/packages/core/src/di/injector.ts index 87d829e2ba..5416a5ce86 100644 --- a/packages/core/src/di/injector.ts +++ b/packages/core/src/di/injector.ts @@ -9,7 +9,7 @@ import {Type} from '../type'; import {stringify} from '../util'; -import {InjectableDef, defineInjectable} from './defs'; +import {defineInjectable, ɵInjectableDef} from './defs'; import {resolveForwardRef} from './forward_ref'; import {InjectionToken} from './injection_token'; import {Inject, Optional, Self, SkipSelf} from './metadata'; @@ -462,7 +462,7 @@ export function inject(token: Type| InjectionToken, flags = InjectFlags if (_currentInjector === undefined) { throw new Error(`inject() must be called from an injection context`); } else if (_currentInjector === null) { - const injectableDef: InjectableDef = (token as any).ngInjectableDef; + const injectableDef: ɵInjectableDef = (token as any).ngInjectableDef; if (injectableDef && injectableDef.providedIn == 'root') { return injectableDef.value === undefined ? injectableDef.value = injectableDef.factory() : injectableDef.value; diff --git a/packages/core/src/di/r3_injector.ts b/packages/core/src/di/r3_injector.ts index a3d679b762..e770029c5a 100644 --- a/packages/core/src/di/r3_injector.ts +++ b/packages/core/src/di/r3_injector.ts @@ -10,7 +10,7 @@ import {OnDestroy} from '../metadata/lifecycle_hooks'; import {Type} from '../type'; import {stringify} from '../util'; -import {InjectableDef, InjectableType, InjectorDef, InjectorType, InjectorTypeWithProviders} from './defs'; +import {InjectableType, InjectorType, InjectorTypeWithProviders, ɵInjectableDef, ɵInjectorDef} from './defs'; import {resolveForwardRef} from './forward_ref'; import {InjectableDefToken, InjectionToken} from './injection_token'; import {INJECTOR, InjectFlags, Injector, NullInjector, THROW_IF_NOT_FOUND, USE_VALUE, inject, injectArgs, setCurrentInjector} from './injector'; @@ -200,7 +200,7 @@ export class R3Injector { // read, so care is taken to only do the read once. // First attempt to read the ngInjectorDef. - let def = (defOrWrappedDef as InjectorType).ngInjectorDef as(InjectorDef| undefined); + let def = (defOrWrappedDef as InjectorType).ngInjectorDef as(ɵInjectorDef| undefined); // If that's not present, then attempt to read ngModule from the InjectorDefTypeWithProviders. const ngModule = @@ -219,7 +219,7 @@ export class R3Injector { EMPTY_ARRAY; // Finally, if defOrWrappedType was an `InjectorDefTypeWithProviders`, then the actual - // `InjectorDef` is on its `ngModule`. + // `ɵInjectorDef` is on its `ngModule`. if (ngModule !== undefined) { def = ngModule.ngInjectorDef; } @@ -314,7 +314,7 @@ export class R3Injector { return record.value as T; } - private injectableDefInScope(def: InjectableDef): boolean { + private injectableDefInScope(def: ɵInjectableDef): boolean { if (!def.providedIn) { return false; } else if (typeof def.providedIn === 'string') { diff --git a/packages/core/src/metadata/ng_module.ts b/packages/core/src/metadata/ng_module.ts index 60e9986efb..da1947b3ad 100644 --- a/packages/core/src/metadata/ng_module.ts +++ b/packages/core/src/metadata/ng_module.ts @@ -6,13 +6,14 @@ * found in the LICENSE file at https://angular.io/license */ -import {InjectorDef, InjectorType, defineInjector} from '../di/defs'; +import {InjectorType, defineInjector, ɵInjectorDef} from '../di/defs'; import {convertInjectableProviderToFactory} from '../di/injectable'; import {Provider} from '../di/provider'; import {Type} from '../type'; import {TypeDecorator, makeDecorator} from '../util/decorators'; + /** * A wrapper around a module that also includes the providers. * diff --git a/packages/core/src/render3/component.ts b/packages/core/src/render3/component.ts index c4f53ac9a9..ac41105777 100644 --- a/packages/core/src/render3/component.ts +++ b/packages/core/src/render3/component.ts @@ -15,7 +15,7 @@ import {ComponentRef as viewEngine_ComponentRef} from '../linker/component_facto import {assertComponentType, assertNotNull} from './assert'; import {queueInitHooks, queueLifecycleHooks} from './hooks'; import {CLEAN_PROMISE, ROOT_DIRECTIVE_INDICES, _getComponentHostLElementNode, baseDirectiveCreate, createLView, createTView, detectChangesInternal, enterView, executeInitAndContentHooks, getRootView, hostElement, initChangeDetectorIfExisting, leaveView, locateHostElement, setHostBindings} from './instructions'; -import {ComponentDef, ComponentType} from './interfaces/definition'; +import {ComponentType, ɵComponentDef} from './interfaces/definition'; import {LElementNode, TNodeFlags} from './interfaces/node'; import {RElement, RendererFactory3, domRendererFactory3} from './interfaces/renderer'; import {LView, LViewFlags, RootContext} from './interfaces/view'; @@ -51,7 +51,7 @@ export interface CreateComponentOptions { * features list because there's no way of knowing when the component will be used as * a root component. */ - hostFeatures?: ((component: T, componentDef: ComponentDef) => void)[]; + hostFeatures?: ((component: T, componentDef: ɵComponentDef) => void)[]; /** * A function which is used to schedule change detection work in the future. @@ -120,7 +120,7 @@ export function renderComponent( opts: CreateComponentOptions = {}): T { ngDevMode && assertComponentType(componentType); const rendererFactory = opts.rendererFactory || domRendererFactory3; - const componentDef = (componentType as ComponentType).ngComponentDef as ComponentDef; + const componentDef = (componentType as ComponentType).ngComponentDef as ɵComponentDef; if (componentDef.type != componentType) componentDef.type = componentType; let component: T; // The first index of the first selector is the tag name. @@ -177,7 +177,7 @@ export function renderComponent( * renderComponent(AppComponent, {features: [RootLifecycleHooks]}); * ``` */ -export function LifecycleHooksFeature(component: any, def: ComponentDef): void { +export function LifecycleHooksFeature(component: any, def: ɵComponentDef): void { const elementNode = _getComponentHostLElementNode(component); // Root component is always created at dir index 0 diff --git a/packages/core/src/render3/definition.ts b/packages/core/src/render3/definition.ts index e3851fe2fb..ed49b17710 100644 --- a/packages/core/src/render3/definition.ts +++ b/packages/core/src/render3/definition.ts @@ -16,7 +16,7 @@ import {Type} from '../type'; import {resolveRendererType2} from '../view/util'; import {diPublic} from './di'; -import {ComponentDef, ComponentDefFeature, ComponentTemplate, ComponentType, DirectiveDef, DirectiveDefFeature, DirectiveDefListOrFactory, DirectiveType, DirectiveTypesOrFactory, PipeDef, PipeType, PipeTypesOrFactory} from './interfaces/definition'; +import {ComponentDefFeature, ComponentTemplate, ComponentType, DirectiveDefFeature, DirectiveDefListOrFactory, DirectiveType, DirectiveTypesOrFactory, PipeType, PipeTypesOrFactory, ɵComponentDef, ɵDirectiveDef, ɵPipeDef} from './interfaces/definition'; import {CssSelectorList, SelectorFlags} from './interfaces/projection'; @@ -150,8 +150,8 @@ export function defineComponent(componentDefinition: { /** * Registry of directives and components that may be found in this component's view. * - * The property is either an array of `DirectiveDef`s or a function which returns the array of - * `DirectiveDef`s. The function is necessary to be able to support forward declarations. + * The property is either an array of `ɵDirectiveDef`s or a function which returns the array of + * `ɵDirectiveDef`s. The function is necessary to be able to support forward declarations. */ directives?: DirectiveTypesOrFactory | null; @@ -162,11 +162,11 @@ export function defineComponent(componentDefinition: { * `PipeDefs`s. The function is necessary to be able to support forward declarations. */ pipes?: PipeTypesOrFactory | null; -}): ComponentDef { +}): ɵComponentDef { const type = componentDefinition.type; const pipeTypes = componentDefinition.pipes !; const directiveTypes = componentDefinition.directives !; - const def = >{ + const def = <ɵComponentDef>{ type: type, diPublic: null, factory: componentDefinition.factory, @@ -200,7 +200,7 @@ export function defineComponent(componentDefinition: { } export function extractDirectiveDef(type: DirectiveType& ComponentType): - DirectiveDef|ComponentDef { + ɵDirectiveDef|ɵComponentDef { const def = type.ngComponentDef || type.ngDirectiveDef; if (ngDevMode && !def) { throw new Error(`'${type.name}' is neither 'ComponentType' or 'DirectiveType'.`); @@ -208,7 +208,7 @@ export function extractDirectiveDef(type: DirectiveType& ComponentType return def; } -export function extractPipeDef(type: PipeType): PipeDef { +export function extractPipeDef(type: PipeType): ɵPipeDef { const def = type.ngPipeDef; if (ngDevMode && !def) { throw new Error(`'${type.name}' is not a 'PipeType'.`); @@ -250,7 +250,7 @@ type OnChangesExpando = OnChanges & { */ export function NgOnChangesFeature(inputPropertyNames?: {[key: string]: string}): DirectiveDefFeature { - return function(definition: DirectiveDef): void { + return function(definition: ɵDirectiveDef): void { const inputs = definition.inputs; const proto = definition.type.prototype; // Place where we will store SimpleChanges if there is a change @@ -306,7 +306,7 @@ export function NgOnChangesFeature(inputPropertyNames?: {[key: string]: string}) } -export function PublicFeature(definition: DirectiveDef) { +export function PublicFeature(definition: ɵDirectiveDef) { definition.diPublic = diPublic; } @@ -400,7 +400,7 @@ export const defineDirective = defineComponent as any as(directiveDefinition: * See: {@link Directive.exportAs} */ exportAs?: string; -}) => DirectiveDef; +}) => ɵDirectiveDef; /** * Create a pipe definition object. @@ -428,8 +428,8 @@ export function definePipe(pipeDef: { /** Whether the pipe is pure. */ pure?: boolean -}): PipeDef { - return >{ +}): ɵPipeDef { + return <ɵPipeDef>{ name: pipeDef.name, n: pipeDef.factory, pure: pipeDef.pure !== false, diff --git a/packages/core/src/render3/di.ts b/packages/core/src/render3/di.ts index c1c76c53fa..32abece2c4 100644 --- a/packages/core/src/render3/di.ts +++ b/packages/core/src/render3/di.ts @@ -20,7 +20,7 @@ import {Type} from '../type'; import {assertGreaterThan, assertLessThan, assertNotNull} from './assert'; import {addToViewTree, assertPreviousIsParent, createLContainer, createLNodeObject, getDirectiveInstance, getPreviousOrParentNode, getRenderer, isComponent, renderEmbeddedTemplate, resolveDirective} from './instructions'; -import {ComponentTemplate, DirectiveDef, DirectiveDefList, PipeDefList} from './interfaces/definition'; +import {ComponentTemplate, DirectiveDefList, PipeDefList, ɵDirectiveDef} from './interfaces/definition'; import {LInjector} from './interfaces/injector'; import {LContainerNode, LElementNode, LNode, LNodeType, LViewNode, TNodeFlags} from './interfaces/node'; import {QueryReadType} from './interfaces/query'; @@ -139,7 +139,7 @@ export function getOrCreateNodeInjectorForNode(node: LElementNode | LContainerNo * @param di The node injector in which a directive will be added * @param def The definition of the directive to be made public */ -export function diPublicInInjector(di: LInjector, def: DirectiveDef): void { +export function diPublicInInjector(di: LInjector, def: ɵDirectiveDef): void { bloomAdd(di, def.type); } @@ -148,7 +148,7 @@ export function diPublicInInjector(di: LInjector, def: DirectiveDef): void * * @param def The definition of the directive to be made public */ -export function diPublic(def: DirectiveDef): void { +export function diPublic(def: ɵDirectiveDef): void { diPublicInInjector(getOrCreateNodeInjector(), def); } @@ -371,7 +371,7 @@ export function getOrCreateInjectable(di: LInjector, token: Type, flags?: for (let i = start; i < end; i++) { // Get the definition for the directive at this index and, if it is injectable (diPublic), // and matches the given token, return the directive instance. - const directiveDef = defs[i] as DirectiveDef; + const directiveDef = defs[i] as ɵDirectiveDef; if (directiveDef.type === token && directiveDef.diPublic) { return getDirectiveInstance(node.view.directives ![i]); } @@ -400,7 +400,7 @@ function searchMatchesQueuedForCreation(node: LNode, token: any): T|null { const matches = node.view.tView.currentMatches; if (matches) { for (let i = 0; i < matches.length; i += 2) { - const def = matches[i] as DirectiveDef; + const def = matches[i] as ɵDirectiveDef; if (def.type === token) { return resolveDirective(def, i + 1, matches, node.view.tView); } diff --git a/packages/core/src/render3/hooks.ts b/packages/core/src/render3/hooks.ts index 0094566580..5bb6a9d9b6 100644 --- a/packages/core/src/render3/hooks.ts +++ b/packages/core/src/render3/hooks.ts @@ -7,7 +7,7 @@ */ import {assertEqual} from './assert'; -import {DirectiveDef} from './interfaces/definition'; +import {ɵDirectiveDef} from './interfaces/definition'; import {TNodeFlags} from './interfaces/node'; import {HookData, LView, LifecycleStage, TView} from './interfaces/view'; @@ -52,7 +52,7 @@ export function queueLifecycleHooks(flags: number, currentView: LView): void { // directiveCreate) so we can preserve the current hook order. Content, view, and destroy // hooks for projected components and directives must be called *before* their hosts. for (let i = start; i < end; i++) { - const def: DirectiveDef = tView.directives ![i]; + const def: ɵDirectiveDef = tView.directives ![i]; queueContentHooks(def, tView, i); queueViewHooks(def, tView, i); queueDestroyHooks(def, tView, i); @@ -61,7 +61,7 @@ export function queueLifecycleHooks(flags: number, currentView: LView): void { } /** Queues afterContentInit and afterContentChecked hooks on TView */ -function queueContentHooks(def: DirectiveDef, tView: TView, i: number): void { +function queueContentHooks(def: ɵDirectiveDef, tView: TView, i: number): void { if (def.afterContentInit) { (tView.contentHooks || (tView.contentHooks = [])).push(i, def.afterContentInit); } @@ -73,7 +73,7 @@ function queueContentHooks(def: DirectiveDef, tView: TView, i: number): voi } /** Queues afterViewInit and afterViewChecked hooks on TView */ -function queueViewHooks(def: DirectiveDef, tView: TView, i: number): void { +function queueViewHooks(def: ɵDirectiveDef, tView: TView, i: number): void { if (def.afterViewInit) { (tView.viewHooks || (tView.viewHooks = [])).push(i, def.afterViewInit); } @@ -85,7 +85,7 @@ function queueViewHooks(def: DirectiveDef, tView: TView, i: number): void { } /** Queues onDestroy hooks on TView */ -function queueDestroyHooks(def: DirectiveDef, tView: TView, i: number): void { +function queueDestroyHooks(def: ɵDirectiveDef, tView: TView, i: number): void { if (def.onDestroy != null) { (tView.destroyHooks || (tView.destroyHooks = [])).push(i, def.onDestroy); } diff --git a/packages/core/src/render3/index.ts b/packages/core/src/render3/index.ts index ea2206fa10..7f78dec1de 100644 --- a/packages/core/src/render3/index.ts +++ b/packages/core/src/render3/index.ts @@ -8,7 +8,7 @@ import {LifecycleHooksFeature, createComponentRef, getHostElement, getRenderedText, renderComponent, whenRendered} from './component'; import {NgOnChangesFeature, PublicFeature, defineComponent, defineDirective, definePipe} from './definition'; -import {ComponentDef, ComponentTemplate, ComponentType, DirectiveDef, DirectiveDefFlags, DirectiveType, PipeDef} from './interfaces/definition'; +import {ComponentTemplate, ComponentType, DirectiveDefFlags, DirectiveType, ɵComponentDef, ɵDirectiveDef, ɵPipeDef} from './interfaces/definition'; export {QUERY_READ_CONTAINER_REF, QUERY_READ_ELEMENT_REF, QUERY_READ_FROM_NODE, QUERY_READ_TEMPLATE_REF, directiveInject, injectAttribute, injectChangeDetectorRef, injectElementRef, injectTemplateRef, injectViewContainerRef} from './di'; export {RenderFlags} from './interfaces/definition'; @@ -103,15 +103,15 @@ export { // clang-format on export { - ComponentDef, + ɵComponentDef, ComponentTemplate, ComponentType, - DirectiveDef, + ɵDirectiveDef, DirectiveDefFlags, DirectiveType, NgOnChangesFeature, PublicFeature, - PipeDef, + ɵPipeDef, LifecycleHooksFeature, defineComponent, defineDirective, diff --git a/packages/core/src/render3/instructions.ts b/packages/core/src/render3/instructions.ts index f8ce9c69ec..a6eef84dfc 100644 --- a/packages/core/src/render3/instructions.ts +++ b/packages/core/src/render3/instructions.ts @@ -19,7 +19,7 @@ import {LContainerNode, LElementNode, LNode, LNodeType, TNodeFlags, LProjectionN import {assertNodeType} from './node_assert'; import {appendChild, insertChild, insertView, appendProjectedNode, removeView, canInsertNativeNode, createTextNode} from './node_manipulation'; import {isNodeMatchingSelectorList, matchingSelectorIndex} from './node_selector_matcher'; -import {ComponentDef, ComponentTemplate, ComponentType, DirectiveDef, DirectiveDefList, DirectiveDefListOrFactory, DirectiveType, PipeDef, PipeDefList, PipeDefListOrFactory, RenderFlags} from './interfaces/definition'; +import {ɵComponentDef, ComponentTemplate, ComponentType, ɵDirectiveDef, DirectiveDefList, DirectiveDefListOrFactory, DirectiveType, ɵPipeDef, PipeDefList, PipeDefListOrFactory, RenderFlags} from './interfaces/definition'; import {RElement, RText, Renderer3, RendererFactory3, ProceduralRenderer3, ObjectOrientedRenderer3, RendererStyleFlags3, isProceduralRenderer} from './interfaces/renderer'; import {isDifferent, stringify} from './util'; import {executeHooks, queueLifecycleHooks, queueInitHooks, executeInitHooks} from './hooks'; @@ -255,7 +255,7 @@ export function setHostBindings(bindings: number[] | null): void { const defs = currentView.tView.directives !; for (let i = 0; i < bindings.length; i += 2) { const dirIndex = bindings[i]; - const def = defs[dirIndex] as DirectiveDef; + const def = defs[dirIndex] as ɵDirectiveDef; def.hostBindings && def.hostBindings(dirIndex, bindings[i + 1]); } } @@ -578,7 +578,7 @@ function cacheMatchingDirectivesForNode( const matches = tView.currentMatches = findDirectiveMatches(tNode); if (matches) { for (let i = 0; i < matches.length; i += 2) { - const def = matches[i] as DirectiveDef; + const def = matches[i] as ɵDirectiveDef; const valueIndex = i + 1; resolveDirective(def, valueIndex, matches, tView); saveNameToExportMap(matches[valueIndex] as number, def, exportsMap); @@ -595,7 +595,7 @@ function findDirectiveMatches(tNode: TNode): CurrentMatchesList|null { for (let i = 0; i < registry.length; i++) { const def = registry[i]; if (isNodeMatchingSelectorList(tNode, def.selectors !)) { - if ((def as ComponentDef).template) { + if ((def as ɵComponentDef).template) { if (tNode.flags & TNodeFlags.isComponent) throwMultipleComponentError(tNode); tNode.flags = TNodeFlags.isComponent; } @@ -608,7 +608,7 @@ function findDirectiveMatches(tNode: TNode): CurrentMatchesList|null { } export function resolveDirective( - def: DirectiveDef, valueIndex: number, matches: CurrentMatchesList, tView: TView): any { + def: ɵDirectiveDef, valueIndex: number, matches: CurrentMatchesList, tView: TView): any { if (matches[valueIndex] === null) { matches[valueIndex] = CIRCULAR; const instance = def.factory(); @@ -663,7 +663,7 @@ function instantiateDirectivesDirectly() { const tDirectives = currentView.tView.directives !; for (let i = start; i < end; i++) { - const def: DirectiveDef = tDirectives[i]; + const def: ɵDirectiveDef = tDirectives[i]; directiveCreate(i, def.factory(), def); } } @@ -691,11 +691,11 @@ function cacheMatchingLocalNames( * to their directive instances. */ function saveNameToExportMap( - index: number, def: DirectiveDef| ComponentDef, + index: number, def: ɵDirectiveDef| ɵComponentDef, exportsMap: {[key: string]: number} | null) { if (exportsMap) { if (def.exportAs) exportsMap[def.exportAs] = index; - if ((def as ComponentDef).template) exportsMap[''] = index; + if ((def as ɵComponentDef).template) exportsMap[''] = index; } } @@ -801,12 +801,12 @@ export function locateHostElement( * Creates the host LNode. * * @param rNode Render host element. - * @param def ComponentDef + * @param def ɵComponentDef * * @returns LElementNode created */ export function hostElement( - tag: string, rNode: RElement | null, def: ComponentDef): LElementNode { + tag: string, rNode: RElement | null, def: ɵComponentDef): LElementNode { resetApplicationState(); const node = createLNode( 0, LNodeType.Element, rNode, @@ -1013,7 +1013,7 @@ function generatePropertyAliases( const defs = currentView.tView.directives !; for (let i = start; i < end; i++) { - const directiveDef = defs[i] as DirectiveDef; + const directiveDef = defs[i] as ɵDirectiveDef; const propertyAliasMap: {[publicName: string]: string} = isInput ? directiveDef.inputs : directiveDef.outputs; for (let publicName in propertyAliasMap) { @@ -1203,18 +1203,18 @@ export function textBinding(index: number, value: T | NO_CHANGE): void { * be retrieved before they are created in which case the value will be null. * * @param directive The directive instance. - * @param directiveDef DirectiveDef object which contains information about the template. + * @param directiveDef ɵDirectiveDef object which contains information about the template. */ export function directiveCreate( - index: number, directive: T, directiveDef: DirectiveDef| ComponentDef): T { + index: number, directive: T, directiveDef: ɵDirectiveDef| ɵComponentDef): T { const instance = baseDirectiveCreate(index, directive, directiveDef); ngDevMode && assertNotNull(previousOrParentNode.tNode, 'previousOrParentNode.tNode'); const tNode = previousOrParentNode.tNode; - const isComponent = (directiveDef as ComponentDef).template; + const isComponent = (directiveDef as ɵComponentDef).template; if (isComponent) { - addComponentLogic(index, directive, directiveDef as ComponentDef); + addComponentLogic(index, directive, directiveDef as ɵComponentDef); } if (firstTemplatePass) { @@ -1232,7 +1232,7 @@ export function directiveCreate( return instance; } -function addComponentLogic(index: number, instance: T, def: ComponentDef): void { +function addComponentLogic(index: number, instance: T, def: ɵComponentDef): void { const tView = getOrCreateTView(def.template, def.directiveDefs, def.pipeDefs); // Only component views should be added to the view tree directly. Embedded views are @@ -1258,7 +1258,7 @@ function addComponentLogic(index: number, instance: T, def: ComponentDef): * current Angular. Example: local refs and inputs on root component. */ export function baseDirectiveCreate( - index: number, directive: T, directiveDef: DirectiveDef| ComponentDef): T { + index: number, directive: T, directiveDef: ɵDirectiveDef| ɵComponentDef): T { ngDevMode && assertEqual( currentView.bindingStartIndex, -1, 'directives should be created before any bindings'); @@ -1631,7 +1631,7 @@ export function componentRefresh(directiveIndex: number, elementIndex: number // Only attached CheckAlways components or attached, dirty OnPush components should be checked if (viewAttached(hostView) && hostView.flags & (LViewFlags.CheckAlways | LViewFlags.Dirty)) { ngDevMode && assertDataInRange(directiveIndex, directives !); - const def = currentView.tView.directives ![directiveIndex] as ComponentDef; + const def = currentView.tView.directives ![directiveIndex] as ɵComponentDef; detectChangesInternal( hostView, element, def, getDirectiveInstance(directives ![directiveIndex])); @@ -1943,7 +1943,7 @@ export function detectChanges(component: T): void { const hostNode = _getComponentHostLElementNode(component); ngDevMode && assertNotNull(hostNode.data, 'Component host node should be attached to an LView'); const componentIndex = hostNode.tNode !.flags >> TNodeFlags.DirectiveStartingIndexShift; - const def = hostNode.view.tView.directives ![componentIndex] as ComponentDef; + const def = hostNode.view.tView.directives ![componentIndex] as ɵComponentDef; detectChangesInternal(hostNode.data as LView, hostNode, def, component); } @@ -1965,7 +1965,7 @@ export function checkNoChanges(component: T): void { /** Checks the view of the component provided. Does not gate on dirty checks or execute doCheck. */ export function detectChangesInternal( - hostView: LView, hostNode: LElementNode, def: ComponentDef, component: T) { + hostView: LView, hostNode: LElementNode, def: ɵComponentDef, component: T) { const oldView = enterView(hostView, hostNode); const template = def.template; diff --git a/packages/core/src/render3/interfaces/definition.ts b/packages/core/src/render3/interfaces/definition.ts index beb1804d73..b44555c15a 100644 --- a/packages/core/src/render3/interfaces/definition.ts +++ b/packages/core/src/render3/interfaces/definition.ts @@ -35,24 +35,24 @@ export const enum RenderFlags { } /** - * A subclass of `Type` which has a static `ngComponentDef`:`ComponentDef` field making it + * A subclass of `Type` which has a static `ngComponentDef`:`ɵComponentDef` field making it * consumable for rendering. */ -export interface ComponentType extends Type { ngComponentDef: ComponentDef; } +export interface ComponentType extends Type { ngComponentDef: ɵComponentDef; } /** - * A subclass of `Type` which has a static `ngDirectiveDef`:`DirectiveDef` field making it + * A subclass of `Type` which has a static `ngDirectiveDef`:`ɵDirectiveDef` field making it * consumable for rendering. */ -export interface DirectiveType extends Type { ngDirectiveDef: DirectiveDef; } +export interface DirectiveType extends Type { ngDirectiveDef: ɵDirectiveDef; } export const enum DirectiveDefFlags {ContentQuery = 0b10} /** - * A subclass of `Type` which has a static `ngPipeDef`:`PipeDef` field making it + * A subclass of `Type` which has a static `ngPipeDef`:`ɵPipeDef` field making it * consumable for rendering. */ -export interface PipeType extends Type { ngPipeDef: PipeDef; } +export interface PipeType extends Type { ngPipeDef: ɵPipeDef; } /** * Runtime link information for Directives. @@ -65,13 +65,18 @@ export interface PipeType extends Type { ngPipeDef: PipeDef; } * can change between versions. * * See: {@link defineDirective} + * + * NOTE: This is a semi public API, and there are no guaranties that the shape of this API will + * remain consistent between version. Use with caution. + * + * @experimental */ -export interface DirectiveDef { +export interface ɵDirectiveDef { /** Token representing the directive. Used by DI. */ type: Type; /** Function that makes a directive public to the DI system. */ - diPublic: ((def: DirectiveDef) => void)|null; + diPublic: ((def: ɵDirectiveDef) => void)|null; /** The selectors that will be used to match nodes to this directive. */ selectors: CssSelectorList; @@ -135,8 +140,13 @@ export interface DirectiveDef { * can change between versions. * * See: {@link defineComponent} + * + * NOTE: This is a semi public API, and there are no guaranties that the shape of this API will + * remain consistent between version. Use with caution. + * + * @experimental */ -export interface ComponentDef extends DirectiveDef { +export interface ɵComponentDef extends ɵDirectiveDef { /** * The View template of the component. * @@ -169,8 +179,8 @@ export interface ComponentDef extends DirectiveDef { /** * Registry of directives and components that may be found in this view. * - * The property is either an array of `DirectiveDef`s or a function which returns the array of - * `DirectiveDef`s. The function is necessary to be able to support forward declarations. + * The property is either an array of `ɵDirectiveDef`s or a function which returns the array of + * `ɵDirectiveDef`s. The function is necessary to be able to support forward declarations. */ directiveDefs: DirectiveDefListOrFactory|null; @@ -194,8 +204,13 @@ export interface ComponentDef extends DirectiveDef { * can change between versions. * * See: {@link definePipe} + * + * NOTE: This is a semi public API, and there are no guaranties that the shape of this API will + * remain consistent between version. Use with caution. + * + * @experimental */ -export interface PipeDef { +export interface ɵPipeDef { /** * Pipe name. * @@ -223,8 +238,8 @@ export interface PipeDef { onDestroy: (() => void)|null; } -export type DirectiveDefFeature = (directiveDef: DirectiveDef) => void; -export type ComponentDefFeature = (componentDef: ComponentDef) => void; +export type DirectiveDefFeature = (directiveDef: ɵDirectiveDef) => void; +export type ComponentDefFeature = (componentDef: ɵComponentDef) => void; /** * Type used for directiveDefs on component definition. @@ -233,12 +248,12 @@ export type ComponentDefFeature = (componentDef: ComponentDef) => void; */ export type DirectiveDefListOrFactory = (() => DirectiveDefList) | DirectiveDefList; -export type DirectiveDefList = (DirectiveDef| ComponentDef)[]; +export type DirectiveDefList = (ɵDirectiveDef| ɵComponentDef)[]; export type DirectiveTypesOrFactory = (() => DirectiveTypeList) | DirectiveTypeList; export type DirectiveTypeList = - (DirectiveDef| ComponentDef| + (ɵDirectiveDef| ɵComponentDef| Type/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[]; /** @@ -248,12 +263,12 @@ export type DirectiveTypeList = */ export type PipeDefListOrFactory = (() => PipeDefList) | PipeDefList; -export type PipeDefList = PipeDef[]; +export type PipeDefList = ɵPipeDef[]; export type PipeTypesOrFactory = (() => DirectiveTypeList) | DirectiveTypeList; export type PipeTypeList = - (PipeDef| Type/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[]; + (ɵPipeDef| Type/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[]; // Note: This hack is necessary so we don't erroneously get a circular dependency diff --git a/packages/core/src/render3/interfaces/view.ts b/packages/core/src/render3/interfaces/view.ts index 24742998ee..dba909f601 100644 --- a/packages/core/src/render3/interfaces/view.ts +++ b/packages/core/src/render3/interfaces/view.ts @@ -8,7 +8,7 @@ import {Injector} from '../../di/injector'; import {LContainer} from './container'; -import {ComponentTemplate, DirectiveDef, DirectiveDefList, PipeDef, PipeDefList} from './definition'; +import {ComponentTemplate, DirectiveDefList, PipeDefList, ɵDirectiveDef, ɵPipeDef} from './definition'; import {LElementNode, LViewNode, TNode} from './node'; import {LQueries} from './query'; import {Renderer3} from './renderer'; @@ -428,10 +428,10 @@ export const enum LifecycleStage { * as its pipe instance in the data array. Any nodes that do not have static * data store a null value in tData to avoid a sparse array. */ -export type TData = (TNode | PipeDef| null)[]; +export type TData = (TNode | ɵPipeDef| null)[]; /** Type for TView.currentMatches */ -export type CurrentMatchesList = [DirectiveDef, (string | number | null)]; +export type CurrentMatchesList = [ɵDirectiveDef, (string | number | null)]; // Note: This hack is necessary so we don't erroneously get a circular dependency // failure based on types. diff --git a/packages/core/src/render3/pipe.ts b/packages/core/src/render3/pipe.ts index 83880d3004..7e8a80497f 100644 --- a/packages/core/src/render3/pipe.ts +++ b/packages/core/src/render3/pipe.ts @@ -9,9 +9,10 @@ import {PipeTransform} from '../change_detection/pipe_transform'; import {getTView, load, store} from './instructions'; -import {PipeDef, PipeDefList} from './interfaces/definition'; +import {PipeDefList, ɵPipeDef} from './interfaces/definition'; import {pureFunction1, pureFunction2, pureFunction3, pureFunction4, pureFunctionV} from './pure_function'; + /** * Create a pipe. * @@ -21,7 +22,7 @@ import {pureFunction1, pureFunction2, pureFunction3, pureFunction4, pureFunction */ export function pipe(index: number, pipeName: string): any { const tView = getTView(); - let pipeDef: PipeDef; + let pipeDef: ɵPipeDef; if (tView.firstTemplatePass) { pipeDef = getPipeDef(pipeName, tView.pipeRegistry); @@ -30,7 +31,7 @@ export function pipe(index: number, pipeName: string): any { (tView.pipeDestroyHooks || (tView.pipeDestroyHooks = [])).push(index, pipeDef.onDestroy); } } else { - pipeDef = tView.data[index] as PipeDef; + pipeDef = tView.data[index] as ɵPipeDef; } const pipeInstance = pipeDef.n(); @@ -44,9 +45,9 @@ export function pipe(index: number, pipeName: string): any { * * @param name Name of pipe to resolve * @param registry Full list of available pipes - * @returns Matching PipeDef + * @returns Matching ɵPipeDef */ -function getPipeDef(name: string, registry: PipeDefList | null): PipeDef { +function getPipeDef(name: string, registry: PipeDefList | null): ɵPipeDef { if (registry) { for (let i = 0; i < registry.length; i++) { const pipeDef = registry[i]; @@ -140,5 +141,5 @@ export function pipeBindV(index: number, values: any[]): any { } function isPure(index: number): boolean { - return (>getTView().data[index]).pure; + return (<ɵPipeDef>getTView().data[index]).pure; } diff --git a/packages/core/src/render3/query.ts b/packages/core/src/render3/query.ts index e81fcaf1f9..ab44d1645d 100644 --- a/packages/core/src/render3/query.ts +++ b/packages/core/src/render3/query.ts @@ -18,7 +18,7 @@ import {getSymbolIterator} from '../util'; import {assertEqual, assertNotNull} from './assert'; import {ReadFromInjectorFn, getOrCreateNodeInjectorForNode} from './di'; import {assertPreviousIsParent, getCurrentQueries, store} from './instructions'; -import {DirectiveDef, unusedValueExportToPlacateAjd as unused1} from './interfaces/definition'; +import {unusedValueExportToPlacateAjd as unused1, ɵDirectiveDef} from './interfaces/definition'; import {LInjector, unusedValueExportToPlacateAjd as unused2} from './interfaces/injector'; import {LContainerNode, LElementNode, LNode, TNode, TNodeFlags, unusedValueExportToPlacateAjd as unused3} from './interfaces/node'; import {LQueries, QueryReadType, unusedValueExportToPlacateAjd as unused4} from './interfaces/query'; @@ -200,7 +200,7 @@ function getIdxOfMatchingDirective(node: LNode, type: Type): number|null { const start = flags >> TNodeFlags.DirectiveStartingIndexShift; const end = start + count; for (let i = start; i < end; i++) { - const def = defs[i] as DirectiveDef; + const def = defs[i] as ɵDirectiveDef; if (def.type === type && def.diPublic) { return i; } diff --git a/packages/core/src/view/ng_module.ts b/packages/core/src/view/ng_module.ts index 20f4ef060d..8f9b1f9795 100644 --- a/packages/core/src/view/ng_module.ts +++ b/packages/core/src/view/ng_module.ts @@ -6,7 +6,7 @@ * found in the LICENSE file at https://angular.io/license */ -import {InjectableDef} from '../di/defs'; +import {ɵInjectableDef} from '../di/defs'; import {resolveForwardRef} from '../di/forward_ref'; import {INJECTOR, InjectFlags, Injector, setCurrentInjector} from '../di/injector'; import {APP_ROOT} from '../di/scope'; @@ -102,7 +102,7 @@ export function resolveNgModuleDep( } return providerInstance === UNDEFINED_VALUE ? undefined : providerInstance; } else if (depDef.token.ngInjectableDef && targetsModule(data, depDef.token.ngInjectableDef)) { - const injectableDef = depDef.token.ngInjectableDef as InjectableDef; + const injectableDef = depDef.token.ngInjectableDef as ɵInjectableDef; const key = tokenKey; const index = data._providers.length; data._def.providersByKey[depDef.tokenKey] = { @@ -126,7 +126,7 @@ function moduleTransitivelyPresent(ngModule: NgModuleData, scope: any): boolean return ngModule._def.modules.indexOf(scope) > -1; } -function targetsModule(ngModule: NgModuleData, def: InjectableDef): boolean { +function targetsModule(ngModule: NgModuleData, def: ɵInjectableDef): boolean { return def.providedIn != null && (moduleTransitivelyPresent(ngModule, def.providedIn) || def.providedIn === 'root' && ngModule._def.isRoot); } diff --git a/packages/core/test/bundling/injection/usage.ts b/packages/core/test/bundling/injection/usage.ts index 669aae806b..a88d6aaabf 100644 --- a/packages/core/test/bundling/injection/usage.ts +++ b/packages/core/test/bundling/injection/usage.ts @@ -6,7 +6,7 @@ * found in the LICENSE file at https://angular.io/license */ -import {InjectableDef, Injector, InjectorDef, createInjector, defineInjectable, defineInjector} from '@angular/core'; +import {Injector, createInjector, defineInjectable, defineInjector, ɵInjectableDef, ɵInjectorDef} from '@angular/core'; export class RootService { static ngInjectableDef = defineInjectable({ diff --git a/packages/core/test/bundling/todo/index.ts b/packages/core/test/bundling/todo/index.ts index cbaf6b8caa..2d17afa510 100644 --- a/packages/core/test/bundling/todo/index.ts +++ b/packages/core/test/bundling/todo/index.ts @@ -7,7 +7,7 @@ */ import {CommonModule, NgForOf, NgIf} from '@angular/common'; -import {ChangeDetectionStrategy, Component, EventEmitter, InjectFlags, Injectable, Input, IterableDiffers, NgModule, Output, createInjector, defineInjector, inject, ɵComponentDef as ComponentDef, ɵComponentType as ComponentType, ɵDirectiveDef as DirectiveDef, ɵDirectiveType as DirectiveType, ɵNgOnChangesFeature as NgOnChangesFeature, ɵdefaultIterableDiffers as defaultIterableDiffers, ɵdefineDirective as defineDirective, ɵdirectiveInject as directiveInject, ɵinjectTemplateRef as injectTemplateRef, ɵinjectViewContainerRef as injectViewContainerRef, ɵmarkDirty as markDirty, ɵrenderComponent as renderComponent} from '@angular/core'; +import {ChangeDetectionStrategy, Component, EventEmitter, InjectFlags, Injectable, Input, IterableDiffers, NgModule, Output, createInjector, defineInjector, inject, ɵComponentDef, ɵComponentType as ComponentType, ɵDirectiveDef, ɵDirectiveType as DirectiveType, ɵNgOnChangesFeature as NgOnChangesFeature, ɵdefaultIterableDiffers as defaultIterableDiffers, ɵdefineDirective as defineDirective, ɵdirectiveInject as directiveInject, ɵinjectTemplateRef as injectTemplateRef, ɵinjectViewContainerRef as injectViewContainerRef, ɵmarkDirty as markDirty, ɵrenderComponent as renderComponent} from '@angular/core'; export class Todo { diff --git a/packages/core/test/di/r3_injector_spec.ts b/packages/core/test/di/r3_injector_spec.ts index 7d08f65de5..d6e331f6ca 100644 --- a/packages/core/test/di/r3_injector_spec.ts +++ b/packages/core/test/di/r3_injector_spec.ts @@ -11,7 +11,7 @@ import {InjectionToken} from '../../src/di/injection_token'; import {INJECTOR, Injector, inject} from '../../src/di/injector'; import {R3Injector, createInjector} from '../../src/di/r3_injector'; -describe('InjectorDef-based createInjector()', () => { +describe('ɵInjectorDef-based createInjector()', () => { class CircularA { static ngInjectableDef = defineInjectable({ providedIn: null, diff --git a/packages/core/test/render3/compiler_canonical/back_patch_types_specs.ts b/packages/core/test/render3/compiler_canonical/back_patch_types_specs.ts index 180d555bb9..4e3e2664ae 100644 --- a/packages/core/test/render3/compiler_canonical/back_patch_types_specs.ts +++ b/packages/core/test/render3/compiler_canonical/back_patch_types_specs.ts @@ -6,13 +6,13 @@ * found in the LICENSE file at https://angular.io/license */ -import {Component, ContentChild, Directive, Injectable, Injector, InjectorDef, Input, NgModule, NgModuleFactory, NgModuleRef, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjector} from '../../../src/core'; +import {Component, ContentChild, Directive, Injectable, Injector, Input, NgModule, NgModuleFactory, NgModuleRef, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjector, ɵInjectorDef} from '../../../src/core'; import * as r3 from '../../../src/render3/index'; const details_elided = { type: Object, } as any; -export type $ComponentDef$ = any; +export type $ɵComponentDef$ = any; /////////// // Lib A - Compiled pre-Ivy @@ -52,7 +52,7 @@ const node_modules_libA_module_metadata = { @Component({}) export class LibBComponent { // COMPILER GENERATED - static ngComponentDef: $ComponentDef$ = r3.defineComponent(details_elided); + static ngComponentDef: $ɵComponentDef$ = r3.defineComponent(details_elided); } @NgModule({declarations: [LibAComponent], imports: []}) @@ -84,7 +84,7 @@ const node_modules_libB_module_metadata = { @Component({}) export class AppComponent { // COMPILER GENERATED - static ngComponentDef: $ComponentDef$ = r3.defineComponent(details_elided); + static ngComponentDef: $ɵComponentDef$ = r3.defineComponent(details_elided); } @NgModule({declarations: [LibAComponent], imports: []}) diff --git a/packages/core/test/render3/compiler_canonical/injection_spec.ts b/packages/core/test/render3/compiler_canonical/injection_spec.ts index 3c61d4901c..e1eb61c2d2 100644 --- a/packages/core/test/render3/compiler_canonical/injection_spec.ts +++ b/packages/core/test/render3/compiler_canonical/injection_spec.ts @@ -6,7 +6,7 @@ * found in the LICENSE file at https://angular.io/license */ -import {Attribute, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, ContentChildren, Directive, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectableDef, Injector, InjectorDef, Input, NgModule, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, SkipSelf, TemplateRef, ViewChild, ViewChildren, ViewContainerRef, defineInjectable, defineInjector, inject} from '../../../src/core'; +import {Attribute, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, ContentChildren, Directive, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, Injector, Input, NgModule, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, SkipSelf, TemplateRef, ViewChild, ViewChildren, ViewContainerRef, defineInjectable, defineInjector, inject, ɵInjectableDef, ɵInjectorDef} from '../../../src/core'; import * as $r3$ from '../../../src/core_render3_private_export'; import {renderComponent, toHtml} from '../render_util'; diff --git a/packages/core/test/render3/compiler_canonical/patch_types_spec.ts b/packages/core/test/render3/compiler_canonical/patch_types_spec.ts index 188de69b32..9fd2b1f6ae 100644 --- a/packages/core/test/render3/compiler_canonical/patch_types_spec.ts +++ b/packages/core/test/render3/compiler_canonical/patch_types_spec.ts @@ -6,10 +6,11 @@ * found in the LICENSE file at https://angular.io/license */ -import {Component, ContentChild, Directive, Injectable, InjectableDef, InjectorDef, Input, NgModule, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjectable, defineInjector} from '../../../src/core'; +import {Component, ContentChild, Directive, Injectable, Input, NgModule, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjectable, defineInjector, ɵInjectableDef, ɵInjectorDef} from '../../../src/core'; import * as r3 from '../../../src/render3/index'; + /** * GOALS: * - Patch types in tree shakable way diff --git a/packages/core/test/render3/compiler_canonical/small_app_spec.ts b/packages/core/test/render3/compiler_canonical/small_app_spec.ts index 25807caeb0..c0b9357b0d 100644 --- a/packages/core/test/render3/compiler_canonical/small_app_spec.ts +++ b/packages/core/test/render3/compiler_canonical/small_app_spec.ts @@ -7,7 +7,7 @@ */ import {NgForOf, NgForOfContext} from '@angular/common'; -import {Component, ContentChild, Directive, EventEmitter, Injectable, InjectableDef, InjectorDef, Input, NgModule, OnDestroy, Optional, Output, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjectable, defineInjector} from '@angular/core'; +import {Component, ContentChild, Directive, EventEmitter, Injectable, Input, NgModule, OnDestroy, Optional, Output, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjectable, defineInjector, ɵInjectableDef, ɵInjectorDef} from '@angular/core'; import {withBody} from '@angular/core/testing'; import * as r3 from '../../../src/render3/index'; diff --git a/packages/core/test/render3/render_util.ts b/packages/core/test/render3/render_util.ts index 9e523f86bd..3ea7ddedbb 100644 --- a/packages/core/test/render3/render_util.ts +++ b/packages/core/test/render3/render_util.ts @@ -11,9 +11,9 @@ import {stringifyElement} from '@angular/platform-browser/testing/src/browser_ut import {Injector} from '../../src/di/injector'; import {CreateComponentOptions} from '../../src/render3/component'; import {extractDirectiveDef, extractPipeDef} from '../../src/render3/definition'; -import {ComponentDef, ComponentTemplate, ComponentType, DirectiveDef, DirectiveType, PublicFeature, RenderFlags, defineComponent, defineDirective, renderComponent as _renderComponent, tick} from '../../src/render3/index'; +import {ComponentTemplate, ComponentType, DirectiveType, PublicFeature, RenderFlags, defineComponent, defineDirective, renderComponent as _renderComponent, tick, ɵComponentDef, ɵDirectiveDef} from '../../src/render3/index'; import {NG_HOST_SYMBOL, renderTemplate} from '../../src/render3/instructions'; -import {DirectiveDefList, DirectiveDefListOrFactory, DirectiveTypesOrFactory, PipeDef, PipeDefList, PipeDefListOrFactory, PipeTypesOrFactory} from '../../src/render3/interfaces/definition'; +import {DirectiveDefList, DirectiveDefListOrFactory, DirectiveTypesOrFactory, PipeDefList, PipeDefListOrFactory, PipeTypesOrFactory, ɵPipeDef} from '../../src/render3/interfaces/definition'; import {LElementNode} from '../../src/render3/interfaces/node'; import {RElement, RText, Renderer3, RendererFactory3, domRendererFactory3} from '../../src/render3/interfaces/renderer'; import {Type} from '../../src/type'; @@ -171,13 +171,13 @@ export function renderToHtml( function toDefs( types: DirectiveTypesOrFactory | undefined | null, - mapFn: (type: Type) => DirectiveDef): DirectiveDefList|null; + mapFn: (type: Type) => ɵDirectiveDef): DirectiveDefList|null; function toDefs( types: PipeTypesOrFactory | undefined | null, - mapFn: (type: Type) => PipeDef): PipeDefList|null; + mapFn: (type: Type) => ɵPipeDef): PipeDefList|null; function toDefs( types: PipeTypesOrFactory | DirectiveTypesOrFactory | undefined | null, - mapFn: (type: Type) => PipeDef| DirectiveDef): any { + mapFn: (type: Type) => ɵPipeDef| ɵDirectiveDef): any { if (!types) return null; if (typeof types == 'function') { types = types(); diff --git a/packages/core/test/view/ng_module_spec.ts b/packages/core/test/view/ng_module_spec.ts index 4e89b95ae0..21c0ef943f 100644 --- a/packages/core/test/view/ng_module_spec.ts +++ b/packages/core/test/view/ng_module_spec.ts @@ -7,7 +7,7 @@ */ import {NgModuleRef} from '@angular/core'; -import {InjectableDef, defineInjectable} from '@angular/core/src/di/defs'; +import {defineInjectable, ɵInjectableDef} from '@angular/core/src/di/defs'; import {INJECTOR, InjectFlags, Injector, inject} from '@angular/core/src/di/injector'; import {makePropDecorator} from '@angular/core/src/util/decorators'; import {NgModuleDefinition, NgModuleProviderDef, NodeFlags} from '@angular/core/src/view'; @@ -24,14 +24,14 @@ class MyChildModule {} class NotMyModule {} class Bar { - static ngInjectableDef: InjectableDef = defineInjectable({ + static ngInjectableDef: ɵInjectableDef = defineInjectable({ factory: () => new Bar(), providedIn: MyModule, }); } class Baz { - static ngInjectableDef: InjectableDef = defineInjectable({ + static ngInjectableDef: ɵInjectableDef = defineInjectable({ factory: () => new Baz(), providedIn: NotMyModule, }); @@ -40,7 +40,7 @@ class Baz { class HasNormalDep { constructor(public foo: Foo) {} - static ngInjectableDef: InjectableDef = defineInjectable({ + static ngInjectableDef: ɵInjectableDef = defineInjectable({ factory: () => new HasNormalDep(inject(Foo)), providedIn: MyModule, }); @@ -49,7 +49,7 @@ class HasNormalDep { class HasDefinedDep { constructor(public bar: Bar) {} - static ngInjectableDef: InjectableDef = defineInjectable({ + static ngInjectableDef: ɵInjectableDef = defineInjectable({ factory: () => new HasDefinedDep(inject(Bar)), providedIn: MyModule, }); @@ -58,14 +58,14 @@ class HasDefinedDep { class HasOptionalDep { constructor(public baz: Baz|null) {} - static ngInjectableDef: InjectableDef = defineInjectable({ + static ngInjectableDef: ɵInjectableDef = defineInjectable({ factory: () => new HasOptionalDep(inject(Baz, InjectFlags.Optional)), providedIn: MyModule, }); } class ChildDep { - static ngInjectableDef: InjectableDef = defineInjectable({ + static ngInjectableDef: ɵInjectableDef = defineInjectable({ factory: () => new ChildDep(), providedIn: MyChildModule, }); @@ -73,7 +73,7 @@ class ChildDep { class FromChildWithOptionalDep { constructor(public baz: Baz|null) {} - static ngInjectableDef: InjectableDef = defineInjectable({ + static ngInjectableDef: ɵInjectableDef = defineInjectable({ factory: () => new FromChildWithOptionalDep(inject(Baz, InjectFlags.Default)), providedIn: MyChildModule, }); @@ -81,7 +81,7 @@ class FromChildWithOptionalDep { class FromChildWithSkipSelfDep { constructor(public depFromParent: ChildDep|null, public depFromChild: Bar|null) {} - static ngInjectableDef: InjectableDef = defineInjectable({ + static ngInjectableDef: ɵInjectableDef = defineInjectable({ factory: () => new FromChildWithSkipSelfDep( inject(ChildDep, InjectFlags.SkipSelf|InjectFlags.Optional), inject(Bar, InjectFlags.Self|InjectFlags.Optional)), @@ -119,10 +119,10 @@ describe('NgModuleRef_ injector', () => { it('injects a provided value', () => { expect(ref.injector.get(Foo) instanceof Foo).toBeTruthy(); }); - it('injects an InjectableDef value', + it('injects an ɵInjectableDef value', () => { expect(ref.injector.get(Bar) instanceof Bar).toBeTruthy(); }); - it('caches InjectableDef values', + it('caches ɵInjectableDef values', () => { expect(ref.injector.get(Bar)).toBe(ref.injector.get(Bar)); }); it('injects provided deps properly', () => { diff --git a/tools/public_api_guard/core/core.d.ts b/tools/public_api_guard/core/core.d.ts index 40a2081fbd..7a294ad02e 100644 --- a/tools/public_api_guard/core/core.d.ts +++ b/tools/public_api_guard/core/core.d.ts @@ -244,14 +244,14 @@ export declare class DefaultIterableDiffer implements IterableDiffer, Iter export declare function defineInjectable(opts: { providedIn?: Type | 'root' | 'any' | null; factory: () => T; -}): InjectableDef; +}): ɵInjectableDef; /** @experimental */ export declare function defineInjector(options: { factory: () => any; providers?: any[]; imports?: any[]; -}): InjectorDef; +}): ɵInjectorDef; /** @experimental */ export declare function destroyPlatform(): void; @@ -354,19 +354,12 @@ export interface InjectableDecorator { } & InjectableProvider): Injectable; } -/** @experimental */ -export interface InjectableDef { - factory: () => T; - providedIn: InjectorType | 'root' | 'any' | null; - value: T | undefined; -} - /** @experimental */ export declare type InjectableProvider = ValueSansProvider | ExistingSansProvider | StaticClassSansProvider | ConstructorSansProvider | FactorySansProvider | ClassSansProvider; /** @experimental */ export interface InjectableType extends Type { - ngInjectableDef: InjectableDef; + ngInjectableDef: ɵInjectableDef; } export interface InjectDecorator { @@ -384,7 +377,7 @@ export declare const enum InjectFlags { export declare class InjectionToken { protected _desc: string; - readonly ngInjectableDef: InjectableDef | undefined; + readonly ngInjectableDef: ɵInjectableDef | undefined; constructor(_desc: string, options?: { providedIn?: Type | 'root' | null; factory: () => T; @@ -397,7 +390,7 @@ export declare abstract class Injector { /** @deprecated */ abstract get(token: any, notFoundValue?: any): any; static NULL: Injector; static THROW_IF_NOT_FOUND: Object; - static ngInjectableDef: InjectableDef; + static ngInjectableDef: ɵInjectableDef; /** @deprecated */ static create(providers: StaticProvider[], parent?: Injector): Injector; static create(options: { providers: StaticProvider[]; @@ -409,16 +402,9 @@ export declare abstract class Injector { /** @experimental */ export declare const INJECTOR: InjectionToken; -/** @experimental */ -export interface InjectorDef { - factory: () => T; - imports: (InjectorType | InjectorTypeWithProviders)[]; - providers: (Type | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | any[])[]; -} - /** @experimental */ export interface InjectorType extends Type { - ngInjectorDef: InjectorDef; + ngInjectorDef: ɵInjectorDef; } /** @experimental */ @@ -462,7 +448,7 @@ export declare class IterableDiffers { /** @deprecated */ factories: IterableDifferFactory[]; constructor(factories: IterableDifferFactory[]); find(iterable: any): IterableDifferFactory; - static ngInjectableDef: InjectableDef; + static ngInjectableDef: ɵInjectableDef; static create(factories: IterableDifferFactory[], parent?: IterableDiffers): IterableDiffers; static extend(factories: IterableDifferFactory[]): StaticProvider; }