@itwin/core-bentley/lib/cjs/ObservableSet.d.ts

Bentley JavaScript core components

/** @packageDocumentation
 * @module Collections
 */
import { BeEvent } from "./BeEvent";
/** A standard [Set<T>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) that emits events when its contents change.
 * @public
 */
export declare class ObservableSet<T> extends Set<T> {
    /** Emitted after `item` is added to this set. */
    readonly onAdded: BeEvent<(item: T) => void>;
    /** Emitted after `item` is deleted from this set. */
    readonly onDeleted: BeEvent<(item: T) => void>;
    /** Emitted after this set's contents are cleared. */
    readonly onCleared: BeEvent<() => void>;
    /** Emitted after multiple items are added to this set via [[addAll]]. */
    readonly onBatchAdded: BeEvent<() => void>;
    /** Emitted after multiple items are deleted from this set via [[deleteAll]]. */
    readonly onBatchDeleted: BeEvent<() => void>;
    /** Construct a new ObservableSet.
     * @param elements Optional elements with which to populate the new set.
     */
    constructor(elements?: Iterable<T> | undefined);
    /** Invokes [Set.delete](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/delete), raising
     * the [[onDeleted]] event if the item was removed from the set.
     */
    delete(item: T): boolean;
    /** If this set is not already empty, invokes [Set.clear](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/clear)
     * and raises the [[onCleared]] event.
     */
    clear(): void;
    /** Add multiple items to the set, raising [[onBatchAdded]] only once after all items are added.
     * This is more efficient than calling [[add]] in a loop when listeners need not be notified of each individual addition.
     * @param items The items to add.
     * @returns The number of items that were actually added (i.e., were not already present).
     */
    addAll(items: Iterable<T>): number;
    /** Delete multiple items from the set, raising [[onBatchDeleted]] only once after all items are deleted.
     * This is more efficient than calling [[delete]] in a loop when listeners need not be notified of each individual deletion.
     * @param items The items to delete.
     * @returns The number of items that were actually deleted (i.e., were present in the set).
     */
    deleteAll(items: Iterable<T>): number;
}
//# sourceMappingURL=ObservableSet.d.ts.map