Merge pull request #52 from JS-AK/fix/zip/update-utils

fix: updated zip utils to-byte fn

Author: JS-AK

package.json

@@ -44,7 +44,9 @@
     "lint": "eslint . --ext .ts",
     "postbuild:esm": "node scripts/write-esm-package.js",
     "postbuild:cjs": "node scripts/write-cjs-package.js",
-    "test": "vitest run",
+    "test:unit": "vitest run --config vitest.unit.config.js",
+    "test:integration": "vitest run --config vitest.integration.config.js",
+    "test": "npm run test:unit && npm run test:integration",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage"
   },

src/lib/zip/utils/to-bytes.ts

@@ -15,25 +15,29 @@ import { Buffer } from "node:buffer";
  * @returns {Buffer} - A new Buffer of exactly `len` bytes containing:
  *        1. The value's bytes in little-endian order (least significant byte first)
  *        2. Zero padding in any remaining higher-order bytes
- * @throws {RangeError} - If the value requires more bytes than `len` to represent
- *        (though this is currently not explicitly checked)
+ *
+ * @throws {RangeError} - If the length is not positive or the value is negative.
  */
 export function toBytes(value: number, len: number): Buffer {
-	// Allocate a new Buffer of the requested length, automatically zero-filled
+	if (len <= 0) throw new RangeError("Length must be a positive integer");
+	if (value < 0) throw new RangeError("Negative values are not supported");
+	if (!Number.isSafeInteger(value)) throw new RangeError("Value must be a safe integer");
+
+	// Use BigInt to correctly handle 53-bit values
+	let bigint = BigInt(value);
 	const buf = Buffer.alloc(len);
 
-	// Process each byte position from least significant to most significant
 	for (let i = 0; i < len; i++) {
-		// Store the least significant byte of the current value
-		buf[i] = value & 0xff;  // Mask to get bottom 8 bits
+		// Extract the least significant byte and assign to buffer
+		buf[i] = Number(bigint & 0xffn);
+		bigint >>= 8n;
 
-		// Right-shift the value by 8 bits to process the next byte
-		// Note: This uses unsigned right shift (>>> would be signed)
-		value >>= 8;
-
-		// If the loop completes with value != 0, we've overflowed the buffer length,
-		// but this isn't currently checked/handled
+		// Stop early if all remaining bits are zero
+		if (bigint === 0n) break;
 	}
 
+	// If bigint is still non-zero, it means we overflowed the buffer length
+	if (bigint > 0n) throw new RangeError("Value exceeds the maximum size for the specified length");
+
 	return buf;
 }

src/lib/zip/utils/to-bytes.unit.spec.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { toBytes } from "./to-bytes.js";
+
+// Test suite for toBytes function
+describe("toBytes", () => {
+	it("should convert a small number to a 1-byte buffer", () => {
+		expect(toBytes(42, 1)).toEqual(Buffer.from([42]));
+	});
+
+	it("should convert a small number to a multi-byte buffer with padding", () => {
+		expect(toBytes(42, 4)).toEqual(Buffer.from([42, 0, 0, 0]));
+	});
+
+	it("should handle multi-byte numbers correctly", () => {
+		expect(toBytes(4660, 4)).toEqual(Buffer.from([0x34, 0x12, 0, 0]));
+		expect(toBytes(0x12345678, 4)).toEqual(Buffer.from([0x78, 0x56, 0x34, 0x12]));
+	});
+
+	it("should handle maximum safe integer correctly", () => {
+		expect(toBytes(Number.MAX_SAFE_INTEGER, 8)).toEqual(Buffer.from([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00]));
+	});
+
+	it("should handle zero correctly", () => {
+		expect(toBytes(0, 4)).toEqual(Buffer.from([0, 0, 0, 0]));
+	});
+
+	it("should return a zero-filled buffer for zero with a larger length", () => {
+		expect(toBytes(0, 8)).toEqual(Buffer.alloc(8));
+	});
+
+	it("should throw a RangeError for negative lengths", () => {
+		expect(() => toBytes(123, -1)).toThrow(RangeError);
+	});
+
+	it("should throw a RangeError for zero length", () => {
+		expect(() => toBytes(123, 0)).toThrow(RangeError);
+	});
+
+	it("should throw a RangeError for negative values", () => {
+		expect(() => toBytes(-123, 4)).toThrow(RangeError);
+	});
+
+	it("should throw a RangeError for non-safe integers", () => {
+		expect(() => toBytes(Number.MAX_SAFE_INTEGER + 1, 8)).toThrow(RangeError);
+	});
+
+	it("should handle maximum value fitting in the given length", () => {
+		expect(toBytes(255, 1)).toEqual(Buffer.from([0xff]));
+		expect(toBytes(65535, 2)).toEqual(Buffer.from([0xff, 0xff]));
+		expect(toBytes(4294967295, 4)).toEqual(Buffer.from([0xff, 0xff, 0xff, 0xff]));
+		expect(toBytes(Number.MAX_SAFE_INTEGER, 8)).toEqual(Buffer.from([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00]));
+	});
+
+	it("should throw a RangeError if the value exceeds the buffer length", () => {
+		expect(() => toBytes(256, 1)).toThrow(RangeError);
+		expect(() => toBytes(65536, 2)).toThrow(RangeError);
+		expect(() => toBytes(4294967296, 4)).toThrow(RangeError);
+		expect(() => toBytes(Number.MAX_SAFE_INTEGER + 1, 8)).toThrow(RangeError);
+	});
+});

vitest.integration.config.js

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		environment: "node",
+		include: ["src/**/*.integration.spec.ts"],
+	},
+});

vitest.config.js renamed to vitest.unit.config.js

@@ -3,6 +3,6 @@ import { defineConfig } from "vitest/config";
 export default defineConfig({
 	test: {
 		environment: "node",
-		include: ["src/**/*.spec.ts"],
+		include: ["src/**/*.unit.spec.ts"],
 	},
 });