5430d2bc66
- Wraps the NgOnChangesFeature in a factory such that no side effects occur in the module root - Adds comments to ngInherit property on feature definition interface to help guide others not to make the same mistake - Updates compiler to generate the feature properly after the change to it being a factory - Updates appropriate tests PR Close #28187
2973 lines
91 KiB
TypeScript
2973 lines
91 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
|
|
import {ComponentFactoryResolver, OnDestroy, SimpleChange, SimpleChanges, ViewContainerRef} from '../../src/core';
|
|
import {AttributeMarker, ComponentTemplate, LifecycleHooksFeature, NO_CHANGE, NgOnChangesFeature, defineComponent, defineDirective, injectComponentFactoryResolver} from '../../src/render3/index';
|
|
|
|
import {bind, container, containerRefreshEnd, containerRefreshStart, directiveInject, element, elementEnd, elementProperty, elementStart, embeddedViewEnd, embeddedViewStart, listener, markDirty, projection, projectionDef, store, template, text} from '../../src/render3/instructions';
|
|
import {RenderFlags} from '../../src/render3/interfaces/definition';
|
|
|
|
import {NgIf} from './common_with_def';
|
|
import {ComponentFixture, containerEl, createComponent, renderComponent, renderToHtml, requestAnimationFrame} from './render_util';
|
|
import {fixmeIvy} from '@angular/private/testing';
|
|
|
|
describe('lifecycles', () => {
|
|
|
|
function getParentTemplate(name: string) {
|
|
return (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, name);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', bind(ctx.val));
|
|
}
|
|
};
|
|
}
|
|
|
|
describe('onInit', () => {
|
|
let events: string[];
|
|
|
|
beforeEach(() => { events = []; });
|
|
|
|
let Comp = createOnInitComponent('comp', (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
projectionDef();
|
|
elementStart(0, 'div');
|
|
{ projection(1); }
|
|
elementEnd();
|
|
}
|
|
}, 2);
|
|
let Parent = createOnInitComponent('parent', getParentTemplate('comp'), 1, 1, [Comp]);
|
|
let ProjectedComp = createOnInitComponent('projected', (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
text(0, 'content');
|
|
}
|
|
}, 1);
|
|
|
|
function createOnInitComponent(
|
|
name: string, template: ComponentTemplate<any>, consts: number, vars: number = 0,
|
|
directives: any[] = []) {
|
|
return class Component {
|
|
val: string = '';
|
|
ngOnInit() {
|
|
if (!this.val) this.val = '';
|
|
events.push(`${name}${this.val}`);
|
|
}
|
|
|
|
static ngComponentDef = defineComponent({
|
|
type: Component,
|
|
selectors: [[name]],
|
|
consts: consts,
|
|
vars: vars,
|
|
factory: () => new Component(),
|
|
inputs: {val: 'val'}, template,
|
|
directives: directives
|
|
});
|
|
};
|
|
}
|
|
|
|
class Directive {
|
|
ngOnInit() { events.push('dir'); }
|
|
|
|
static ngDirectiveDef = defineDirective(
|
|
{type: Directive, selectors: [['', 'dir', '']], factory: () => new Directive()});
|
|
}
|
|
|
|
const directives = [Comp, Parent, ProjectedComp, Directive, NgIf];
|
|
|
|
it('should call onInit method after inputs are set in creation mode (and not in update mode)',
|
|
() => {
|
|
/** <comp [val]="val"></comp> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', bind(ctx.val));
|
|
}
|
|
}, 1, 1, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
fixture.update();
|
|
expect(events).toEqual(['comp']);
|
|
|
|
fixture.component.val = '2';
|
|
fixture.update();
|
|
expect(events).toEqual(['comp']);
|
|
});
|
|
|
|
it('should be called on root component in creation mode', () => {
|
|
const comp = renderComponent(Comp, {hostFeatures: [LifecycleHooksFeature]});
|
|
expect(events).toEqual(['comp']);
|
|
|
|
markDirty(comp);
|
|
requestAnimationFrame.flush();
|
|
expect(events).toEqual(['comp']);
|
|
});
|
|
|
|
it('should call parent onInit before child onInit', () => {
|
|
/**
|
|
* <parent></parent>
|
|
* parent temp: <comp></comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
}
|
|
}, 1, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['parent', 'comp']);
|
|
});
|
|
|
|
it('should call all parent onInits across view before calling children onInits', () => {
|
|
/**
|
|
* <parent [val]="1"></parent>
|
|
* <parent [val]="2"></parent>
|
|
*
|
|
* parent temp: <comp [val]="val"></comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
element(1, 'parent');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(1, 'val', 2);
|
|
}
|
|
}, 2, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['parent1', 'parent2', 'comp1', 'comp2']);
|
|
});
|
|
|
|
|
|
it('should call onInit every time a new view is created (if block)', () => {
|
|
/**
|
|
* % if (!skip) {
|
|
* <comp></comp>
|
|
* % }
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
container(0);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
containerRefreshStart(0);
|
|
{
|
|
if (!ctx.skip) {
|
|
let rf1 = embeddedViewStart(0, 1, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 1, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp']);
|
|
|
|
fixture.component.skip = true;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp']);
|
|
|
|
fixture.component.skip = false;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp', 'comp']);
|
|
});
|
|
|
|
|
|
it('should call onInit every time a new view is created (ngIf)', () => {
|
|
|
|
function IfTemplate(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
}
|
|
|
|
/** <comp *ngIf="showing"></comp> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
template(0, IfTemplate, 1, 0, 'comp', ['ngIf', '']);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'ngIf', bind(ctx.showing));
|
|
}
|
|
}, 1, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
|
|
fixture.component.showing = true;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp']);
|
|
|
|
fixture.component.showing = false;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp']);
|
|
|
|
fixture.component.showing = true;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp', 'comp']);
|
|
});
|
|
|
|
it('should call onInit for children of dynamically created components', () => {
|
|
let viewContainerComp !: ViewContainerComp;
|
|
|
|
class ViewContainerComp {
|
|
constructor(public vcr: ViewContainerRef, public cfr: ComponentFactoryResolver) {}
|
|
|
|
static ngComponentDef = defineComponent({
|
|
type: ViewContainerComp,
|
|
selectors: [['view-container-comp']],
|
|
factory: () => viewContainerComp = new ViewContainerComp(
|
|
directiveInject(ViewContainerRef as any), injectComponentFactoryResolver()),
|
|
consts: 0,
|
|
vars: 0,
|
|
template: (rf: RenderFlags, ctx: ViewContainerComp) => {}
|
|
});
|
|
}
|
|
|
|
const DynamicComp = createComponent('dynamic-comp', (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
}, 1, 0, [Comp]);
|
|
|
|
const fixture = new ComponentFixture(ViewContainerComp);
|
|
expect(events).toEqual([]);
|
|
|
|
viewContainerComp.vcr.createComponent(
|
|
viewContainerComp.cfr.resolveComponentFactory(DynamicComp));
|
|
fixture.update();
|
|
expect(events).toEqual(['comp']);
|
|
});
|
|
|
|
it('should call onInit in hosts before their content children', () => {
|
|
/**
|
|
* <comp>
|
|
* <projected></projected>
|
|
* </comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'comp');
|
|
{ elementStart(1, 'projected'); }
|
|
elementEnd();
|
|
}
|
|
}, 2, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp', 'projected']);
|
|
});
|
|
|
|
it('should call onInit in host and its content children before next host', () => {
|
|
/**
|
|
* <comp [val]="1">
|
|
* <projected [val]="1"></projected>
|
|
* </comp>
|
|
* <comp [val]="2">
|
|
* <projected [val]="1"></projected>
|
|
* </comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'comp');
|
|
{ elementStart(1, 'projected'); }
|
|
elementEnd();
|
|
elementStart(2, 'comp');
|
|
{ elementStart(3, 'projected'); }
|
|
elementEnd();
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(1, 'val', 1);
|
|
elementProperty(2, 'val', 2);
|
|
elementProperty(3, 'val', 2);
|
|
}
|
|
}, 4, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp1', 'projected1', 'comp2', 'projected2']);
|
|
});
|
|
|
|
it('should be called on directives after component', () => {
|
|
/** <comp directive></comp> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp', ['dir', '']);
|
|
}
|
|
}, 1, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp', 'dir']);
|
|
|
|
fixture.update();
|
|
expect(events).toEqual(['comp', 'dir']);
|
|
});
|
|
|
|
it('should be called on directives on an element', () => {
|
|
/** <div directive></div> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'div', ['dir', '']);
|
|
}
|
|
}, 1, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['dir']);
|
|
|
|
fixture.update();
|
|
expect(events).toEqual(['dir']);
|
|
});
|
|
|
|
it('should call onInit properly in for loop', () => {
|
|
/**
|
|
* <comp [val]="1"></comp>
|
|
* % for (let j = 2; j < 5; j++) {
|
|
* <comp [val]="j"></comp>
|
|
* % }
|
|
* <comp [val]="5"></comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
container(1);
|
|
element(2, 'comp');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(2, 'val', 5);
|
|
containerRefreshStart(1);
|
|
{
|
|
for (let j = 2; j < 5; j++) {
|
|
let rf1 = embeddedViewStart(0, 1, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
if (rf1 & RenderFlags.Update) {
|
|
elementProperty(0, 'val', j);
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 3, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
// onInit is called top to bottom, so top level comps (1 and 5) are called
|
|
// before the comps inside the for loop's embedded view (2, 3, and 4)
|
|
expect(events).toEqual(['comp1', 'comp5', 'comp2', 'comp3', 'comp4']);
|
|
});
|
|
|
|
it('should call onInit properly in for loop with children', () => {
|
|
/**
|
|
* <parent [val]="1"></parent>
|
|
* % for (let j = 2; j < 5; j++) {
|
|
* <parent [val]="j"></parent>
|
|
* % }
|
|
* <parent [val]="5"></parent>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
container(1);
|
|
element(2, 'parent');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(2, 'val', 5);
|
|
containerRefreshStart(1);
|
|
{
|
|
for (let j = 2; j < 5; j++) {
|
|
let rf1 = embeddedViewStart(0, 1, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
}
|
|
if (rf1 & RenderFlags.Update) {
|
|
elementProperty(0, 'val', j);
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 3, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
// onInit is called top to bottom, so top level comps (1 and 5) are called
|
|
// before the comps inside the for loop's embedded view (2, 3, and 4)
|
|
expect(events).toEqual([
|
|
'parent1', 'parent5', 'parent2', 'comp2', 'parent3', 'comp3', 'parent4', 'comp4', 'comp1',
|
|
'comp5'
|
|
]);
|
|
});
|
|
|
|
});
|
|
|
|
describe('doCheck', () => {
|
|
let events: string[];
|
|
let allEvents: string[];
|
|
|
|
beforeEach(() => {
|
|
events = [];
|
|
allEvents = [];
|
|
});
|
|
|
|
let Comp = createDoCheckComponent('comp', (rf: RenderFlags, ctx: any) => {});
|
|
let Parent = createDoCheckComponent('parent', getParentTemplate('comp'), 1, 1, [Comp]);
|
|
|
|
function createDoCheckComponent(
|
|
name: string, template: ComponentTemplate<any>, consts: number = 0, vars: number = 0,
|
|
directives: any[] = []) {
|
|
return class Component {
|
|
ngDoCheck() {
|
|
events.push(name);
|
|
allEvents.push('check ' + name);
|
|
}
|
|
|
|
ngOnInit() { allEvents.push('init ' + name); }
|
|
|
|
static ngComponentDef = defineComponent({
|
|
type: Component,
|
|
selectors: [[name]],
|
|
factory: () => new Component(), template,
|
|
consts: consts,
|
|
vars: vars,
|
|
directives: directives
|
|
});
|
|
};
|
|
}
|
|
|
|
class Directive {
|
|
ngDoCheck() { events.push('dir'); }
|
|
|
|
static ngDirectiveDef = defineDirective(
|
|
{type: Directive, selectors: [['', 'dir', '']], factory: () => new Directive()});
|
|
}
|
|
|
|
const directives = [Comp, Parent, Directive];
|
|
|
|
it('should call doCheck on every refresh', () => {
|
|
/** <comp></comp> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
}, 1, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp']);
|
|
|
|
fixture.update();
|
|
expect(events).toEqual(['comp', 'comp']);
|
|
});
|
|
|
|
it('should be called on root component', () => {
|
|
const comp = renderComponent(Comp, {hostFeatures: [LifecycleHooksFeature]});
|
|
expect(events).toEqual(['comp']);
|
|
|
|
markDirty(comp);
|
|
requestAnimationFrame.flush();
|
|
expect(events).toEqual(['comp', 'comp']);
|
|
});
|
|
|
|
it('should call parent doCheck before child doCheck', () => {
|
|
/**
|
|
* <parent></parent>
|
|
* parent temp: <comp></comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
}
|
|
}, 1, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['parent', 'comp']);
|
|
});
|
|
|
|
it('should call ngOnInit before ngDoCheck if creation mode', () => {
|
|
/** <comp></comp> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
}, 1, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(allEvents).toEqual(['init comp', 'check comp']);
|
|
|
|
fixture.update();
|
|
expect(allEvents).toEqual(['init comp', 'check comp', 'check comp']);
|
|
});
|
|
|
|
it('should be called on directives after component', () => {
|
|
/** <comp directive></comp> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp', ['dir', '']);
|
|
}
|
|
}, 1, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp', 'dir']);
|
|
|
|
fixture.update();
|
|
expect(events).toEqual(['comp', 'dir', 'comp', 'dir']);
|
|
});
|
|
|
|
it('should be called on directives on an element', () => {
|
|
/** <div directive></div> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'div', ['dir', '']);
|
|
}
|
|
}, 1, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['dir']);
|
|
|
|
fixture.update();
|
|
expect(events).toEqual(['dir', 'dir']);
|
|
});
|
|
|
|
});
|
|
|
|
describe('afterContentInit', () => {
|
|
let events: string[];
|
|
let allEvents: string[];
|
|
|
|
beforeEach(() => {
|
|
events = [];
|
|
allEvents = [];
|
|
});
|
|
|
|
let Comp = createAfterContentInitComp('comp', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
projectionDef();
|
|
projection(0);
|
|
}
|
|
}, 1);
|
|
|
|
let Parent = createAfterContentInitComp('parent', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
projectionDef();
|
|
elementStart(0, 'comp');
|
|
{ projection(1); }
|
|
elementEnd();
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', bind(ctx.val));
|
|
}
|
|
}, 2, 1, [Comp]);
|
|
|
|
let ProjectedComp = createAfterContentInitComp('projected', (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
projectionDef();
|
|
projection(0);
|
|
}
|
|
}, 1);
|
|
|
|
function createAfterContentInitComp(
|
|
name: string, template: ComponentTemplate<any>, consts: number = 0, vars: number = 0,
|
|
directives: any[] = []) {
|
|
return class Component {
|
|
val: string = '';
|
|
ngAfterContentInit() {
|
|
events.push(`${name}${this.val}`);
|
|
allEvents.push(`${name}${this.val} init`);
|
|
}
|
|
ngAfterContentChecked() { allEvents.push(`${name}${this.val} check`); }
|
|
|
|
static ngComponentDef = defineComponent({
|
|
type: Component,
|
|
selectors: [[name]],
|
|
factory: () => new Component(),
|
|
consts: consts,
|
|
vars: vars,
|
|
inputs: {val: 'val'},
|
|
template: template,
|
|
directives: directives
|
|
});
|
|
};
|
|
}
|
|
|
|
class Directive {
|
|
ngAfterContentInit() { events.push('init'); }
|
|
ngAfterContentChecked() { events.push('check'); }
|
|
|
|
static ngDirectiveDef = defineDirective(
|
|
{type: Directive, selectors: [['', 'dir', '']], factory: () => new Directive()});
|
|
}
|
|
|
|
function ForLoopWithChildrenTemplate(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'parent');
|
|
{ text(1, 'content'); }
|
|
elementEnd();
|
|
container(2);
|
|
elementStart(3, 'parent');
|
|
{ text(4, 'content'); }
|
|
elementEnd();
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(3, 'val', 4);
|
|
containerRefreshStart(2);
|
|
{
|
|
for (let i = 2; i < 4; i++) {
|
|
let rf1 = embeddedViewStart(0, 2, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
elementStart(0, 'parent');
|
|
{ text(1, 'content'); }
|
|
elementEnd();
|
|
}
|
|
if (rf1 & RenderFlags.Update) {
|
|
elementProperty(0, 'val', i);
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}
|
|
|
|
const directives = [Comp, Parent, ProjectedComp, Directive];
|
|
|
|
it('should be called only in creation mode', () => {
|
|
/** <comp>content</comp> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'comp');
|
|
{ text(1, 'content'); }
|
|
elementEnd();
|
|
}
|
|
}, 2, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp']);
|
|
|
|
fixture.update();
|
|
expect(events).toEqual(['comp']);
|
|
});
|
|
|
|
it('should be called on root component in creation mode', () => {
|
|
const comp = renderComponent(Comp, {hostFeatures: [LifecycleHooksFeature]});
|
|
expect(events).toEqual(['comp']);
|
|
|
|
markDirty(comp);
|
|
requestAnimationFrame.flush();
|
|
expect(events).toEqual(['comp']);
|
|
});
|
|
|
|
it('should be called on every init (if blocks)', () => {
|
|
/**
|
|
* % if (!skip) {
|
|
* <comp>content</comp>
|
|
* % }
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
container(0);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
containerRefreshStart(0);
|
|
{
|
|
if (!ctx.skip) {
|
|
let rf1 = embeddedViewStart(0, 2, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
elementStart(0, 'comp');
|
|
{ text(1, 'content'); }
|
|
elementEnd();
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 1, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp']);
|
|
|
|
fixture.component.skip = true;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp']);
|
|
|
|
fixture.component.skip = false;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp', 'comp']);
|
|
});
|
|
|
|
it('should be called in parents before children', () => {
|
|
/**
|
|
* <parent>content</parent>
|
|
*
|
|
* parent template: <comp><ng-content></ng-content></comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'parent');
|
|
{ text(1, 'content'); }
|
|
elementEnd();
|
|
}
|
|
}, 2, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['parent', 'comp']);
|
|
});
|
|
|
|
it('should be called breadth-first in entire parent subtree before any children', () => {
|
|
/**
|
|
* <parent [val]="1">content</parent>
|
|
* <parent [val]="2">content</parent>
|
|
*
|
|
* parent template: <comp [val]="val"><ng-content></ng-content></comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'parent');
|
|
{ text(1, 'content'); }
|
|
elementEnd();
|
|
elementStart(2, 'parent');
|
|
{ text(3, 'content'); }
|
|
elementEnd();
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(2, 'val', 2);
|
|
}
|
|
}, 4, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['parent1', 'parent2', 'comp1', 'comp2']);
|
|
});
|
|
|
|
it('should be called in projected components before their hosts', () => {
|
|
/**
|
|
* <parent>
|
|
* <projected>content</projected>
|
|
* </parent>
|
|
*
|
|
* parent template:
|
|
* <comp><ng-content></ng-content></comp>
|
|
*
|
|
* projected comp: <ng-content></ng-content>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'parent');
|
|
{
|
|
elementStart(1, 'projected');
|
|
{ text(2, 'content'); }
|
|
elementEnd();
|
|
}
|
|
elementEnd();
|
|
}
|
|
}, 3, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['projected', 'parent', 'comp']);
|
|
});
|
|
|
|
it('should be called in projected components and hosts before children', () => {
|
|
/**
|
|
* <parent [val]="1">
|
|
* <projected [val]="1">content</projected>
|
|
* </parent>
|
|
* * <parent [val]="2">
|
|
* <projected [val]="2">content</projected>
|
|
* </parent>
|
|
*
|
|
* parent template:
|
|
* <comp [val]="val"><ng-content></ng-content></comp>
|
|
*
|
|
* projected comp: <ng-content></ng-content>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'parent');
|
|
{
|
|
elementStart(1, 'projected');
|
|
{ text(2, 'content'); }
|
|
elementEnd();
|
|
}
|
|
elementEnd();
|
|
elementStart(3, 'parent');
|
|
{
|
|
elementStart(4, 'projected');
|
|
{ text(5, 'content'); }
|
|
elementEnd();
|
|
}
|
|
elementEnd();
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(1, 'val', 1);
|
|
elementProperty(3, 'val', 2);
|
|
elementProperty(4, 'val', 2);
|
|
}
|
|
}, 6, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['projected1', 'parent1', 'projected2', 'parent2', 'comp1', 'comp2']);
|
|
});
|
|
|
|
it('should be called in correct order in a for loop', () => {
|
|
/**
|
|
* <comp [val]="1">content</comp>
|
|
* % for(let i = 2; i < 4; i++) {
|
|
* <comp [val]="i">content</comp>
|
|
* % }
|
|
* <comp [val]="4">content</comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'comp');
|
|
{ text(1, 'content'); }
|
|
elementEnd();
|
|
container(2);
|
|
elementStart(3, 'comp');
|
|
{ text(4, 'content'); }
|
|
elementEnd();
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(3, 'val', 4);
|
|
containerRefreshStart(2);
|
|
{
|
|
for (let i = 2; i < 4; i++) {
|
|
let rf1 = embeddedViewStart(0, 2, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
elementStart(0, 'comp');
|
|
{ text(1, 'content'); }
|
|
elementEnd();
|
|
}
|
|
if (rf1 & RenderFlags.Update) {
|
|
elementProperty(0, 'val', i);
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 5, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp2', 'comp3', 'comp1', 'comp4']);
|
|
});
|
|
|
|
it('should be called in correct order in a for loop with children', () => {
|
|
/**
|
|
* <parent [val]="1">content</parent>
|
|
* % for(let i = 2; i < 4; i++) {
|
|
* <parent [val]="i">content</parent>
|
|
* % }
|
|
* <parent [val]="4">content</parent>
|
|
*/
|
|
|
|
renderToHtml(ForLoopWithChildrenTemplate, {}, 5, 0, directives);
|
|
expect(events).toEqual(
|
|
['parent2', 'comp2', 'parent3', 'comp3', 'parent1', 'parent4', 'comp1', 'comp4']);
|
|
});
|
|
|
|
describe('ngAfterContentChecked', () => {
|
|
|
|
it('should be called every change detection run after afterContentInit', () => {
|
|
/** <comp>content</comp> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'comp');
|
|
{ text(1, 'content'); }
|
|
elementEnd();
|
|
}
|
|
}, 2, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(allEvents).toEqual(['comp init', 'comp check']);
|
|
|
|
fixture.update();
|
|
expect(allEvents).toEqual(['comp init', 'comp check', 'comp check']);
|
|
});
|
|
|
|
it('should be called on root component', () => {
|
|
const comp = renderComponent(Comp, {hostFeatures: [LifecycleHooksFeature]});
|
|
expect(allEvents).toEqual(['comp init', 'comp check']);
|
|
|
|
markDirty(comp);
|
|
requestAnimationFrame.flush();
|
|
expect(allEvents).toEqual(['comp init', 'comp check', 'comp check']);
|
|
});
|
|
|
|
});
|
|
|
|
describe('directives', () => {
|
|
it('should be called on directives after component', () => {
|
|
/** <comp directive></comp> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp', ['dir', '']);
|
|
}
|
|
}, 1, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp', 'init', 'check']);
|
|
});
|
|
|
|
it('should be called on directives on an element', () => {
|
|
/** <div directive></div> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'div', ['dir', '']);
|
|
}
|
|
}, 1, 0, directives);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['init', 'check']);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('afterViewInit', () => {
|
|
let events: string[];
|
|
let allEvents: string[];
|
|
|
|
beforeEach(() => {
|
|
events = [];
|
|
allEvents = [];
|
|
});
|
|
|
|
let Comp = createAfterViewInitComponent('comp', (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
projectionDef();
|
|
elementStart(0, 'div');
|
|
{ projection(1); }
|
|
elementEnd();
|
|
}
|
|
}, 2);
|
|
let Parent = createAfterViewInitComponent('parent', getParentTemplate('comp'), 1, 1, [Comp]);
|
|
|
|
let ProjectedComp = createAfterViewInitComponent('projected', (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
text(0, 'content');
|
|
}
|
|
}, 1);
|
|
|
|
function createAfterViewInitComponent(
|
|
name: string, template: ComponentTemplate<any>, consts: number, vars: number = 0,
|
|
directives: any[] = []) {
|
|
return class Component {
|
|
val: string = '';
|
|
ngAfterViewInit() {
|
|
if (!this.val) this.val = '';
|
|
events.push(`${name}${this.val}`);
|
|
allEvents.push(`${name}${this.val} init`);
|
|
}
|
|
ngAfterViewChecked() { allEvents.push(`${name}${this.val} check`); }
|
|
|
|
static ngComponentDef = defineComponent({
|
|
type: Component,
|
|
selectors: [[name]],
|
|
consts: consts,
|
|
vars: vars,
|
|
factory: () => new Component(),
|
|
inputs: {val: 'val'},
|
|
template: template,
|
|
directives: directives
|
|
});
|
|
};
|
|
}
|
|
|
|
class Directive {
|
|
ngAfterViewInit() { events.push('init'); }
|
|
ngAfterViewChecked() { events.push('check'); }
|
|
|
|
static ngDirectiveDef = defineDirective(
|
|
{type: Directive, selectors: [['', 'dir', '']], factory: () => new Directive()});
|
|
}
|
|
|
|
const defs = [Comp, Parent, ProjectedComp, Directive];
|
|
|
|
it('should be called on init and not in update mode', () => {
|
|
/** <comp></comp> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp']);
|
|
|
|
fixture.update();
|
|
expect(events).toEqual(['comp']);
|
|
});
|
|
|
|
it('should be called on root component in creation mode', () => {
|
|
const comp = renderComponent(Comp, {hostFeatures: [LifecycleHooksFeature]});
|
|
expect(events).toEqual(['comp']);
|
|
|
|
markDirty(comp);
|
|
requestAnimationFrame.flush();
|
|
expect(events).toEqual(['comp']);
|
|
});
|
|
|
|
it('should be called every time a view is initialized (if block)', () => {
|
|
/*
|
|
* % if (!skip) {
|
|
* <comp></comp>
|
|
* % }
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
container(0);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
containerRefreshStart(0);
|
|
{
|
|
if (!ctx.skip) {
|
|
let rf1 = embeddedViewStart(0, 1, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp']);
|
|
|
|
fixture.component.skip = true;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp']);
|
|
|
|
fixture.component.skip = false;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp', 'comp']);
|
|
|
|
});
|
|
|
|
it('should be called in children before parents', () => {
|
|
/**
|
|
* <parent></parent>
|
|
*
|
|
* parent temp: <comp></comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp', 'parent']);
|
|
});
|
|
|
|
it('should be called for entire subtree before being called in any parent view comps', () => {
|
|
/**
|
|
* <parent [val]="1"></parent>
|
|
* <parent [val]="2"></parent>
|
|
*
|
|
* parent temp: <comp [val]="val"></comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
element(1, 'parent');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(1, 'val', 2);
|
|
}
|
|
}, 2, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp1', 'comp2', 'parent1', 'parent2']);
|
|
|
|
});
|
|
|
|
it('should be called in projected components before their hosts', () => {
|
|
/**
|
|
* <comp>
|
|
* <projected></projected>
|
|
* </comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'comp');
|
|
{ element(1, 'projected'); }
|
|
elementEnd();
|
|
}
|
|
}, 2, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['projected', 'comp']);
|
|
});
|
|
|
|
it('should call afterViewInit in content children and host before next host', () => {
|
|
/**
|
|
* <comp [val]="1">
|
|
* <projected [val]="1"></projected>
|
|
* </comp>
|
|
* <comp [val]="2">
|
|
* <projected [val]="2"></projected>
|
|
* </comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'comp');
|
|
{ element(1, 'projected'); }
|
|
elementEnd();
|
|
elementStart(2, 'comp');
|
|
{ element(3, 'projected'); }
|
|
elementEnd();
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(1, 'val', 1);
|
|
elementProperty(2, 'val', 2);
|
|
elementProperty(3, 'val', 2);
|
|
}
|
|
}, 4, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['projected1', 'comp1', 'projected2', 'comp2']);
|
|
});
|
|
|
|
it('should call afterViewInit in content children and hosts before parents', () => {
|
|
/*
|
|
* <comp [val]="val">
|
|
* <projected [val]="val"></projected>
|
|
* </comp>
|
|
*/
|
|
const ParentComp = createAfterViewInitComponent('parent', (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'comp');
|
|
{ element(1, 'projected'); }
|
|
elementEnd();
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', bind(ctx.val));
|
|
elementProperty(1, 'val', bind(ctx.val));
|
|
}
|
|
}, 2, 2, [Comp, ProjectedComp]);
|
|
|
|
/**
|
|
* <parent [val]="1"></parent>
|
|
* <parent [val]="2"></parent>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
element(1, 'parent');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(1, 'val', 2);
|
|
}
|
|
}, 2, 0, [ParentComp]);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['projected1', 'comp1', 'projected2', 'comp2', 'parent1', 'parent2']);
|
|
});
|
|
|
|
it('should be called in correct order with for loops', () => {
|
|
/**
|
|
* <comp [val]="1"></comp>
|
|
* % for (let i = 0; i < 4; i++) {
|
|
* <comp [val]="i"></comp>
|
|
* % }
|
|
* <comp [val]="4"></comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
container(1);
|
|
element(2, 'comp');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(2, 'val', 4);
|
|
containerRefreshStart(1);
|
|
{
|
|
for (let i = 2; i < 4; i++) {
|
|
let rf1 = embeddedViewStart(0, 1, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
if (rf1 & RenderFlags.Update) {
|
|
elementProperty(0, 'val', i);
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 3, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp2', 'comp3', 'comp1', 'comp4']);
|
|
|
|
});
|
|
|
|
it('should be called in correct order with for loops with children', () => {
|
|
/**
|
|
* <parent [val]="1"></parent>
|
|
* % for(let i = 0; i < 4; i++) {
|
|
* <parent [val]="i"></parent>
|
|
* % }
|
|
* <parent [val]="4"></parent>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
container(1);
|
|
element(2, 'parent');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(2, 'val', 4);
|
|
containerRefreshStart(1);
|
|
{
|
|
for (let i = 2; i < 4; i++) {
|
|
let rf1 = embeddedViewStart(0, 1, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
}
|
|
if (rf1 & RenderFlags.Update) {
|
|
elementProperty(0, 'val', i);
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 3, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(
|
|
['comp2', 'parent2', 'comp3', 'parent3', 'comp1', 'comp4', 'parent1', 'parent4']);
|
|
|
|
});
|
|
|
|
describe('ngAfterViewChecked', () => {
|
|
|
|
it('should call ngAfterViewChecked every update', () => {
|
|
/** <comp></comp> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(allEvents).toEqual(['comp init', 'comp check']);
|
|
|
|
fixture.update();
|
|
expect(allEvents).toEqual(['comp init', 'comp check', 'comp check']);
|
|
});
|
|
|
|
it('should be called on root component', () => {
|
|
const comp = renderComponent(Comp, {hostFeatures: [LifecycleHooksFeature]});
|
|
expect(allEvents).toEqual(['comp init', 'comp check']);
|
|
|
|
markDirty(comp);
|
|
requestAnimationFrame.flush();
|
|
expect(allEvents).toEqual(['comp init', 'comp check', 'comp check']);
|
|
});
|
|
|
|
it('should call ngAfterViewChecked with bindings', () => {
|
|
/** <comp [val]="myVal"></comp> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', bind(ctx.myVal));
|
|
}
|
|
}, 1, 1, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(allEvents).toEqual(['comp init', 'comp check']);
|
|
|
|
fixture.component.myVal = 2;
|
|
fixture.update();
|
|
expect(allEvents).toEqual(['comp init', 'comp check', 'comp2 check']);
|
|
});
|
|
|
|
it('should be called in correct order with for loops with children', () => {
|
|
/**
|
|
* <parent [val]="1"></parent>
|
|
* % for(let i = 0; i < 4; i++) {
|
|
* <parent [val]="i"></parent>
|
|
* % }
|
|
* <parent [val]="4"></parent>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
container(1);
|
|
element(2, 'parent');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(2, 'val', 4);
|
|
containerRefreshStart(1);
|
|
{
|
|
for (let i = 2; i < 4; i++) {
|
|
let rf1 = embeddedViewStart(0, 1, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
}
|
|
if (rf1 & RenderFlags.Update) {
|
|
elementProperty(0, 'val', i);
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 3, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(allEvents).toEqual([
|
|
'comp2 init', 'comp2 check', 'parent2 init', 'parent2 check', 'comp3 init', 'comp3 check',
|
|
'parent3 init', 'parent3 check', 'comp1 init', 'comp1 check', 'comp4 init', 'comp4 check',
|
|
'parent1 init', 'parent1 check', 'parent4 init', 'parent4 check'
|
|
]);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
describe('directives', () => {
|
|
it('should be called on directives after component', () => {
|
|
/** <comp directive></comp> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp', ['dir', '']);
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['comp', 'init', 'check']);
|
|
});
|
|
|
|
it('should be called on directives on an element', () => {
|
|
/** <div directive></div> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'div', ['dir', '']);
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual(['init', 'check']);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('onDestroy', () => {
|
|
let events: string[];
|
|
|
|
beforeEach(() => { events = []; });
|
|
|
|
let Comp = createOnDestroyComponent('comp', (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
projectionDef();
|
|
projection(0);
|
|
}
|
|
}, 1);
|
|
let Parent = createOnDestroyComponent('parent', getParentTemplate('comp'), 1, 1, [Comp]);
|
|
|
|
function createOnDestroyComponent(
|
|
name: string, template: ComponentTemplate<any>, consts: number = 0, vars: number = 0,
|
|
directives: any[] = []) {
|
|
return class Component {
|
|
val: string = '';
|
|
ngOnDestroy() { events.push(`${name}${this.val}`); }
|
|
|
|
static ngComponentDef = defineComponent({
|
|
type: Component,
|
|
selectors: [[name]],
|
|
factory: () => new Component(),
|
|
consts: consts,
|
|
vars: vars,
|
|
inputs: {val: 'val'},
|
|
template: template,
|
|
directives: directives
|
|
});
|
|
};
|
|
}
|
|
|
|
let Grandparent = createOnDestroyComponent('grandparent', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
}
|
|
}, 1, 0, [Parent]);
|
|
|
|
const ProjectedComp = createOnDestroyComponent('projected', (rf: RenderFlags, ctx: any) => {});
|
|
|
|
class Directive {
|
|
ngOnDestroy() { events.push('dir'); }
|
|
|
|
static ngDirectiveDef = defineDirective(
|
|
{type: Directive, selectors: [['', 'dir', '']], factory: () => new Directive()});
|
|
}
|
|
|
|
const defs = [Comp, Parent, Grandparent, ProjectedComp, Directive];
|
|
|
|
it('should call destroy when view is removed', () => {
|
|
/**
|
|
* % if (!skip) {
|
|
* <comp></comp>
|
|
* % }
|
|
*/
|
|
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
container(0);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
containerRefreshStart(0);
|
|
{
|
|
if (!ctx.skip) {
|
|
let rf1 = embeddedViewStart(0, 1, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
|
|
fixture.component.skip = true;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp']);
|
|
});
|
|
|
|
it('should call destroy when multiple views are removed', () => {
|
|
/**
|
|
* % if (!skip) {
|
|
* <comp [val]="1"></comp>
|
|
* <comp [val]="2"></comp>
|
|
* % }
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
container(0);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
containerRefreshStart(0);
|
|
{
|
|
if (!ctx.skip) {
|
|
let rf1 = embeddedViewStart(0, 2, 2);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
element(1, 'comp');
|
|
}
|
|
if (rf1 & RenderFlags.Update) {
|
|
elementProperty(0, 'val', bind('1'));
|
|
elementProperty(1, 'val', bind('2'));
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
|
|
fixture.component.skip = true;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp1', 'comp2']);
|
|
});
|
|
|
|
it('should be called in child components before parent components', () => {
|
|
/**
|
|
* % if (!skip) {
|
|
* <parent></parent>
|
|
* % }
|
|
*
|
|
* parent template: <comp></comp>
|
|
*/
|
|
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
container(0);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
containerRefreshStart(0);
|
|
{
|
|
if (!ctx.skip) {
|
|
let rf1 = embeddedViewStart(0, 1, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
|
|
fixture.component.skip = true;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp', 'parent']);
|
|
});
|
|
|
|
it('should be called bottom up with children nested 2 levels deep', () => {
|
|
/**
|
|
* % if (!skip) {
|
|
* <grandparent></grandparent>
|
|
* % }
|
|
*
|
|
* grandparent template: <parent></parent>
|
|
* parent template: <comp></comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
container(0);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
containerRefreshStart(0);
|
|
{
|
|
if (!ctx.skip) {
|
|
let rf1 = embeddedViewStart(0, 1, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'grandparent');
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
|
|
fixture.component.skip = true;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp', 'parent', 'grandparent']);
|
|
});
|
|
|
|
it('should be called in projected components before their hosts', () => {
|
|
/**
|
|
* % if (!skip) {
|
|
* <comp [val]="1">
|
|
* <projected [val]="1"></projected>
|
|
* </comp>
|
|
* <comp [val]="2">
|
|
* <projected [val]="2"></projected>
|
|
* </comp>
|
|
* }
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
container(0);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
containerRefreshStart(0);
|
|
{
|
|
if (!ctx.skip) {
|
|
let rf1 = embeddedViewStart(0, 4, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
elementStart(0, 'comp');
|
|
{ element(1, 'projected'); }
|
|
elementEnd();
|
|
elementStart(2, 'comp');
|
|
{ element(3, 'projected'); }
|
|
elementEnd();
|
|
}
|
|
if (rf1 & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(1, 'val', 1);
|
|
elementProperty(2, 'val', 2);
|
|
elementProperty(3, 'val', 2);
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
|
|
fixture.component.skip = true;
|
|
fixture.update();
|
|
expect(events).toEqual(['projected1', 'comp1', 'projected2', 'comp2']);
|
|
});
|
|
|
|
|
|
it('should be called in consistent order if views are removed and re-added', () => {
|
|
/**
|
|
* % if (condition) {
|
|
* <comp [val]="1"></comp>
|
|
* % if (condition2) {
|
|
* <comp [val]="2"></comp>
|
|
* % }
|
|
* <comp [val]="3"></comp>
|
|
* % }
|
|
*/
|
|
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
container(0);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
containerRefreshStart(0);
|
|
{
|
|
if (ctx.condition) {
|
|
let rf1 = embeddedViewStart(0, 3, 2);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
container(1);
|
|
element(2, 'comp');
|
|
}
|
|
if (rf1 & RenderFlags.Update) {
|
|
elementProperty(0, 'val', bind('1'));
|
|
elementProperty(2, 'val', bind('3'));
|
|
containerRefreshStart(1);
|
|
{
|
|
if (ctx.condition2) {
|
|
let rf2 = embeddedViewStart(0, 1, 1);
|
|
if (rf2 & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
if (rf2 & RenderFlags.Update) {
|
|
elementProperty(0, 'val', bind('2'));
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
fixture.component.condition = true;
|
|
fixture.component.condition2 = true;
|
|
fixture.update();
|
|
|
|
// remove all views
|
|
fixture.component.condition = false;
|
|
fixture.update();
|
|
|
|
/**
|
|
* Current angular will process in this same order (root is the top-level removed view):
|
|
*
|
|
* root.child (comp1 view) onDestroy: null
|
|
* root.child.next (container) -> embeddedView
|
|
* embeddedView.child (comp2 view) onDestroy: null
|
|
* embeddedView onDestroy: [comp2]
|
|
* root.child.next.next (comp3 view) onDestroy: null
|
|
* root onDestroy: [comp1, comp3]
|
|
*/
|
|
expect(events).toEqual(['comp2', 'comp1', 'comp3']);
|
|
|
|
events = [];
|
|
// remove inner view
|
|
fixture.component.condition = true;
|
|
fixture.component.condition2 = false;
|
|
fixture.update();
|
|
|
|
// remove outer view
|
|
fixture.component.condition = false;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp1', 'comp3']);
|
|
|
|
events = [];
|
|
// restore both views
|
|
fixture.component.condition = true;
|
|
fixture.component.condition2 = true;
|
|
fixture.update();
|
|
|
|
// remove both views
|
|
fixture.component.condition = false;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp2', 'comp1', 'comp3']);
|
|
});
|
|
|
|
it('should be called in every iteration of a destroyed for loop', () => {
|
|
/**
|
|
* % if (condition) {
|
|
* <comp [val]="1"></comp>
|
|
* % for (let i = 2; i < len; i++) {
|
|
* <comp [val]="i"></comp>
|
|
* % }
|
|
* <comp [val]="5"></comp>
|
|
* % }
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
container(0);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
containerRefreshStart(0);
|
|
{
|
|
if (ctx.condition) {
|
|
let rf1 = embeddedViewStart(0, 3, 2);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
container(1);
|
|
element(2, 'comp');
|
|
}
|
|
if (rf1 & RenderFlags.Update) {
|
|
elementProperty(0, 'val', bind('1'));
|
|
elementProperty(2, 'val', bind('5'));
|
|
containerRefreshStart(1);
|
|
{
|
|
for (let j = 2; j < ctx.len; j++) {
|
|
let rf2 = embeddedViewStart(0, 1, 1);
|
|
if (rf2 & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
if (rf2 & RenderFlags.Update) {
|
|
elementProperty(0, 'val', bind(j));
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
fixture.component.condition = true;
|
|
fixture.component.len = 5;
|
|
fixture.update();
|
|
|
|
fixture.component.condition = false;
|
|
fixture.update();
|
|
|
|
/**
|
|
* Current angular will process in this same order (root is the top-level removed view):
|
|
*
|
|
* root.child (comp1 view) onDestroy: null
|
|
* root.child.next (container) -> embeddedView (children[0].data)
|
|
* embeddedView.child (comp2 view) onDestroy: null
|
|
* embeddedView onDestroy: [comp2]
|
|
* embeddedView.next.child (comp3 view) onDestroy: null
|
|
* embeddedView.next onDestroy: [comp3]
|
|
* embeddedView.next.next.child (comp4 view) onDestroy: null
|
|
* embeddedView.next.next onDestroy: [comp4]
|
|
* embeddedView.next.next -> container -> root
|
|
* root onDestroy: [comp1, comp5]
|
|
*/
|
|
expect(events).toEqual(['comp2', 'comp3', 'comp4', 'comp1', 'comp5']);
|
|
|
|
events = [];
|
|
fixture.component.condition = true;
|
|
fixture.component.len = 4;
|
|
fixture.update();
|
|
|
|
fixture.component.condition = false;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp2', 'comp3', 'comp1', 'comp5']);
|
|
|
|
events = [];
|
|
fixture.component.condition = true;
|
|
fixture.component.len = 5;
|
|
fixture.update();
|
|
|
|
fixture.component.condition = false;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp2', 'comp3', 'comp4', 'comp1', 'comp5']);
|
|
});
|
|
|
|
it('should call destroy properly if view also has listeners', () => {
|
|
/**
|
|
* % if (condition) {
|
|
* <button (click)="onClick()">Click me</button>
|
|
* <comp></comp>
|
|
* <button (click)="onClick()">Click me</button>
|
|
* % }
|
|
*/
|
|
function Template(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
container(0);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
containerRefreshStart(0);
|
|
{
|
|
if (ctx.condition) {
|
|
let rf1 = embeddedViewStart(0, 5, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
elementStart(0, 'button');
|
|
{
|
|
listener('click', ctx.onClick.bind(ctx));
|
|
text(1, 'Click me');
|
|
}
|
|
elementEnd();
|
|
element(2, 'comp');
|
|
elementStart(3, 'button');
|
|
{
|
|
listener('click', ctx.onClick.bind(ctx));
|
|
text(4, 'Click me');
|
|
}
|
|
elementEnd();
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}
|
|
|
|
class App {
|
|
counter = 0;
|
|
condition = true;
|
|
onClick() { this.counter++; }
|
|
}
|
|
|
|
const ctx: {counter: number} = new App();
|
|
renderToHtml(Template, ctx, 1, 0, defs);
|
|
|
|
const buttons = containerEl.querySelectorAll('button') !;
|
|
buttons[0].click();
|
|
expect(ctx.counter).toEqual(1);
|
|
buttons[1].click();
|
|
expect(ctx.counter).toEqual(2);
|
|
|
|
renderToHtml(Template, {condition: false}, 1, 0, defs);
|
|
|
|
buttons[0].click();
|
|
buttons[1].click();
|
|
expect(events).toEqual(['comp']);
|
|
expect(ctx.counter).toEqual(2);
|
|
});
|
|
|
|
it('should be called on directives after component', () => {
|
|
/**
|
|
* % if (condition) {
|
|
* <comp></comp>
|
|
* % }
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
container(0);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
containerRefreshStart(0);
|
|
{
|
|
if (ctx.condition) {
|
|
let rf1 = embeddedViewStart(0, 1, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'comp', ['dir', '']);
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
fixture.component.condition = true;
|
|
fixture.update();
|
|
expect(events).toEqual([]);
|
|
|
|
fixture.component.condition = false;
|
|
fixture.update();
|
|
expect(events).toEqual(['comp', 'dir']);
|
|
|
|
});
|
|
|
|
it('should be called on directives on an element', () => {
|
|
/**
|
|
* % if (condition) {
|
|
* <div directive></div>
|
|
* % }
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
container(0);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
containerRefreshStart(0);
|
|
{
|
|
if (ctx.condition) {
|
|
let rf1 = embeddedViewStart(0, 1, 0);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'div', ['dir', '']);
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
fixture.component.condition = true;
|
|
fixture.update();
|
|
expect(events).toEqual([]);
|
|
|
|
fixture.component.condition = false;
|
|
fixture.update();
|
|
expect(events).toEqual(['dir']);
|
|
});
|
|
|
|
});
|
|
|
|
describe('onChanges', () => {
|
|
let events: ({type: string, name: string, [key: string]: any})[];
|
|
|
|
beforeEach(() => { events = []; });
|
|
|
|
/**
|
|
* <div>
|
|
* <ng-content/>
|
|
* </div>
|
|
*/
|
|
const Comp = createOnChangesComponent('comp', (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
projectionDef();
|
|
elementStart(0, 'div');
|
|
{ projection(1); }
|
|
elementEnd();
|
|
}
|
|
}, 2);
|
|
|
|
/**
|
|
* <comp [val1]="a" [publicVal2]="b"/>
|
|
*/
|
|
const Parent = createOnChangesComponent('parent', (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val1', bind(ctx.a));
|
|
elementProperty(0, 'publicVal2', bind(ctx.b));
|
|
}
|
|
}, 1, 2, [Comp]);
|
|
|
|
const ProjectedComp = createOnChangesComponent('projected', (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
text(0, 'content');
|
|
}
|
|
}, 1);
|
|
|
|
|
|
function createOnChangesComponent(
|
|
name: string, template: ComponentTemplate<any>, consts: number = 0, vars: number = 0,
|
|
directives: any[] = []) {
|
|
return class Component {
|
|
// @Input() val1: string;
|
|
// @Input('publicVal2') val2: string;
|
|
a: string = 'wasVal1BeforeMinification';
|
|
b: string = 'wasVal2BeforeMinification';
|
|
ngOnChanges(changes: SimpleChanges) {
|
|
if (changes.a && this.a !== changes.a.currentValue) {
|
|
throw Error(
|
|
`SimpleChanges invalid expected this.a ${this.a} to equal currentValue ${changes.a.currentValue}`);
|
|
}
|
|
if (changes.b && this.b !== changes.b.currentValue) {
|
|
throw Error(
|
|
`SimpleChanges invalid expected this.b ${this.b} to equal currentValue ${changes.b.currentValue}`);
|
|
}
|
|
events.push({type: 'onChanges', name: 'comp - ' + name, changes});
|
|
}
|
|
|
|
static ngComponentDef = defineComponent({
|
|
type: Component,
|
|
selectors: [[name]],
|
|
factory: () => new Component(),
|
|
consts: consts,
|
|
vars: vars,
|
|
inputs: {a: 'val1', b: ['publicVal2', 'val2']}, template,
|
|
directives: directives,
|
|
features: [NgOnChangesFeature()],
|
|
});
|
|
};
|
|
}
|
|
|
|
class Directive {
|
|
// @Input() val1: string;
|
|
// @Input('publicVal2') val2: string;
|
|
a: string = 'wasVal1BeforeMinification';
|
|
b: string = 'wasVal2BeforeMinification';
|
|
ngOnChanges(changes: SimpleChanges) {
|
|
events.push({type: 'onChanges', name: 'dir - dir', changes});
|
|
}
|
|
|
|
static ngDirectiveDef = defineDirective({
|
|
type: Directive,
|
|
selectors: [['', 'dir', '']],
|
|
factory: () => new Directive(),
|
|
inputs: {a: 'val1', b: ['publicVal2', 'val2']},
|
|
features: [NgOnChangesFeature()],
|
|
});
|
|
}
|
|
|
|
const defs = [Comp, Parent, Directive, ProjectedComp];
|
|
|
|
it('should call onChanges method after inputs are set in creation and update mode', () => {
|
|
/** <comp [val1]="val1" [publicVal2]="val2"></comp> */
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val1', bind(ctx.val1));
|
|
elementProperty(0, 'publicVal2', bind(ctx.val2));
|
|
}
|
|
}, 1, 2, defs);
|
|
|
|
// First changes happen here.
|
|
const fixture = new ComponentFixture(App);
|
|
|
|
events = [];
|
|
fixture.component.val1 = '1';
|
|
fixture.component.val2 = 'a';
|
|
fixture.update();
|
|
expect(events).toEqual([{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(
|
|
undefined, '1', false), // we cleared `events` above, this is the second change
|
|
'val2': new SimpleChange(undefined, 'a', false),
|
|
}
|
|
}]);
|
|
|
|
events = [];
|
|
fixture.component.val1 = '2';
|
|
fixture.component.val2 = 'b';
|
|
fixture.update();
|
|
expect(events).toEqual([{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange('1', '2', false),
|
|
'val2': new SimpleChange('a', 'b', false),
|
|
}
|
|
}]);
|
|
});
|
|
|
|
it('should call parent onChanges before child onChanges', () => {
|
|
/**
|
|
* <parent></parent>
|
|
* parent temp: <comp></comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val1', bind(ctx.val1));
|
|
elementProperty(0, 'publicVal2', bind(ctx.val2));
|
|
}
|
|
}, 1, 2, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
|
|
// We're clearing events after the first change here
|
|
events = [];
|
|
fixture.component.val1 = '1';
|
|
fixture.component.val2 = 'a';
|
|
fixture.update();
|
|
|
|
expect(events).toEqual([
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - parent',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, '1', false),
|
|
'val2': new SimpleChange(undefined, 'a', false),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, '1', false),
|
|
'val2': new SimpleChange(undefined, 'a', false),
|
|
}
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('should call all parent onChanges across view before calling children onChanges', () => {
|
|
/**
|
|
* <parent [val1]="1"></parent>
|
|
* <parent [val1]="2"></parent>
|
|
*/
|
|
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
element(1, 'parent');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val1', bind(1));
|
|
elementProperty(0, 'publicVal2', bind(1));
|
|
elementProperty(1, 'val1', bind(2));
|
|
elementProperty(1, 'publicVal2', bind(2));
|
|
}
|
|
}, 2, 4, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual([
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - parent',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 1, true),
|
|
'val2': new SimpleChange(undefined, 1, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - parent',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 2, true),
|
|
'val2': new SimpleChange(undefined, 2, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 1, true),
|
|
'val2': new SimpleChange(undefined, 1, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 2, true),
|
|
'val2': new SimpleChange(undefined, 2, true),
|
|
}
|
|
},
|
|
]);
|
|
});
|
|
|
|
|
|
it('should call onChanges every time a new view is created (if block)', () => {
|
|
/**
|
|
* % if (condition) {
|
|
* <comp></comp>
|
|
* % }
|
|
*/
|
|
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
container(0);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
containerRefreshStart(0);
|
|
{
|
|
if (ctx.condition) {
|
|
let rf1 = embeddedViewStart(0, 1, 2);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
if (rf1 & RenderFlags.Update) {
|
|
elementProperty(0, 'val1', bind(1));
|
|
elementProperty(0, 'publicVal2', bind(1));
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 1, 0, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
|
|
// Show the `comp` component, causing it to initialize. (first change is true)
|
|
fixture.component.condition = true;
|
|
fixture.update();
|
|
expect(events).toEqual([{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 1, true),
|
|
'val2': new SimpleChange(undefined, 1, true),
|
|
}
|
|
}]);
|
|
|
|
// Hide the `comp` component, no onChanges should fire
|
|
fixture.component.condition = false;
|
|
fixture.update();
|
|
expect(events).toEqual([{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 1, true),
|
|
'val2': new SimpleChange(undefined, 1, true),
|
|
}
|
|
}]);
|
|
|
|
// Show the `comp` component, it initializes again. (first change is true)
|
|
fixture.component.condition = true;
|
|
fixture.update();
|
|
expect(events).toEqual([
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 1, true),
|
|
'val2': new SimpleChange(undefined, 1, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 1, true),
|
|
'val2': new SimpleChange(undefined, 1, true),
|
|
}
|
|
}
|
|
]);
|
|
});
|
|
|
|
it('should call onChanges in hosts before their content children', () => {
|
|
/**
|
|
* <comp>
|
|
* <projected></projected>
|
|
* </comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'comp');
|
|
{ elementStart(1, 'projected'); }
|
|
elementEnd();
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val1', bind(1));
|
|
elementProperty(0, 'publicVal2', bind(1));
|
|
elementProperty(1, 'val1', bind(2));
|
|
elementProperty(1, 'publicVal2', bind(2));
|
|
}
|
|
}, 2, 4, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual([
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 1, true),
|
|
'val2': new SimpleChange(undefined, 1, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - projected',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 2, true),
|
|
'val2': new SimpleChange(undefined, 2, true),
|
|
}
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('should call onChanges in host and its content children before next host', () => {
|
|
/**
|
|
* <comp [val1]="1" [publicVal2]="1">
|
|
* <projected [val1]="2" [publicVal2]="2"></projected>
|
|
* </comp>
|
|
* <comp [val1]="3" [publicVal2]="3">
|
|
* <projected [val1]="4" [publicVal2]="4"></projected>
|
|
* </comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'comp');
|
|
{ elementStart(1, 'projected'); }
|
|
elementEnd();
|
|
elementStart(2, 'comp');
|
|
{ elementStart(3, 'projected'); }
|
|
elementEnd();
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val1', bind(1));
|
|
elementProperty(0, 'publicVal2', bind(1));
|
|
elementProperty(1, 'val1', bind(2));
|
|
elementProperty(1, 'publicVal2', bind(2));
|
|
elementProperty(2, 'val1', bind(3));
|
|
elementProperty(2, 'publicVal2', bind(3));
|
|
elementProperty(3, 'val1', bind(4));
|
|
elementProperty(3, 'publicVal2', bind(4));
|
|
}
|
|
}, 4, 8, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual([
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 1, true),
|
|
'val2': new SimpleChange(undefined, 1, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - projected',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 2, true),
|
|
'val2': new SimpleChange(undefined, 2, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 3, true),
|
|
'val2': new SimpleChange(undefined, 3, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - projected',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 4, true),
|
|
'val2': new SimpleChange(undefined, 4, true),
|
|
}
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('should be called on directives after component', () => {
|
|
/**
|
|
* <comp dir [val1]="1" [publicVal2]="1"></comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp', ['dir', '']);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val1', bind(1));
|
|
elementProperty(0, 'publicVal2', bind(1));
|
|
}
|
|
}, 1, 2, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual([
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 1, true),
|
|
'val2': new SimpleChange(undefined, 1, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'dir - dir',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 1, true),
|
|
'val2': new SimpleChange(undefined, 1, true),
|
|
}
|
|
},
|
|
]);
|
|
|
|
// Update causes no changes to be fired, since the bindings didn't change.
|
|
events = [];
|
|
fixture.update();
|
|
expect(events).toEqual([]);
|
|
|
|
});
|
|
|
|
it('should be called on directives on an element', () => {
|
|
/**
|
|
* <div dir [val]="1" [publicVal2]="1"></div>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'div', ['dir', '']);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val1', bind(1));
|
|
elementProperty(0, 'publicVal2', bind(1));
|
|
}
|
|
}, 1, 2, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual([{
|
|
type: 'onChanges',
|
|
name: 'dir - dir',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 1, true),
|
|
'val2': new SimpleChange(undefined, 1, true),
|
|
}
|
|
}]);
|
|
|
|
events = [];
|
|
fixture.update();
|
|
expect(events).toEqual([]);
|
|
});
|
|
|
|
it('should call onChanges properly in for loop', () => {
|
|
/**
|
|
* <comp [val1]="1" [publicVal2]="1"></comp>
|
|
* % for (let j = 2; j < 5; j++) {
|
|
* <comp [val1]="j" [publicVal2]="j"></comp>
|
|
* % }
|
|
* <comp [val1]="5" [publicVal2]="5"></comp>
|
|
*/
|
|
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
container(1);
|
|
element(2, 'comp');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val1', bind(1));
|
|
elementProperty(0, 'publicVal2', bind(1));
|
|
elementProperty(2, 'val1', bind(5));
|
|
elementProperty(2, 'publicVal2', bind(5));
|
|
containerRefreshStart(1);
|
|
{
|
|
for (let j = 2; j < 5; j++) {
|
|
let rf1 = embeddedViewStart(0, 1, 2);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
if (rf1 & RenderFlags.Update) {
|
|
elementProperty(0, 'val1', bind(j));
|
|
elementProperty(0, 'publicVal2', bind(j));
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 3, 4, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
|
|
// onChanges is called top to bottom, so top level comps (1 and 5) are called
|
|
// before the comps inside the for loop's embedded view (2, 3, and 4)
|
|
expect(events).toEqual([
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 1, true),
|
|
'val2': new SimpleChange(undefined, 1, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 5, true),
|
|
'val2': new SimpleChange(undefined, 5, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 2, true),
|
|
'val2': new SimpleChange(undefined, 2, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 3, true),
|
|
'val2': new SimpleChange(undefined, 3, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 4, true),
|
|
'val2': new SimpleChange(undefined, 4, true),
|
|
}
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('should call onChanges properly in for loop with children', () => {
|
|
/**
|
|
* <parent [val1]="1" [publicVal2]="1"></parent>
|
|
* % for (let j = 2; j < 5; j++) {
|
|
* <parent [val1]="j" [publicVal2]="j"></parent>
|
|
* % }
|
|
* <parent [val1]="5" [publicVal2]="5"></parent>
|
|
*/
|
|
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
container(1);
|
|
element(2, 'parent');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val1', bind(1));
|
|
elementProperty(0, 'publicVal2', bind(1));
|
|
elementProperty(2, 'val1', bind(5));
|
|
elementProperty(2, 'publicVal2', bind(5));
|
|
containerRefreshStart(1);
|
|
{
|
|
for (let j = 2; j < 5; j++) {
|
|
let rf1 = embeddedViewStart(0, 1, 2);
|
|
if (rf1 & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
}
|
|
if (rf1 & RenderFlags.Update) {
|
|
elementProperty(0, 'val1', bind(j));
|
|
elementProperty(0, 'publicVal2', bind(j));
|
|
}
|
|
embeddedViewEnd();
|
|
}
|
|
}
|
|
containerRefreshEnd();
|
|
}
|
|
}, 3, 4, defs);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
|
|
// onChanges is called top to bottom, so top level comps (1 and 5) are called
|
|
// before the comps inside the for loop's embedded view (2, 3, and 4)
|
|
expect(events).toEqual([
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - parent',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 1, true),
|
|
'val2': new SimpleChange(undefined, 1, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - parent',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 5, true),
|
|
'val2': new SimpleChange(undefined, 5, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - parent',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 2, true),
|
|
'val2': new SimpleChange(undefined, 2, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 2, true),
|
|
'val2': new SimpleChange(undefined, 2, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - parent',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 3, true),
|
|
'val2': new SimpleChange(undefined, 3, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 3, true),
|
|
'val2': new SimpleChange(undefined, 3, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - parent',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 4, true),
|
|
'val2': new SimpleChange(undefined, 4, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 4, true),
|
|
'val2': new SimpleChange(undefined, 4, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 1, true),
|
|
'val2': new SimpleChange(undefined, 1, true),
|
|
}
|
|
},
|
|
{
|
|
type: 'onChanges',
|
|
name: 'comp - comp',
|
|
changes: {
|
|
'val1': new SimpleChange(undefined, 5, true),
|
|
'val2': new SimpleChange(undefined, 5, true),
|
|
}
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('should not call onChanges if props are set directly', () => {
|
|
let events: SimpleChanges[] = [];
|
|
let compInstance: MyComp;
|
|
class MyComp {
|
|
value = 0;
|
|
|
|
ngOnChanges(changes: SimpleChanges) { events.push(changes); }
|
|
|
|
static ngComponentDef = defineComponent({
|
|
type: MyComp,
|
|
factory: () => {
|
|
// Capture the instance so we can test setting the property directly
|
|
compInstance = new MyComp();
|
|
return compInstance;
|
|
},
|
|
template: (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'div');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'data-a', bind(ctx.a));
|
|
}
|
|
},
|
|
selectors: [['mycomp']],
|
|
inputs: {
|
|
value: 'value',
|
|
},
|
|
consts: 1,
|
|
vars: 1,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* <my-comp [value]="1"></my-comp>
|
|
*/
|
|
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'mycomp');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'value', bind(1));
|
|
}
|
|
}, 1, 1, [MyComp]);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
events = [];
|
|
|
|
// Try setting the property directly
|
|
compInstance !.value = 2;
|
|
|
|
fixture.update();
|
|
expect(events).toEqual([]);
|
|
});
|
|
|
|
});
|
|
|
|
describe('hook order', () => {
|
|
let events: string[];
|
|
|
|
beforeEach(() => { events = []; });
|
|
|
|
function createAllHooksComponent(
|
|
name: string, template: ComponentTemplate<any>, consts: number = 0, vars: number = 0,
|
|
directives: any[] = []) {
|
|
return class Component {
|
|
val: string = '';
|
|
|
|
ngOnChanges() { events.push(`changes ${name}${this.val}`); }
|
|
|
|
ngOnInit() { events.push(`init ${name}${this.val}`); }
|
|
ngDoCheck() { events.push(`check ${name}${this.val}`); }
|
|
|
|
ngAfterContentInit() { events.push(`contentInit ${name}${this.val}`); }
|
|
ngAfterContentChecked() { events.push(`contentCheck ${name}${this.val}`); }
|
|
|
|
ngAfterViewInit() { events.push(`viewInit ${name}${this.val}`); }
|
|
ngAfterViewChecked() { events.push(`viewCheck ${name}${this.val}`); }
|
|
|
|
static ngComponentDef = defineComponent({
|
|
type: Component,
|
|
selectors: [[name]],
|
|
factory: () => new Component(),
|
|
consts: consts,
|
|
vars: vars,
|
|
inputs: {val: 'val'}, template,
|
|
directives: directives,
|
|
features: [NgOnChangesFeature()],
|
|
});
|
|
};
|
|
}
|
|
|
|
it('should call all hooks in correct order', () => {
|
|
const Comp = createAllHooksComponent('comp', (rf: RenderFlags, ctx: any) => {});
|
|
|
|
/**
|
|
* <comp [val]="1"></comp>
|
|
* <comp [val]="2"></comp>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
element(1, 'comp');
|
|
}
|
|
// This template function is a little weird in that the `elementProperty` calls
|
|
// below are directly setting values `1` and `2`, where normally there would be
|
|
// a call to `bind()` that would do the work of seeing if something changed.
|
|
// This means when `fixture.update()` is called below, ngOnChanges should fire,
|
|
// even though the *value* itself never changed.
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(1, 'val', 2);
|
|
}
|
|
}, 2, 0, [Comp]);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual([
|
|
'changes comp1', 'init comp1', 'check comp1', 'changes comp2', 'init comp2', 'check comp2',
|
|
'contentInit comp1', 'contentCheck comp1', 'contentInit comp2', 'contentCheck comp2',
|
|
'viewInit comp1', 'viewCheck comp1', 'viewInit comp2', 'viewCheck comp2'
|
|
]);
|
|
|
|
events = [];
|
|
fixture.update(); // Changes are made due to lack of `bind()` call in template fn.
|
|
expect(events).toEqual([
|
|
'changes comp1', 'check comp1', 'changes comp2', 'check comp2', 'contentCheck comp1',
|
|
'contentCheck comp2', 'viewCheck comp1', 'viewCheck comp2'
|
|
]);
|
|
});
|
|
|
|
it('should call all hooks in correct order with children', () => {
|
|
const Comp = createAllHooksComponent('comp', (rf: RenderFlags, ctx: any) => {});
|
|
|
|
/** <comp [val]="val"></comp> */
|
|
const Parent = createAllHooksComponent('parent', (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'comp');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', bind(ctx.val));
|
|
}
|
|
}, 1, 1, [Comp]);
|
|
|
|
/**
|
|
* <parent [val]="1"></parent>
|
|
* <parent [val]="2"></parent>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
element(0, 'parent');
|
|
element(1, 'parent');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', 1);
|
|
elementProperty(1, 'val', 2);
|
|
}
|
|
}, 2, 0, [Parent]);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual([
|
|
'changes parent1', 'init parent1', 'check parent1',
|
|
'changes parent2', 'init parent2', 'check parent2',
|
|
'contentInit parent1', 'contentCheck parent1', 'contentInit parent2',
|
|
'contentCheck parent2', 'changes comp1', 'init comp1',
|
|
'check comp1', 'contentInit comp1', 'contentCheck comp1',
|
|
'viewInit comp1', 'viewCheck comp1', 'changes comp2',
|
|
'init comp2', 'check comp2', 'contentInit comp2',
|
|
'contentCheck comp2', 'viewInit comp2', 'viewCheck comp2',
|
|
'viewInit parent1', 'viewCheck parent1', 'viewInit parent2',
|
|
'viewCheck parent2'
|
|
]);
|
|
|
|
events = [];
|
|
fixture.update();
|
|
expect(events).toEqual([
|
|
'changes parent1', 'check parent1', 'changes parent2', 'check parent2',
|
|
'contentCheck parent1', 'contentCheck parent2', 'check comp1', 'contentCheck comp1',
|
|
'viewCheck comp1', 'check comp2', 'contentCheck comp2', 'viewCheck comp2',
|
|
'viewCheck parent1', 'viewCheck parent2'
|
|
]);
|
|
|
|
});
|
|
|
|
// Angular 5 reference: https://stackblitz.com/edit/lifecycle-hooks-ng
|
|
it('should call all hooks in correct order with view and content', () => {
|
|
const Content = createAllHooksComponent('content', (rf: RenderFlags, ctx: any) => {});
|
|
|
|
const View = createAllHooksComponent('view', (rf: RenderFlags, ctx: any) => {});
|
|
|
|
/** <ng-content></ng-content><view [val]="val"></view> */
|
|
const Parent = createAllHooksComponent('parent', (rf: RenderFlags, ctx: any) => {
|
|
if (rf & RenderFlags.Create) {
|
|
projectionDef();
|
|
projection(0);
|
|
element(1, 'view');
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(1, 'val', bind(ctx.val));
|
|
}
|
|
}, 2, 1, [View]);
|
|
|
|
/**
|
|
* <parent [val]="1">
|
|
* <content [val]="1"></content>
|
|
* </parent>
|
|
* <parent [val]="2">
|
|
* <content [val]="2"></content>
|
|
* </parent>
|
|
*/
|
|
const App = createComponent('app', function(rf: RenderFlags, ctx: any) {
|
|
if (rf & RenderFlags.Create) {
|
|
elementStart(0, 'parent');
|
|
{ element(1, 'content'); }
|
|
elementEnd();
|
|
elementStart(2, 'parent');
|
|
{ element(3, 'content'); }
|
|
elementEnd();
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'val', bind(1));
|
|
elementProperty(1, 'val', bind(1));
|
|
elementProperty(2, 'val', bind(2));
|
|
elementProperty(3, 'val', bind(2));
|
|
}
|
|
}, 4, 4, [Parent, Content]);
|
|
|
|
const fixture = new ComponentFixture(App);
|
|
expect(events).toEqual([
|
|
'changes parent1', 'init parent1',
|
|
'check parent1', 'changes content1',
|
|
'init content1', 'check content1',
|
|
'changes parent2', 'init parent2',
|
|
'check parent2', 'changes content2',
|
|
'init content2', 'check content2',
|
|
'contentInit content1', 'contentCheck content1',
|
|
'contentInit parent1', 'contentCheck parent1',
|
|
'contentInit content2', 'contentCheck content2',
|
|
'contentInit parent2', 'contentCheck parent2',
|
|
'changes view1', 'init view1',
|
|
'check view1', 'contentInit view1',
|
|
'contentCheck view1', 'viewInit view1',
|
|
'viewCheck view1', 'changes view2',
|
|
'init view2', 'check view2',
|
|
'contentInit view2', 'contentCheck view2',
|
|
'viewInit view2', 'viewCheck view2',
|
|
'viewInit content1', 'viewCheck content1',
|
|
'viewInit parent1', 'viewCheck parent1',
|
|
'viewInit content2', 'viewCheck content2',
|
|
'viewInit parent2', 'viewCheck parent2'
|
|
]);
|
|
|
|
events = [];
|
|
fixture.update();
|
|
expect(events).toEqual([
|
|
'check parent1', 'check content1', 'check parent2', 'check content2',
|
|
'contentCheck content1', 'contentCheck parent1', 'contentCheck content2',
|
|
'contentCheck parent2', 'check view1', 'contentCheck view1', 'viewCheck view1',
|
|
'check view2', 'contentCheck view2', 'viewCheck view2', 'viewCheck content1',
|
|
'viewCheck parent1', 'viewCheck content2', 'viewCheck parent2'
|
|
]);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
describe('non-regression', () => {
|
|
|
|
it('should call lifecycle hooks for directives active on <ng-template>', () => {
|
|
let destroyed = false;
|
|
|
|
class OnDestroyDirective implements OnDestroy {
|
|
ngOnDestroy() { destroyed = true; }
|
|
|
|
static ngDirectiveDef = defineDirective({
|
|
type: OnDestroyDirective,
|
|
selectors: [['', 'onDestroyDirective', '']],
|
|
factory: () => new OnDestroyDirective()
|
|
});
|
|
}
|
|
|
|
|
|
function conditionTpl(rf: RenderFlags, ctx: Cmpt) {
|
|
if (rf & RenderFlags.Create) {
|
|
template(
|
|
0, null, 0, 1, 'ng-template', [AttributeMarker.SelectOnly, 'onDestroyDirective']);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <ng-template [ngIf]="condition">
|
|
* <ng-template onDestroyDirective></ng-template>
|
|
* </ng-template>
|
|
*/
|
|
function cmptTpl(rf: RenderFlags, cmpt: Cmpt) {
|
|
if (rf & RenderFlags.Create) {
|
|
template(0, conditionTpl, 1, 1, 'ng-template', [AttributeMarker.SelectOnly, 'ngIf']);
|
|
}
|
|
if (rf & RenderFlags.Update) {
|
|
elementProperty(0, 'ngIf', bind(cmpt.showing));
|
|
}
|
|
}
|
|
|
|
class Cmpt {
|
|
showing = true;
|
|
static ngComponentDef = defineComponent({
|
|
type: Cmpt,
|
|
factory: () => new Cmpt(),
|
|
selectors: [['cmpt']],
|
|
consts: 1,
|
|
vars: 1,
|
|
template: cmptTpl,
|
|
directives: [NgIf, OnDestroyDirective]
|
|
});
|
|
}
|
|
|
|
const fixture = new ComponentFixture(Cmpt);
|
|
expect(destroyed).toBeFalsy();
|
|
|
|
fixture.component.showing = false;
|
|
fixture.update();
|
|
expect(destroyed).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
});
|