@osmix/core 0.1.8 → 0.2.0

package/test/typed-arrays.test.ts

@@ -1,134 +1,135 @@
-import { describe, expect, it } from "bun:test"
-import { BufferConstructor, ResizeableTypedArray } from "../src/typed-arrays"
+import { describe, expect, it } from "vitest";
+
+import { BufferConstructor, ResizeableTypedArray } from "../src/typed-arrays";
 
 describe("typed array helpers", () => {
-	it("selects the appropriate buffer constructor", () => {
-		if (typeof SharedArrayBuffer !== "undefined") {
-			expect(BufferConstructor).toBe(SharedArrayBuffer)
-		} else {
-			expect(BufferConstructor).toBe(ArrayBuffer)
-		}
-	})
+  it("selects the appropriate buffer constructor", () => {
+    if (typeof SharedArrayBuffer !== "undefined") {
+      expect(BufferConstructor).toBe(SharedArrayBuffer);
+    } else {
+      expect(BufferConstructor).toBe(ArrayBuffer);
+    }
+  });
 
-	describe("ResizeableTypedArray", () => {
-		it("push stores values and returns the index", () => {
-			const arr = new ResizeableTypedArray(Float64Array)
+  describe("ResizeableTypedArray", () => {
+    it("push stores values and returns the index", () => {
+      const arr = new ResizeableTypedArray(Float64Array);
 
-			const first = arr.push(1.5)
-			const second = arr.push(2.5)
+      const first = arr.push(1.5);
+      const second = arr.push(2.5);
 
-			expect(first).toBe(0)
-			expect(second).toBe(1)
-			expect(arr.length).toBe(2)
-			expect(arr.at(0)).toBe(1.5)
-			expect(arr.at(1)).toBe(2.5)
-		})
+      expect(first).toBe(0);
+      expect(second).toBe(1);
+      expect(arr.length).toBe(2);
+      expect(arr.at(0)).toBe(1.5);
+      expect(arr.at(1)).toBe(2.5);
+    });
 
-		it("should push many values", () => {
-			const arr = new ResizeableTypedArray(Float64Array)
+    it("should push many values", () => {
+      const arr = new ResizeableTypedArray(Float64Array);
 
-			arr.pushMany([1.5, 2.5])
+      arr.pushMany([1.5, 2.5]);
 
-			expect(arr.length).toBe(2)
-			expect(arr.at(0)).toBe(1.5)
-			expect(arr.at(1)).toBe(2.5)
-		})
+      expect(arr.length).toBe(2);
+      expect(arr.at(0)).toBe(1.5);
+      expect(arr.at(1)).toBe(2.5);
+    });
 
-		it("at supports negative indices and guards bounds", () => {
-			const arr = new ResizeableTypedArray(Int16Array)
+    it("at supports negative indices and guards bounds", () => {
+      const arr = new ResizeableTypedArray(Int16Array);
 
-			arr.pushMany([10, 20, 30])
+      arr.pushMany([10, 20, 30]);
 
-			expect(arr.length).toBe(3)
-			expect(Array.from(arr.slice(0, arr.length))).toEqual([10, 20, 30])
-			expect(arr.at(-1)).toBe(30)
-			expect(arr.at(-3)).toBe(10)
-			expect(() => arr.at(-4)).toThrow(/Index out of bounds/)
-			expect(() => arr.at(3)).toThrow(/Index out of bounds/)
-		})
+      expect(arr.length).toBe(3);
+      expect(Array.from(arr.slice(0, arr.length))).toEqual([10, 20, 30]);
+      expect(arr.at(-1)).toBe(30);
+      expect(arr.at(-3)).toBe(10);
+      expect(() => arr.at(-4)).toThrow(/Index out of bounds/);
+      expect(() => arr.at(3)).toThrow(/Index out of bounds/);
+    });
 
-		it("pushMany appends arrays while preserving order", () => {
-			const arr = new ResizeableTypedArray(Uint32Array)
+    it("pushMany appends arrays while preserving order", () => {
+      const arr = new ResizeableTypedArray(Uint32Array);
 
-			arr.pushMany([1, 2, 3])
-			arr.pushMany(Uint32Array.from([4, 5]))
+      arr.pushMany([1, 2, 3]);
+      arr.pushMany(Uint32Array.from([4, 5]));
 
-			expect(arr.length).toBe(5)
-			expect(Array.from(arr.slice(0, arr.length))).toEqual([1, 2, 3, 4, 5])
-		})
+      expect(arr.length).toBe(5);
+      expect(Array.from(arr.slice(0, arr.length))).toEqual([1, 2, 3, 4, 5]);
+    });
 
-		it("slice returns a copy of the requested segment", () => {
-			const arr = new ResizeableTypedArray(Uint8Array)
+    it("slice returns a copy of the requested segment", () => {
+      const arr = new ResizeableTypedArray(Uint8Array);
 
-			arr.pushMany([1, 2, 3, 4])
+      arr.pushMany([1, 2, 3, 4]);
 
-			const segment = arr.slice(1, 3)
+      const segment = arr.slice(1, 3);
 
-			expect(segment).toBeInstanceOf(Uint8Array)
-			expect(Array.from(segment)).toEqual([2, 3])
+      expect(segment).toBeInstanceOf(Uint8Array);
+      expect(Array.from(segment)).toEqual([2, 3]);
 
-			segment[0] = 99
-			expect(arr.at(1)).toBe(2)
-		})
+      segment[0] = 99;
+      expect(arr.at(1)).toBe(2);
+    });
 
-		it("compact trims unused capacity", () => {
-			const arr = new ResizeableTypedArray(Float64Array)
+    it("compact trims unused capacity", () => {
+      const arr = new ResizeableTypedArray(Float64Array);
 
-			arr.pushMany([5, 6, 7])
+      arr.pushMany([5, 6, 7]);
 
-			const previousCapacity = arr.array.length
-			const compacted = arr.compact()
-			const expectedByteLength = arr.length * Float64Array.BYTES_PER_ELEMENT
+      const previousCapacity = arr.array.length;
+      const compacted = arr.compact();
+      const expectedByteLength = arr.length * Float64Array.BYTES_PER_ELEMENT;
 
-			expect(compacted).toBe(arr.array)
-			expect(compacted.length).toBe(arr.length)
-			expect(compacted.length).toBeLessThan(previousCapacity)
-			expect(arr.array.buffer.byteLength).toBe(expectedByteLength)
-		})
+      expect(compacted).toBe(arr.array);
+      expect(compacted.length).toBe(arr.length);
+      expect(compacted.length).toBeLessThan(previousCapacity);
+      expect(arr.array.buffer.byteLength).toBe(expectedByteLength);
+    });
 
-		it("from reuses an existing buffer and grows when needed", () => {
-			const backing = new ArrayBuffer(16)
-			new Uint32Array(backing).set([1, 2, 3, 4])
+    it("from reuses an existing buffer and grows when needed", () => {
+      const backing = new ArrayBuffer(16);
+      new Uint32Array(backing).set([1, 2, 3, 4]);
 
-			const arr = ResizeableTypedArray.from(Uint32Array, backing)
+      const arr = ResizeableTypedArray.from(Uint32Array, backing);
 
-			arr.bufferSize = arr.buffer.byteLength
-			arr.maxByteLength = Math.max(arr.maxByteLength, arr.bufferSize * 2)
-			arr.items = arr.array.length
+      arr.bufferSize = arr.buffer.byteLength;
+      arr.maxByteLength = Math.max(arr.maxByteLength, arr.bufferSize * 2);
+      arr.items = arr.array.length;
 
-			expect(arr.length).toBe(4)
-			expect(Array.from(arr.slice(0, arr.length))).toEqual([1, 2, 3, 4])
+      expect(arr.length).toBe(4);
+      expect(Array.from(arr.slice(0, arr.length))).toEqual([1, 2, 3, 4]);
 
-			arr.push(5)
+      arr.push(5);
 
-			expect(arr.length).toBe(5)
-			expect(arr.array.length).toBe(8)
-			expect(Array.from(arr.slice(0, arr.length))).toEqual([1, 2, 3, 4, 5])
-		})
+      expect(arr.length).toBe(5);
+      expect(arr.array.length).toBe(8);
+      expect(Array.from(arr.slice(0, arr.length))).toEqual([1, 2, 3, 4, 5]);
+    });
 
-		if (typeof SharedArrayBuffer !== "undefined") {
-			it("grows shared buffers in place", () => {
-				const backing = new SharedArrayBuffer(8, {
-					maxByteLength: 32,
-				})
-				const seed = new Uint8Array(backing)
-				seed.set([1, 2, 3, 4, 5, 6, 7, 8])
+    if (typeof SharedArrayBuffer !== "undefined") {
+      it("grows shared buffers in place", () => {
+        const backing = new SharedArrayBuffer(8, {
+          maxByteLength: 32,
+        });
+        const seed = new Uint8Array(backing);
+        seed.set([1, 2, 3, 4, 5, 6, 7, 8]);
 
-				const arr = ResizeableTypedArray.from(Uint8Array, backing)
+        const arr = ResizeableTypedArray.from(Uint8Array, backing);
 
-				arr.bufferSize = arr.buffer.byteLength
-				arr.maxByteLength = backing.maxByteLength
-				arr.items = arr.array.length
+        arr.bufferSize = arr.buffer.byteLength;
+        arr.maxByteLength = backing.maxByteLength;
+        arr.items = arr.array.length;
 
-				const originalBuffer = arr.buffer
+        const originalBuffer = arr.buffer;
 
-				arr.push(9)
+        arr.push(9);
 
-				expect(arr.buffer).toBe(originalBuffer)
-				expect(arr.array.length).toBe(16)
-				expect(arr.buffer.byteLength).toBe(16)
-				expect(Array.from(arr.slice(0, 9))).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9])
-			})
-		}
-	})
-})
+        expect(arr.buffer).toBe(originalBuffer);
+        expect(arr.array.length).toBe(16);
+        expect(arr.buffer.byteLength).toBe(16);
+        expect(Array.from(arr.slice(0, 9))).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+      });
+    }
+  });
+});

package/tsconfig.build.json

@@ -1,5 +1,8 @@
 {
-	"$schema": "https://json.schemastore.org/tsconfig",
-	"extends": "./tsconfig.json",
-	"include": ["src"]
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./tsconfig.json",
+  "include": ["src"],
+  "compilerOptions": {
+    "rootDir": "./src"
+  }
 }

package/tsconfig.json

@@ -1,9 +1,9 @@
 {
-	"$schema": "https://json.schemastore.org/tsconfig",
-	"extends": "@osmix/shared/tsconfig/base.json",
-	"exclude": ["node_modules", "dist"],
-	"include": ["src", "test"],
-	"compilerOptions": {
-		"outDir": "./dist"
-	}
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@osmix/shared/tsconfig/base.json",
+  "exclude": ["node_modules", "dist"],
+  "include": ["src", "test"],
+  "compilerOptions": {
+    "outDir": "./dist"
+  }
 }