@ue-too/board 0.5.1 → 0.5.2

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

@@ -0,0 +1,263 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,23 @@
+{
+  "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

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