@b9g/libuild 0.1.21 → 0.1.23

package/src/test-browser.js

@@ -0,0 +1,337 @@
+/// <reference types="./test-browser.d.ts" />
+import "./_chunks/chunk-IBOCQ33F.js";
+
+// src/test-browser.ts
+var ExpectError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ExpectError";
+  }
+};
+function stringify(value) {
+  if (value === void 0)
+    return "undefined";
+  if (value === null)
+    return "null";
+  if (typeof value === "function")
+    return "[Function]";
+  if (typeof value === "symbol")
+    return value.toString();
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (typeof a !== typeof b)
+    return false;
+  if (a === null || b === null)
+    return a === b;
+  if (typeof a !== "object")
+    return a === b;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    return a.every((item, i) => deepEqual(item, b[i]));
+  }
+  if (Array.isArray(a) !== Array.isArray(b))
+    return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length)
+    return false;
+  return aKeys.every(
+    (key) => deepEqual(
+      a[key],
+      b[key]
+    )
+  );
+}
+function createMatchers(actual, negated = false) {
+  const assert = (pass, message, negatedMessage) => {
+    const shouldPass = negated ? !pass : pass;
+    if (!shouldPass) {
+      throw new ExpectError(negated ? negatedMessage : message);
+    }
+  };
+  const matchers = {
+    toBe(expected) {
+      assert(
+        actual === expected,
+        `Expected ${stringify(actual)} to be ${stringify(expected)}`,
+        `Expected ${stringify(actual)} not to be ${stringify(expected)}`
+      );
+    },
+    toEqual(expected) {
+      assert(
+        deepEqual(actual, expected),
+        `Expected ${stringify(actual)} to equal ${stringify(expected)}`,
+        `Expected ${stringify(actual)} not to equal ${stringify(expected)}`
+      );
+    },
+    toStrictEqual(expected) {
+      assert(
+        deepEqual(actual, expected),
+        `Expected ${stringify(actual)} to strictly equal ${stringify(expected)}`,
+        `Expected ${stringify(actual)} not to strictly equal ${stringify(expected)}`
+      );
+    },
+    toBeTruthy() {
+      assert(
+        Boolean(actual),
+        `Expected ${stringify(actual)} to be truthy`,
+        `Expected ${stringify(actual)} not to be truthy`
+      );
+    },
+    toBeFalsy() {
+      assert(
+        !actual,
+        `Expected ${stringify(actual)} to be falsy`,
+        `Expected ${stringify(actual)} not to be falsy`
+      );
+    },
+    toBeNull() {
+      assert(
+        actual === null,
+        `Expected ${stringify(actual)} to be null`,
+        `Expected ${stringify(actual)} not to be null`
+      );
+    },
+    toBeUndefined() {
+      assert(
+        actual === void 0,
+        `Expected ${stringify(actual)} to be undefined`,
+        `Expected ${stringify(actual)} not to be undefined`
+      );
+    },
+    toBeDefined() {
+      assert(
+        actual !== void 0,
+        `Expected ${stringify(actual)} to be defined`,
+        `Expected ${stringify(actual)} not to be defined`
+      );
+    },
+    toBeNaN() {
+      assert(
+        Number.isNaN(actual),
+        `Expected ${stringify(actual)} to be NaN`,
+        `Expected ${stringify(actual)} not to be NaN`
+      );
+    },
+    toBeGreaterThan(expected) {
+      assert(
+        actual > expected,
+        `Expected ${stringify(actual)} to be greater than ${expected}`,
+        `Expected ${stringify(actual)} not to be greater than ${expected}`
+      );
+    },
+    toBeGreaterThanOrEqual(expected) {
+      assert(
+        actual >= expected,
+        `Expected ${stringify(actual)} to be greater than or equal to ${expected}`,
+        `Expected ${stringify(actual)} not to be greater than or equal to ${expected}`
+      );
+    },
+    toBeLessThan(expected) {
+      assert(
+        actual < expected,
+        `Expected ${stringify(actual)} to be less than ${expected}`,
+        `Expected ${stringify(actual)} not to be less than ${expected}`
+      );
+    },
+    toBeLessThanOrEqual(expected) {
+      assert(
+        actual <= expected,
+        `Expected ${stringify(actual)} to be less than or equal to ${expected}`,
+        `Expected ${stringify(actual)} not to be less than or equal to ${expected}`
+      );
+    },
+    toContain(expected) {
+      const contains = Array.isArray(actual) ? actual.includes(expected) : typeof actual === "string" && typeof expected === "string" ? actual.includes(expected) : false;
+      assert(
+        contains,
+        `Expected ${stringify(actual)} to contain ${stringify(expected)}`,
+        `Expected ${stringify(actual)} not to contain ${stringify(expected)}`
+      );
+    },
+    toHaveLength(expected) {
+      const len = actual.length;
+      assert(
+        len === expected,
+        `Expected length ${len} to be ${expected}`,
+        `Expected length ${len} not to be ${expected}`
+      );
+    },
+    toMatch(expected) {
+      const regex = typeof expected === "string" ? new RegExp(expected) : expected;
+      assert(
+        regex.test(actual),
+        `Expected ${stringify(actual)} to match ${expected}`,
+        `Expected ${stringify(actual)} not to match ${expected}`
+      );
+    },
+    toThrow(expected) {
+      let threw = false;
+      let error;
+      try {
+        actual();
+      } catch (e) {
+        threw = true;
+        error = e;
+      }
+      if (expected === void 0) {
+        assert(
+          threw,
+          `Expected function to throw`,
+          `Expected function not to throw`
+        );
+      } else if (typeof expected === "string") {
+        assert(
+          threw && error.message.includes(expected),
+          `Expected function to throw error containing "${expected}"`,
+          `Expected function not to throw error containing "${expected}"`
+        );
+      } else if (expected instanceof RegExp) {
+        assert(
+          threw && expected.test(error.message),
+          `Expected function to throw error matching ${expected}`,
+          `Expected function not to throw error matching ${expected}`
+        );
+      } else if (expected instanceof Error) {
+        assert(
+          threw && error.message === expected.message,
+          `Expected function to throw ${expected.message}`,
+          `Expected function not to throw ${expected.message}`
+        );
+      }
+    },
+    toBeInstanceOf(expected) {
+      assert(
+        actual instanceof expected,
+        `Expected ${stringify(actual)} to be instance of ${expected.name}`,
+        `Expected ${stringify(actual)} not to be instance of ${expected.name}`
+      );
+    },
+    get not() {
+      return createMatchers(actual, !negated);
+    }
+  };
+  return matchers;
+}
+function expect(actual) {
+  return createMatchers(actual);
+}
+globalThis.__LIBUILD_TEST__ = {
+  ended: false,
+  failed: 0,
+  passed: 0,
+  errors: []
+};
+var tests = [];
+var rootSuite = {
+  name: "",
+  parent: null,
+  beforeAll: [],
+  afterAll: [],
+  beforeEach: [],
+  afterEach: []
+};
+var currentSuite = rootSuite;
+function describe(name, fn) {
+  const suite = {
+    name,
+    parent: currentSuite,
+    beforeAll: [],
+    afterAll: [],
+    beforeEach: [],
+    afterEach: []
+  };
+  const prev = currentSuite;
+  currentSuite = suite;
+  fn();
+  currentSuite = prev;
+}
+function test(name, fn) {
+  tests.push({ name, fn, suite: currentSuite });
+}
+var it = test;
+function beforeEach(fn) {
+  currentSuite.beforeEach.push(fn);
+}
+function afterEach(fn) {
+  currentSuite.afterEach.push(fn);
+}
+function beforeAll(fn) {
+  currentSuite.beforeAll.push(fn);
+}
+function afterAll(fn) {
+  currentSuite.afterAll.push(fn);
+}
+function getSuiteChain(suite) {
+  const chain = [];
+  let s = suite;
+  while (s) {
+    chain.unshift(s);
+    s = s.parent;
+  }
+  return chain;
+}
+function getFullName(t) {
+  const chain = getSuiteChain(t.suite);
+  const names = chain.map((s) => s.name).filter(Boolean);
+  names.push(t.name);
+  return names.join(" > ");
+}
+queueMicrotask(async () => {
+  const suiteRan = /* @__PURE__ */ new Set();
+  for (const t of tests) {
+    const fullName = getFullName(t);
+    const chain = getSuiteChain(t.suite);
+    try {
+      for (const suite of chain) {
+        if (!suiteRan.has(suite)) {
+          for (const hook of suite.beforeAll)
+            await hook();
+          suiteRan.add(suite);
+        }
+      }
+      for (const suite of chain) {
+        for (const hook of suite.beforeEach)
+          await hook();
+      }
+      await t.fn();
+      for (const suite of [...chain].reverse()) {
+        for (const hook of suite.afterEach)
+          await hook();
+      }
+      console.log("\u2713", fullName);
+      globalThis.__LIBUILD_TEST__.passed++;
+    } catch (e) {
+      console.error("\u2717", fullName);
+      console.error("  ", e.message);
+      globalThis.__LIBUILD_TEST__.failed++;
+      globalThis.__LIBUILD_TEST__.errors.push({
+        name: fullName,
+        error: e.message || String(e)
+      });
+    }
+  }
+  for (const suite of [...suiteRan].reverse()) {
+    for (const hook of suite.afterAll)
+      await hook();
+  }
+  globalThis.__LIBUILD_TEST__.ended = true;
+});
+export {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  test
+};

package/src/test-bun.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Bun test shim for @b9g/libuild/test
+ *
+ * Simply re-exports bun:test which already has Jest-compatible APIs.
+ */
+export { describe, test, it, expect, beforeAll, afterAll, beforeEach, afterEach, } from "bun:test";

package/src/test-bun.js

@@ -0,0 +1,24 @@
+/// <reference types="./test-bun.d.ts" />
+import "./_chunks/chunk-IBOCQ33F.js";
+
+// src/test-bun.ts
+import {
+  describe,
+  test,
+  it,
+  expect,
+  beforeAll,
+  afterAll,
+  beforeEach,
+  afterEach
+} from "bun:test";
+export {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  test
+};

package/src/test-node.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Node.js test shim for @b9g/libuild/test
+ *
+ * Combines node:test runner with Jest's expect matchers.
+ */
+import { describe, test, it, before, after, beforeEach, afterEach } from "node:test";
+export { expect } from "expect";
+export { describe, test, it, before as beforeAll, after as afterAll, beforeEach, afterEach, };

package/src/test-node.js

@@ -0,0 +1,24 @@
+/// <reference types="./test-node.d.ts" />
+import "./_chunks/chunk-IBOCQ33F.js";
+
+// src/test-node.ts
+import {
+  describe,
+  test,
+  it,
+  before,
+  after,
+  beforeEach,
+  afterEach
+} from "node:test";
+import { expect } from "expect";
+export {
+  after as afterAll,
+  afterEach,
+  before as beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  test
+};

package/src/test-runner.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @b9g/libuild test runner
+ *
+ * Cross-platform test execution for Bun, Node, and browsers.
+ */
+export type Platform = "bun" | "node" | "chromium" | "firefox" | "webkit";
+export interface TestRunnerOptions {
+    /** Working directory */
+    cwd: string;
+    /** Test file patterns */
+    patterns: string[];
+    /** Platforms to run on (bun, node, chromium, firefox, webkit) */
+    platforms: Platform[];
+    /** Enable debug mode (keeps browser open) */
+    debug: boolean;
+    /** Test timeout in ms */
+    timeout: number;
+    /** Watch mode */
+    watch: boolean;
+}
+export interface TestResult {
+    platform: string;
+    passed: number;
+    failed: number;
+    errors: Array<{
+        name: string;
+        error: string;
+    }>;
+}
+/**
+ * Main test runner
+ */
+export declare function runTests(options?: Partial<TestRunnerOptions>): Promise<boolean>;
+/**
+ * Detect available platforms
+ */
+export declare function detectPlatforms(): Promise<("bun" | "node" | "browser")[]>;