cargdev/angular
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(core): Update types for TypeScript nullability support (#15472)

Browse Source
This commit is contained in:
Miško Hevery
2017-03-29 09:34:45 -07:00
committed by Victor Berchet
parent 331b9f6425
commit 910c0d9ee7
84 changed files with 1287 additions and 1260 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
packages/core/src/animation/animation_metadata_wrapped.ts
View File

@ -62,7 +62,7 @@ export interface AnimationStyleMetadata extends AnimationMetadata {
*/
export interface AnimationAnimateMetadata extends AnimationMetadata {
timings: string|number|AnimateTimings;
styles: AnimationStyleMetadata|AnimationKeyframesSequenceMetadata;
styles: AnimationStyleMetadata|AnimationKeyframesSequenceMetadata|null;
}
/**
@ -86,8 +86,8 @@ export function trigger(name: string, definitions: AnimationMetadata[]): Animati
* @deprecated This symbol has moved. Please Import from @angular/animations instead!
*/
export function animate(
timings: string | number, styles: AnimationStyleMetadata | AnimationKeyframesSequenceMetadata =
null): AnimationAnimateMetadata {
timings: string | number, styles?: AnimationStyleMetadata |
AnimationKeyframesSequenceMetadata): AnimationAnimateMetadata {
return _animate(timings, styles);
}

17
packages/core/src/application_ref.ts
View File

@ -99,7 +99,7 @@ export function createPlatform(injector: Injector): PlatformRef {
* @experimental APIs related to application bootstrap are currently under review.
*/
export function createPlatformFactory(
parentPlatformFactory: (extraProviders?: Provider[]) => PlatformRef, name: string,
parentPlatformFactory: ((extraProviders?: Provider[]) => PlatformRef) | null, name: string,
providers: Provider[] = []): (extraProviders?: Provider[]) => PlatformRef {
const marker = new InjectionToken(`Platform: ${name}`);
return (extraProviders: Provider[] = []) => {
@ -153,7 +153,7 @@ export function destroyPlatform(): void {
*
* @experimental APIs related to application bootstrap are currently under review.
*/
export function getPlatform(): PlatformRef {
export function getPlatform(): PlatformRef|null {
return _platform && !_platform.destroyed ? _platform : null;
}
@ -278,10 +278,10 @@ export class PlatformRef_ extends PlatformRef {
}
bootstrapModuleFactory<M>(moduleFactory: NgModuleFactory<M>): Promise<NgModuleRef<M>> {
return this._bootstrapModuleFactoryWithZone(moduleFactory, null);
return this._bootstrapModuleFactoryWithZone(moduleFactory);
}
private _bootstrapModuleFactoryWithZone<M>(moduleFactory: NgModuleFactory<M>, ngZone: NgZone):
private _bootstrapModuleFactoryWithZone<M>(moduleFactory: NgModuleFactory<M>, ngZone?: NgZone):
Promise<NgModuleRef<M>> {
// Note: We need to create the NgZone _before_ we instantiate the module,
// as instantiating the module creates some providers eagerly.
@ -299,7 +299,7 @@ export class PlatformRef_ extends PlatformRef {
throw new Error('No ErrorHandler. Is platform module (BrowserModule) included?');
}
moduleRef.onDestroy(() => remove(this._modules, moduleRef));
ngZone.onError.subscribe({next: (error: any) => { exceptionHandler.handleError(error); }});
ngZone !.onError.subscribe({next: (error: any) => { exceptionHandler.handleError(error); }});
return _callAndReportToErrorHandler(exceptionHandler, () => {
const initStatus: ApplicationInitStatus = moduleRef.injector.get(ApplicationInitStatus);
return initStatus.donePromise.then(() => {
@ -312,12 +312,12 @@ export class PlatformRef_ extends PlatformRef {
bootstrapModule<M>(moduleType: Type<M>, compilerOptions: CompilerOptions|CompilerOptions[] = []):
Promise<NgModuleRef<M>> {
return this._bootstrapModuleWithZone(moduleType, compilerOptions, null);
return this._bootstrapModuleWithZone(moduleType, compilerOptions);
}
private _bootstrapModuleWithZone<M>(
moduleType: Type<M>, compilerOptions: CompilerOptions|CompilerOptions[] = [],
ngZone: NgZone = null): Promise<NgModuleRef<M>> {
ngZone?: NgZone): Promise<NgModuleRef<M>> {
const compilerFactory: CompilerFactory = this.injector.get(CompilerFactory);
const compiler = compilerFactory.createCompiler(
Array.isArray(compilerOptions) ? compilerOptions : [compilerOptions]);
@ -500,7 +500,8 @@ export class ApplicationRef_ extends ApplicationRef {
if (componentOrFactory instanceof ComponentFactory) {
componentFactory = componentOrFactory;
} else {
componentFactory = this._componentFactoryResolver.resolveComponentFactory(componentOrFactory);
componentFactory =
this._componentFactoryResolver.resolveComponentFactory(componentOrFactory) !;
}
this._rootComponentTypes.push(componentFactory.componentType);

146
packages/core/src/change_detection/differs/default_iterable_differ.ts
View File

@ -15,16 +15,15 @@ import {IterableChangeRecord, IterableChanges, IterableDiffer, IterableDifferFac
export class DefaultIterableDifferFactory implements IterableDifferFactory {
constructor() {}
supports(obj: Object): boolean { return isListLikeIterable(obj); }
supports(obj: Object|null|undefined): boolean { return isListLikeIterable(obj); }
create<V>(trackByFn?: TrackByFunction<any>): DefaultIterableDiffer<V>;
create<V>(trackByFn?: TrackByFunction<V>): DefaultIterableDiffer<V>;
/**
* @deprecated v4.0.0 - ChangeDetectorRef is not used and is no longer a parameter
*/
create<V>(
cdRefOrTrackBy?: ChangeDetectorRef|TrackByFunction<any>,
trackByFn?: TrackByFunction<any>): DefaultIterableDiffer<V> {
create<V>(cdRefOrTrackBy?: ChangeDetectorRef|TrackByFunction<V>, trackByFn?: TrackByFunction<V>):
DefaultIterableDiffer<V> {
return new DefaultIterableDiffer<V>(trackByFn || <TrackByFunction<any>>cdRefOrTrackBy);
}
}
@ -35,27 +34,28 @@ const trackByIdentity = (index: number, item: any) => item;
* @deprecated v4.0.0 - Should not be part of public API.
*/
export class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChanges<V> {
private _length: number = null;
private _collection: NgIterable<V> = null;
private _length: number = 0;
private _collection: NgIterable<V>|null = null;
// Keeps track of the used records at any point in time (during & across `_check()` calls)
private _linkedRecords: _DuplicateMap<V> = null;
private _linkedRecords: _DuplicateMap<V>|null = null;
// Keeps track of the removed records at any point in time during `_check()` calls.
private _unlinkedRecords: _DuplicateMap<V> = null;
private _previousItHead: IterableChangeRecord_<V> = null;
private _itHead: IterableChangeRecord_<V> = null;
private _itTail: IterableChangeRecord_<V> = null;
private _additionsHead: IterableChangeRecord_<V> = null;
private _additionsTail: IterableChangeRecord_<V> = null;
private _movesHead: IterableChangeRecord_<V> = null;
private _movesTail: IterableChangeRecord_<V> = null;
private _removalsHead: IterableChangeRecord_<V> = null;
private _removalsTail: IterableChangeRecord_<V> = null;
private _unlinkedRecords: _DuplicateMap<V>|null = null;
private _previousItHead: IterableChangeRecord_<V>|null = null;
private _itHead: IterableChangeRecord_<V>|null = null;
private _itTail: IterableChangeRecord_<V>|null = null;
private _additionsHead: IterableChangeRecord_<V>|null = null;
private _additionsTail: IterableChangeRecord_<V>|null = null;
private _movesHead: IterableChangeRecord_<V>|null = null;
private _movesTail: IterableChangeRecord_<V>|null = null;
private _removalsHead: IterableChangeRecord_<V>|null = null;
private _removalsTail: IterableChangeRecord_<V>|null = null;
// Keeps track of records where custom track by is the same, but item identity has changed
private _identityChangesHead: IterableChangeRecord_<V> = null;
private _identityChangesTail: IterableChangeRecord_<V> = null;
private _identityChangesHead: IterableChangeRecord_<V>|null = null;
private _identityChangesTail: IterableChangeRecord_<V>|null = null;
private _trackByFn: TrackByFunction<V>
constructor(private _trackByFn?: TrackByFunction<V>) {
this._trackByFn = this._trackByFn || trackByIdentity;
constructor(trackByFn?: TrackByFunction<V>) {
this._trackByFn = trackByFn || trackByIdentity;
}
get collection() { return this._collection; }
@ -63,25 +63,27 @@ export class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChan
get length(): number { return this._length; }
forEachItem(fn: (record: IterableChangeRecord_<V>) => void) {
let record: IterableChangeRecord_<V>;
let record: IterableChangeRecord_<V>|null;
for (record = this._itHead; record !== null; record = record._next) {
fn(record);
}
}
forEachOperation(
fn: (item: IterableChangeRecord_<V>, previousIndex: number, currentIndex: number) => void) {
fn: (item: IterableChangeRecord<V>, previousIndex: number|null, currentIndex: number|null) =>
void) {
let nextIt = this._itHead;
let nextRemove = this._removalsHead;
let addRemoveOffset = 0;
let moveOffsets: number[] = null;
let moveOffsets: number[]|null = null;
while (nextIt || nextRemove) {
// Figure out which is the next record to process
// Order: remove, add, move
const record = !nextRemove ||
const record: IterableChangeRecord<V> = !nextRemove ||
nextIt &&
nextIt.currentIndex < getPreviousIndex(nextRemove, addRemoveOffset, moveOffsets) ?
nextIt :
nextIt.currentIndex ! <
getPreviousIndex(nextRemove, addRemoveOffset, moveOffsets) ?
nextIt ! :
nextRemove;
const adjPreviousIndex = getPreviousIndex(record, addRemoveOffset, moveOffsets);
const currentIndex = record.currentIndex;
@ -91,14 +93,14 @@ export class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChan
addRemoveOffset--;
nextRemove = nextRemove._nextRemoved;
} else {
nextIt = nextIt._next;
nextIt = nextIt !._next;
if (record.previousIndex == null) {
addRemoveOffset++;
} else {
// INVARIANT: currentIndex < previousIndex
if (!moveOffsets) moveOffsets = [];
const localMovePreviousIndex = adjPreviousIndex - addRemoveOffset;
const localCurrentIndex = currentIndex - addRemoveOffset;
const localCurrentIndex = currentIndex ! - addRemoveOffset;
if (localMovePreviousIndex != localCurrentIndex) {
for (let i = 0; i < localMovePreviousIndex; i++) {
const offset = i < moveOffsets.length ? moveOffsets[i] : (moveOffsets[i] = 0);
@ -120,41 +122,41 @@ export class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChan
}
forEachPreviousItem(fn: (record: IterableChangeRecord_<V>) => void) {
let record: IterableChangeRecord_<V>;
let record: IterableChangeRecord_<V>|null;
for (record = this._previousItHead; record !== null; record = record._nextPrevious) {
fn(record);
}
}
forEachAddedItem(fn: (record: IterableChangeRecord_<V>) => void) {
let record: IterableChangeRecord_<V>;
let record: IterableChangeRecord_<V>|null;
for (record = this._additionsHead; record !== null; record = record._nextAdded) {
fn(record);
}
}
forEachMovedItem(fn: (record: IterableChangeRecord_<V>) => void) {
let record: IterableChangeRecord_<V>;
let record: IterableChangeRecord_<V>|null;
for (record = this._movesHead; record !== null; record = record._nextMoved) {
fn(record);
}
}
forEachRemovedItem(fn: (record: IterableChangeRecord_<V>) => void) {
let record: IterableChangeRecord_<V>;
let record: IterableChangeRecord_<V>|null;
for (record = this._removalsHead; record !== null; record = record._nextRemoved) {
fn(record);
}
}
forEachIdentityChange(fn: (record: IterableChangeRecord_<V>) => void) {
let record: IterableChangeRecord_<V>;
let record: IterableChangeRecord_<V>|null;
for (record = this._identityChangesHead; record !== null; record = record._nextIdentityChange) {
fn(record);
}
}
diff(collection: NgIterable<V>): DefaultIterableDiffer<V> {
diff(collection: NgIterable<V>): DefaultIterableDiffer<V>|null {
if (collection == null) collection = [];
if (!isListLikeIterable(collection)) {
throw new Error(
@ -174,7 +176,7 @@ export class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChan
check(collection: NgIterable<V>): boolean {
this._reset();
let record: IterableChangeRecord_<V> = this._itHead;
let record: IterableChangeRecord_<V>|null = this._itHead;
let mayBeDirty: boolean = false;
let index: number;
let item: V;
@ -241,8 +243,8 @@ export class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChan
*/
_reset() {
if (this.isDirty) {
let record: IterableChangeRecord_<V>;
let nextRecord: IterableChangeRecord_<V>;
let record: IterableChangeRecord_<V>|null;
let nextRecord: IterableChangeRecord_<V>|null;
for (record = this._previousItHead = this._itHead; record !== null; record = record._next) {
record._nextPrevious = record._next;
@ -276,15 +278,15 @@ export class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChan
*
* @internal
*/
_mismatch(record: IterableChangeRecord_<V>, item: V, itemTrackBy: any, index: number):
_mismatch(record: IterableChangeRecord_<V>|null, item: V, itemTrackBy: any, index: number):
IterableChangeRecord_<V> {
// The previous record after which we will append the current one.
let previousRecord: IterableChangeRecord_<V>;
if (record === null) {
previousRecord = this._itTail;
previousRecord = this._itTail !;
} else {
previousRecord = record._prev;
previousRecord = record._prev !;
// Remove the record from the collection since we know it does not match the item.
this._remove(record);
}
@ -299,7 +301,7 @@ export class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChan
this._moveAfter(record, previousRecord, index);
} else {
// Never seen it, check evicted list.
record = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy);
record = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);
if (record !== null) {
// It is an item which we have evicted earlier: reinsert it back into the list.
// But first we need to check if identity changed, so we can update in view if necessary
@ -344,10 +346,10 @@ export class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChan
*/
_verifyReinsertion(record: IterableChangeRecord_<V>, item: V, itemTrackBy: any, index: number):
IterableChangeRecord_<V> {
let reinsertRecord: IterableChangeRecord_<V> =
this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy);
let reinsertRecord: IterableChangeRecord_<V>|null =
this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);
if (reinsertRecord !== null) {
record = this._reinsertAfter(reinsertRecord, record._prev, index);
record = this._reinsertAfter(reinsertRecord, record._prev !, index);
} else if (record.currentIndex != index) {
record.currentIndex = index;
this._addToMoves(record, index);
@ -362,10 +364,10 @@ export class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChan
*
* @internal
*/
_truncate(record: IterableChangeRecord_<V>) {
_truncate(record: IterableChangeRecord_<V>|null) {
// Anything after that needs to be removed;
while (record !== null) {
const nextRecord: IterableChangeRecord_<V> = record._next;
const nextRecord: IterableChangeRecord_<V>|null = record._next;
this._addToRemovals(this._unlink(record));
record = nextRecord;
}
@ -452,7 +454,8 @@ export class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChan
// assert(record._next === null);
// assert(record._prev === null);
const next: IterableChangeRecord_<V> = prevRecord === null ? this._itHead : prevRecord._next;
const next: IterableChangeRecord_<V>|null =
prevRecord === null ? this._itHead : prevRecord._next;
// todo(vicb)
// assert(next != record);
// assert(prevRecord != record);
@ -599,29 +602,29 @@ export class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChan
* @stable
*/
export class IterableChangeRecord_<V> implements IterableChangeRecord<V> {
currentIndex: number = null;
previousIndex: number = null;
currentIndex: number|null = null;
previousIndex: number|null = null;
/** @internal */
_nextPrevious: IterableChangeRecord_<V> = null;
_nextPrevious: IterableChangeRecord_<V>|null = null;
/** @internal */
_prev: IterableChangeRecord_<V> = null;
_prev: IterableChangeRecord_<V>|null = null;
/** @internal */
_next: IterableChangeRecord_<V> = null;
_next: IterableChangeRecord_<V>|null = null;
/** @internal */
_prevDup: IterableChangeRecord_<V> = null;
_prevDup: IterableChangeRecord_<V>|null = null;
/** @internal */
_nextDup: IterableChangeRecord_<V> = null;
_nextDup: IterableChangeRecord_<V>|null = null;
/** @internal */
_prevRemoved: IterableChangeRecord_<V> = null;
_prevRemoved: IterableChangeRecord_<V>|null = null;
/** @internal */
_nextRemoved: IterableChangeRecord_<V> = null;
_nextRemoved: IterableChangeRecord_<V>|null = null;
/** @internal */
_nextAdded: IterableChangeRecord_<V> = null;
_nextAdded: IterableChangeRecord_<V>|null = null;
/** @internal */
_nextMoved: IterableChangeRecord_<V> = null;
_nextMoved: IterableChangeRecord_<V>|null = null;
/** @internal */
_nextIdentityChange: IterableChangeRecord_<V> = null;
_nextIdentityChange: IterableChangeRecord_<V>|null = null;
constructor(public item: V, public trackById: any) {}
@ -636,9 +639,9 @@ export class IterableChangeRecord_<V> implements IterableChangeRecord<V> {
// A linked list of CollectionChangeRecords with the same IterableChangeRecord_.item
class _DuplicateItemRecordList<V> {
/** @internal */
_head: IterableChangeRecord_<V> = null;
_head: IterableChangeRecord_<V>|null = null;
/** @internal */
_tail: IterableChangeRecord_<V> = null;
_tail: IterableChangeRecord_<V>|null = null;
/**
* Append the record to the list of duplicates.
@ -654,7 +657,7 @@ class _DuplicateItemRecordList<V> {
// todo(vicb)
// assert(record.item == _head.item ||
// record.item is num && record.item.isNaN && _head.item is num && _head.item.isNaN);
this._tail._nextDup = record;
this._tail !._nextDup = record;
record._prevDup = this._tail;
record._nextDup = null;
this._tail = record;
@ -663,8 +666,8 @@ class _DuplicateItemRecordList<V> {
// Returns a IterableChangeRecord_ having IterableChangeRecord_.trackById == trackById and
// IterableChangeRecord_.currentIndex >= afterIndex
get(trackById: any, afterIndex: number): IterableChangeRecord_<V> {
let record: IterableChangeRecord_<V>;
get(trackById: any, afterIndex: number|null): IterableChangeRecord_<V>|null {
let record: IterableChangeRecord_<V>|null;
for (record = this._head; record !== null; record = record._nextDup) {
if ((afterIndex === null || afterIndex < record.currentIndex) &&
looseIdentical(record.trackById, trackById)) {
@ -689,8 +692,8 @@ class _DuplicateItemRecordList<V> {
// return false;
//});
const prev: IterableChangeRecord_<V> = record._prevDup;
const next: IterableChangeRecord_<V> = record._nextDup;
const prev: IterableChangeRecord_<V>|null = record._prevDup;
const next: IterableChangeRecord_<V>|null = record._nextDup;
if (prev === null) {
this._head = next;
} else {
@ -726,7 +729,7 @@ class _DuplicateMap<V> {
* Use case: `[a, b, c, a, a]` if we are at index `3` which is the second `a` then asking if we
* have any more `a`s needs to return the last `a` not the first or second.
*/
get(trackById: any, afterIndex: number = null): IterableChangeRecord_<V> {
get(trackById: any, afterIndex: number|null): IterableChangeRecord_<V>|null {
const key = trackById;
const recordList = this.map.get(key);
return recordList ? recordList.get(trackById, afterIndex) : null;
@ -739,7 +742,7 @@ class _DuplicateMap<V> {
*/
remove(record: IterableChangeRecord_<V>): IterableChangeRecord_<V> {
const key = record.trackById;
const recordList: _DuplicateItemRecordList<V> = this.map.get(key);
const recordList: _DuplicateItemRecordList<V> = this.map.get(key) !;
// Remove the list of duplicates when it gets empty
if (recordList.remove(record)) {
this.map.delete(key);
@ -754,7 +757,8 @@ class _DuplicateMap<V> {
toString(): string { return '_DuplicateMap(' + stringify(this.map) + ')'; }
}
function getPreviousIndex(item: any, addRemoveOffset: number, moveOffsets: number[]): number {
function getPreviousIndex(
item: any, addRemoveOffset: number, moveOffsets: number[] | null): number {
const previousIndex = item.previousIndex;
if (previousIndex === null) return previousIndex;
let moveOffset = 0;

59
packages/core/src/change_detection/differs/default_keyvalue_differ.ts
View File

@ -28,21 +28,16 @@ export class DefaultKeyValueDifferFactory<K, V> implements KeyValueDifferFactory
export class DefaultKeyValueDiffer<K, V> implements KeyValueDiffer<K, V>, KeyValueChanges<K, V> {
private _records = new Map<K, KeyValueChangeRecord_<K, V>>();
private _mapHead: KeyValueChangeRecord_<K, V> = null;
private _mapHead: KeyValueChangeRecord_<K, V>|null = null;
// _appendAfter is used in the check loop
private _appendAfter: KeyValueChangeRecord_<K, V> = null;
private _previousMapHead: KeyValueChangeRecord_<K, V> = null;
private _changesHead: KeyValueChangeRecord_<K, V> = null;
private _changesTail: KeyValueChangeRecord_<K, V> = null;
private _additionsHead: KeyValueChangeRecord_<K, V> = null;
private _additionsTail: KeyValueChangeRecord_<K, V> = null;
private _removalsHead: KeyValueChangeRecord_<K, V> = null;
private _removalsTail: KeyValueChangeRecord_<K, V> = null;
private _appendAfter: KeyValueChangeRecord_<K, V>|null = null;
private _previousMapHead: KeyValueChangeRecord_<K, V>|null = null;
private _changesHead: KeyValueChangeRecord_<K, V>|null = null;
private _changesTail: KeyValueChangeRecord_<K, V>|null = null;
private _additionsHead: KeyValueChangeRecord_<K, V>|null = null;
private _additionsTail: KeyValueChangeRecord_<K, V>|null = null;
private _removalsHead: KeyValueChangeRecord_<K, V>|null = null;
private _removalsTail: KeyValueChangeRecord_<K, V>|null = null;
get isDirty(): boolean {
return this._additionsHead !== null || this._changesHead !== null ||
@ -50,41 +45,41 @@ export class DefaultKeyValueDiffer<K, V> implements KeyValueDiffer<K, V>, KeyVal
}
forEachItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {
let record: KeyValueChangeRecord_<K, V>;
let record: KeyValueChangeRecord_<K, V>|null;
for (record = this._mapHead; record !== null; record = record._next) {
fn(record);
}
}
forEachPreviousItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {
let record: KeyValueChangeRecord_<K, V>;
let record: KeyValueChangeRecord_<K, V>|null;
for (record = this._previousMapHead; record !== null; record = record._nextPrevious) {
fn(record);
}
}
forEachChangedItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {
let record: KeyValueChangeRecord_<K, V>;
let record: KeyValueChangeRecord_<K, V>|null;
for (record = this._changesHead; record !== null; record = record._nextChanged) {
fn(record);
}
}
forEachAddedItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {
let record: KeyValueChangeRecord_<K, V>;
let record: KeyValueChangeRecord_<K, V>|null;
for (record = this._additionsHead; record !== null; record = record._nextAdded) {
fn(record);
}
}
forEachRemovedItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {
let record: KeyValueChangeRecord_<K, V>;
let record: KeyValueChangeRecord_<K, V>|null;
for (record = this._removalsHead; record !== null; record = record._nextRemoved) {
fn(record);
}
}
diff(map: Map<any, any>|{[k: string]: any}): any {
diff(map?: Map<any, any>|{[k: string]: any}|null): any {
if (!map) {
map = new Map();
} else if (!(map instanceof Map || isJsObject(map))) {
@ -209,7 +204,7 @@ export class DefaultKeyValueDiffer<K, V> implements KeyValueDiffer<K, V>, KeyVal
/** @internal */
_reset() {
if (this.isDirty) {
let record: KeyValueChangeRecord_<K, V>;
let record: KeyValueChangeRecord_<K, V>|null;
// let `_previousMapHead` contain the state of the map before the changes
this._previousMapHead = this._mapHead;
for (record = this._previousMapHead; record !== null; record = record._next) {
@ -244,7 +239,7 @@ export class DefaultKeyValueDiffer<K, V> implements KeyValueDiffer<K, V>, KeyVal
if (this._additionsHead === null) {
this._additionsHead = this._additionsTail = record;
} else {
this._additionsTail._nextAdded = record;
this._additionsTail !._nextAdded = record;
this._additionsTail = record;
}
}
@ -253,7 +248,7 @@ export class DefaultKeyValueDiffer<K, V> implements KeyValueDiffer<K, V>, KeyVal
if (this._changesHead === null) {
this._changesHead = this._changesTail = record;
} else {
this._changesTail._nextChanged = record;
this._changesTail !._nextChanged = record;
this._changesTail = record;
}
}
@ -264,7 +259,7 @@ export class DefaultKeyValueDiffer<K, V> implements KeyValueDiffer<K, V>, KeyVal
const changes: any[] = [];
const additions: any[] = [];
const removals: any[] = [];
let record: KeyValueChangeRecord_<K, V>;
let record: KeyValueChangeRecord_<K, V>|null;
for (record = this._mapHead; record !== null; record = record._next) {
items.push(stringify(record));
@ -304,21 +299,21 @@ export class DefaultKeyValueDiffer<K, V> implements KeyValueDiffer<K, V>, KeyVal
* @stable
*/
class KeyValueChangeRecord_<K, V> implements KeyValueChangeRecord<K, V> {
previousValue: V = null;
currentValue: V = null;
previousValue: V|null = null;
currentValue: V|null = null;
/** @internal */
_nextPrevious: KeyValueChangeRecord_<K, V> = null;
_nextPrevious: KeyValueChangeRecord_<K, V>|null = null;
/** @internal */
_next: KeyValueChangeRecord_<K, V> = null;
_next: KeyValueChangeRecord_<K, V>|null = null;
/** @internal */
_prev: KeyValueChangeRecord_<K, V> = null;
_prev: KeyValueChangeRecord_<K, V>|null = null;
/** @internal */
_nextAdded: KeyValueChangeRecord_<K, V> = null;
_nextAdded: KeyValueChangeRecord_<K, V>|null = null;
/** @internal */
_nextRemoved: KeyValueChangeRecord_<K, V> = null;
_nextRemoved: KeyValueChangeRecord_<K, V>|null = null;
/** @internal */
_nextChanged: KeyValueChangeRecord_<K, V> = null;
_nextChanged: KeyValueChangeRecord_<K, V>|null = null;
constructor(public key: K) {}

14
packages/core/src/change_detection/differs/iterable_differs.ts
View File

@ -30,7 +30,7 @@ export interface IterableDiffer<V> {
* @returns an object describing the difference. The return value is only valid until the next
* `diff()` invocation.
*/
diff(object: NgIterable<V>): IterableChanges<V>;
diff(object: NgIterable<V>): IterableChanges<V>|null;
}
/**
@ -92,20 +92,16 @@ export interface IterableChanges<V> {
*/
export interface IterableChangeRecord<V> {
/** Current index of the item in `Iterable` or null if removed. */
// TODO(TS2.1): make readonly once we move to TS v2.1
/* readonly */ currentIndex: number;
readonly currentIndex: number|null;
/** Previous index of the item in `Iterable` or null if added. */
// TODO(TS2.1): make readonly once we move to TS v2.1
/* readonly */ previousIndex: number;
readonly previousIndex: number|null;
/** The item. */
// TODO(TS2.1): make readonly once we move to TS v2.1
/* readonly */ item: V;
readonly item: V;
/** Track by identity as computed by the `trackByFn`. */
// TODO(TS2.1): make readonly once we move to TS v2.1
/* readonly */ trackById: any;
readonly trackById: any;
}
/**

10
packages/core/src/change_detection/differs/keyvalue_differs.ts
View File

@ -82,17 +82,17 @@ export interface KeyValueChangeRecord<K, V> {
/**
* Current key in the Map.
*/
/* readonly */ key: K;
readonly key: K;
/**
* Current value for the key or `undefined` if removed.
* Current value for the key or `null` if removed.
*/
/* readonly */ currentValue: V;
readonly currentValue: V|null;
/**
* Previous value for the key or `undefined` if added.
* Previous value for the key or `null` if added.
*/
/* readonly */ previousValue: V;
readonly previousValue: V|null;
}
/**

28
packages/core/src/debug/debug_node.ts
View File

@ -17,9 +17,9 @@ export class EventListener { constructor(public name: string, public callback: F
export class DebugNode {
nativeNode: any;
listeners: EventListener[];
parent: DebugElement;
parent: DebugElement|null;
constructor(nativeNode: any, parent: DebugNode, private _debugContext: DebugContext) {
constructor(nativeNode: any, parent: DebugNode|null, private _debugContext: DebugContext) {
this.nativeNode = nativeNode;
if (parent && parent instanceof DebugElement) {
parent.addChild(this);
@ -29,19 +29,15 @@ export class DebugNode {
this.listeners = [];
}
get injector(): Injector { return this._debugContext ? this._debugContext.injector : null; }
get injector(): Injector { return this._debugContext.injector; }
get componentInstance(): any { return this._debugContext ? this._debugContext.component : null; }
get componentInstance(): any { return this._debugContext.component; }
get context(): any { return this._debugContext ? this._debugContext.context : null; }
get context(): any { return this._debugContext.context; }
get references(): {[key: string]: any} {
return this._debugContext ? this._debugContext.references : null;
}
get references(): {[key: string]: any} { return this._debugContext.references; }
get providerTokens(): any[] {
return this._debugContext ? this._debugContext.providerTokens : null;
}
get providerTokens(): any[] { return this._debugContext.providerTokens; }
/**
* @deprecated since v4
@ -55,9 +51,9 @@ export class DebugNode {
export class DebugElement extends DebugNode {
name: string;
properties: {[key: string]: any};
attributes: {[key: string]: string};
attributes: {[key: string]: string | null};
classes: {[key: string]: boolean};
styles: {[key: string]: string};
styles: {[key: string]: string | null};
childNodes: DebugNode[];
nativeElement: any;
@ -181,8 +177,8 @@ const _nativeNodeToDebugNode = new Map<any, DebugNode>();
/**
* @experimental
*/
export function getDebugNode(nativeNode: any): DebugNode {
return _nativeNodeToDebugNode.get(nativeNode);
export function getDebugNode(nativeNode: any): DebugNode|null {
return _nativeNodeToDebugNode.get(nativeNode) || null;
}
export function getAllDebugNodes(): DebugNode[] {
@ -203,4 +199,4 @@ export function removeDebugNodeFromIndex(node: DebugNode) {
*
* @experimental All debugging apis are currently experimental.
*/
export interface Predicate<T> { (value: T, index?: number, array?: T[]): boolean; }
export interface Predicate<T> { (value: T): boolean; }

20
packages/core/src/di/reflective_injector.ts
View File

@ -115,7 +115,7 @@ export abstract class ReflectiveInjector implements Injector {
* because it needs to resolve the passed-in providers first.
* See {@link Injector#resolve} and {@link Injector#fromResolvedProviders}.
*/
static resolveAndCreate(providers: Provider[], parent: Injector = null): ReflectiveInjector {
static resolveAndCreate(providers: Provider[], parent?: Injector): ReflectiveInjector {
const ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
return ReflectiveInjector.fromResolvedProviders(ResolvedReflectiveProviders, parent);
}
@ -143,7 +143,7 @@ export abstract class ReflectiveInjector implements Injector {
* ```
* @experimental
*/
static fromResolvedProviders(providers: ResolvedReflectiveProvider[], parent: Injector = null):
static fromResolvedProviders(providers: ResolvedReflectiveProvider[], parent?: Injector):
ReflectiveInjector {
return new ReflectiveInjector_(providers, parent);
}
@ -163,7 +163,7 @@ export abstract class ReflectiveInjector implements Injector {
* expect(child.parent).toBe(parent);
* ```
*/
abstract get parent(): Injector;
abstract get parent(): Injector|null;
/**
* Resolves an array of providers and creates a child injector from those providers.
@ -282,16 +282,16 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
/** @internal */
public _providers: ResolvedReflectiveProvider[];
/** @internal */
public _parent: Injector;
public _parent: Injector|null;
keyIds: number[];
objs: any[];
/**
* Private
*/
constructor(_providers: ResolvedReflectiveProvider[], _parent: Injector = null) {
constructor(_providers: ResolvedReflectiveProvider[], _parent?: Injector) {
this._providers = _providers;
this._parent = _parent;
this._parent = _parent || null;
const len = _providers.length;
@ -308,7 +308,7 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
return this._getByKey(ReflectiveKey.get(token), null, notFoundValue);
}
get parent(): Injector { return this._parent; }
get parent(): Injector|null { return this._parent; }
resolveAndCreateChild(providers: Provider[]): ReflectiveInjector {
const ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
@ -388,7 +388,7 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
return this._getByKey(dep.key, dep.visibility, dep.optional ? null : THROW_IF_NOT_FOUND);
}
private _getByKey(key: ReflectiveKey, visibility: Self|SkipSelf, notFoundValue: any): any {
private _getByKey(key: ReflectiveKey, visibility: Self|SkipSelf|null, notFoundValue: any): any {
if (key === INJECTOR_KEY) {
return this;
}
@ -431,8 +431,8 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
}
/** @internal */
_getByKeyDefault(key: ReflectiveKey, notFoundValue: any, visibility: Self|SkipSelf): any {
let inj: Injector;
_getByKeyDefault(key: ReflectiveKey, notFoundValue: any, visibility: Self|SkipSelf|null): any {
let inj: Injector|null;
if (visibility instanceof SkipSelf) {
inj = this._parent;

2
packages/core/src/di/reflective_key.ts
View File

@ -64,7 +64,7 @@ export class KeyRegistry {
if (token instanceof ReflectiveKey) return token;
if (this._allKeys.has(token)) {
return this._allKeys.get(token);
return this._allKeys.get(token) !;
}
const newKey = new ReflectiveKey(token, ReflectiveKey.numberOfKeys);

11
packages/core/src/di/reflective_provider.ts
View File

@ -26,7 +26,7 @@ interface NormalizedProvider extends TypeProvider, ValueProvider, ClassProvider,
*/
export class ReflectiveDependency {
constructor(
public key: ReflectiveKey, public optional: boolean, public visibility: Self|SkipSelf) {}
public key: ReflectiveKey, public optional: boolean, public visibility: Self|SkipSelf|null) {}
static fromKey(key: ReflectiveKey): ReflectiveDependency {
return new ReflectiveDependency(key, false, null);
@ -128,7 +128,8 @@ function resolveReflectiveFactory(provider: NormalizedProvider): ResolvedReflect
*/
function resolveReflectiveProvider(provider: NormalizedProvider): ResolvedReflectiveProvider {
return new ResolvedReflectiveProvider_(
ReflectiveKey.get(provider.provide), [resolveReflectiveFactory(provider)], provider.multi);
ReflectiveKey.get(provider.provide), [resolveReflectiveFactory(provider)],
provider.multi || false);
}
/**
@ -198,7 +199,7 @@ function _normalizeProviders(providers: Provider[], res: Provider[]): Provider[]
}
export function constructDependencies(
typeOrFunc: any, dependencies: any[]): ReflectiveDependency[] {
typeOrFunc: any, dependencies?: any[]): ReflectiveDependency[] {
if (!dependencies) {
return _dependenciesFor(typeOrFunc);
} else {
@ -230,7 +231,7 @@ function _extractToken(
}
}
let visibility: Self|SkipSelf = null;
let visibility: Self|SkipSelf|null = null;
for (let i = 0; i < metadata.length; ++i) {
const paramMetadata = metadata[i];
@ -261,6 +262,6 @@ function _extractToken(
}
function _createDependency(
token: any, optional: boolean, visibility: Self | SkipSelf): ReflectiveDependency {
token: any, optional: boolean, visibility: Self | SkipSelf | null): ReflectiveDependency {
return new ReflectiveDependency(ReflectiveKey.get(token), optional, visibility);
}

2
packages/core/src/linker/component_factory_resolver.ts
View File

@ -56,7 +56,7 @@ export class CodegenComponentFactoryResolver implements ComponentFactoryResolver
resolveComponentFactory<T>(component: {new (...args: any[]): T}): ComponentFactory<T> {
let factory = this._factories.get(component) || this._parent.resolveComponentFactory(component);
return factory ? new ComponentFactoryBoundToModule(factory, this._ngModule) : null;
return new ComponentFactoryBoundToModule(factory, this._ngModule);
}
}

2
packages/core/src/linker/ng_module_factory.ts
View File

@ -60,7 +60,7 @@ export class NgModuleFactory<T> {
get moduleType(): Type<T> { return this._moduleType; }
create(parentInjector: Injector): NgModuleRef<T> {
create(parentInjector: Injector|null): NgModuleRef<T> {
const instance = new this._injectorClass(parentInjector || Injector.NULL);
instance.create();
return instance;

4
packages/core/src/linker/query_list.ts
View File

@ -63,7 +63,9 @@ export class QueryList<T>/* implements Iterable<T> */ {
* See
* [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
*/
find(fn: (item: T, index: number, array: T[]) => boolean): T { return this._results.find(fn); }
find(fn: (item: T, index: number, array: T[]) => boolean): T|undefined {
return this._results.find(fn);
}
/**
* See

4
packages/core/src/linker/view_container_ref.ts
View File

@ -51,7 +51,7 @@ export abstract class ViewContainerRef {
/**
* Returns the {@link ViewRef} for the View located in this container at the specified index.
*/
abstract get(index: number): ViewRef;
abstract get(index: number): ViewRef|null;
/**
* Returns the number of Views currently attached to this container.
@ -120,5 +120,5 @@ export abstract class ViewContainerRef {
*
* If the `index` param is omitted, the last {@link ViewRef} is detached.
*/
abstract detach(index?: number): ViewRef;
abstract detach(index?: number): ViewRef|null;
}

14
packages/core/src/metadata/view.ts
View File

@ -62,19 +62,19 @@ export enum ViewEncapsulation {
*/
export class ViewMetadata {
/** {@link Component.templateUrl} */
templateUrl: string;
templateUrl: string|undefined;
/** {@link Component.template} */
template: string;
template: string|undefined;
/** {@link Component.stylesUrl} */
styleUrls: string[];
styleUrls: string[]|undefined;
/** {@link Component.styles} */
styles: string[];
styles: string[]|undefined;
/** {@link Component.encapsulation} */
encapsulation: ViewEncapsulation;
encapsulation: ViewEncapsulation|undefined;
/** {@link Component.animation} */
animations: any[];
animations: any[]|undefined;
/** {@link Component.interpolation} */
interpolation: [string, string];
interpolation: [string, string]|undefined;
constructor(
{templateUrl, template, encapsulation, styles, styleUrls, animations, interpolation}: {

4
packages/core/src/profile/wtf_impl.ts
View File

@ -53,7 +53,9 @@ export function createScope(signature: string, flags: any = null): any {
return events.createScope(signature, flags);
}
export function leave<T>(scope: Scope, returnValue?: T): T {
export function leave<T>(scope: Scope): void;
export function leave<T>(scope: Scope, returnValue?: T): T;
export function leave<T>(scope: Scope, returnValue?: any): any {
trace.leaveScope(scope, returnValue);
return returnValue;
}

2
packages/core/src/reflection/platform_reflection_capabilities.ts
View File

@ -21,6 +21,6 @@ export interface PlatformReflectionCapabilities {
method(name: string): MethodFn;
importUri(type: Type<any>): string;
resourceUri(type: Type<any>): string;
resolveIdentifier(name: string, moduleUrl: string, members: string[], runtime: any): any;
resolveIdentifier(name: string, moduleUrl: string, members: string[]|null, runtime: any): any;
resolveEnum(enumIdentifier: any, name: string): any;
}

8
packages/core/src/reflection/reflection_capabilities.ts
View File

@ -54,7 +54,7 @@ export class ReflectionCapabilities implements PlatformReflectionCapabilities {
return result;
}
private _ownParameters(type: Type<any>, parentCtor: any): any[][] {
private _ownParameters(type: Type<any>, parentCtor: any): any[][]|null {
// If we have no decorators, we only have function.length as metadata.
// In that case, to detect whether a child class declared an own constructor or not,
// we need to look inside of that constructor to check whether it is
@ -115,7 +115,7 @@ export class ReflectionCapabilities implements PlatformReflectionCapabilities {
return parameters || [];
}
private _ownAnnotations(typeOrFunc: Type<any>, parentCtor: any): any[] {
private _ownAnnotations(typeOrFunc: Type<any>, parentCtor: any): any[]|null {
// Prefer the direct API.
if ((<any>typeOrFunc).annotations && (<any>typeOrFunc).annotations !== parentCtor.annotations) {
let annotations = (<any>typeOrFunc).annotations;
@ -134,6 +134,7 @@ export class ReflectionCapabilities implements PlatformReflectionCapabilities {
if (this._reflect && this._reflect.getOwnMetadata) {
return this._reflect.getOwnMetadata('annotations', typeOrFunc);
}
return null;
}
annotations(typeOrFunc: Type<any>): any[] {
@ -146,7 +147,7 @@ export class ReflectionCapabilities implements PlatformReflectionCapabilities {
return parentAnnotations.concat(ownAnnotations);
}
private _ownPropMetadata(typeOrFunc: any, parentCtor: any): {[key: string]: any[]} {
private _ownPropMetadata(typeOrFunc: any, parentCtor: any): {[key: string]: any[]}|null {
// Prefer the direct API.
if ((<any>typeOrFunc).propMetadata &&
(<any>typeOrFunc).propMetadata !== parentCtor.propMetadata) {
@ -172,6 +173,7 @@ export class ReflectionCapabilities implements PlatformReflectionCapabilities {
if (this._reflect && this._reflect.getOwnMetadata) {
return this._reflect.getOwnMetadata('propMetadata', typeOrFunc);
}
return null;
}
propMetadata(typeOrFunc: any): {[key: string]: any[]} {

2
packages/core/src/reflection/reflector.ts
View File

@ -51,7 +51,7 @@ export class Reflector extends ReflectorReader {
resourceUri(type: any): string { return this.reflectionCapabilities.resourceUri(type); }
resolveIdentifier(name: string, moduleUrl: string, members: string[], runtime: any): any {
resolveIdentifier(name: string, moduleUrl: string, members: string[]|null, runtime: any): any {
return this.reflectionCapabilities.resolveIdentifier(name, moduleUrl, members, runtime);
}

2
packages/core/src/reflection/reflector_reader.ts
View File

@ -14,7 +14,7 @@ export abstract class ReflectorReader {
abstract parameters(typeOrFunc: /*Type*/ any): any[][];
abstract annotations(typeOrFunc: /*Type*/ any): any[];
abstract propMetadata(typeOrFunc: /*Type*/ any): {[key: string]: any[]};
abstract importUri(typeOrFunc: /*Type*/ any): string;
abstract importUri(typeOrFunc: /*Type*/ any): string|null;
abstract resourceUri(typeOrFunc: /*Type*/ any): string;
abstract resolveIdentifier(name: string, moduleUrl: string, members: string[], runtime: any): any;
abstract resolveEnum(identifier: any, name: string): any;

10
packages/core/src/render/api.ts
View File

@ -126,7 +126,7 @@ export interface RendererType2 {
* @experimental
*/
export abstract class RendererFactory2 {
abstract createRenderer(hostElement: any, type: RendererType2): Renderer2;
abstract createRenderer(hostElement: any, type: RendererType2|null): Renderer2;
}
/**
@ -148,7 +148,7 @@ export abstract class Renderer2 {
abstract get data(): {[key: string]: any};
abstract destroy(): void;
abstract createElement(name: string, namespace?: string): any;
abstract createElement(name: string, namespace?: string|null): any;
abstract createComment(value: string): any;
abstract createText(value: string): any;
/**
@ -156,7 +156,7 @@ export abstract class Renderer2 {
* in which case the view engine won't call it.
* This is used as a performance optimization for production mode.
*/
destroyNode: (node: any) => void | null;
destroyNode: ((node: any) => void)|null;
abstract appendChild(parent: any, newChild: any): void;
abstract insertBefore(parent: any, newChild: any, refChild: any): void;
abstract removeChild(parent: any, oldChild: any): void;
@ -173,8 +173,8 @@ export abstract class Renderer2 {
* the caller can't rely on checking whether this is null or not.
*/
abstract nextSibling(node: any): any;
abstract setAttribute(el: any, name: string, value: string, namespace?: string): void;
abstract removeAttribute(el: any, name: string, namespace?: string): void;
abstract setAttribute(el: any, name: string, value: string, namespace?: string|null): void;
abstract removeAttribute(el: any, name: string, namespace?: string|null): void;
abstract addClass(el: any, name: string): void;
abstract removeClass(el: any, name: string): void;
abstract setStyle(el: any, style: string, value: any, flags?: RendererStyleFlags2): void;

10
packages/core/src/testability/testability.ts
View File

@ -92,7 +92,7 @@ export class Testability implements PublicTestability {
// Schedules the call backs in a new frame so that it is always async.
scheduleMicroTask(() => {
while (this._callbacks.length !== 0) {
(this._callbacks.pop())(this._didWork);
(this._callbacks.pop() !)(this._didWork);
}
this._didWork = false;
});
@ -136,13 +136,13 @@ export class TestabilityRegistry {
this._applications.set(token, testability);
}
getTestability(elem: any): Testability { return this._applications.get(elem); }
getTestability(elem: any): Testability|null { return this._applications.get(elem) || null; }
getAllTestabilities(): Testability[] { return Array.from(this._applications.values()); }
getAllRootElements(): any[] { return Array.from(this._applications.keys()); }
findTestabilityInTree(elem: Node, findInAncestors: boolean = true): Testability {
findTestabilityInTree(elem: Node, findInAncestors: boolean = true): Testability|null {
return _testabilityGetter.findTestabilityInTree(this, elem, findInAncestors);
}
}
@ -157,13 +157,13 @@ export class TestabilityRegistry {
export interface GetTestability {
addToWindow(registry: TestabilityRegistry): void;
findTestabilityInTree(registry: TestabilityRegistry, elem: any, findInAncestors: boolean):
Testability;
Testability|null;
}
class _NoopGetTestability implements GetTestability {
addToWindow(registry: TestabilityRegistry): void {}
findTestabilityInTree(registry: TestabilityRegistry, elem: any, findInAncestors: boolean):
Testability {
Testability|null {
return null;
}
}

10
packages/core/src/util/decorators.ts
View File

@ -96,7 +96,7 @@ function extractAnnotation(annotation: any): any {
return annotation;
}
function applyParams(fnOrArray: (Function | any[]), key: string): Function {
function applyParams(fnOrArray: Function | any[] | undefined, key: string): Function {
if (fnOrArray === Object || fnOrArray === String || fnOrArray === Function ||
fnOrArray === Number || fnOrArray === Array) {
throw new Error(`Can not use native ${stringify(fnOrArray)} as constructor`);
@ -107,7 +107,7 @@ function applyParams(fnOrArray: (Function | any[]), key: string): Function {
}
if (Array.isArray(fnOrArray)) {
const annotations: any[] = fnOrArray;
const annotations: any[] = fnOrArray as any[];
const annoLength = annotations.length - 1;
const fn: Function = fnOrArray[annoLength];
if (typeof fn !== 'function') {
@ -263,7 +263,7 @@ export function Class(clsDef: ClassDefinition): Type<any> {
*/
export function makeDecorator(
name: string, props: {[name: string]: any}, parentClass?: any,
chainFn: (fn: Function) => void = null): (...args: any[]) => (cls: any) => any {
chainFn?: (fn: Function) => void): (...args: any[]) => (cls: any) => any {
const metaCtor = makeMetadataCtor([props]);
function DecoratorFactory(objOrType: any): (cls: any) => any {
@ -332,7 +332,7 @@ export function makeParamDecorator(
return ParamDecorator;
function ParamDecorator(cls: any, unusedKey: any, index: number): any {
const parameters: any[][] = Reflect.getOwnMetadata('parameters', cls) || [];
const parameters: (any[] | null)[] = Reflect.getOwnMetadata('parameters', cls) || [];
// there might be gaps if some in between parameters do not have annotations.
// we pad with nulls.
@ -341,7 +341,7 @@ export function makeParamDecorator(
}
parameters[index] = parameters[index] || [];
parameters[index].push(annotationInstance);
parameters[index] !.push(annotationInstance);
Reflect.defineMetadata('parameters', parameters, cls);
return cls;

92
packages/core/src/view/element.ts
View File

@ -16,20 +16,17 @@ export function anchorDef(
flags: NodeFlags, matchedQueriesDsl: [string | number, QueryValueType][],
ngContentIndex: number, childCount: number, handleEvent?: ElementHandleEventFn,
templateFactory?: ViewDefinitionFactory): NodeDef {
if (!handleEvent) {
handleEvent = NOOP;
}
flags |= NodeFlags.TypeElement;
const {matchedQueries, references, matchedQueryIds} = splitMatchedQueriesDsl(matchedQueriesDsl);
const template = templateFactory ? resolveViewDefinition(templateFactory) : null;
return {
// will bet set by the view definition
index: undefined,
parent: undefined,
renderParent: undefined,
bindingIndex: undefined,
outputIndex: undefined,
index: -1,
parent: null,
renderParent: null,
bindingIndex: -1,
outputIndex: -1,
// regular values
flags,
childFlags: 0,
@ -39,19 +36,20 @@ export function anchorDef(
bindingFlags: 0,
outputs: [],
element: {
ns: undefined,
name: undefined,
attrs: undefined, template,
componentProvider: undefined,
componentView: undefined,
componentRendererType: undefined,
publicProviders: undefined,
allProviders: undefined, handleEvent
ns: null,
name: null,
attrs: null, template,
componentProvider: null,
componentView: null,
componentRendererType: null,
publicProviders: null,
allProviders: null,
handleEvent: handleEvent || NOOP
},
provider: undefined,
text: undefined,
query: undefined,
ngContent: undefined
provider: null,
text: null,
query: null,
ngContent: null
};
}
@ -61,13 +59,13 @@ export function elementDef(
fixedAttrs: [string, string][] = [],
bindings?: [BindingFlags, string, string | SecurityContext][], outputs?: ([string, string])[],
handleEvent?: ElementHandleEventFn, componentView?: ViewDefinitionFactory,
componentRendererType?: RendererType2): NodeDef {
componentRendererType?: RendererType2 | null): NodeDef {
if (!handleEvent) {
handleEvent = NOOP;
}
const {matchedQueries, references, matchedQueryIds} = splitMatchedQueriesDsl(matchedQueriesDsl);
let ns: string;
let name: string;
let ns: string = null !;
let name: string = null !;
if (namespaceAndName) {
[ns, name] = splitNamespace(namespaceAndName);
}
@ -77,8 +75,8 @@ export function elementDef(
const [bindingFlags, namespaceAndName, suffixOrSecurityContext] = bindings[i];
const [ns, name] = splitNamespace(namespaceAndName);
let securityContext: SecurityContext;
let suffix: string;
let securityContext: SecurityContext = undefined !;
let suffix: string = undefined !;
switch (bindingFlags & BindingFlags.Types) {
case BindingFlags.TypeElementStyle:
suffix = <string>suffixOrSecurityContext;
@ -98,7 +96,7 @@ export function elementDef(
outputDefs[i] = {
type: OutputType.ElementOutput,
target: <any>target, eventName,
propName: undefined
propName: null
};
}
fixedAttrs = fixedAttrs || [];
@ -113,11 +111,11 @@ export function elementDef(
flags |= NodeFlags.TypeElement;
return {
// will bet set by the view definition
index: undefined,
parent: undefined,
renderParent: undefined,
bindingIndex: undefined,
outputIndex: undefined,
index: -1,
parent: null,
renderParent: null,
bindingIndex: -1,
outputIndex: -1,
// regular values
flags,
childFlags: 0,
@ -130,21 +128,24 @@ export function elementDef(
ns,
name,
attrs,
template: undefined,
template: null,
// will bet set by the view definition
componentProvider: undefined, componentView, componentRendererType,
publicProviders: undefined,
allProviders: undefined, handleEvent,
componentProvider: null,
componentView: componentView || null,
componentRendererType: componentRendererType,
publicProviders: null,
allProviders: null,
handleEvent: handleEvent || NOOP,
},
provider: undefined,
text: undefined,
query: undefined,
ngContent: undefined
provider: null,
text: null,
query: null,
ngContent: null
};
}
export function createElement(view: ViewData, renderHost: any, def: NodeDef): ElementData {
const elDef = def.element;
const elDef = def.element !;
const rootSelectorOrNode = view.root.selectorOrNode;
const renderer = view.renderer;
let el: any;
@ -175,7 +176,7 @@ export function listenToElementOutputs(view: ViewData, compView: ViewData, def:
const output = def.outputs[i];
const handleEventClosure = renderEventHandlerClosure(
view, def.index, elementEventFullName(output.target, output.eventName));
let listenTarget = output.target;
let listenTarget: 'window'|'document'|'body'|'component'|null = output.target;
let listenerView = view;
if (output.target === 'component') {
listenTarget = null;
@ -183,7 +184,7 @@ export function listenToElementOutputs(view: ViewData, compView: ViewData, def:
}
const disposable =
<any>listenerView.renderer.listen(listenTarget || el, output.eventName, handleEventClosure);
view.disposables[def.outputIndex + i] = disposable;
view.disposables ![def.outputIndex + i] = disposable;
}
}
@ -225,7 +226,7 @@ function checkAndUpdateElementValue(view: ViewData, def: NodeDef, bindingIdx: nu
const binding = def.bindings[bindingIdx];
const elData = asElementData(view, def.index);
const renderNode = elData.renderElement;
const name = binding.name;
const name = binding.name !;
switch (binding.flags & BindingFlags.Types) {
case BindingFlags.TypeElementAttribute:
setElementAttribute(view, binding, renderNode, binding.ns, name, value);
@ -248,7 +249,8 @@ function checkAndUpdateElementValue(view: ViewData, def: NodeDef, bindingIdx: nu
}
function setElementAttribute(
view: ViewData, binding: BindingDef, renderNode: any, ns: string, name: string, value: any) {
view: ViewData, binding: BindingDef, renderNode: any, ns: string | null, name: string,
value: any) {
const securityContext = binding.securityContext;
let renderValue = securityContext ? view.root.sanitizer.sanitize(securityContext, value) : value;
renderValue = renderValue != null ? renderValue.toString() : null;
@ -271,7 +273,7 @@ function setElementClass(view: ViewData, renderNode: any, name: string, value: b
function setElementStyle(
view: ViewData, binding: BindingDef, renderNode: any, name: string, value: any) {
let renderValue = view.root.sanitizer.sanitize(SecurityContext.STYLE, value);
let renderValue: string|null = view.root.sanitizer.sanitize(SecurityContext.STYLE, value);
if (renderValue != null) {
renderValue = renderValue.toString();
const unit = binding.suffix;

22
packages/core/src/view/ng_content.ts
View File

@ -12,11 +12,11 @@ import {RenderNodeAction, getParentRenderElement, visitProjectedRenderNodes} fro
export function ngContentDef(ngContentIndex: number, index: number): NodeDef {
return {
// will bet set by the view definition
index: undefined,
parent: undefined,
renderParent: undefined,
bindingIndex: undefined,
outputIndex: undefined,
index: -1,
parent: null,
renderParent: null,
bindingIndex: -1,
outputIndex: -1,
// regular values
flags: NodeFlags.TypeNgContent,
childFlags: 0,
@ -29,10 +29,10 @@ export function ngContentDef(ngContentIndex: number, index: number): NodeDef {
bindings: [],
bindingFlags: 0,
outputs: [],
element: undefined,
provider: undefined,
text: undefined,
query: undefined,
element: null,
provider: null,
text: null,
query: null,
ngContent: {index}
};
}
@ -43,7 +43,7 @@ export function appendNgContent(view: ViewData, renderHost: any, def: NodeDef) {
// Nothing to do if there is no parent element.
return;
}
const ngContentIndex = def.ngContent.index;
const ngContentIndex = def.ngContent !.index;
visitProjectedRenderNodes(
view, ngContentIndex, RenderNodeAction.AppendChild, parentEl, undefined, undefined);
view, ngContentIndex, RenderNodeAction.AppendChild, parentEl, null, undefined);
}

82
packages/core/src/view/provider.ts
View File

@ -38,9 +38,9 @@ export function directiveDef(
bindings[bindingIndex] = {
flags: BindingFlags.TypeProperty,
name: prop, nonMinifiedName,
ns: undefined,
securityContext: undefined,
suffix: undefined
ns: null,
securityContext: null,
suffix: null
};
}
}
@ -67,9 +67,9 @@ export function providerDef(
}
export function _def(
flags: NodeFlags, matchedQueriesDsl: [string | number, QueryValueType][], childCount: number,
token: any, value: any, deps: ([DepFlags, any] | any)[], bindings?: BindingDef[],
outputs?: OutputDef[]): NodeDef {
flags: NodeFlags, matchedQueriesDsl: [string | number, QueryValueType][] | null,
childCount: number, token: any, value: any, deps: ([DepFlags, any] | any)[],
bindings?: BindingDef[], outputs?: OutputDef[]): NodeDef {
const {matchedQueries, references, matchedQueryIds} = splitMatchedQueriesDsl(matchedQueriesDsl);
if (!outputs) {
outputs = [];
@ -92,23 +92,23 @@ export function _def(
return {
// will bet set by the view definition
index: undefined,
parent: undefined,
renderParent: undefined,
bindingIndex: undefined,
outputIndex: undefined,
index: -1,
parent: null,
renderParent: null,
bindingIndex: -1,
outputIndex: -1,
// regular values
flags,
childFlags: 0,
directChildFlags: 0,
childMatchedQueries: 0, matchedQueries, matchedQueryIds, references,
ngContentIndex: undefined, childCount, bindings,
ngContentIndex: -1, childCount, bindings,
bindingFlags: calcBindingFlags(bindings), outputs,
element: undefined,
element: null,
provider: {token, tokenKey: tokenKey(token), value, deps: depDefs},
text: undefined,
query: undefined,
ngContent: undefined
text: null,
query: null,
ngContent: null
};
}
@ -126,22 +126,22 @@ export function createPipeInstance(view: ViewData, def: NodeDef): any {
const allowPrivateServices = true;
// pipes are always eager and classes!
return createClass(
compView.parent, viewParentEl(compView), allowPrivateServices, def.provider.value,
def.provider.deps);
compView.parent !, viewParentEl(compView) !, allowPrivateServices, def.provider !.value,
def.provider !.deps);
}
export function createDirectiveInstance(view: ViewData, def: NodeDef): any {
// components can see other private services, other directives can't.
const allowPrivateServices = (def.flags & NodeFlags.Component) > 0;
// directives are always eager and classes!
const instance =
createClass(view, def.parent, allowPrivateServices, def.provider.value, def.provider.deps);
const instance = createClass(
view, def.parent !, allowPrivateServices, def.provider !.value, def.provider !.deps);
if (def.outputs.length) {
for (let i = 0; i < def.outputs.length; i++) {
const output = def.outputs[i];
const subscription = instance[output.propName].subscribe(
eventHandlerClosure(view, def.parent.index, output.eventName));
view.disposables[def.outputIndex + i] = subscription.unsubscribe.bind(subscription);
const subscription = instance[output.propName !].subscribe(
eventHandlerClosure(view, def.parent !.index, output.eventName));
view.disposables ![def.outputIndex + i] = subscription.unsubscribe.bind(subscription);
}
}
return instance;
@ -157,7 +157,7 @@ export function checkAndUpdateDirectiveInline(
const providerData = asProviderData(view, def.index);
const directive = providerData.instance;
let changed = false;
let changes: SimpleChanges;
let changes: SimpleChanges = undefined !;
const bindLen = def.bindings.length;
if (bindLen > 0 && checkBinding(view, def, 0, v0)) {
changed = true;
@ -216,7 +216,7 @@ export function checkAndUpdateDirectiveDynamic(
const providerData = asProviderData(view, def.index);
const directive = providerData.instance;
let changed = false;
let changes: SimpleChanges;
let changes: SimpleChanges = undefined !;
for (let i = 0; i < values.length; i++) {
if (checkBinding(view, def, i, values[i])) {
changed = true;
@ -242,18 +242,18 @@ function _createProviderInstance(view: ViewData, def: NodeDef): any {
let injectable: any;
switch (def.flags & NodeFlags.Types) {
case NodeFlags.TypeClassProvider:
injectable =
createClass(view, def.parent, allowPrivateServices, providerDef.value, providerDef.deps);
injectable = createClass(
view, def.parent !, allowPrivateServices, providerDef !.value, providerDef !.deps);
break;
case NodeFlags.TypeFactoryProvider:
injectable =
callFactory(view, def.parent, allowPrivateServices, providerDef.value, providerDef.deps);
injectable = callFactory(
view, def.parent !, allowPrivateServices, providerDef !.value, providerDef !.deps);
break;
case NodeFlags.TypeUseExistingProvider:
injectable = resolveDep(view, def.parent, allowPrivateServices, providerDef.deps[0]);
injectable = resolveDep(view, def.parent !, allowPrivateServices, providerDef !.deps[0]);
break;
case NodeFlags.TypeValueProvider:
injectable = providerDef.value;
injectable = providerDef !.value;
break;
}
return injectable;
@ -345,7 +345,7 @@ export const NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = {};
export function resolveDep(
view: ViewData, elDef: NodeDef, allowPrivateServices: boolean, depDef: DepDef,
notFoundValue = Injector.THROW_IF_NOT_FOUND): any {
notFoundValue: any = Injector.THROW_IF_NOT_FOUND): any {
if (depDef.flags & DepFlags.Value) {
return depDef.token;
}
@ -357,7 +357,7 @@ export function resolveDep(
if (elDef && (depDef.flags & DepFlags.SkipSelf)) {
allowPrivateServices = false;
elDef = elDef.parent;
elDef = elDef.parent !;
}
while (view) {
@ -376,7 +376,7 @@ export function resolveDep(
case ViewContainerRefTokenKey:
return asElementData(view, elDef.index).viewContainer;
case TemplateRefTokenKey: {
if (elDef.element.template) {
if (elDef.element !.template) {
return asElementData(view, elDef.index).template;
}
break;
@ -389,8 +389,8 @@ export function resolveDep(
return createInjector(view, elDef);
default:
const providerDef =
(allowPrivateServices ? elDef.element.allProviders :
elDef.element.publicProviders)[tokenKey];
(allowPrivateServices ? elDef.element !.allProviders :
elDef.element !.publicProviders) ![tokenKey];
if (providerDef) {
const providerData = asProviderData(view, providerDef.index);
if (providerData.instance === NOT_CREATED) {
@ -401,8 +401,8 @@ export function resolveDep(
}
}
allowPrivateServices = isComponentView(view);
elDef = viewParentEl(view);
view = view.parent;
elDef = viewParentEl(view) !;
view = view.parent !;
}
const value = startView.root.injector.get(depDef.token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR);
@ -437,13 +437,13 @@ function updateProp(
view: ViewData, providerData: ProviderData, def: NodeDef, bindingIdx: number, value: any,
changes: SimpleChanges): SimpleChanges {
if (def.flags & NodeFlags.Component) {
const compView = asElementData(view, def.parent.index).componentView;
const compView = asElementData(view, def.parent !.index).componentView;
if (compView.def.flags & ViewFlags.OnPush) {
compView.state |= ViewState.ChecksEnabled;
}
}
const binding = def.bindings[bindingIdx];
const propName = binding.name;
const propName = binding.name !;
// Note: This is still safe with Closure Compiler as
// the user passed in the property name as an object has to `providerDef`,
// so Closure Compiler will have renamed the property correctly already.
@ -455,7 +455,7 @@ function updateProp(
oldValue = oldValue.wrapped;
}
const binding = def.bindings[bindingIdx];
changes[binding.nonMinifiedName] =
changes[binding.nonMinifiedName !] =
new SimpleChange(oldValue, value, (view.state & ViewState.FirstCheck) !== 0);
}
view.oldValues[def.bindingIndex + bindingIdx] = value;

50
packages/core/src/view/pure_expression.ts
View File

@ -29,19 +29,19 @@ function _pureExpressionDef(flags: NodeFlags, propertyNames: string[]): NodeDef
bindings[i] = {
flags: BindingFlags.TypeProperty,
name: prop,
ns: undefined,
ns: null,
nonMinifiedName: prop,
securityContext: undefined,
suffix: undefined
securityContext: null,
suffix: null
};
}
return {
// will bet set by the view definition
index: undefined,
parent: undefined,
renderParent: undefined,
bindingIndex: undefined,
outputIndex: undefined,
index: -1,
parent: null,
renderParent: null,
bindingIndex: -1,
outputIndex: -1,
// regular values
flags,
childFlags: 0,
@ -50,15 +50,15 @@ function _pureExpressionDef(flags: NodeFlags, propertyNames: string[]): NodeDef
matchedQueries: {},
matchedQueryIds: 0,
references: {},
ngContentIndex: undefined,
ngContentIndex: -1,
childCount: 0, bindings,
bindingFlags: calcBindingFlags(bindings),
outputs: [],
element: undefined,
provider: undefined,
text: undefined,
query: undefined,
ngContent: undefined
element: null,
provider: null,
text: null,
query: null,
ngContent: null
};
}
@ -102,16 +102,16 @@ export function checkAndUpdatePureExpressionInline(
break;
case NodeFlags.TypePureObject:
value = {};
if (bindLen > 0) value[bindings[0].name] = v0;
if (bindLen > 1) value[bindings[1].name] = v1;
if (bindLen > 2) value[bindings[2].name] = v2;
if (bindLen > 3) value[bindings[3].name] = v3;
if (bindLen > 4) value[bindings[4].name] = v4;
if (bindLen > 5) value[bindings[5].name] = v5;
if (bindLen > 6) value[bindings[6].name] = v6;
if (bindLen > 7) value[bindings[7].name] = v7;
if (bindLen > 8) value[bindings[8].name] = v8;
if (bindLen > 9) value[bindings[9].name] = v9;
if (bindLen > 0) value[bindings[0].name !] = v0;
if (bindLen > 1) value[bindings[1].name !] = v1;
if (bindLen > 2) value[bindings[2].name !] = v2;
if (bindLen > 3) value[bindings[3].name !] = v3;
if (bindLen > 4) value[bindings[4].name !] = v4;
if (bindLen > 5) value[bindings[5].name !] = v5;
if (bindLen > 6) value[bindings[6].name !] = v6;
if (bindLen > 7) value[bindings[7].name !] = v7;
if (bindLen > 8) value[bindings[8].name !] = v8;
if (bindLen > 9) value[bindings[9].name !] = v9;
break;
case NodeFlags.TypePurePipe:
const pipe = v0;
@ -175,7 +175,7 @@ export function checkAndUpdatePureExpressionDynamic(
case NodeFlags.TypePureObject:
value = {};
for (let i = 0; i < values.length; i++) {
value[bindings[i].name] = values[i];
value[bindings[i].name !] = values[i];
}
break;
case NodeFlags.TypePurePipe:

43
packages/core/src/view/query.ts
View File

@ -22,17 +22,17 @@ export function queryDef(
return {
// will bet set by the view definition
index: undefined,
parent: undefined,
renderParent: undefined,
bindingIndex: undefined,
outputIndex: undefined,
index: -1,
parent: null,
renderParent: null,
bindingIndex: -1,
outputIndex: -1,
// regular values
flags,
childFlags: 0,
directChildFlags: 0,
childMatchedQueries: 0,
ngContentIndex: undefined,
ngContentIndex: -1,
matchedQueries: {},
matchedQueryIds: 0,
references: {},
@ -40,11 +40,11 @@ export function queryDef(
bindings: [],
bindingFlags: 0,
outputs: [],
element: undefined,
provider: undefined,
text: undefined,
element: null,
provider: null,
text: null,
query: {id, filterId: filterQueryId(id), bindings: bindingDefs},
ngContent: undefined
ngContent: null
};
}
@ -55,7 +55,7 @@ export function createQuery(): QueryList<any> {
export function dirtyParentQueries(view: ViewData) {
const queryIds = view.def.nodeMatchedQueries;
while (view.parent && isEmbeddedView(view)) {
let tplDef = view.parentNodeDef;
let tplDef = view.parentNodeDef !;
view = view.parent;
// content queries
const end = tplDef.index + tplDef.childCount;
@ -63,7 +63,7 @@ export function dirtyParentQueries(view: ViewData) {
const nodeDef = view.def.nodes[i];
if ((nodeDef.flags & NodeFlags.TypeContentQuery) &&
(nodeDef.flags & NodeFlags.DynamicQuery) &&
(nodeDef.query.filterId & queryIds) === nodeDef.query.filterId) {
(nodeDef.query !.filterId & queryIds) === nodeDef.query !.filterId) {
asQueryList(view, i).setDirty();
}
if ((nodeDef.flags & NodeFlags.TypeElement && i + nodeDef.childCount < tplDef.index) ||
@ -94,18 +94,18 @@ export function checkAndUpdateQuery(view: ViewData, nodeDef: NodeDef) {
return;
}
let directiveInstance: any;
let newValues: any[];
let newValues: any[] = undefined !;
if (nodeDef.flags & NodeFlags.TypeContentQuery) {
const elementDef = nodeDef.parent.parent;
const elementDef = nodeDef.parent !.parent !;
newValues = calcQueryValues(
view, elementDef.index, elementDef.index + elementDef.childCount, nodeDef.query, []);
directiveInstance = asProviderData(view, nodeDef.parent.index).instance;
view, elementDef.index, elementDef.index + elementDef.childCount, nodeDef.query !, []);
directiveInstance = asProviderData(view, nodeDef.parent !.index).instance;
} else if (nodeDef.flags & NodeFlags.TypeViewQuery) {
newValues = calcQueryValues(view, 0, view.def.nodes.length - 1, nodeDef.query, []);
newValues = calcQueryValues(view, 0, view.def.nodes.length - 1, nodeDef.query !, []);
directiveInstance = view.component;
}
queryList.reset(newValues);
const bindings = nodeDef.query.bindings;
const bindings = nodeDef.query !.bindings;
let notify = false;
for (let i = 0; i < bindings.length; i++) {
const binding = bindings[i];
@ -135,12 +135,13 @@ function calcQueryValues(
if (valueType != null) {
values.push(getQueryValue(view, nodeDef, valueType));
}
if (nodeDef.flags & NodeFlags.TypeElement && nodeDef.element.template &&
(nodeDef.element.template.nodeMatchedQueries & queryDef.filterId) === queryDef.filterId) {
if (nodeDef.flags & NodeFlags.TypeElement && nodeDef.element !.template &&
(nodeDef.element !.template !.nodeMatchedQueries & queryDef.filterId) ===
queryDef.filterId) {
// check embedded views that were attached at the place of their template.
const elementData = asElementData(view, i);
if (nodeDef.flags & NodeFlags.EmbeddedViews) {
const embeddedViews = elementData.viewContainer._embeddedViews;
const embeddedViews = elementData.viewContainer !._embeddedViews;
for (let k = 0; k < embeddedViews.length; k++) {
const embeddedView = embeddedViews[k];
const dvc = declaredViewContainer(embeddedView);

20
packages/core/src/view/refs.ts
View File

@ -85,7 +85,7 @@ class ComponentFactory_ extends ComponentFactory<any> {
throw new Error('ngModule should be provided');
}
const viewDef = resolveViewDefinition(this.viewDefFactory);
const componentNodeIndex = viewDef.nodes[0].element.componentProvider.index;
const componentNodeIndex = viewDef.nodes[0].element !.componentProvider !.index;
const view = Services.createRootView(
injector, projectableNodes || [], rootSelectorOrNode, viewDef, ngModule, EMPTY_CONTEXT);
const component = asProviderData(view, componentNodeIndex).instance;
@ -135,7 +135,7 @@ class ViewContainerRef_ implements ViewContainerData {
let elDef = this._elDef.parent;
while (!elDef && view) {
elDef = viewParentEl(view);
view = view.parent;
view = view.parent !;
}
return view ? new Injector_(view, elDef) : new Injector_(this._view, null);
@ -144,12 +144,12 @@ class ViewContainerRef_ implements ViewContainerData {
clear(): void {
const len = this._embeddedViews.length;
for (let i = len - 1; i >= 0; i--) {
const view = detachEmbeddedView(this._data, i);
const view = detachEmbeddedView(this._data, i) !;
Services.destroyView(view);
}
}
get(index: number): ViewRef {
get(index: number): ViewRef|null {
const view = this._embeddedViews[index];
if (view) {
const ref = new ViewRef_(view);
@ -206,7 +206,7 @@ class ViewContainerRef_ implements ViewContainerData {
}
}
detach(index?: number): ViewRef {
detach(index?: number): ViewRef|null {
const view = detachEmbeddedView(this._data, index);
return view ? new ViewRef_(view) : null;
}
@ -219,8 +219,8 @@ export function createChangeDetectorRef(view: ViewData): ChangeDetectorRef {
export class ViewRef_ implements EmbeddedViewRef<any>, InternalViewRef {
/** @internal */
_view: ViewData;
private _viewContainerRef: ViewContainerRef;
private _appRef: ApplicationRef;
private _viewContainerRef: ViewContainerRef|null;
private _appRef: ApplicationRef|null;
constructor(_view: ViewData) {
this._view = _view;
@ -317,7 +317,7 @@ export function nodeValue(view: ViewData, index: number): any {
const def = view.def.nodes[index];
if (def.flags & NodeFlags.TypeElement) {
const elData = asElementData(view, def.index);
return def.element.template ? elData.template : elData.renderElement;
return def.element !.template ? elData.template : elData.renderElement;
} else if (def.flags & NodeFlags.TypeText) {
return asTextData(view, def.index).renderText;
} else if (def.flags & (NodeFlags.CatProvider | NodeFlags.TypePipe)) {
@ -387,7 +387,7 @@ class RendererAdapter implements RendererV1 {
destroyView(hostElement: Element|DocumentFragment, viewAllNodes: Node[]) {
for (let i = 0; i < viewAllNodes.length; i++) {
this.delegate.destroyNode(viewAllNodes[i]);
this.delegate.destroyNode !(viewAllNodes[i]);
}
}
@ -439,4 +439,4 @@ class RendererAdapter implements RendererV1 {
setText(renderNode: Text, text: string): void { this.delegate.setValue(renderNode, text); }
animate(): any { throw new Error('Renderer.animate is no longer supported!'); }
}
}

48
packages/core/src/view/services.ts
View File

@ -159,9 +159,9 @@ enum DebugAction {
let _currentAction: DebugAction;
let _currentView: ViewData;
let _currentNodeIndex: number;
let _currentNodeIndex: number|null;
function debugSetCurrentNode(view: ViewData, nodeIndex: number) {
function debugSetCurrentNode(view: ViewData, nodeIndex: number | null) {
_currentView = view;
_currentNodeIndex = nodeIndex;
}
@ -231,13 +231,13 @@ function debugCheckAndUpdateNode(
const binding = nodeDef.bindings[i];
const value = values[i];
if (binding.flags & BindingFlags.TypeProperty) {
bindingValues[normalizeDebugBindingName(binding.nonMinifiedName)] =
bindingValues[normalizeDebugBindingName(binding.nonMinifiedName !)] =
normalizeDebugBindingValue(value);
}
}
const elDef = nodeDef.parent;
const elDef = nodeDef.parent !;
const el = asElementData(view, elDef.index).renderElement;
if (!elDef.element.name) {
if (!elDef.element !.name) {
// a comment.
view.renderer.setValue(el, `bindings=${JSON.stringify(bindingValues, null, 2)}`);
} else {
@ -281,31 +281,31 @@ function normalizeDebugBindingValue(value: any): string {
}
}
function nextDirectiveWithBinding(view: ViewData, nodeIndex: number): number {
function nextDirectiveWithBinding(view: ViewData, nodeIndex: number): number|null {
for (let i = nodeIndex; i < view.def.nodes.length; i++) {
const nodeDef = view.def.nodes[i];
if (nodeDef.flags & NodeFlags.TypeDirective && nodeDef.bindings && nodeDef.bindings.length) {
return i;
}
}
return undefined;
return null;
}
function nextRenderNodeWithBinding(view: ViewData, nodeIndex: number): number {
function nextRenderNodeWithBinding(view: ViewData, nodeIndex: number): number|null {
for (let i = nodeIndex; i < view.def.nodes.length; i++) {
const nodeDef = view.def.nodes[i];
if ((nodeDef.flags & NodeFlags.CatRenderNode) && nodeDef.bindings && nodeDef.bindings.length) {
return i;
}
}
return undefined;
return null;
}
class DebugContext_ implements DebugContext {
private nodeDef: NodeDef;
private elView: ViewData;
private elDef: NodeDef;
constructor(public view: ViewData, public nodeIndex: number) {
constructor(public view: ViewData, public nodeIndex: number|null) {
if (nodeIndex == null) {
this.nodeIndex = nodeIndex = 0;
}
@ -313,12 +313,12 @@ class DebugContext_ implements DebugContext {
let elDef = this.nodeDef;
let elView = view;
while (elDef && (elDef.flags & NodeFlags.TypeElement) === 0) {
elDef = elDef.parent;
elDef = elDef.parent !;
}
if (!elDef) {
while (!elDef && elView) {
elDef = viewParentEl(elView);
elView = elView.parent;
elDef = viewParentEl(elView) !;
elView = elView.parent !;
}
}
this.elDef = elDef;
@ -337,7 +337,7 @@ class DebugContext_ implements DebugContext {
for (let i = this.elDef.index + 1; i <= this.elDef.index + this.elDef.childCount; i++) {
const childDef = this.elView.def.nodes[i];
if (childDef.flags & NodeFlags.CatProvider) {
tokens.push(childDef.provider.token);
tokens.push(childDef.provider !.token);
}
i += childDef.childCount;
}
@ -389,7 +389,7 @@ class DebugContext_ implements DebugContext {
return NOOP;
}
};
logViewDef.factory(nodeLogger);
logViewDef.factory !(nodeLogger);
if (currRenderNodeIndex < renderNodeIndex) {
console.error('Illegal state: the ViewDefinitionFactory did not call the logger!');
(<any>console.error)(...values);
@ -408,14 +408,14 @@ function getRenderNodeIndex(viewDef: ViewDefinition, nodeIndex: number): number
return renderNodeIndex;
}
function findHostElement(view: ViewData): ElementData {
function findHostElement(view: ViewData): ElementData|null {
while (view && !isComponentView(view)) {
view = view.parent;
view = view.parent !;
}
if (view.parent) {
return asElementData(view.parent, viewParentEl(view).index);
return asElementData(view.parent, viewParentEl(view) !.index);
}
return undefined;
return null;
}
function collectReferences(view: ViewData, nodeDef: NodeDef, references: {[key: string]: any}) {
@ -440,11 +440,11 @@ function callWithDebugContext(action: DebugAction, fn: any, self: any, args: any
throw e;
}
_currentView.state |= ViewState.Errored;
throw viewWrappedDebugError(e, getCurrentDebugContext());
throw viewWrappedDebugError(e, getCurrentDebugContext() !);
}
}
export function getCurrentDebugContext(): DebugContext {
export function getCurrentDebugContext(): DebugContext|null {
return _currentView ? new DebugContext_(_currentView, _currentNodeIndex) : null;
}
@ -452,7 +452,7 @@ export function getCurrentDebugContext(): DebugContext {
class DebugRendererFactory2 implements RendererFactory2 {
constructor(private delegate: RendererFactory2) {}
createRenderer(element: any, renderData: RendererType2): Renderer2 {
createRenderer(element: any, renderData: RendererType2|null): Renderer2 {
return new DebugRenderer2(this.delegate.createRenderer(element, renderData));
}
}
@ -464,7 +464,7 @@ class DebugRenderer2 implements Renderer2 {
get data() { return this.delegate.data; }
destroyNode(node: any) {
removeDebugNodeFromIndex(getDebugNode(node));
removeDebugNodeFromIndex(getDebugNode(node) !);
if (this.delegate.destroyNode) {
this.delegate.destroyNode(node);
}
@ -513,7 +513,7 @@ class DebugRenderer2 implements Renderer2 {
insertBefore(parent: any, newChild: any, refChild: any): void {
const debugEl = getDebugNode(parent);
const debugChildEl = getDebugNode(newChild);
const debugRefEl = getDebugNode(refChild);
const debugRefEl = getDebugNode(refChild) !;
if (debugEl && debugChildEl && debugEl instanceof DebugElement) {
debugEl.insertBefore(debugRefEl, debugChildEl);
}

32
packages/core/src/view/text.ts
View File

@ -14,21 +14,21 @@ export function textDef(ngContentIndex: number, constants: string[]): NodeDef {
for (let i = 1; i < constants.length; i++) {
bindings[i - 1] = {
flags: BindingFlags.TypeProperty,
name: undefined,
ns: undefined,
nonMinifiedName: undefined,
securityContext: undefined,
name: null,
ns: null,
nonMinifiedName: null,
securityContext: null,
suffix: constants[i]
};
}
const flags = NodeFlags.TypeText;
return {
// will bet set by the view definition
index: undefined,
parent: undefined,
renderParent: undefined,
bindingIndex: undefined,
outputIndex: undefined,
index: -1,
parent: null,
renderParent: null,
bindingIndex: -1,
outputIndex: -1,
// regular values
flags,
childFlags: 0,
@ -40,18 +40,18 @@ export function textDef(ngContentIndex: number, constants: string[]): NodeDef {
childCount: 0, bindings,
bindingFlags: calcBindingFlags(bindings),
outputs: [],
element: undefined,
provider: undefined,
element: null,
provider: null,
text: {prefix: constants[0]},
query: undefined,
ngContent: undefined
query: null,
ngContent: null
};
}
export function createText(view: ViewData, renderHost: any, def: NodeDef): TextData {
let renderNode: any;
const renderer = view.renderer;
renderNode = renderer.createText(def.text.prefix);
renderNode = renderer.createText(def.text !.prefix);
const parentEl = getParentRenderElement(view, renderHost, def);
if (parentEl) {
renderer.appendChild(parentEl, renderNode);
@ -77,7 +77,7 @@ export function checkAndUpdateTextInline(
if (bindLen > 9 && checkAndUpdateBinding(view, def, 9, v9)) changed = true;
if (changed) {
let value = def.text.prefix;
let value = def.text !.prefix;
if (bindLen > 0) value += _addInterpolationPart(v0, bindings[0]);
if (bindLen > 1) value += _addInterpolationPart(v1, bindings[1]);
if (bindLen > 2) value += _addInterpolationPart(v2, bindings[2]);
@ -109,7 +109,7 @@ export function checkAndUpdateTextDynamic(view: ViewData, def: NodeDef, values:
for (let i = 0; i < values.length; i++) {
value = value + _addInterpolationPart(values[i], bindings[i]);
}
value = def.text.prefix + value;
value = def.text !.prefix + value;
const renderNode = asTextData(view, def.index).renderText;
view.renderer.setValue(renderNode, value);
}

90
packages/core/src/view/types.ts
View File

@ -19,7 +19,7 @@ import {Sanitizer, SecurityContext} from '../security';
// -------------------------------------
export interface ViewDefinition {
factory: ViewDefinitionFactory;
factory: ViewDefinitionFactory|null;
flags: ViewFlags;
updateDirectives: ViewUpdateFn;
updateRenderer: ViewUpdateFn;
@ -32,7 +32,7 @@ export interface ViewDefinition {
/** aggregated NodeFlags for all nodes **/
nodeFlags: NodeFlags;
rootNodeFlags: NodeFlags;
lastRenderRootNode: NodeDef;
lastRenderRootNode: NodeDef|null;
bindingCount: number;
outputCount: number;
/**
@ -91,8 +91,8 @@ export const enum ViewFlags {
export interface NodeDef {
flags: NodeFlags;
index: number;
parent: NodeDef;
renderParent: NodeDef;
parent: NodeDef|null;
renderParent: NodeDef|null;
/** this is checked against NgContentDef.index to find matched nodes */
ngContentIndex: number;
/** number of transitive children */
@ -123,11 +123,11 @@ export interface NodeDef {
* Used as a bloom filter.
*/
childMatchedQueries: number;
element: ElementDef;
provider: ProviderDef;
text: TextDef;
query: QueryDef;
ngContent: NgContentDef;
element: ElementDef|null;
provider: ProviderDef|null;
text: TextDef|null;
query: QueryDef|null;
ngContent: NgContentDef|null;
}
/**
@ -179,11 +179,11 @@ export const enum NodeFlags {
export interface BindingDef {
flags: BindingFlags;
ns: string;
name: string;
nonMinifiedName: string;
securityContext: SecurityContext;
suffix: string;
ns: string|null;
name: string|null;
nonMinifiedName: string|null;
securityContext: SecurityContext|null;
suffix: string|null;
}
export const enum BindingFlags {
@ -201,9 +201,9 @@ export const enum BindingFlags {
export interface OutputDef {
type: OutputType;
target: 'window'|'document'|'body'|'component';
target: 'window'|'document'|'body'|'component'|null;
eventName: string;
propName: string;
propName: string|null;
}
export const enum OutputType {ElementOutput, DirectiveOutput}
@ -217,26 +217,26 @@ export const enum QueryValueType {
}
export interface ElementDef {
name: string;
ns: string;
name: string|null;
ns: string|null;
/** ns, name, value */
attrs: [string, string, string][];
template: ViewDefinition;
componentProvider: NodeDef;
componentRendererType: RendererType2;
attrs: [string, string, string][]|null;
template: ViewDefinition|null;
componentProvider: NodeDef|null;
componentRendererType: RendererType2|null;
// closure to allow recursive components
componentView: ViewDefinitionFactory;
componentView: ViewDefinitionFactory|null;
/**
* visible public providers for DI in the view,
* as see from this element. This does not include private providers.
*/
publicProviders: {[tokenKey: string]: NodeDef};
publicProviders: {[tokenKey: string]: NodeDef}|null;
/**
* same as visiblePublicProviders, but also includes private providers
* that are located on this element.
*/
allProviders: {[tokenKey: string]: NodeDef};
handleEvent: ElementHandleEventFn;
allProviders: {[tokenKey: string]: NodeDef}|null;
handleEvent: ElementHandleEventFn|null;
}
export interface ElementHandleEventFn { (view: ViewData, eventName: string, event: any): boolean; }
@ -303,9 +303,9 @@ export interface ViewData {
root: RootData;
renderer: Renderer2;
// index of component provider / anchor.
parentNodeDef: NodeDef;
parent: ViewData;
viewContainerParent: ViewData;
parentNodeDef: NodeDef|null;
parent: ViewData|null;
viewContainerParent: ViewData|null;
component: any;
context: any;
// Attention: Never loop over this, as this will
@ -316,7 +316,7 @@ export interface ViewData {
nodes: {[key: number]: NodeData};
state: ViewState;
oldValues: any[];
disposables: DisposableFn[];
disposables: DisposableFn[]|null;
}
/**
@ -366,7 +366,7 @@ export function asTextData(view: ViewData, index: number): TextData {
export interface ElementData {
renderElement: any;
componentView: ViewData;
viewContainer: ViewContainerData;
viewContainer: ViewContainerData|null;
template: TemplateData;
}
@ -434,7 +434,7 @@ export interface RootData {
export abstract class DebugContext {
abstract get view(): ViewData;
abstract get nodeIndex(): number;
abstract get nodeIndex(): number|null;
abstract get injector(): Injector;
abstract get component(): any;
abstract get providerTokens(): any[];
@ -461,7 +461,7 @@ export interface Services {
checkNoChangesView(view: ViewData): void;
destroyView(view: ViewData): void;
resolveDep(
view: ViewData, elDef: NodeDef, allowPrivateServices: boolean, depDef: DepDef,
view: ViewData, elDef: NodeDef|null, allowPrivateServices: boolean, depDef: DepDef,
notFoundValue?: any): any;
createDebugContext(view: ViewData, nodeIndex: number): DebugContext;
handleEvent: ViewHandleEventFn;
@ -475,16 +475,16 @@ export interface Services {
* debug mode can hook it. It is lazily filled when `isDevMode` is known.
*/
export const Services: Services = {
setCurrentNode: undefined,
createRootView: undefined,
createEmbeddedView: undefined,
checkAndUpdateView: undefined,
checkNoChangesView: undefined,
destroyView: undefined,
resolveDep: undefined,
createDebugContext: undefined,
handleEvent: undefined,
updateDirectives: undefined,
updateRenderer: undefined,
dirtyParentQueries: undefined,
setCurrentNode: undefined !,
createRootView: undefined !,
createEmbeddedView: undefined !,
checkAndUpdateView: undefined !,
checkNoChangesView: undefined !,
destroyView: undefined !,
resolveDep: undefined !,
createDebugContext: undefined !,
handleEvent: undefined !,
updateDirectives: undefined !,
updateRenderer: undefined !,
dirtyParentQueries: undefined !,
};

72
packages/core/src/view/util.ts
View File

@ -60,7 +60,7 @@ export function createRendererType2(values: {
let _renderCompCount = 0;
export function resolveRendererType2(type: RendererType2): RendererType2 {
export function resolveRendererType2(type?: RendererType2 | null): RendererType2|null {
if (type && type.id === UNDEFINED_RENDERER_TYPE_ID) {
// first time we see this RendererType2. Initialize it...
const isFilled =
@ -75,7 +75,7 @@ export function resolveRendererType2(type: RendererType2): RendererType2 {
if (type && type.id === EMPTY_RENDERER_TYPE_ID) {
type = null;
}
return type;
return type || null;
}
export function checkBinding(
@ -108,7 +108,7 @@ export function checkBindingNoChanges(
}
export function markParentViewsForCheck(view: ViewData) {
let currView = view;
let currView: ViewData|null = view;
while (currView) {
if (currView.def.flags & ViewFlags.OnPush) {
currView.state |= ViewState.ChecksEnabled;
@ -126,12 +126,12 @@ export function dispatchEvent(
return Services.handleEvent(view, nodeIndex, eventName, event);
}
export function declaredViewContainer(view: ViewData): ElementData {
export function declaredViewContainer(view: ViewData): ElementData|null {
if (view.parent) {
const parentView = view.parent;
return asElementData(parentView, view.parentNodeDef.index);
return asElementData(parentView, view.parentNodeDef !.index);
}
return undefined;
return null;
}
/**
@ -139,10 +139,10 @@ export function declaredViewContainer(view: ViewData): ElementData {
* for embedded views, this is the index of the parent node
* that contains the view container.
*/
export function viewParentEl(view: ViewData): NodeDef {
export function viewParentEl(view: ViewData): NodeDef|null {
const parentView = view.parent;
if (parentView) {
return view.parentNodeDef.parent;
return view.parentNodeDef !.parent;
} else {
return null;
}
@ -157,23 +157,24 @@ export function renderNode(view: ViewData, def: NodeDef): any {
}
}
export function elementEventFullName(target: string, name: string): string {
export function elementEventFullName(target: string | null, name: string): string {
return target ? `${target}:${name}` : name;
}
export function isComponentView(view: ViewData): boolean {
return !!view.parent && !!(view.parentNodeDef.flags & NodeFlags.Component);
return !!view.parent && !!(view.parentNodeDef !.flags & NodeFlags.Component);
}
export function isEmbeddedView(view: ViewData): boolean {
return !!view.parent && !(view.parentNodeDef.flags & NodeFlags.Component);
return !!view.parent && !(view.parentNodeDef !.flags & NodeFlags.Component);
}
export function filterQueryId(queryId: number): number {
return 1 << (queryId % 32);
}
export function splitMatchedQueriesDsl(matchedQueriesDsl: [string | number, QueryValueType][]): {
export function splitMatchedQueriesDsl(
matchedQueriesDsl: [string | number, QueryValueType][] | null): {
matchedQueries: {[queryId: string]: QueryValueType},
references: {[refId: string]: QueryValueType},
matchedQueryIds: number
@ -199,11 +200,12 @@ export function getParentRenderElement(view: ViewData, renderHost: any, def: Nod
if (renderParent) {
if ((renderParent.flags & NodeFlags.TypeElement) === 0 ||
(renderParent.flags & NodeFlags.ComponentView) === 0 ||
(renderParent.element.componentRendererType &&
renderParent.element.componentRendererType.encapsulation === ViewEncapsulation.Native)) {
(renderParent.element !.componentRendererType &&
renderParent.element !.componentRendererType !.encapsulation ===
ViewEncapsulation.Native)) {
// only children of non components, or children of components with native encapsulation should
// be attached.
return asElementData(view, def.renderParent.index).renderElement;
return asElementData(view, def.renderParent !.index).renderElement;
}
} else {
return renderHost;
@ -213,7 +215,7 @@ export function getParentRenderElement(view: ViewData, renderHost: any, def: Nod
const VIEW_DEFINITION_CACHE = new WeakMap<any, ViewDefinition>();
export function resolveViewDefinition(factory: ViewDefinitionFactory): ViewDefinition {
let value: ViewDefinition = VIEW_DEFINITION_CACHE.get(factory);
let value: ViewDefinition = VIEW_DEFINITION_CACHE.get(factory) !;
if (!value) {
value = factory(() => NOOP);
value.factory = factory;
@ -231,10 +233,10 @@ export function rootRenderNodes(view: ViewData): any[] {
export const enum RenderNodeAction {Collect, AppendChild, InsertBefore, RemoveChild}
export function visitRootRenderNodes(
view: ViewData, action: RenderNodeAction, parentNode: any, nextSibling: any, target: any[]) {
view: ViewData, action: RenderNodeAction, parentNode: any, nextSibling: any, target?: any[]) {
// We need to re-compute the parent node in case the nodes have been moved around manually
if (action === RenderNodeAction.RemoveChild) {
parentNode = view.renderer.parentNode(renderNode(view, view.def.lastRenderRootNode));
parentNode = view.renderer.parentNode(renderNode(view, view.def.lastRenderRootNode !));
}
visitSiblingRenderNodes(
view, action, 0, view.def.nodes.length - 1, parentNode, nextSibling, target);
@ -242,7 +244,7 @@ export function visitRootRenderNodes(
export function visitSiblingRenderNodes(
view: ViewData, action: RenderNodeAction, startIndex: number, endIndex: number, parentNode: any,
nextSibling: any, target: any[]) {
nextSibling: any, target?: any[]) {
for (let i = startIndex; i <= endIndex; i++) {
const nodeDef = view.def.nodes[i];
if (nodeDef.flags & (NodeFlags.TypeElement | NodeFlags.TypeText | NodeFlags.TypeNgContent)) {
@ -255,24 +257,24 @@ export function visitSiblingRenderNodes(
export function visitProjectedRenderNodes(
view: ViewData, ngContentIndex: number, action: RenderNodeAction, parentNode: any,
nextSibling: any, target: any[]) {
let compView = view;
nextSibling: any, target?: any[]) {
let compView: ViewData|null = view;
while (compView && !isComponentView(compView)) {
compView = compView.parent;
}
const hostView = compView.parent;
const hostElDef = viewParentEl(compView);
const startIndex = hostElDef.index + 1;
const endIndex = hostElDef.index + hostElDef.childCount;
const hostView = compView !.parent;
const hostElDef = viewParentEl(compView !);
const startIndex = hostElDef !.index + 1;
const endIndex = hostElDef !.index + hostElDef !.childCount;
for (let i = startIndex; i <= endIndex; i++) {
const nodeDef = hostView.def.nodes[i];
const nodeDef = hostView !.def.nodes[i];
if (nodeDef.ngContentIndex === ngContentIndex) {
visitRenderNode(hostView, nodeDef, action, parentNode, nextSibling, target);
visitRenderNode(hostView !, nodeDef, action, parentNode, nextSibling, target);
}
// jump to next sibling
i += nodeDef.childCount;
}
if (!hostView.parent) {
if (!hostView !.parent) {
// a root view
const projectedNodes = view.root.projectableNodes[ngContentIndex];
if (projectedNodes) {
@ -285,10 +287,10 @@ export function visitProjectedRenderNodes(
function visitRenderNode(
view: ViewData, nodeDef: NodeDef, action: RenderNodeAction, parentNode: any, nextSibling: any,
target: any[]) {
target?: any[]) {
if (nodeDef.flags & NodeFlags.TypeNgContent) {
visitProjectedRenderNodes(
view, nodeDef.ngContent.index, action, parentNode, nextSibling, target);
view, nodeDef.ngContent !.index, action, parentNode, nextSibling, target);
} else {
const rn = renderNode(view, nodeDef);
if (action === RenderNodeAction.RemoveChild && (nodeDef.flags & NodeFlags.ComponentView) &&
@ -305,12 +307,12 @@ function visitRenderNode(
execRenderNodeAction(view, rn, action, parentNode, nextSibling, target);
}
if (nodeDef.flags & NodeFlags.EmbeddedViews) {
const embeddedViews = asElementData(view, nodeDef.index).viewContainer._embeddedViews;
const embeddedViews = asElementData(view, nodeDef.index).viewContainer !._embeddedViews;
for (let k = 0; k < embeddedViews.length; k++) {
visitRootRenderNodes(embeddedViews[k], action, parentNode, nextSibling, target);
}
}
if (nodeDef.flags & NodeFlags.TypeElement && !nodeDef.element.name) {
if (nodeDef.flags & NodeFlags.TypeElement && !nodeDef.element !.name) {
visitSiblingRenderNodes(
view, action, nodeDef.index + 1, nodeDef.index + nodeDef.childCount, parentNode,
nextSibling, target);
@ -320,7 +322,7 @@ function visitRenderNode(
function execRenderNodeAction(
view: ViewData, renderNode: any, action: RenderNodeAction, parentNode: any, nextSibling: any,
target: any[]) {
target?: any[]) {
const renderer = view.renderer;
switch (action) {
case RenderNodeAction.AppendChild:
@ -333,7 +335,7 @@ function execRenderNodeAction(
renderer.removeChild(parentNode, renderNode);
break;
case RenderNodeAction.Collect:
target.push(renderNode);
target !.push(renderNode);
break;
}
}
@ -342,7 +344,7 @@ const NS_PREFIX_RE = /^:([^:]+):(.+)$/;
export function splitNamespace(name: string): string[] {
if (name[0] === ':') {
const match = name.match(NS_PREFIX_RE);
const match = name.match(NS_PREFIX_RE) !;
return [match[1], match[2]];
}
return ['', name];

75
packages/core/src/view/view.ts
View File

@ -28,15 +28,15 @@ export function viewDef(
let viewNodeFlags = 0;
let viewRootNodeFlags = 0;
let viewMatchedQueries = 0;
let currentParent: NodeDef = null;
let currentParent: NodeDef|null = null;
let currentElementHasPublicProviders = false;
let currentElementHasPrivateProviders = false;
let lastRenderRootNode: NodeDef = null;
let lastRenderRootNode: NodeDef|null = null;
for (let i = 0; i < nodes.length; i++) {
while (currentParent && i > currentParent.index + currentParent.childCount) {
const newParent = currentParent.parent;
const newParent: NodeDef|null = currentParent.parent;
if (newParent) {
newParent.childFlags |= currentParent.childFlags;
newParent.childFlags |= currentParent.childFlags !;
newParent.childMatchedQueries |= currentParent.childMatchedQueries;
}
currentParent = newParent;
@ -48,9 +48,9 @@ export function viewDef(
node.outputIndex = viewDisposableCount;
// renderParent needs to account for ng-container!
let currentRenderParent: NodeDef;
let currentRenderParent: NodeDef|null;
if (currentParent && currentParent.flags & NodeFlags.TypeElement &&
!currentParent.element.name) {
!currentParent.element !.name) {
currentRenderParent = currentParent.renderParent;
} else {
currentRenderParent = currentParent;
@ -60,7 +60,7 @@ export function viewDef(
if (node.element) {
const elDef = node.element;
elDef.publicProviders =
currentParent ? currentParent.element.publicProviders : Object.create(null);
currentParent ? currentParent.element !.publicProviders : Object.create(null);
elDef.allProviders = elDef.publicProviders;
// Note: We assume that all providers of an element are before any child element!
currentElementHasPublicProviders = false;
@ -94,24 +94,25 @@ export function viewDef(
if (!currentElementHasPublicProviders) {
currentElementHasPublicProviders = true;
// Use prototypical inheritance to not get O(n^2) complexity...
currentParent.element.publicProviders =
Object.create(currentParent.element.publicProviders);
currentParent.element.allProviders = currentParent.element.publicProviders;
currentParent !.element !.publicProviders =
Object.create(currentParent !.element !.publicProviders);
currentParent !.element !.allProviders = currentParent !.element !.publicProviders;
}
const isPrivateService = (node.flags & NodeFlags.PrivateProvider) !== 0;
const isComponent = (node.flags & NodeFlags.Component) !== 0;
if (!isPrivateService || isComponent) {
currentParent.element.publicProviders[node.provider.tokenKey] = node;
currentParent !.element !.publicProviders ![node.provider !.tokenKey] = node;
} else {
if (!currentElementHasPrivateProviders) {
currentElementHasPrivateProviders = true;
// Use protoyypical inheritance to not get O(n^2) complexity...
currentParent.element.allProviders = Object.create(currentParent.element.publicProviders);
currentParent !.element !.allProviders =
Object.create(currentParent !.element !.publicProviders);
}
currentParent.element.allProviders[node.provider.tokenKey] = node;
currentParent !.element !.allProviders ![node.provider !.tokenKey] = node;
}
if (isComponent) {
currentParent.element.componentProvider = node;
currentParent !.element !.componentProvider = node;
}
}
if (node.childCount) {
@ -127,10 +128,10 @@ export function viewDef(
currentParent = newParent;
}
const handleEvent: ViewHandleEventFn = (view, nodeIndex, eventName, event) =>
nodes[nodeIndex].element.handleEvent(view, eventName, event);
nodes[nodeIndex].element !.handleEvent !(view, eventName, event);
return {
// Will be filled later...
factory: undefined,
factory: null,
nodeFlags: viewNodeFlags,
rootNodeFlags: viewRootNodeFlags,
nodeMatchedQueries: viewMatchedQueries, flags,
@ -143,7 +144,7 @@ export function viewDef(
};
}
function validateNode(parent: NodeDef, node: NodeDef, nodeCount: number) {
function validateNode(parent: NodeDef | null, node: NodeDef, nodeCount: number) {
const template = node.element && node.element.template;
if (template) {
if (!template.lastRenderRootNode) {
@ -156,7 +157,7 @@ function validateNode(parent: NodeDef, node: NodeDef, nodeCount: number) {
}
}
if (node.flags & NodeFlags.CatProvider) {
const parentFlags = parent ? parent.flags : null;
const parentFlags = parent ? parent.flags : 0;
if ((parentFlags & NodeFlags.TypeElement) === 0) {
throw new Error(
`Illegal State: Provider/Directive nodes need to be children of elements or anchors, at index ${node.index}!`);
@ -186,7 +187,7 @@ export function createEmbeddedView(parent: ViewData, anchorDef: NodeDef, context
// embedded views are seen as siblings to the anchor, so we need
// to get the parent of the anchor and use it as parentIndex.
const view =
createView(parent.root, parent.renderer, parent, anchorDef, anchorDef.element.template);
createView(parent.root, parent.renderer, parent, anchorDef, anchorDef.element !.template !);
initView(view, parent.component, context);
createViewNodes(view);
return view;
@ -200,16 +201,16 @@ export function createRootView(root: RootData, def: ViewDefinition, context?: an
}
function createView(
root: RootData, renderer: Renderer2, parent: ViewData, parentNodeDef: NodeDef,
root: RootData, renderer: Renderer2, parent: ViewData | null, parentNodeDef: NodeDef | null,
def: ViewDefinition): ViewData {
const nodes: NodeData[] = new Array(def.nodes.length);
const disposables = def.outputCount ? new Array(def.outputCount) : undefined;
const disposables = def.outputCount ? new Array(def.outputCount) : null;
const view: ViewData = {
def,
parent,
viewContainerParent: undefined, parentNodeDef,
context: undefined,
component: undefined, nodes,
viewContainerParent: null, parentNodeDef,
context: null,
component: null, nodes,
state: ViewState.FirstCheck | ViewState.ChecksEnabled, root, renderer,
oldValues: new Array(def.bindingCount), disposables
};
@ -225,7 +226,7 @@ function createViewNodes(view: ViewData) {
let renderHost: any;
if (isComponentView(view)) {
const hostDef = view.parentNodeDef;
renderHost = asElementData(view.parent, hostDef.parent.index).renderElement;
renderHost = asElementData(view.parent !, hostDef !.parent !.index).renderElement;
}
const def = view.def;
const nodes = view.nodes;
@ -236,10 +237,10 @@ function createViewNodes(view: ViewData) {
switch (nodeDef.flags & NodeFlags.Types) {
case NodeFlags.TypeElement:
const el = createElement(view, renderHost, nodeDef) as any;
let componentView: ViewData;
let componentView: ViewData = undefined !;
if (nodeDef.flags & NodeFlags.ComponentView) {
const compViewDef = resolveViewDefinition(nodeDef.element.componentView);
const rendererType = nodeDef.element.componentRendererType;
const compViewDef = resolveViewDefinition(nodeDef.element !.componentView !);
const rendererType = nodeDef.element !.componentRendererType;
let compRenderer: Renderer2;
if (!rendererType) {
compRenderer = view.root.renderer;
@ -247,14 +248,14 @@ function createViewNodes(view: ViewData) {
compRenderer = view.root.rendererFactory.createRenderer(el, rendererType);
}
componentView = createView(
view.root, compRenderer, view, nodeDef.element.componentProvider, compViewDef);
view.root, compRenderer, view, nodeDef.element !.componentProvider, compViewDef);
}
listenToElementOutputs(view, componentView, nodeDef, el);
nodeData = <ElementData>{
renderElement: el,
componentView,
viewContainer: undefined,
template: nodeDef.element.template ? createTemplateData(view, nodeDef) : undefined
viewContainer: null,
template: nodeDef.element !.template ? createTemplateData(view, nodeDef) : undefined
};
if (nodeDef.flags & NodeFlags.EmbeddedViews) {
nodeData.viewContainer = createViewContainerData(view, nodeDef, nodeData);
@ -280,7 +281,7 @@ function createViewNodes(view: ViewData) {
const instance = createDirectiveInstance(view, nodeDef);
nodeData = <ProviderData>{instance};
if (nodeDef.flags & NodeFlags.Component) {
const compView = asElementData(view, nodeDef.parent.index).componentView;
const compView = asElementData(view, nodeDef.parent !.index).componentView;
initView(compView, instance, instance);
}
break;
@ -451,8 +452,8 @@ function checkNoChangesQuery(view: ViewData, nodeDef: NodeDef) {
const queryList = asQueryList(view, nodeDef.index);
if (queryList.dirty) {
throw expressionChangedAfterItHasBeenCheckedError(
Services.createDebugContext(view, nodeDef.index), `Query ${nodeDef.query.id} not dirty`,
`Query ${nodeDef.query.id} dirty`, (view.state & ViewState.FirstCheck) !== 0);
Services.createDebugContext(view, nodeDef.index), `Query ${nodeDef.query!.id} not dirty`,
`Query ${nodeDef.query!.id} dirty`, (view.state & ViewState.FirstCheck) !== 0);
}
}
@ -482,9 +483,9 @@ function destroyViewNodes(view: ViewData) {
for (let i = 0; i < len; i++) {
const def = view.def.nodes[i];
if (def.flags & NodeFlags.TypeElement) {
view.renderer.destroyNode(asElementData(view, i).renderElement);
view.renderer.destroyNode !(asElementData(view, i).renderElement);
} else if (def.flags & NodeFlags.TypeText) {
view.renderer.destroyNode(asTextData(view, i).renderText);
view.renderer.destroyNode !(asTextData(view, i).renderText);
}
}
}
@ -524,7 +525,7 @@ function execEmbeddedViewsAction(view: ViewData, action: ViewAction) {
const nodeDef = def.nodes[i];
if (nodeDef.flags & NodeFlags.EmbeddedViews) {
// a leaf
const embeddedViews = asElementData(view, i).viewContainer._embeddedViews;
const embeddedViews = asElementData(view, i).viewContainer !._embeddedViews;
for (let k = 0; k < embeddedViews.length; k++) {
callViewAction(embeddedViews[k], action);
}

26
packages/core/src/view/view_attach.ts
View File

@ -10,13 +10,14 @@ import {ElementData, Services, ViewData} from './types';
import {RenderNodeAction, declaredViewContainer, renderNode, visitRootRenderNodes} from './util';
export function attachEmbeddedView(
parentView: ViewData, elementData: ElementData, viewIndex: number, view: ViewData) {
let embeddedViews = elementData.viewContainer._embeddedViews;
if (viewIndex == null) {
parentView: ViewData, elementData: ElementData, viewIndex: number | undefined | null,
view: ViewData) {
let embeddedViews = elementData.viewContainer !._embeddedViews;
if (viewIndex === null || viewIndex === undefined) {
viewIndex = embeddedViews.length;
}
view.viewContainerParent = parentView;
addToArray(embeddedViews, viewIndex, view);
addToArray(embeddedViews, viewIndex !, view);
const dvcElementData = declaredViewContainer(view);
if (dvcElementData && dvcElementData !== elementData) {
let projectedViews = dvcElementData.template._projectedViews;
@ -28,12 +29,12 @@ export function attachEmbeddedView(
Services.dirtyParentQueries(view);
const prevView = viewIndex > 0 ? embeddedViews[viewIndex - 1] : null;
const prevView = viewIndex ! > 0 ? embeddedViews[viewIndex ! - 1] : null;
renderAttachEmbeddedView(elementData, prevView, view);
}
export function detachEmbeddedView(elementData: ElementData, viewIndex: number): ViewData {
const embeddedViews = elementData.viewContainer._embeddedViews;
export function detachEmbeddedView(elementData: ElementData, viewIndex?: number): ViewData|null {
const embeddedViews = elementData.viewContainer !._embeddedViews;
if (viewIndex == null || viewIndex >= embeddedViews.length) {
viewIndex = embeddedViews.length - 1;
}
@ -41,7 +42,7 @@ export function detachEmbeddedView(elementData: ElementData, viewIndex: number):
return null;
}
const view = embeddedViews[viewIndex];
view.viewContainerParent = undefined;
view.viewContainerParent = null;
removeFromArray(embeddedViews, viewIndex);
const dvcElementData = declaredViewContainer(view);
@ -59,7 +60,7 @@ export function detachEmbeddedView(elementData: ElementData, viewIndex: number):
export function moveEmbeddedView(
elementData: ElementData, oldViewIndex: number, newViewIndex: number): ViewData {
const embeddedViews = elementData.viewContainer._embeddedViews;
const embeddedViews = elementData.viewContainer !._embeddedViews;
const view = embeddedViews[oldViewIndex];
removeFromArray(embeddedViews, oldViewIndex);
if (newViewIndex == null) {
@ -79,9 +80,10 @@ export function moveEmbeddedView(
return view;
}
function renderAttachEmbeddedView(elementData: ElementData, prevView: ViewData, view: ViewData) {
const prevRenderNode =
prevView ? renderNode(prevView, prevView.def.lastRenderRootNode) : elementData.renderElement;
function renderAttachEmbeddedView(
elementData: ElementData, prevView: ViewData | null, view: ViewData) {
const prevRenderNode = prevView ? renderNode(prevView, prevView.def.lastRenderRootNode !) :
elementData.renderElement;
const parentNode = view.renderer.parentNode(prevRenderNode);
const nextSibling = view.renderer.nextSibling(prevRenderNode);
// Note: We can't check if `nextSibling` is present, as on WebWorkers it will always be!