717b2c1610
## Description This PR includes Changes for Drag and drop Improvements, That includes, - Resizing dragging widgets along Container edges. - Initially resize widgets against Container/Droptarget widgets. - While holding close to Container/Droptarget widgets for half a second, start to reflow the widget. Fixes #19139 Fixes #12892 Media https://user-images.githubusercontent.com/71900764/209154834-66acecbb-2df8-4598-86d5-4fe7843dd21b.mp4 ## Type of change - Bug fix (non-breaking change which fixes an issue) - New feature (non-breaking change which adds functionality) ## How Has This Been Tested? - Manual - Jest ### Test Plan > Add Testsmith test cases links that relate to this PR ### Issues raised during DP testing > Link issues raised during DP testing for better visiblity and tracking (copy link from comments dropped on this PR) ## Checklist: ### Dev activity - [x] My code follows the style guidelines of this project - [x] I have performed a self-review of my own code - [x] I have commented my code, particularly in hard-to-understand areas - [ ] I have made corresponding changes to the documentation - [x] My changes generate no new warnings - [x] I have added tests that prove my fix is effective or that my feature works - [x] New and existing unit tests pass locally with my changes - [ ] PR is being merged under a feature flag ### QA activity: - [ ] Test plan has been approved by relevant developers - [ ] Test plan has been peer reviewed by QA - [ ] Cypress test cases have been added and approved by either SDET or manual QA - [ ] Organized project review call with relevant stakeholders after Round 1/2 of QA - [ ] Added Test Plan Approved label after reveiwing all Cypress test
2387 lines
59 KiB
JavaScript
2387 lines
59 KiB
JavaScript
import { ReflowDirection, SpaceAttributes } from "reflow/reflowTypes";
|
|
import {
|
|
getAccessor,
|
|
shouldReplaceOldMovement,
|
|
getResizedDimensions,
|
|
sortCollidingSpacesByDistance,
|
|
getShouldReflow,
|
|
getDelta,
|
|
getCollidingSpacesInDirection,
|
|
filterSpaceById,
|
|
getMaxX,
|
|
getMaxY,
|
|
getReflowDistance,
|
|
getReflowedDimension,
|
|
getCollidingSpaceMap,
|
|
ShouldAddToCollisionSpacesArray,
|
|
filterSpaceByDirection,
|
|
filterCommonSpaces,
|
|
getSpacesMapFromArray,
|
|
buildArrayToCollisionMap,
|
|
getModifiedOccupiedSpacesMap,
|
|
getModifiedCollidingSpace,
|
|
checkReCollisionWithOtherNewSpacePositions,
|
|
getCalculatedDirection,
|
|
getBottomMostRow,
|
|
initializeMovementLimitMap,
|
|
checkProcessNodeForTree,
|
|
getRelativeCollidingValue,
|
|
getContainerExitEdge,
|
|
getCollisionDirectionOfDropTarget,
|
|
modifyResizePosition,
|
|
willItCauseUndroppableState,
|
|
verifyMovementLimits,
|
|
} from "../reflowUtils";
|
|
import {
|
|
HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
VERTICAL_RESIZE_MIN_LIMIT,
|
|
} from "../reflowTypes";
|
|
|
|
const gridProps = {
|
|
parentColumnSpace: 20,
|
|
parentRowSpace: 10,
|
|
maxGridColumns: 100,
|
|
};
|
|
|
|
describe("Test reflow util methods", () => {
|
|
describe("Test shouldReplaceOldMovement method", () => {
|
|
it("should return true when Space's new movement coordinate is farther than the olds'", () => {
|
|
const newMovement = {
|
|
X: 20,
|
|
},
|
|
oldMovement = {
|
|
X: 10,
|
|
};
|
|
expect(
|
|
shouldReplaceOldMovement(
|
|
oldMovement,
|
|
newMovement,
|
|
ReflowDirection.RIGHT,
|
|
),
|
|
).toBe(true);
|
|
});
|
|
it("should return false when Space's new movement coordinate is not farther than the olds'", () => {
|
|
const newMovement = {
|
|
X: 10,
|
|
},
|
|
oldMovement = {
|
|
X: 20,
|
|
};
|
|
expect(
|
|
shouldReplaceOldMovement(oldMovement, newMovement, ReflowDirection.TOP),
|
|
).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("Test getResizedDimensions method", () => {
|
|
it("should return Resized Dimensions based on dimensionBeforeCollision and the emptySpaces in between", () => {
|
|
const collisionTree = {
|
|
right: 20,
|
|
collidingValue: 10,
|
|
left: 0,
|
|
},
|
|
accessors = getAccessor(ReflowDirection.RIGHT);
|
|
const resizedDimension = {
|
|
right: 30,
|
|
};
|
|
|
|
expect(getResizedDimensions(collisionTree, accessors).right).toBe(
|
|
resizedDimension.right,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("Test sortCollidingSpacesByDistance method", () => {
|
|
const collisionSpaces = [
|
|
{
|
|
direction: ReflowDirection.RIGHT,
|
|
left: 100,
|
|
collidingValue: 80,
|
|
},
|
|
{
|
|
direction: ReflowDirection.LEFT,
|
|
right: 30,
|
|
collidingValue: 40,
|
|
},
|
|
{
|
|
direction: ReflowDirection.BOTTOM,
|
|
top: 110,
|
|
collidingValue: 70,
|
|
},
|
|
{
|
|
direction: ReflowDirection.TOP,
|
|
bottom: 0,
|
|
collidingValue: 30,
|
|
},
|
|
];
|
|
|
|
it("should sort the collidingSpaces with respect to the distance from the staticPosition in a Ascending manner", () => {
|
|
const sortedCollisionSpaces = [
|
|
{
|
|
direction: ReflowDirection.BOTTOM,
|
|
top: 110,
|
|
collidingValue: 70,
|
|
},
|
|
{
|
|
direction: ReflowDirection.TOP,
|
|
bottom: 0,
|
|
collidingValue: 30,
|
|
},
|
|
{
|
|
direction: ReflowDirection.RIGHT,
|
|
left: 100,
|
|
collidingValue: 80,
|
|
},
|
|
{
|
|
direction: ReflowDirection.LEFT,
|
|
right: 30,
|
|
collidingValue: 40,
|
|
},
|
|
];
|
|
sortCollidingSpacesByDistance(collisionSpaces, true);
|
|
expect(collisionSpaces).toEqual(sortedCollisionSpaces);
|
|
});
|
|
it("should sort the collidingSpaces with respect to the distance from the staticPosition in a descending manner", () => {
|
|
const sortedCollisionSpaces = [
|
|
{
|
|
direction: ReflowDirection.LEFT,
|
|
right: 30,
|
|
collidingValue: 40,
|
|
},
|
|
{
|
|
direction: ReflowDirection.RIGHT,
|
|
left: 100,
|
|
collidingValue: 80,
|
|
},
|
|
{
|
|
direction: ReflowDirection.TOP,
|
|
bottom: 0,
|
|
collidingValue: 30,
|
|
},
|
|
{
|
|
direction: ReflowDirection.BOTTOM,
|
|
top: 110,
|
|
collidingValue: 70,
|
|
},
|
|
];
|
|
sortCollidingSpacesByDistance(collisionSpaces, false);
|
|
expect(collisionSpaces).toEqual(sortedCollisionSpaces);
|
|
});
|
|
});
|
|
|
|
describe("Test getShouldReflow method", () => {
|
|
const spaceMovementMap = {
|
|
"1234": [
|
|
{
|
|
maxMovement: 30,
|
|
directionalIndicator: 1,
|
|
coordinateKey: "X",
|
|
isHorizontal: true,
|
|
},
|
|
{
|
|
maxMovement: 30,
|
|
directionalIndicator: 1,
|
|
coordinateKey: "Y",
|
|
isHorizontal: false,
|
|
},
|
|
{
|
|
maxMovement: -30,
|
|
directionalIndicator: -1,
|
|
coordinateKey: "X",
|
|
isHorizontal: true,
|
|
},
|
|
{
|
|
maxMovement: -30,
|
|
directionalIndicator: -1,
|
|
coordinateKey: "Y",
|
|
isHorizontal: false,
|
|
},
|
|
],
|
|
};
|
|
|
|
it("should check canHorizontalMove or canVerticalMove when either direction movement has reached limit", () => {
|
|
let movementLimit = {};
|
|
getShouldReflow(movementLimit, spaceMovementMap, {
|
|
X: 25,
|
|
Y: 0,
|
|
});
|
|
expect(movementLimit["1234"]).toEqual({
|
|
canHorizontalMove: true,
|
|
canVerticalMove: true,
|
|
});
|
|
movementLimit = {};
|
|
getShouldReflow(movementLimit, spaceMovementMap, {
|
|
X: 35,
|
|
Y: 0,
|
|
});
|
|
expect(movementLimit["1234"]).toEqual({
|
|
canHorizontalMove: false,
|
|
canVerticalMove: true,
|
|
});
|
|
movementLimit = {};
|
|
getShouldReflow(movementLimit, spaceMovementMap, {
|
|
X: -25,
|
|
Y: 0,
|
|
});
|
|
expect(movementLimit["1234"]).toEqual({
|
|
canHorizontalMove: true,
|
|
canVerticalMove: true,
|
|
});
|
|
movementLimit = {};
|
|
getShouldReflow(movementLimit, spaceMovementMap, {
|
|
X: -35,
|
|
Y: 0,
|
|
});
|
|
expect(movementLimit["1234"]).toEqual({
|
|
canHorizontalMove: false,
|
|
canVerticalMove: true,
|
|
});
|
|
movementLimit = {};
|
|
getShouldReflow(movementLimit, spaceMovementMap, {
|
|
X: 0,
|
|
Y: 25,
|
|
});
|
|
expect(movementLimit["1234"]).toEqual({
|
|
canHorizontalMove: true,
|
|
canVerticalMove: true,
|
|
});
|
|
movementLimit = {};
|
|
getShouldReflow(movementLimit, spaceMovementMap, {
|
|
X: 0,
|
|
Y: 35,
|
|
});
|
|
expect(movementLimit["1234"]).toEqual({
|
|
canHorizontalMove: true,
|
|
canVerticalMove: false,
|
|
});
|
|
movementLimit = {};
|
|
getShouldReflow(movementLimit, spaceMovementMap, {
|
|
X: 0,
|
|
Y: -25,
|
|
});
|
|
expect(movementLimit["1234"]).toEqual({
|
|
canHorizontalMove: true,
|
|
canVerticalMove: true,
|
|
});
|
|
movementLimit = {};
|
|
getShouldReflow(movementLimit, spaceMovementMap, {
|
|
X: 0,
|
|
Y: -35,
|
|
});
|
|
expect(movementLimit["1234"]).toEqual({
|
|
canHorizontalMove: true,
|
|
canVerticalMove: false,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Test getDelta method", () => {
|
|
const OGPositions = {
|
|
"1234": {
|
|
id: "1234",
|
|
left: 50,
|
|
top: 50,
|
|
right: 110,
|
|
bottom: 110,
|
|
},
|
|
},
|
|
newPositions = {
|
|
"1234": { id: "1234", left: 40, top: 30, right: 80, bottom: 70 },
|
|
};
|
|
|
|
it("should check X and Y Coordinates for constant direction", () => {
|
|
expect(getDelta(OGPositions, newPositions, ReflowDirection.LEFT)).toEqual(
|
|
{
|
|
X: 10,
|
|
Y: 20,
|
|
},
|
|
);
|
|
expect(getDelta(OGPositions, newPositions, ReflowDirection.TOP)).toEqual({
|
|
X: 10,
|
|
Y: 20,
|
|
});
|
|
expect(
|
|
getDelta(OGPositions, newPositions, ReflowDirection.RIGHT),
|
|
).toEqual({
|
|
X: 30,
|
|
Y: 20,
|
|
});
|
|
expect(
|
|
getDelta(OGPositions, newPositions, ReflowDirection.BOTTOM),
|
|
).toEqual({
|
|
X: 10,
|
|
Y: 40,
|
|
});
|
|
});
|
|
|
|
it("should check X and Y Coordinates for composite direction", () => {
|
|
expect(
|
|
getDelta(OGPositions, newPositions, ReflowDirection.TOPLEFT),
|
|
).toEqual({
|
|
X: 10,
|
|
Y: 20,
|
|
});
|
|
expect(
|
|
getDelta(OGPositions, newPositions, ReflowDirection.TOPRIGHT),
|
|
).toEqual({
|
|
X: 30,
|
|
Y: 20,
|
|
});
|
|
expect(
|
|
getDelta(OGPositions, newPositions, ReflowDirection.BOTTOMLEFT),
|
|
).toEqual({
|
|
X: 10,
|
|
Y: 40,
|
|
});
|
|
expect(
|
|
getDelta(OGPositions, newPositions, ReflowDirection.BOTTOMRIGHT),
|
|
).toEqual({
|
|
X: 30,
|
|
Y: 40,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Test getCollidingSpaces and getCollidingSpacesInDirection method", () => {
|
|
const newPositions = [
|
|
{
|
|
id: "1234",
|
|
left: 40,
|
|
top: 30,
|
|
right: 80,
|
|
bottom: 70,
|
|
},
|
|
],
|
|
occupiedSpaces = [
|
|
{
|
|
id: "1235",
|
|
left: 10,
|
|
top: 10,
|
|
right: 35,
|
|
bottom: 25,
|
|
},
|
|
{
|
|
id: "1236",
|
|
left: 30,
|
|
top: 20,
|
|
right: 50,
|
|
bottom: 35,
|
|
},
|
|
{
|
|
id: "1237",
|
|
left: 10,
|
|
top: 10,
|
|
right: 90,
|
|
bottom: 80,
|
|
},
|
|
];
|
|
|
|
it("should return collidingSpaces with direction", () => {
|
|
const collidingSpaces = {
|
|
"1236": {
|
|
id: "1236",
|
|
left: 30,
|
|
top: 20,
|
|
right: 50,
|
|
bottom: 35,
|
|
direction: "BOTTOM",
|
|
collidingId: "1234",
|
|
collidingValue: 70,
|
|
isHorizontal: false,
|
|
order: 1,
|
|
},
|
|
"1237": {
|
|
id: "1237",
|
|
left: 10,
|
|
top: 10,
|
|
right: 90,
|
|
bottom: 80,
|
|
direction: "BOTTOM",
|
|
collidingId: "1234",
|
|
collidingValue: 70,
|
|
isHorizontal: false,
|
|
order: 2,
|
|
},
|
|
};
|
|
expect(
|
|
getCollidingSpaceMap(
|
|
newPositions,
|
|
occupiedSpaces,
|
|
ReflowDirection.BOTTOM,
|
|
{ horizontal: {}, vertical: {} },
|
|
false,
|
|
).collidingSpaceMap,
|
|
).toEqual(collidingSpaces);
|
|
});
|
|
|
|
it("should return collidingSpaces with predicted direction based on Previous positions", () => {
|
|
const collidingSpaces = {
|
|
"1237": {
|
|
id: "1237",
|
|
left: 10,
|
|
top: 10,
|
|
right: 90,
|
|
bottom: 80,
|
|
direction: "BOTTOM",
|
|
collidingId: "1234",
|
|
collidingValue: 70,
|
|
isHorizontal: false,
|
|
order: 1,
|
|
},
|
|
},
|
|
prevPositions = {
|
|
"1234": {
|
|
id: "1234",
|
|
left: 50,
|
|
top: 30,
|
|
right: 90,
|
|
bottom: 70,
|
|
},
|
|
};
|
|
expect(
|
|
getCollidingSpaceMap(
|
|
newPositions,
|
|
occupiedSpaces,
|
|
ReflowDirection.BOTTOM,
|
|
{ horizontal: {}, vertical: {} },
|
|
false,
|
|
prevPositions,
|
|
).collidingSpaceMap,
|
|
).toEqual(collidingSpaces);
|
|
});
|
|
|
|
it("should return collidingSpaces In a particular direction", () => {
|
|
const collidingSpaces = [
|
|
{
|
|
id: "1236",
|
|
left: 30,
|
|
top: 20,
|
|
right: 50,
|
|
bottom: 35,
|
|
direction: "LEFT",
|
|
collidingId: "1234",
|
|
collidingValue: 40,
|
|
isHorizontal: true,
|
|
order: 1,
|
|
},
|
|
{
|
|
id: "1237",
|
|
left: 10,
|
|
top: 10,
|
|
right: 90,
|
|
bottom: 80,
|
|
direction: "LEFT",
|
|
collidingId: "1234",
|
|
collidingValue: 40,
|
|
isHorizontal: true,
|
|
order: 2,
|
|
},
|
|
];
|
|
expect(
|
|
getCollidingSpacesInDirection(
|
|
newPositions[0],
|
|
newPositions,
|
|
ReflowDirection.LEFT,
|
|
ReflowDirection.LEFT,
|
|
{},
|
|
{},
|
|
{},
|
|
occupiedSpaces,
|
|
).collidingSpaces,
|
|
).toEqual(collidingSpaces);
|
|
});
|
|
});
|
|
|
|
describe("Test filterSpaceById method", () => {
|
|
const occupiedSpaces = [
|
|
{
|
|
id: "1234",
|
|
left: 40,
|
|
top: 30,
|
|
right: 80,
|
|
bottom: 70,
|
|
},
|
|
{
|
|
id: "1235",
|
|
left: 10,
|
|
top: 10,
|
|
right: 35,
|
|
bottom: 25,
|
|
},
|
|
{
|
|
id: "1236",
|
|
left: 30,
|
|
top: 20,
|
|
right: 50,
|
|
bottom: 35,
|
|
},
|
|
];
|
|
|
|
it("should return filtered Spaces", () => {
|
|
const filteredSpaces = occupiedSpaces.slice(1);
|
|
expect(filterSpaceById("1234", occupiedSpaces)).toEqual(filteredSpaces);
|
|
});
|
|
});
|
|
|
|
describe("Test getMaxX method", () => {
|
|
const collisionTree = {
|
|
id: "1234",
|
|
left: 40,
|
|
top: 30,
|
|
right: 60,
|
|
bottom: 70,
|
|
children: [],
|
|
};
|
|
|
|
it("should return max number for LEFT Direction when not Resizing", () => {
|
|
const depth = 2;
|
|
expect(
|
|
getMaxX(
|
|
collisionTree,
|
|
gridProps,
|
|
ReflowDirection.LEFT,
|
|
depth * HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
30,
|
|
false,
|
|
),
|
|
).toBe(-1 * 10 * gridProps.parentColumnSpace);
|
|
});
|
|
it("should return max number for LEFT Direction when Resizing", () => {
|
|
const depth = 2;
|
|
expect(
|
|
getMaxX(
|
|
collisionTree,
|
|
gridProps,
|
|
ReflowDirection.LEFT,
|
|
depth * HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
30,
|
|
true,
|
|
),
|
|
).toBe(
|
|
-1 *
|
|
(collisionTree.left - depth * HORIZONTAL_RESIZE_MIN_LIMIT) *
|
|
gridProps.parentColumnSpace,
|
|
);
|
|
});
|
|
it("should return max number for RIGHT Direction when not Resizing", () => {
|
|
const depth = 2;
|
|
expect(
|
|
getMaxX(
|
|
collisionTree,
|
|
gridProps,
|
|
ReflowDirection.RIGHT,
|
|
depth * HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
30,
|
|
false,
|
|
),
|
|
).toBe(
|
|
(gridProps.maxGridColumns - collisionTree.right - 30) *
|
|
gridProps.parentColumnSpace,
|
|
);
|
|
});
|
|
it("should return max number for RIGHT Direction when Resizing", () => {
|
|
const depth = 2;
|
|
expect(
|
|
getMaxX(
|
|
collisionTree,
|
|
gridProps,
|
|
ReflowDirection.RIGHT,
|
|
depth * HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
30,
|
|
true,
|
|
),
|
|
).toBe(
|
|
(gridProps.maxGridColumns -
|
|
collisionTree.right -
|
|
depth * HORIZONTAL_RESIZE_MIN_LIMIT) *
|
|
gridProps.parentColumnSpace,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("Test getMaxY method", () => {
|
|
const collisionTree = {
|
|
id: "1234",
|
|
left: 40,
|
|
top: 30,
|
|
right: 60,
|
|
bottom: 70,
|
|
children: [],
|
|
};
|
|
|
|
it("should return max number for TOP Direction when not Resizing", () => {
|
|
const depth = 2;
|
|
expect(
|
|
getMaxY(
|
|
collisionTree,
|
|
gridProps,
|
|
ReflowDirection.TOP,
|
|
depth * VERTICAL_RESIZE_MIN_LIMIT,
|
|
20,
|
|
false,
|
|
),
|
|
).toBe(-1 * 10 * gridProps.parentRowSpace);
|
|
});
|
|
it("should return max number for TOP Direction when Resizing", () => {
|
|
const depth = 2;
|
|
expect(
|
|
getMaxY(
|
|
collisionTree,
|
|
gridProps,
|
|
ReflowDirection.TOP,
|
|
depth * VERTICAL_RESIZE_MIN_LIMIT,
|
|
20,
|
|
true,
|
|
),
|
|
).toBe(
|
|
-1 *
|
|
(collisionTree.top - depth * VERTICAL_RESIZE_MIN_LIMIT) *
|
|
gridProps.parentRowSpace,
|
|
);
|
|
});
|
|
it("should return max number for BOTTOM Direction with or without Resizing", () => {
|
|
const depth = 2;
|
|
expect(
|
|
getMaxY(
|
|
collisionTree,
|
|
gridProps,
|
|
ReflowDirection.BOTTOM,
|
|
depth * VERTICAL_RESIZE_MIN_LIMIT,
|
|
230,
|
|
false,
|
|
),
|
|
).toBe(Infinity);
|
|
});
|
|
});
|
|
|
|
describe("Test getReflowDistance method", () => {
|
|
const collisionTree = {
|
|
id: "1234",
|
|
left: 90,
|
|
top: 100,
|
|
right: 150,
|
|
bottom: 140,
|
|
children: [],
|
|
},
|
|
width =
|
|
(collisionTree.right - collisionTree.left) *
|
|
gridProps.parentColumnSpace,
|
|
height =
|
|
(collisionTree.bottom - collisionTree.top) * gridProps.parentRowSpace;
|
|
|
|
it("should return distance for space in TOP direction", () => {
|
|
//before it reaches max limit
|
|
let dimensionBeforeCollision = 40,
|
|
emptySpaces = 20,
|
|
maxDistance = -60 * gridProps.parentRowSpace;
|
|
expect(
|
|
getReflowDistance(
|
|
collisionTree,
|
|
ReflowDirection.TOP,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
height,
|
|
emptySpaces,
|
|
gridProps.parentRowSpace,
|
|
),
|
|
).toBe(
|
|
-1 *
|
|
(dimensionBeforeCollision - emptySpaces) *
|
|
gridProps.parentRowSpace,
|
|
);
|
|
|
|
//reflowing past max limit
|
|
dimensionBeforeCollision = 90;
|
|
expect(
|
|
getReflowDistance(
|
|
collisionTree,
|
|
ReflowDirection.TOP,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
height,
|
|
emptySpaces,
|
|
gridProps.parentRowSpace,
|
|
),
|
|
).toBe(maxDistance);
|
|
});
|
|
|
|
it("should return distance for space in LEFT direction", () => {
|
|
//before it reaches max limit
|
|
let dimensionBeforeCollision = 40,
|
|
emptySpaces = 20,
|
|
maxDistance = -60 * gridProps.parentRowSpace;
|
|
expect(
|
|
getReflowDistance(
|
|
collisionTree,
|
|
ReflowDirection.LEFT,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
height,
|
|
emptySpaces,
|
|
gridProps.parentRowSpace,
|
|
),
|
|
).toBe(
|
|
-1 *
|
|
(dimensionBeforeCollision - emptySpaces) *
|
|
gridProps.parentRowSpace,
|
|
);
|
|
|
|
//reflowing past max limit
|
|
dimensionBeforeCollision = 90;
|
|
expect(
|
|
getReflowDistance(
|
|
collisionTree,
|
|
ReflowDirection.LEFT,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
height,
|
|
emptySpaces,
|
|
gridProps.parentRowSpace,
|
|
),
|
|
).toBe(maxDistance);
|
|
});
|
|
|
|
it("should return distance for space in RIGHT direction", () => {
|
|
//before it reaches max limit
|
|
let dimensionBeforeCollision = -40,
|
|
emptySpaces = 20,
|
|
maxDistance = 60 * gridProps.parentRowSpace;
|
|
expect(
|
|
getReflowDistance(
|
|
collisionTree,
|
|
ReflowDirection.RIGHT,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
width,
|
|
emptySpaces,
|
|
gridProps.parentColumnSpace,
|
|
),
|
|
).toBe(
|
|
-1 *
|
|
(dimensionBeforeCollision + emptySpaces) *
|
|
gridProps.parentColumnSpace,
|
|
);
|
|
|
|
//reflowing past max limit
|
|
dimensionBeforeCollision = -90;
|
|
expect(
|
|
getReflowDistance(
|
|
collisionTree,
|
|
ReflowDirection.RIGHT,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
width,
|
|
emptySpaces,
|
|
gridProps.parentColumnSpace,
|
|
),
|
|
).toBe(maxDistance);
|
|
});
|
|
});
|
|
|
|
describe("Test getReflowedDimension method", () => {
|
|
const collisionTree = {
|
|
id: "1234",
|
|
left: 90,
|
|
top: 100,
|
|
right: 150,
|
|
bottom: 140,
|
|
children: [],
|
|
},
|
|
width =
|
|
(collisionTree.right - collisionTree.left) *
|
|
gridProps.parentColumnSpace,
|
|
height =
|
|
(collisionTree.bottom - collisionTree.top) * gridProps.parentRowSpace;
|
|
|
|
describe("should return resized height in TOP direction", () => {
|
|
let dimensionBeforeCollision = 40,
|
|
emptySpaces = 20,
|
|
maxDistance = -60 * gridProps.parentRowSpace,
|
|
travelDistance = -50;
|
|
|
|
it("should return height when resize is off", () => {
|
|
expect(
|
|
getReflowedDimension(
|
|
collisionTree,
|
|
ReflowDirection.TOP,
|
|
travelDistance * gridProps.parentRowSpace,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
gridProps.parentRowSpace,
|
|
emptySpaces,
|
|
VERTICAL_RESIZE_MIN_LIMIT,
|
|
),
|
|
).toBe(height);
|
|
});
|
|
|
|
it("should return height before resize threshold", () => {
|
|
expect(
|
|
getReflowedDimension(
|
|
collisionTree,
|
|
ReflowDirection.TOP,
|
|
travelDistance * gridProps.parentRowSpace,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
gridProps.parentRowSpace,
|
|
emptySpaces,
|
|
VERTICAL_RESIZE_MIN_LIMIT,
|
|
true,
|
|
),
|
|
).toBe(height);
|
|
});
|
|
it("should return resized height after resize threshold before min height", () => {
|
|
dimensionBeforeCollision = 100;
|
|
const resizedHeight =
|
|
maxDistance +
|
|
(dimensionBeforeCollision - emptySpaces) * gridProps.parentRowSpace;
|
|
expect(
|
|
getReflowedDimension(
|
|
collisionTree,
|
|
ReflowDirection.TOP,
|
|
travelDistance * gridProps.parentRowSpace,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
gridProps.parentRowSpace,
|
|
emptySpaces,
|
|
VERTICAL_RESIZE_MIN_LIMIT,
|
|
true,
|
|
),
|
|
).toBe(resizedHeight);
|
|
});
|
|
it("should return min height after resize threshold after reaching min height", () => {
|
|
dimensionBeforeCollision = 130;
|
|
expect(
|
|
getReflowedDimension(
|
|
collisionTree,
|
|
ReflowDirection.TOP,
|
|
travelDistance * gridProps.parentRowSpace,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
gridProps.parentRowSpace,
|
|
emptySpaces,
|
|
VERTICAL_RESIZE_MIN_LIMIT,
|
|
true,
|
|
),
|
|
).toBe(VERTICAL_RESIZE_MIN_LIMIT * gridProps.parentRowSpace);
|
|
});
|
|
});
|
|
|
|
describe("should return resized width in LEFT direction", () => {
|
|
let dimensionBeforeCollision = 40,
|
|
emptySpaces = 20,
|
|
maxDistance = -60 * gridProps.parentColumnSpace,
|
|
travelDistance = -50;
|
|
|
|
it("should return width when resize is off", () => {
|
|
expect(
|
|
getReflowedDimension(
|
|
collisionTree,
|
|
ReflowDirection.LEFT,
|
|
travelDistance * gridProps.parentColumnSpace,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
gridProps.parentColumnSpace,
|
|
emptySpaces,
|
|
HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
),
|
|
).toBe(width);
|
|
});
|
|
|
|
it("should return width before resize threshold", () => {
|
|
expect(
|
|
getReflowedDimension(
|
|
collisionTree,
|
|
ReflowDirection.LEFT,
|
|
travelDistance * gridProps.parentColumnSpace,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
gridProps.parentColumnSpace,
|
|
emptySpaces,
|
|
HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
true,
|
|
),
|
|
).toBe(width);
|
|
});
|
|
|
|
it("should return resized width after resize threshold before min width", () => {
|
|
dimensionBeforeCollision = 110;
|
|
const resizedWidth =
|
|
maxDistance +
|
|
(dimensionBeforeCollision - emptySpaces) *
|
|
gridProps.parentColumnSpace;
|
|
expect(
|
|
getReflowedDimension(
|
|
collisionTree,
|
|
ReflowDirection.LEFT,
|
|
travelDistance * gridProps.parentColumnSpace,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
gridProps.parentColumnSpace,
|
|
emptySpaces,
|
|
HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
true,
|
|
),
|
|
).toBe(resizedWidth);
|
|
});
|
|
it("should return min width after resize threshold after reaching min width", () => {
|
|
dimensionBeforeCollision = 150;
|
|
expect(
|
|
getReflowedDimension(
|
|
collisionTree,
|
|
ReflowDirection.LEFT,
|
|
travelDistance * gridProps.parentColumnSpace,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
gridProps.parentColumnSpace,
|
|
emptySpaces,
|
|
HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
true,
|
|
),
|
|
).toBe(HORIZONTAL_RESIZE_MIN_LIMIT * gridProps.parentColumnSpace);
|
|
});
|
|
});
|
|
|
|
describe("should return resized width in RIGHT direction", () => {
|
|
let dimensionBeforeCollision = -40,
|
|
emptySpaces = 20,
|
|
maxDistance = 60 * gridProps.parentColumnSpace,
|
|
travelDistance = 50;
|
|
|
|
it("should return width when resize is off", () => {
|
|
expect(
|
|
getReflowedDimension(
|
|
collisionTree,
|
|
ReflowDirection.RIGHT,
|
|
travelDistance * gridProps.parentColumnSpace,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
gridProps.parentColumnSpace,
|
|
emptySpaces,
|
|
HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
),
|
|
).toBe(width);
|
|
});
|
|
|
|
it("should return width before resize threshold", () => {
|
|
expect(
|
|
getReflowedDimension(
|
|
collisionTree,
|
|
ReflowDirection.RIGHT,
|
|
travelDistance * gridProps.parentColumnSpace,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
gridProps.parentColumnSpace,
|
|
emptySpaces,
|
|
HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
true,
|
|
),
|
|
).toBe(width);
|
|
});
|
|
|
|
it("should return resized width after resize threshold before min width", () => {
|
|
dimensionBeforeCollision = -110;
|
|
const resizedWidth =
|
|
-1 *
|
|
(dimensionBeforeCollision + emptySpaces) *
|
|
gridProps.parentColumnSpace -
|
|
maxDistance;
|
|
expect(
|
|
getReflowedDimension(
|
|
collisionTree,
|
|
ReflowDirection.RIGHT,
|
|
travelDistance * gridProps.parentColumnSpace,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
gridProps.parentColumnSpace,
|
|
emptySpaces,
|
|
HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
true,
|
|
),
|
|
).toBe(resizedWidth);
|
|
});
|
|
it("should return min width after resize threshold after reaching min width", () => {
|
|
dimensionBeforeCollision = -150;
|
|
expect(
|
|
getReflowedDimension(
|
|
collisionTree,
|
|
ReflowDirection.RIGHT,
|
|
travelDistance * gridProps.parentColumnSpace,
|
|
maxDistance,
|
|
dimensionBeforeCollision,
|
|
gridProps.parentColumnSpace,
|
|
emptySpaces,
|
|
HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
true,
|
|
),
|
|
).toBe(HORIZONTAL_RESIZE_MIN_LIMIT * gridProps.parentColumnSpace);
|
|
});
|
|
});
|
|
});
|
|
describe("Test ShouldAddToCollisionSpacesArray method", () => {
|
|
const newSpacePosition = {
|
|
id: "1234",
|
|
left: 40,
|
|
top: 30,
|
|
right: 60,
|
|
bottom: 90,
|
|
children: [],
|
|
};
|
|
const OGPosition = {
|
|
id: "1234",
|
|
left: 40,
|
|
top: 30,
|
|
right: 60,
|
|
bottom: 70,
|
|
children: [],
|
|
};
|
|
const collidingSpace = {
|
|
id: "1235",
|
|
left: 30,
|
|
top: 80,
|
|
right: 50,
|
|
bottom: 110,
|
|
children: [],
|
|
};
|
|
const gridProps = {
|
|
parentRowSpace: 10,
|
|
parentRowSpace: 10,
|
|
};
|
|
const accessors = getAccessor(ReflowDirection.BOTTOM);
|
|
|
|
it("should return false if not intersecting", () => {
|
|
const localCollidingSpace = {
|
|
id: "1235",
|
|
left: 30,
|
|
top: 90,
|
|
right: 50,
|
|
bottom: 110,
|
|
children: [],
|
|
};
|
|
expect(
|
|
ShouldAddToCollisionSpacesArray(
|
|
newSpacePosition,
|
|
OGPosition,
|
|
localCollidingSpace,
|
|
ReflowDirection.BOTTOM,
|
|
).shouldAddToArray,
|
|
).toBe(false);
|
|
});
|
|
it("should return true while intersecting after confirming with previous movement map", () => {
|
|
const prevMovementMap = {
|
|
"1235": {
|
|
directionY: ReflowDirection.BOTTOM,
|
|
},
|
|
};
|
|
expect(
|
|
ShouldAddToCollisionSpacesArray(
|
|
newSpacePosition,
|
|
OGPosition,
|
|
collidingSpace,
|
|
ReflowDirection.BOTTOM,
|
|
accessors,
|
|
true,
|
|
gridProps,
|
|
ReflowDirection.BOTTOM,
|
|
prevMovementMap,
|
|
).shouldAddToArray,
|
|
).toBe(true);
|
|
});
|
|
it("should return false while intersecting after failing confirmation with previous movement map", () => {
|
|
const prevMovementMap = {
|
|
"1235": {
|
|
directionY: ReflowDirection.TOP,
|
|
},
|
|
};
|
|
expect(
|
|
ShouldAddToCollisionSpacesArray(
|
|
newSpacePosition,
|
|
OGPosition,
|
|
collidingSpace,
|
|
ReflowDirection.BOTTOM,
|
|
accessors,
|
|
true,
|
|
gridProps,
|
|
ReflowDirection.BOTTOM,
|
|
prevMovementMap,
|
|
).shouldAddToArray,
|
|
).toBe(false);
|
|
});
|
|
it("should return true while intersecting with isSecondaryCollidingWidget as false", () => {
|
|
expect(
|
|
ShouldAddToCollisionSpacesArray(
|
|
newSpacePosition,
|
|
OGPosition,
|
|
collidingSpace,
|
|
ReflowDirection.BOTTOM,
|
|
accessors,
|
|
false,
|
|
gridProps,
|
|
ReflowDirection.BOTTOM,
|
|
).shouldAddToArray,
|
|
).toBe(true);
|
|
});
|
|
|
|
it("should return true while intersecting with isSecondaryCollidingWidget as true and no prevSecondOrderCollisionMap", () => {
|
|
expect(
|
|
ShouldAddToCollisionSpacesArray(
|
|
newSpacePosition,
|
|
OGPosition,
|
|
collidingSpace,
|
|
ReflowDirection.BOTTOM,
|
|
accessors,
|
|
true,
|
|
gridProps,
|
|
ReflowDirection.BOTTOM,
|
|
{},
|
|
).shouldAddToArray,
|
|
).toBe(true);
|
|
});
|
|
it("should return true while intersecting with isSecondaryCollidingWidget as true, no prevMovementMap but with prevSecondOrderCollisionMap", () => {
|
|
expect(
|
|
ShouldAddToCollisionSpacesArray(
|
|
newSpacePosition,
|
|
OGPosition,
|
|
collidingSpace,
|
|
ReflowDirection.BOTTOM,
|
|
accessors,
|
|
true,
|
|
gridProps,
|
|
ReflowDirection.BOTTOM,
|
|
{},
|
|
{},
|
|
).shouldAddToArray,
|
|
).toBe(true);
|
|
});
|
|
});
|
|
describe("Test filterSpaceByDirection and filterCommonSpaces method", () => {
|
|
const occupiedSpaceMap = {
|
|
"1235": {
|
|
id: "1235",
|
|
left: 10,
|
|
top: 10,
|
|
right: 35,
|
|
bottom: 25,
|
|
},
|
|
"1236": {
|
|
id: "1236",
|
|
left: 30,
|
|
top: 20,
|
|
right: 50,
|
|
bottom: 35,
|
|
},
|
|
"1237": {
|
|
id: "1237",
|
|
left: 40,
|
|
top: 10,
|
|
right: 40,
|
|
bottom: 55,
|
|
},
|
|
"1238": {
|
|
id: "1238",
|
|
left: 90,
|
|
top: 60,
|
|
right: 130,
|
|
bottom: 90,
|
|
},
|
|
};
|
|
const filteredSpaceMap = {
|
|
"1237": {
|
|
id: "1237",
|
|
left: 40,
|
|
top: 10,
|
|
right: 40,
|
|
bottom: 55,
|
|
},
|
|
"1238": {
|
|
id: "1238",
|
|
left: 90,
|
|
top: 60,
|
|
right: 130,
|
|
bottom: 90,
|
|
},
|
|
};
|
|
it("filters spaces in a BOTTOM direction", () => {
|
|
const spaceToFilterFrom = {
|
|
id: "1234",
|
|
left: 40,
|
|
top: 50,
|
|
right: 80,
|
|
bottom: 70,
|
|
};
|
|
|
|
expect(
|
|
filterSpaceByDirection(
|
|
spaceToFilterFrom,
|
|
Object.values(occupiedSpaceMap),
|
|
ReflowDirection.BOTTOM,
|
|
),
|
|
).toEqual(Object.values(filteredSpaceMap));
|
|
});
|
|
|
|
it("filters out common spaces", () => {
|
|
const spacesToFilter = {
|
|
"1236": {},
|
|
"1235": {},
|
|
};
|
|
filterCommonSpaces(spacesToFilter, occupiedSpaceMap);
|
|
expect(occupiedSpaceMap).toEqual(filteredSpaceMap);
|
|
});
|
|
});
|
|
describe("Test getSpacesMapFromArray method", () => {
|
|
const occupiedSpaceMap = {
|
|
"1235": {
|
|
id: "1235",
|
|
left: 10,
|
|
top: 10,
|
|
right: 35,
|
|
bottom: 25,
|
|
},
|
|
"1236": {
|
|
id: "1236",
|
|
left: 30,
|
|
top: 20,
|
|
right: 50,
|
|
bottom: 35,
|
|
},
|
|
"1237": {
|
|
id: "1237",
|
|
left: 40,
|
|
top: 10,
|
|
right: 40,
|
|
bottom: 55,
|
|
},
|
|
"1238": {
|
|
id: "1238",
|
|
left: 90,
|
|
top: 60,
|
|
right: 130,
|
|
bottom: 90,
|
|
},
|
|
};
|
|
it("should return an map from array", () => {
|
|
expect(getSpacesMapFromArray(Object.values(occupiedSpaceMap))).toEqual(
|
|
occupiedSpaceMap,
|
|
);
|
|
});
|
|
});
|
|
describe("Test buildArrayToCollisionMap method", () => {
|
|
const collidingSpaces = [
|
|
{
|
|
id: "1235",
|
|
left: 10,
|
|
top: 10,
|
|
right: 35,
|
|
bottom: 25,
|
|
collidingValue: 20,
|
|
direction: ReflowDirection.BOTTOM,
|
|
},
|
|
{
|
|
id: "1236",
|
|
left: 30,
|
|
top: 20,
|
|
right: 50,
|
|
bottom: 35,
|
|
collidingValue: 10,
|
|
direction: ReflowDirection.LEFT,
|
|
},
|
|
{
|
|
id: "1237",
|
|
left: 40,
|
|
top: 10,
|
|
right: 40,
|
|
bottom: 55,
|
|
collidingValue: 10,
|
|
direction: ReflowDirection.TOP,
|
|
},
|
|
{
|
|
id: "1235",
|
|
left: 10,
|
|
top: 10,
|
|
right: 35,
|
|
bottom: 25,
|
|
collidingValue: 40,
|
|
direction: ReflowDirection.BOTTOM,
|
|
},
|
|
{
|
|
id: "1237",
|
|
left: 40,
|
|
top: 10,
|
|
right: 40,
|
|
bottom: 55,
|
|
collidingValue: 50,
|
|
direction: ReflowDirection.TOP,
|
|
},
|
|
{
|
|
id: "1238",
|
|
left: 90,
|
|
top: 60,
|
|
right: 130,
|
|
bottom: 90,
|
|
collidingValue: 30,
|
|
direction: ReflowDirection.BOTTOM,
|
|
},
|
|
];
|
|
it("should return an map from array", () => {
|
|
const collidingSpaceMap = {
|
|
"1236": {
|
|
id: "1236",
|
|
left: 30,
|
|
top: 20,
|
|
right: 50,
|
|
bottom: 35,
|
|
collidingValue: 10,
|
|
direction: ReflowDirection.LEFT,
|
|
order: 2,
|
|
},
|
|
"1237": {
|
|
id: "1237",
|
|
left: 40,
|
|
top: 10,
|
|
right: 40,
|
|
bottom: 55,
|
|
collidingValue: 10,
|
|
direction: ReflowDirection.TOP,
|
|
order: 3,
|
|
},
|
|
"1235": {
|
|
id: "1235",
|
|
left: 10,
|
|
top: 10,
|
|
right: 35,
|
|
bottom: 25,
|
|
collidingValue: 40,
|
|
direction: ReflowDirection.BOTTOM,
|
|
order: 4,
|
|
},
|
|
"1238": {
|
|
id: "1238",
|
|
left: 90,
|
|
top: 60,
|
|
right: 130,
|
|
bottom: 90,
|
|
collidingValue: 30,
|
|
direction: ReflowDirection.BOTTOM,
|
|
order: 5,
|
|
},
|
|
};
|
|
expect(buildArrayToCollisionMap(collidingSpaces)).toEqual(
|
|
collidingSpaceMap,
|
|
);
|
|
});
|
|
});
|
|
describe("Test getModifiedOccupiedSpacesMap method", () => {
|
|
const occupiedSpaceMap = {
|
|
"1236": {
|
|
id: "1236",
|
|
left: 30,
|
|
top: 20,
|
|
right: 50,
|
|
bottom: 35,
|
|
},
|
|
"1237": {
|
|
id: "1237",
|
|
left: 40,
|
|
top: 10,
|
|
right: 40,
|
|
bottom: 55,
|
|
},
|
|
"1235": {
|
|
id: "1235",
|
|
left: 10,
|
|
top: 10,
|
|
right: 35,
|
|
bottom: 25,
|
|
},
|
|
"1238": {
|
|
id: "1238",
|
|
left: 90,
|
|
top: 60,
|
|
right: 130,
|
|
bottom: 90,
|
|
},
|
|
};
|
|
const gridProps = {
|
|
parentColumnSpace: 10,
|
|
parentRowSpace: 10,
|
|
};
|
|
const prevMovementMap = {
|
|
"1236": {
|
|
Y: 10,
|
|
height: 150,
|
|
},
|
|
"1237": {
|
|
X: 20,
|
|
width: 180,
|
|
},
|
|
"1238": {
|
|
X: -100,
|
|
Y: -80,
|
|
width: 400,
|
|
height: 200,
|
|
},
|
|
};
|
|
it("should return horizontally modified occupied spaces map", () => {
|
|
const modifiedOccupiedSpacesMap = {
|
|
"1235": {
|
|
id: "1235",
|
|
left: 10,
|
|
top: 10,
|
|
right: 35,
|
|
bottom: 25,
|
|
},
|
|
"1236": {
|
|
id: "1236",
|
|
left: 30,
|
|
top: 20,
|
|
right: 50,
|
|
bottom: 35,
|
|
},
|
|
"1237": {
|
|
id: "1237",
|
|
left: 42,
|
|
top: 10,
|
|
right: 60,
|
|
bottom: 55,
|
|
},
|
|
"1238": {
|
|
id: "1238",
|
|
left: 80,
|
|
top: 60,
|
|
right: 120,
|
|
bottom: 90,
|
|
},
|
|
};
|
|
expect(
|
|
getModifiedOccupiedSpacesMap(
|
|
occupiedSpaceMap,
|
|
prevMovementMap,
|
|
false,
|
|
gridProps,
|
|
SpaceAttributes.right,
|
|
SpaceAttributes.left,
|
|
),
|
|
).toEqual(modifiedOccupiedSpacesMap);
|
|
});
|
|
it("should return vertically modified occupied spaces map", () => {
|
|
const modifiedOccupiedSpacesMap = {
|
|
"1235": {
|
|
id: "1235",
|
|
left: 10,
|
|
top: 10,
|
|
right: 35,
|
|
bottom: 25,
|
|
},
|
|
"1236": {
|
|
id: "1236",
|
|
left: 30,
|
|
top: 21,
|
|
right: 50,
|
|
bottom: 36,
|
|
},
|
|
"1237": {
|
|
id: "1237",
|
|
left: 40,
|
|
top: 10,
|
|
right: 40,
|
|
bottom: 55,
|
|
},
|
|
"1238": {
|
|
id: "1238",
|
|
left: 90,
|
|
top: 52,
|
|
right: 130,
|
|
bottom: 72,
|
|
},
|
|
};
|
|
expect(
|
|
getModifiedOccupiedSpacesMap(
|
|
occupiedSpaceMap,
|
|
prevMovementMap,
|
|
true,
|
|
gridProps,
|
|
SpaceAttributes.bottom,
|
|
SpaceAttributes.top,
|
|
),
|
|
).toEqual(modifiedOccupiedSpacesMap);
|
|
});
|
|
});
|
|
describe("Test getModifiedCollidingSpace method", () => {
|
|
const collidingSpace = {
|
|
id: "1238",
|
|
left: 90,
|
|
top: 60,
|
|
right: 130,
|
|
bottom: 90,
|
|
};
|
|
const occupiedSpaceMap = {
|
|
"1238": {
|
|
id: "1238",
|
|
left: 90,
|
|
top: 60,
|
|
right: 130,
|
|
bottom: 90,
|
|
},
|
|
};
|
|
const gridProps = {
|
|
parentColumnSpace: 10,
|
|
parentRowSpace: 10,
|
|
};
|
|
const prevMovementMap = {
|
|
"1238": {
|
|
X: -100,
|
|
Y: -80,
|
|
width: 400,
|
|
height: 200,
|
|
},
|
|
};
|
|
it("should return horizontally modified colliding Space", () => {
|
|
const modifiedCollidingSpace = {
|
|
id: "1238",
|
|
left: 80,
|
|
top: 60,
|
|
right: 120,
|
|
bottom: 90,
|
|
};
|
|
expect(
|
|
getModifiedCollidingSpace(
|
|
collidingSpace,
|
|
occupiedSpaceMap,
|
|
prevMovementMap,
|
|
false,
|
|
gridProps,
|
|
SpaceAttributes.right,
|
|
SpaceAttributes.left,
|
|
),
|
|
).toEqual(modifiedCollidingSpace);
|
|
});
|
|
it("should return vertically modified colliding Space", () => {
|
|
const modifiedOccupiedSpacesMap = {
|
|
id: "1238",
|
|
left: 90,
|
|
top: 52,
|
|
right: 130,
|
|
bottom: 72,
|
|
};
|
|
expect(
|
|
getModifiedCollidingSpace(
|
|
collidingSpace,
|
|
occupiedSpaceMap,
|
|
prevMovementMap,
|
|
true,
|
|
gridProps,
|
|
SpaceAttributes.bottom,
|
|
SpaceAttributes.top,
|
|
),
|
|
).toEqual(modifiedOccupiedSpacesMap);
|
|
});
|
|
});
|
|
describe("Test checkReCollisionWithOtherNewSpacePositions", () => {
|
|
const newSpacePositions = [
|
|
{
|
|
id: "1235",
|
|
left: 10,
|
|
top: 10,
|
|
right: 35,
|
|
bottom: 25,
|
|
},
|
|
{
|
|
id: "1236",
|
|
left: 30,
|
|
top: 20,
|
|
right: 50,
|
|
bottom: 35,
|
|
},
|
|
{
|
|
id: "1237",
|
|
left: 40,
|
|
top: 10,
|
|
right: 60,
|
|
bottom: 55,
|
|
},
|
|
];
|
|
it("should return false if there is no intersection", () => {
|
|
const collidingSpace = {
|
|
id: "1234",
|
|
left: 110,
|
|
top: 130,
|
|
right: 150,
|
|
bottom: 170,
|
|
};
|
|
expect(
|
|
checkReCollisionWithOtherNewSpacePositions(
|
|
collidingSpace,
|
|
collidingSpace,
|
|
ReflowDirection.BOTTOM,
|
|
ReflowDirection.BOTTOM,
|
|
newSpacePositions,
|
|
[],
|
|
1,
|
|
{},
|
|
{},
|
|
{},
|
|
),
|
|
).toBe(false);
|
|
});
|
|
it("should return false when there is intersection but previous direction does not match", () => {
|
|
const collidingSpace = {
|
|
id: "1234",
|
|
left: 40,
|
|
top: 45,
|
|
right: 60,
|
|
bottom: 60,
|
|
};
|
|
const prevCollidingSpaceMap = {
|
|
horizontal: {
|
|
1234: {
|
|
collidingId: "1237",
|
|
direction: ReflowDirection.LEFT,
|
|
},
|
|
},
|
|
};
|
|
expect(
|
|
checkReCollisionWithOtherNewSpacePositions(
|
|
collidingSpace,
|
|
collidingSpace,
|
|
ReflowDirection.BOTTOM,
|
|
ReflowDirection.BOTTOM,
|
|
newSpacePositions,
|
|
[],
|
|
1,
|
|
{},
|
|
{},
|
|
{ prevCollidingSpaceMap },
|
|
),
|
|
).toBe(false);
|
|
});
|
|
it("should return false when there is intersection and direction matches but colliding value is lesser than before", () => {
|
|
const collidingSpace = {
|
|
id: "1234",
|
|
left: 40,
|
|
top: 45,
|
|
right: 60,
|
|
bottom: 60,
|
|
collidingValue: 60,
|
|
};
|
|
expect(
|
|
checkReCollisionWithOtherNewSpacePositions(
|
|
collidingSpace,
|
|
collidingSpace,
|
|
ReflowDirection.BOTTOM,
|
|
ReflowDirection.BOTTOM,
|
|
newSpacePositions,
|
|
[],
|
|
1,
|
|
{},
|
|
{},
|
|
{},
|
|
),
|
|
).toBe(false);
|
|
});
|
|
it("should return true when there is intersection and direction matches but colliding value is greater than before", () => {
|
|
const collidingSpace = {
|
|
id: "1234",
|
|
left: 40,
|
|
top: 45,
|
|
right: 60,
|
|
bottom: 60,
|
|
collidingValue: 50,
|
|
};
|
|
expect(
|
|
checkReCollisionWithOtherNewSpacePositions(
|
|
collidingSpace,
|
|
collidingSpace,
|
|
ReflowDirection.BOTTOM,
|
|
ReflowDirection.BOTTOM,
|
|
newSpacePositions,
|
|
[],
|
|
1,
|
|
{},
|
|
{},
|
|
{},
|
|
),
|
|
).toBe(true);
|
|
});
|
|
it("should return true when there is intersection, colliding value is greater than before, previous direction does not match but is second run so it is forced in current direction", () => {
|
|
const collidingSpace = {
|
|
id: "1234",
|
|
left: 40,
|
|
top: 45,
|
|
right: 60,
|
|
bottom: 60,
|
|
collidingValue: 50,
|
|
};
|
|
const prevCollidingSpaceMap = {
|
|
horizontal: {
|
|
1234: {
|
|
collidingId: "1237",
|
|
direction: ReflowDirection.LEFT,
|
|
},
|
|
},
|
|
};
|
|
expect(
|
|
checkReCollisionWithOtherNewSpacePositions(
|
|
collidingSpace,
|
|
collidingSpace,
|
|
ReflowDirection.BOTTOM,
|
|
ReflowDirection.BOTTOM,
|
|
newSpacePositions,
|
|
[],
|
|
1,
|
|
{},
|
|
{},
|
|
{ prevCollidingSpaceMap },
|
|
true,
|
|
),
|
|
).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("Test getCalculatedDirection method", () => {
|
|
it("should return passed direction for composite direction", () => {
|
|
expect(
|
|
getCalculatedDirection({}, {}, ReflowDirection.BOTTOMLEFT),
|
|
).toEqual([ReflowDirection.BOTTOMLEFT]);
|
|
});
|
|
it("should return Top direction if moved only in top direction, regardless of passed direction", () => {
|
|
const newSpacePositions = {
|
|
"1234": {
|
|
top: 50,
|
|
left: 70,
|
|
},
|
|
};
|
|
const prevSpacePositions = {
|
|
"1234": {
|
|
top: 55,
|
|
left: 70,
|
|
},
|
|
};
|
|
expect(
|
|
getCalculatedDirection(
|
|
newSpacePositions,
|
|
prevSpacePositions,
|
|
ReflowDirection.BOTTOM,
|
|
),
|
|
).toEqual([ReflowDirection.TOP]);
|
|
});
|
|
it("should return right direction if moved only in right direction, regardless of passed direction", () => {
|
|
const newSpacePositions = {
|
|
"1234": {
|
|
top: 50,
|
|
left: 70,
|
|
},
|
|
};
|
|
const prevSpacePositions = {
|
|
"1234": {
|
|
top: 50,
|
|
left: 65,
|
|
},
|
|
};
|
|
expect(
|
|
getCalculatedDirection(
|
|
newSpacePositions,
|
|
prevSpacePositions,
|
|
ReflowDirection.BOTTOM,
|
|
),
|
|
).toEqual([ReflowDirection.RIGHT]);
|
|
});
|
|
it("should return bottom and left direction if moved in both bottom and left direction, regardless of passed direction", () => {
|
|
const newSpacePositions = {
|
|
"1234": {
|
|
top: 50,
|
|
left: 70,
|
|
},
|
|
};
|
|
const prevSpacePositions = {
|
|
"1234": {
|
|
top: 45,
|
|
left: 75,
|
|
},
|
|
};
|
|
expect(
|
|
getCalculatedDirection(
|
|
newSpacePositions,
|
|
prevSpacePositions,
|
|
ReflowDirection.BOTTOM,
|
|
),
|
|
).toEqual([ReflowDirection.BOTTOM, ReflowDirection.LEFT]);
|
|
});
|
|
});
|
|
|
|
describe("test getBottomMostRow", () => {
|
|
const occupiedSpaces = [
|
|
{ bottom: 10 },
|
|
{ bottom: 15 },
|
|
{ bottom: 90 },
|
|
{ bottom: 5 },
|
|
{ bottom: 67 },
|
|
{ bottom: 48 },
|
|
{ bottom: 36 },
|
|
];
|
|
it("should return bottom most row from the array", () => {
|
|
expect(getBottomMostRow(occupiedSpaces)).toBe(90);
|
|
});
|
|
});
|
|
|
|
describe("test initializeMovementLimitMap", () => {
|
|
const occupiedSpaces = [
|
|
{ id: "12" },
|
|
{ id: "13" },
|
|
{ id: "14" },
|
|
{ id: "15" },
|
|
{ id: "16" },
|
|
];
|
|
const initialMovementLimitMap = {
|
|
"12": {
|
|
canHorizontalMove: true,
|
|
canVerticalMove: true,
|
|
},
|
|
"13": {
|
|
canHorizontalMove: true,
|
|
canVerticalMove: true,
|
|
},
|
|
"14": {
|
|
canHorizontalMove: true,
|
|
canVerticalMove: true,
|
|
},
|
|
"15": {
|
|
canHorizontalMove: true,
|
|
canVerticalMove: true,
|
|
},
|
|
"16": {
|
|
canHorizontalMove: true,
|
|
canVerticalMove: true,
|
|
},
|
|
};
|
|
it("should return a map with all the spaces with canHorizontalMove and canVerticalMove set as true", () => {
|
|
expect(initializeMovementLimitMap(occupiedSpaces)).toEqual(
|
|
initialMovementLimitMap,
|
|
);
|
|
});
|
|
});
|
|
describe("test checkProcessNodeForTree", () => {
|
|
const collidingSpace = {
|
|
id: "1234",
|
|
collidingValue: 10,
|
|
direction: ReflowDirection.BOTTOM,
|
|
};
|
|
it("should be true if the processed nodes object is undefined", () => {
|
|
const processedNodes = {};
|
|
expect(checkProcessNodeForTree(collidingSpace, processedNodes)).toEqual({
|
|
shouldProcessNode: true,
|
|
});
|
|
});
|
|
it("should be false if the current node has a value in the opposite direction", () => {
|
|
const processedNodes = {
|
|
"1234": {
|
|
TOP: {
|
|
value: 15,
|
|
},
|
|
},
|
|
};
|
|
expect(checkProcessNodeForTree(collidingSpace, processedNodes)).toEqual({
|
|
shouldProcessNode: false,
|
|
});
|
|
});
|
|
it("should be true if the current node is not processed in the current direction", () => {
|
|
const processedNodes = {
|
|
"1234": {
|
|
LEFT: {
|
|
value: 15,
|
|
},
|
|
},
|
|
};
|
|
expect(checkProcessNodeForTree(collidingSpace, processedNodes)).toEqual({
|
|
shouldProcessNode: true,
|
|
});
|
|
});
|
|
it("should be false if the current node is processed in the current direction if the current node's colliding value is lesser", () => {
|
|
const processedNodes = {
|
|
"1234": {
|
|
BOTTOM: {
|
|
value: 15,
|
|
},
|
|
},
|
|
};
|
|
expect(checkProcessNodeForTree(collidingSpace, processedNodes)).toEqual({
|
|
shouldProcessNode: false,
|
|
});
|
|
});
|
|
it("should be true if the current node is processed in the current direction if the current node's colliding value is greater", () => {
|
|
const processedNodes = {
|
|
"1234": {
|
|
BOTTOM: { value: 5 },
|
|
},
|
|
};
|
|
expect(checkProcessNodeForTree(collidingSpace, processedNodes)).toEqual({
|
|
shouldProcessNode: true,
|
|
});
|
|
});
|
|
it("should be false and return cached values if colliding values equal each other", () => {
|
|
const processedNodes = {
|
|
"1234": {
|
|
BOTTOM: {
|
|
value: 10,
|
|
occupiedLength: 5 * VERTICAL_RESIZE_MIN_LIMIT,
|
|
occupiedSpace: 10,
|
|
currentEmptySpaces: 10,
|
|
},
|
|
},
|
|
};
|
|
expect(checkProcessNodeForTree(collidingSpace, processedNodes)).toEqual({
|
|
shouldProcessNode: false,
|
|
occupiedLength: 5 * VERTICAL_RESIZE_MIN_LIMIT,
|
|
occupiedSpace: 10,
|
|
currentEmptySpaces: 10,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("test getRelativeCollidingValue", () => {
|
|
const gridProps = {
|
|
maxGridColumns: 64,
|
|
};
|
|
it("should return original colliding value if direction is Bottom", () => {
|
|
const direction = ReflowDirection.BOTTOM;
|
|
const accessors = getAccessor(direction);
|
|
const collidingValue = 10;
|
|
const depth = 5;
|
|
expect(
|
|
getRelativeCollidingValue(
|
|
accessors,
|
|
collidingValue,
|
|
direction,
|
|
gridProps,
|
|
depth * VERTICAL_RESIZE_MIN_LIMIT,
|
|
),
|
|
).toBe(collidingValue);
|
|
});
|
|
it("should return original colliding value if depth is less compared to colliding value", () => {
|
|
const direction = ReflowDirection.TOP;
|
|
const accessors = getAccessor(direction);
|
|
const collidingValue = 8;
|
|
const depth = 1;
|
|
expect(
|
|
getRelativeCollidingValue(
|
|
accessors,
|
|
collidingValue,
|
|
direction,
|
|
gridProps,
|
|
depth * VERTICAL_RESIZE_MIN_LIMIT,
|
|
),
|
|
).toBe(collidingValue);
|
|
});
|
|
it("should return calculated colliding value if depth is high compared to colliding value in TOP direction", () => {
|
|
const direction = ReflowDirection.TOP;
|
|
const accessors = getAccessor(direction);
|
|
const collidingValue = 8;
|
|
const depth = 3;
|
|
expect(
|
|
getRelativeCollidingValue(
|
|
accessors,
|
|
collidingValue,
|
|
direction,
|
|
gridProps,
|
|
depth * VERTICAL_RESIZE_MIN_LIMIT,
|
|
),
|
|
).toBe(depth * VERTICAL_RESIZE_MIN_LIMIT);
|
|
});
|
|
it("should return calculated colliding value if depth is high compared to colliding value in LEFT direction", () => {
|
|
const direction = ReflowDirection.LEFT;
|
|
const accessors = getAccessor(direction);
|
|
const collidingValue = 5;
|
|
const depth = 3;
|
|
expect(
|
|
getRelativeCollidingValue(
|
|
accessors,
|
|
collidingValue,
|
|
direction,
|
|
gridProps,
|
|
depth * HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
),
|
|
).toBe(depth * HORIZONTAL_RESIZE_MIN_LIMIT);
|
|
});
|
|
it("should return calculated colliding value if depth is high compared to colliding value in RIGHT direction", () => {
|
|
const direction = ReflowDirection.RIGHT;
|
|
const accessors = getAccessor(direction);
|
|
const collidingValue = 60;
|
|
const depth = 3;
|
|
expect(
|
|
getRelativeCollidingValue(
|
|
accessors,
|
|
collidingValue,
|
|
direction,
|
|
gridProps,
|
|
depth * HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
),
|
|
).toBe(gridProps.maxGridColumns - depth * HORIZONTAL_RESIZE_MIN_LIMIT);
|
|
});
|
|
});
|
|
|
|
describe("while testing getContainerExitEdge, it should return edge direction that is closest to mouse", () => {
|
|
const exitContainer = {
|
|
id: "exit",
|
|
left: 20,
|
|
right: 60,
|
|
top: 20,
|
|
bottom: 70,
|
|
};
|
|
it("should return RIGHT if closer to right container edge", () => {
|
|
const mousePointer = {
|
|
left: 62,
|
|
top: 40,
|
|
};
|
|
expect(getContainerExitEdge(exitContainer, mousePointer)).toEqual(
|
|
ReflowDirection.RIGHT,
|
|
);
|
|
});
|
|
|
|
it("should return LEFT if closer to right container edge", () => {
|
|
const mousePointer = {
|
|
left: 19,
|
|
top: 40,
|
|
};
|
|
expect(getContainerExitEdge(exitContainer, mousePointer)).toEqual(
|
|
ReflowDirection.LEFT,
|
|
);
|
|
});
|
|
|
|
it("should return TOP if closer to top container edge", () => {
|
|
const mousePointer = {
|
|
left: 40,
|
|
top: 19,
|
|
};
|
|
expect(getContainerExitEdge(exitContainer, mousePointer)).toEqual(
|
|
ReflowDirection.TOP,
|
|
);
|
|
});
|
|
|
|
it("should return BOTTOM if closer to bottom container edge", () => {
|
|
const mousePointer = {
|
|
left: 40,
|
|
top: 72,
|
|
};
|
|
expect(getContainerExitEdge(exitContainer, mousePointer)).toEqual(
|
|
ReflowDirection.BOTTOM,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("test getCollisionDirectionOfDropTarget method", () => {
|
|
const containerSpace = {
|
|
id: "container",
|
|
left: 20,
|
|
right: 60,
|
|
top: 20,
|
|
bottom: 70,
|
|
};
|
|
|
|
it("should return current direction if it is possible push direction", () => {
|
|
const mousePosition = {
|
|
left: 63,
|
|
top: 75,
|
|
};
|
|
expect(
|
|
getCollisionDirectionOfDropTarget(
|
|
containerSpace,
|
|
ReflowDirection.LEFT,
|
|
mousePosition,
|
|
),
|
|
).toBe(ReflowDirection.LEFT);
|
|
|
|
expect(
|
|
getCollisionDirectionOfDropTarget(
|
|
containerSpace,
|
|
ReflowDirection.TOP,
|
|
mousePosition,
|
|
),
|
|
).toBe(ReflowDirection.TOP);
|
|
});
|
|
|
|
it("should return push direction if mouse is only on one edge even if direction sent is not the same", () => {
|
|
let mousePosition = {
|
|
left: 40,
|
|
top: 14,
|
|
};
|
|
expect(
|
|
getCollisionDirectionOfDropTarget(
|
|
containerSpace,
|
|
ReflowDirection.UNSET,
|
|
mousePosition,
|
|
),
|
|
).toBe(ReflowDirection.BOTTOM);
|
|
|
|
mousePosition = {
|
|
left: 67,
|
|
top: 40,
|
|
};
|
|
expect(
|
|
getCollisionDirectionOfDropTarget(
|
|
containerSpace,
|
|
ReflowDirection.UNSET,
|
|
mousePosition,
|
|
),
|
|
).toBe(ReflowDirection.LEFT);
|
|
});
|
|
|
|
it("should return push direction which is farthest from edge, if it has 2 possible directions and the direction sent is not one of them", () => {
|
|
let mousePosition = {
|
|
left: 18,
|
|
top: 14,
|
|
};
|
|
expect(
|
|
getCollisionDirectionOfDropTarget(
|
|
containerSpace,
|
|
ReflowDirection.UNSET,
|
|
mousePosition,
|
|
),
|
|
).toBe(ReflowDirection.BOTTOM);
|
|
});
|
|
});
|
|
|
|
describe("test modifyResizePosition method", () => {
|
|
const containerSpace = {
|
|
id: "container",
|
|
left: 20,
|
|
right: 60,
|
|
top: 20,
|
|
bottom: 70,
|
|
};
|
|
it("should return resized position based on direction of collision with Container's left side", () => {
|
|
const spacePosition = {
|
|
id: "id",
|
|
left: 10,
|
|
right: 30,
|
|
top: 15,
|
|
bottom: 40,
|
|
};
|
|
const resizedPosition = {
|
|
id: "id",
|
|
left: 10,
|
|
right: 20,
|
|
top: 15,
|
|
bottom: 40,
|
|
};
|
|
|
|
expect(
|
|
modifyResizePosition(
|
|
spacePosition,
|
|
containerSpace,
|
|
ReflowDirection.RIGHT,
|
|
),
|
|
).toEqual(resizedPosition);
|
|
});
|
|
|
|
it("should return resized position based on direction of collision with Container's right side", () => {
|
|
const spacePosition = {
|
|
id: "id",
|
|
left: 50,
|
|
right: 90,
|
|
top: 15,
|
|
bottom: 40,
|
|
};
|
|
const resizedPosition = {
|
|
id: "id",
|
|
left: 60,
|
|
right: 90,
|
|
top: 15,
|
|
bottom: 40,
|
|
};
|
|
|
|
expect(
|
|
modifyResizePosition(
|
|
spacePosition,
|
|
containerSpace,
|
|
ReflowDirection.LEFT,
|
|
),
|
|
).toEqual(resizedPosition);
|
|
});
|
|
|
|
it("should return resized position based on direction of collision with Container's top side", () => {
|
|
const spacePosition = {
|
|
id: "id",
|
|
left: 15,
|
|
right: 40,
|
|
top: 5,
|
|
bottom: 40,
|
|
};
|
|
const resizedPosition = {
|
|
id: "id",
|
|
left: 15,
|
|
right: 40,
|
|
top: 5,
|
|
bottom: 20,
|
|
};
|
|
|
|
expect(
|
|
modifyResizePosition(
|
|
spacePosition,
|
|
containerSpace,
|
|
ReflowDirection.BOTTOM,
|
|
),
|
|
).toEqual(resizedPosition);
|
|
});
|
|
|
|
it("should return resized position based on direction of collision with Container's bottom side", () => {
|
|
const spacePosition = {
|
|
id: "id",
|
|
left: 15,
|
|
right: 40,
|
|
top: 60,
|
|
bottom: 95,
|
|
};
|
|
const resizedPosition = {
|
|
id: "id",
|
|
left: 15,
|
|
right: 40,
|
|
top: 70,
|
|
bottom: 95,
|
|
};
|
|
|
|
expect(
|
|
modifyResizePosition(
|
|
spacePosition,
|
|
containerSpace,
|
|
ReflowDirection.TOP,
|
|
),
|
|
).toEqual(resizedPosition);
|
|
});
|
|
|
|
it("should return resized position based on direction of collision but with min heights and widths", () => {
|
|
let spacePosition = {
|
|
id: "id",
|
|
left: 19,
|
|
right: 40,
|
|
top: 19,
|
|
bottom: 95,
|
|
};
|
|
let resizedPosition = {
|
|
id: "id",
|
|
left: 19,
|
|
right: 40,
|
|
top: 19,
|
|
bottom: 19 + VERTICAL_RESIZE_MIN_LIMIT,
|
|
};
|
|
|
|
expect(
|
|
modifyResizePosition(
|
|
spacePosition,
|
|
containerSpace,
|
|
ReflowDirection.BOTTOM,
|
|
),
|
|
).toEqual(resizedPosition);
|
|
|
|
resizedPosition = {
|
|
id: "id",
|
|
left: 19,
|
|
right: 19 + HORIZONTAL_RESIZE_MIN_LIMIT,
|
|
top: 19,
|
|
bottom: 95,
|
|
};
|
|
|
|
expect(
|
|
modifyResizePosition(
|
|
spacePosition,
|
|
containerSpace,
|
|
ReflowDirection.RIGHT,
|
|
),
|
|
).toEqual(resizedPosition);
|
|
|
|
spacePosition.fixedHeight = 95 - 19;
|
|
expect(
|
|
modifyResizePosition(
|
|
spacePosition,
|
|
containerSpace,
|
|
ReflowDirection.BOTTOM,
|
|
),
|
|
).toEqual(spacePosition);
|
|
});
|
|
});
|
|
|
|
it("should test willItCauseUndroppableState method, it should return true if any value is false", () => {
|
|
const movementLimitMap = {
|
|
"1": {
|
|
canVerticalMove: true,
|
|
canHorizontalMove: true,
|
|
},
|
|
"2": {
|
|
canVerticalMove: true,
|
|
canHorizontalMove: true,
|
|
},
|
|
};
|
|
|
|
expect(willItCauseUndroppableState(movementLimitMap)).toEqual(false);
|
|
|
|
movementLimitMap["3"] = {
|
|
canVerticalMove: true,
|
|
canHorizontalMove: false,
|
|
};
|
|
expect(willItCauseUndroppableState(movementLimitMap)).toEqual(true);
|
|
});
|
|
|
|
it("verifyMovementLimits should check if space is colliding with any container and return movementLimits based on that", () => {
|
|
const movementLimits = {
|
|
"1": {
|
|
canVerticalMove: true,
|
|
canHorizontalMove: true,
|
|
},
|
|
"2": {
|
|
canVerticalMove: true,
|
|
canHorizontalMove: true,
|
|
},
|
|
"3": {
|
|
canVerticalMove: false,
|
|
canHorizontalMove: true,
|
|
},
|
|
};
|
|
|
|
const occupiedSpacesMap = {
|
|
"4": {
|
|
left: 50,
|
|
right: 70,
|
|
top: 60,
|
|
bottom: 90,
|
|
isDropTarget: true,
|
|
},
|
|
};
|
|
const spacePositionMap = {
|
|
"1": {
|
|
left: 10,
|
|
right: 40,
|
|
top: 20,
|
|
bottom: 50,
|
|
},
|
|
"2": {
|
|
left: 20,
|
|
right: 65,
|
|
top: 20,
|
|
bottom: 50,
|
|
},
|
|
"3": {
|
|
left: 90,
|
|
right: 110,
|
|
top: 20,
|
|
bottom: 50,
|
|
},
|
|
};
|
|
|
|
const verifiedMovementLimits = {
|
|
"1": {
|
|
canVerticalMove: true,
|
|
canHorizontalMove: true,
|
|
},
|
|
"2": {
|
|
canVerticalMove: true,
|
|
canHorizontalMove: true,
|
|
},
|
|
"3": {
|
|
canVerticalMove: false,
|
|
canHorizontalMove: true,
|
|
},
|
|
};
|
|
|
|
expect(
|
|
verifyMovementLimits(movementLimits, spacePositionMap, occupiedSpacesMap),
|
|
).toEqual(verifiedMovementLimits);
|
|
});
|
|
});
|