@cloudscape-design/board-components 3.0.0

package/internal/layout-engine/engine-step.js

@@ -0,0 +1,307 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { StackSet } from "../utils/stack-set";
+export function resolveOverlaps(userMove, grid, moves, conflicts) {
+    new LayoutEngineStep(grid, moves, conflicts).resolveOverlaps(userMove);
+}
+export function refloatGrid(grid, moves, conflicts) {
+    new LayoutEngineStep(grid, moves, conflicts).refloatGrid();
+}
+class LayoutEngineStep {
+    constructor(grid, moves, conflicts) {
+        this.moves = [];
+        this.conflicts = new Set();
+        this.grid = grid;
+        this.moves = moves;
+        this.conflicts = conflicts;
+    }
+    // Issue moves on overlapping items trying to resolve all of them.
+    resolveOverlaps(userMove) {
+        const priorities = new Map();
+        const activeId = userMove.itemId;
+        const isResize = userMove.type === "RESIZE";
+        let overlaps = new StackSet();
+        let priorityOverlaps = new StackSet();
+        const addOverlap = (itemId) => {
+            if (!this.conflicts.has(itemId)) {
+                overlaps.push(itemId);
+            }
+        };
+        this.makeMove(userMove, addOverlap, priorities);
+        const tryVacantMoves = () => {
+            // Try vacant moves on all overlaps.
+            let overlap = overlaps.pop();
+            while (overlap) {
+                const nextMove = this.tryFindVacantMove(overlap, activeId, isResize);
+                if (nextMove) {
+                    this.makeMove(nextMove, addOverlap, priorities);
+                }
+                else {
+                    priorityOverlaps.push(overlap);
+                }
+                overlap = overlaps.pop();
+            }
+            overlaps = priorityOverlaps;
+            priorityOverlaps = new StackSet();
+            tryPriorityMoves();
+        };
+        const tryPriorityMoves = () => {
+            // Try priority moves until first success and delegate back to vacant moves check.
+            const overlap = overlaps.pop();
+            if (overlap) {
+                const nextMove = this.findPriorityMove(overlap, priorities, activeId, isResize);
+                this.makeMove(nextMove, addOverlap, priorities);
+                tryVacantMoves();
+            }
+        };
+        tryVacantMoves();
+        this.refloatGrid(activeId);
+    }
+    // Find items that can "float" to the top and apply the necessary moves.
+    refloatGrid(activeId) {
+        if (this.conflicts.size > 0) {
+            return;
+        }
+        let needAnotherRefloat = false;
+        for (const item of this.grid.items) {
+            // The active item is skipped until the operation is committed.
+            if (item.id === activeId) {
+                continue;
+            }
+            const move = {
+                itemId: item.id,
+                x: item.x,
+                y: item.y,
+                width: item.width,
+                height: item.height,
+                type: "FLOAT",
+            };
+            for (move.y; move.y >= 0; move.y--) {
+                if (!this.validateVacantMove({ ...move, y: move.y - 1 }, activeId !== null && activeId !== void 0 ? activeId : "", false)) {
+                    break;
+                }
+            }
+            if (item.y !== move.y) {
+                this.grid.move(move.itemId, move.x, move.y);
+                this.moves.push(move);
+                needAnotherRefloat = true;
+            }
+        }
+        if (needAnotherRefloat) {
+            this.refloatGrid(activeId);
+        }
+    }
+    makeMove(move, addOverlap, priorities) {
+        switch (move.type) {
+            case "ESCAPE":
+            case "FLOAT":
+            case "MOVE":
+            case "VACANT":
+            case "PRIORITY":
+                this.grid.move(move.itemId, move.x, move.y, addOverlap);
+                break;
+            case "INSERT":
+                this.grid.insert({ id: move.itemId, ...move }, addOverlap);
+                break;
+            case "REMOVE":
+                this.grid.remove(move.itemId);
+                break;
+            case "RESIZE":
+                this.grid.resize(move.itemId, move.width, move.height, addOverlap);
+                break;
+        }
+        this.moves.push(move);
+        priorities.set(move.itemId, this.getMovePriority(move));
+    }
+    getMovePriority(move) {
+        switch (move.type) {
+            case "FLOAT":
+                return 0;
+            case "VACANT":
+                return 1;
+            case "PRIORITY":
+            case "ESCAPE":
+                return 5;
+            default:
+                return 9999;
+        }
+    }
+    // Retrieves prioritized list of directions to look for a resolution move.
+    getMoveDirections(issuer) {
+        const diff = this.getLastStepDiff(issuer);
+        const firstVertical = diff.y > 0 ? "down" : "up";
+        const nextVertical = firstVertical === "down" ? "up" : "down";
+        const firstHorizontal = diff.x > 0 ? "right" : "left";
+        const nextHorizontal = firstHorizontal === "right" ? "left" : "right";
+        return Math.abs(diff.y) > Math.abs(diff.x)
+            ? [firstVertical, firstHorizontal, nextHorizontal, nextVertical]
+            : [firstHorizontal, firstVertical, nextVertical, nextHorizontal];
+    }
+    getResizeDirections(issuer) {
+        const diff = this.getLastStepDiff(issuer);
+        const firstVertical = diff.y > 0 ? "up" : "down";
+        const nextVertical = firstVertical === "down" ? "up" : "down";
+        const firstHorizontal = diff.x > 0 ? "left" : "right";
+        const nextHorizontal = firstHorizontal === "right" ? "left" : "right";
+        return Math.abs(diff.y) > Math.abs(diff.x)
+            ? [firstVertical, firstHorizontal, nextHorizontal, nextVertical]
+            : [firstHorizontal, firstVertical, nextVertical, nextHorizontal];
+    }
+    getLastStepDiff(issuer) {
+        var _a, _b;
+        const issuerMoves = this.moves.filter((move) => move.itemId === issuer.id);
+        const originalParams = {
+            x: issuer.originalX,
+            y: issuer.originalY,
+            width: issuer.originalWidth,
+            height: issuer.originalHeight,
+        };
+        const prevIssuerMove = (_a = issuerMoves[issuerMoves.length - 2]) !== null && _a !== void 0 ? _a : originalParams;
+        const lastIssuerMove = (_b = issuerMoves[issuerMoves.length - 1]) !== null && _b !== void 0 ? _b : originalParams;
+        const diff = {
+            x: prevIssuerMove.x - lastIssuerMove.x,
+            y: prevIssuerMove.y - lastIssuerMove.y,
+            width: prevIssuerMove.width - lastIssuerMove.width,
+            height: prevIssuerMove.height - lastIssuerMove.height,
+        };
+        return diff.x || diff.y ? { x: diff.x, y: diff.y } : { x: diff.width, y: diff.height };
+    }
+    // Try finding a move that resolves an overlap by moving an item to a vacant space.
+    tryFindVacantMove(overlap, activeId, isResize) {
+        const overlapItem = this.grid.getItem(overlap);
+        const overlapWith = this.getOverlapWith(overlapItem);
+        const directions = isResize ? this.getResizeDirections(overlapWith) : this.getMoveDirections(overlapWith);
+        for (const direction of directions) {
+            const move = this.getMoveForDirection(overlapItem, overlapWith, direction, "VACANT");
+            if (this.validateVacantMove(move, activeId, isResize)) {
+                return move;
+            }
+        }
+        return null;
+    }
+    validateVacantMove(move, activeId, isResize) {
+        const moveTarget = this.grid.getItem(move.itemId);
+        for (let y = moveTarget.y; y < moveTarget.y + moveTarget.height; y++) {
+            for (let x = moveTarget.x; x < moveTarget.x + moveTarget.width; x++) {
+                const newY = move.y + (y - moveTarget.y);
+                const newX = move.x + (x - moveTarget.x);
+                // Outside the grid.
+                if (newY < 0 || newX < 0 || newX >= this.grid.width) {
+                    return false;
+                }
+                // The probed destination is occupied.
+                if (this.grid.getCellOverlap(newX, newY, move.itemId)) {
+                    return false;
+                }
+            }
+        }
+        if (isResize && activeId && !this.validateResizeMove(move, activeId)) {
+            return false;
+        }
+        return true;
+    }
+    // Find a move that resolves an overlap by moving an item over another item that has not been disturbed yet.
+    findPriorityMove(overlap, priorities, activeId, isResize) {
+        const overlapItem = this.grid.getItem(overlap);
+        const overlapWith = this.getOverlapWith(overlapItem);
+        const directions = isResize ? this.getResizeDirections(overlapWith) : this.getMoveDirections(overlapWith);
+        for (const direction of directions) {
+            const move = this.getMoveForDirection(overlapItem, overlapWith, direction, "PRIORITY");
+            if (this.validatePriorityMove(move, priorities, activeId, isResize)) {
+                return move;
+            }
+        }
+        // If can't find a good move - "escape" item to the bottom.
+        const move = {
+            itemId: overlapItem.id,
+            y: overlapItem.y + 1,
+            x: overlapItem.x,
+            width: overlapItem.width,
+            height: overlapItem.height,
+            type: "ESCAPE",
+        };
+        for (move.y; move.y < 100; move.y++) {
+            if (this.validatePriorityMove(move, priorities, activeId, false)) {
+                return move;
+            }
+        }
+        throw new Error("Invariant violation: can't find escape move.");
+    }
+    validatePriorityMove(move, priorities, activeId, isResize) {
+        var _a;
+        const moveTarget = this.grid.getItem(move.itemId);
+        for (let y = moveTarget.y; y < moveTarget.y + moveTarget.height; y++) {
+            for (let x = moveTarget.x; x < moveTarget.x + moveTarget.width; x++) {
+                const newY = move.y + (y - moveTarget.y);
+                const newX = move.x + (x - moveTarget.x);
+                // Outside the grid.
+                if (newY < 0 || newX < 0 || newX >= this.grid.width) {
+                    return false;
+                }
+                for (const item of this.grid.getCell(newX, newY)) {
+                    // Can't overlap with the active item.
+                    if (item.id === activeId) {
+                        return false;
+                    }
+                    // The overlapping item has same or bigger priority.
+                    if (((_a = priorities.get(item.id)) !== null && _a !== void 0 ? _a : 0) >= this.getMovePriority(move)) {
+                        return false;
+                    }
+                    // The probed destination is currently blocked.
+                    if (this.conflicts.has(item.id)) {
+                        return false;
+                    }
+                }
+            }
+        }
+        if (isResize && activeId && !this.validateResizeMove(move, activeId)) {
+            return false;
+        }
+        return true;
+    }
+    validateResizeMove(move, activeId) {
+        const resizeTarget = this.grid.getItem(activeId);
+        const moveTarget = this.grid.getItem(move.itemId);
+        const diff = this.getLastStepDiff(resizeTarget);
+        const direction = diff.x ? "horizontal" : "vertical";
+        const originalPlacement = {
+            isNext: resizeTarget.x + resizeTarget.originalWidth - 1 < moveTarget.x,
+            isBelow: resizeTarget.y + resizeTarget.originalHeight - 1 < moveTarget.y,
+        };
+        const nextPlacement = {
+            isNext: resizeTarget.x + resizeTarget.width - 1 < move.x,
+            isBelow: resizeTarget.y + resizeTarget.height - 1 < move.y,
+        };
+        return ((direction === "horizontal" && originalPlacement.isNext === nextPlacement.isNext) ||
+            (direction === "vertical" && originalPlacement.isBelow === nextPlacement.isBelow));
+    }
+    getOverlapWith(targetItem) {
+        for (let y = targetItem.y; y < targetItem.y + targetItem.height; y++) {
+            for (let x = targetItem.x; x < targetItem.x + targetItem.width; x++) {
+                const overlap = this.grid.getCellOverlap(x, y, targetItem.id);
+                if (overlap) {
+                    return overlap;
+                }
+            }
+        }
+        throw new Error("Invariant violation - no overlaps found.");
+    }
+    // Retrieve first possible move for the given direction to resolve the overlap.
+    getMoveForDirection(moveTarget, overlap, direction, moveType) {
+        const common = { itemId: moveTarget.id, width: moveTarget.width, height: moveTarget.height, type: moveType };
+        switch (direction) {
+            case "up": {
+                return { ...common, y: overlap.top - moveTarget.height, x: moveTarget.x };
+            }
+            case "down": {
+                return { ...common, y: overlap.bottom + 1, x: moveTarget.x };
+            }
+            case "left": {
+                return { ...common, y: moveTarget.y, x: overlap.left - moveTarget.width };
+            }
+            case "right": {
+                return { ...common, y: moveTarget.y, x: overlap.right + 1 };
+            }
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import { GridLayout, ItemId } from "../interfaces";
+import { InsertCommand, LayoutShift, MoveCommand, ResizeCommand } from "./interfaces";
+export declare class LayoutEngine {
+    private current;
+    private grid;
+    private moves;
+    private conflicts;
+    private chained;
+    constructor(args: GridLayout | LayoutEngine);
+    move(moveCommand: MoveCommand): LayoutEngine;
+    resize(resize: ResizeCommand): LayoutEngine;
+    insert({ itemId, width, height, path: [position, ...path] }: InsertCommand): LayoutEngine;
+    remove(itemId: ItemId): LayoutEngine;
+    refloat(): LayoutEngine;
+    getLayoutShift(): LayoutShift;
+    private cleanup;
+    private validateMoveCommand;
+    private validateResizeCommand;
+}

package/internal/layout-engine/engine.js

@@ -0,0 +1,105 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Position } from "../utils/position";
+import { findConflicts } from "./engine-conflicts";
+import { refloatGrid, resolveOverlaps } from "./engine-step";
+import { LayoutEngineGrid } from "./grid";
+import { normalizeMovePath, normalizeResizePath, sortGridItems } from "./utils";
+export class LayoutEngine {
+    constructor(args) {
+        this.moves = [];
+        this.conflicts = new Set();
+        this.chained = false;
+        if (args instanceof LayoutEngine) {
+            this.current = args.current;
+            this.grid = args.grid;
+            this.moves = args.moves;
+            this.conflicts = args.conflicts;
+            this.chained = true;
+        }
+        else {
+            this.current = args;
+            this.grid = new LayoutEngineGrid(args.items, args.columns);
+        }
+    }
+    move(moveCommand) {
+        this.cleanup();
+        const { itemId, path } = this.validateMoveCommand(moveCommand);
+        for (let stepIndex = 0; stepIndex < path.length; stepIndex++) {
+            const step = path[stepIndex];
+            const { width, height } = this.grid.getItem(itemId);
+            const move = { itemId, x: step.x, y: step.y, width, height, type: "MOVE" };
+            this.conflicts = findConflicts(move, this.grid);
+            resolveOverlaps(move, this.grid, this.moves, this.conflicts);
+        }
+        return new LayoutEngine(this);
+    }
+    resize(resize) {
+        this.cleanup();
+        const { itemId, path } = this.validateResizeCommand(resize);
+        const resizeTarget = this.grid.getItem(itemId);
+        for (let stepIndex = 0; stepIndex < path.length; stepIndex++) {
+            const width = path[stepIndex].x - resizeTarget.x;
+            const height = path[stepIndex].y - resizeTarget.y;
+            resolveOverlaps({ itemId, x: resizeTarget.x, y: resizeTarget.y, width, height, type: "RESIZE" }, this.grid, this.moves, this.conflicts);
+        }
+        return new LayoutEngine(this);
+    }
+    insert({ itemId, width, height, path: [position, ...path] }) {
+        this.cleanup();
+        resolveOverlaps({ itemId, ...position, width, height, type: "INSERT" }, this.grid, this.moves, this.conflicts);
+        return new LayoutEngine(this).move({ itemId, path });
+    }
+    remove(itemId) {
+        this.cleanup();
+        const { x, y, width, height } = this.grid.getItem(itemId);
+        resolveOverlaps({ itemId, x, y, width, height, type: "REMOVE" }, this.grid, this.moves, this.conflicts);
+        return new LayoutEngine(this);
+    }
+    refloat() {
+        refloatGrid(this.grid, this.moves, this.conflicts);
+        return new LayoutEngine(this);
+    }
+    getLayoutShift() {
+        return {
+            current: this.current,
+            next: {
+                items: sortGridItems(this.grid.items.map((item) => ({ ...item }))),
+                columns: this.grid.width,
+                rows: this.grid.height,
+            },
+            moves: [...this.moves],
+            conflicts: [...this.conflicts],
+        };
+    }
+    cleanup() {
+        if (!this.chained) {
+            this.grid = new LayoutEngineGrid(this.current.items, this.current.columns);
+            this.moves = [];
+            this.conflicts = new Set();
+        }
+    }
+    validateMoveCommand({ itemId, path }) {
+        const moveTarget = this.grid.getItem(itemId);
+        for (const step of path) {
+            if (step.x < 0 || step.y < 0 || step.x + moveTarget.width > this.grid.width) {
+                throw new Error("Invalid move: outside grid.");
+            }
+        }
+        return { itemId, path: normalizeMovePath(new Position({ x: moveTarget.x, y: moveTarget.y }), path) };
+    }
+    validateResizeCommand({ itemId, path }) {
+        const resizeTarget = this.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.grid.width) {
+                throw new Error("Invalid resize: outside grid.");
+            }
+        }
+        return { itemId, path: normalizeResizePath(new Position({ x, y }), path) };
+    }
+}

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

@@ -0,0 +1,28 @@
+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 LayoutEngineGrid {
+    private _width;
+    private _height;
+    private _items;
+    private layout;
+    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;
+    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;
+    remove(itemId: ItemId): void;
+    private removeLayoutItem;
+    private insertLayoutItem;
+    private makeNewRow;
+}

package/internal/layout-engine/grid.js

@@ -0,0 +1,140 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { getItemRect } from "./utils";
+export class LayoutEngineGrid {
+    constructor(items, columns) {
+        this._items = new Map();
+        this.layout = [];
+        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.");
+                    }
+                }
+            }
+        }
+    }
+    get width() {
+        return this._width;
+    }
+    get height() {
+        return this._height;
+    }
+    get items() {
+        return [...this._items.values()];
+    }
+    getItem(itemId) {
+        const item = this._items.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;
+    }
+    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);
+    }
+    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);
+    }
+    insert(item, onOverlap) {
+        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("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);
+            }
+        }
+    }
+    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);
+            }
+        }
+    }
+    makeNewRow() {
+        this.layout.push([...Array(this._width)].map(() => new Set()));
+        this._height = this.layout.length;
+    }
+}

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

@@ -0,0 +1,30 @@
+import { GridLayout, ItemId } from "../interfaces";
+import { Position } from "../utils/position";
+export interface MoveCommand {
+    itemId: ItemId;
+    path: readonly Position[];
+}
+export interface ResizeCommand {
+    itemId: ItemId;
+    path: readonly Position[];
+}
+export interface InsertCommand {
+    itemId: ItemId;
+    width: number;
+    height: number;
+    path: readonly Position[];
+}
+export interface CommittedMove {
+    itemId: ItemId;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    type: "MOVE" | "VACANT" | "PRIORITY" | "ESCAPE" | "FLOAT" | "RESIZE" | "INSERT" | "REMOVE";
+}
+export interface LayoutShift {
+    current: GridLayout;
+    next: GridLayout;
+    moves: readonly CommittedMove[];
+    conflicts: readonly ItemId[];
+}

package/internal/layout-engine/interfaces.js

@@ -0,0 +1,3 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export {};

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

@@ -0,0 +1,12 @@
+import { GridLayoutItem } from "../interfaces";
+import { Position } from "../utils/position";
+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 normalizeMovePath(origin: Position, path: readonly Position[]): readonly Position[];
+export declare function normalizeResizePath(origin: Position, path: readonly Position[]): readonly Position[];