@itwin/components-react 3.7.17 → 3.8.0

package/lib/esm/components-react/tree/controlled/internal/SparseTree.d.ts

@@ -1,74 +1,74 @@
-/** @packageDocumentation
- * @module Tree
- */
-import { immerable } from "immer";
-/** @internal */
-export interface Node {
-    readonly id: string;
-}
-/**
- * Structure for sparse tree storage.
- * It uses SparseArray to store children ids for parent. This allows
- * having tree structure with some nodes missing in the tree branch.
- * @internal
- */
-export declare class SparseTree<T extends Node> {
-    [immerable]: boolean;
-    private _rootNodes;
-    private _parentToChildren;
-    private _idToNode;
-    constructor();
-    getNode(nodeId: string): T | undefined;
-    getChildOffset(parentId: string | undefined, childId: string): number | undefined;
-    getChildren(parentId: string | undefined, createIfNotExist?: boolean): SparseArray<string> | undefined;
-    setChildren(parentId: string | undefined, children: T[], offset: number): void;
-    insertChild(parentId: string | undefined, child: T, offset: number): void;
-    setNodeId(parentId: string | undefined, index: number, newId: string): boolean;
-    moveNode(sourceParentId: string | undefined, sourceNodeId: string, targetParentId: string | undefined, targetIndex: number): void;
-    setNumChildren(parentId: string | undefined, numChildren: number): void;
-    removeChild(parentId: string | undefined, child: string | number): void;
-    deleteSubtree(parentId: string | undefined, deleteParent?: boolean): void;
-}
-/**
- * Structure for sparse array value storage.
- * The main advantage of this class over the standard javascript array is that
- * this class does not need to check each index when iterating values that are
- * stored in the array.
- * @public
- */
-export declare class SparseArray<T> implements Iterable<T | undefined> {
-    [immerable]: boolean;
-    private _length;
-    private _array;
-    constructor();
-    /** Returns length of array including intermediate 'undefined' values */
-    getLength(): number;
-    /** Sets length of array. */
-    setLength(length: number): void;
-    /** Returns index of supplied value.
-     *
-     * @returns index of value or undefined if value is not found.
-     */
-    getIndex(lookupValue: T): number | undefined;
-    /** Returns value at specific position.
-     *
-     * @returns stored value or undefined.
-     */
-    get(index: number): T | undefined;
-    /** Sets value at specific position. Overrides any existing value. */
-    set(index: number, value: T): void;
-    /** Inserts value at specific position. Increases array length by one. */
-    insert(index: number, value: T): void;
-    /** Removes value at specified index and reduces array length by one. */
-    remove(index: number): void;
-    /**
-     * Iterates values that are stored in the array
-     * @returns `[value, index]` tuples.
-     */
-    iterateValues(): IterableIterator<[T, number]>;
-    /** Iterates the array with all intermediate `undefined` values */
-    [Symbol.iterator](): IterableIterator<T | undefined>;
-    private lowerBound;
-    private static compare;
-}
+/** @packageDocumentation
+ * @module Tree
+ */
+import { immerable } from "immer";
+/** @internal */
+export interface Node {
+    readonly id: string;
+}
+/**
+ * Structure for sparse tree storage.
+ * It uses SparseArray to store children ids for parent. This allows
+ * having tree structure with some nodes missing in the tree branch.
+ * @internal
+ */
+export declare class SparseTree<T extends Node> {
+    [immerable]: boolean;
+    private _rootNodes;
+    private _parentToChildren;
+    private _idToNode;
+    constructor();
+    getNode(nodeId: string): T | undefined;
+    getChildOffset(parentId: string | undefined, childId: string): number | undefined;
+    getChildren(parentId: string | undefined, createIfNotExist?: boolean): SparseArray<string> | undefined;
+    setChildren(parentId: string | undefined, children: T[], offset: number): void;
+    insertChild(parentId: string | undefined, child: T, offset: number): void;
+    setNodeId(parentId: string | undefined, index: number, newId: string): boolean;
+    moveNode(sourceParentId: string | undefined, sourceNodeId: string, targetParentId: string | undefined, targetIndex: number): void;
+    setNumChildren(parentId: string | undefined, numChildren: number): void;
+    removeChild(parentId: string | undefined, child: string | number): void;
+    deleteSubtree(parentId: string | undefined, deleteParent?: boolean): void;
+}
+/**
+ * Structure for sparse array value storage.
+ * The main advantage of this class over the standard javascript array is that
+ * this class does not need to check each index when iterating values that are
+ * stored in the array.
+ * @public
+ */
+export declare class SparseArray<T> implements Iterable<T | undefined> {
+    [immerable]: boolean;
+    private _length;
+    private _array;
+    constructor();
+    /** Returns length of array including intermediate 'undefined' values */
+    getLength(): number;
+    /** Sets length of array. */
+    setLength(length: number): void;
+    /** Returns index of supplied value.
+     *
+     * @returns index of value or undefined if value is not found.
+     */
+    getIndex(lookupValue: T): number | undefined;
+    /** Returns value at specific position.
+     *
+     * @returns stored value or undefined.
+     */
+    get(index: number): T | undefined;
+    /** Sets value at specific position. Overrides any existing value. */
+    set(index: number, value: T): void;
+    /** Inserts value at specific position. Increases array length by one. */
+    insert(index: number, value: T): void;
+    /** Removes value at specified index and reduces array length by one. */
+    remove(index: number): void;
+    /**
+     * Iterates values that are stored in the array
+     * @returns `[value, index]` tuples.
+     */
+    iterateValues(): IterableIterator<[T, number]>;
+    /** Iterates the array with all intermediate `undefined` values */
+    [Symbol.iterator](): IterableIterator<T | undefined>;
+    private lowerBound;
+    private static compare;
+}
 //# sourceMappingURL=SparseTree.d.ts.map

package/lib/esm/components-react/tree/controlled/internal/SparseTree.js

@@ -1,238 +1,238 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Tree
- */
-import { immerable } from "immer";
-import { assert, compareNumbers, lowerBound } from "@itwin/core-bentley";
-/**
- * Structure for sparse tree storage.
- * It uses SparseArray to store children ids for parent. This allows
- * having tree structure with some nodes missing in the tree branch.
- * @internal
- */
-export class SparseTree {
-    constructor() {
-        this._rootNodes = new SparseArray();
-        this._parentToChildren = {};
-        this._idToNode = {};
-        this[immerable] = true;
-    }
-    getNode(nodeId) {
-        return this._idToNode[nodeId];
-    }
-    getChildOffset(parentId, childId) {
-        const children = this.getChildren(parentId);
-        if (!children)
-            return undefined;
-        return children.getIndex(childId);
-    }
-    getChildren(parentId, createIfNotExist = false) {
-        if (parentId === undefined) {
-            return this._rootNodes;
-        }
-        if (this._parentToChildren[parentId] === undefined && createIfNotExist) {
-            this._parentToChildren[parentId] = new SparseArray();
-        }
-        return this._parentToChildren[parentId];
-    }
-    setChildren(parentId, children, offset) {
-        const existingChildren = this.getChildren(parentId, true);
-        children.forEach((child, index) => {
-            const existingChildId = existingChildren.get(offset + index);
-            if (existingChildId !== undefined) {
-                this.deleteSubtree(existingChildId);
-            }
-            existingChildren.set(offset + index, child.id);
-            this._idToNode[child.id] = child;
-        });
-    }
-    insertChild(parentId, child, offset) {
-        const existingChildren = this.getChildren(parentId, true);
-        existingChildren.insert(offset, child.id);
-        this._idToNode[child.id] = child;
-    }
-    setNodeId(parentId, index, newId) {
-        var _a;
-        const previousNodeId = (_a = this.getChildren(parentId)) === null || _a === void 0 ? void 0 : _a.get(index);
-        if (previousNodeId === undefined) {
-            return false;
-        }
-        if (previousNodeId === newId) {
-            return true;
-        }
-        if (this.getNode(newId) !== undefined) {
-            return false;
-        }
-        this._idToNode[newId] = this._idToNode[previousNodeId];
-        delete this._idToNode[previousNodeId];
-        this._parentToChildren[newId] = this._parentToChildren[previousNodeId];
-        delete this._parentToChildren[previousNodeId];
-        if (parentId === undefined) {
-            this._rootNodes.set(index, newId);
-        }
-        else {
-            this._parentToChildren[parentId].set(index, newId);
-        }
-        return true;
-    }
-    moveNode(sourceParentId, sourceNodeId, targetParentId, targetIndex) {
-        const sourceNodeSiblings = this.getChildren(sourceParentId);
-        assert(sourceNodeSiblings !== undefined);
-        const sourceIndex = this.getChildOffset(sourceParentId, sourceNodeId);
-        assert(sourceIndex !== undefined);
-        sourceNodeSiblings.remove(sourceIndex);
-        if (targetParentId === sourceParentId && targetIndex > sourceIndex) {
-            targetIndex -= 1;
-        }
-        const targetNodeSiblings = this.getChildren(targetParentId, true);
-        assert(targetNodeSiblings !== undefined);
-        targetNodeSiblings.insert(targetIndex, sourceNodeId);
-    }
-    setNumChildren(parentId, numChildren) {
-        const children = this.getChildren(parentId, true);
-        for (const [childId] of children.iterateValues()) {
-            this.deleteSubtree(childId);
-        }
-        children.setLength(numChildren);
-    }
-    removeChild(parentId, child) {
-        const children = this.getChildren(parentId);
-        if (children === undefined)
-            return;
-        if (typeof child === "string") {
-            const childIndex = children.getIndex(child);
-            if (childIndex !== undefined) {
-                children.remove(childIndex);
-            }
-            this.deleteSubtree(child);
-        }
-        else {
-            const childId = children.get(child);
-            children.remove(child);
-            if (childId !== undefined) {
-                this.deleteSubtree(childId);
-            }
-        }
-    }
-    deleteSubtree(parentId, deleteParent = true) {
-        const children = this.getChildren(parentId);
-        if (children !== undefined) {
-            for (const [childId] of children.iterateValues()) {
-                this.deleteSubtree(childId);
-            }
-        }
-        if (parentId === undefined) {
-            this._rootNodes.setLength(0);
-            return;
-        }
-        if (deleteParent) {
-            delete this._idToNode[parentId];
-        }
-        delete this._parentToChildren[parentId];
-    }
-}
-/**
- * Structure for sparse array value storage.
- * The main advantage of this class over the standard javascript array is that
- * this class does not need to check each index when iterating values that are
- * stored in the array.
- * @public
- */
-export class SparseArray {
-    constructor() {
-        this._length = 0;
-        this._array = [];
-        this[immerable] = true;
-    }
-    /** Returns length of array including intermediate 'undefined' values */
-    getLength() {
-        return this._length;
-    }
-    /** Sets length of array. */
-    setLength(length) {
-        const { index } = this.lowerBound(length);
-        this._array.length = index;
-        this._length = length;
-    }
-    /** Returns index of supplied value.
-     *
-     * @returns index of value or undefined if value is not found.
-     */
-    getIndex(lookupValue) {
-        for (const [value, index] of this._array) {
-            if (value === lookupValue)
-                return index;
-        }
-        return undefined;
-    }
-    /** Returns value at specific position.
-     *
-     * @returns stored value or undefined.
-     */
-    get(index) {
-        const { index: i, equal } = this.lowerBound(index);
-        return equal ? this._array[i][0] : undefined;
-    }
-    /** Sets value at specific position. Overrides any existing value. */
-    set(index, value) {
-        const { index: i, equal } = this.lowerBound(index);
-        this._array.splice(i, equal ? 1 : 0, [value, index]);
-        this._length = Math.max(this._length, index + 1);
-    }
-    /** Inserts value at specific position. Increases array length by one. */
-    insert(index, value) {
-        const { index: i } = this.lowerBound(index);
-        this._array.splice(i, 0, [value, index]);
-        for (let j = i + 1; j < this._array.length; j++) {
-            this._array[j][1]++;
-        }
-        this._length = Math.max(this._length + 1, index + 1);
-    }
-    /** Removes value at specified index and reduces array length by one. */
-    remove(index) {
-        if (index >= this._length) {
-            return;
-        }
-        const { index: i, equal } = this.lowerBound(index);
-        this._array.splice(i, equal ? 1 : 0);
-        for (let j = i; j < this._array.length; j++) {
-            this._array[j][1]--;
-        }
-        this._length = Math.max(0, this._length - 1);
-    }
-    /**
-     * Iterates values that are stored in the array
-     * @returns `[value, index]` tuples.
-     */
-    iterateValues() {
-        return this._array[Symbol.iterator]();
-    }
-    /** Iterates the array with all intermediate `undefined` values */
-    [Symbol.iterator]() {
-        const array = this._array;
-        const length = this._length;
-        return (function* () {
-            let currentIndex = 0;
-            for (const [value, index] of array) {
-                for (; currentIndex < index; ++currentIndex) {
-                    yield undefined;
-                }
-                yield value;
-                ++currentIndex;
-            }
-            for (; currentIndex < length; ++currentIndex) {
-                yield undefined;
-            }
-        })();
-    }
-    lowerBound(index) {
-        return lowerBound(index, this._array, SparseArray.compare);
-    }
-    static compare(index, value) {
-        return compareNumbers(index, value[1]);
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Tree
+ */
+import { immerable } from "immer";
+import { assert, compareNumbers, lowerBound } from "@itwin/core-bentley";
+/**
+ * Structure for sparse tree storage.
+ * It uses SparseArray to store children ids for parent. This allows
+ * having tree structure with some nodes missing in the tree branch.
+ * @internal
+ */
+export class SparseTree {
+    constructor() {
+        this._rootNodes = new SparseArray();
+        this._parentToChildren = {};
+        this._idToNode = {};
+        this[immerable] = true;
+    }
+    getNode(nodeId) {
+        return this._idToNode[nodeId];
+    }
+    getChildOffset(parentId, childId) {
+        const children = this.getChildren(parentId);
+        if (!children)
+            return undefined;
+        return children.getIndex(childId);
+    }
+    getChildren(parentId, createIfNotExist = false) {
+        if (parentId === undefined) {
+            return this._rootNodes;
+        }
+        if (this._parentToChildren[parentId] === undefined && createIfNotExist) {
+            this._parentToChildren[parentId] = new SparseArray();
+        }
+        return this._parentToChildren[parentId];
+    }
+    setChildren(parentId, children, offset) {
+        const existingChildren = this.getChildren(parentId, true);
+        children.forEach((child, index) => {
+            const existingChildId = existingChildren.get(offset + index);
+            if (existingChildId !== undefined) {
+                this.deleteSubtree(existingChildId);
+            }
+            existingChildren.set(offset + index, child.id);
+            this._idToNode[child.id] = child;
+        });
+    }
+    insertChild(parentId, child, offset) {
+        const existingChildren = this.getChildren(parentId, true);
+        existingChildren.insert(offset, child.id);
+        this._idToNode[child.id] = child;
+    }
+    setNodeId(parentId, index, newId) {
+        var _a;
+        const previousNodeId = (_a = this.getChildren(parentId)) === null || _a === void 0 ? void 0 : _a.get(index);
+        if (previousNodeId === undefined) {
+            return false;
+        }
+        if (previousNodeId === newId) {
+            return true;
+        }
+        if (this.getNode(newId) !== undefined) {
+            return false;
+        }
+        this._idToNode[newId] = this._idToNode[previousNodeId];
+        delete this._idToNode[previousNodeId];
+        this._parentToChildren[newId] = this._parentToChildren[previousNodeId];
+        delete this._parentToChildren[previousNodeId];
+        if (parentId === undefined) {
+            this._rootNodes.set(index, newId);
+        }
+        else {
+            this._parentToChildren[parentId].set(index, newId);
+        }
+        return true;
+    }
+    moveNode(sourceParentId, sourceNodeId, targetParentId, targetIndex) {
+        const sourceNodeSiblings = this.getChildren(sourceParentId);
+        assert(sourceNodeSiblings !== undefined);
+        const sourceIndex = this.getChildOffset(sourceParentId, sourceNodeId);
+        assert(sourceIndex !== undefined);
+        sourceNodeSiblings.remove(sourceIndex);
+        if (targetParentId === sourceParentId && targetIndex > sourceIndex) {
+            targetIndex -= 1;
+        }
+        const targetNodeSiblings = this.getChildren(targetParentId, true);
+        assert(targetNodeSiblings !== undefined);
+        targetNodeSiblings.insert(targetIndex, sourceNodeId);
+    }
+    setNumChildren(parentId, numChildren) {
+        const children = this.getChildren(parentId, true);
+        for (const [childId] of children.iterateValues()) {
+            this.deleteSubtree(childId);
+        }
+        children.setLength(numChildren);
+    }
+    removeChild(parentId, child) {
+        const children = this.getChildren(parentId);
+        if (children === undefined)
+            return;
+        if (typeof child === "string") {
+            const childIndex = children.getIndex(child);
+            if (childIndex !== undefined) {
+                children.remove(childIndex);
+            }
+            this.deleteSubtree(child);
+        }
+        else {
+            const childId = children.get(child);
+            children.remove(child);
+            if (childId !== undefined) {
+                this.deleteSubtree(childId);
+            }
+        }
+    }
+    deleteSubtree(parentId, deleteParent = true) {
+        const children = this.getChildren(parentId);
+        if (children !== undefined) {
+            for (const [childId] of children.iterateValues()) {
+                this.deleteSubtree(childId);
+            }
+        }
+        if (parentId === undefined) {
+            this._rootNodes.setLength(0);
+            return;
+        }
+        if (deleteParent) {
+            delete this._idToNode[parentId];
+        }
+        delete this._parentToChildren[parentId];
+    }
+}
+/**
+ * Structure for sparse array value storage.
+ * The main advantage of this class over the standard javascript array is that
+ * this class does not need to check each index when iterating values that are
+ * stored in the array.
+ * @public
+ */
+export class SparseArray {
+    constructor() {
+        this._length = 0;
+        this._array = [];
+        this[immerable] = true;
+    }
+    /** Returns length of array including intermediate 'undefined' values */
+    getLength() {
+        return this._length;
+    }
+    /** Sets length of array. */
+    setLength(length) {
+        const { index } = this.lowerBound(length);
+        this._array.length = index;
+        this._length = length;
+    }
+    /** Returns index of supplied value.
+     *
+     * @returns index of value or undefined if value is not found.
+     */
+    getIndex(lookupValue) {
+        for (const [value, index] of this._array) {
+            if (value === lookupValue)
+                return index;
+        }
+        return undefined;
+    }
+    /** Returns value at specific position.
+     *
+     * @returns stored value or undefined.
+     */
+    get(index) {
+        const { index: i, equal } = this.lowerBound(index);
+        return equal ? this._array[i][0] : undefined;
+    }
+    /** Sets value at specific position. Overrides any existing value. */
+    set(index, value) {
+        const { index: i, equal } = this.lowerBound(index);
+        this._array.splice(i, equal ? 1 : 0, [value, index]);
+        this._length = Math.max(this._length, index + 1);
+    }
+    /** Inserts value at specific position. Increases array length by one. */
+    insert(index, value) {
+        const { index: i } = this.lowerBound(index);
+        this._array.splice(i, 0, [value, index]);
+        for (let j = i + 1; j < this._array.length; j++) {
+            this._array[j][1]++;
+        }
+        this._length = Math.max(this._length + 1, index + 1);
+    }
+    /** Removes value at specified index and reduces array length by one. */
+    remove(index) {
+        if (index >= this._length) {
+            return;
+        }
+        const { index: i, equal } = this.lowerBound(index);
+        this._array.splice(i, equal ? 1 : 0);
+        for (let j = i; j < this._array.length; j++) {
+            this._array[j][1]--;
+        }
+        this._length = Math.max(0, this._length - 1);
+    }
+    /**
+     * Iterates values that are stored in the array
+     * @returns `[value, index]` tuples.
+     */
+    iterateValues() {
+        return this._array[Symbol.iterator]();
+    }
+    /** Iterates the array with all intermediate `undefined` values */
+    [Symbol.iterator]() {
+        const array = this._array;
+        const length = this._length;
+        return (function* () {
+            let currentIndex = 0;
+            for (const [value, index] of array) {
+                for (; currentIndex < index; ++currentIndex) {
+                    yield undefined;
+                }
+                yield value;
+                ++currentIndex;
+            }
+            for (; currentIndex < length; ++currentIndex) {
+                yield undefined;
+            }
+        })();
+    }
+    lowerBound(index) {
+        return lowerBound(index, this._array, SparseArray.compare);
+    }
+    static compare(index, value) {
+        return compareNumbers(index, value[1]);
+    }
+}
 //# sourceMappingURL=SparseTree.js.map