@jterrazz/typescript 9.0.1 → 9.1.1

package/lib/merge-knip-config.js

@@ -6,6 +6,11 @@
  *
  * Usage: node merge-knip-config.js <base.json> [project-knip.json]
  *
+ * The project file is read as JSONC — comments and trailing commas — so an
+ * ignore can carry the reason it exists. Every entry knip is told to overlook
+ * is a judgement, and a judgement with no reason beside it is re-litigated by
+ * the next reader.
+ *
  * Merge rules:
  *   - Arrays (ignoreDependencies, ignoreBinaries, ignore): concatenated and deduplicated
  *   - Objects (rules, vitest, etc.): project values override base
@@ -29,14 +34,101 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 
 import { workspaceMembers } from './workspace-members.js';
 
+/**
+ * Drops `//` and block comments, leaving everything inside a string literal
+ * alone — a comment marker in a glob (`ignore: ["**\/*.js"]`) is data.
+ */
+function withoutComments(text) {
+    let output = '',
+        index = 0,
+        inString = false;
+
+    while (index < text.length) {
+        const char = text[index];
+
+        if (inString) {
+            const escaped = char === '\\';
+            output += escaped ? char + (text[index + 1] ?? '') : char;
+            inString = escaped || char !== '"';
+            index += escaped ? 2 : 1;
+        } else if (char === '"') {
+            inString = true;
+            output += char;
+            index += 1;
+        } else if (char === '/' && text[index + 1] === '/') {
+            while (index < text.length && text[index] !== '\n') {
+                index += 1;
+            }
+        } else if (char === '/' && text[index + 1] === '*') {
+            const end = text.indexOf('*/', index + 2);
+            index = end === -1 ? text.length : end + 2;
+        } else {
+            output += char;
+            index += 1;
+        }
+    }
+
+    return output;
+}
+
+/** Whether the comma at `index` is the last one of its collection — `["a",]`. */
+function closesCollection(text, index) {
+    if (text[index] !== ',') {
+        return false;
+    }
+
+    let next = index + 1;
+    while (next < text.length && text[next].trim() === '') {
+        next += 1;
+    }
+
+    return text[next] === ']' || text[next] === '}';
+}
+
+/** Drops a comma that closes its collection, outside string literals. */
+function withoutTrailingCommas(text) {
+    let output = '',
+        index = 0,
+        inString = false;
+
+    while (index < text.length) {
+        const char = text[index];
+        const closes = closesCollection(text, index);
+
+        if (inString) {
+            const escaped = char === '\\';
+            output += escaped ? char + (text[index + 1] ?? '') : char;
+            inString = escaped || char !== '"';
+            index += escaped ? 2 : 1;
+        } else {
+            inString = char === '"';
+            output += closes ? '' : char;
+            index += 1;
+        }
+    }
+
+    return output;
+}
+
+/**
+ * Reads a JSONC document. Hand-written on purpose: no JSONC parser is in this
+ * package's tree, and two token classes do not earn a dependency.
+ */
+function readJsonc(path) {
+    const document = readFileSync(path, 'utf8'),
+        json = withoutTrailingCommas(withoutComments(document));
+
+    return JSON.parse(json);
+}
+
 const basePath = process.argv[2];
 const projectPath = process.argv[3];
 
-const base = JSON.parse(readFileSync(basePath, 'utf8'));
+const base = readJsonc(basePath);
 
 let project = {};
 if (projectPath) {
-    project = JSON.parse(readFileSync(projectPath, 'utf8'));
+    project = readJsonc(projectPath);
 }
 
 const ARRAY_KEYS = new Set(['ignore', 'ignoreBinaries', 'ignoreDependencies', 'entry', 'project']);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jterrazz/typescript",
-    "version": "9.0.1",
+    "version": "9.1.1",
     "author": "Jean-Baptiste Terrazzoni <contact@jterrazz.com>",
     "repository": {
         "type": "git",
@@ -23,6 +23,10 @@
             "types": "./src/index.d.ts",
             "default": "./src/index.js"
         },
+        "./oxfmt": {
+            "types": "./src/oxfmt.d.ts",
+            "default": "./src/oxfmt.js"
+        },
         "./oxlint": {
             "types": "./src/oxlint.d.ts",
             "default": "./src/oxlint.js"

package/presets/knip/base.json

@@ -1,5 +1,26 @@
 {
     "$schema": "https://unpkg.com/knip@6/schema.json",
     "ignoreDependencies": ["@jterrazz/test", "@jterrazz/typescript"],
-    "ignoreBinaries": ["oxlint", "oxfmt"]
+    "ignoreBinaries": ["oxlint", "oxfmt"],
+    // Knip's own oxlint/oxfmt/vitest/tsdown plugins auto-enable only when
+    // that PACKAGE is a direct dependency of the project (`hasDependency`
+    // reads package.json). A consumer of this preset declares only
+    // `@jterrazz/typescript`, so those tools are never direct dependencies
+    // of its own — the plugins stay off and their config files read as
+    // unused. Naming the toolchain's own config files here, by hand, is
+    // the fix: an explicit `entry` always wins, regardless of the plugin.
+    //
+    // Setting `entry` at all REPLACES knip's own default (it does not add
+    // to it) — so the first two patterns below are knip's own defaults,
+    // repeated here on purpose, or a consumer with a bare `index.ts` and no
+    // `entry` of its own would lose it the moment this preset's `entry`
+    // took over.
+    "entry": [
+        "{index,cli,main}.{js,mjs,cjs,jsx,ts,tsx,mts,cts}!",
+        "src/{index,cli,main}.{js,mjs,cjs,jsx,ts,tsx,mts,cts}!",
+        "oxlint.config.ts",
+        "oxfmt.config.ts",
+        "vitest.config.{js,mjs,ts,cjs,mts,cts}",
+        "tsdown.config.{ts,mts,cts,js,mjs,cjs}"
+    ]
 }

package/src/oxfmt.d.ts

@@ -0,0 +1,6 @@
+type ConfigObject = Record<string, unknown>;
+
+declare const base: ConfigObject;
+
+export { defineConfig } from 'oxfmt';
+export { base };

package/src/oxfmt.js

@@ -0,0 +1,14 @@
+/*
+ * The tool-facing oxfmt entry (`@jterrazz/typescript/oxfmt`): the shared
+ * formatting preset plus oxfmt's own `defineConfig`, for the same reason
+ * `oxlint.js` re-exports its tool's — a consumer's config names this package
+ * and nothing else:
+ *
+ *     import { base, defineConfig } from '@jterrazz/typescript/oxfmt';
+ *
+ *     export default defineConfig(base);
+ */
+
+export { defineConfig } from 'oxfmt';
+
+export { default as base } from '../presets/oxfmt/index.js';

package/src/oxfmt.test.ts

@@ -0,0 +1,17 @@
+import { expect, test } from 'vitest';
+
+import { base, defineConfig } from './oxfmt.js';
+
+test('exports the shared formatting preset', () => {
+    // Given - the tool-facing entry
+    // Then - the preset carries the ecosystem's format: four spaces, single quotes, 100 columns
+    expect(base).toMatchObject({ printWidth: 100, singleQuote: true, tabWidth: 4 });
+});
+
+test("re-exports oxfmt's own defineConfig", () => {
+    // Given - a config a consumer would write, with oxfmt declared nowhere in its project
+    const config = { printWidth: 80 };
+
+    // Then - the entry carries the tool's helper, which returns the config unchanged
+    expect(defineConfig(config)).toBe(config);
+});

package/src/oxlint.d.ts

@@ -12,4 +12,5 @@ declare const node: ConfigObject;
  */
 declare function compose(...fragments: ConfigObject[]): ConfigObject;
 
+export { defineConfig } from 'oxlint';
 export { compose, expo, hexagonal, next, node };

package/src/oxlint.js

@@ -1,7 +1,8 @@
 /*
  * The tool-facing oxlint entry (`@jterrazz/typescript/oxlint`): the named
- * presets plus the `compose()` helper. Wiring is EXPLICIT — a consumer
- * composes exactly the fragments it wants, nothing is auto-detected:
+ * presets, the `compose()` helper, and oxlint's own `defineConfig`. Wiring is
+ * EXPLICIT — a consumer composes exactly the fragments it wants, nothing is
+ * auto-detected:
  *
  *     import { testing } from '@jterrazz/test/oxlint';
  *     import { compose, node } from '@jterrazz/typescript/oxlint';
@@ -50,6 +51,13 @@ export function compose(...fragments) {
     return merged;
 }
 
+/* Oxlint's own `defineConfig`, re-exported from here: a bare
+ * `import { defineConfig } from 'oxlint'` in a consumer's config resolves only
+ * where the consumer declares oxlint itself, which pnpm's strict node_modules
+ * refuses to assume. Resolved from THIS package — where oxlint is a real
+ * dependency — the one-devDependency shape holds on every package manager. */
+export { defineConfig } from 'oxlint';
+
 export { default as hexagonal } from '../presets/oxlint/architectures/hexagonal.js';
 export { default as expo } from '../presets/oxlint/expo.js';
 export { default as next } from '../presets/oxlint/next.js';

package/src/oxlint.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from 'vitest';
 
-import { compose, expo, hexagonal, next, node } from './oxlint.js';
+import { compose, defineConfig, expo, hexagonal, next, node } from './oxlint.js';
 
 test('concatenates and dedupes plugin lists', () => {
     // Given - two fragments sharing one jsPlugin
@@ -77,3 +77,11 @@ test('exports the named presets', () => {
         expect(typeof preset).toBe('object');
     }
 });
+
+test("re-exports oxlint's own defineConfig", () => {
+    // Given - a config a consumer would write, with oxlint declared nowhere in its project
+    const config = { rules: { curly: 'error' } };
+
+    // Then - the entry carries the tool's helper, which returns the config unchanged
+    expect(defineConfig(config)).toBe(config);
+});