@flighthq/geometry 0.1.0

package/src/rectanglePool.test.ts

@@ -0,0 +1,71 @@
+import type { Rectangle } from '@flighthq/types';
+
+import { acquireEmptyRectangle, acquireRectangle, clearRectanglePool, releaseRectangle } from './rectanglePool';
+
+beforeEach(() => {
+  clearRectanglePool();
+});
+
+describe('acquireEmptyRectangle', () => {
+  it('returns a rectangle with all properties set to 0', () => {
+    const r = acquireEmptyRectangle();
+    expect(r.x).toBe(0);
+    expect(r.y).toBe(0);
+    expect(r.width).toBe(0);
+    expect(r.height).toBe(0);
+  });
+
+  it('resets a released rectangle to empty', () => {
+    const r1 = acquireRectangle();
+    r1.x = 5;
+    r1.y = 10;
+    r1.width = 50;
+    r1.height = 100;
+    releaseRectangle(r1);
+    const r2 = acquireEmptyRectangle();
+    expect(r2).toBe(r1);
+    expect(r2.x).toBe(0);
+    expect(r2.y).toBe(0);
+    expect(r2.width).toBe(0);
+    expect(r2.height).toBe(0);
+  });
+});
+
+describe('acquireRectangle', () => {
+  it('returns a new Rectangle when pool is empty', () => {
+    const r: Rectangle = acquireRectangle();
+    expect(r).not.toBeNull();
+  });
+
+  it('reuses released rectangles', () => {
+    const r1 = acquireRectangle();
+    releaseRectangle(r1);
+    const r2 = acquireRectangle();
+    expect(r2).toBe(r1);
+  });
+
+  it('reuses released rectangles in last-in-first-out order', () => {
+    const r1 = acquireRectangle();
+    const r2 = acquireRectangle();
+    releaseRectangle(r1);
+    releaseRectangle(r2);
+    expect(acquireRectangle()).toBe(r2);
+    expect(acquireRectangle()).toBe(r1);
+  });
+});
+
+describe('clearRectanglePool', () => {
+  it('empties the pool so the next get allocates fresh', () => {
+    const r = acquireRectangle();
+    releaseRectangle(r);
+    clearRectanglePool();
+    const r2 = acquireRectangle();
+    expect(r2).not.toBe(r);
+  });
+});
+
+describe('releaseRectangle', () => {
+  it('handles null safely', () => {
+    expect(() => releaseRectangle(null as unknown as Rectangle)).not.toThrow();
+  });
+});

package/src/typedarray.test.ts

@@ -0,0 +1,118 @@
+import { reserveFloat32Array, reserveInt16Array, reserveUint16Array } from './typedarray';
+
+describe('reserveFloat32Array', () => {
+  it('returns the same array if the capacity is equal', () => {
+    const array = new Float32Array(100);
+    const out = reserveFloat32Array(array, 100);
+    expect(out).toStrictEqual(array);
+  });
+
+  it('returns the same array if the capacity is less than existing length', () => {
+    const array = new Float32Array(100);
+    const out = reserveFloat32Array(array, 10);
+    expect(out).toStrictEqual(array);
+    expect(out.length).toBe(100);
+  });
+
+  it('allocates a new array if the capacity is larger', () => {
+    const array = new Float32Array(100);
+    const out = reserveFloat32Array(array, 1000);
+    expect(out).not.toStrictEqual(array);
+    expect(out.length).toBe(1000);
+  });
+
+  it('leaves extended capacity zero-filled', () => {
+    const array = new Float32Array([1, 2]);
+    const out = reserveFloat32Array(array, 4);
+    expect(Array.from(out)).toEqual([1, 2, 0, 0]);
+  });
+
+  it('copies the existing array values if it allocates', () => {
+    const array = new Float32Array(10);
+    for (let i = 0; i < 10; i++) {
+      array[i] = i;
+    }
+    const out = reserveFloat32Array(array, 100);
+    for (let i = 0; i < 10; i++) {
+      expect(out[i]).toBe(array[i]);
+    }
+  });
+});
+
+describe('reserveInt16Array', () => {
+  it('returns the same array if the capacity is equal', () => {
+    const array = new Int16Array(100);
+    const out = reserveInt16Array(array, 100);
+    expect(out).toStrictEqual(array);
+  });
+
+  it('returns the same array if the capacity is less than existing length', () => {
+    const array = new Int16Array(100);
+    const out = reserveInt16Array(array, 10);
+    expect(out).toStrictEqual(array);
+    expect(out.length).toBe(100);
+  });
+
+  it('allocates a new array if the capacity is larger', () => {
+    const array = new Int16Array(100);
+    const out = reserveInt16Array(array, 1000);
+    expect(out).not.toStrictEqual(array);
+    expect(out.length).toBe(1000);
+  });
+
+  it('leaves extended capacity zero-filled', () => {
+    const array = new Int16Array([1, 2]);
+    const out = reserveInt16Array(array, 4);
+    expect(Array.from(out)).toEqual([1, 2, 0, 0]);
+  });
+
+  it('copies the existing array values if it allocates', () => {
+    const array = new Int16Array(10);
+    for (let i = 0; i < 10; i++) {
+      array[i] = i;
+    }
+    const out = reserveInt16Array(array, 100);
+    for (let i = 0; i < 10; i++) {
+      expect(out[i]).toBe(array[i]);
+    }
+  });
+});
+
+describe('reserveUint16Array', () => {
+  it('returns the same array if the capacity is equal', () => {
+    const array = new Uint16Array(100);
+    const out = reserveUint16Array(array, 100);
+    expect(out).toStrictEqual(array);
+  });
+
+  it('returns the same array if the capacity is less than existing length', () => {
+    const array = new Uint16Array(100);
+    const out = reserveUint16Array(array, 10);
+    expect(out).toStrictEqual(array);
+    expect(out.length).toBe(100);
+  });
+
+  it('allocates a new array if the capacity is larger', () => {
+    const array = new Uint16Array(100);
+    const out = reserveUint16Array(array, 1000);
+    expect(out).not.toStrictEqual(array);
+    expect(out.length).toBe(1000);
+  });
+
+  it('leaves extended capacity zero-filled', () => {
+    const array = new Uint16Array([1, 2]);
+    const out = reserveUint16Array(array, 4);
+    expect(Array.from(out)).toEqual([1, 2, 0, 0]);
+  });
+
+  it('copies the existing array values if it allocates', () => {
+    const array = new Uint16Array(10);
+    for (let i = 0; i < 10; i++) {
+      array[i] = i;
+    }
+    const out = reserveUint16Array(array, 100);
+    for (let i = 0; i < 10; i++) {
+      expect(out[i]).toBe(array[i]);
+    }
+  });
+});