From 674c3def319e2c444823319ae43394d46f3973b7 Mon Sep 17 00:00:00 2001 From: Igor Minar Date: Fri, 13 Apr 2018 23:02:29 -0700 Subject: [PATCH] revert: refactor(ivy): make return value of define(Component|Directive|Pipe|Injector|Injectable) private (#23371) This reverts commit 2c09b707ce2c185cf617050a7b0ab1ff9b587be0. --- .../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, 172 insertions(+), 179 deletions(-) diff --git a/modules/benchmarks/src/largetable/render3/table.ts b/modules/benchmarks/src/largetable/render3/table.ts index 6270aaf244..85b43102ce 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 7517b51258..61bd0955e0 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 5bfe95c4d2..14845f2c07 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 1292c983e8..912bfe7b7c 100644 --- a/packages/core/src/change_detection/differs/iterable_differs.ts +++ b/packages/core/src/change_detection/differs/iterable_differs.ts @@ -6,13 +6,12 @@ * found in the LICENSE file at https://angular.io/license */ -import {defineInjectable, ɵInjectableDef} from '../../di/defs'; +import {InjectableDef, defineInjectable} 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. * @@ -138,7 +137,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 016a6931eb..136b4fd3e4 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, - ɵDirectiveDef, - ɵPipeDef, + ComponentDef as ɵComponentDef, + DirectiveDef as ɵDirectiveDef, + PipeDef as ɵ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 362b5431c8..9cfa828cbd 100644 --- a/packages/core/src/di/defs.ts +++ b/packages/core/src/di/defs.ts @@ -17,15 +17,14 @@ 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. * - * 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. + * This type is typically generated by the Angular compiler, but can be hand-written if needed. * * @experimental */ -export interface ɵInjectableDef { +export interface InjectableDef { /** * Specifies that the given type belongs to a particular injector: * - `InjectorType` such as `NgModule`, @@ -51,13 +50,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 @@ -69,29 +68,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 */ @@ -103,7 +102,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 @@ -121,7 +120,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, @@ -130,7 +129,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`. @@ -150,7 +149,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 c7fdbc407d..507623051a 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 {InjectableType, defineInjectable, ɵInjectableDef} from './defs'; +import {InjectableDef, InjectableType, defineInjectable} 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 bbe432aa0a..080ee0188e 100644 --- a/packages/core/src/di/injection_token.ts +++ b/packages/core/src/di/injection_token.ts @@ -8,8 +8,7 @@ import {Type} from '../type'; -import {defineInjectable, ɵInjectableDef} from './defs'; - +import {InjectableDef, defineInjectable} from './defs'; /** * Creates a token that can be used in a DI Provider. @@ -53,7 +52,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, @@ -73,5 +72,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 5416a5ce86..87d829e2ba 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 {defineInjectable, ɵInjectableDef} from './defs'; +import {InjectableDef, defineInjectable} 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 e770029c5a..a3d679b762 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 {InjectableType, InjectorType, InjectorTypeWithProviders, ɵInjectableDef, ɵInjectorDef} from './defs'; +import {InjectableDef, InjectableType, InjectorDef, InjectorType, InjectorTypeWithProviders} 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 da1947b3ad..60e9986efb 100644 --- a/packages/core/src/metadata/ng_module.ts +++ b/packages/core/src/metadata/ng_module.ts @@ -6,14 +6,13 @@ * found in the LICENSE file at https://angular.io/license */ -import {InjectorType, defineInjector, ɵInjectorDef} from '../di/defs'; +import {InjectorDef, InjectorType, defineInjector} 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 ac41105777..c4f53ac9a9 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 {ComponentType, ɵComponentDef} from './interfaces/definition'; +import {ComponentDef, ComponentType} 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 ed49b17710..e3851fe2fb 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 {ComponentDefFeature, ComponentTemplate, ComponentType, DirectiveDefFeature, DirectiveDefListOrFactory, DirectiveType, DirectiveTypesOrFactory, PipeType, PipeTypesOrFactory, ɵComponentDef, ɵDirectiveDef, ɵPipeDef} from './interfaces/definition'; +import {ComponentDef, ComponentDefFeature, ComponentTemplate, ComponentType, DirectiveDef, DirectiveDefFeature, DirectiveDefListOrFactory, DirectiveType, DirectiveTypesOrFactory, PipeDef, PipeType, PipeTypesOrFactory} 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 = <ɵComponentDef>{ + const def = >{ 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>{ +}): PipeDef { + return >{ 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 32abece2c4..c1c76c53fa 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, DirectiveDefList, PipeDefList, ɵDirectiveDef} from './interfaces/definition'; +import {ComponentTemplate, DirectiveDef, DirectiveDefList, PipeDefList} 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): voi * * @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 5bb6a9d9b6..0094566580 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): v } /** 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 7f78dec1de..ea2206fa10 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 {ComponentTemplate, ComponentType, DirectiveDefFlags, DirectiveType, ɵComponentDef, ɵDirectiveDef, ɵPipeDef} from './interfaces/definition'; +import {ComponentDef, ComponentTemplate, ComponentType, DirectiveDef, DirectiveDefFlags, DirectiveType, 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 280a771686..a4df47a916 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]); } } @@ -579,7 +579,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); @@ -596,7 +596,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; } @@ -609,7 +609,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(); @@ -664,7 +664,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); } } @@ -692,11 +692,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; } } @@ -802,12 +802,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, @@ -1014,7 +1014,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) { @@ -1204,18 +1204,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) { @@ -1233,7 +1233,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 @@ -1259,7 +1259,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'); @@ -1632,7 +1632,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])); @@ -1944,7 +1944,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); } @@ -1966,7 +1966,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 b44555c15a..beb1804d73 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,18 +65,13 @@ 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; @@ -140,13 +135,8 @@ 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. * @@ -179,8 +169,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; @@ -204,13 +194,8 @@ 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. * @@ -238,8 +223,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. @@ -248,12 +233,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 */)[]; /** @@ -263,12 +248,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 dba909f601..24742998ee 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, DirectiveDefList, PipeDefList, ɵDirectiveDef, ɵPipeDef} from './definition'; +import {ComponentTemplate, DirectiveDef, DirectiveDefList, PipeDef, PipeDefList} 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 7e8a80497f..83880d3004 100644 --- a/packages/core/src/render3/pipe.ts +++ b/packages/core/src/render3/pipe.ts @@ -9,10 +9,9 @@ import {PipeTransform} from '../change_detection/pipe_transform'; import {getTView, load, store} from './instructions'; -import {PipeDefList, ɵPipeDef} from './interfaces/definition'; +import {PipeDef, PipeDefList} from './interfaces/definition'; import {pureFunction1, pureFunction2, pureFunction3, pureFunction4, pureFunctionV} from './pure_function'; - /** * Create a pipe. * @@ -22,7 +21,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); @@ -31,7 +30,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(); @@ -45,9 +44,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]; @@ -141,5 +140,5 @@ export function pipeBindV(index: number, values: any[]): any { } function isPure(index: number): boolean { - return (<ɵPipeDef>getTView().data[index]).pure; + return (>getTView().data[index]).pure; } diff --git a/packages/core/src/render3/query.ts b/packages/core/src/render3/query.ts index ab44d1645d..e81fcaf1f9 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 {unusedValueExportToPlacateAjd as unused1, ɵDirectiveDef} from './interfaces/definition'; +import {DirectiveDef, unusedValueExportToPlacateAjd as unused1} 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 8f9b1f9795..20f4ef060d 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 a88d6aaabf..669aae806b 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 {Injector, createInjector, defineInjectable, defineInjector, ɵInjectableDef, ɵInjectorDef} from '@angular/core'; +import {InjectableDef, Injector, InjectorDef, createInjector, defineInjectable, defineInjector} 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 2d17afa510..cbaf6b8caa 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, ɵ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'; +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'; export class Todo { diff --git a/packages/core/test/di/r3_injector_spec.ts b/packages/core/test/di/r3_injector_spec.ts index d6e331f6ca..7d08f65de5 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 4e3e2664ae..180d555bb9 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, Input, NgModule, NgModuleFactory, NgModuleRef, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjector, ɵInjectorDef} from '../../../src/core'; +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 * 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 e1eb61c2d2..3c61d4901c 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, Injector, Input, NgModule, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, SkipSelf, TemplateRef, ViewChild, ViewChildren, ViewContainerRef, defineInjectable, defineInjector, inject, ɵInjectableDef, ɵInjectorDef} from '../../../src/core'; +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 * 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 9fd2b1f6ae..188de69b32 100644 --- a/packages/core/test/render3/compiler_canonical/patch_types_spec.ts +++ b/packages/core/test/render3/compiler_canonical/patch_types_spec.ts @@ -6,11 +6,10 @@ * found in the LICENSE file at https://angular.io/license */ -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 {Component, ContentChild, Directive, Injectable, InjectableDef, InjectorDef, Input, NgModule, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjectable, defineInjector} 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 c0b9357b0d..25807caeb0 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, Input, NgModule, OnDestroy, Optional, Output, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjectable, defineInjector, ɵInjectableDef, ɵInjectorDef} from '@angular/core'; +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 {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 3ea7ddedbb..9e523f86bd 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 {ComponentTemplate, ComponentType, DirectiveType, PublicFeature, RenderFlags, defineComponent, defineDirective, renderComponent as _renderComponent, tick, ɵComponentDef, ɵDirectiveDef} from '../../src/render3/index'; +import {ComponentDef, ComponentTemplate, ComponentType, DirectiveDef, DirectiveType, PublicFeature, RenderFlags, defineComponent, defineDirective, renderComponent as _renderComponent, tick} from '../../src/render3/index'; import {NG_HOST_SYMBOL, renderTemplate} from '../../src/render3/instructions'; -import {DirectiveDefList, DirectiveDefListOrFactory, DirectiveTypesOrFactory, PipeDefList, PipeDefListOrFactory, PipeTypesOrFactory, ɵPipeDef} from '../../src/render3/interfaces/definition'; +import {DirectiveDefList, DirectiveDefListOrFactory, DirectiveTypesOrFactory, PipeDef, PipeDefList, PipeDefListOrFactory, PipeTypesOrFactory} 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 21c0ef943f..4e89b95ae0 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 {defineInjectable, ɵInjectableDef} from '@angular/core/src/di/defs'; +import {InjectableDef, defineInjectable} 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 7a294ad02e..40a2081fbd 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,12 +354,19 @@ 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 { @@ -377,7 +384,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; @@ -390,7 +397,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[]; @@ -402,9 +409,16 @@ 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 */ @@ -448,7 +462,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; }