@b9g/libuild 0.1.21 → 0.1.23

package/src/test-runner.js

@@ -0,0 +1,406 @@
+/// <reference types="./test-runner.d.ts" />
+import {
+  __require
+} from "./_chunks/chunk-IBOCQ33F.js";
+
+// src/test-runner.ts
+import * as FS from "fs/promises";
+import * as Path from "path";
+import { createServer } from "http";
+import * as ESBuild from "esbuild";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+var __dirname = Path.dirname(fileURLToPath(import.meta.url));
+var DEFAULT_PATTERNS = [
+  "**/*.test.ts",
+  "**/*.test.tsx",
+  "**/*.test.js",
+  "**/*.test.jsx",
+  "**/*.spec.ts",
+  "**/*.spec.tsx",
+  "**/*.spec.js",
+  "**/*.spec.jsx",
+  "**/test/**/*.ts",
+  "**/test/**/*.tsx",
+  "**/test/**/*.js",
+  "**/test/**/*.jsx"
+];
+var IGNORE_PATTERNS = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/.git/**",
+  "**/coverage/**"
+];
+async function findTestFiles(cwd, patterns) {
+  const { glob } = await import("glob");
+  const files = [];
+  for (const pattern of patterns) {
+    const matches = await glob(pattern, {
+      cwd,
+      ignore: IGNORE_PATTERNS,
+      absolute: true
+    });
+    files.push(...matches);
+  }
+  return [...new Set(files)];
+}
+function generateTestEntry(testFiles, platform) {
+  const imports = testFiles.map((file, i) => `import "${file.replace(/\\/g, "/")}";`).join("\n");
+  return `// Auto-generated test entry for ${platform}
+${imports}
+`;
+}
+function isBrowserPlatform(platform) {
+  return platform === "chromium" || platform === "firefox" || platform === "webkit";
+}
+async function bundleTests(testFiles, platform, outDir, cwd) {
+  const entryContent = generateTestEntry(testFiles, platform);
+  const entryPath = Path.join(outDir, `entry-${platform}.ts`);
+  const outPath = Path.join(outDir, `bundle-${platform}.js`);
+  await FS.writeFile(entryPath, entryContent);
+  const isBrowser = isBrowserPlatform(platform);
+  const shimName = isBrowser ? "test-browser" : `test-${platform}`;
+  let shimPath;
+  try {
+    shimPath = __require.resolve(`@b9g/libuild/${shimName}`);
+  } catch {
+    shimPath = Path.join(__dirname, `${shimName}.js`);
+  }
+  const requireShim = `
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+`;
+  const buildOptions = {
+    entryPoints: [entryPath],
+    bundle: true,
+    format: "esm",
+    outfile: outPath,
+    platform: isBrowser ? "browser" : "node",
+    target: isBrowser ? "es2020" : "node18",
+    // Replace @b9g/libuild/test with platform-specific shim
+    alias: {
+      "@b9g/libuild/test": shimPath
+    },
+    // External runtime-specific modules
+    external: platform === "bun" ? ["bun:test"] : [],
+    // Inject require shim for node/bun to handle CJS deps like expect/chalk
+    ...isBrowser ? {} : { banner: { js: requireShim } },
+    // Define for dead code elimination
+    define: {
+      "process.env.NODE_ENV": '"test"'
+    },
+    logLevel: "warning"
+  };
+  await ESBuild.build(buildOptions);
+  return outPath;
+}
+function parseTapOutput(output) {
+  let passed = 0;
+  let failed = 0;
+  const errors = [];
+  const lines = output.split("\n");
+  let lastTestName = "";
+  let lastTestPassed = true;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const okMatch = line.match(/^\s*ok \d+ - (.+)/);
+    const notOkMatch = line.match(/^\s*not ok \d+ - (.+)/);
+    if (okMatch) {
+      lastTestName = okMatch[1];
+      lastTestPassed = true;
+    } else if (notOkMatch) {
+      lastTestName = notOkMatch[1];
+      lastTestPassed = false;
+    }
+    if (line.includes("type: 'test'") || line.includes('type: "test"')) {
+      if (lastTestPassed) {
+        passed++;
+      } else {
+        failed++;
+        errors.push({ name: lastTestName, error: "Test failed" });
+      }
+    }
+  }
+  return { passed, failed, errors };
+}
+async function runNodeTests(bundlePath, timeout) {
+  const { spawn } = await import("child_process");
+  return new Promise((resolve) => {
+    const child = spawn("node", ["--test", "--test-reporter=tap", bundlePath], {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout
+    });
+    let stdout = "";
+    let stderr = "";
+    let pendingTest = null;
+    const printedTests = /* @__PURE__ */ new Set();
+    child.stdout?.on("data", (data) => {
+      const text = data.toString();
+      stdout += text;
+      for (const line of text.split("\n")) {
+        const okMatch = line.match(/^\s*ok \d+ - (.+)/);
+        const notOkMatch = line.match(/^\s*not ok \d+ - (.+)/);
+        if (okMatch) {
+          pendingTest = { name: okMatch[1], passed: true };
+        } else if (notOkMatch) {
+          pendingTest = { name: notOkMatch[1], passed: false };
+        }
+        if ((line.includes("type: 'test'") || line.includes('type: "test"')) && pendingTest) {
+          const key = `${pendingTest.name}-${pendingTest.passed}`;
+          if (!printedTests.has(key)) {
+            printedTests.add(key);
+            if (pendingTest.passed) {
+              console.log(`\u2713 ${pendingTest.name}`);
+            } else {
+              console.log(`\u2717 ${pendingTest.name}`);
+            }
+          }
+          pendingTest = null;
+        }
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+      process.stderr.write(data);
+    });
+    child.on("close", () => {
+      const { passed, failed, errors } = parseTapOutput(stdout);
+      resolve({
+        platform: "node",
+        passed,
+        failed,
+        errors
+      });
+    });
+    child.on("error", (err) => {
+      resolve({
+        platform: "node",
+        passed: 0,
+        failed: 1,
+        errors: [{ name: "spawn error", error: err.message }]
+      });
+    });
+  });
+}
+function parseBunOutput(output) {
+  let passed = 0;
+  let failed = 0;
+  const errors = [];
+  const passMatch = output.match(/^\s*(\d+)\s+pass/m);
+  const failMatch = output.match(/^\s*(\d+)\s+fail/m);
+  if (passMatch)
+    passed = parseInt(passMatch[1], 10);
+  if (failMatch)
+    failed = parseInt(failMatch[1], 10);
+  return { passed, failed, errors };
+}
+async function runBunTests(bundlePath, timeout) {
+  const { spawn } = await import("child_process");
+  return new Promise((resolve) => {
+    const child = spawn("bun", ["test", bundlePath], {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      const text = data.toString();
+      stdout += text;
+      process.stdout.write(data);
+    });
+    child.stderr?.on("data", (data) => {
+      const text = data.toString();
+      stderr += text;
+      process.stderr.write(data);
+    });
+    child.on("close", () => {
+      const { passed, failed, errors } = parseBunOutput(stdout + stderr);
+      resolve({
+        platform: "bun",
+        passed,
+        failed,
+        errors
+      });
+    });
+    child.on("error", (err) => {
+      resolve({
+        platform: "bun",
+        passed: 0,
+        failed: 1,
+        errors: [{ name: "spawn error", error: err.message }]
+      });
+    });
+  });
+}
+async function runBrowserTests(bundlePath, browser, timeout, debug, cwd) {
+  let playwright;
+  try {
+    const require2 = createRequire(Path.join(cwd, "package.json"));
+    playwright = require2("playwright");
+  } catch {
+    console.error("Playwright is required for browser tests.");
+    console.error("Install it with: npm install -D playwright");
+    return {
+      platform: `browser (${browser})`,
+      passed: 0,
+      failed: 1,
+      errors: [{ name: "setup", error: "Playwright not installed" }]
+    };
+  }
+  const bundleContent = await FS.readFile(bundlePath, "utf-8");
+  const html = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>libuild tests</title>
+</head>
+<body>
+  <script type="module">
+${bundleContent}
+  </script>
+</body>
+</html>`;
+  let server;
+  let port;
+  await new Promise((resolve) => {
+    server = createServer((req, res) => {
+      res.setHeader("Content-Type", "text/html");
+      res.end(html);
+    });
+    server.listen(0, () => {
+      const addr = server.address();
+      port = typeof addr === "object" && addr ? addr.port : 3e3;
+      resolve();
+    });
+  });
+  try {
+    const browserInstance = await playwright[browser].launch({
+      headless: !debug
+    });
+    const context = await browserInstance.newContext();
+    const page = await context.newPage();
+    page.on("console", (msg) => {
+      const type = msg.type();
+      const text = msg.text();
+      if (type === "error") {
+        console.error(text);
+      } else {
+        console.log(text);
+      }
+    });
+    page.on("pageerror", (err) => {
+      console.error("Page error:", err.message);
+    });
+    await page.goto(`http://localhost:${port}/`);
+    await page.waitForFunction(
+      () => globalThis.__LIBUILD_TEST__?.ended === true,
+      { timeout }
+    );
+    const results = await page.evaluate(() => globalThis.__LIBUILD_TEST__);
+    if (!debug) {
+      await browserInstance.close();
+    } else {
+      console.log("\nDebug mode: browser left open. Press Ctrl+C to exit.");
+      await new Promise(() => {
+      });
+    }
+    return {
+      platform: `browser (${browser})`,
+      passed: results.passed,
+      failed: results.failed,
+      errors: results.errors
+    };
+  } finally {
+    server.close();
+  }
+}
+function printResults(results) {
+  console.log("\n" + "=".repeat(60));
+  console.log("Test Results Summary");
+  console.log("=".repeat(60));
+  let allPassed = true;
+  for (const result of results) {
+    const status = result.failed === 0 ? "\u2713" : "\u2717";
+    const color = result.failed === 0 ? "\x1B[32m" : "\x1B[31m";
+    const reset = "\x1B[0m";
+    console.log(
+      `${color}${status}${reset} ${result.platform}: ${result.passed} passed, ${result.failed} failed`
+    );
+    if (result.failed > 0) {
+      allPassed = false;
+      for (const error of result.errors) {
+        console.log(`    \u2717 ${error.name}`);
+        console.log(`      ${error.error}`);
+      }
+    }
+  }
+  console.log("=".repeat(60));
+  return allPassed;
+}
+async function runTests(options = {}) {
+  const opts = {
+    cwd: options.cwd || process.cwd(),
+    patterns: options.patterns || DEFAULT_PATTERNS,
+    platforms: options.platforms || ["bun"],
+    debug: options.debug || false,
+    timeout: options.timeout || 6e4,
+    watch: options.watch || false
+  };
+  console.log("Finding test files...");
+  const testFiles = await findTestFiles(opts.cwd, opts.patterns);
+  if (testFiles.length === 0) {
+    console.log("No test files found.");
+    return true;
+  }
+  console.log(`Found ${testFiles.length} test file(s)`);
+  const tempDir = Path.join(opts.cwd, ".libuild-test");
+  await FS.mkdir(tempDir, { recursive: true });
+  const results = [];
+  try {
+    for (const platform of opts.platforms) {
+      console.log(`
+Building tests for ${platform}...`);
+      const bundlePath = await bundleTests(testFiles, platform, tempDir, opts.cwd);
+      console.log(`Running tests on ${platform}...`);
+      let result;
+      if (platform === "bun") {
+        result = await runBunTests(bundlePath, opts.timeout);
+      } else if (platform === "node") {
+        result = await runNodeTests(bundlePath, opts.timeout);
+      } else {
+        result = await runBrowserTests(bundlePath, platform, opts.timeout, opts.debug, opts.cwd);
+      }
+      results.push(result);
+    }
+    return printResults(results);
+  } finally {
+    if (!opts.debug) {
+      await FS.rm(tempDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+}
+async function detectPlatforms() {
+  const platforms = [];
+  const { spawn } = await import("child_process");
+  try {
+    await new Promise((resolve, reject) => {
+      const child = spawn("bun", ["--version"], { stdio: "ignore" });
+      child.on("close", (code) => code === 0 ? resolve() : reject());
+      child.on("error", reject);
+    });
+    platforms.push("bun");
+  } catch {
+  }
+  platforms.push("node");
+  try {
+    await import("playwright");
+    platforms.push("browser");
+  } catch {
+  }
+  return platforms;
+}
+export {
+  detectPlatforms,
+  runTests
+};

package/src/test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @b9g/libuild/test - Cross-platform test utilities
+ *
+ * Provides a unified testing API across Bun, Node, and browsers.
+ * Uses top-level await to detect runtime and load appropriate shim.
+ */
+declare const describe: typeof import("node:test").describe | import("bun:test").Describe<[]>, test: typeof import("node:test") | import("bun:test").Test<[]>, it: typeof import("node:test") | import("bun:test").Test<[]>, expect: import("expect").Expect | import("bun:test").Expect, beforeAll: typeof import("node:test").before | typeof import("bun:test").beforeAll, afterAll: typeof import("node:test").after | typeof import("bun:test").afterAll, beforeEach: typeof import("node:test").beforeEach | typeof import("bun:test").beforeEach, afterEach: typeof import("node:test").afterEach | typeof import("bun:test").afterEach;
+export { describe, test, it, expect, beforeAll, afterAll, beforeEach, afterEach, };

package/src/test.js

@@ -0,0 +1,25 @@
+/// <reference types="./test.d.ts" />
+import "./_chunks/chunk-IBOCQ33F.js";
+
+// src/test.ts
+var isBun = typeof Bun !== "undefined";
+var {
+  describe,
+  test,
+  it,
+  expect,
+  beforeAll,
+  afterAll,
+  beforeEach,
+  afterEach
+} = isBun ? await import("./test-bun.js") : await import("./test-node.js");
+export {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  test
+};

package/src/cli.cjs

@@ -1,183 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/cli.ts
-var import_util = require("util");
-var Path = __toESM(require("path"), 1);
-var import_libuild = require("./libuild.cjs");
-var { values, positionals } = (0, import_util.parseArgs)({
-  args: process.argv.slice(2),
-  options: {
-    help: { type: "boolean", short: "h" },
-    version: { type: "boolean", short: "v" },
-    save: { type: "boolean" },
-    "no-save": { type: "boolean" }
-  },
-  allowPositionals: true,
-  strict: false
-  // Allow unknown options to be passed through
-});
-var HELP_TEXT = `
-libuild - Zero-config library builds
-
-Usage:
-  libuild [command] [directory] [options]
-
-Commands:
-  build     Build the library (default command)
-  publish   Build and publish the library
-
-Arguments:
-  directory Optional directory to build (defaults to current directory)
-
-Options:
-  --save    Update root package.json to point to dist files
-  --no-save Skip package.json updates (for publish command)
-
-IMPORTANT:
-  \u2022 libuild is zero-config - there is NO libuild.config.js file
-  \u2022 Configuration comes from your package.json (main, module, exports, etc.)
-  \u2022 Use --save to regenerate package.json fields based on built files
-  \u2022 Invalid bin/exports paths are automatically cleaned up with --save
-
-For publish command, all additional flags are forwarded to npm publish.
-
-Examples:
-  libuild                 # Build the library in current directory
-  libuild build           # Same as above
-  libuild ../other-proj   # Build library in ../other-proj
-  libuild build --save    # Build and update package.json for npm link
-  libuild publish ../lib  # Build and publish library in ../lib
-  libuild publish --dry-run --tag beta  # Build and publish with npm flags
-`;
-async function main() {
-  if (values.help) {
-    console.log(HELP_TEXT);
-    process.exit(0);
-  }
-  if (values.version) {
-    const pkg = await import("../package.json");
-    console.log(pkg.version);
-    process.exit(0);
-  }
-  const command = positionals[0] || "build";
-  let targetDir;
-  for (let i = 1; i < positionals.length; i++) {
-    const arg = positionals[i];
-    const flagValueFlags = ["--tag", "--access", "--registry", "--otp", "--workspace"];
-    const isValueForFlag = flagValueFlags.some((flag) => {
-      const flagIndex = process.argv.indexOf(flag);
-      const argIndex = process.argv.indexOf(arg);
-      return flagIndex !== -1 && argIndex === flagIndex + 1;
-    });
-    if (isValueForFlag) {
-      continue;
-    }
-    if (!arg.startsWith("--")) {
-      try {
-        const isSystemPath = Path.isAbsolute(arg) && (arg.startsWith("/bin/") || arg.startsWith("/usr/") || arg.startsWith("/etc/") || arg.startsWith("/var/") || arg.startsWith("/opt/") || arg.startsWith("/tmp/") || arg.startsWith("/System/") || arg.startsWith("/Applications/"));
-        if (isSystemPath) {
-          continue;
-        }
-        const resolvedPath = Path.resolve(arg);
-        if (arg.includes("/") || arg.includes("\\") || arg === "." || arg === ".." || arg.startsWith("./") || arg.startsWith("../")) {
-          targetDir = arg;
-          break;
-        }
-        const fs = await import("fs/promises");
-        try {
-          const stat = await fs.stat(resolvedPath);
-          if (stat.isDirectory() && !Path.isAbsolute(arg)) {
-            targetDir = arg;
-            break;
-          }
-        } catch {
-        }
-      } catch {
-      }
-    }
-  }
-  const cwd = targetDir ? Path.resolve(targetDir) : process.cwd();
-  const shouldSave = values.save || command === "publish" && !values["no-save"];
-  const allowedNpmFlags = [
-    "--dry-run",
-    "--tag",
-    "--access",
-    "--registry",
-    "--otp",
-    "--provenance",
-    "--workspace",
-    "--workspaces",
-    "--include-workspace-root"
-  ];
-  const rawExtraArgs = process.argv.slice(2).filter(
-    (arg) => !["build", "publish"].includes(arg) && !["--save", "--no-save", "--help", "-h", "--version", "-v"].includes(arg) && arg !== targetDir
-    // Don't filter out the target directory
-  );
-  const extraArgs = [];
-  for (let i = 0; i < rawExtraArgs.length; i++) {
-    const arg = rawExtraArgs[i];
-    if (arg.startsWith("--")) {
-      const flagName = arg.split("=")[0];
-      if (allowedNpmFlags.includes(flagName)) {
-        extraArgs.push(arg);
-        if (!arg.includes("=") && ["--tag", "--access", "--registry", "--otp", "--workspace"].includes(flagName)) {
-          if (i + 1 < rawExtraArgs.length && !rawExtraArgs[i + 1].startsWith("--")) {
-            extraArgs.push(rawExtraArgs[i + 1]);
-            i++;
-          }
-        }
-      } else {
-        console.warn(`Warning: Ignoring unknown/unsafe npm flag: ${arg}`);
-      }
-    } else {
-      const prevArg = i > 0 ? rawExtraArgs[i - 1] : "";
-      const isPrevArgValueFlag = ["--tag", "--access", "--registry", "--otp", "--workspace"].includes(prevArg) && !prevArg.includes("=");
-      if (isPrevArgValueFlag && extraArgs.includes(prevArg)) {
-        extraArgs.push(arg);
-      } else {
-        console.warn(`Warning: Ignoring unexpected argument: ${arg}`);
-      }
-    }
-  }
-  try {
-    switch (command) {
-      case "build":
-        await (0, import_libuild.build)(cwd, shouldSave);
-        break;
-      case "publish":
-        await (0, import_libuild.publish)(cwd, shouldSave, extraArgs);
-        break;
-      default:
-        console.error(`Unknown command: ${command}`);
-        console.log(HELP_TEXT);
-        process.exit(1);
-    }
-  } catch (error) {
-    console.error("Error:", error.message);
-    process.exit(1);
-  }
-}
-main();