@pob/root 27.5.0 → 27.7.0

package/bin/oxlint.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import { createRequire } from "node:module";
+import pkg from "oxlint/package.json" with { type: "json" };
+
+// oxlint looks for tsgolint (type-aware rules) in the project's
+// node_modules/.bin, which does not contain the bins of @pob/root dependencies
+if (!process.env.OXLINT_TSGOLINT_PATH) {
+  const require = createRequire(
+    import.meta.resolve("oxlint-tsgolint/package.json"),
+  );
+  try {
+    process.env.OXLINT_TSGOLINT_PATH = require.resolve(
+      `@oxlint-tsgolint/${process.platform}-${process.arch}/tsgolint${process.platform === "win32" ? ".exe" : ""}`,
+    );
+  } catch {
+    // unsupported platform: oxlint reports the missing tsgolint when needed
+  }
+}
+
+await import(
+  new URL(
+    typeof pkg.bin === "string" ? pkg.bin : pkg.bin.oxlint,
+    import.meta.resolve("oxlint/package.json"),
+  ).href
+);

package/bin/pob-claude-run-lint-staged.js

@@ -56,16 +56,18 @@ for (const [pattern, commandFnOrArray] of Object.entries(config)) {
   const matchBase = !pattern.includes("/");
   if (!picomatch.isMatch(relFile, pattern, { matchBase })) continue;
 
-  let commands;
-  if (typeof commandFnOrArray === "function") {
-    const result = commandFnOrArray([file]);
-    commands = Array.isArray(result) ? result : [result];
-  } else {
-    const arr = Array.isArray(commandFnOrArray)
-      ? commandFnOrArray
-      : [commandFnOrArray];
-    commands = arr.map((cmd) => `${cmd} ${JSON.stringify(file)}`);
-  }
+  // Function tasks generate their own commands and get no filename appended,
+  // arrays are sequential tasks and nested arrays parallel ones.
+  const resolveCommands = (command) => {
+    if (typeof command === "function") {
+      const result = command([file]);
+      return Array.isArray(result) ? result : [result];
+    }
+    if (Array.isArray(command)) return command.flatMap(resolveCommands);
+    return [`${command} ${JSON.stringify(file)}`];
+  };
+
+  const commands = resolveCommands(commandFnOrArray);
 
   for (const cmd of commands.filter(Boolean)) {
     if (shouldSkip(cmd)) continue;

package/bin/pob-root-lint-staged.js

@@ -10,6 +10,7 @@ lintStaged({
     process.exitCode = passed ? 0 : 1;
   })
   // eslint-disable-next-line unicorn/prefer-top-level-await
-  .catch(() => {
+  .catch((error) => {
+    console.error(error);
     process.exitCode = 1;
   });

package/bin/postinstall/github-workflows/{push-renovate-prettier.yml → push-renovate-format.yml}

@@ -1,8 +1,10 @@
-name: Run Prettier on renovate update
+name: Run format on renovate update
 
 on:
   push:
     branches:
+      - "renovate/oxfmt-**"
+      - "renovate/major-oxfmt"
       - "renovate/prettier-**"
       - "renovate/major-prettier"
 
@@ -10,7 +12,7 @@ permissions:
   contents: write
 
 jobs:
-  run-prettier:
+  run-format:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v7
@@ -26,8 +28,8 @@ jobs:
       - name: Install Dependencies
         run: $installOnCICommand$
 
-      - name: Run Prettier
-        run: $pmExec$ prettier --write .
+      - name: Run format
+        run: $pmRun$ format
 
       - name: Check for added or modified files
         id: git-check-modified
@@ -39,5 +41,5 @@ jobs:
           git add .
           git -c user.name="Christophe Hurpeau" \
             -c user.email="christophehurpeau@users.noreply.github.com" \
-            commit -m "style: prettier format" --author="github-actions[bot] <actions@github.com>"
+            commit -m "style: format" --author="github-actions[bot] <actions@github.com>"
           git push --no-verify

package/bin/postinstall/install-github-workflows.js

@@ -1,9 +1,23 @@
+import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { assertYarnBerry } from "../../lib/assert-yarn-berry.js";
 import { getPackageManagerCommands } from "./packageManagerHelpers.js";
 
+// this workflow only exists to commit the build output back to the branch.
+const hasBuildOutputInGit = () => {
+  try {
+    return execFileSync("git", ["ls-files", "--", "*dist/*", "*build/*"], {
+      encoding: "utf8",
+    })
+      .split("\n")
+      .some((file) => /(?:^|\/)(?:dist|build)\//.test(file));
+  } catch {
+    return false;
+  }
+};
+
 const ensureWorkflowUninstalled = (workflowName) => {
   try {
     fs.unlinkSync(path.resolve(`.github/workflows/${workflowName}.yml`));
@@ -12,7 +26,7 @@ const ensureWorkflowUninstalled = (workflowName) => {
 
 const installWorkflow = (
   workflowName,
-  { pmExec, installOnCICommand, installMutableCommand, ciPreStep },
+  { pmRun, pmExec, installOnCICommand, installMutableCommand, ciPreStep },
   condition = true,
 ) => {
   if (condition) {
@@ -26,6 +40,7 @@ const installWorkflow = (
           ),
           { encoding: "utf8" },
         )
+        .replaceAll("$pmRun$", pmRun)
         .replaceAll("$pmExec$", pmExec)
         .replaceAll("$ciPreStep$", ciPreStep)
         .replaceAll("$installOnCICommand$", installOnCICommand)
@@ -43,14 +58,16 @@ export default function installGithubWorkflows({ pkg, pm }) {
 
   if (fs.existsSync(".github")) {
     installWorkflow("push-renovate-pob_root", pmCommands);
-    installWorkflow("push-renovate-prettier", pmCommands);
+    installWorkflow("push-renovate-format", pmCommands);
+    ensureWorkflowUninstalled("push-renovate-prettier");
     ensureWorkflowUninstalled("push-renovate-typedoc");
     if (
       pkg.devDependencies &&
       (pkg.devDependencies.rollup ||
         pkg.devDependencies["@pob/rollup-esbuild"] ||
         pkg.devDependencies["@pob/rollup-typescript"]) &&
-      pkg.scripts?.build
+      pkg.scripts?.build &&
+      hasBuildOutputInGit()
     ) {
       installWorkflow("push-renovate-build", pmCommands);
     } else {

package/createLintStagedConfig.js

@@ -1,5 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
+import { defineConfig } from "lint-staged/config";
+import picomatch from "picomatch";
 import { assertYarnBerry } from "./lib/assert-yarn-berry.js";
 import { whichPmRuns } from "./lib/which-pm-runs.js";
 
@@ -56,23 +58,110 @@ const { lockfile, configfile, installAndDedupe } = (() => {
 const pkg = JSON.parse(fs.readFileSync(path.resolve("package.json")));
 const workspaces = pkg.workspaces || false;
 
+const workspacesPattern = (() => {
+  if (!workspaces) return undefined;
+  return workspaces.length === 1 ? workspaces[0] : `{${workspaces.join(",")}}`;
+})();
+
+const OXFMT = "oxfmt --no-error-on-unmatched-pattern";
+// Above this many files, commands run on the whole project instead.
+const MAX_FILENAMES = 100;
+const ESLINT_FIX = "eslint --fix --quiet";
+const OXLINT_FIX = "oxlint --fix --quiet --no-error-on-unmatched-pattern";
+
+// projects not yet migrated by pob have no oxlint config
+const hasOxlint = fs.existsSync(path.resolve(".oxlintrc.json"));
+const isOxlintSupportedFile = (filename) =>
+  /\.[cm]?[jt]sx?$/.test(filename) && !filename.endsWith(".d.ts");
+
+const CODE_COMMANDS = [OXFMT, hasOxlint && OXLINT_FIX, ESLINT_FIX].filter(
+  Boolean,
+);
+
 const getSrcDirectories = () => {
-  if (workspaces) {
-    return `${workspaces.length === 1 ? workspaces[0] : `{${workspaces.join(",")}}`}/{src,lib}`;
+  if (workspacesPattern) {
+    return `${workspacesPattern}/{src,lib}`;
   }
 
   return "{src,lib}";
 };
 
-export default function createLintStagedConfig() {
-  const srcDirectories = getSrcDirectories();
+// Changing the lockfile, the package manager config or any package.json
+// requires a reinstall before anything else runs.
+const getPmFilesPattern = () =>
+  `{${lockfile},${configfile ? `${configfile},` : ""}package.json${
+    workspaces
+      ? `,${workspaces.map((workspacePath) => `${workspacePath}/package.json`).join(",")}`
+      : ""
+  }}`;
+
+// tsc must also run when the typescript project layout or the dependencies
+// change, not only when a source file changes.
+const getTscTriggerPattern = (srcDirectories) =>
+  `{${[
+    `${srcDirectories}/**/*.{ts,tsx}`,
+    "tsconfig*.json",
+    "package.json",
+    workspacesPattern && `${workspacesPattern}/tsconfig*.json`,
+    workspacesPattern && `${workspacesPattern}/package.json`,
+  ]
+    .filter(Boolean)
+    .join(",")}}`;
+
+const getGitAddPmFilesCommand = () =>
+  `git add ${lockfile}${configfile ? ` ${configfile}` : ""}${pm.name === "yarn" ? " .yarn" : ""}`;
 
-  return {
-    [`{${lockfile},${configfile ? `${configfile},` : ""}package.json${
-      workspaces
-        ? `,${workspaces.map((workspacePath) => `${workspacePath}/package.json`).join(",")}`
-        : ""
-    }}`]: (filenames) => {
+/**
+ * Matches a file against a list of patterns, with the same picomatch options
+ * lint-staged itself uses (see lint-staged/lib/matchFiles.js), so both config
+ * flavors match the exact same files.
+ */
+const createMatcher = (patterns) => {
+  const matchers = patterns.map((pattern) =>
+    picomatch(pattern, {
+      dot: true,
+      // If the pattern doesn't look like a path, match against the basename in
+      // every directory.
+      matchBase: !pattern.includes("/"),
+      posixSlashes: true,
+      strictBrackets: true,
+    }),
+  );
+
+  return (filename) => matchers.some((isMatch) => isMatch(filename));
+};
+
+// lint-staged passes absolute paths unless `relative: true` is set.
+const toRelativePosixPath = (filename) =>
+  (path.isAbsolute(filename)
+    ? path.relative(process.cwd(), filename)
+    : filename
+  )
+    .split(path.sep)
+    .join("/");
+
+const withFilenames = (command, filenames) =>
+  `${command} "${filenames.join('" "')}"`;
+
+/**
+ * Legacy: one entry per pattern group, each running its own oxfmt and eslint on
+ * the files it matched. Kept behind POB_LEGACY_LINT_STAGED_CONFIG.
+ */
+const createLegacyConfig = ({
+  buildTasks,
+  cssPattern,
+  otherJsonPattern,
+  pmFilesPattern,
+  rootConfigPattern,
+  rootFilesPattern,
+  configDirsCodePattern,
+  srcCodePattern,
+  srcDocsPattern,
+  tscTriggerPattern,
+  workspaceConfigPattern,
+}) =>
+  defineConfig({
+    [pmFilesPattern]: (filenames) => {
       const packagejsonFilenames = filenames.filter((filename) =>
         filename.endsWith(".json"),
       );
@@ -82,32 +171,147 @@ export default function createLintStagedConfig() {
         pkg.scripts?.checks ? `${pm.name} run checks` : undefined,
         packagejsonFilenames.length === 0
           ? undefined
-          : `oxfmt "${packagejsonFilenames.join('" "')}"`,
-        "eslint --fix --quiet",
-        `git add ${lockfile}${configfile ? ` ${configfile}` : ""}${pm.name === "yarn" ? " .yarn" : ""}`,
+          : withFilenames("oxfmt", packagejsonFilenames),
+        ESLINT_FIX,
+        getGitAddPmFilesCommand(),
       ].filter(Boolean);
     },
-    "!(package|package-lock|.eslintrc).json": [
-      "oxfmt --no-error-on-unmatched-pattern",
-    ],
-    [`{.github,scripts,config,${srcDirectories}}/**/*.{yml,yaml,md}`]: [
-      "oxfmt --no-error-on-unmatched-pattern",
-    ],
-    "./*.{yml,yaml,md,jsonc}": ["oxfmt --no-error-on-unmatched-pattern"],
-    [`${srcDirectories}/**/*.{js,ts,tsx}`]: [
-      "oxfmt --no-error-on-unmatched-pattern",
-      "eslint --fix --quiet",
-    ],
-    "{scripts,config,.storyboook}/**/*.{js,mjs,cjs}": [
-      "oxfmt --no-error-on-unmatched-pattern",
-      "eslint --fix --quiet",
-    ],
-    [`{.storybook,${srcDirectories}}/**/*.css`]: [
-      "oxfmt --no-error-on-unmatched-pattern",
+    [otherJsonPattern]: [OXFMT],
+    [srcDocsPattern]: [OXFMT],
+    [rootFilesPattern]: [OXFMT],
+    [srcCodePattern]: CODE_COMMANDS,
+    [configDirsCodePattern]: CODE_COMMANDS,
+    [rootConfigPattern]: CODE_COMMANDS,
+    ...(workspaceConfigPattern && {
+      [workspaceConfigPattern]: CODE_COMMANDS,
+    }),
+    [cssPattern]: [OXFMT],
+    // Tasks are declared as functions so that lint-staged does not append the
+    // matched filenames: both commands build the whole project.
+    [tscTriggerPattern]: buildTasks,
+  });
+
+/**
+ * A single entry, which builds the command list itself: oxfmt and eslint each
+ * run once on all the files they should handle, instead of once per pattern
+ * group, and the build runs after them instead of alongside.
+ *
+ * oxfmt receives every staged file: it skips the files it does not support and
+ * the ones ignored by its config, so no file it can format is left out.
+ */
+const createConfig = ({
+  hasRollup,
+  pmFilesPattern,
+  rootConfigPattern,
+  configDirsCodePattern,
+  srcCodePattern,
+  tscTriggerPattern,
+  workspaceConfigPattern,
+}) => {
+  const matchesPmFiles = createMatcher([pmFilesPattern]);
+  const matchesEslint = createMatcher(
+    [
+      pmFilesPattern,
+      srcCodePattern,
+      configDirsCodePattern,
+      rootConfigPattern,
+      workspaceConfigPattern,
+    ].filter(Boolean),
+  );
+  const matchesTscTrigger = createMatcher([tscTriggerPattern]);
+
+  // Build tasks generate their own command so that lint-staged does not append
+  // the matched filenames: they build the whole project. They return no command
+  // at all when nothing they depend on changed.
+  const createBuildTask = (command) => (allStagedFiles) =>
+    allStagedFiles.map(toRelativePosixPath).some(matchesTscTrigger)
+      ? command
+      : [];
+
+  return defineConfig({
+    "*": [
+      (allStagedFiles) => {
+        const filenames = allStagedFiles.map(toRelativePosixPath);
+        const hasPmFiles = filenames.some(matchesPmFiles);
+        const eslintFilenames = filenames.filter(matchesEslint);
+
+        // Running on the whole project is simpler and avoids too long command
+        // lines when many files are staged.
+        const withFilenamesOrWholeProject = (command, commandFilenames) => {
+          if (commandFilenames.length === 0) return undefined;
+          if (commandFilenames.length > MAX_FILENAMES) return command;
+          return withFilenames(command, commandFilenames);
+        };
+
+        const getOxlintCommand = () => {
+          if (!hasOxlint) return undefined;
+          return withFilenamesOrWholeProject(
+            OXLINT_FIX,
+            eslintFilenames.filter(isOxlintSupportedFile),
+          );
+        };
+
+        const getEslintCommand = () => {
+          // eslint runs on the whole project when a package.json, the lockfile
+          // or the package manager config changed, like in the legacy config,
+          // as lint rules depend on the dependencies themselves.
+          if (hasPmFiles) return ESLINT_FIX;
+          return withFilenamesOrWholeProject(ESLINT_FIX, eslintFilenames);
+        };
+
+        return [
+          ...(hasPmFiles ? installAndDedupe : []),
+          hasPmFiles && pkg.scripts?.checks
+            ? `${pm.name} run checks`
+            : undefined,
+          withFilenamesOrWholeProject(OXFMT, filenames),
+          getOxlintCommand(),
+          getEslintCommand(),
+          hasPmFiles ? getGitAddPmFilesCommand() : undefined,
+        ].filter(Boolean);
+      },
+      // Runs after the tasks above, so that the build sees the formatted and
+      // fixed files. Both commands build the whole project, in parallel.
+      hasRollup
+        ? [
+            createBuildTask("rollup --config rollup.config.mjs"),
+            createBuildTask("tsc -b"),
+          ]
+        : createBuildTask("tsc"),
     ],
-    [`${srcDirectories}/**/*.{ts,tsx}`]: () =>
-      pkg.devDependencies && pkg.devDependencies["@pob/rollup-esbuild"]
-        ? ["rollup --config rollup.config.mjs", "tsc -b"]
-        : ["tsc"],
+  });
+};
+
+export default function createLintStagedConfig() {
+  const srcDirectories = getSrcDirectories();
+
+  const hasRollup = Boolean(
+    pkg.devDependencies && pkg.devDependencies["@pob/rollup-esbuild"],
+  );
+
+  const rootConfigPattern = "./*.{js,mjs,cjs,ts}";
+  const workspaceConfigPattern = workspacesPattern
+    ? `${workspacesPattern}/*.{js,mjs,cjs,ts}`
+    : undefined;
+
+  const patterns = {
+    buildTasks: hasRollup
+      ? [[() => "rollup --config rollup.config.mjs", () => "tsc -b"]] // run in parallel
+      : [() => "tsc"],
+    cssPattern: `{.storybook,${srcDirectories}}/**/*.css`,
+    hasRollup,
+    otherJsonPattern: "!(package|package-lock|.eslintrc).json",
+    pmFilesPattern: getPmFilesPattern(),
+    rootConfigPattern,
+    rootFilesPattern: "./*.{yml,yaml,md,jsonc}",
+    configDirsCodePattern: "{scripts,config,.storybook}/**/*.{js,mjs,cjs}",
+    srcCodePattern: `${srcDirectories}/**/*.{js,ts,tsx}`,
+    srcDocsPattern: `{.github,scripts,config,${srcDirectories}}/**/*.{yml,yaml,md}`,
+    tscTriggerPattern: getTscTriggerPattern(srcDirectories),
+    workspaceConfigPattern,
   };
+
+  return process.env.POB_LEGACY_LINT_STAGED_CONFIG
+    ? createLegacyConfig(patterns)
+    : createConfig(patterns);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pob/root",
-  "version": "27.5.0",
+  "version": "27.7.0",
   "description": "root package",
   "keywords": [],
   "homepage": "https://github.com/christophehurpeau/pob",
@@ -16,6 +16,7 @@
   },
   "bin": {
     "oxfmt": "./bin/oxfmt.cjs",
+    "oxlint": "./bin/oxlint.js",
     "pob-check-commit-msg": "./bin/pob-check-commit-msg.js",
     "pob-claude-run-lint-staged": "./bin/pob-claude-run-lint-staged.js",
     "pob-root-lint-staged": "./bin/pob-root-lint-staged.js",
@@ -68,19 +69,22 @@
     "conventional-changelog-writer": "^8.2.0",
     "conventional-commits-parser": "^6.2.1",
     "json5": "^2.2.3",
-    "lint-staged": "17.3.0",
+    "lint-staged": "17.4.1",
     "oxfmt": "0.54.0",
-    "picomatch": "^4.0.5",
+    "oxlint": "1.85.0",
+    "oxlint-tsgolint": "7.0.2002",
+    "picomatch": "^4.0.7",
     "semver": "^7.7.3",
-    "@pob/version": "6.0.1",
-    "pob-dependencies": "27.4.0"
+    "@pob/version": "6.2.0",
+    "pob-dependencies": "27.6.0"
   },
   "engines": {
     "node": ">=22.18.0"
   },
   "pob": {},
   "scripts": {
-    "lint": "pnpm run lint:eslint",
-    "lint:eslint": "pnpm run --dir '../..' eslint --quiet '@pob/root'"
+    "lint": "pnpm run lint:oxlint && pnpm run lint:eslint",
+    "lint:eslint": "pnpm --dir '../..' exec eslint --quiet '@pob/root'",
+    "lint:oxlint": "pnpm --dir '../..' exec oxlint --quiet '@pob/root'"
   }
 }