Icard/angular-clarity-master(work.../node_modules/@angular/cdk/fesm2022/collections.mjs

463 lines
17 KiB
JavaScript

import { ConnectableObservable, isObservable, of, Subject } from 'rxjs';
import * as i0 from '@angular/core';
import { Injectable, InjectionToken } from '@angular/core';
class DataSource {
}
/** Checks whether an object is a data source. */
function isDataSource(value) {
// Check if the value is a DataSource by observing if it has a connect function. Cannot
// be checked as an `instanceof DataSource` since people could create their own sources
// that match the interface, but don't extend DataSource. We also can't use `isObservable`
// here, because of some internal apps.
return value && typeof value.connect === 'function' && !(value instanceof ConnectableObservable);
}
/** DataSource wrapper for a native array. */
class ArrayDataSource extends DataSource {
constructor(_data) {
super();
this._data = _data;
}
connect() {
return isObservable(this._data) ? this._data : of(this._data);
}
disconnect() { }
}
/**
* A repeater that destroys views when they are removed from a
* {@link ViewContainerRef}. When new items are inserted into the container,
* the repeater will always construct a new embedded view for each item.
*
* @template T The type for the embedded view's $implicit property.
* @template R The type for the item in each IterableDiffer change record.
* @template C The type for the context passed to each embedded view.
*/
class _DisposeViewRepeaterStrategy {
applyChanges(changes, viewContainerRef, itemContextFactory, itemValueResolver, itemViewChanged) {
changes.forEachOperation((record, adjustedPreviousIndex, currentIndex) => {
let view;
let operation;
if (record.previousIndex == null) {
const insertContext = itemContextFactory(record, adjustedPreviousIndex, currentIndex);
view = viewContainerRef.createEmbeddedView(insertContext.templateRef, insertContext.context, insertContext.index);
operation = 1 /* _ViewRepeaterOperation.INSERTED */;
}
else if (currentIndex == null) {
viewContainerRef.remove(adjustedPreviousIndex);
operation = 3 /* _ViewRepeaterOperation.REMOVED */;
}
else {
view = viewContainerRef.get(adjustedPreviousIndex);
viewContainerRef.move(view, currentIndex);
operation = 2 /* _ViewRepeaterOperation.MOVED */;
}
if (itemViewChanged) {
itemViewChanged({
context: view?.context,
operation,
record,
});
}
});
}
detach() { }
}
/**
* A repeater that caches views when they are removed from a
* {@link ViewContainerRef}. When new items are inserted into the container,
* the repeater will reuse one of the cached views instead of creating a new
* embedded view. Recycling cached views reduces the quantity of expensive DOM
* inserts.
*
* @template T The type for the embedded view's $implicit property.
* @template R The type for the item in each IterableDiffer change record.
* @template C The type for the context passed to each embedded view.
*/
class _RecycleViewRepeaterStrategy {
constructor() {
/**
* The size of the cache used to store unused views.
* Setting the cache size to `0` will disable caching. Defaults to 20 views.
*/
this.viewCacheSize = 20;
/**
* View cache that stores embedded view instances that have been previously stamped out,
* but don't are not currently rendered. The view repeater will reuse these views rather than
* creating brand new ones.
*
* TODO(michaeljamesparsons) Investigate whether using a linked list would improve performance.
*/
this._viewCache = [];
}
/** Apply changes to the DOM. */
applyChanges(changes, viewContainerRef, itemContextFactory, itemValueResolver, itemViewChanged) {
// Rearrange the views to put them in the right location.
changes.forEachOperation((record, adjustedPreviousIndex, currentIndex) => {
let view;
let operation;
if (record.previousIndex == null) {
// Item added.
const viewArgsFactory = () => itemContextFactory(record, adjustedPreviousIndex, currentIndex);
view = this._insertView(viewArgsFactory, currentIndex, viewContainerRef, itemValueResolver(record));
operation = view ? 1 /* _ViewRepeaterOperation.INSERTED */ : 0 /* _ViewRepeaterOperation.REPLACED */;
}
else if (currentIndex == null) {
// Item removed.
this._detachAndCacheView(adjustedPreviousIndex, viewContainerRef);
operation = 3 /* _ViewRepeaterOperation.REMOVED */;
}
else {
// Item moved.
view = this._moveView(adjustedPreviousIndex, currentIndex, viewContainerRef, itemValueResolver(record));
operation = 2 /* _ViewRepeaterOperation.MOVED */;
}
if (itemViewChanged) {
itemViewChanged({
context: view?.context,
operation,
record,
});
}
});
}
detach() {
for (const view of this._viewCache) {
view.destroy();
}
this._viewCache = [];
}
/**
* Inserts a view for a new item, either from the cache or by creating a new
* one. Returns `undefined` if the item was inserted into a cached view.
*/
_insertView(viewArgsFactory, currentIndex, viewContainerRef, value) {
const cachedView = this._insertViewFromCache(currentIndex, viewContainerRef);
if (cachedView) {
cachedView.context.$implicit = value;
return undefined;
}
const viewArgs = viewArgsFactory();
return viewContainerRef.createEmbeddedView(viewArgs.templateRef, viewArgs.context, viewArgs.index);
}
/** Detaches the view at the given index and inserts into the view cache. */
_detachAndCacheView(index, viewContainerRef) {
const detachedView = viewContainerRef.detach(index);
this._maybeCacheView(detachedView, viewContainerRef);
}
/** Moves view at the previous index to the current index. */
_moveView(adjustedPreviousIndex, currentIndex, viewContainerRef, value) {
const view = viewContainerRef.get(adjustedPreviousIndex);
viewContainerRef.move(view, currentIndex);
view.context.$implicit = value;
return view;
}
/**
* Cache the given detached view. If the cache is full, the view will be
* destroyed.
*/
_maybeCacheView(view, viewContainerRef) {
if (this._viewCache.length < this.viewCacheSize) {
this._viewCache.push(view);
}
else {
const index = viewContainerRef.indexOf(view);
// The host component could remove views from the container outside of
// the view repeater. It's unlikely this will occur, but just in case,
// destroy the view on its own, otherwise destroy it through the
// container to ensure that all the references are removed.
if (index === -1) {
view.destroy();
}
else {
viewContainerRef.remove(index);
}
}
}
/** Inserts a recycled view from the cache at the given index. */
_insertViewFromCache(index, viewContainerRef) {
const cachedView = this._viewCache.pop();
if (cachedView) {
viewContainerRef.insert(cachedView, index);
}
return cachedView || null;
}
}
/**
* Class to be used to power selecting one or more options from a list.
*/
class SelectionModel {
/** Selected values. */
get selected() {
if (!this._selected) {
this._selected = Array.from(this._selection.values());
}
return this._selected;
}
constructor(_multiple = false, initiallySelectedValues, _emitChanges = true, compareWith) {
this._multiple = _multiple;
this._emitChanges = _emitChanges;
this.compareWith = compareWith;
/** Currently-selected values. */
this._selection = new Set();
/** Keeps track of the deselected options that haven't been emitted by the change event. */
this._deselectedToEmit = [];
/** Keeps track of the selected options that haven't been emitted by the change event. */
this._selectedToEmit = [];
/** Event emitted when the value has changed. */
this.changed = new Subject();
if (initiallySelectedValues && initiallySelectedValues.length) {
if (_multiple) {
initiallySelectedValues.forEach(value => this._markSelected(value));
}
else {
this._markSelected(initiallySelectedValues[0]);
}
// Clear the array in order to avoid firing the change event for preselected values.
this._selectedToEmit.length = 0;
}
}
/**
* Selects a value or an array of values.
* @param values The values to select
* @return Whether the selection changed as a result of this call
* @breaking-change 16.0.0 make return type boolean
*/
select(...values) {
this._verifyValueAssignment(values);
values.forEach(value => this._markSelected(value));
const changed = this._hasQueuedChanges();
this._emitChangeEvent();
return changed;
}
/**
* Deselects a value or an array of values.
* @param values The values to deselect
* @return Whether the selection changed as a result of this call
* @breaking-change 16.0.0 make return type boolean
*/
deselect(...values) {
this._verifyValueAssignment(values);
values.forEach(value => this._unmarkSelected(value));
const changed = this._hasQueuedChanges();
this._emitChangeEvent();
return changed;
}
/**
* Sets the selected values
* @param values The new selected values
* @return Whether the selection changed as a result of this call
* @breaking-change 16.0.0 make return type boolean
*/
setSelection(...values) {
this._verifyValueAssignment(values);
const oldValues = this.selected;
const newSelectedSet = new Set(values);
values.forEach(value => this._markSelected(value));
oldValues
.filter(value => !newSelectedSet.has(value))
.forEach(value => this._unmarkSelected(value));
const changed = this._hasQueuedChanges();
this._emitChangeEvent();
return changed;
}
/**
* Toggles a value between selected and deselected.
* @param value The value to toggle
* @return Whether the selection changed as a result of this call
* @breaking-change 16.0.0 make return type boolean
*/
toggle(value) {
return this.isSelected(value) ? this.deselect(value) : this.select(value);
}
/**
* Clears all of the selected values.
* @param flushEvent Whether to flush the changes in an event.
* If false, the changes to the selection will be flushed along with the next event.
* @return Whether the selection changed as a result of this call
* @breaking-change 16.0.0 make return type boolean
*/
clear(flushEvent = true) {
this._unmarkAll();
const changed = this._hasQueuedChanges();
if (flushEvent) {
this._emitChangeEvent();
}
return changed;
}
/**
* Determines whether a value is selected.
*/
isSelected(value) {
return this._selection.has(this._getConcreteValue(value));
}
/**
* Determines whether the model does not have a value.
*/
isEmpty() {
return this._selection.size === 0;
}
/**
* Determines whether the model has a value.
*/
hasValue() {
return !this.isEmpty();
}
/**
* Sorts the selected values based on a predicate function.
*/
sort(predicate) {
if (this._multiple && this.selected) {
this._selected.sort(predicate);
}
}
/**
* Gets whether multiple values can be selected.
*/
isMultipleSelection() {
return this._multiple;
}
/** Emits a change event and clears the records of selected and deselected values. */
_emitChangeEvent() {
// Clear the selected values so they can be re-cached.
this._selected = null;
if (this._selectedToEmit.length || this._deselectedToEmit.length) {
this.changed.next({
source: this,
added: this._selectedToEmit,
removed: this._deselectedToEmit,
});
this._deselectedToEmit = [];
this._selectedToEmit = [];
}
}
/** Selects a value. */
_markSelected(value) {
value = this._getConcreteValue(value);
if (!this.isSelected(value)) {
if (!this._multiple) {
this._unmarkAll();
}
if (!this.isSelected(value)) {
this._selection.add(value);
}
if (this._emitChanges) {
this._selectedToEmit.push(value);
}
}
}
/** Deselects a value. */
_unmarkSelected(value) {
value = this._getConcreteValue(value);
if (this.isSelected(value)) {
this._selection.delete(value);
if (this._emitChanges) {
this._deselectedToEmit.push(value);
}
}
}
/** Clears out the selected values. */
_unmarkAll() {
if (!this.isEmpty()) {
this._selection.forEach(value => this._unmarkSelected(value));
}
}
/**
* Verifies the value assignment and throws an error if the specified value array is
* including multiple values while the selection model is not supporting multiple values.
*/
_verifyValueAssignment(values) {
if (values.length > 1 && !this._multiple && (typeof ngDevMode === 'undefined' || ngDevMode)) {
throw getMultipleValuesInSingleSelectionError();
}
}
/** Whether there are queued up change to be emitted. */
_hasQueuedChanges() {
return !!(this._deselectedToEmit.length || this._selectedToEmit.length);
}
/** Returns a value that is comparable to inputValue by applying compareWith function, returns the same inputValue otherwise. */
_getConcreteValue(inputValue) {
if (!this.compareWith) {
return inputValue;
}
else {
for (let selectedValue of this._selection) {
if (this.compareWith(inputValue, selectedValue)) {
return selectedValue;
}
}
return inputValue;
}
}
}
/**
* Returns an error that reports that multiple values are passed into a selection model
* with a single value.
* @docs-private
*/
function getMultipleValuesInSingleSelectionError() {
return Error('Cannot pass multiple values into SelectionModel with single-value mode.');
}
/**
* Class to coordinate unique selection based on name.
* Intended to be consumed as an Angular service.
* This service is needed because native radio change events are only fired on the item currently
* being selected, and we still need to uncheck the previous selection.
*
* This service does not *store* any IDs and names because they may change at any time, so it is
* less error-prone if they are simply passed through when the events occur.
*/
class UniqueSelectionDispatcher {
constructor() {
this._listeners = [];
}
/**
* Notify other items that selection for the given name has been set.
* @param id ID of the item.
* @param name Name of the item.
*/
notify(id, name) {
for (let listener of this._listeners) {
listener(id, name);
}
}
/**
* Listen for future changes to item selection.
* @return Function used to deregister listener
*/
listen(listener) {
this._listeners.push(listener);
return () => {
this._listeners = this._listeners.filter((registered) => {
return listener !== registered;
});
};
}
ngOnDestroy() {
this._listeners = [];
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: UniqueSelectionDispatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: UniqueSelectionDispatcher, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: UniqueSelectionDispatcher, decorators: [{
type: Injectable,
args: [{ providedIn: 'root' }]
}] });
/**
* Injection token for {@link _ViewRepeater}. This token is for use by Angular Material only.
* @docs-private
*/
const _VIEW_REPEATER_STRATEGY = new InjectionToken('_ViewRepeater');
/**
* Generated bundle index. Do not edit.
*/
export { ArrayDataSource, DataSource, SelectionModel, UniqueSelectionDispatcher, _DisposeViewRepeaterStrategy, _RecycleViewRepeaterStrategy, _VIEW_REPEATER_STRATEGY, getMultipleValuesInSingleSelectionError, isDataSource };
//# sourceMappingURL=collections.mjs.map