npm - @itwin/core-bentley - Versions diffs - 3.7.0-dev.1 → 3.7.0-dev.2 - Mend

@itwin/core-bentley 3.7.0-dev.1 → 3.7.0-dev.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/CHANGELOG.md +18 -11
package/lib/cjs/SortedArray.d.ts +4 -0
package/lib/cjs/SortedArray.d.ts.map +1 -1
package/lib/cjs/SortedArray.js +12 -0
package/lib/cjs/SortedArray.js.map +1 -1
package/lib/esm/SortedArray.d.ts +4 -0
package/lib/esm/SortedArray.d.ts.map +1 -1
package/lib/esm/SortedArray.js +12 -0
package/lib/esm/SortedArray.js.map +1 -1
package/package.json +3 -3

package/CHANGELOG.md CHANGED Viewed

@@ -12,6 +12,13 @@ Wed, 08 Feb 2023 14:58:39 GMT
 - Added TransientIdSequence.peekNext to preview the next Id in the sequence.
 - Deprecate TransientIdSequence.next property in favor of getNext method.
+## 3.5.6
+Fri, 24 Feb 2023 16:02:47 GMT
+### Updates
+- Add SortedArray.slice.
 ## 3.5.5
 Thu, 26 Jan 2023 22:53:27 GMT
@@ -874,7 +881,7 @@ Thu, 28 May 2020 22:48:59 GMT
 ### Updates
 - Added FailedToGetProductSettings error
-- Setup Guid.normalize() for internal use.
+- Setup Guid.normalize() for internal use.
 - channel rules
 ## 2.0.0
@@ -882,12 +889,12 @@ Wed, 06 May 2020 13:17:49 GMT
 ### Updates
-- Monitor progress of downloading briefcases, ability to cancel download of briefcases.
+- Monitor progress of downloading briefcases, ability to cancel download of briefcases.
 - Update Config.App documentation to reflect the removal of the config.json file
 - Added ContextDoesNotExist error
 - BUG273249
-- Updated docs.
-- Updated error text.
+- Updated docs.
+- Updated error text.
 - added raw log method that bypass catogory check
 - order imports.
 - Add a type guard for `IDisposable`
@@ -921,7 +928,7 @@ Wed, 22 Jan 2020 19:24:11 GMT
 ### Updates
-- VSS$257397: Temporary fix for checking electron renderer.
+- VSS$257397: Temporary fix for checking electron renderer.
 - Upgrade to TypeScript 3.7.2.
 ## 1.10.0
@@ -936,7 +943,7 @@ Tue, 10 Dec 2019 18:08:56 GMT
 ### Updates
-- Setup OidcDesktopClient for Electron use cases.
+- Setup OidcDesktopClient for Electron use cases.
 - Added non-static wait and executeAfter to BeDuration
 - Fix warnings from static analysis
 - Added `BeDuration.race` for common timeout operations.
@@ -989,7 +996,7 @@ Mon, 01 Jul 2019 19:04:29 GMT
 ### Updates
 - Added OneAtATimeActivity class
-- Introduced AsyncMutex - a utility to run async blocks of code in sequence.
+- Introduced AsyncMutex - a utility to run async blocks of code in sequence.
 - Update to TypeScript 3.5
 ## 1.0.0
@@ -1016,10 +1023,10 @@ Mon, 13 May 2019 15:52:05 GMT
 - Logged the fields in ClientRequestContext
 - Logging fixes.
 - Put sourcemap in npm package.
-- Fixed logger to not mutate incoming objects.
+- Fixed logger to not mutate incoming objects.
 - Improved performance logging
 - Added functions for iterating and obtaining the number of elements of a collection of Id64s represented as an Id64Arg.
-- Setup a generic context for tracking client requests, and made various related enhancements to logging, usage tracking and authorization.
+- Setup a generic context for tracking client requests, and made various related enhancements to logging, usage tracking and authorization.
 - Use TextDecoder to decode binary utf-8 strings if supported.
 - Upgrade TypeDoc dependency to 0.14.2
@@ -1055,7 +1062,7 @@ Mon, 14 Jan 2019 23:09:10 GMT
 ### Updates
-- Removed IModelDb's cache of accessToken. For long running operations like AutoPush, the user must explicitly supply an IAccessTokenManager to keep the token current.
+- Removed IModelDb's cache of accessToken. For long running operations like AutoPush, the user must explicitly supply an IAccessTokenManager to keep the token current.
 ## 0.185.0
 Fri, 11 Jan 2019 18:29:00 GMT
@@ -1162,7 +1169,7 @@ Fri, 16 Nov 2018 21:45:44 GMT
 ### Updates
-- Changes to debug utilities.
+- Changes to debug utilities.
 - Fluentd Bunnyan Logger added
 ## 0.166.0

package/lib/cjs/SortedArray.d.ts CHANGED Viewed

@@ -128,6 +128,8 @@ export declare class ReadonlySortedArray<T> implements Iterable<T> {
      * @param func The function to be applied.
      */
     forEach(func: (value: T) => void): void;
+    /** The equivalent of [Array.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice). */
+    slice(start?: number, end?: number): ReadonlySortedArray<T>;
     /**
      * Computes the position at which the specified value should be inserted to maintain sorted order.
      * @param value The value whose position is to be computed.
@@ -229,5 +231,7 @@ export declare class SortedArray<T> extends ReadonlySortedArray<T> {
      * @returns the index of the deleted value, or -1 if no such element exists.
      */
     remove(value: T): number;
+    /** The equivalent of [Array.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice). */
+    slice(start?: number, end?: number): SortedArray<T>;
 }
 //# sourceMappingURL=SortedArray.d.ts.map

package/lib/cjs/SortedArray.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"SortedArray.d.ts","sourceRoot":"","sources":["../../src/SortedArray.ts"],"names":[],"mappings":"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~~CAChC~~"}
1	+ {"version":3,"file":"SortedArray.d.ts","sourceRoot":"","sources":["../../src/SortedArray.ts"],"names":[],"mappings":"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"}

package/lib/cjs/SortedArray.js CHANGED Viewed

@@ -168,6 +168,12 @@ class ReadonlySortedArray {
         for (let i = 0; i < this.length; i++)
             func(this._array[i]);
     }
+    /** The equivalent of [Array.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice). */
+    slice(start, end) {
+        const slice = new ReadonlySortedArray(this._compare, this._duplicatePolicy, this._clone);
+        slice._array = this._array.slice(start, end);
+        return slice;
+    }
     /**
      * Computes the position at which the specified value should be inserted to maintain sorted order.
      * @param value The value whose position is to be computed.
@@ -299,6 +305,12 @@ class SortedArray extends ReadonlySortedArray {
      * @returns the index of the deleted value, or -1 if no such element exists.
      */
     remove(value) { return this._remove(value); }
+    /** The equivalent of [Array.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice). */
+    slice(start, end) {
+        const slice = new SortedArray(this._compare, this._duplicatePolicy, this._clone);
+        slice._array = this._array.slice(start, end);
+        return slice;
+    }
 }
 exports.SortedArray = SortedArray;
 //# sourceMappingURL=SortedArray.js.map

package/lib/cjs/SortedArray.js.map CHANGED Viewed

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

package/lib/esm/SortedArray.d.ts CHANGED Viewed

@@ -128,6 +128,8 @@ export declare class ReadonlySortedArray<T> implements Iterable<T> {
      * @param func The function to be applied.
      */
     forEach(func: (value: T) => void): void;
+    /** The equivalent of [Array.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice). */
+    slice(start?: number, end?: number): ReadonlySortedArray<T>;
     /**
      * Computes the position at which the specified value should be inserted to maintain sorted order.
      * @param value The value whose position is to be computed.
@@ -229,5 +231,7 @@ export declare class SortedArray<T> extends ReadonlySortedArray<T> {
      * @returns the index of the deleted value, or -1 if no such element exists.
      */
     remove(value: T): number;
+    /** The equivalent of [Array.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice). */
+    slice(start?: number, end?: number): SortedArray<T>;
 }
 //# sourceMappingURL=SortedArray.d.ts.map

package/lib/esm/SortedArray.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"SortedArray.d.ts","sourceRoot":"","sources":["../../src/SortedArray.ts"],"names":[],"mappings":"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~~CAChC~~"}
1	+ {"version":3,"file":"SortedArray.d.ts","sourceRoot":"","sources":["../../src/SortedArray.ts"],"names":[],"mappings":"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"}

package/lib/esm/SortedArray.js CHANGED Viewed

@@ -163,6 +163,12 @@ export class ReadonlySortedArray {
         for (let i = 0; i < this.length; i++)
             func(this._array[i]);
     }
+    /** The equivalent of [Array.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice). */
+    slice(start, end) {
+        const slice = new ReadonlySortedArray(this._compare, this._duplicatePolicy, this._clone);
+        slice._array = this._array.slice(start, end);
+        return slice;
+    }
     /**
      * Computes the position at which the specified value should be inserted to maintain sorted order.
      * @param value The value whose position is to be computed.
@@ -293,5 +299,11 @@ export class SortedArray extends ReadonlySortedArray {
      * @returns the index of the deleted value, or -1 if no such element exists.
      */
     remove(value) { return this._remove(value); }
+    /** The equivalent of [Array.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice). */
+    slice(start, end) {
+        const slice = new SortedArray(this._compare, this._duplicatePolicy, this._clone);
+        slice._array = this._array.slice(start, end);
+        return slice;
+    }
 }
 //# sourceMappingURL=SortedArray.js.map

package/lib/esm/SortedArray.js.map CHANGED Viewed

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

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@itwin/core-bentley",
-  "version": "3.7.0-dev.1",
+  "version": "3.7.0-dev.2",
   "description": "Bentley JavaScript core components",
   "main": "lib/cjs/core-bentley.js",
   "module": "lib/esm/core-bentley.js",
@@ -21,8 +21,8 @@
     "url": "http://www.bentley.com"
   },
   "devDependencies": {
-    "@itwin/build-tools": "3.7.0-dev.1",
-    "@itwin/eslint-plugin": "3.7.0-dev.1",
+    "@itwin/build-tools": "3.7.0-dev.2",
+    "@itwin/eslint-plugin": "3.7.0-dev.2",
     "@opentelemetry/api": "1.0.4",
     "@types/chai": "4.3.1",
     "@types/chai-as-promised": "^7",