@jterrazz/typescript 10.1.0 → 10.1.2

package/bin/commands/check.sh

@@ -359,16 +359,20 @@ run_checks() {
     local format_status=0
     if [ "$FIX_MODE" = true ]; then
         # A fixer that changes MEANING is never applied unattended: the rules
-        # marked `unsafe` in the manifest are allowed for THIS run only, so
-        # `fix` leaves them alone and `check` still reports them for a human.
-        local unsafe_fixers=()
-        while IFS= read -r flag; do
-            [ -n "$flag" ] && unsafe_fixers+=("$flag")
-        done < <(node "$PACKAGE_ROOT/lib/unsafe-fixers.js")
-
-        "$OXLINT" --type-aware --fix "${unsafe_fixers[@]}" "${LINT_ARGS[@]}" \
+        # marked `unsafe` in the manifest are turned off for THIS run by a
+        # wrapper config written beside the consumer's own, so `fix` leaves
+        # them alone and `check` still reports them for a human.
+        local fix_config="oxlint.fix.config.mjs"
+        local fix_args=()
+        if [ -n "$OXLINT_CONFIG" ]; then
+            node "$PACKAGE_ROOT/lib/unsafe-fixers.js" "$PWD/$OXLINT_CONFIG" "$fix_config"
+            fix_args=(-c "$fix_config")
+        fi
+
+        "$OXLINT" --type-aware --fix "${fix_args[@]}" "${LINT_ARGS[@]}" \
             > "$tmp_dir/lint.log" 2>&1 ||
             lint_status=$?
+        rm -f "$fix_config"
         "$OXFMT" > "$tmp_dir/format.log" 2>&1 || format_status=$?
     else
         "$OXLINT" --type-aware "${LINT_ARGS[@]}" > "$tmp_dir/lint.log" 2>&1 &
@@ -614,8 +618,11 @@ run_checks() {
     # Bash decides whether the file is there; the script decides what it says.
     #
     # What fix mode judges is what SURVIVED the rewrite, so its machine-readable
-    # run is made here, after the fixer, and in the foreground.
-    if [ -f "$BASELINE_FILE" ]; then
+    # run is made here, after the fixer, and in the foreground — with the unsafe
+    # fixers armed again, so a directive that names one of them is used, not
+    # reported unused. The fixer's own exit code is never the verdict: it ran
+    # with those rules allowed. Without a baseline the judge wants zero.
+    if [ -f "$BASELINE_FILE" ] || [ "$FIX_MODE" = true ]; then
         if [ -n "$lint_json_pid" ]; then
             wait $lint_json_pid
         else

package/lib/check-baseline.js

@@ -128,7 +128,18 @@ if (import.meta.main) {
     const baseline = readBaseline(root);
 
     if (baseline === null) {
-        exit(Object.keys(counts).length > 0 ? 1 : 0);
+        const rules = Object.keys(counts).toSorted();
+        for (const rule of rules) {
+            stdout.write(
+                `${rule}  ${counts[rule]} diagnostic(s), and the project keeps no baseline\n`,
+            );
+        }
+        if (rules.length > 0) {
+            stdout.write(
+                "Fix them, or run 'typescript baseline' to record where the project stands.\n",
+            );
+        }
+        exit(rules.length > 0 ? 1 : 0);
     }
 
     const broken = judge(counts, baseline);

package/lib/check-markdown.js

@@ -20,8 +20,9 @@
  * paragraph into the two ideas it was carrying.
  */
 
+import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, join, relative, resolve } from 'node:path';
 import { argv, exit, stdout } from 'node:process';
 
 import { ignorePatternsOf, readText, trackedFiles } from './tracked-files.js';
@@ -216,18 +217,31 @@ function isRelative(target) {
     );
 }
 
-/** Every violation of one page, in the order the rules are declared. */
-function auditPage(root, path, markdown) {
-    const found = [];
-    const cited = withoutFences(markdown);
+/*
+ * A coordinate git ignores is not stale: a build product, a workbench clone
+ * or a generated tree is absent from a fresh checkout by design, and the page
+ * that names it is still true. Outside a repository nothing is ignored.
+ */
+function isIgnored(root, target) {
+    const probe = spawnSync('git', ['check-ignore', '-q', '--no-index', target], {
+        cwd: root,
+        stdio: 'ignore',
+    });
 
+    return probe.status === 0;
+}
+
+/** The links of one page that resolve to nothing, ignored coordinates forgiven. */
+function missingLinks(root, path, cited) {
+    const found = [];
     for (const match of cited.matchAll(LINK)) {
         const { target } = match.groups;
         const clean = target.split('#')[0] ?? '';
         if (!isRelative(target) || clean === '') {
             continue;
         }
-        if (!existsSync(resolve(root, dirname(path), clean))) {
+        const linked = resolve(root, dirname(path), clean);
+        if (!existsSync(linked) && !isIgnored(root, relative(root, linked))) {
             found.push({
                 message: `${target} resolves to nothing on disk`,
                 rule: 'markdown-link-missing',
@@ -235,9 +249,19 @@ function auditPage(root, path, markdown) {
         }
     }
 
+    return found;
+}
+
+/** The backticked paths of one page that name nothing, ignored coordinates forgiven. */
+function missingPaths(root, path, cited) {
+    const found = [];
     for (const match of cited.matchAll(BACKTICK_PATH)) {
         const target = match.groups.path.replace(/\/$/u, '');
-        if (!existsSync(join(root, target)) && !existsSync(resolve(root, dirname(path), target))) {
+        if (
+            !existsSync(join(root, target)) &&
+            !existsSync(resolve(root, dirname(path), target)) &&
+            !isIgnored(root, target)
+        ) {
             found.push({
                 message: `\`${target}\` names nothing on disk`,
                 rule: 'markdown-path-missing',
@@ -245,6 +269,14 @@ function auditPage(root, path, markdown) {
         }
     }
 
+    return found;
+}
+
+/** Every violation of one page, in the order the rules are declared. */
+function auditPage(root, path, markdown) {
+    const cited = withoutFences(markdown);
+    const found = [...missingLinks(root, path, cited), ...missingPaths(root, path, cited)];
+
     for (const reason of longProseBlocks(markdown)) {
         found.push({ message: reason, rule: 'markdown-block-long' });
     }

package/lib/unsafe-fixers.js

@@ -1,25 +1,47 @@
 #!/usr/bin/env node
 
 /**
- * The rules `fix` must not let oxlint rewrite, as the flags that switch them
- * off for one run: `--allow <rule>` per rule, one per line.
+ * The config the oxlint pass of `fix` runs with: the consumer's own, plus one
+ * trailing override turning every rule marked `unsafe` in the manifest off.
  *
  * A fixer that changes MEANING cannot be applied unattended — it turns working
  * code into code that does not compile, or into code that claims something
- * else. The rules are marked in the manifest (`unsafeFix()`), this prints them
- * for the shell, and the oxlint pass of `fix` passes them through. Check mode
- * keeps every one of them armed: the diagnostic is still owed an answer, from
- * a human ([Quality checks](../docs/06-quality-checks.md)).
+ * else. An override is the one form that reaches a rule wherever it was armed:
+ * a CLI `--allow` stops at the base config, and a rule the consumer's own
+ * overrides arm again (the vitest block, on the test globs) would still
+ * rewrite. Check mode keeps every one of them armed: the diagnostic is still
+ * owed an answer, from a human ([Quality checks](../docs/06-quality-checks.md)).
  *
- * Usage: node unsafe-fixers.js
+ * The file is written beside the consumer's config, never elsewhere: oxlint
+ * resolves `ignorePatterns` against the directory its config sits in.
+ *
+ * Usage: node unsafe-fixers.js <consumer config, absolute> <wrapper to write>
  */
 
-import { stdout } from 'node:process';
+import { writeFileSync } from 'node:fs';
+import { argv } from 'node:process';
 
 import { unsafeFixers } from '../rules/catalog.js';
 
+/** The wrapper module's source, for a JSON or an ES module config. */
+export function wrapperOf(consumerConfig) {
+    const off = Object.fromEntries(unsafeFixers().map(({ rule }) => [rule, 'off']));
+    const attributes = consumerConfig.endsWith('.json') ? " with { type: 'json' }" : '';
+
+    return [
+        `import base from ${JSON.stringify(consumerConfig)}${attributes};`,
+        '',
+        `const OFF = ${JSON.stringify(off)};`,
+        '',
+        'export default {',
+        '    ...base,',
+        "    overrides: [...(base.overrides ?? []), { files: ['**/*'], rules: OFF }],",
+        '};',
+        '',
+    ].join('\n');
+}
+
 if (import.meta.main) {
-    for (const { rule } of unsafeFixers()) {
-        stdout.write(`--allow\n${rule}\n`);
-    }
+    const [consumerConfig, wrapper] = argv.slice(2);
+    writeFileSync(wrapper, wrapperOf(consumerConfig));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jterrazz/typescript",
-    "version": "10.1.0",
+    "version": "10.1.2",
     "license": "MIT",
     "author": "Jean-Baptiste Terrazzoni <contact@jterrazz.com>",
     "repository": {

package/src/index.d.ts

@@ -9,6 +9,7 @@ declare const oxlintProfiles: {
     expo: OxlintConfig;
     hexagonal: OxlintConfig;
     library: OxlintConfig;
+    nested: (config: OxlintConfig) => OxlintConfig;
     next: OxlintConfig;
     node: OxlintConfig;
     react: OxlintConfig;

package/src/index.js

@@ -8,6 +8,7 @@ import nodeProfile from '../presets/oxlint/profiles/node.js';
 import reactProfile from '../presets/oxlint/profiles/react.js';
 import hexagonalFragment from '../rules/architecture/hexagonal.js';
 import { compile } from '../rules/compile.js';
+import { nested } from './oxlint.js';
 
 export const oxfmt = oxfmtConfig;
 
@@ -17,6 +18,7 @@ export const oxlint = {
     expo: expoProfile,
     hexagonal: compile(hexagonalFragment),
     library: libraryProfile,
+    nested,
     next: nextProfile,
     node: nodeProfile,
     react: reactProfile,

package/src/oxlint.d.ts

@@ -46,6 +46,12 @@ declare function compose(...configs: OxlintConfig[]): OxlintConfig;
  */
 declare function layers(definition: { id?: string; map: readonly Layer[] }): OxlintConfig;
 
+/**
+ * A config for a nested oxlint.config: the profile without the linter
+ * `options` oxlint accepts in the root config only.
+ */
+declare function nested(config: OxlintConfig): OxlintConfig;
+
 export { defineConfig } from 'oxlint';
 export { type OxlintConfig, type OxlintOverride } from 'oxlint';
 export {
@@ -58,6 +64,7 @@ export {
     type Layer,
     layers,
     library,
+    nested,
     next,
     node,
     react,

package/src/oxlint.js

@@ -48,3 +48,14 @@ export const hexagonal = compile(hexagonalFragment);
 export function layers(definition) {
     return compile(layersFragment(definition));
 }
+
+/**
+ * A config for a NESTED oxlint.config: oxlint accepts linter `options` in the
+ * root config only, and the root's already turn type information on for the
+ * whole tree, so a subtree's profile ships without its own.
+ */
+export function nested(config) {
+    const { options: _rootOnly, ...subtree } = config;
+
+    return subtree;
+}

package/src/oxlint.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from 'vitest';
 
-import { compose, defineConfig, hexagonal, layers } from './oxlint.js';
+import { compose, defineConfig, hexagonal, layers, nested, react } from './oxlint.js';
 
 test('concatenates and dedupes plugin lists', () => {
     // Given - two configs sharing one jsPlugin
@@ -139,3 +139,14 @@ test("re-exports oxlint's own defineConfig", () => {
     // Then - the entry carries the tool's helper, which returns the config unchanged
     expect(defineConfig(config)).toBe(config);
 });
+
+test('a nested config carries no linter options, which oxlint reads in the root only', () => {
+    // Given - a profile, which ships the options every root config needs
+    expect(react.options).toBeDefined();
+
+    // Then - its nested form keeps everything but them
+    const subtree = nested(compose(react, { rules: { curly: 'off' } }));
+    expect(subtree.options).toBeUndefined();
+    expect(subtree.plugins).toStrictEqual(react.plugins);
+    expect(subtree.rules?.curly).toBe('off');
+});