@b9g/libuild 0.1.21 → 0.1.23

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.1.22] - 2025-12-22
+
+### Fixed
+- **Bin imports from src polluting source tree** - Fixed .d.ts files being emitted to source directories when bin entries import from `../src/`. This caused lint failures and polluted the src/ folder. Fixes [#2](https://github.com/bikeshaving/libuild/issues/2).
+
 ## [0.1.21] - 2025-12-22
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/libuild",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "Zero-config library builds",
   "keywords": [
     "build",
@@ -22,18 +22,25 @@
     "libuild": "src/cli.js"
   },
   "dependencies": {
-    "esbuild": "^0.19.0"
+    "commander": "^14.0.2",
+    "esbuild": "^0.19.0",
+    "expect": "^30.2.0",
+    "glob": "^13.0.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
     "typescript": "^5.0.0"
   },
   "peerDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "playwright": "^1.40.0"
   },
   "peerDependenciesMeta": {
     "typescript": {
       "optional": true
+    },
+    "playwright": {
+      "optional": true
     }
   },
   "engines": {
@@ -47,34 +54,68 @@
     "CHANGELOG.md",
     "src/"
   ],
-  "main": "src/libuild.cjs",
   "module": "src/libuild.js",
   "exports": {
     ".": {
       "types": "./src/libuild.d.ts",
-      "import": "./src/libuild.js",
-      "require": "./src/libuild.cjs"
+      "import": "./src/libuild.js"
     },
     "./cli": {
       "types": "./src/cli.d.ts",
-      "import": "./src/cli.js",
-      "require": "./src/cli.cjs"
+      "import": "./src/cli.js"
     },
     "./cli.js": {
       "types": "./src/cli.d.ts",
-      "import": "./src/cli.js",
-      "require": "./src/cli.cjs"
+      "import": "./src/cli.js"
     },
     "./libuild": {
       "types": "./src/libuild.d.ts",
-      "import": "./src/libuild.js",
-      "require": "./src/libuild.cjs"
+      "import": "./src/libuild.js"
     },
     "./libuild.js": {
       "types": "./src/libuild.d.ts",
-      "import": "./src/libuild.js",
-      "require": "./src/libuild.cjs"
+      "import": "./src/libuild.js"
+    },
+    "./package.json": "./package.json",
+    "./test": {
+      "types": "./src/test.d.ts",
+      "import": "./src/test.js"
+    },
+    "./test.js": {
+      "types": "./src/test.d.ts",
+      "import": "./src/test.js"
+    },
+    "./test-bun": {
+      "types": "./src/test-bun.d.ts",
+      "import": "./src/test-bun.js"
+    },
+    "./test-bun.js": {
+      "types": "./src/test-bun.d.ts",
+      "import": "./src/test-bun.js"
     },
-    "./package.json": "./package.json"
+    "./test-node": {
+      "types": "./src/test-node.d.ts",
+      "import": "./src/test-node.js"
+    },
+    "./test-node.js": {
+      "types": "./src/test-node.d.ts",
+      "import": "./src/test-node.js"
+    },
+    "./test-browser": {
+      "types": "./src/test-browser.d.ts",
+      "import": "./src/test-browser.js"
+    },
+    "./test-browser.js": {
+      "types": "./src/test-browser.d.ts",
+      "import": "./src/test-browser.js"
+    },
+    "./test-runner": {
+      "types": "./src/test-runner.d.ts",
+      "import": "./src/test-runner.js"
+    },
+    "./test-runner.js": {
+      "types": "./src/test-runner.d.ts",
+      "import": "./src/test-runner.js"
+    }
   }
 }

package/src/_chunks/chunk-IBOCQ33F.js

@@ -0,0 +1,11 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/src/cli.js

@@ -3,160 +3,51 @@
 /// <reference types="./cli.d.ts" />
 
 // src/cli.ts
-import { parseArgs } from "util";
+import { Command } from "commander";
 import * as Path from "path";
 import { build, publish } from "./libuild.js";
-var { values, positionals } = 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
+import { runTests } from "./test-runner.js";
+var program = new Command();
+program.name("libuild").description("Zero-config library builds").version("0.1.22");
+program.command("build", { isDefault: true }).description("Build the library").argument("[directory]", "Directory to build", ".").option("--save", "Update root package.json to point to dist files").action(async (directory, options) => {
+  const cwd = Path.resolve(directory);
+  await build(cwd, options.save || false);
 });
-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 build(cwd, shouldSave);
-        break;
-      case "publish":
-        await 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);
+program.command("publish").description("Build and publish the library").argument("[directory]", "Directory to build and publish", ".").option("--no-save", "Skip package.json updates").option("--dry-run", "Perform a dry run").option("--tag <tag>", "Publish with a specific tag").option("--access <access>", "Set access level (public/restricted)").option("--registry <url>", "Use a specific registry").option("--otp <code>", "One-time password for 2FA").option("--provenance", "Generate provenance statement").action(async (directory, options) => {
+  const cwd = Path.resolve(directory);
+  const shouldSave = options.save !== false;
+  const npmArgs = [];
+  if (options.dryRun)
+    npmArgs.push("--dry-run");
+  if (options.tag)
+    npmArgs.push("--tag", options.tag);
+  if (options.access)
+    npmArgs.push("--access", options.access);
+  if (options.registry)
+    npmArgs.push("--registry", options.registry);
+  if (options.otp)
+    npmArgs.push("--otp", options.otp);
+  if (options.provenance)
+    npmArgs.push("--provenance");
+  await publish(cwd, shouldSave, npmArgs);
+});
+program.command("test").description("Run tests across platforms").argument("[directory]", "Directory containing tests", ".").option("-p, --platform <platforms...>", "Platforms to test on (bun, node, chromium, firefox, webkit)").option("--debug", "Keep browser open for debugging").option("-w, --watch", "Watch mode - re-run tests on file changes").option("--timeout <ms>", "Test timeout in milliseconds", "60000").action(async (directory, options) => {
+  const cwd = Path.resolve(directory);
+  const validPlatforms = ["bun", "node", "chromium", "firefox", "webkit"];
+  const platforms = options.platform?.length ? options.platform.filter((p) => validPlatforms.includes(p)) : ["bun"];
+  if (options.platform?.length && platforms.length !== options.platform.length) {
+    const invalid = options.platform.filter((p) => !validPlatforms.includes(p));
+    console.error(`Invalid platform(s): ${invalid.join(", ")}`);
+    console.error(`Valid platforms: ${validPlatforms.join(", ")}`);
     process.exit(1);
   }
-}
-main();
+  const success = await runTests({
+    cwd,
+    platforms,
+    debug: options.debug || false,
+    watch: options.watch || false,
+    timeout: parseInt(options.timeout || "60000", 10)
+  });
+  process.exit(success ? 0 : 1);
+});
+program.parse();

package/src/libuild.js

@@ -1,4 +1,6 @@
 /// <reference types="./libuild.d.ts" />
+import "./_chunks/chunk-IBOCQ33F.js";
+
 // src/libuild.ts
 import * as FS3 from "fs/promises";
 import * as Path3 from "path";
@@ -110,15 +112,15 @@ function dtsPlugin(options) {
         } catch (error) {
           return;
         }
-        const tsFiles = entryFiles.filter((file) => file.endsWith(".ts") && !file.endsWith(".d.ts"));
-        if (tsFiles.length === 0) {
-          return;
-        }
         await FS2.mkdir(options.outDir, { recursive: true });
         const fs = await import("fs");
         const resolvedRootDir = fs.realpathSync(options.rootDir);
         const resolvedOutDir = fs.realpathSync(options.outDir);
-        const resolvedTsFiles = tsFiles.map((f) => fs.realpathSync(f));
+        const tsFiles = entryFiles.filter((file) => file.endsWith(".ts") && !file.endsWith(".d.ts")).map((f) => fs.realpathSync(f)).filter((f) => f.startsWith(resolvedRootDir + Path2.sep));
+        if (tsFiles.length === 0) {
+          return;
+        }
+        const resolvedTsFiles = tsFiles;
         try {
           const compilerOptions = {
             declaration: true,
@@ -132,7 +134,13 @@ function dtsPlugin(options) {
             moduleResolution: TS.ModuleResolutionKind.Bundler
           };
           const program = TS.createProgram(resolvedTsFiles, compilerOptions);
-          const emitResult = program.emit();
+          const writeFile4 = (fileName, data, writeByteOrderMark, onError, sourceFiles) => {
+            if (!fileName.startsWith(resolvedOutDir + Path2.sep)) {
+              return;
+            }
+            TS.sys.writeFile(fileName, data, writeByteOrderMark);
+          };
+          const emitResult = program.emit(void 0, writeFile4);
           if (emitResult.diagnostics.length > 0) {
             const diagnostics = TS.formatDiagnosticsWithColorAndContext(emitResult.diagnostics, {
               getCanonicalFileName: (path) => path,
@@ -1019,8 +1027,10 @@ async function build2(cwd, save = false) {
   const externalDeps = [
     "*.json",
     // Let Node.js handle JSON imports natively
-    "esbuild"
+    "esbuild",
     // Explicit external to suppress require.resolve warning from esbuild's own code
+    "bun:*"
+    // Bun built-ins (bun:test, bun:sqlite, etc.)
   ];
   const entryPoints = [];
   const umdEntries = [];

package/src/test-browser.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Browser test shim for @b9g/libuild/test
+ *
+ * Implements a minimal test runner that works in browsers.
+ * Results are exposed via globalThis.__LIBUILD_TEST__ for Playwright to poll.
+ */
+interface Matchers {
+    toBe(expected: unknown): void;
+    toEqual(expected: unknown): void;
+    toStrictEqual(expected: unknown): void;
+    toBeTruthy(): void;
+    toBeFalsy(): void;
+    toBeNull(): void;
+    toBeUndefined(): void;
+    toBeDefined(): void;
+    toBeNaN(): void;
+    toBeGreaterThan(expected: number): void;
+    toBeGreaterThanOrEqual(expected: number): void;
+    toBeLessThan(expected: number): void;
+    toBeLessThanOrEqual(expected: number): void;
+    toContain(expected: unknown): void;
+    toHaveLength(expected: number): void;
+    toMatch(expected: RegExp | string): void;
+    toThrow(expected?: string | RegExp | Error): void;
+    toBeInstanceOf(expected: new (...args: any[]) => any): void;
+    not: Matchers;
+}
+export declare function expect(actual: unknown): Matchers;
+declare global {
+    var __LIBUILD_TEST__: {
+        ended: boolean;
+        failed: number;
+        passed: number;
+        errors: Array<{
+            name: string;
+            error: string;
+        }>;
+    };
+}
+type TestFn = () => void | Promise<void>;
+type HookFn = () => void | Promise<void>;
+export declare function describe(name: string, fn: () => void): void;
+export declare function test(name: string, fn: TestFn): void;
+export declare const it: typeof test;
+export declare function beforeEach(fn: HookFn): void;
+export declare function afterEach(fn: HookFn): void;
+export declare function beforeAll(fn: HookFn): void;
+export declare function afterAll(fn: HookFn): void;
+export {};