@itwin/core-bentley 3.0.0-dev.78 → 3.0.0-dev.79

package/lib/esm/Dictionary.d.ts

@@ -0,0 +1,126 @@
+/** @packageDocumentation
+ * @module Collections
+ */
+import { OrderedComparator } from "./Compare";
+import { CloneFunction } from "./SortedArray";
+/**
+ * Represents an entry in a [[Dictionary]].
+ * @public
+ */
+export interface DictionaryEntry<K, V> {
+    /** The key used for lookup in the Dictionary. */
+    key: K;
+    /** The value associated with the key in the Dictionary. */
+    value: V;
+}
+/**
+ * Maintains a mapping of keys to values.
+ * Unlike the standard Map<K, V>, a Dictionary<K, V> supports custom comparison logic for keys of object type (and for any other type).
+ * The user supplies a key comparison function to the constructor, that must meet the following criteria given 'lhs' and 'rhs' of type K:
+ *  - If lhs is equal to rhs, returns 0
+ *  - If lhs is less than rhs, returns a negative value
+ *  - If lhs is greater than rhs, returns a positive value
+ *  - If compare(lhs, rhs) returns 0, then compare(rhs, lhs) must also return 0
+ *  - If compare(lhs, rhs) returns a negative value, then compare(rhs, lhs) must return a positive value, and vice versa.
+ *
+ * Modifying a key in a way that affects the comparison function will produce unpredictable results, the
+ * most likely of which is that keys will cease to map to the values with which they were initially inserted.
+ * @public
+ */
+export declare class Dictionary<K, V> implements Iterable<DictionaryEntry<K, V>> {
+    protected _keys: K[];
+    protected readonly _compareKeys: OrderedComparator<K>;
+    protected readonly _cloneKey: CloneFunction<K>;
+    protected _values: V[];
+    protected readonly _cloneValue: CloneFunction<V>;
+    /**
+     * Construct a new Dictionary<K, V>.
+     * @param compareKeys The function used to compare keys within the dictionary.
+     * @param cloneKey The function invoked to clone a key for insertion into the dictionary. The default implementation simply returns its input.
+     * @param cloneValue The function invoked to clone a value for insertion into the dictionary. The default implementation simply returns its input.
+     */
+    constructor(compareKeys: OrderedComparator<K>, cloneKey?: CloneFunction<K>, cloneValue?: CloneFunction<V>);
+    /** The number of entries in the dictionary. */
+    get size(): number;
+    /** Returns an iterator over the key-value pairs in the Dictionary suitable for use in `for-of` loops. Entries are returned in sorted order by key. */
+    [Symbol.iterator](): Iterator<DictionaryEntry<K, V>>;
+    /** Provides iteration over the keys in this Dictionary, in sorted order. */
+    keys(): Iterable<K>;
+    /** Provides iteration over the values in this Dictionary, in sorted order by the corresponding keys. */
+    values(): Iterable<V>;
+    /** Removes all entries from this dictionary */
+    clear(): void;
+    /**
+     * Looks up a value by its key.
+     * @param key The key to search for
+     * @returns the value associated with the key, or undefined if the key is not present in the dictionary.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Determines if an entry exists for the specified key
+     * @param key The key to search for
+     * @returns true if an entry exists in this dictionary corresponding to the specified key.
+     */
+    has(key: K): boolean;
+    /**
+     * Deletes a value using its key.
+     * @param key The key to delete
+     * @returns true if the key was found and deleted.
+     */
+    delete(key: K): boolean;
+    /**
+     * Attempts to insert a new entry into the dictionary. If an entry with an equivalent key exists, the dictionary is unmodified.
+     * If the new entry is in fact inserted, both the key and value will be cloned using the functions supplied to the dictionary's constructor.
+     * @param key The key to associate with the value
+     * @param value The value to associate with the key
+     * @returns true if the new entry was inserted, false if an entry with an equivalent key already exists.
+     */
+    insert(key: K, value: V): boolean;
+    /** Obtains the value associated with the specified key, or inserts it if the specified key does not yet exist.
+     * @param key The key to search for.
+     * @param value The value to associate with `key` if `key` does not yet exist in the dictionary.
+     * @returns The found or inserted value and a flag indicating whether the new value was inserted.
+     */
+    findOrInsert(key: K, value: V): {
+        value: V;
+        inserted: boolean;
+    };
+    /**
+     * Sets the value associated with the specified key in the dictionary.
+     * If no such key already exists, this is equivalent to insert(key, value); otherwise, the existing value associated with the key is replaced.
+     * In either case, the value will be cloned using the function supplied to the dictionary's constructor.
+     */
+    set(key: K, value: V): void;
+    /**
+     * Extracts the contents of this dictionary as an array of { key, value } pairs, and empties this dictionary.
+     * @returns An array of { key, value } pairs sorted by key.
+     */
+    extractPairs(): Array<{
+        key: K;
+        value: V;
+    }>;
+    /**
+     * Extracts the contents of this dictionary as a pair of { keys, values } arrays, and empties this dictionary.
+     * The array of keys is sorted according to the comparison criterion.
+     * The position of each value in the array of values corresponds the the position of the corresponding key in the array of keys.
+     * @returns a pair of { keys, values } arrays in which key[i] corresponds to value[i] in this dictionary and the keys are in sorted order.
+     */
+    extractArrays(): {
+        keys: K[];
+        values: V[];
+    };
+    /** Apply a function to each (key, value) pair in the dictionary, in sorted order.
+     * @param func The function to be applied.
+     */
+    forEach(func: (key: K, value: V) => void): void;
+    /**
+     * Computes the position at which the specified key should be inserted to maintain sorted order.
+     * @param key The key whose position is to be computed.
+     * @returns an object with 'index' corresponding to the computed position and 'equal' set to true if an equivalent key already exists at that index.
+     */
+    protected lowerBound(key: K): {
+        index: number;
+        equal: boolean;
+    };
+}
+//# sourceMappingURL=Dictionary.d.ts.map

package/lib/esm/Dictionary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dictionary.d.ts","sourceRoot":"","sources":["../../src/Dictionary.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,aAAa,EAA4B,MAAM,eAAe,CAAC;AAyBxE;;;GAGG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,EAAE,CAAC;IACnC,iDAAiD;IACjD,GAAG,EAAE,CAAC,CAAC;IACP,2DAA2D;IAC3D,KAAK,EAAE,CAAC,CAAC;CACV;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,UAAU,CAAC,CAAC,EAAE,CAAC,CAAE,YAAW,QAAQ,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACtE,SAAS,CAAC,KAAK,EAAE,CAAC,EAAE,CAAM;IAC1B,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IACtD,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IAC/C,SAAS,CAAC,OAAO,EAAE,CAAC,EAAE,CAAM;IAC5B,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IAEjD;;;;;OAKG;gBACgB,WAAW,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAE,aAAa,CAAC,CAAC,CAAgB,EAAE,UAAU,GAAE,aAAa,CAAC,CAAC,CAAgB;IAM5I,+CAA+C;IAC/C,IAAW,IAAI,IAAI,MAAM,CAA8B;IAEvD,sJAAsJ;IAC/I,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAI3D,4EAA4E;IACrE,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC;IAW1B,wGAAwG;IACjG,MAAM,IAAI,QAAQ,CAAC,CAAC,CAAC;IAW5B,+CAA+C;IACxC,KAAK,IAAI,IAAI;IAKpB;;;;OAIG;IACI,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAKjC;;;;OAIG;IACI,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAI3B;;;;OAIG;IACI,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAW9B;;;;;;OAMG;IACI,MAAM,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO;IAKxC;;;;OAIG;IACI,YAAY,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG;QAAE,KAAK,EAAE,CAAC,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE;IAWtE;;;;OAIG;IACI,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAWlC;;;OAGG;IACI,YAAY,IAAI,KAAK,CAAC;QAAE,GAAG,EAAE,CAAC,CAAC;QAAC,KAAK,EAAE,CAAC,CAAA;KAAE,CAAC;IASlD;;;;;OAKG;IACI,aAAa,IAAI;QAAE,IAAI,EAAE,CAAC,EAAE,CAAC;QAAC,MAAM,EAAE,CAAC,EAAE,CAAA;KAAE;IAMlD;;OAEG;IACI,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI;IAKtD;;;;OAIG;IACH,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,GAAG;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE;CAChE"}

package/lib/esm/Dictionary.js

@@ -0,0 +1,200 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Collections
+ */
+import { lowerBound, shallowClone } from "./SortedArray";
+class DictionaryIterator {
+    constructor(keys, values) {
+        this._curIndex = -1;
+        this._keys = keys;
+        this._values = values;
+    }
+    next() {
+        if (++this._curIndex >= this._keys.length) {
+            // The ECMAScript spec states that value=undefined is valid if done=true. The TypeScript interface violates the spec hence the cast to any and back below.
+            return { done: true };
+        }
+        else {
+            return {
+                value: {
+                    key: this._keys[this._curIndex],
+                    value: this._values[this._curIndex],
+                },
+                done: false,
+            };
+        }
+    }
+}
+/**
+ * Maintains a mapping of keys to values.
+ * Unlike the standard Map<K, V>, a Dictionary<K, V> supports custom comparison logic for keys of object type (and for any other type).
+ * The user supplies a key comparison function to the constructor, that must meet the following criteria given 'lhs' and 'rhs' of type K:
+ *  - If lhs is equal to rhs, returns 0
+ *  - If lhs is less than rhs, returns a negative value
+ *  - If lhs is greater than rhs, returns a positive value
+ *  - If compare(lhs, rhs) returns 0, then compare(rhs, lhs) must also return 0
+ *  - If compare(lhs, rhs) returns a negative value, then compare(rhs, lhs) must return a positive value, and vice versa.
+ *
+ * Modifying a key in a way that affects the comparison function will produce unpredictable results, the
+ * most likely of which is that keys will cease to map to the values with which they were initially inserted.
+ * @public
+ */
+export class Dictionary {
+    /**
+     * Construct a new Dictionary<K, V>.
+     * @param compareKeys The function used to compare keys within the dictionary.
+     * @param cloneKey The function invoked to clone a key for insertion into the dictionary. The default implementation simply returns its input.
+     * @param cloneValue The function invoked to clone a value for insertion into the dictionary. The default implementation simply returns its input.
+     */
+    constructor(compareKeys, cloneKey = shallowClone, cloneValue = shallowClone) {
+        this._keys = [];
+        this._values = [];
+        this._compareKeys = compareKeys;
+        this._cloneKey = cloneKey;
+        this._cloneValue = cloneValue;
+    }
+    /** The number of entries in the dictionary. */
+    get size() { return this._keys.length; }
+    /** Returns an iterator over the key-value pairs in the Dictionary suitable for use in `for-of` loops. Entries are returned in sorted order by key. */
+    [Symbol.iterator]() {
+        return new DictionaryIterator(this._keys, this._values);
+    }
+    /** Provides iteration over the keys in this Dictionary, in sorted order. */
+    keys() {
+        function* iterator(dict) {
+            for (const entry of dict)
+                yield entry.key;
+        }
+        return {
+            [Symbol.iterator]: () => iterator(this),
+        };
+    }
+    /** Provides iteration over the values in this Dictionary, in sorted order by the corresponding keys. */
+    values() {
+        function* iterator(dict) {
+            for (const entry of dict)
+                yield entry.value;
+        }
+        return {
+            [Symbol.iterator]: () => iterator(this),
+        };
+    }
+    /** Removes all entries from this dictionary */
+    clear() {
+        this._keys = [];
+        this._values = [];
+    }
+    /**
+     * Looks up a value by its key.
+     * @param key The key to search for
+     * @returns the value associated with the key, or undefined if the key is not present in the dictionary.
+     */
+    get(key) {
+        const bound = this.lowerBound(key);
+        return bound.equal ? this._values[bound.index] : undefined;
+    }
+    /**
+     * Determines if an entry exists for the specified key
+     * @param key The key to search for
+     * @returns true if an entry exists in this dictionary corresponding to the specified key.
+     */
+    has(key) {
+        return this.lowerBound(key).equal;
+    }
+    /**
+     * Deletes a value using its key.
+     * @param key The key to delete
+     * @returns true if the key was found and deleted.
+     */
+    delete(key) {
+        const bound = this.lowerBound(key);
+        if (bound.equal) {
+            this._values.splice(bound.index, 1);
+            this._keys.splice(bound.index, 1);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * Attempts to insert a new entry into the dictionary. If an entry with an equivalent key exists, the dictionary is unmodified.
+     * If the new entry is in fact inserted, both the key and value will be cloned using the functions supplied to the dictionary's constructor.
+     * @param key The key to associate with the value
+     * @param value The value to associate with the key
+     * @returns true if the new entry was inserted, false if an entry with an equivalent key already exists.
+     */
+    insert(key, value) {
+        const result = this.findOrInsert(key, value);
+        return result.inserted;
+    }
+    /** Obtains the value associated with the specified key, or inserts it if the specified key does not yet exist.
+     * @param key The key to search for.
+     * @param value The value to associate with `key` if `key` does not yet exist in the dictionary.
+     * @returns The found or inserted value and a flag indicating whether the new value was inserted.
+     */
+    findOrInsert(key, value) {
+        const bound = this.lowerBound(key);
+        if (bound.equal)
+            return { value: this._values[bound.index], inserted: false };
+        value = this._cloneValue(value);
+        this._keys.splice(bound.index, 0, this._cloneKey(key));
+        this._values.splice(bound.index, 0, this._cloneValue(value));
+        return { value, inserted: true };
+    }
+    /**
+     * Sets the value associated with the specified key in the dictionary.
+     * If no such key already exists, this is equivalent to insert(key, value); otherwise, the existing value associated with the key is replaced.
+     * In either case, the value will be cloned using the function supplied to the dictionary's constructor.
+     */
+    set(key, value) {
+        value = this._cloneValue(value);
+        const bound = this.lowerBound(key);
+        if (bound.equal) {
+            this._values[bound.index] = value;
+        }
+        else {
+            this._keys.splice(bound.index, 0, this._cloneKey(key));
+            this._values.splice(bound.index, 0, value);
+        }
+    }
+    /**
+     * Extracts the contents of this dictionary as an array of { key, value } pairs, and empties this dictionary.
+     * @returns An array of { key, value } pairs sorted by key.
+     */
+    extractPairs() {
+        const pairs = [];
+        for (let i = 0; i < this.size; i++)
+            pairs.push({ key: this._keys[i], value: this._values[i] });
+        this.clear();
+        return pairs;
+    }
+    /**
+     * Extracts the contents of this dictionary as a pair of { keys, values } arrays, and empties this dictionary.
+     * The array of keys is sorted according to the comparison criterion.
+     * The position of each value in the array of values corresponds the the position of the corresponding key in the array of keys.
+     * @returns a pair of { keys, values } arrays in which key[i] corresponds to value[i] in this dictionary and the keys are in sorted order.
+     */
+    extractArrays() {
+        const result = { keys: this._keys, values: this._values };
+        this.clear();
+        return result;
+    }
+    /** Apply a function to each (key, value) pair in the dictionary, in sorted order.
+     * @param func The function to be applied.
+     */
+    forEach(func) {
+        for (let i = 0; i < this.size; i++)
+            func(this._keys[i], this._values[i]);
+    }
+    /**
+     * Computes the position at which the specified key should be inserted to maintain sorted order.
+     * @param key The key whose position is to be computed.
+     * @returns an object with 'index' corresponding to the computed position and 'equal' set to true if an equivalent key already exists at that index.
+     */
+    lowerBound(key) { return lowerBound(key, this._keys, this._compareKeys); }
+}
+//# sourceMappingURL=Dictionary.js.map

package/lib/esm/Dictionary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dictionary.js","sourceRoot":"","sources":["../../src/Dictionary.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module Collections\n */\n\nimport { OrderedComparator } from \"./Compare\";\nimport { CloneFunction, lowerBound, shallowClone } from \"./SortedArray\";\n\nclass DictionaryIterator<K, V> implements Iterator<DictionaryEntry<K, V>> {\n  private _keys: K[];\n  private _values: V[];\n  private _curIndex = -1;\n\n  public constructor(keys: K[], values: V[]) { this._keys = keys; this._values = values; }\n\n  public next(): IteratorResult<DictionaryEntry<K, V>> {\n    if (++this._curIndex >= this._keys.length) {\n      // The ECMAScript spec states that value=undefined is valid if done=true. The TypeScript interface violates the spec hence the cast to any and back below.\n      return { done: true } as any as IteratorResult<DictionaryEntry<K, V>>;\n    } else {\n      return {\n        value: {\n          key: this._keys[this._curIndex],\n          value: this._values[this._curIndex],\n        },\n        done: false,\n      };\n    }\n  }\n}\n\n/**\n * Represents an entry in a [[Dictionary]].\n * @public\n */\nexport interface DictionaryEntry<K, V> {\n  /** The key used for lookup in the Dictionary. */\n  key: K;\n  /** The value associated with the key in the Dictionary. */\n  value: V;\n}\n\n/**\n * Maintains a mapping of keys to values.\n * Unlike the standard Map<K, V>, a Dictionary<K, V> supports custom comparison logic for keys of object type (and for any other type).\n * The user supplies a key comparison function to the constructor, that must meet the following criteria given 'lhs' and 'rhs' of type K:\n *  - If lhs is equal to rhs, returns 0\n *  - If lhs is less than rhs, returns a negative value\n *  - If lhs is greater than rhs, returns a positive value\n *  - If compare(lhs, rhs) returns 0, then compare(rhs, lhs) must also return 0\n *  - If compare(lhs, rhs) returns a negative value, then compare(rhs, lhs) must return a positive value, and vice versa.\n *\n * Modifying a key in a way that affects the comparison function will produce unpredictable results, the\n * most likely of which is that keys will cease to map to the values with which they were initially inserted.\n * @public\n */\nexport class Dictionary<K, V> implements Iterable<DictionaryEntry<K, V>> {\n  protected _keys: K[] = [];\n  protected readonly _compareKeys: OrderedComparator<K>;\n  protected readonly _cloneKey: CloneFunction<K>;\n  protected _values: V[] = [];\n  protected readonly _cloneValue: CloneFunction<V>;\n\n  /**\n   * Construct a new Dictionary<K, V>.\n   * @param compareKeys The function used to compare keys within the dictionary.\n   * @param cloneKey The function invoked to clone a key for insertion into the dictionary. The default implementation simply returns its input.\n   * @param cloneValue The function invoked to clone a value for insertion into the dictionary. The default implementation simply returns its input.\n   */\n  public constructor(compareKeys: OrderedComparator<K>, cloneKey: CloneFunction<K> = shallowClone, cloneValue: CloneFunction<V> = shallowClone) {\n    this._compareKeys = compareKeys;\n    this._cloneKey = cloneKey;\n    this._cloneValue = cloneValue;\n  }\n\n  /** The number of entries in the dictionary. */\n  public get size(): number { return this._keys.length; }\n\n  /** Returns an iterator over the key-value pairs in the Dictionary suitable for use in `for-of` loops. Entries are returned in sorted order by key. */\n  public [Symbol.iterator](): Iterator<DictionaryEntry<K, V>> {\n    return new DictionaryIterator<K, V>(this._keys, this._values);\n  }\n\n  /** Provides iteration over the keys in this Dictionary, in sorted order. */\n  public keys(): Iterable<K> {\n    function * iterator(dict: Dictionary<K, V>) {\n      for (const entry of dict)\n        yield entry.key;\n    }\n\n    return {\n      [Symbol.iterator]: () => iterator(this),\n    };\n  }\n\n  /** Provides iteration over the values in this Dictionary, in sorted order by the corresponding keys. */\n  public values(): Iterable<V> {\n    function * iterator(dict: Dictionary<K, V>) {\n      for (const entry of dict)\n        yield entry.value;\n    }\n\n    return {\n      [Symbol.iterator]: () => iterator(this),\n    };\n  }\n\n  /** Removes all entries from this dictionary */\n  public clear(): void {\n    this._keys = [];\n    this._values = [];\n  }\n\n  /**\n   * Looks up a value by its key.\n   * @param key The key to search for\n   * @returns the value associated with the key, or undefined if the key is not present in the dictionary.\n   */\n  public get(key: K): V | undefined {\n    const bound = this.lowerBound(key);\n    return bound.equal ? this._values[bound.index] : undefined;\n  }\n\n  /**\n   * Determines if an entry exists for the specified key\n   * @param key The key to search for\n   * @returns true if an entry exists in this dictionary corresponding to the specified key.\n   */\n  public has(key: K): boolean {\n    return this.lowerBound(key).equal;\n  }\n\n  /**\n   * Deletes a value using its key.\n   * @param key The key to delete\n   * @returns true if the key was found and deleted.\n   */\n  public delete(key: K): boolean {\n    const bound = this.lowerBound(key);\n    if (bound.equal) {\n      this._values.splice(bound.index, 1);\n      this._keys.splice(bound.index, 1);\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Attempts to insert a new entry into the dictionary. If an entry with an equivalent key exists, the dictionary is unmodified.\n   * If the new entry is in fact inserted, both the key and value will be cloned using the functions supplied to the dictionary's constructor.\n   * @param key The key to associate with the value\n   * @param value The value to associate with the key\n   * @returns true if the new entry was inserted, false if an entry with an equivalent key already exists.\n   */\n  public insert(key: K, value: V): boolean {\n    const result = this.findOrInsert(key, value);\n    return result.inserted;\n  }\n\n  /** Obtains the value associated with the specified key, or inserts it if the specified key does not yet exist.\n   * @param key The key to search for.\n   * @param value The value to associate with `key` if `key` does not yet exist in the dictionary.\n   * @returns The found or inserted value and a flag indicating whether the new value was inserted.\n   */\n  public findOrInsert(key: K, value: V): { value: V, inserted: boolean } {\n    const bound = this.lowerBound(key);\n    if (bound.equal)\n      return { value: this._values[bound.index], inserted: false };\n\n    value = this._cloneValue(value);\n    this._keys.splice(bound.index, 0, this._cloneKey(key));\n    this._values.splice(bound.index, 0, this._cloneValue(value));\n    return { value, inserted: true };\n  }\n\n  /**\n   * Sets the value associated with the specified key in the dictionary.\n   * If no such key already exists, this is equivalent to insert(key, value); otherwise, the existing value associated with the key is replaced.\n   * In either case, the value will be cloned using the function supplied to the dictionary's constructor.\n   */\n  public set(key: K, value: V): void {\n    value = this._cloneValue(value);\n    const bound = this.lowerBound(key);\n    if (bound.equal) {\n      this._values[bound.index] = value;\n    } else {\n      this._keys.splice(bound.index, 0, this._cloneKey(key));\n      this._values.splice(bound.index, 0, value);\n    }\n  }\n\n  /**\n   * Extracts the contents of this dictionary as an array of { key, value } pairs, and empties this dictionary.\n   * @returns An array of { key, value } pairs sorted by key.\n   */\n  public extractPairs(): Array<{ key: K, value: V }> {\n    const pairs: Array<{ key: K, value: V }> = [];\n    for (let i = 0; i < this.size; i++)\n      pairs.push({ key: this._keys[i], value: this._values[i] });\n\n    this.clear();\n    return pairs;\n  }\n\n  /**\n   * Extracts the contents of this dictionary as a pair of { keys, values } arrays, and empties this dictionary.\n   * The array of keys is sorted according to the comparison criterion.\n   * The position of each value in the array of values corresponds the the position of the corresponding key in the array of keys.\n   * @returns a pair of { keys, values } arrays in which key[i] corresponds to value[i] in this dictionary and the keys are in sorted order.\n   */\n  public extractArrays(): { keys: K[], values: V[] } {\n    const result = { keys: this._keys, values: this._values };\n    this.clear();\n    return result;\n  }\n\n  /** Apply a function to each (key, value) pair in the dictionary, in sorted order.\n   * @param func The function to be applied.\n   */\n  public forEach(func: (key: K, value: V) => void): void {\n    for (let i = 0; i < this.size; i++)\n      func(this._keys[i], this._values[i]);\n  }\n\n  /**\n   * Computes the position at which the specified key should be inserted to maintain sorted order.\n   * @param key The key whose position is to be computed.\n   * @returns an object with 'index' corresponding to the computed position and 'equal' set to true if an equivalent key already exists at that index.\n   */\n  protected lowerBound(key: K): { index: number, equal: boolean } { return lowerBound(key, this._keys, this._compareKeys); }\n}\n"]}

package/lib/esm/Disposable.d.ts

@@ -0,0 +1,81 @@
+/** @packageDocumentation
+ * @module Utils
+ */
+/** Interface adopted by a type which has deterministic cleanup logic.
+ * For example:
+ *  - Most rendering-related types, such as [[RenderGraphic]] and [[Viewport]], own WebGL resources which must be explicitly released when no longer needed.
+ *  - Some low-level objects like [[ECDb]] own native types defined in C++ code which must be explicitly released when no longer needed.
+ *
+ * A similar concept exists in languages like C++ (implemented as "destructors") and C# ("IDisposable").
+ * However, because TypeScript and Javascript lack any built-in support for deterministic destruction, it is up to the programmer to ensure dispose() is called appropriately.
+ * Failure to do so may result in memory leaks or leaking of other resources.
+ *
+ * IDisposable tends to be contagious; that is, if a type has members which implement IDisposable, that type should also implement IDisposable to dispose of those members.
+ *
+ * Implementations of IDisposable tend to be more "low-level" types. The disposal of such types is often handled on your behalf by imodel.js.
+ * However, always consult the documentation for an IDisposable type to determine under what circumstances you are expected to explicitly dispose of it.
+ * @public
+ */
+export interface IDisposable {
+    /** Disposes of any resources owned by this object.
+     * @note The object is generally considered unusable after it has been disposed of.
+     */
+    dispose(): void;
+}
+/**
+ * A type guard that checks whether the given argument implements `IDisposable` interface
+ * @public
+ */
+export declare function isIDisposable(obj: unknown): obj is IDisposable;
+/** Convenience function for disposing of a disposable object that may be undefined.
+ * This is primarily used to simplify implementations of [[IDisposable.dispose]].
+ * As a simple example:
+ * ```ts
+ *  class Disposable implements IDisposable {
+ *    public member1?: DisposableType1;
+ *    public member2?: DisposableType2;
+ *
+ *    public dispose() {
+ *      this.member1 = dispose(this.member1); // If member1 is defined, dispose of it and set it to undefined.
+ *      this.member2 = dispose(this.member2); // Likewise for member2.
+ *    }
+ *  }
+ * ```
+ * @param disposable The object to be disposed of.
+ * @returns undefined
+ * @public
+ */
+export declare function dispose(disposable?: IDisposable): undefined;
+/** Disposes of and empties a list of disposable objects.
+ * @param list The list of disposable objects.
+ * @returns undefined
+ * @public
+ */
+export declare function disposeArray(list?: IDisposable[]): undefined;
+/** A 'using' function which is a substitution for .NET's using statement. It makes sure that 'dispose'
+ * is called on the resource no matter if the func returns or throws. If func returns, the return value
+ * of this function is equal to return value of func. If func throws, this function also throws (after
+ * disposing the resource).
+ * @public
+ */
+export declare function using<T extends IDisposable, TResult>(resources: T | T[], func: (...r: T[]) => TResult): TResult;
+/** A definition of function which may be called to dispose an object
+ * @public
+ */
+export declare type DisposeFunc = () => void;
+/** A disposable container of disposable objects.
+ * @public
+ */
+export declare class DisposableList implements IDisposable {
+    private _disposables;
+    /** Creates a disposable list. */
+    constructor(disposables?: Array<IDisposable | DisposeFunc>);
+    private isDisposable;
+    /** Register an object for disposal. */
+    add(disposable: IDisposable | DisposeFunc): void;
+    /** Unregister disposable object. */
+    remove(disposable: IDisposable): void;
+    /** Disposes all registered objects. */
+    dispose(): void;
+}
+//# sourceMappingURL=Disposable.d.ts.map

package/lib/esm/Disposable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Disposable.d.ts","sourceRoot":"","sources":["../../src/Disposable.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,WAAW,CAG9D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CAAC,UAAU,CAAC,EAAE,WAAW,GAAG,SAAS,CAI3D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,GAAG,SAAS,CAS5D;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,KAAK,OAAO,GAAG,OAAO,CAkB/G;AAED;;GAEG;AACH,oBAAY,WAAW,GAAG,MAAM,IAAI,CAAC;AAQrC;;GAEG;AACH,qBAAa,cAAe,YAAW,WAAW;IAChD,OAAO,CAAC,YAAY,CAAgB;IAEpC,iCAAiC;gBACrB,WAAW,GAAE,KAAK,CAAC,WAAW,GAAG,WAAW,CAAM;IAO9D,OAAO,CAAC,YAAY;IAIpB,uCAAuC;IAChC,GAAG,CAAC,UAAU,EAAE,WAAW,GAAG,WAAW;IAOhD,oCAAoC;IAC7B,MAAM,CAAC,UAAU,EAAE,WAAW,GAAG,IAAI;IAM5C,uCAAuC;IAChC,OAAO,IAAI,IAAI;CAIvB"}

package/lib/esm/Disposable.js

@@ -0,0 +1,113 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Utils
+ */
+/**
+ * A type guard that checks whether the given argument implements `IDisposable` interface
+ * @public
+ */
+export function isIDisposable(obj) {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    return !!obj && (obj instanceof Object) && !!obj.dispose && (typeof obj.dispose === "function");
+}
+/** Convenience function for disposing of a disposable object that may be undefined.
+ * This is primarily used to simplify implementations of [[IDisposable.dispose]].
+ * As a simple example:
+ * ```ts
+ *  class Disposable implements IDisposable {
+ *    public member1?: DisposableType1;
+ *    public member2?: DisposableType2;
+ *
+ *    public dispose() {
+ *      this.member1 = dispose(this.member1); // If member1 is defined, dispose of it and set it to undefined.
+ *      this.member2 = dispose(this.member2); // Likewise for member2.
+ *    }
+ *  }
+ * ```
+ * @param disposable The object to be disposed of.
+ * @returns undefined
+ * @public
+ */
+export function dispose(disposable) {
+    if (undefined !== disposable)
+        disposable.dispose();
+    return undefined;
+}
+/** Disposes of and empties a list of disposable objects.
+ * @param list The list of disposable objects.
+ * @returns undefined
+ * @public
+ */
+export function disposeArray(list) {
+    if (undefined === list)
+        return undefined;
+    for (const entry of list)
+        dispose(entry);
+    list.length = 0;
+    return undefined;
+}
+/** A 'using' function which is a substitution for .NET's using statement. It makes sure that 'dispose'
+ * is called on the resource no matter if the func returns or throws. If func returns, the return value
+ * of this function is equal to return value of func. If func throws, this function also throws (after
+ * disposing the resource).
+ * @public
+ */
+export function using(resources, func) {
+    if (!Array.isArray(resources))
+        return using([resources], func);
+    const doDispose = () => resources.forEach((disposable) => disposable.dispose());
+    let shouldDisposeImmediately = true;
+    try {
+        const result = func(...resources);
+        if (result instanceof Promise) {
+            shouldDisposeImmediately = false;
+            result.then(doDispose, doDispose);
+        }
+        return result;
+    }
+    finally {
+        if (shouldDisposeImmediately)
+            doDispose();
+    }
+}
+class FuncDisposable {
+    constructor(disposeFunc) { this._disposeFunc = disposeFunc; }
+    dispose() { this._disposeFunc(); }
+}
+/** A disposable container of disposable objects.
+ * @public
+ */
+export class DisposableList {
+    /** Creates a disposable list. */
+    constructor(disposables = []) {
+        this._disposables = [];
+        disposables.forEach((disposable) => {
+            this.add(disposable);
+        });
+    }
+    isDisposable(x) {
+        return x.dispose !== undefined;
+    }
+    /** Register an object for disposal. */
+    add(disposable) {
+        if (this.isDisposable(disposable))
+            this._disposables.push(disposable);
+        else
+            this._disposables.push(new FuncDisposable(disposable));
+    }
+    /** Unregister disposable object. */
+    remove(disposable) {
+        const idx = this._disposables.indexOf(disposable);
+        if (-1 !== idx)
+            this._disposables.splice(idx, 1);
+    }
+    /** Disposes all registered objects. */
+    dispose() {
+        for (const disposable of this._disposables)
+            disposable.dispose();
+    }
+}
+//# sourceMappingURL=Disposable.js.map

package/lib/esm/Disposable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Disposable.js","sourceRoot":"","sources":["../../src/Disposable.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module Utils\n */\n\n/** Interface adopted by a type which has deterministic cleanup logic.\n * For example:\n *  - Most rendering-related types, such as [[RenderGraphic]] and [[Viewport]], own WebGL resources which must be explicitly released when no longer needed.\n *  - Some low-level objects like [[ECDb]] own native types defined in C++ code which must be explicitly released when no longer needed.\n *\n * A similar concept exists in languages like C++ (implemented as \"destructors\") and C# (\"IDisposable\").\n * However, because TypeScript and Javascript lack any built-in support for deterministic destruction, it is up to the programmer to ensure dispose() is called appropriately.\n * Failure to do so may result in memory leaks or leaking of other resources.\n *\n * IDisposable tends to be contagious; that is, if a type has members which implement IDisposable, that type should also implement IDisposable to dispose of those members.\n *\n * Implementations of IDisposable tend to be more \"low-level\" types. The disposal of such types is often handled on your behalf by imodel.js.\n * However, always consult the documentation for an IDisposable type to determine under what circumstances you are expected to explicitly dispose of it.\n * @public\n */\nexport interface IDisposable {\n  /** Disposes of any resources owned by this object.\n   * @note The object is generally considered unusable after it has been disposed of.\n   */\n  dispose(): void;\n}\n\n/**\n * A type guard that checks whether the given argument implements `IDisposable` interface\n * @public\n */\nexport function isIDisposable(obj: unknown): obj is IDisposable {\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  return !!obj && (obj instanceof Object) && !!(obj as IDisposable).dispose && (typeof (obj as IDisposable).dispose === \"function\");\n}\n\n/** Convenience function for disposing of a disposable object that may be undefined.\n * This is primarily used to simplify implementations of [[IDisposable.dispose]].\n * As a simple example:\n * ```ts\n *  class Disposable implements IDisposable {\n *    public member1?: DisposableType1;\n *    public member2?: DisposableType2;\n *\n *    public dispose() {\n *      this.member1 = dispose(this.member1); // If member1 is defined, dispose of it and set it to undefined.\n *      this.member2 = dispose(this.member2); // Likewise for member2.\n *    }\n *  }\n * ```\n * @param disposable The object to be disposed of.\n * @returns undefined\n * @public\n */\nexport function dispose(disposable?: IDisposable): undefined {\n  if (undefined !== disposable)\n    disposable.dispose();\n  return undefined;\n}\n\n/** Disposes of and empties a list of disposable objects.\n * @param list The list of disposable objects.\n * @returns undefined\n * @public\n */\nexport function disposeArray(list?: IDisposable[]): undefined {\n  if (undefined === list)\n    return undefined;\n\n  for (const entry of list)\n    dispose(entry);\n\n  list.length = 0;\n  return undefined;\n}\n\n/** A 'using' function which is a substitution for .NET's using statement. It makes sure that 'dispose'\n * is called on the resource no matter if the func returns or throws. If func returns, the return value\n * of this function is equal to return value of func. If func throws, this function also throws (after\n * disposing the resource).\n * @public\n */\nexport function using<T extends IDisposable, TResult>(resources: T | T[], func: (...r: T[]) => TResult): TResult {\n  if (!Array.isArray(resources))\n    return using([resources], func);\n\n  const doDispose = () => resources.forEach((disposable) => disposable.dispose());\n  let shouldDisposeImmediately = true;\n\n  try {\n    const result = func(...resources);\n    if (result instanceof Promise) {\n      shouldDisposeImmediately = false;\n      result.then(doDispose, doDispose);\n    }\n    return result;\n  } finally {\n    if (shouldDisposeImmediately)\n      doDispose();\n  }\n}\n\n/** A definition of function which may be called to dispose an object\n * @public\n */\nexport type DisposeFunc = () => void;\n\nclass FuncDisposable implements IDisposable {\n  private _disposeFunc: () => void;\n  constructor(disposeFunc: () => void) { this._disposeFunc = disposeFunc; }\n  public dispose() { this._disposeFunc(); }\n}\n\n/** A disposable container of disposable objects.\n * @public\n */\nexport class DisposableList implements IDisposable {\n  private _disposables: IDisposable[];\n\n  /** Creates a disposable list. */\n  constructor(disposables: Array<IDisposable | DisposeFunc> = []) {\n    this._disposables = [];\n    disposables.forEach((disposable) => {\n      this.add(disposable);\n    });\n  }\n\n  private isDisposable(x: IDisposable | DisposeFunc): x is IDisposable {\n    return (x as IDisposable).dispose !== undefined;\n  }\n\n  /** Register an object for disposal. */\n  public add(disposable: IDisposable | DisposeFunc) {\n    if (this.isDisposable(disposable))\n      this._disposables.push(disposable);\n    else\n      this._disposables.push(new FuncDisposable(disposable));\n  }\n\n  /** Unregister disposable object. */\n  public remove(disposable: IDisposable): void {\n    const idx = this._disposables.indexOf(disposable);\n    if (-1 !== idx)\n      this._disposables.splice(idx, 1);\n  }\n\n  /** Disposes all registered objects. */\n  public dispose(): void {\n    for (const disposable of this._disposables)\n      disposable.dispose();\n  }\n}\n"]}