@angular/core
Version:
Angular - the core framework
233 lines • 16.6 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { Optional, SkipSelf, ɵɵdefineInjectable } from '../../di';
import { DefaultKeyValueDifferFactory } from './default_keyvalue_differ';
/**
* A differ that tracks changes made to an object over time.
*
* \@publicApi
* @record
* @template K, V
*/
export function KeyValueDiffer() { }
if (false) {
/**
* Compute a difference between the previous state and the new `object` state.
*
* @param {?} object containing the new value.
* @return {?} an object describing the difference. The return value is only valid until the next
* `diff()` invocation.
*/
KeyValueDiffer.prototype.diff = function (object) { };
/**
* Compute a difference between the previous state and the new `object` state.
*
* @param {?} object containing the new value.
* @return {?} an object describing the difference. The return value is only valid until the next
* `diff()` invocation.
*/
KeyValueDiffer.prototype.diff = function (object) { };
}
/**
* An object describing the changes in the `Map` or `{[k:string]: string}` since last time
* `KeyValueDiffer#diff()` was invoked.
*
* \@publicApi
* @record
* @template K, V
*/
export function KeyValueChanges() { }
if (false) {
/**
* Iterate over all changes. `KeyValueChangeRecord` will contain information about changes
* to each item.
* @param {?} fn
* @return {?}
*/
KeyValueChanges.prototype.forEachItem = function (fn) { };
/**
* Iterate over changes in the order of original Map showing where the original items
* have moved.
* @param {?} fn
* @return {?}
*/
KeyValueChanges.prototype.forEachPreviousItem = function (fn) { };
/**
* Iterate over all keys for which values have changed.
* @param {?} fn
* @return {?}
*/
KeyValueChanges.prototype.forEachChangedItem = function (fn) { };
/**
* Iterate over all added items.
* @param {?} fn
* @return {?}
*/
KeyValueChanges.prototype.forEachAddedItem = function (fn) { };
/**
* Iterate over all removed items.
* @param {?} fn
* @return {?}
*/
KeyValueChanges.prototype.forEachRemovedItem = function (fn) { };
}
/**
* Record representing the item change information.
*
* \@publicApi
* @record
* @template K, V
*/
export function KeyValueChangeRecord() { }
if (false) {
/**
* Current key in the Map.
* @type {?}
*/
KeyValueChangeRecord.prototype.key;
/**
* Current value for the key or `null` if removed.
* @type {?}
*/
KeyValueChangeRecord.prototype.currentValue;
/**
* Previous value for the key or `null` if added.
* @type {?}
*/
KeyValueChangeRecord.prototype.previousValue;
}
/**
* Provides a factory for {\@link KeyValueDiffer}.
*
* \@publicApi
* @record
*/
export function KeyValueDifferFactory() { }
if (false) {
/**
* Test to see if the differ knows how to diff this kind of object.
* @param {?} objects
* @return {?}
*/
KeyValueDifferFactory.prototype.supports = function (objects) { };
/**
* Create a `KeyValueDiffer`.
* @template K, V
* @return {?}
*/
KeyValueDifferFactory.prototype.create = function () { };
}
/**
* A repository of different Map diffing strategies used by NgClass, NgStyle, and others.
*
* \@publicApi
*/
export class KeyValueDiffers {
/**
* @param {?} factories
*/
constructor(factories) { this.factories = factories; }
/**
* @template S
* @param {?} factories
* @param {?=} parent
* @return {?}
*/
static create(factories, parent) {
if (parent) {
/** @type {?} */
const copied = parent.factories.slice();
factories = factories.concat(copied);
}
return new KeyValueDiffers(factories);
}
/**
* Takes an array of {\@link KeyValueDifferFactory} and returns a provider used to extend the
* inherited {\@link KeyValueDiffers} instance with the provided factories and return a new
* {\@link KeyValueDiffers} instance.
*
* \@usageNotes
* ### Example
*
* The following example shows how to extend an existing list of factories,
* which will only be applied to the injector for this component and its children.
* This step is all that's required to make a new {\@link KeyValueDiffer} available.
*
* ```
* \@Component({
* viewProviders: [
* KeyValueDiffers.extend([new ImmutableMapDiffer()])
* ]
* })
* ```
* @template S
* @param {?} factories
* @return {?}
*/
static extend(factories) {
return {
provide: KeyValueDiffers,
useFactory: (/**
* @param {?} parent
* @return {?}
*/
(parent) => {
if (!parent) {
// Typically would occur when calling KeyValueDiffers.extend inside of dependencies passed
// to bootstrap(), which would override default pipes instead of extending them.
throw new Error('Cannot extend KeyValueDiffers without a parent injector');
}
return KeyValueDiffers.create(factories, parent);
}),
// Dependency technically isn't optional, but we can provide a better error message this way.
deps: [[KeyValueDiffers, new SkipSelf(), new Optional()]]
};
}
/**
* @param {?} kv
* @return {?}
*/
find(kv) {
/** @type {?} */
const factory = this.factories.find((/**
* @param {?} f
* @return {?}
*/
f => f.supports(kv)));
if (factory) {
return factory;
}
throw new Error(`Cannot find a differ supporting object '${kv}'`);
}
}
/** @nocollapse */
/** @nocollapse */ KeyValueDiffers.ngInjectableDef = ɵɵdefineInjectable({
token: KeyValueDiffers,
providedIn: 'root',
factory: (/**
* @nocollapse @return {?}
*/
() => new KeyValueDiffers([new DefaultKeyValueDifferFactory()]))
});
if (false) {
/**
* @nocollapse
* @type {?}
*/
KeyValueDiffers.ngInjectableDef;
/**
* @deprecated v4.0.0 - Should be private.
* @type {?}
*/
KeyValueDiffers.prototype.factories;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyvalue_differs.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/change_detection/differs/keyvalue_differs.ts"],"names":[],"mappings":";;;;;;;;;;;AAQA,OAAO,EAAC,QAAQ,EAAE,QAAQ,EAAkB,kBAAkB,EAAC,MAAM,UAAU,CAAC;AAChF,OAAO,EAAC,4BAA4B,EAAC,MAAM,2BAA2B,CAAC;;;;;;;;AAQvE,oCAoBC;;;;;;;;;IAZC,sDAAoD;;;;;;;;IASpD,sDAAkE;;;;;;;;;;AAWpE,qCA2BC;;;;;;;;IAtBC,0DAA+D;;;;;;;IAM/D,kEAAuE;;;;;;IAKvE,iEAAsE;;;;;;IAKtE,+DAAoE;;;;;;IAKpE,iEAAsE;;;;;;;;;AAQxE,0CAeC;;;;;;IAXC,mCAAgB;;;;;IAKhB,4CAA8B;;;;;IAK9B,6CAA+B;;;;;;;;AAQjC,2CAUC;;;;;;;IANC,kEAAgC;;;;;;IAKhC,yDAAqC;;;;;;;AAQvC,MAAM,OAAO,eAAe;;;;IAa1B,YAAY,SAAkC,IAAI,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC;;;;;;;IAE/E,MAAM,CAAC,MAAM,CAAI,SAAkC,EAAE,MAAwB;QAC3E,IAAI,MAAM,EAAE;;kBACJ,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE;YACvC,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;SACtC;QACD,OAAO,IAAI,eAAe,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;IAsBD,MAAM,CAAC,MAAM,CAAI,SAAkC;QACjD,OAAO;YACL,OAAO,EAAE,eAAe;YACxB,UAAU;;;;YAAE,CAAC,MAAuB,EAAE,EAAE;gBACtC,IAAI,CAAC,MAAM,EAAE;oBACX,0FAA0F;oBAC1F,gFAAgF;oBAChF,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;iBAC5E;gBACD,OAAO,eAAe,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;YACnD,CAAC,CAAA;;YAED,IAAI,EAAE,CAAC,CAAC,eAAe,EAAE,IAAI,QAAQ,EAAE,EAAE,IAAI,QAAQ,EAAE,CAAC,CAAC;SAC1D,CAAC;IACJ,CAAC;;;;;IAED,IAAI,CAAC,EAAO;;cACJ,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI;;;;QAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAC;QACxD,IAAI,OAAO,EAAE;YACX,OAAO,OAAO,CAAC;SAChB;QACD,MAAM,IAAI,KAAK,CAAC,2CAA2C,EAAE,GAAG,CAAC,CAAC;IACpE,CAAC;;;AA/DM,+BAAe,GAAG,kBAAkB,CAAC;IAC1C,KAAK,EAAE,eAAe;IACtB,UAAU,EAAE,MAAM;IAClB,OAAO;;;IAAE,GAAG,EAAE,CAAC,IAAI,eAAe,CAAC,CAAC,IAAI,4BAA4B,EAAE,CAAC,CAAC,CAAA;CACzE,CAAC,CAAC;;;;;;IAJH,gCAIG;;;;;IAKH,oCAAmC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Optional, SkipSelf, StaticProvider, ɵɵdefineInjectable} from '../../di';\nimport {DefaultKeyValueDifferFactory} from './default_keyvalue_differ';\n\n\n/**\n * A differ that tracks changes made to an object over time.\n *\n * @publicApi\n */\nexport interface KeyValueDiffer<K, V> {\n  /**\n   * Compute a difference between the previous state and the new `object` state.\n   *\n   * @param object containing the new value.\n   * @returns an object describing the difference. The return value is only valid until the next\n   * `diff()` invocation.\n   */\n  diff(object: Map<K, V>): KeyValueChanges<K, V>|null;\n\n  /**\n   * Compute a difference between the previous state and the new `object` state.\n   *\n   * @param object containing the new value.\n   * @returns an object describing the difference. The return value is only valid until the next\n   * `diff()` invocation.\n   */\n  diff(object: {[key: string]: V}): KeyValueChanges<string, V>|null;\n  // TODO(TS2.1): diff<KP extends string>(this: KeyValueDiffer<KP, V>, object: Record<KP, V>):\n  // KeyValueDiffer<KP, V>;\n}\n\n/**\n * An object describing the changes in the `Map` or `{[k:string]: string}` since last time\n * `KeyValueDiffer#diff()` was invoked.\n *\n * @publicApi\n */\nexport interface KeyValueChanges<K, V> {\n  /**\n   * Iterate over all changes. `KeyValueChangeRecord` will contain information about changes\n   * to each item.\n   */\n  forEachItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;\n\n  /**\n   * Iterate over changes in the order of original Map showing where the original items\n   * have moved.\n   */\n  forEachPreviousItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;\n\n  /**\n   * Iterate over all keys for which values have changed.\n   */\n  forEachChangedItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;\n\n  /**\n   * Iterate over all added items.\n   */\n  forEachAddedItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;\n\n  /**\n   * Iterate over all removed items.\n   */\n  forEachRemovedItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;\n}\n\n/**\n * Record representing the item change information.\n *\n * @publicApi\n */\nexport interface KeyValueChangeRecord<K, V> {\n  /**\n   * Current key in the Map.\n   */\n  readonly key: K;\n\n  /**\n   * Current value for the key or `null` if removed.\n   */\n  readonly currentValue: V|null;\n\n  /**\n   * Previous value for the key or `null` if added.\n   */\n  readonly previousValue: V|null;\n}\n\n/**\n * Provides a factory for {@link KeyValueDiffer}.\n *\n * @publicApi\n */\nexport interface KeyValueDifferFactory {\n  /**\n   * Test to see if the differ knows how to diff this kind of object.\n   */\n  supports(objects: any): boolean;\n\n  /**\n   * Create a `KeyValueDiffer`.\n   */\n  create<K, V>(): KeyValueDiffer<K, V>;\n}\n\n/**\n * A repository of different Map diffing strategies used by NgClass, NgStyle, and others.\n *\n * @publicApi\n */\nexport class KeyValueDiffers {\n  /** @nocollapse */\n  static ngInjectableDef = ɵɵdefineInjectable({\n    token: KeyValueDiffers,\n    providedIn: 'root',\n    factory: () => new KeyValueDiffers([new DefaultKeyValueDifferFactory()])\n  });\n\n  /**\n   * @deprecated v4.0.0 - Should be private.\n   */\n  factories: KeyValueDifferFactory[];\n\n  constructor(factories: KeyValueDifferFactory[]) { this.factories = factories; }\n\n  static create<S>(factories: KeyValueDifferFactory[], parent?: KeyValueDiffers): KeyValueDiffers {\n    if (parent) {\n      const copied = parent.factories.slice();\n      factories = factories.concat(copied);\n    }\n    return new KeyValueDiffers(factories);\n  }\n\n  /**\n   * Takes an array of {@link KeyValueDifferFactory} and returns a provider used to extend the\n   * inherited {@link KeyValueDiffers} instance with the provided factories and return a new\n   * {@link KeyValueDiffers} instance.\n   *\n   * @usageNotes\n   * ### Example\n   *\n   * The following example shows how to extend an existing list of factories,\n   * which will only be applied to the injector for this component and its children.\n   * This step is all that's required to make a new {@link KeyValueDiffer} available.\n   *\n   * ```\n   * @Component({\n   *   viewProviders: [\n   *     KeyValueDiffers.extend([new ImmutableMapDiffer()])\n   *   ]\n   * })\n   * ```\n   */\n  static extend<S>(factories: KeyValueDifferFactory[]): StaticProvider {\n    return {\n      provide: KeyValueDiffers,\n      useFactory: (parent: KeyValueDiffers) => {\n        if (!parent) {\n          // Typically would occur when calling KeyValueDiffers.extend inside of dependencies passed\n          // to bootstrap(), which would override default pipes instead of extending them.\n          throw new Error('Cannot extend KeyValueDiffers without a parent injector');\n        }\n        return KeyValueDiffers.create(factories, parent);\n      },\n      // Dependency technically isn't optional, but we can provide a better error message this way.\n      deps: [[KeyValueDiffers, new SkipSelf(), new Optional()]]\n    };\n  }\n\n  find(kv: any): KeyValueDifferFactory {\n    const factory = this.factories.find(f => f.supports(kv));\n    if (factory) {\n      return factory;\n    }\n    throw new Error(`Cannot find a differ supporting object '${kv}'`);\n  }\n}\n"]}