@forwardimpact/libutil 0.1.70 → 0.1.73

package/test/tokenizer.test.js

@@ -1,123 +0,0 @@
-import { test, describe, beforeEach } from "node:test";
-import assert from "node:assert";
-
-// Module under test
-import { Tokenizer, ranks } from "../tokenizer.js";
-import { countTokens, createTokenizer } from "../index.js";
-
-describe("Tokenizer", () => {
-  describe("constructor", () => {
-    test("creates instance with ranks parameter", () => {
-      const tokenizer = new Tokenizer(ranks);
-      assert.ok(tokenizer instanceof Tokenizer);
-    });
-
-    test("creates instance without ranks parameter", () => {
-      const tokenizer = new Tokenizer();
-      assert.ok(tokenizer instanceof Tokenizer);
-    });
-  });
-
-  describe("encode", () => {
-    let tokenizer;
-
-    beforeEach(() => {
-      tokenizer = new Tokenizer(ranks);
-    });
-
-    test("handles empty string", () => {
-      const result = tokenizer.encode("");
-      assert.strictEqual(result.length, 0);
-    });
-
-    test("handles non-string input", () => {
-      const result = tokenizer.encode(null);
-      assert.strictEqual(result.length, 0);
-    });
-
-    test("encodes simple word", () => {
-      const result = tokenizer.encode("hello");
-      assert.ok(result.length >= 1);
-      assert.ok(Array.isArray(result));
-    });
-
-    test("encodes longer text", () => {
-      const shortText = "hello";
-      const longText = "hello world this is a longer piece of text";
-
-      const shortResult = tokenizer.encode(shortText);
-      const longResult = tokenizer.encode(longText);
-
-      assert.ok(longResult.length > shortResult.length);
-    });
-
-    test("handles whitespace-only text", () => {
-      const result = tokenizer.encode("   ");
-      assert.strictEqual(result.length, 0);
-    });
-
-    test("handles punctuation", () => {
-      const result = tokenizer.encode("Hello, world!");
-      assert.ok(result.length >= 3); // At least hello + comma + world + exclamation
-    });
-
-    test("handles mixed content", () => {
-      const result = tokenizer.encode("The year 2024 was great!");
-      assert.ok(result.length >= 5); // Multiple words and punctuation
-    });
-
-    test("provides reasonable approximation", () => {
-      // Test that the approximation is in a reasonable range
-      const text = "This is a test sentence with about ten words here.";
-      const result = tokenizer.encode(text);
-
-      // Should be roughly 10-15 tokens for this sentence
-      assert.ok(result.length >= 8);
-      assert.ok(result.length <= 20);
-    });
-  });
-
-  describe("decode", () => {
-    test("throws error when called", () => {
-      const tokenizer = new Tokenizer(ranks);
-      assert.throws(() => tokenizer.decode([1, 2, 3]), {
-        message: /decode\(\) not implemented/,
-      });
-    });
-  });
-});
-
-describe("Integration with libutil functions", () => {
-  describe("tokenizerFactory", () => {
-    test("creates Tokenizer instance", () => {
-      const tokenizer = createTokenizer();
-      assert.ok(tokenizer instanceof Tokenizer);
-    });
-  });
-
-  describe("countTokens", () => {
-    test("returns token count for text", () => {
-      const count = countTokens("hello world");
-      assert.ok(typeof count === "number");
-      assert.ok(count >= 1);
-    });
-
-    test("handles empty text", () => {
-      const count = countTokens("");
-      assert.strictEqual(count, 0);
-    });
-
-    test("uses provided tokenizer", () => {
-      const customTokenizer = new Tokenizer(ranks);
-      const count = countTokens("test", customTokenizer);
-      assert.ok(typeof count === "number");
-      assert.ok(count >= 1);
-    });
-
-    test("uses default tokenizer when none provided", () => {
-      const count = countTokens("test");
-      assert.ok(typeof count === "number");
-      assert.ok(count >= 1);
-    });
-  });
-});

package/test/wait.test.js

@@ -1,109 +0,0 @@
-import { describe, test } from "node:test";
-import assert from "node:assert";
-
-import { waitFor } from "../wait.js";
-
-const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-describe("waitFor", () => {
-  test("throws if delayFn is missing", async () => {
-    await assert.rejects(
-      () => waitFor(() => Promise.resolve(true), {}),
-      /delayFn is required/,
-    );
-  });
-
-  test("resolves immediately when condition is true", async () => {
-    let callCount = 0;
-    await waitFor(
-      () => {
-        callCount++;
-        return Promise.resolve(true);
-      },
-      {},
-      delay,
-    );
-
-    assert.strictEqual(callCount, 1);
-  });
-
-  test("retries until condition becomes true", async () => {
-    let callCount = 0;
-    await waitFor(
-      () => {
-        callCount++;
-        return Promise.resolve(callCount >= 3);
-      },
-      { interval: 10, timeout: 5000 },
-      delay,
-    );
-
-    assert.strictEqual(callCount, 3);
-  });
-
-  test("throws error on timeout", async () => {
-    await assert.rejects(
-      () =>
-        waitFor(
-          () => Promise.resolve(false),
-          { timeout: 50, interval: 10 },
-          delay,
-        ),
-      { message: "Timeout waiting for condition after 50ms" },
-    );
-  });
-
-  test("ignores errors during polling", async () => {
-    let callCount = 0;
-    await waitFor(
-      () => {
-        callCount++;
-        if (callCount < 3) {
-          throw new Error("Service not ready");
-        }
-        return Promise.resolve(true);
-      },
-      { interval: 10, timeout: 5000 },
-      delay,
-    );
-
-    assert.strictEqual(callCount, 3);
-  });
-
-  test("uses default options when not provided", async () => {
-    let called = false;
-    await waitFor(
-      () => {
-        called = true;
-        return Promise.resolve(true);
-      },
-      {},
-      delay,
-    );
-
-    assert.strictEqual(called, true);
-  });
-
-  test("increases interval with exponential backoff", async () => {
-    const intervals = [];
-    let lastTime = Date.now();
-    let callCount = 0;
-
-    await waitFor(
-      () => {
-        const now = Date.now();
-        if (callCount > 0) {
-          intervals.push(now - lastTime);
-        }
-        lastTime = now;
-        callCount++;
-        return Promise.resolve(callCount >= 4);
-      },
-      { interval: 20, maxInterval: 100, timeout: 5000 },
-      delay,
-    );
-
-    // Intervals should generally increase (with some tolerance for timing)
-    assert.ok(intervals.length >= 2);
-  });
-});