ComfyUI_frontend/test/infrastructure/Rectangle.resize.test.ts

import { beforeEach, describe, expect, test } from "vitest"

import { Rectangle } from "@/infrastructure/Rectangle"

describe("Rectangle resize functionality", () => {
  let rect: Rectangle

  beforeEach(() => {
    rect = new Rectangle(100, 200, 300, 400) // x, y, width, height
    // So: left=100, top=200, right=400, bottom=600
  })

  describe("findContainingCorner", () => {
    const cornerSize = 15

    test("should detect NW (top-left) corner", () => {
      expect(rect.findContainingCorner(100, 200, cornerSize)).toBe("NW")
      expect(rect.findContainingCorner(110, 210, cornerSize)).toBe("NW")
      expect(rect.findContainingCorner(114, 214, cornerSize)).toBe("NW")
    })

    test("should detect NE (top-right) corner", () => {
      // Top-right corner starts at (right - cornerSize, top) = (385, 200)
      expect(rect.findContainingCorner(385, 200, cornerSize)).toBe("NE")
      expect(rect.findContainingCorner(390, 210, cornerSize)).toBe("NE")
      expect(rect.findContainingCorner(399, 214, cornerSize)).toBe("NE")
    })

    test("should detect SW (bottom-left) corner", () => {
      // Bottom-left corner starts at (left, bottom - cornerSize) = (100, 585)
      expect(rect.findContainingCorner(100, 585, cornerSize)).toBe("SW")
      expect(rect.findContainingCorner(110, 590, cornerSize)).toBe("SW")
      expect(rect.findContainingCorner(114, 599, cornerSize)).toBe("SW")
    })

    test("should detect SE (bottom-right) corner", () => {
      // Bottom-right corner starts at (right - cornerSize, bottom - cornerSize) = (385, 585)
      expect(rect.findContainingCorner(385, 585, cornerSize)).toBe("SE")
      expect(rect.findContainingCorner(390, 590, cornerSize)).toBe("SE")
      expect(rect.findContainingCorner(399, 599, cornerSize)).toBe("SE")
    })

    test("should return undefined when not in any corner", () => {
      // Middle of rectangle
      expect(rect.findContainingCorner(250, 400, cornerSize)).toBeUndefined()
      // On edge but not in corner
      expect(rect.findContainingCorner(200, 200, cornerSize)).toBeUndefined()
      expect(rect.findContainingCorner(100, 400, cornerSize)).toBeUndefined()
      // Outside rectangle
      expect(rect.findContainingCorner(50, 150, cornerSize)).toBeUndefined()
    })
  })

  describe("corner detection methods", () => {
    const cornerSize = 20

    describe("isInTopLeftCorner", () => {
      test("should return true when point is in top-left corner", () => {
        expect(rect.isInTopLeftCorner(100, 200, cornerSize)).toBe(true)
        expect(rect.isInTopLeftCorner(110, 210, cornerSize)).toBe(true)
        expect(rect.isInTopLeftCorner(119, 219, cornerSize)).toBe(true)
      })

      test("should return false when point is outside top-left corner", () => {
        expect(rect.isInTopLeftCorner(120, 200, cornerSize)).toBe(false)
        expect(rect.isInTopLeftCorner(100, 220, cornerSize)).toBe(false)
        expect(rect.isInTopLeftCorner(99, 200, cornerSize)).toBe(false)
        expect(rect.isInTopLeftCorner(100, 199, cornerSize)).toBe(false)
      })
    })

    describe("isInTopRightCorner", () => {
      test("should return true when point is in top-right corner", () => {
        // Top-right corner area is from (right - cornerSize, top) to (right, top + cornerSize)
        // That's (380, 200) to (400, 220)
        expect(rect.isInTopRightCorner(380, 200, cornerSize)).toBe(true)
        expect(rect.isInTopRightCorner(390, 210, cornerSize)).toBe(true)
        expect(rect.isInTopRightCorner(399, 219, cornerSize)).toBe(true)
      })

      test("should return false when point is outside top-right corner", () => {
        expect(rect.isInTopRightCorner(379, 200, cornerSize)).toBe(false)
        expect(rect.isInTopRightCorner(400, 220, cornerSize)).toBe(false)
        expect(rect.isInTopRightCorner(401, 200, cornerSize)).toBe(false)
        expect(rect.isInTopRightCorner(400, 199, cornerSize)).toBe(false)
      })
    })

    describe("isInBottomLeftCorner", () => {
      test("should return true when point is in bottom-left corner", () => {
        // Bottom-left corner area is from (left, bottom - cornerSize) to (left + cornerSize, bottom)
        // That's (100, 580) to (120, 600)
        expect(rect.isInBottomLeftCorner(100, 580, cornerSize)).toBe(true)
        expect(rect.isInBottomLeftCorner(110, 590, cornerSize)).toBe(true)
        expect(rect.isInBottomLeftCorner(119, 599, cornerSize)).toBe(true)
      })

      test("should return false when point is outside bottom-left corner", () => {
        expect(rect.isInBottomLeftCorner(120, 600, cornerSize)).toBe(false)
        expect(rect.isInBottomLeftCorner(100, 579, cornerSize)).toBe(false)
        expect(rect.isInBottomLeftCorner(99, 600, cornerSize)).toBe(false)
        expect(rect.isInBottomLeftCorner(100, 601, cornerSize)).toBe(false)
      })
    })

    describe("isInBottomRightCorner", () => {
      test("should return true when point is in bottom-right corner", () => {
        // Bottom-right corner area is from (right - cornerSize, bottom - cornerSize) to (right, bottom)
        // That's (380, 580) to (400, 600)
        expect(rect.isInBottomRightCorner(380, 580, cornerSize)).toBe(true)
        expect(rect.isInBottomRightCorner(390, 590, cornerSize)).toBe(true)
        expect(rect.isInBottomRightCorner(399, 599, cornerSize)).toBe(true)
      })

      test("should return false when point is outside bottom-right corner", () => {
        expect(rect.isInBottomRightCorner(379, 600, cornerSize)).toBe(false)
        expect(rect.isInBottomRightCorner(400, 579, cornerSize)).toBe(false)
        expect(rect.isInBottomRightCorner(401, 600, cornerSize)).toBe(false)
        expect(rect.isInBottomRightCorner(400, 601, cornerSize)).toBe(false)
      })
    })
  })

  describe("edge cases", () => {
    test("should handle zero-sized corner areas", () => {
      expect(rect.findContainingCorner(100, 200, 0)).toBeUndefined()
      expect(rect.isInTopLeftCorner(100, 200, 0)).toBe(false)
    })

    test("should handle rectangles at origin", () => {
      const originRect = new Rectangle(0, 0, 100, 100)
      expect(originRect.findContainingCorner(0, 0, 10)).toBe("NW")
      // Bottom-right corner is at (90, 90) to (100, 100)
      expect(originRect.findContainingCorner(90, 90, 10)).toBe("SE")
    })

    test("should handle negative coordinates", () => {
      const negRect = new Rectangle(-50, -50, 100, 100)
      expect(negRect.findContainingCorner(-50, -50, 10)).toBe("NW")
      // Bottom-right corner is at (40, 40) to (50, 50)
      expect(negRect.findContainingCorner(40, 40, 10)).toBe("SE")
    })
  })
})