@scelar/nodepod 1.0.2 → 1.0.3

package/src/__tests__/byte-encoding.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from "vitest";
+import {
+  bytesToBase64,
+  base64ToBytes,
+  bytesToHex,
+  bytesToLatin1,
+} from "../helpers/byte-encoding";
+
+const textEncoder = new TextEncoder();
+
+describe("bytesToBase64 / base64ToBytes", () => {
+  it("round-trips an ASCII string", () => {
+    const data = textEncoder.encode("Hello World");
+    const b64 = bytesToBase64(data);
+    const back = base64ToBytes(b64);
+    expect(back).toEqual(data);
+  });
+
+  it("round-trips an empty array", () => {
+    expect(bytesToBase64(new Uint8Array(0))).toBe("");
+    expect(base64ToBytes("")).toEqual(new Uint8Array(0));
+  });
+
+  it("round-trips all 256 byte values", () => {
+    const data = new Uint8Array(256);
+    for (let i = 0; i < 256; i++) data[i] = i;
+    const b64 = bytesToBase64(data);
+    const back = base64ToBytes(b64);
+    expect(back).toEqual(data);
+  });
+
+  it("round-trips a large buffer (> SEGMENT_SIZE 8192 bytes)", () => {
+    const data = new Uint8Array(20000);
+    for (let i = 0; i < data.length; i++) data[i] = i % 256;
+    const b64 = bytesToBase64(data);
+    const back = base64ToBytes(b64);
+    expect(back).toEqual(data);
+  });
+
+  it("handles binary data with null bytes", () => {
+    const data = new Uint8Array([0, 0, 0, 255, 0, 128]);
+    const back = base64ToBytes(bytesToBase64(data));
+    expect(back).toEqual(data);
+  });
+
+  it("matches native btoa output for ASCII", () => {
+    const str = "test string 123";
+    const data = textEncoder.encode(str);
+    expect(bytesToBase64(data)).toBe(btoa(str));
+  });
+});
+
+describe("bytesToHex", () => {
+  it("converts empty array to empty string", () => {
+    expect(bytesToHex(new Uint8Array(0))).toBe("");
+  });
+
+  it("converts known byte values correctly", () => {
+    expect(bytesToHex(new Uint8Array([0, 255, 128, 1]))).toBe("00ff8001");
+  });
+
+  it("produces lowercase hex digits", () => {
+    const hex = bytesToHex(new Uint8Array([0xab, 0xcd, 0xef]));
+    expect(hex).toBe("abcdef");
+    expect(hex).toBe(hex.toLowerCase());
+  });
+
+  it("handles single byte", () => {
+    expect(bytesToHex(new Uint8Array([10]))).toBe("0a");
+  });
+});
+
+describe("bytesToLatin1", () => {
+  it("converts empty array to empty string", () => {
+    expect(bytesToLatin1(new Uint8Array(0))).toBe("");
+  });
+
+  it("converts byte values to latin1 code points", () => {
+    expect(bytesToLatin1(new Uint8Array([72, 101, 108, 108, 111]))).toBe(
+      "Hello",
+    );
+  });
+
+  it("preserves high bytes (128-255) as single chars", () => {
+    const data = new Uint8Array([0xe9]);
+    const result = bytesToLatin1(data);
+    expect(result).toBe("\xe9");
+    expect(result.charCodeAt(0)).toBe(0xe9);
+  });
+
+  it("handles large buffer (> SEGMENT_SIZE)", () => {
+    const data = new Uint8Array(10000);
+    for (let i = 0; i < data.length; i++) data[i] = 65;
+    const result = bytesToLatin1(data);
+    expect(result.length).toBe(10000);
+    expect(result).toBe("A".repeat(10000));
+  });
+});

package/src/__tests__/digest.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { quickDigest } from "../helpers/digest";
+
+describe("quickDigest", () => {
+  it("returns a string", () => {
+    expect(typeof quickDigest("hello")).toBe("string");
+  });
+
+  it("returns consistent results for same input", () => {
+    expect(quickDigest("hello")).toBe(quickDigest("hello"));
+    expect(quickDigest("test/path/file.js")).toBe(
+      quickDigest("test/path/file.js"),
+    );
+  });
+
+  it("returns different results for different inputs", () => {
+    expect(quickDigest("hello")).not.toBe(quickDigest("world"));
+    expect(quickDigest("a")).not.toBe(quickDigest("b"));
+  });
+
+  it("handles empty string", () => {
+    const result = quickDigest("");
+    expect(typeof result).toBe("string");
+    expect(result.length).toBeGreaterThan(0);
+  });
+
+  it("handles very long strings", () => {
+    const long = "x".repeat(100_000);
+    const result = quickDigest(long);
+    expect(typeof result).toBe("string");
+  });
+
+  it("handles unicode", () => {
+    const result = quickDigest("🎉🚀日本語");
+    expect(typeof result).toBe("string");
+    expect(result.length).toBeGreaterThan(0);
+  });
+
+  it("returns base-36 encoded string", () => {
+    const result = quickDigest("some input");
+    // djb2 can go negative, hence the -?
+    expect(result).toMatch(/^-?[0-9a-z]+$/);
+  });
+});

package/src/__tests__/events.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect, vi } from "vitest";
+import eventModule, { EventEmitter } from "../polyfills/events";
+
+describe("EventEmitter", () => {
+  describe("on/emit", () => {
+    it("emits event and calls listener", () => {
+      const ee = new EventEmitter();
+      const fn = vi.fn();
+      ee.on("test", fn);
+      ee.emit("test");
+      expect(fn).toHaveBeenCalledOnce();
+    });
+
+    it("passes arguments to listener", () => {
+      const ee = new EventEmitter();
+      const fn = vi.fn();
+      ee.on("data", fn);
+      ee.emit("data", 1, "two", { three: 3 });
+      expect(fn).toHaveBeenCalledWith(1, "two", { three: 3 });
+    });
+
+    it("handles multiple listeners on same event", () => {
+      const ee = new EventEmitter();
+      const fn1 = vi.fn();
+      const fn2 = vi.fn();
+      ee.on("x", fn1);
+      ee.on("x", fn2);
+      ee.emit("x");
+      expect(fn1).toHaveBeenCalled();
+      expect(fn2).toHaveBeenCalled();
+    });
+
+    it("returns true when listeners exist, false otherwise", () => {
+      const ee = new EventEmitter();
+      expect(ee.emit("nope")).toBe(false);
+      ee.on("yep", () => {});
+      expect(ee.emit("yep")).toBe(true);
+    });
+  });
+
+  describe("once", () => {
+    it("listener fires only once", () => {
+      const ee = new EventEmitter();
+      const fn = vi.fn();
+      ee.once("one", fn);
+      ee.emit("one");
+      ee.emit("one");
+      expect(fn).toHaveBeenCalledOnce();
+    });
+
+    it("is removed after first emit", () => {
+      const ee = new EventEmitter();
+      ee.once("x", () => {});
+      expect(ee.listenerCount("x")).toBe(1);
+      ee.emit("x");
+      expect(ee.listenerCount("x")).toBe(0);
+    });
+  });
+
+  describe("removeListener / off", () => {
+    it("removes specific listener", () => {
+      const ee = new EventEmitter();
+      const fn = vi.fn();
+      ee.on("x", fn);
+      ee.removeListener("x", fn);
+      ee.emit("x");
+      expect(fn).not.toHaveBeenCalled();
+    });
+
+    it("does not remove other listeners on same event", () => {
+      const ee = new EventEmitter();
+      const fn1 = vi.fn();
+      const fn2 = vi.fn();
+      ee.on("x", fn1);
+      ee.on("x", fn2);
+      ee.off("x", fn1);
+      ee.emit("x");
+      expect(fn1).not.toHaveBeenCalled();
+      expect(fn2).toHaveBeenCalled();
+    });
+  });
+
+  describe("removeAllListeners", () => {
+    it("removes all listeners for a specific event", () => {
+      const ee = new EventEmitter();
+      ee.on("a", () => {});
+      ee.on("a", () => {});
+      ee.on("b", () => {});
+      ee.removeAllListeners("a");
+      expect(ee.listenerCount("a")).toBe(0);
+      expect(ee.listenerCount("b")).toBe(1);
+    });
+
+    it("removes all listeners for all events when no arg", () => {
+      const ee = new EventEmitter();
+      ee.on("a", () => {});
+      ee.on("b", () => {});
+      ee.removeAllListeners();
+      expect(ee.eventNames()).toEqual([]);
+    });
+  });
+
+  describe("error event", () => {
+    it("throws Error when emitting 'error' with no listeners", () => {
+      const ee = new EventEmitter();
+      expect(() => ee.emit("error", new Error("boom"))).toThrow("boom");
+    });
+
+    it("throws generic error when payload is not an Error", () => {
+      const ee = new EventEmitter();
+      expect(() => ee.emit("error", "string")).toThrow("Unhandled error event");
+    });
+
+    it("does not throw when error listener is registered", () => {
+      const ee = new EventEmitter();
+      ee.on("error", () => {});
+      expect(() => ee.emit("error", new Error("handled"))).not.toThrow();
+    });
+  });
+
+  describe("Object.create pattern", () => {
+    it("works when created via Object.create(EventEmitter.prototype)", () => {
+      const obj = Object.create(EventEmitter.prototype);
+      const fn = vi.fn();
+      obj.on("test", fn);
+      obj.emit("test", 42);
+      expect(fn).toHaveBeenCalledWith(42);
+    });
+  });
+
+  describe("listenerCount", () => {
+    it("returns 0 for event with no listeners", () => {
+      const ee = new EventEmitter();
+      expect(ee.listenerCount("nope")).toBe(0);
+    });
+
+    it("returns correct count", () => {
+      const ee = new EventEmitter();
+      ee.on("x", () => {});
+      ee.on("x", () => {});
+      expect(ee.listenerCount("x")).toBe(2);
+    });
+  });
+
+  describe("eventNames", () => {
+    it("returns empty array initially", () => {
+      const ee = new EventEmitter();
+      expect(ee.eventNames()).toEqual([]);
+    });
+
+    it("returns array of event names with listeners", () => {
+      const ee = new EventEmitter();
+      ee.on("a", () => {});
+      ee.on("b", () => {});
+      expect(ee.eventNames().sort()).toEqual(["a", "b"]);
+    });
+  });
+
+  describe("prependListener", () => {
+    it("adds listener to beginning of list", () => {
+      const order: number[] = [];
+      const ee = new EventEmitter();
+      ee.on("x", () => order.push(1));
+      ee.prependListener("x", () => order.push(2));
+      ee.emit("x");
+      expect(order).toEqual([2, 1]);
+    });
+  });
+
+  describe("prependOnceListener", () => {
+    it("fires once and was prepended", () => {
+      const order: number[] = [];
+      const ee = new EventEmitter();
+      ee.on("x", () => order.push(1));
+      ee.prependOnceListener("x", () => order.push(2));
+      ee.emit("x");
+      ee.emit("x");
+      expect(order).toEqual([2, 1, 1]);
+    });
+  });
+
+  describe("setMaxListeners / getMaxListeners", () => {
+    it("defaults to 10", () => {
+      const ee = new EventEmitter();
+      expect(ee.getMaxListeners()).toBe(10);
+    });
+
+    it("can be changed", () => {
+      const ee = new EventEmitter();
+      ee.setMaxListeners(50);
+      expect(ee.getMaxListeners()).toBe(50);
+    });
+  });
+
+  describe("listeners / rawListeners", () => {
+    it("returns copy of listener array", () => {
+      const ee = new EventEmitter();
+      const fn = () => {};
+      ee.on("x", fn);
+      const list = ee.listeners("x");
+      expect(list).toEqual([fn]);
+      list.pop();
+      expect(ee.listenerCount("x")).toBe(1);
+    });
+  });
+
+  describe("static EventEmitter.once()", () => {
+    it("returns a Promise that resolves on event", async () => {
+      const ee = new EventEmitter();
+      const p = eventModule.once(ee, "data");
+      ee.emit("data", 42, "extra");
+      const result = await p;
+      expect(result).toEqual([42, "extra"]);
+    });
+
+    it("rejects on error event", async () => {
+      const ee = new EventEmitter();
+      const p = eventModule.once(ee, "data");
+      ee.emit("error", new Error("fail"));
+      await expect(p).rejects.toThrow("fail");
+    });
+  });
+
+  describe("static EventEmitter.listenerCount()", () => {
+    it("returns count from target", () => {
+      const ee = new EventEmitter();
+      ee.on("x", () => {});
+      ee.on("x", () => {});
+      expect(eventModule.listenerCount(ee, "x")).toBe(2);
+    });
+  });
+
+  describe("module export shape", () => {
+    it("has EventEmitter as both default.EventEmitter and named export", () => {
+      expect(eventModule.EventEmitter).toBe(EventEmitter);
+    });
+
+    it("has static once, on, getEventListeners, listenerCount", () => {
+      expect(typeof eventModule.once).toBe("function");
+      expect(typeof eventModule.on).toBe("function");
+      expect(typeof eventModule.getEventListeners).toBe("function");
+      expect(typeof eventModule.listenerCount).toBe("function");
+    });
+  });
+});