@ue-too/board 0.5.2 → 0.6.0

package/test/board-camera/camera-utils.test.ts

@@ -1,263 +0,0 @@
-import { withinBoundaries, normalizeAngleZero2TwoPI, angleSpan, convert2WorldSpace, invertFromWorldSpace, convert2WorldSpaceAnchorAtCenter, convert2ViewPortSpaceAnchorAtCenter, transformationMatrixFromCamera, convert2WorldSpaceWithTransformationMatrix } from "../../src/camera";
-import { clampRotation, RotationLimits, rotationWithinBoundary, RotationBoundary, rotationWithinLimits } from "../../src/camera/utils/rotation";
-
-import { Boundaries, halfTranslationWidthOf, translationWidthOf, translationHeightOf, halfTranslationHeightOf } from "../../src/camera/utils/position";
-
-describe("withinBoundaries", () => {
-
-    test("should return true if no boundaries", () => {
-        expect(withinBoundaries({x: 0, y: 0}, undefined)).toBe(true);
-    });
-
-    test("should return true if point is within boundaries", () => {
-        expect(withinBoundaries({x: 0, y: 0}, {min: {x: -1, y: -1}, max: {x: 1, y: 1}})).toBe(true);
-    });
-
-    test("should return false if point is outside boundaries", () => {
-        expect(withinBoundaries({x: 0, y: 0}, {min: {x: 1, y: 1}, max: {x: 2, y: 2}})).toBe(false);
-    });
-
-    test("should still work if only one boundary is defined", () => {
-        expect(withinBoundaries({x: 0, y: 0}, {min: {x: -1, y: -1}})).toBe(true);
-        expect(withinBoundaries({x: 0, y: 0}, {max: {x: 1, y: 1}})).toBe(true);
-        expect(withinBoundaries({x: 0, y: 0}, {min: {x: 1, y: 1}})).toBe(false);
-        expect(withinBoundaries({x: 0, y: 0}, {max: {x: -1, y: -1}})).toBe(false);
-    });
-
-    test("should still work if only one axis is defined", () => {
-        expect(withinBoundaries({x: 0, y: 0}, {min: {x: -1}})).toBe(true);
-        expect(withinBoundaries({x: 0, y: 0}, {max: {x: 1}})).toBe(true);
-        expect(withinBoundaries({x: 0, y: 0}, {min: {x: 1}})).toBe(false);
-        expect(withinBoundaries({x: 0, y: 0}, {max: {x: -1}})).toBe(false);
-    });
-        
-});
-
-describe("rotation boundaries testing", ()=>{
-    test("should return true if the rotation is within the boundaries", ()=>{
-        const rotationBoundaries: RotationBoundary = {start: 0, end: Math.PI, positiveDirection: true, startAsTieBreaker: true};
-        expect(rotationWithinBoundary(0, rotationBoundaries)).toBe(true);
-        expect(rotationWithinBoundary(Math.PI, rotationBoundaries)).toBe(true);
-        expect(rotationWithinBoundary(Math.PI / 2, rotationBoundaries)).toBe(true);
-    });
-
-    test("should return false if the rotation is outside the boundaries", ()=>{
-        const rotationBoundaries: RotationBoundary = {start: 0, end: Math.PI, positiveDirection: true, startAsTieBreaker: true};
-        expect(rotationWithinBoundary(-Math.PI / 2, rotationBoundaries)).toBe(false);
-        expect(rotationWithinBoundary(Math.PI * 3 / 2, rotationBoundaries)).toBe(false);
-    });
-
-    test("should still work if the boundaries cross the 0 degree mark", ()=>{
-        const rotationBoundaries: RotationBoundary = {start: (360 - 45) * Math.PI / 180, end: 45 * Math.PI / 180, positiveDirection: true, startAsTieBreaker: true};
-        expect(rotationWithinBoundary(0, rotationBoundaries)).toBe(true);
-        expect(rotationWithinBoundary(50 * Math.PI / 180, rotationBoundaries)).toBe(false);
-        expect(rotationWithinBoundary(330 * Math.PI / 180, rotationBoundaries)).toBe(true);
-        expect(rotationWithinBoundary(300 * Math.PI / 180, rotationBoundaries)).toBe(false);
-        expect(rotationWithinBoundary(-50 * Math.PI / 180, rotationBoundaries)).toBe(false);
-        expect(rotationWithinBoundary(315 * Math.PI / 180, rotationBoundaries)).toBe(true);
-    });
-
-    test("should return false if the rotation is outside the boundaries", ()=>{
-        const rotationBoundaries: RotationBoundary = {start: (360 - 45) * Math.PI / 180, end: 45 * Math.PI / 180, positiveDirection: true, startAsTieBreaker: true};
-        expect(rotationWithinBoundary(50 * Math.PI / 180, rotationBoundaries)).toBe(false);
-    });
-
-    test("should return true for a full revolution boundary", ()=>{
-        const rotationBoundaries: RotationBoundary = {start: 0, end: Math.PI * 2, positiveDirection: true, startAsTieBreaker: true};
-        expect(rotationWithinBoundary(0, rotationBoundaries)).toBe(true);
-        expect(rotationWithinBoundary(Math.PI * 2, rotationBoundaries)).toBe(true);
-        expect(rotationWithinBoundary(1, rotationBoundaries)).toBe(true);
-        expect(rotationWithinBoundary(Math.PI * 2 - 1, rotationBoundaries)).toBe(true);
-    });
-});
-
-describe("rotationLimits", ()=>{
-    test("should return true if the rotation is within the boundaries", ()=>{
-        const rotationLimits: RotationLimits = {start: 0, end: Math.PI, ccw: true, startAsTieBreaker: true};
-        expect(rotationWithinLimits(0, rotationLimits)).toBe(true);
-        expect(rotationWithinLimits(Math.PI, rotationLimits)).toBe(true);
-        expect(rotationWithinLimits(Math.PI / 2, rotationLimits)).toBe(true);
-    });
-
-    test("should return false if the rotation is outside the boundaries", ()=>{
-        const rotationLimits: RotationLimits = {start: 0, end: Math.PI, ccw: true, startAsTieBreaker: true};
-        expect(rotationWithinLimits(-Math.PI / 2, rotationLimits)).toBe(false);
-        expect(rotationWithinLimits(Math.PI * 3 / 2, rotationLimits)).toBe(false);
-    });
-
-    test("should still work if the boundaries cross the 0 degree mark", ()=>{
-        const rotationLimits: RotationLimits = {start: (360 - 45) * Math.PI / 180, end: 45 * Math.PI / 180, ccw: true, startAsTieBreaker: true};
-        expect(rotationWithinLimits(0, rotationLimits)).toBe(true);
-        expect(rotationWithinLimits(50 * Math.PI / 180, rotationLimits)).toBe(false);
-        expect(rotationWithinLimits(330 * Math.PI / 180, rotationLimits)).toBe(true);
-        expect(rotationWithinLimits(300 * Math.PI / 180, rotationLimits)).toBe(false);
-        expect(rotationWithinLimits(-50 * Math.PI / 180, rotationLimits)).toBe(false);
-        expect(rotationWithinLimits(315 * Math.PI / 180, rotationLimits)).toBe(true);
-    });
-
-    test("should return false if the rotation is outside the boundaries", ()=>{
-        const rotationLimits: RotationLimits = {start: (360 - 45) * Math.PI / 180, end: 45 * Math.PI / 180, ccw: true, startAsTieBreaker: true};
-        expect(rotationWithinLimits(50 * Math.PI / 180, rotationLimits)).toBe(false);
-    });
-
-    test("should return true for a full revolution limit", ()=>{
-        const rotationLimits: RotationLimits = {start: 0, end: Math.PI * 2, ccw: true, startAsTieBreaker: true};
-        expect(rotationWithinLimits(0, rotationLimits)).toBe(true);
-        expect(rotationWithinLimits(Math.PI * 2, rotationLimits)).toBe(true);
-        expect(rotationWithinLimits(Math.PI * 2 + 1, rotationLimits)).toBe(true);
-        expect(rotationWithinLimits(Math.PI * 2 - 1, rotationLimits)).toBe(true);
-    });
-});
-
-describe("get the translation dimensions from boundaries", () => {
-    
-    test("translation width from boundaries", ()=>{
-        let boundaries: Boundaries | undefined = undefined;
-
-        expect(translationWidthOf(boundaries)).toBe(undefined);
-        boundaries = {min: {x: 0}, max: {x: 10}};
-        expect(translationWidthOf(boundaries)).toBe(10);
-        expect(halfTranslationWidthOf(boundaries)).toBe(5);
-    });
-
-    test("translation height from boundaries", ()=>{
-        let boundaries: Boundaries | undefined = undefined;
-
-        expect(translationHeightOf(boundaries)).toBe(undefined);
-        boundaries = {min: {y: 0}, max: {y: 10}};
-        expect(translationHeightOf(boundaries)).toBe(10);
-        expect(halfTranslationHeightOf(boundaries)).toBe(5);
-    });
-
-});
-
-describe("normalizeAngleZero2TwoPI", () => {
-    test("should return the same angle if it is already between 0 and 2PI", () => {
-        expect(normalizeAngleZero2TwoPI(0)).toBe(0);
-        expect(normalizeAngleZero2TwoPI(Math.PI)).toBe(Math.PI);
-        expect(normalizeAngleZero2TwoPI(Math.PI * 2)).toBe(0);
-    });
-
-    test("should return the normalized angle if it is not between 0 and 2PI", () => {
-        expect(normalizeAngleZero2TwoPI(-45 * Math.PI / 180)).toBeCloseTo(315 * Math.PI / 180);
-        expect(normalizeAngleZero2TwoPI(-Math.PI)).toBe(Math.PI);
-        expect(normalizeAngleZero2TwoPI(-Math.PI * 2)).toBe(0);
-        expect(normalizeAngleZero2TwoPI(Math.PI * 3)).toBe(Math.PI);
-        expect(normalizeAngleZero2TwoPI(Math.PI * 4)).toBe(0);
-    });
-});
-
-describe("angle clamping", ()=>{
-
-    test("should return the same angle if it is within the limits", ()=>{
-        const limits:RotationLimits = {start: 0, end: Math.PI, ccw: true, startAsTieBreaker: true};
-        expect(clampRotation(0, limits)).toBe(0);
-        expect(clampRotation(Math.PI, limits)).toBe(Math.PI);
-        expect(clampRotation(Math.PI / 2, limits)).toBe(Math.PI / 2);
-
-    });
-
-    test("should return the clamped angle if out of limits with tie", ()=>{
-        const limits:RotationLimits = {start: 0, end: Math.PI, ccw: true, startAsTieBreaker: true};
-        expect(clampRotation(-Math.PI / 2, limits)).toBe(0);
-        expect(clampRotation(Math.PI * 3 / 2, limits)).toBeCloseTo(0);
-    });
-
-    test("counter-clockwise rotation limits crossing the 0 degree mark", ()=>{
-        const limits: RotationLimits = {start: (360 - 45) * Math.PI / 180, end: 45 * Math.PI / 180, ccw: true, startAsTieBreaker: true};
-        expect(clampRotation(0, limits)).toBe(0);
-        expect(clampRotation(50 * Math.PI / 180, limits)).toBe(45 * Math.PI / 180);
-        expect(clampRotation(330 * Math.PI / 180, limits)).toBeCloseTo(330 * Math.PI / 180);
-        expect(clampRotation(300 * Math.PI / 180, limits)).toBe(315 * Math.PI / 180);
-        expect(clampRotation(-50 * Math.PI / 180, limits)).toBe(315 * Math.PI / 180);
-    });
-
-    test("clockwise rotation limits crossing the 0 degree mark", ()=>{
-        const limits: RotationLimits = {start: 45 * Math.PI / 180, end: 315 * Math.PI / 180, ccw: false, startAsTieBreaker: true};
-        expect(clampRotation(0, limits)).toBe(0);
-        expect(clampRotation(50 * Math.PI / 180, limits)).toBe(45 * Math.PI / 180);
-        expect(clampRotation(-50 * Math.PI / 180, limits)).toBe(315 * Math.PI / 180);
-    });
-
-});
-
-describe("calculate the minimum angle span from an angle to another", () => {
-
-    test("a full revolution meaning no angle span", () => {
-        expect(angleSpan(0, Math.PI * 2)).toBe(0);
-        expect(angleSpan(0, -Math.PI * 2)).toBe(0);
-        expect(angleSpan(Math.PI * 2, Math.PI * 4)).toBe(0);
-    });
-
-    test("testing the angle span between 0 and 90 degrees", ()=>{
-        expect(angleSpan(0, Math.PI / 2)).toBe(Math.PI / 2);
-        expect(angleSpan(-Math.PI / 2, 0)).toBe(Math.PI / 2);
-    });
-
-    test("testing the angle span that rotating clockwise is smaller than rotating counter clockwise", ()=>{
-        expect(angleSpan(0, 270 * Math.PI / 180)).toBeCloseTo(-90 * Math.PI / 180);
-    });
-
-    test("testing the angle span that cross the 0 degree mark", ()=>{
-        expect(angleSpan(22.5 * Math.PI / 180, -22.5 * Math.PI / 180)).toBeCloseTo(- 45 * Math.PI / 180);
-    });
-});
-
-describe("coordinate conversion", () => {
-    test("Convert point within camera view to world space", ()=>{
-        const testRes = convert2WorldSpace({x: 100, y: 100}, 1000, 1000, {x: 30, y: 50}, 10, -45 * Math.PI / 180);
-        expect(testRes.x).toBeCloseTo(30 - (800 / (Math.sqrt(2) * 10)));
-        expect(testRes.y).toBeCloseTo(50);
-        const testRes2 = convert2WorldSpace({x: 100, y: 100}, 1000, 1000, {x: 10, y: 10}, 1, 0);
-        expect(testRes2.x).toBeCloseTo(-390);
-        expect(testRes2.y).toBeCloseTo(-390);
-    });
-
-    test("Convert point within camera view to world space with the camera position as view port origin", ()=>{
-        const testRes = convert2WorldSpaceAnchorAtCenter({x: -400, y: -400},  {x: 30, y: 50}, 10, -45 * Math.PI / 180);
-        expect(testRes.x).toBeCloseTo(30 - (800 / (Math.sqrt(2) * 10)));
-        expect(testRes.y).toBeCloseTo(50);
-        const testRes2 = convert2WorldSpaceAnchorAtCenter({x: -400, y: -400}, {x: 10, y: 10}, 1, 0);
-        expect(testRes2.x).toBeCloseTo(-390);
-        expect(testRes2.y).toBeCloseTo(-390);
-    });
-
-    test("Convert point within world space to camera view", ()=>{
-        const point = {x: 10, y: 30};
-        const cameraCenterInViewPort = {x: 500, y: 500};
-        const testRes = invertFromWorldSpace(point, 1000, 1000, {x: 30, y: 50}, 1, 0);
-        expect(testRes.x).toBeCloseTo(cameraCenterInViewPort.x - 20);
-        expect(testRes.y).toBeCloseTo(cameraCenterInViewPort.y - 20);
-        const test2Point = {x: 10, y: 50};
-        const testRes2 = invertFromWorldSpace(test2Point, 1000, 1000, {x: 30, y: 50}, 1, -45 * Math.PI / 180);
-        const expectedRes = {x: 500 - 20 / Math.sqrt(2), y: 500 - 20 / Math.sqrt(2)};
-        expect(testRes2.x).toBeCloseTo(expectedRes.x);
-        expect(testRes2.y).toBeCloseTo(expectedRes.y);
-    });
-
-    test("Convert point within world space to camera view with camera position as viewport origin", ()=>{
-        const point = {x: 10, y: 30};
-        const testRes = convert2ViewPortSpaceAnchorAtCenter(point, {x: 30, y: 50}, 1, 0);
-        expect(testRes.x).toBeCloseTo(-20);
-        expect(testRes.y).toBeCloseTo(-20);
-        const test2Point = {x: 10, y: 50};
-        const testRes2 = convert2ViewPortSpaceAnchorAtCenter(test2Point, {x: 30, y: 50}, 1, -45 * Math.PI / 180);
-        const expectedRes = {x: - 20 / Math.sqrt(2), y: - 20 / Math.sqrt(2)};
-        expect(testRes2.x).toBeCloseTo(expectedRes.x);
-        expect(testRes2.y).toBeCloseTo(expectedRes.y);
-    });
-    
-    describe('coorindate conversion using transformation matrix', ()=>{
-        test("should convert point within world space to camera view", ()=>{
-            const point = {x: -400, y: -400};
-            const transformationMatrix = transformationMatrixFromCamera({x: 30, y: 50}, 10, -45 * Math.PI / 180);
-            const testRes = convert2WorldSpaceWithTransformationMatrix(point, transformationMatrix);
-            expect(testRes.x).toBeCloseTo(30 - (800 / (Math.sqrt(2) * 10)));
-            expect(testRes.y).toBeCloseTo(50);
-            const transformationMatrix2 = transformationMatrixFromCamera({x: 10, y: 10}, 1, 0);
-            const testRes2 = convert2WorldSpaceWithTransformationMatrix(point, transformationMatrix2);
-            expect(testRes2.x).toBeCloseTo(-390);
-            expect(testRes2.y).toBeCloseTo(-390);
-        });
-    });
-});

package/test/board-camera/utils/coordinate-conversion.test.ts

@@ -1,26 +0,0 @@
-import { convertDeltaInViewPortToWorldSpace, convertDeltaInWorldToViewPortSpace } from "../../../src/camera/utils/coordinate-conversion";
-
-const testcases = [
-
-];
-
-describe("convertDeltaInWorldToViewPortSpace", ()=>{
-    it("should convert delta in world space to view port space", ()=>{
-        const delta = {x: -7.071067811865475, y: 7.071067811865475};
-        const cameraZoomLevel = 1;
-        const cameraRotation = 45 * Math.PI / 180;
-        const result = convertDeltaInWorldToViewPortSpace(delta, cameraZoomLevel, cameraRotation);
-        expect(result.x).toBeCloseTo(0);
-        expect(result.y).toBeCloseTo(10);
-    });
-
-    it("should convert delta in view port space to world space", ()=>{
-        const delta = {x: 0, y: 10};
-        const cameraZoomLevel = 1;
-        const cameraRotation = 45 * Math.PI / 180;
-        const result = convertDeltaInViewPortToWorldSpace(delta, cameraZoomLevel, cameraRotation);
-        expect(result.x).toBeCloseTo(-7.071067811865475);
-        expect(result.y).toBeCloseTo(7.071067811865475);
-    });
-
-});

package/test/board-camera/utils/matrix.test.ts

@@ -1,35 +0,0 @@
-import { createCameraMatrix, decomposeCameraMatrix } from "../../../src/camera/utils/matrix";
-
-describe("matrix operations", ()=>{
-    it("should decompose the matrix correctly", ()=>{
-        const originalCamera = {
-            position: { x: 100, y: 50 },
-            zoom: 2.0,
-            rotation: Math.PI / 6 // 30 degrees
-        };
-        const devicePixelRatio = 1.5;
-        const canvasWidth = 800;
-        const canvasHeight = 600;
-
-        const matrix = createCameraMatrix(
-            originalCamera.position, 
-            originalCamera.zoom, 
-            originalCamera.rotation, 
-            devicePixelRatio, 
-            canvasWidth, 
-            canvasHeight
-        );
-
-        const decomposed = decomposeCameraMatrix(
-            matrix, 
-            devicePixelRatio, 
-            canvasWidth, 
-            canvasHeight
-        );
-
-        expect(decomposed.position.x).toBeCloseTo(originalCamera.position.x);
-        expect(decomposed.position.y).toBeCloseTo(originalCamera.position.y);
-        expect(decomposed.zoom).toBeCloseTo(originalCamera.zoom);
-        expect(decomposed.rotation).toBeCloseTo(originalCamera.rotation);
-    });
-});

package/test/boardify/utils/canvas.test.ts

@@ -1,20 +0,0 @@
-import { invertYAxisForDrawImageWith9Args } from "../../../src/utils";
-
-// Mock Image class for testing
-class MockImage {
-    width: number;
-    height: number;
-    constructor(width: number, height: number) {
-        this.width = width;
-        this.height = height;
-    }
-}
-
-describe("canvas", () => {
-    it("should invert the y-axis for drawImage with 9 arguments", () => {
-        const image = new MockImage(1200, 1500);
-        const args = [image, 0, 0, 300, 300, 200, 200, 300, 300];
-        const newArgs = invertYAxisForDrawImageWith9Args(args);
-        expect(newArgs).toEqual([image, 0, 1500, 300, -300, 200, -500, 300, 300]);
-    });
-});

package/test/util/drawing.test.ts

@@ -1,83 +0,0 @@
-import { calculateTickValues } from '../../src/utils/drawing';
-
-describe('calculateTickValues', () => {
-    it('should calculate correct tick values for a basic range', () => {
-        const result = calculateTickValues(0, 100);
-        
-        expect(result.minMajorTickValue).toBe(0);
-        expect(result.maxMajorTickValue).toBe(100);
-        expect(result.majorTickStep).toBe(100);
-        expect(result.minMinTickValue).toBe(0);
-        expect(result.maxMaxTickValue).toBe(100);
-        expect(result.minTickStep).toBe(10);
-        expect(result.minHalfTickValue).toBe(0);
-        expect(result.maxHalfTickValue).toBe(100);
-        expect(result.halfTickStep).toBe(50);
-        expect(result.calibrationMultiplier).toBe(1);
-        expect(result.normalizedOrderOfMagnitude).toBe(2);
-    });
-
-    it('should handle negative ranges correctly', () => {
-        const result = calculateTickValues(-100, 0);
-        
-        expect(result.minMajorTickValue).toBe(-100);
-        expect(result.maxMajorTickValue).toBe(0);
-        expect(result.majorTickStep).toBe(100);
-        expect(result.minMinTickValue).toBe(-100);
-        expect(result.maxMaxTickValue).toBe(0);
-        expect(result.minTickStep).toBe(10);
-        expect(result.minHalfTickValue).toBe(-100);
-        expect(result.maxHalfTickValue).toBe(0);
-        expect(result.halfTickStep).toBe(50);
-        expect(result.calibrationMultiplier).toBe(1);
-        expect(result.normalizedOrderOfMagnitude).toBe(2);
-    });
-
-    it('should handle large ranges with appropriate order of magnitude', () => {
-        const result = calculateTickValues(0, 1000);
-        
-        expect(result.minMajorTickValue).toBe(0);
-        expect(result.maxMajorTickValue).toBe(1000);
-        expect(result.majorTickStep).toBe(1000);
-        expect(result.minMinTickValue).toBe(0);
-        expect(result.maxMaxTickValue).toBe(1000);
-        expect(result.minTickStep).toBe(100);
-        expect(result.minHalfTickValue).toBe(0);
-        expect(result.maxHalfTickValue).toBe(1000);
-        expect(result.halfTickStep).toBe(500);
-        expect(result.calibrationMultiplier).toBe(1);
-        expect(result.normalizedOrderOfMagnitude).toBe(3);
-    });
-
-    it('should respect provided order of magnitude', () => {
-        const result = calculateTickValues(0, 100, 2);
-        
-        expect(result.minMajorTickValue).toBe(0);
-        expect(result.maxMajorTickValue).toBe(100);
-        expect(result.majorTickStep).toBe(100);
-        expect(result.minMinTickValue).toBe(0);
-        expect(result.maxMaxTickValue).toBe(100);
-        expect(result.minTickStep).toBe(10);
-        expect(result.minHalfTickValue).toBe(0);
-        expect(result.maxHalfTickValue).toBe(100);
-        expect(result.halfTickStep).toBe(50);
-        expect(result.calibrationMultiplier).toBe(1);
-        expect(result.normalizedOrderOfMagnitude).toBe(2);
-    });
-
-    it('should handle small ranges with appropriate precision', () => {
-        const result = calculateTickValues(0, 0.1);
-        
-        expect(result.minMajorTickValue).toBe(0);
-        expect(result.maxMajorTickValue).toBe(10);
-        expect(result.majorTickStep).toBe(10);
-        expect(result.minMinTickValue).toBe(0);
-        expect(result.maxMaxTickValue).toBe(10);
-        expect(result.minTickStep).toBe(1);
-        expect(result.minHalfTickValue).toBe(0);
-        expect(result.maxHalfTickValue).toBe(10);
-        expect(result.halfTickStep).toBe(5);
-        expect(result.calibrationMultiplier).toBe(0.01);
-        expect(result.normalizedOrderOfMagnitude).toBe(1);
-    });
-}); 

package/test/util/handler-pipeline.test.ts

@@ -1,74 +0,0 @@
-import { createHandlerChain } from "../../src/utils/handler-pipeline";
-
-describe("handler-pipeline", ()=>{
-    it("should create a handler chain from an array of handlers", ()=>{
-        const handler1 = jest.fn().mockReturnValue(2);
-        const handler2 = jest.fn().mockReturnValue(3);
-        const handler3 = jest.fn().mockReturnValue(4);
-        const handlerChain = createHandlerChain(handler1, handler2, handler3);
-        const result = handlerChain(1);
-        expect(handler1).toHaveBeenCalledWith(1);
-        expect(handler2).toHaveBeenCalledWith(2);
-        expect(handler3).toHaveBeenCalledWith(3);
-        expect(result).toBe(4);
-    });
-
-    it("should pass additional arguments to each handler", () => {
-        const handler1 = jest.fn().mockReturnValue(2);
-        const handler2 = jest.fn().mockReturnValue(3);
-        const handler3 = jest.fn().mockReturnValue(4);
-        const handlerChain = createHandlerChain(handler1, handler2, handler3);
-        const result = handlerChain(1, "arg1", "arg2");
-        expect(handler1).toHaveBeenCalledWith(1, "arg1", "arg2");
-        expect(handler2).toHaveBeenCalledWith(2, "arg1", "arg2");
-        expect(handler3).toHaveBeenCalledWith(3, "arg1", "arg2");
-        expect(result).toBe(4);
-    });
-
-    it("should work with a single handler", () => {
-        const handler = jest.fn().mockReturnValue(2);
-        const handlerChain = createHandlerChain(handler);
-        const result = handlerChain(1);
-        expect(handler).toHaveBeenCalledWith(1);
-        expect(result).toBe(2);
-    });
-
-    it("should work with an array of handlers", () => {
-        const handler1 = jest.fn().mockReturnValue(2);
-        const handler2 = jest.fn().mockReturnValue(3);
-        const handler3 = jest.fn().mockReturnValue(4);
-        const handlers = [handler1, handler2, handler3];
-        const handlerChain = createHandlerChain(handlers);
-        const result = handlerChain(1);
-        expect(handler1).toHaveBeenCalledWith(1);
-        expect(handler2).toHaveBeenCalledWith(2);
-        expect(handler3).toHaveBeenCalledWith(3);
-        expect(result).toBe(4);
-    });
-
-    it("should return the initial value if no handlers are provided", () => {
-        const handlerChain = createHandlerChain();
-        const result = handlerChain(1);
-        expect(result).toBe(1);
-    });
-
-    it("should handle handlers that return undefined", () => {
-        const handler1 = jest.fn().mockReturnValue(undefined);
-        const handler2 = jest.fn().mockReturnValue(3);
-        const handlerChain = createHandlerChain(handler1, handler2);
-        const result = handlerChain(1);
-        expect(handler1).toHaveBeenCalledWith(1);
-        expect(handler2).toHaveBeenCalledWith(undefined);
-        expect(result).toBe(3);
-    });
-
-    it("should handle handlers that return null", () => {
-        const handler1 = jest.fn().mockReturnValue(null);
-        const handler2 = jest.fn().mockReturnValue(3);
-        const handlerChain = createHandlerChain(handler1, handler2);
-        const result = handlerChain(1);
-        expect(handler1).toHaveBeenCalledWith(1);
-        expect(handler2).toHaveBeenCalledWith(null);
-        expect(result).toBe(3);
-    });
-});

package/test/util/observable.test.ts

@@ -1,42 +0,0 @@
-import { Observable } from "../../src/utils/observable";
-
-describe("observable", ()=>{
-    it("should notify observers when data is changed", async ()=>{
-        const observable = new Observable<[number]>();
-        const observer = jest.fn();
-        observable.subscribe(observer);
-        observable.notify(1);
-        
-        // Wait for microtasks to complete
-        await Promise.resolve();
-        
-        expect(observer).toHaveBeenCalledWith(1);
-    });
-
-    it("should unsubscribe observer when unsubscribe function is called", async ()=>{
-        const observable = new Observable<[number]>();
-        const observer = jest.fn();
-        const unsubscribe = observable.subscribe(observer);
-        observable.notify(1);
-        await Promise.resolve();
-        expect(observer).toHaveBeenCalledWith(1);
-        unsubscribe();
-        observable.notify(2);
-        await Promise.resolve();
-        expect(observer).toHaveBeenCalledTimes(1);
-    });
-
-    it("should unsubscribe observer when signal is aborted", async ()=>{
-        const observable = new Observable<[number]>();
-        const observer = jest.fn();
-        const abortController = new AbortController();
-        observable.subscribe(observer, {signal: abortController.signal});
-        observable.notify(1);
-        await Promise.resolve();
-        expect(observer).toHaveBeenCalledWith(1);
-        abortController.abort();
-        observable.notify(2);
-        await Promise.resolve();
-        expect(observer).toHaveBeenCalledTimes(1);
-    });
-});

package/test/util/ruler.test.ts

@@ -1,41 +0,0 @@
-import { calculateOrderOfMagnitude } from "../../src/utils";
-
-describe("Ruler related utility functions", () => {
-    describe("calculateOrderOfMagnitude", () => {
-        test("should return 0 for 1", () => {
-            expect(calculateOrderOfMagnitude(1)).toBe(0);
-        });
-
-        test("should return 0 for 9", () => {
-            expect(calculateOrderOfMagnitude(9)).toBe(0);
-        });
-
-        test("should return 1 for 10", () => {
-            expect(calculateOrderOfMagnitude(10)).toBe(1);
-        });
-
-        test("should return 1 for 99", () => {
-            expect(calculateOrderOfMagnitude(99)).toBe(1);
-        });
-
-        test("should return 2 for 100", () => {
-            expect(calculateOrderOfMagnitude(100)).toBe(2);
-        });
-
-        test("should return -1 for 0.1", () => {
-            expect(calculateOrderOfMagnitude(0.1)).toBe(-1);
-        });
-        
-        test("should return -1 for 0.9", () => {
-            expect(calculateOrderOfMagnitude(0.9)).toBe(-1);
-        });
-
-        test("should return -2 for 0.01", () => {
-            expect(calculateOrderOfMagnitude(0.01)).toBe(-2);
-        });
-
-        test("should return -3 for 0.001", () => {
-            expect(calculateOrderOfMagnitude(0.001)).toBe(-3);
-        });
-    });
-});

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "baseUrl": ".",
-    "outDir": "dist",
-    "tsBuildInfoFile": "dist/board.tsbuildinfo",
-    "declaration": true,
-    "moduleResolution": "node",
-    "module": "esnext",
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "references": [
-    {
-      "path": "../being"
-    },
-    {
-      "path": "../math"
-    }
-  ]
-}

package/tsconfig.spec.json

@@ -1,12 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "baseUrl": ".",
-    "outDir": "dist",
-    "tsBuildInfoFile": "dist/board.tsbuildinfo",
-    "declaration": true
-  },
-  "include": ["test/**/*"]
-}
-