@codebend3r/gale 0.2.0 → 0.2.1

package/README.md

@@ -27,4 +27,4 @@ console.log(result.errored);
 console.log(result.results);
 ```
 
-See the full documentation at [github.com/LyricalString/gale](https://github.com/LyricalString/gale).
+See the full documentation at [github.com/codebend3r/gale](https://github.com/codebend3r/gale).

package/index.mjs

@@ -20,6 +20,13 @@ const __dirname = dirname(__filename);
 // ---------------------------------------------------------------------------
 
 function findBinary() {
+  // 0. An explicit override wins. Test suites and monorepos use this to point
+  //    at a freshly built binary instead of the bundled one.
+  const override = process.env.GALE_BINARY;
+  if (override) {
+    return override;
+  }
+
   // 1. Check the bin/ directory within the npm package
   const localBin = join(__dirname, "bin", "gale");
   if (existsSync(localBin)) {

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@codebend3r/gale",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "An extremely fast CSS linter, written in Rust. Drop-in replacement for Stylelint.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/LyricalString/gale"
+    "url": "https://github.com/codebend3r/gale"
   },
-  "homepage": "https://github.com/LyricalString/gale",
-  "bugs": "https://github.com/LyricalString/gale/issues",
+  "homepage": "https://github.com/codebend3r/gale",
+  "bugs": "https://github.com/codebend3r/gale/issues",
   "keywords": [
     "css",
     "linter",
@@ -39,7 +39,7 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=20.0.0"
   },
   "scripts": {
     "test": "node test.mjs"

package/test.mjs

@@ -8,18 +8,45 @@
  * Requires a working gale binary (either in npm/bin/ or on PATH).
  */
 
+import { createRequire } from "node:module";
+
 import { lint, formatters, resolveConfig, createPlugin } from "./index.mjs";
 
+const require = createRequire(import.meta.url);
+
 let passed = 0;
 let failed = 0;
+let current = "";
+
+// Dots reporter: one "." per passing assertion, "F" per failure. Failure
+// details are printed on their own line so the dots stay readable.
+function section(name) {
+  current = name;
+}
+
+function fail(message) {
+  process.stdout.write("F");
+  console.error(`\n  FAIL [${current}] ${message}`);
+  failed++;
+}
 
 function assert(condition, message) {
   if (condition) {
-    console.log(`  PASS: ${message}`);
+    process.stdout.write(".");
     passed++;
   } else {
-    console.error(`  FAIL: ${message}`);
-    failed++;
+    fail(message);
+  }
+}
+
+// Runs fn with console.warn muted, for APIs that warn by design.
+function quietly(fn) {
+  const warn = console.warn;
+  console.warn = () => {};
+  try {
+    return fn();
+  } finally {
+    console.warn = warn;
   }
 }
 
@@ -28,7 +55,7 @@ function assert(condition, message) {
 // ---------------------------------------------------------------------------
 
 async function testLintCodeEmptyBlock() {
-  console.log("\nTest 1: lint({ code: 'a {}' })");
+  section("Test 1: lint({ code: 'a {}' })");
 
   try {
     const result = await lint({ code: "a {}" });
@@ -50,8 +77,7 @@ async function testLintCodeEmptyBlock() {
       assert(typeof first.ignored === "boolean", "first result has ignored boolean");
     }
   } catch (err) {
-    console.error(`  ERROR: ${err.message}`);
-    failed++;
+    fail(`ERROR: ${err.message}`);
   }
 }
 
@@ -60,7 +86,7 @@ async function testLintCodeEmptyBlock() {
 // ---------------------------------------------------------------------------
 
 async function testLintCodeWithConfig() {
-  console.log("\nTest 2: lint({ code: 'a { color: pink; }', config: { rules: { 'color-named': 'never' } } })");
+  section("Test 2: lint({ code: 'a { color: pink; }', config: { rules: { 'color-named': 'never' } } })");
 
   try {
     const result = await lint({
@@ -86,13 +112,10 @@ async function testLintCodeWithConfig() {
           w.rule === "color-named",
           `warning rule is "color-named" (got "${w.rule}")`,
         );
-      } else {
-        console.log("  INFO: No warnings returned (gale may not flag this without config).");
       }
     }
   } catch (err) {
-    console.error(`  ERROR: ${err.message}`);
-    failed++;
+    fail(`ERROR: ${err.message}`);
   }
 }
 
@@ -101,7 +124,7 @@ async function testLintCodeWithConfig() {
 // ---------------------------------------------------------------------------
 
 async function testResolveConfig() {
-  console.log("\nTest 3: resolveConfig('test.css')");
+  section("Test 3: resolveConfig('test.css')");
 
   try {
     const config = await resolveConfig("test.css");
@@ -111,8 +134,7 @@ async function testResolveConfig() {
       "resolveConfig returns object or undefined",
     );
   } catch (err) {
-    console.error(`  ERROR: ${err.message}`);
-    failed++;
+    fail(`ERROR: ${err.message}`);
   }
 }
 
@@ -121,7 +143,7 @@ async function testResolveConfig() {
 // ---------------------------------------------------------------------------
 
 async function testFormattersJson() {
-  console.log("\nTest 4: formatters.json resolves to a function");
+  section("Test 4: formatters.json resolves to a function");
 
   try {
     const jsonFormatter = await formatters.json;
@@ -144,8 +166,7 @@ async function testFormattersJson() {
     const parsed = JSON.parse(output);
     assert(Array.isArray(parsed), "JSON formatter output is parseable as array");
   } catch (err) {
-    console.error(`  ERROR: ${err.message}`);
-    failed++;
+    fail(`ERROR: ${err.message}`);
   }
 }
 
@@ -154,9 +175,9 @@ async function testFormattersJson() {
 // ---------------------------------------------------------------------------
 
 async function testCreatePlugin() {
-  console.log("\nTest 5: createPlugin returns stub");
+  section("Test 5: createPlugin returns stub");
 
-  const plugin = createPlugin("my-rule", () => {});
+  const plugin = quietly(() => createPlugin("my-rule", () => {}));
   assert(plugin.ruleName === "my-rule", 'plugin.ruleName is "my-rule"');
   assert(typeof plugin.rule === "function", "plugin.rule is a function");
 }
@@ -166,7 +187,7 @@ async function testCreatePlugin() {
 // ---------------------------------------------------------------------------
 
 async function testLinterResultShape() {
-  console.log("\nTest 6: LinterResult has correct shape");
+  section("Test 6: LinterResult has correct shape");
 
   try {
     const result = await lint({ code: "a { color: red; }" });
@@ -179,8 +200,39 @@ async function testLinterResultShape() {
     assert("maxWarningsExceeded" in result, "result has maxWarningsExceeded key");
     assert("code" in result, "result has code key");
   } catch (err) {
-    console.error(`  ERROR: ${err.message}`);
-    failed++;
+    fail(`ERROR: ${err.message}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Test 7: CommonJS entry point bridges to the ESM implementation
+// ---------------------------------------------------------------------------
+
+async function testCommonJsEntry() {
+  section("Test 7: require('./index.cjs') exposes the same API");
+
+  try {
+    const cjs = require("./index.cjs");
+
+    assert(typeof cjs.lint === "function", "cjs.lint is a function");
+    assert(typeof cjs.resolveConfig === "function", "cjs.resolveConfig is a function");
+    assert(typeof cjs.createPlugin === "function", "cjs.createPlugin is a function");
+    assert(cjs.default === cjs, "cjs.default points back at module.exports");
+
+    const jsonFormatter = await cjs.formatters.json;
+    assert(typeof jsonFormatter === "function", "cjs.formatters.json resolves to a function");
+
+    const result = await cjs.lint({
+      code: "a {}",
+      config: { rules: { "block-no-empty": true } },
+    });
+    assert(Array.isArray(result.results), "cjs.lint returns results");
+    assert(
+      result.results[0]?.warnings[0]?.rule === "block-no-empty",
+      "cjs.lint reports block-no-empty",
+    );
+  } catch (err) {
+    fail(`ERROR: ${err.message}`);
   }
 }
 
@@ -189,16 +241,15 @@ async function testLinterResultShape() {
 // ---------------------------------------------------------------------------
 
 async function main() {
-  console.log("=== @codebend3r/gale programmatic API tests ===");
-
   await testLintCodeEmptyBlock();
   await testLintCodeWithConfig();
   await testResolveConfig();
   await testFormattersJson();
   await testCreatePlugin();
   await testLinterResultShape();
+  await testCommonJsEntry();
 
-  console.log(`\n=== Results: ${passed} passed, ${failed} failed ===`);
+  console.log(`\n${passed} passed, ${failed} failed (Node ${process.versions.node})`);
 
   if (failed > 0) {
     process.exit(1);