@cloudscape-design/board-components 3.0.30 → 3.0.32

package/internal/layout-engine/engine.js

@@ -1,97 +1,105 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { Position } from "../utils/position";
-import { LayoutEngineStepState, refloatGrid, resolveOverlaps } from "./engine-step";
+import { LayoutEngineCacheNode } from "./engine-cache";
+import { LayoutEngineState } from "./engine-state";
+import { resolveOverlaps } from "./engine-step";
 import { LayoutEngineGrid } from "./grid";
-import { normalizeMovePath, normalizeResizePath, sortGridItems } from "./utils";
+import { createMove, normalizeMovePath, normalizeResizePath, sortGridItems } from "./utils";
+/**
+ * Layout engine is an abstraction to compute effects of user actions (move, resize, insert, remove).
+ * The engine is initialized with the board state and then takes a command to calculate the respective layout shift.
+ * Use a single engine instance until the user commits their move to take advantage of the internal cache.
+ * Once user move is committed the layout engine needs to be re-initialized with the updated layout state.
+ */
 export class LayoutEngine {
-    constructor(args) {
-        this.chained = false;
-        if (args instanceof LayoutEngine) {
-            this.current = args.current;
-            this.step = args.step;
-            this.chained = true;
-        }
-        else {
-            this.current = args;
-            this.step = new LayoutEngineStepState(new LayoutEngineGrid(args.items, args.columns));
-        }
+    constructor(layout) {
+        this.layout = layout;
+        this.cache = new LayoutEngineCacheNode(new LayoutEngineState(new LayoutEngineGrid(layout.items, layout.columns)));
     }
-    move(moveCommand) {
-        this.cleanup();
-        const { itemId, path } = this.validateMoveCommand(moveCommand);
+    move(moveCommand, cache = this.cache) {
+        // The validation ensures no position in the path is outside the board and updates the path so that all
+        // positions are incremental (moving one cell at a time) and no loops are present (no position can occur twice).
+        // Removing the loops guarantees that moving back to one of the previous positions including the starting one
+        // revives the previous state as is. The same behavior might cause confusion in case the user comes back
+        // to a previous position accidentally especially if the move path is long.
+        const path = this.validateMovePath({ ...moveCommand }, cache.state);
+        // The user command is resolved one step at a time. When layout engine is reused withing one transition
+        // it is expected that all steps but the last one are already cached.
         for (let stepIndex = 0; stepIndex < path.length; stepIndex++) {
-            const step = path[stepIndex];
-            const { width, height } = this.step.grid.getItem(itemId);
-            const move = { itemId, x: step.x, y: step.y, width, height, type: "MOVE" };
-            this.step = resolveOverlaps(move, this.step);
+            const item = cache.state.grid.getItem(moveCommand.itemId);
+            const move = createMove("MOVE", item, path[stepIndex]);
+            cache = cache.matches(path[stepIndex], () => resolveOverlaps(cache.state, move));
         }
-        return new LayoutEngine(this);
+        return this.getLayoutShift(cache.state);
     }
-    resize(resize) {
-        this.cleanup();
-        const { itemId, path } = this.validateResizeCommand(resize);
-        const resizeTarget = this.step.grid.getItem(itemId);
+    resize(resizeCommand) {
+        // The validation ensures no position in the path is outside the board and the width/height are above 0.
+        // The resize path is updated so that all positions are incremental (moving one cell at a time) and
+        // no loops are present (no position can occur twice).
+        // Removing the loops guarantees that moving back to one of the previous positions including the starting one
+        // revives the previous state as is. The same behavior might cause confusion in case the user comes back
+        // to a previous position accidentally especially if the move path is long.
+        const path = this.validateResizePath(resizeCommand, this.cache.state);
+        // The user command is resolved one step at a time. When layout engine is reused withing one transition
+        // it is expected that all steps but the last one are already cached.
+        let cache = this.cache;
         for (let stepIndex = 0; stepIndex < path.length; stepIndex++) {
+            const resizeTarget = cache.state.grid.getItem(resizeCommand.itemId);
             const width = path[stepIndex].x - resizeTarget.x;
             const height = path[stepIndex].y - resizeTarget.y;
-            this.step = resolveOverlaps({ itemId, x: resizeTarget.x, y: resizeTarget.y, width, height, type: "RESIZE" }, this.step);
+            const move = createMove("RESIZE", resizeTarget, new Position({ x: width, y: height }));
+            cache = cache.matches(path[stepIndex], () => resolveOverlaps(cache.state, move));
         }
-        return new LayoutEngine(this);
+        return this.getLayoutShift(cache.state);
     }
-    insert({ itemId, width, height, path: [position, ...path] }) {
-        this.cleanup();
-        this.step = resolveOverlaps({ itemId, ...position, width, height, type: "INSERT" }, this.step);
-        return new LayoutEngine(this).move({ itemId, path });
+    insert({ itemId, width, height, path: [position, ...movePath] }) {
+        // For insert command the new item is injected to the given location first and then it can be moved
+        // the same way as the existing item would.
+        const insertMove = createMove("INSERT", { id: itemId, x: position.x, y: position.y, width, height }, position);
+        const cache = this.cache.matches(position, () => resolveOverlaps(this.cache.state, insertMove));
+        return this.move({ itemId, path: movePath }, cache);
     }
     remove(itemId) {
-        this.cleanup();
-        const { x, y, width, height } = this.step.grid.getItem(itemId);
-        this.step = resolveOverlaps({ itemId, x, y, width, height, type: "REMOVE" }, this.step);
-        return new LayoutEngine(this);
-    }
-    refloat() {
-        this.step = refloatGrid(this.step);
-        return new LayoutEngine(this);
+        // The remove command does not define the move path and is not cached. It is expected to be performed only once.
+        const { x, y, width, height } = this.cache.state.grid.getItem(itemId);
+        const move = createMove("REMOVE", { id: itemId, x, y, width, height }, new Position({ x, y }));
+        const state = resolveOverlaps(this.cache.state, move);
+        return this.getLayoutShift(state);
     }
-    getLayoutShift() {
+    getLayoutShift(state) {
         return {
-            current: this.current,
+            current: this.layout,
             next: {
-                items: sortGridItems(this.step.grid.items.map((item) => ({ ...item }))),
-                columns: this.step.grid.width,
-                rows: this.step.grid.height,
+                items: sortGridItems(state.grid.items),
+                columns: state.grid.width,
+                rows: state.grid.height,
             },
-            moves: [...this.step.moves],
-            conflicts: [...this.step.conflicts],
+            moves: state.moves,
+            conflicts: state.conflicts ? [...state.conflicts.items] : [],
         };
     }
-    cleanup() {
-        if (!this.chained) {
-            this.step = new LayoutEngineStepState(new LayoutEngineGrid(this.current.items, this.current.columns));
-        }
-    }
-    validateMoveCommand({ itemId, path }) {
-        const moveTarget = this.step.grid.getItem(itemId);
+    validateMovePath({ itemId, path }, state) {
+        const moveTarget = state.grid.getItem(itemId);
         for (const step of path) {
-            if (step.x < 0 || step.y < 0 || step.x + moveTarget.width > this.step.grid.width) {
+            if (step.x < 0 || step.y < 0 || step.x + moveTarget.width > state.grid.width) {
                 throw new Error("Invalid move: outside grid.");
             }
         }
-        return { itemId, path: normalizeMovePath(new Position({ x: moveTarget.x, y: moveTarget.y }), path) };
+        return normalizeMovePath(new Position({ x: moveTarget.x, y: moveTarget.y }), path);
     }
-    validateResizeCommand({ itemId, path }) {
-        const resizeTarget = this.step.grid.getItem(itemId);
+    validateResizePath({ itemId, path }, state) {
+        const resizeTarget = state.grid.getItem(itemId);
         const x = resizeTarget.x + resizeTarget.width;
         const y = resizeTarget.y + resizeTarget.height;
         for (const step of path) {
             if (step.x < 1 || step.y < 1) {
                 throw new Error("Invalid resize: can't resize to 0.");
             }
-            if (step.x > this.step.grid.width) {
+            if (step.x > state.grid.width) {
                 throw new Error("Invalid resize: outside grid.");
             }
         }
-        return { itemId, path: normalizeResizePath(new Position({ x, y }), path) };
+        return normalizeResizePath(new Position({ x, y }), path);
     }
 }

package/internal/layout-engine/grid.d.ts

@@ -1,31 +1,20 @@
 import { GridLayoutItem, ItemId } from "../interfaces";
-import { Rect } from "./utils";
-export interface LayoutEngineItem extends GridLayoutItem, Rect {
-    originalX: number;
-    originalY: number;
-    originalWidth: number;
-    originalHeight: number;
-}
 export declare class ReadonlyLayoutEngineGrid {
     protected _width: number;
     protected _height: number;
-    protected _items: Map<string, LayoutEngineItem>;
-    protected _layout: Set<ItemId>[][];
+    protected _items: GridLayoutItem[];
+    protected _itemsMap: Map<string, GridLayoutItem>;
     static clone(grid: ReadonlyLayoutEngineGrid): LayoutEngineGrid;
     constructor(items: readonly GridLayoutItem[], columns: number);
     get width(): number;
     get height(): number;
-    get items(): LayoutEngineItem[];
-    getItem(itemId: ItemId): LayoutEngineItem;
-    getCell(x: number, y: number): LayoutEngineItem[];
-    getCellOverlap(x: number, y: number, itemId: ItemId): null | LayoutEngineItem;
-    protected makeNewRow(): void;
+    get items(): GridLayoutItem[];
+    getItem(itemId: ItemId): GridLayoutItem;
+    getOverlaps(item: GridLayoutItem): GridLayoutItem[];
 }
 export declare class LayoutEngineGrid extends ReadonlyLayoutEngineGrid {
-    move(itemId: ItemId, x: number, y: number, onOverlap?: (overlapId: ItemId) => void): void;
-    resize(itemId: ItemId, width: number, height: number, onOverlap?: (overlapId: ItemId) => void): void;
-    insert(item: GridLayoutItem, onOverlap: (overlapId: ItemId) => void): void;
+    move(itemId: ItemId, x: number, y: number): void;
+    resize(itemId: ItemId, width: number, height: number): void;
+    insert(item: GridLayoutItem): void;
     remove(itemId: ItemId): void;
-    private removeLayoutItem;
-    private insertLayoutItem;
 }

package/internal/layout-engine/grid.js

@@ -1,46 +1,39 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { getItemRect } from "./utils";
+import { checkItemsIntersection } from "./utils";
 export class ReadonlyLayoutEngineGrid {
     static clone(grid) {
         const clone = new LayoutEngineGrid([], 0);
         clone._width = grid._width;
         clone._height = grid._height;
-        clone._items = new Map([...grid._items].map(([k, v]) => [k, { ...v }]));
-        clone._layout = grid._layout.map((row) => row.map((set) => new Set([...set])));
+        for (const item of grid._items) {
+            const itemClone = { ...item };
+            clone._itemsMap.set(itemClone.id, itemClone);
+            clone._items.push(itemClone);
+        }
         return clone;
     }
     constructor(items, columns) {
-        this._items = new Map();
-        this._layout = [];
+        this._items = new Array();
+        this._itemsMap = new Map();
         this._width = columns;
         this._height = 0;
         for (const item of items) {
-            this._items.set(item.id, {
-                ...item,
-                originalY: item.y,
-                originalX: item.x,
-                originalWidth: item.width,
-                originalHeight: item.height,
-                ...getItemRect(item),
-            });
             if (item.x < 0 || item.y < 0 || item.x + item.width > this._width) {
                 throw new Error("Invalid grid: items outside the boundaries.");
             }
             if (item.width < 1 || item.height < 1) {
                 throw new Error("Invalid grid: items of invalid size.");
             }
-            for (let y = item.y; y < item.y + item.height; y++) {
-                while (this._layout.length <= y) {
-                    this.makeNewRow();
-                }
-                for (let x = item.x; x < item.x + item.width; x++) {
-                    this._layout[y][x].add(item.id);
-                    if (this._layout[y][x].size > 1) {
-                        throw new Error("Invalid grid: items overlap.");
-                    }
+            for (const gridItem of this._items) {
+                if (checkItemsIntersection(gridItem, item)) {
+                    throw new Error("Invalid grid: items overlap.");
                 }
             }
+            const itemClone = { ...item };
+            this._itemsMap.set(itemClone.id, itemClone);
+            this._items.push(itemClone);
+            this._height = Math.max(this.height, itemClone.y + itemClone.height);
         }
     }
     get width() {
@@ -50,101 +43,46 @@ export class ReadonlyLayoutEngineGrid {
         return this._height;
     }
     get items() {
-        return [...this._items.values()];
+        return this._items;
     }
     getItem(itemId) {
-        const item = this._items.get(itemId);
+        const item = this._itemsMap.get(itemId);
         if (!item) {
             throw new Error(`Item with id "${itemId}" not found in the grid.`);
         }
         return item;
     }
-    getCell(x, y) {
-        if (!this._layout[y] || !this._layout[y][x]) {
-            return [];
-        }
-        return [...this._layout[y][x]].map((itemId) => this.getItem(itemId));
-    }
-    getCellOverlap(x, y, itemId) {
-        for (const item of this.getCell(x, y)) {
-            if (item.id !== itemId) {
-                return item;
-            }
-        }
-        return null;
-    }
-    makeNewRow() {
-        this._layout.push([...Array(this._width)].map(() => new Set()));
-        this._height = this._layout.length;
+    getOverlaps(item) {
+        return this._items.filter((gridItem) => checkItemsIntersection(gridItem, item));
     }
 }
 export class LayoutEngineGrid extends ReadonlyLayoutEngineGrid {
-    move(itemId, x, y, onOverlap) {
-        const moveTarget = this.getItem(itemId);
-        this.removeLayoutItem(moveTarget);
-        moveTarget.x = x;
-        moveTarget.y = y;
-        Object.assign(moveTarget, getItemRect(moveTarget));
-        this.insertLayoutItem(moveTarget, onOverlap);
+    move(itemId, x, y) {
+        const item = this.getItem(itemId);
+        item.x = x;
+        item.y = y;
+        this._height = Math.max(this.height, item.y + item.height);
     }
-    resize(itemId, width, height, onOverlap) {
-        const resizeTarget = this.getItem(itemId);
-        this.removeLayoutItem(resizeTarget);
-        resizeTarget.width = width;
-        resizeTarget.height = height;
-        Object.assign(resizeTarget, getItemRect(resizeTarget));
-        this.insertLayoutItem(resizeTarget, onOverlap);
+    resize(itemId, width, height) {
+        const item = this.getItem(itemId);
+        item.width = width;
+        item.height = height;
+        this._height = Math.max(this.height, item.y + item.height);
     }
-    insert(item, onOverlap) {
-        this._items.set(item.id, {
-            ...item,
-            originalY: item.y,
-            originalX: item.x,
-            originalWidth: item.width,
-            originalHeight: item.height,
-            ...getItemRect(item),
-        });
+    insert(item) {
         if (item.x < 0 || item.y < 0 || item.x + item.width > this._width) {
             throw new Error("Inserting item is outside the boundaries.");
         }
         if (item.width < 1 || item.height < 1) {
             throw new Error("Inserting item has invalid size.");
         }
-        for (let y = item.y; y < item.y + item.height; y++) {
-            while (this._layout.length <= y) {
-                this.makeNewRow();
-            }
-            for (let x = item.x; x < item.x + item.width; x++) {
-                for (const overlapId of this._layout[y][x]) {
-                    onOverlap(overlapId);
-                }
-                this._layout[y][x].add(item.id);
-            }
-        }
+        const itemClone = { ...item };
+        this._itemsMap.set(itemClone.id, itemClone);
+        this._items.push(itemClone);
+        this._height = Math.max(this.height, item.y + item.height);
     }
     remove(itemId) {
-        const removeTarget = this.getItem(itemId);
-        this._items.delete(itemId);
-        this.removeLayoutItem(removeTarget);
-    }
-    removeLayoutItem(item) {
-        for (let y = item.y; y < item.y + item.height; y++) {
-            for (let x = item.x; x < item.x + item.width; x++) {
-                this._layout[y][x].delete(item.id);
-            }
-        }
-    }
-    insertLayoutItem(item, onOverlap) {
-        for (let y = item.y; y < item.y + item.height; y++) {
-            for (let x = item.x; x < item.x + item.width; x++) {
-                while (!this._layout[y]) {
-                    this.makeNewRow();
-                }
-                for (const overlapId of this._layout[y][x]) {
-                    onOverlap === null || onOverlap === void 0 ? void 0 : onOverlap(overlapId);
-                }
-                this._layout[y][x].add(item.id);
-            }
-        }
+        this._itemsMap.delete(itemId);
+        this._items = this._items.filter((item) => item.id !== itemId);
     }
 }

package/internal/layout-engine/interfaces.d.ts

@@ -1,4 +1,4 @@
-import { GridLayout, ItemId } from "../interfaces";
+import { Direction, GridLayout, ItemId } from "../interfaces";
 import { Position } from "../utils/position";
 export interface MoveCommand {
     itemId: ItemId;
@@ -20,7 +20,11 @@ export interface CommittedMove {
     y: number;
     width: number;
     height: number;
-    type: "MOVE" | "VACANT" | "PRIORITY" | "ESCAPE" | "FLOAT" | "RESIZE" | "INSERT" | "REMOVE";
+    type: "MOVE" | "RESIZE" | "INSERT" | "REMOVE" | "OVERLAP" | "FLOAT";
+    direction: Direction;
+    distanceX: number;
+    distanceY: number;
+    score: number;
 }
 export interface LayoutShift {
     current: GridLayout;

package/internal/layout-engine/utils.d.ts

@@ -1,12 +1,17 @@
-import { GridLayoutItem } from "../interfaces";
+import { Direction, GridLayoutItem } from "../interfaces";
 import { Position } from "../utils/position";
+import { CommittedMove } from "./interfaces";
 export interface Rect {
     left: number;
     right: number;
     top: number;
     bottom: number;
 }
-export declare function sortGridItems(items: readonly GridLayoutItem[]): readonly GridLayoutItem[];
-export declare function getItemRect(item: GridLayoutItem): Rect;
+export declare function sortGridItems(items: GridLayoutItem[]): readonly GridLayoutItem[];
 export declare function normalizeMovePath(origin: Position, path: readonly Position[]): readonly Position[];
 export declare function normalizeResizePath(origin: Position, path: readonly Position[]): readonly Position[];
+export declare function createMove(type: CommittedMove["type"], item: GridLayoutItem, next: Position, score?: number): CommittedMove;
+export declare function getMoveOriginalRect(move: CommittedMove): Rect;
+export declare function getMoveRect(move: CommittedMove): Rect;
+export declare function checkItemsIntersection(i1: GridLayoutItem, i2: GridLayoutItem): boolean;
+export declare function checkOppositeDirections(d1: Direction, d2: Direction): boolean;

package/internal/layout-engine/utils.js

@@ -2,15 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import { Position } from "../utils/position";
 export function sortGridItems(items) {
-    return [...items].sort((a, b) => (b.y - a.y === 0 ? b.x - a.x : b.y - a.y));
-}
-export function getItemRect(item) {
-    return {
-        left: item.x,
-        right: item.x + item.width - 1,
-        top: item.y,
-        bottom: item.y + item.height - 1,
-    };
+    return items.sort((a, b) => (b.y - a.y === 0 ? b.x - a.x : b.y - a.y));
 }
 export function normalizeMovePath(origin, path) {
     path = normalizePathOrigin(origin, path);
@@ -45,6 +37,53 @@ export function normalizeResizePath(origin, path) {
     normalizedPath.reverse();
     return normalizePathSteps(origin, normalizedPath);
 }
+export function createMove(type, item, next, score = 0) {
+    const distanceX = type === "RESIZE" ? next.x - item.width : next.x - item.x;
+    const distanceY = type === "RESIZE" ? next.y - item.height : next.y - item.y;
+    return {
+        type,
+        itemId: item.id,
+        x: type !== "RESIZE" ? next.x : item.x,
+        y: type !== "RESIZE" ? next.y : item.y,
+        width: type === "RESIZE" ? next.x : item.width,
+        height: type === "RESIZE" ? next.y : item.height,
+        direction: distanceX > 0 ? "right" : distanceX < 0 ? "left" : distanceY < 0 ? "up" : "down",
+        distanceX,
+        distanceY,
+        score,
+    };
+}
+export function getMoveOriginalRect(move) {
+    return {
+        left: move.x - move.distanceX,
+        right: move.x - move.distanceX + move.width - 1,
+        top: move.y - move.distanceY,
+        bottom: move.y - move.distanceY + move.height - 1,
+    };
+}
+export function getMoveRect(move) {
+    return {
+        left: move.x,
+        right: move.x + move.width - 1,
+        top: move.y,
+        bottom: move.y + move.height - 1,
+    };
+}
+export function checkItemsIntersection(i1, i2) {
+    if (i1.id === i2.id) {
+        return false;
+    }
+    return (i1.x <= i2.x + i2.width - 1 &&
+        i2.x <= i1.x + i1.width - 1 &&
+        i1.y <= i2.y + i2.height - 1 &&
+        i2.y <= i1.y + i1.height - 1);
+}
+export function checkOppositeDirections(d1, d2) {
+    return ((d1 === "down" && d2 === "up") ||
+        (d1 === "up" && d2 === "down") ||
+        (d1 === "left" && d2 === "right") ||
+        (d1 === "right" && d2 === "left"));
+}
 // Removes path prefixes that return to the original location.
 function normalizePathOrigin(origin, path) {
     let lastOriginIndex = -1;

package/internal/manifest.json

@@ -1,3 +1,3 @@
 {
-  "commit": "5dff29478d324c1d9508bb43b94dcef2e723a177"
+  "commit": "4a7c9c80e8d3f01df0e46772e037635bd3aee13c"
 }

package/items-palette/internal.js

@@ -18,7 +18,7 @@ export function InternalItemsPalette({ items, renderItem, i18nStrings, __interna
         itemContainerRef.current[itemId].focusDragHandle();
     }
     useDragSubscription("start", ({ draggableItem: { id } }) => {
-        setDropState({ id, isExpanded: false });
+        setDropState({ id });
         // Announce only if the target item belongs to the palette.
         if (items.some((it) => it.id === id)) {
             setAnnouncement(i18nStrings.liveAnnouncementDndStarted);
@@ -27,8 +27,8 @@ export function InternalItemsPalette({ items, renderItem, i18nStrings, __interna
             setAnnouncement("");
         }
     });
-    useDragSubscription("update", ({ draggableItem: { id }, dropTarget }) => {
-        setDropState({ id, isExpanded: !!dropTarget });
+    useDragSubscription("update", ({ draggableItem: { id } }) => {
+        setDropState({ id });
     });
     useDragSubscription("submit", () => {
         setDropState(undefined);
@@ -68,7 +68,5 @@ export function InternalItemsPalette({ items, renderItem, i18nStrings, __interna
                             }
                             const { width, height } = dropContext.scale(item);
                             return { width, minWidth: width, maxWidth: width, height, minHeight: height, maxHeight: height };
-                        }, children: () => renderItem(item, {
-                            showPreview: (dropState === null || dropState === void 0 ? void 0 : dropState.id) === item.id && dropState.isExpanded,
-                        }) }, item.id))) }) }), _jsx(LiveRegion, { children: announcement })] }));
+                        }, children: (hasDropTarget) => renderItem(item, { showPreview: hasDropTarget }) }, item.id))) }) }), _jsx(LiveRegion, { children: announcement })] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudscape-design/board-components",
-  "version": "3.0.30",
+  "version": "3.0.32",
   "repository": {
     "type": "git",
     "url": "https://github.com/cloudscape-design/board-components.git"

package/internal/utils/stack-set.d.ts

@@ -1,8 +0,0 @@
-export declare class StackSet<T> implements Iterable<T> {
-    private list;
-    private set;
-    constructor(input?: Iterable<T>);
-    push(value: T): void;
-    pop(): null | T;
-    [Symbol.iterator](): Iterator<T>;
-}

package/internal/utils/stack-set.js

@@ -1,23 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-export class StackSet {
-    constructor(input = []) {
-        this.list = [...input];
-        this.set = new Set(this.list);
-    }
-    push(value) {
-        if (!this.set.has(value)) {
-            this.list.push(value);
-            this.set.add(value);
-        }
-    }
-    pop() {
-        var _a;
-        const value = (_a = this.list.pop()) !== null && _a !== void 0 ? _a : null;
-        value && this.set.delete(value);
-        return value;
-    }
-    [Symbol.iterator]() {
-        return this.list[Symbol.iterator]();
-    }
-}