@itwin/core-bentley 4.0.0-dev.8 → 4.0.0-dev.80

package/lib/esm/SortedArray.js.map

@@ -1 +1 @@
-{"version":3,"file":"SortedArray.js","sourceRoot":"","sources":["../../src/SortedArray.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Collections\r\n */\r\n\r\nimport { OrderedComparator } from \"./Compare\";\r\n\r\n/**\r\n * A function that, given a value of type T, returns a copy of that value. Such functions are used by various collection classes.\r\n * It is up to the function to decide how deeply or shallowly the value is cloned. For example, [[shallowClone]] simply returns the input.\r\n * @public\r\n */\r\nexport type CloneFunction<T> = (value: T) => T;\r\n\r\n/**\r\n * A [[CloneFunction]] that, given a value of type T, returns the same value.\r\n * Useful as a default argument for functions that can alternatively accept custom logic for cloning values of object type.\r\n * @param value The value to clone.\r\n * @returns the input value.\r\n * @public\r\n */\r\nexport function shallowClone<T>(value: T) {\r\n  return value;\r\n}\r\n\r\n/**\r\n * Given a sorted array, computes the position at which the specified value should be inserted into the array so that the array remains sorted.\r\n * @param value The value whose position is to be computed.\r\n * @param list An array of U already sorted according to the comparison criterion.\r\n * @param compare The function used to compare the value with elements in `list`.\r\n * @returns an object with 'index' corresponding to the computed position and 'equal' set to true if an equivalent element already exists at that index.\r\n * @public\r\n */\r\nexport function lowerBound<T, U = T>(value: T, list: U[], compare: OrderedComparator<T, U>): { index: number, equal: boolean } {\r\n  return lowerBoundOfEquivalent(list, (element: U) => compare(value, element));\r\n}\r\n\r\nfunction lowerBoundOfEquivalent<T>(list: T[], criterion: (element: T) => number): { index: number, equal: boolean } {\r\n  let low = 0;\r\n  let high = list.length;\r\n  while (low < high) {\r\n    const mid = Math.floor((low + high) / 2);\r\n    const comp = criterion(list[mid]);\r\n    if (0 === comp)\r\n      return { index: mid, equal: true };\r\n    else if (comp < 0)\r\n      high = mid;\r\n    else\r\n      low = mid + 1;\r\n  }\r\n\r\n  return { index: low, equal: false };\r\n}\r\n\r\n/** Describes how duplicate values are handled when inserting into a [[SortedArray]].\r\n * A \"duplicate\" value is one that compares equal to a value already present in the array, per the array's comparison function.\r\n * @public\r\n */\r\nexport enum DuplicatePolicy {\r\n  /** The array allows duplicate values to be inserted. All duplicate values will be adjacent in the array, but the ordering between duplicate values is unspecified.\r\n   * @note In the presence of duplicate values, functions like [[SortedArray.indexOf]] and [[SortedArray.findEqual]] will return one of the values - exactly which one is unspecified.\r\n   */\r\n  Allow,\r\n  /** Duplicate values are forbidden - when attempting to insert a value equivalent to one already present, the already-present value is retained. */\r\n  Retain,\r\n  /** Duplicate values are forbidden - when attempting to insert a value equivalent to one already present, the already-present value is replaced by the new value.\r\n   * This can be useful when the value type carries additional data that is not evaluated by the comparison function.\r\n   */\r\n  Replace,\r\n}\r\n\r\n/**\r\n * A read-only view of an array of some type T sorted according to some user-supplied criterion.\r\n * Duplicate elements may be present, though sub-types may enforce uniqueness of elements.\r\n * In the absence of duplicates, a ReadonlySortedArray<T> can behave like a Set<T> where T is an object and equality is determined\r\n * by some criterion other than object identity.\r\n *\r\n * Because the array is always sorted, querying for the presence of an element is performed using binary\r\n * search, which is more efficient than a linear search for reasonably large arrays.\r\n *\r\n * The comparison function must meet the following criteria, given 'lhs' and 'rhs' of type T:\r\n *  - If lhs is equal to rhs, returns 0\r\n *  - If lhs is less than rhs, returns a negative value\r\n *  - If lhs is greater than rhs, returns a positive value\r\n *  - If compare(lhs, rhs) returns 0, then compare(rhs, lhs) must also return 0\r\n *  - If compare(lhs, rhs) returns a negative value, then compare(rhs, lhs) must return a positive value, and vice versa.\r\n *\r\n * Note that the array is read-only only from the perspective of its public interface. Mutation methods are defined for internal use by sub-types.\r\n *\r\n * @see [[SortedArray]] for a general-purpose mutable sorted array.\r\n * @public\r\n */\r\nexport class ReadonlySortedArray<T> implements Iterable<T> {\r\n  protected _array: T[] = [];\r\n  protected readonly _compare: OrderedComparator<T>;\r\n  protected readonly _clone: CloneFunction<T>;\r\n  protected readonly _duplicatePolicy: DuplicatePolicy;\r\n\r\n  /**\r\n   * Construct a new ReadonlySortedArray<T>.\r\n   * @param compare The function used to compare elements within the array.\r\n   * @param duplicatePolicy Policy for handling attempts to insert a value when an equivalent value already exists. If the input is a boolean, then `true` indicates [[DuplicatePolicy.Allow]], and `false` indicates [[DuplicatePolicy.Retain]].\r\n   * @param clone The function invoked to clone a new element for insertion into the array. The default implementation simply returns its input.\r\n   */\r\n  protected constructor(compare: OrderedComparator<T>, duplicatePolicy: DuplicatePolicy | boolean = false, clone: CloneFunction<T> = shallowClone) {\r\n    this._compare = compare;\r\n    this._clone = clone;\r\n    if (typeof duplicatePolicy === \"boolean\")\r\n      duplicatePolicy = duplicatePolicy ? DuplicatePolicy.Allow : DuplicatePolicy.Retain;\r\n\r\n    this._duplicatePolicy = duplicatePolicy;\r\n  }\r\n\r\n  /** The number of elements in the array */\r\n  public get length(): number { return this._array.length; }\r\n\r\n  /** Returns true if the array contains no elements. */\r\n  public get isEmpty(): boolean { return 0 === this.length; }\r\n\r\n  /** Returns an iterator over the contents of the array in sorted order, suitable for use in `for-of` loops. */\r\n  public [Symbol.iterator](): Iterator<T> { return this._array[Symbol.iterator](); }\r\n\r\n  /**\r\n   * Looks up the index of an element comparing equal to the specified value using binary search.\r\n   * @param value The value to search for\r\n   * @returns the index of the first equivalent element found in the array, or -1 if no such element exists.\r\n   */\r\n  public indexOf(value: T): number {\r\n    const bound = this.lowerBound(value);\r\n    return bound.equal ? bound.index : -1;\r\n  }\r\n\r\n  /**\r\n   * Returns true if this array contains at least one value comparing equal to the specified value.\r\n   * @param value The value to search for\r\n   * @returns true if an equivalent element exists in the array.\r\n   */\r\n  public contains(value: T): boolean {\r\n    return -1 !== this.indexOf(value);\r\n  }\r\n\r\n  /**\r\n   * Looks up an element comparing equal to the specified value using binary search.\r\n   * @param value The value to search for\r\n   * @returns the first equivalent element found in the array, or undefined if no such element exists.\r\n   */\r\n  public findEqual(value: T): T | undefined {\r\n    const index = this.indexOf(value);\r\n    return -1 !== index ? this._array[index] : undefined;\r\n  }\r\n\r\n  /** Find an element that compares as equivalent based on some criterion. If multiple elements are equivalent, the specific one returned is unspecified.\r\n   * As an example, consider a `SortedArray<ModelState>` which uses `ModelState.id` as its ordering criterion. To find a model by its Id,\r\n   * use `sortedArray.findEquivalent((element) => compareStrings(element.id, modelId))` where `modelId` is an [[Id64String]].\r\n   * @param criterion A function accepting an element and returning 0 if it compares as equivalent, a negative number if it compares as \"less-than\", or a positive value if it compares as \"greater-than\".\r\n   * @returns The first element found that meets the criterion, or `undefined` if no elements meet the criterion.\r\n   * @see [[indexOfEquivalent]].\r\n   * @public\r\n   */\r\n  public findEquivalent(criterion: (element: T) => number): T | undefined {\r\n    const index = this.indexOfEquivalent(criterion);\r\n    return -1 !== index ? this._array[index] : undefined;\r\n  }\r\n\r\n  /** Find the index of an element that compares as equivalent based on some criterion. If multiple elements are equivalent, the specific one returned is unspecified.\r\n   * As an example, consider a `SortedArray<ModelState>` which uses `ModelState.id` as its ordering criterion. To find the index of a model by its Id,\r\n   * use `sortedArray.indexOfEquivalent((element) => compareStrings(element.id, modelId))` where `modelId` is an [[Id64String]].\r\n   * @param criterion A function accepting an element and returning 0 if it compares as equivalent, a negative number if the element compares as \"less-than\", or a positive value if the element compares as \"greater-than\".\r\n   * @returns The index of the first element found that meets the criterion, or -1 if no elements meet the criterion.\r\n   * @public\r\n   */\r\n  public indexOfEquivalent(criterion: (element: T) => number): number {\r\n    // NB: Must invert the ordering.\r\n    const bound = lowerBoundOfEquivalent(this._array, (elem: T) => 0 - criterion(elem));\r\n    return bound.equal ? bound.index : -1;\r\n  }\r\n\r\n  /**\r\n   * Looks up an element by its index in the array.\r\n   * @param index The array index\r\n   * @returns the element corresponding to that position in the array, or undefined if the supplied index exceeds the length of the array.\r\n   */\r\n  public get(index: number): T | undefined { return index < this.length ? this._array[index] : undefined; }\r\n\r\n  /** Apply a function to each element in the array, in sorted order.\r\n   * @param func The function to be applied.\r\n   */\r\n  public forEach(func: (value: T) => void): void {\r\n    for (let i = 0; i < this.length; i++)\r\n      func(this._array[i]);\r\n  }\r\n\r\n  /**\r\n   * Computes the position at which the specified value should be inserted to maintain sorted order.\r\n   * @param value The value whose position is to be computed.\r\n   * @returns an object with 'index' corresponding to the computed position and 'equal' set to true if an equivalent element already exists at that index.\r\n   */\r\n  protected lowerBound(value: T): { index: number, equal: boolean } { return lowerBound(value, this._array, this._compare); }\r\n\r\n  /** Clears the contents of the sorted array. */\r\n  protected _clear(): void { this._array.length = 0; }\r\n\r\n  /** Extracts the sorted array as a T[] and empties the contents of this ReadonlySortedArray.\r\n   * @returns the contents of this ReadonlySortedArray as a T[].\r\n   */\r\n  protected _extractArray(): T[] {\r\n    const result = this._array;\r\n    this._array = [];\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Attempts to insert a new value into the array at a position determined by the ordering.\r\n   * The behavior differs based on the array's [[DuplicatePolicy]]:\r\n   * If duplicates are **not** permitted, then:\r\n   *  - If an equivalent element already exists in the array:\r\n   *    - [[DuplicatePolicy.Retain]]: nothing will be inserted and the index of the existing element will be returned.\r\n   *    - [[DuplicatePolicy.Replace]]: the input value will overwrite the existing element at the same index and that index will be returned.\r\n   *  - Otherwise, the element is inserted and its index is returned.\r\n   * If duplicates **are** permitted, then:\r\n   *  - The element will be inserted in a correct position based on the sorting criterion;\r\n   *  - The position of the element relative to other elements comparing as equal to it is unspecified; and\r\n   *  - The actual index of the newly-inserted element is returned.\r\n   * If the element is to be inserted, then the supplied value will be passed to the clone function supplied to the constructor and the result will be inserted into the array.\r\n   * @param value The value to insert\r\n   * @param onInsert The optional callback method to call if insertion occurs with the inserted value\r\n   * @returns the index in the array of the newly-inserted value, or, if duplicates are not permitted and an equivalent value already exists, the index of the equivalent value.\r\n   */\r\n  protected _insert(value: T, onInsert?: (value: T) => any): number {\r\n    const bound = this.lowerBound(value);\r\n\r\n    if (bound.equal) {\r\n      switch (this._duplicatePolicy) {\r\n        case DuplicatePolicy.Retain:\r\n          return bound.index;\r\n        case DuplicatePolicy.Replace:\r\n          this._array[bound.index] = this._clone(value);\r\n          if (onInsert)\r\n            onInsert(value);\r\n\r\n          return bound.index;\r\n      }\r\n    }\r\n\r\n    this._array.splice(bound.index, 0, this._clone(value));\r\n    if (undefined !== onInsert)\r\n      onInsert(value);\r\n\r\n    return bound.index;\r\n  }\r\n\r\n  /**\r\n   * Removes the first occurrence of a value comparing equal to the specified value from the array.\r\n   * @param value The value of the element to delete\r\n   * @returns the index of the deleted value, or -1 if no such element exists.\r\n   */\r\n  protected _remove(value: T): number {\r\n    const bound = this.lowerBound(value);\r\n    if (bound.equal) {\r\n      this._array.splice(bound.index, 1);\r\n      return bound.index;\r\n    } else {\r\n      return -1;\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Maintains an array of some type T in sorted order. The ordering is specified by a function supplied\r\n * by the user.\r\n * By default, only unique elements are permitted; attempting to insert a new element that compares\r\n * as equal to an element already in the array will not modify the contents of the array.\r\n *\r\n * This allows a SortedArray<T> to behave like a Set<T> where T is an object and equality is determined\r\n * by some criterion other than object identity.\r\n *\r\n * Because the array is always sorted, querying for the presence of an element is performed using binary\r\n * search, which is more efficient than a linear search for reasonably large arrays.\r\n *\r\n * The user can also specify how the SortedArray takes ownership of inserted values, e.g., by cloning them.\r\n *\r\n * The comparison function must meet the following criteria, given 'lhs' and 'rhs' of type T:\r\n *  - If lhs is equal to rhs, returns 0\r\n *  - If lhs is less than rhs, returns a negative value\r\n *  - If lhs is greater than rhs, returns a positive value\r\n *  - If compare(lhs, rhs) returns 0, then compare(rhs, lhs) must also return 0\r\n *  - If compare(lhs, rhs) returns a negative value, then compare(rhs, lhs) must return a positive value, and vice versa.\r\n *\r\n * Modifying an element in a way that affects the comparison function will produce unpredictable results, the\r\n * most likely of which is that the array will cease to be sorted.\r\n * @public\r\n */\r\nexport class SortedArray<T> extends ReadonlySortedArray<T> {\r\n  /**\r\n   * Construct a new SortedArray<T>.\r\n   * @param compare The function used to compare elements within the array.\r\n   * @param duplicatePolicy Policy for handling attempts to insert a value when an equivalent value already exists. If the input is a boolean, then `true` indicates [[DuplicatePolicy.Allow]], and `false` indicates [[DuplicatePolicy.Retain]].\r\n   * @param clone The function invoked to clone a new element for insertion into the array. The default implementation simply returns its input.\r\n   */\r\n  public constructor(compare: OrderedComparator<T>, duplicatePolicy: DuplicatePolicy | boolean = false, clone: CloneFunction<T> = shallowClone) {\r\n    super(compare, duplicatePolicy, clone);\r\n  }\r\n\r\n  /** Clears the contents of the sorted array. */\r\n  public clear(): void { this._clear(); }\r\n\r\n  /** Extracts the sorted array as a T[] and empties the contents of this SortedArray.\r\n   * @returns the contents of this SortedArray as a T[].\r\n   */\r\n  public extractArray(): T[] { return this._extractArray(); }\r\n\r\n  /**\r\n   * Attempts to insert a new value into the array at a position determined by the ordering.\r\n   * The behavior differs based on whether or not duplicate elements are permitted.\r\n   * If duplicates are **not** permitted, then:\r\n   *  - If an equivalent element already exists in the array, nothing will be inserted and the index of the existing element will be returned.\r\n   *  - Otherwise, the element is inserted and its index is returned.\r\n   * If duplicates **are** permitted, then:\r\n   *  - The element will be inserted in a correct position based on the sorting criterion;\r\n   *  - The position of the element relative to other elements comparing as equal to it is unspecified; and\r\n   *  - The actual index of the newly-inserted element is returned.\r\n   * If the element is to be inserted, then the supplied value will be passed to the clone function supplied to the constructor and the result will be inserted into the array.\r\n   * @param value The value to insert\r\n   * @param onInsert The optional callback method to call if insertion occurs with the inserted value\r\n   * @returns the index in the array of the newly-inserted value, or, if duplicates are not permitted and an equivalent value already exists, the index of the equivalent value.\r\n   */\r\n  public insert(value: T, onInsert?: (value: T) => any): number { return this._insert(value, onInsert); }\r\n\r\n  /**\r\n   * Removes the first occurrence of a value comparing equal to the specified value from the array.\r\n   * @param value The value of the element to delete\r\n   * @returns the index of the deleted value, or -1 if no such element exists.\r\n   */\r\n  public remove(value: T): number { return this._remove(value); }\r\n}\r\n"]}
+{"version":3,"file":"SortedArray.js","sourceRoot":"","sources":["../../src/SortedArray.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Collections\r\n */\r\n\r\nimport { OrderedComparator } from \"./Compare\";\r\n\r\n/**\r\n * A function that, given a value of type T, returns a copy of that value. Such functions are used by various collection classes.\r\n * It is up to the function to decide how deeply or shallowly the value is cloned. For example, [[shallowClone]] simply returns the input.\r\n * @public\r\n */\r\nexport type CloneFunction<T> = (value: T) => T;\r\n\r\n/**\r\n * A [[CloneFunction]] that, given a value of type T, returns the same value.\r\n * Useful as a default argument for functions that can alternatively accept custom logic for cloning values of object type.\r\n * @param value The value to clone.\r\n * @returns the input value.\r\n * @public\r\n */\r\nexport function shallowClone<T>(value: T) {\r\n  return value;\r\n}\r\n\r\n/**\r\n * Given a sorted array, computes the position at which the specified value should be inserted into the array so that the array remains sorted.\r\n * @param value The value whose position is to be computed.\r\n * @param list An array of U already sorted according to the comparison criterion.\r\n * @param compare The function used to compare the value with elements in `list`.\r\n * @returns an object with 'index' corresponding to the computed position and 'equal' set to true if an equivalent element already exists at that index.\r\n * @public\r\n */\r\nexport function lowerBound<T, U = T>(value: T, list: U[], compare: OrderedComparator<T, U>): { index: number, equal: boolean } {\r\n  return lowerBoundOfEquivalent(list, (element: U) => compare(value, element));\r\n}\r\n\r\nfunction lowerBoundOfEquivalent<T>(list: T[], criterion: (element: T) => number): { index: number, equal: boolean } {\r\n  let low = 0;\r\n  let high = list.length;\r\n  while (low < high) {\r\n    const mid = Math.floor((low + high) / 2);\r\n    const comp = criterion(list[mid]);\r\n    if (0 === comp)\r\n      return { index: mid, equal: true };\r\n    else if (comp < 0)\r\n      high = mid;\r\n    else\r\n      low = mid + 1;\r\n  }\r\n\r\n  return { index: low, equal: false };\r\n}\r\n\r\n/** Describes how duplicate values are handled when inserting into a [[SortedArray]].\r\n * A \"duplicate\" value is one that compares equal to a value already present in the array, per the array's comparison function.\r\n * @public\r\n */\r\nexport enum DuplicatePolicy {\r\n  /** The array allows duplicate values to be inserted. All duplicate values will be adjacent in the array, but the ordering between duplicate values is unspecified.\r\n   * @note In the presence of duplicate values, functions like [[SortedArray.indexOf]] and [[SortedArray.findEqual]] will return one of the values - exactly which one is unspecified.\r\n   */\r\n  Allow,\r\n  /** Duplicate values are forbidden - when attempting to insert a value equivalent to one already present, the already-present value is retained. */\r\n  Retain,\r\n  /** Duplicate values are forbidden - when attempting to insert a value equivalent to one already present, the already-present value is replaced by the new value.\r\n   * This can be useful when the value type carries additional data that is not evaluated by the comparison function.\r\n   */\r\n  Replace,\r\n}\r\n\r\n/**\r\n * A read-only view of an array of some type T sorted according to some user-supplied criterion.\r\n * Duplicate elements may be present, though sub-types may enforce uniqueness of elements.\r\n * In the absence of duplicates, a ReadonlySortedArray<T> can behave like a Set<T> where T is an object and equality is determined\r\n * by some criterion other than object identity.\r\n *\r\n * Because the array is always sorted, querying for the presence of an element is performed using binary\r\n * search, which is more efficient than a linear search for reasonably large arrays.\r\n *\r\n * The comparison function must meet the following criteria, given 'lhs' and 'rhs' of type T:\r\n *  - If lhs is equal to rhs, returns 0\r\n *  - If lhs is less than rhs, returns a negative value\r\n *  - If lhs is greater than rhs, returns a positive value\r\n *  - If compare(lhs, rhs) returns 0, then compare(rhs, lhs) must also return 0\r\n *  - If compare(lhs, rhs) returns a negative value, then compare(rhs, lhs) must return a positive value, and vice versa.\r\n *\r\n * Note that the array is read-only only from the perspective of its public interface. Mutation methods are defined for internal use by sub-types.\r\n *\r\n * @see [[SortedArray]] for a general-purpose mutable sorted array.\r\n * @public\r\n */\r\nexport class ReadonlySortedArray<T> implements Iterable<T> {\r\n  protected _array: T[] = [];\r\n  protected readonly _compare: OrderedComparator<T>;\r\n  protected readonly _clone: CloneFunction<T>;\r\n  protected readonly _duplicatePolicy: DuplicatePolicy;\r\n\r\n  /**\r\n   * Construct a new ReadonlySortedArray<T>.\r\n   * @param compare The function used to compare elements within the array.\r\n   * @param duplicatePolicy Policy for handling attempts to insert a value when an equivalent value already exists. If the input is a boolean, then `true` indicates [[DuplicatePolicy.Allow]], and `false` indicates [[DuplicatePolicy.Retain]].\r\n   * @param clone The function invoked to clone a new element for insertion into the array. The default implementation simply returns its input.\r\n   */\r\n  protected constructor(compare: OrderedComparator<T>, duplicatePolicy: DuplicatePolicy | boolean = false, clone: CloneFunction<T> = shallowClone) {\r\n    this._compare = compare;\r\n    this._clone = clone;\r\n    if (typeof duplicatePolicy === \"boolean\")\r\n      duplicatePolicy = duplicatePolicy ? DuplicatePolicy.Allow : DuplicatePolicy.Retain;\r\n\r\n    this._duplicatePolicy = duplicatePolicy;\r\n  }\r\n\r\n  /** The number of elements in the array */\r\n  public get length(): number { return this._array.length; }\r\n\r\n  /** Returns true if the array contains no elements. */\r\n  public get isEmpty(): boolean { return 0 === this.length; }\r\n\r\n  /** Returns an iterator over the contents of the array in sorted order, suitable for use in `for-of` loops. */\r\n  public [Symbol.iterator](): Iterator<T> { return this._array[Symbol.iterator](); }\r\n\r\n  /**\r\n   * Looks up the index of an element comparing equal to the specified value using binary search.\r\n   * @param value The value to search for\r\n   * @returns the index of the first equivalent element found in the array, or -1 if no such element exists.\r\n   */\r\n  public indexOf(value: T): number {\r\n    const bound = this.lowerBound(value);\r\n    return bound.equal ? bound.index : -1;\r\n  }\r\n\r\n  /**\r\n   * Returns true if this array contains at least one value comparing equal to the specified value.\r\n   * @param value The value to search for\r\n   * @returns true if an equivalent element exists in the array.\r\n   */\r\n  public contains(value: T): boolean {\r\n    return -1 !== this.indexOf(value);\r\n  }\r\n\r\n  /**\r\n   * Looks up an element comparing equal to the specified value using binary search.\r\n   * @param value The value to search for\r\n   * @returns the first equivalent element found in the array, or undefined if no such element exists.\r\n   */\r\n  public findEqual(value: T): T | undefined {\r\n    const index = this.indexOf(value);\r\n    return -1 !== index ? this._array[index] : undefined;\r\n  }\r\n\r\n  /** Find an element that compares as equivalent based on some criterion. If multiple elements are equivalent, the specific one returned is unspecified.\r\n   * As an example, consider a `SortedArray<ModelState>` which uses `ModelState.id` as its ordering criterion. To find a model by its Id,\r\n   * use `sortedArray.findEquivalent((element) => compareStrings(element.id, modelId))` where `modelId` is an [[Id64String]].\r\n   * @param criterion A function accepting an element and returning 0 if it compares as equivalent, a negative number if it compares as \"less-than\", or a positive value if it compares as \"greater-than\".\r\n   * @returns The first element found that meets the criterion, or `undefined` if no elements meet the criterion.\r\n   * @see [[indexOfEquivalent]].\r\n   * @public\r\n   */\r\n  public findEquivalent(criterion: (element: T) => number): T | undefined {\r\n    const index = this.indexOfEquivalent(criterion);\r\n    return -1 !== index ? this._array[index] : undefined;\r\n  }\r\n\r\n  /** Find the index of an element that compares as equivalent based on some criterion. If multiple elements are equivalent, the specific one returned is unspecified.\r\n   * As an example, consider a `SortedArray<ModelState>` which uses `ModelState.id` as its ordering criterion. To find the index of a model by its Id,\r\n   * use `sortedArray.indexOfEquivalent((element) => compareStrings(element.id, modelId))` where `modelId` is an [[Id64String]].\r\n   * @param criterion A function accepting an element and returning 0 if it compares as equivalent, a negative number if the element compares as \"less-than\", or a positive value if the element compares as \"greater-than\".\r\n   * @returns The index of the first element found that meets the criterion, or -1 if no elements meet the criterion.\r\n   * @public\r\n   */\r\n  public indexOfEquivalent(criterion: (element: T) => number): number {\r\n    // NB: Must invert the ordering.\r\n    const bound = lowerBoundOfEquivalent(this._array, (elem: T) => 0 - criterion(elem));\r\n    return bound.equal ? bound.index : -1;\r\n  }\r\n\r\n  /**\r\n   * Looks up an element by its index in the array.\r\n   * @param index The array index\r\n   * @returns the element corresponding to that position in the array, or undefined if the supplied index exceeds the length of the array.\r\n   */\r\n  public get(index: number): T | undefined { return index < this.length ? this._array[index] : undefined; }\r\n\r\n  /** Apply a function to each element in the array, in sorted order.\r\n   * @param func The function to be applied.\r\n   */\r\n  public forEach(func: (value: T) => void): void {\r\n    for (let i = 0; i < this.length; i++)\r\n      func(this._array[i]);\r\n  }\r\n\r\n  /** The equivalent of [Array.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice). */\r\n  public slice(start?: number, end?: number): ReadonlySortedArray<T> {\r\n    const slice = new ReadonlySortedArray<T>(this._compare, this._duplicatePolicy, this._clone);\r\n    slice._array = this._array.slice(start, end);\r\n    return slice;\r\n  }\r\n\r\n  /**\r\n   * Computes the position at which the specified value should be inserted to maintain sorted order.\r\n   * @param value The value whose position is to be computed.\r\n   * @returns an object with 'index' corresponding to the computed position and 'equal' set to true if an equivalent element already exists at that index.\r\n   */\r\n  protected lowerBound(value: T): { index: number, equal: boolean } { return lowerBound(value, this._array, this._compare); }\r\n\r\n  /** Clears the contents of the sorted array. */\r\n  protected _clear(): void { this._array.length = 0; }\r\n\r\n  /** Extracts the sorted array as a T[] and empties the contents of this ReadonlySortedArray.\r\n   * @returns the contents of this ReadonlySortedArray as a T[].\r\n   */\r\n  protected _extractArray(): T[] {\r\n    const result = this._array;\r\n    this._array = [];\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Attempts to insert a new value into the array at a position determined by the ordering.\r\n   * The behavior differs based on the array's [[DuplicatePolicy]]:\r\n   * If duplicates are **not** permitted, then:\r\n   *  - If an equivalent element already exists in the array:\r\n   *    - [[DuplicatePolicy.Retain]]: nothing will be inserted and the index of the existing element will be returned.\r\n   *    - [[DuplicatePolicy.Replace]]: the input value will overwrite the existing element at the same index and that index will be returned.\r\n   *  - Otherwise, the element is inserted and its index is returned.\r\n   * If duplicates **are** permitted, then:\r\n   *  - The element will be inserted in a correct position based on the sorting criterion;\r\n   *  - The position of the element relative to other elements comparing as equal to it is unspecified; and\r\n   *  - The actual index of the newly-inserted element is returned.\r\n   * If the element is to be inserted, then the supplied value will be passed to the clone function supplied to the constructor and the result will be inserted into the array.\r\n   * @param value The value to insert\r\n   * @param onInsert The optional callback method to call if insertion occurs with the inserted value\r\n   * @returns the index in the array of the newly-inserted value, or, if duplicates are not permitted and an equivalent value already exists, the index of the equivalent value.\r\n   */\r\n  protected _insert(value: T, onInsert?: (value: T) => any): number {\r\n    const bound = this.lowerBound(value);\r\n\r\n    if (bound.equal) {\r\n      switch (this._duplicatePolicy) {\r\n        case DuplicatePolicy.Retain:\r\n          return bound.index;\r\n        case DuplicatePolicy.Replace:\r\n          this._array[bound.index] = this._clone(value);\r\n          if (onInsert)\r\n            onInsert(value);\r\n\r\n          return bound.index;\r\n      }\r\n    }\r\n\r\n    this._array.splice(bound.index, 0, this._clone(value));\r\n    if (undefined !== onInsert)\r\n      onInsert(value);\r\n\r\n    return bound.index;\r\n  }\r\n\r\n  /**\r\n   * Removes the first occurrence of a value comparing equal to the specified value from the array.\r\n   * @param value The value of the element to delete\r\n   * @returns the index of the deleted value, or -1 if no such element exists.\r\n   */\r\n  protected _remove(value: T): number {\r\n    const bound = this.lowerBound(value);\r\n    if (bound.equal) {\r\n      this._array.splice(bound.index, 1);\r\n      return bound.index;\r\n    } else {\r\n      return -1;\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Maintains an array of some type T in sorted order. The ordering is specified by a function supplied\r\n * by the user.\r\n * By default, only unique elements are permitted; attempting to insert a new element that compares\r\n * as equal to an element already in the array will not modify the contents of the array.\r\n *\r\n * This allows a SortedArray<T> to behave like a Set<T> where T is an object and equality is determined\r\n * by some criterion other than object identity.\r\n *\r\n * Because the array is always sorted, querying for the presence of an element is performed using binary\r\n * search, which is more efficient than a linear search for reasonably large arrays.\r\n *\r\n * The user can also specify how the SortedArray takes ownership of inserted values, e.g., by cloning them.\r\n *\r\n * The comparison function must meet the following criteria, given 'lhs' and 'rhs' of type T:\r\n *  - If lhs is equal to rhs, returns 0\r\n *  - If lhs is less than rhs, returns a negative value\r\n *  - If lhs is greater than rhs, returns a positive value\r\n *  - If compare(lhs, rhs) returns 0, then compare(rhs, lhs) must also return 0\r\n *  - If compare(lhs, rhs) returns a negative value, then compare(rhs, lhs) must return a positive value, and vice versa.\r\n *\r\n * Modifying an element in a way that affects the comparison function will produce unpredictable results, the\r\n * most likely of which is that the array will cease to be sorted.\r\n * @public\r\n */\r\nexport class SortedArray<T> extends ReadonlySortedArray<T> {\r\n  /**\r\n   * Construct a new SortedArray<T>.\r\n   * @param compare The function used to compare elements within the array.\r\n   * @param duplicatePolicy Policy for handling attempts to insert a value when an equivalent value already exists. If the input is a boolean, then `true` indicates [[DuplicatePolicy.Allow]], and `false` indicates [[DuplicatePolicy.Retain]].\r\n   * @param clone The function invoked to clone a new element for insertion into the array. The default implementation simply returns its input.\r\n   */\r\n  public constructor(compare: OrderedComparator<T>, duplicatePolicy: DuplicatePolicy | boolean = false, clone: CloneFunction<T> = shallowClone) {\r\n    super(compare, duplicatePolicy, clone);\r\n  }\r\n\r\n  /** Clears the contents of the sorted array. */\r\n  public clear(): void { this._clear(); }\r\n\r\n  /** Extracts the sorted array as a T[] and empties the contents of this SortedArray.\r\n   * @returns the contents of this SortedArray as a T[].\r\n   */\r\n  public extractArray(): T[] { return this._extractArray(); }\r\n\r\n  /**\r\n   * Attempts to insert a new value into the array at a position determined by the ordering.\r\n   * The behavior differs based on whether or not duplicate elements are permitted.\r\n   * If duplicates are **not** permitted, then:\r\n   *  - If an equivalent element already exists in the array, nothing will be inserted and the index of the existing element will be returned.\r\n   *  - Otherwise, the element is inserted and its index is returned.\r\n   * If duplicates **are** permitted, then:\r\n   *  - The element will be inserted in a correct position based on the sorting criterion;\r\n   *  - The position of the element relative to other elements comparing as equal to it is unspecified; and\r\n   *  - The actual index of the newly-inserted element is returned.\r\n   * If the element is to be inserted, then the supplied value will be passed to the clone function supplied to the constructor and the result will be inserted into the array.\r\n   * @param value The value to insert\r\n   * @param onInsert The optional callback method to call if insertion occurs with the inserted value\r\n   * @returns the index in the array of the newly-inserted value, or, if duplicates are not permitted and an equivalent value already exists, the index of the equivalent value.\r\n   */\r\n  public insert(value: T, onInsert?: (value: T) => any): number { return this._insert(value, onInsert); }\r\n\r\n  /**\r\n   * Removes the first occurrence of a value comparing equal to the specified value from the array.\r\n   * @param value The value of the element to delete\r\n   * @returns the index of the deleted value, or -1 if no such element exists.\r\n   */\r\n  public remove(value: T): number { return this._remove(value); }\r\n\r\n  /** The equivalent of [Array.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice). */\r\n  public override slice(start?: number, end?: number): SortedArray<T> {\r\n    const slice = new SortedArray<T>(this._compare, this._duplicatePolicy, this._clone);\r\n    slice._array = this._array.slice(start, end);\r\n    return slice;\r\n  }\r\n}\r\n"]}

package/lib/esm/StatusCategory.d.ts

@@ -1,31 +1,31 @@
-/** @packageDocumentation
- * @module Errors
- */
-import { BentleyError } from "./BentleyError";
-/** @alpha */
-export declare type StatusCategoryHandler = (error: BentleyError) => StatusCategory | undefined;
-/** A group of related statuses for aggregate reporting purposes.
- * @alpha
- */
-export declare abstract class StatusCategory {
-    static handlers: Set<StatusCategoryHandler>;
-    static for(error: BentleyError): StatusCategory;
-    abstract name: string;
-    abstract code: number;
-    abstract error: boolean;
-}
-/***
- * A success status.
- * @alpha
- */
-export declare abstract class SuccessCategory extends StatusCategory {
-    error: boolean;
-}
-/**
- * An error status.
- * @alpha
- */
-export declare abstract class ErrorCategory extends StatusCategory {
-    error: boolean;
-}
+/** @packageDocumentation
+ * @module Errors
+ */
+import { BentleyError } from "./BentleyError";
+/** @alpha */
+export type StatusCategoryHandler = (error: BentleyError) => StatusCategory | undefined;
+/** A group of related statuses for aggregate reporting purposes.
+ * @alpha
+ */
+export declare abstract class StatusCategory {
+    static handlers: Set<StatusCategoryHandler>;
+    static for(error: BentleyError): StatusCategory;
+    abstract name: string;
+    abstract code: number;
+    abstract error: boolean;
+}
+/***
+ * A success status.
+ * @alpha
+ */
+export declare abstract class SuccessCategory extends StatusCategory {
+    error: boolean;
+}
+/**
+ * An error status.
+ * @alpha
+ */
+export declare abstract class ErrorCategory extends StatusCategory {
+    error: boolean;
+}
 //# sourceMappingURL=StatusCategory.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"StatusCategory.d.ts","sourceRoot":"","sources":["../../src/StatusCategory.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EACL,YAAY,EAWb,MAAM,gBAAgB,CAAC;AAIxB,aAAa;AACb,oBAAY,qBAAqB,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,cAAc,GAAG,SAAS,CAAC;AAExF;;GAEG;AACH,8BAAsB,cAAc;IAClC,OAAc,QAAQ,EAAE,GAAG,CAAC,qBAAqB,CAAC,CAAa;WAEjD,GAAG,CAAC,KAAK,EAAE,YAAY,GAAG,cAAc;IAWtD,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,KAAK,EAAE,OAAO,CAAC;CAChC;AAED;;;GAGG;AACH,8BAAsB,eAAgB,SAAQ,cAAc;IACnD,KAAK,UAAS;CACtB;AAED;;;GAGG;AACH,8BAAsB,aAAc,SAAQ,cAAc;IACjD,KAAK,UAAQ;CACrB"}
+{"version":3,"file":"StatusCategory.d.ts","sourceRoot":"","sources":["../../src/StatusCategory.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EACL,YAAY,EAWb,MAAM,gBAAgB,CAAC;AAIxB,aAAa;AACb,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,cAAc,GAAG,SAAS,CAAC;AAExF;;GAEG;AACH,8BAAsB,cAAc;IAClC,OAAc,QAAQ,EAAE,GAAG,CAAC,qBAAqB,CAAC,CAAa;WAEjD,GAAG,CAAC,KAAK,EAAE,YAAY,GAAG,cAAc;IAWtD,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,KAAK,EAAE,OAAO,CAAC;CAChC;AAED;;;GAGG;AACH,8BAAsB,eAAgB,SAAQ,cAAc;IACnD,KAAK,UAAS;CACtB;AAED;;;GAGG;AACH,8BAAsB,aAAc,SAAQ,cAAc;IACjD,KAAK,UAAQ;CACrB"}