@plumeria/eslint-plugin 19.10.1 → 19.10.3

package/README.md

@@ -34,12 +34,14 @@ export default [plumeria.configs.recommended];
 
 ## Configuring the styling prop
 
-Both `custom-props-require-import` and `no-mixed-styling-props` need to know which JSX
+`custom-props-require-import`, `no-inline-object`, `no-mixed-styling-props`,
+`no-style-prop-relay` and `no-unresolved-composition` need to know which JSX
 prop carries styles. It is `classStyle` unless you changed it, so most projects
 configure nothing.
 
 If you did rename it — via `styleProp` on `withPlumeria` or on the unplugin
-options — tell the plugin the same name. ESLint cannot read it from your bundler
+options — tell the plugin the same name. The lint the bundler plugins run in the
+build is given that name already. ESLint cannot read it from your bundler
 config, so set it once in `settings` and every rule picks it up:
 
 ```js
@@ -257,6 +259,16 @@ plumerialint
 The process exits with a non-zero status code if any errors or warnings are found,
 making it suitable for use in CI and build pipelines.
 
+### Styling prop
+
+If the styling prop is renamed, pass the name with `--style-prop`. Without the
+flag, `plumerialint` asks ESLint for `settings.plumeria.styleProp` when ESLint
+and a flat config are installed, and uses `classStyle` otherwise:
+
+```bash
+plumerialint --style-prop sx
+```
+
 ### Aborting Builds on Lint Errors (Parallel Pipeline)
 
 You can run `plumerialint` in parallel with your build command (e.g. `next build` or `vite build`) using the `--` separator:

package/bin/oxlint.js

@@ -3,6 +3,7 @@
 const { spawn } = require('child_process');
 const process = require('process');
 const path = require('path');
+const fs = require('fs');
 const oxlintConfig = path.join(__dirname, '..', 'oxlint.json');
 const oxlintBin = path.join(
   path.dirname(require.resolve('oxlint/package.json')),
@@ -10,49 +11,73 @@ const oxlintBin = path.join(
   'oxlint',
 );
 
+const { cliOverrides } = require('../dist/cli.js');
+const { lintConfig, lowerPriority } = require('../dist/guard.js');
+
 const doubleDashIndex = process.argv.indexOf('--');
-let oxlintExtraArgs = [];
+let cliArgs = [];
 let buildCommand = null;
 let buildArgs = [];
 
 if (doubleDashIndex !== -1) {
-  oxlintExtraArgs = process.argv.slice(2, doubleDashIndex);
+  cliArgs = process.argv.slice(2, doubleDashIndex);
   if (doubleDashIndex + 1 < process.argv.length) {
     buildCommand = process.argv[doubleDashIndex + 1];
     buildArgs = process.argv.slice(doubleDashIndex + 2);
   }
 } else {
-  oxlintExtraArgs = process.argv.slice(2);
+  cliArgs = process.argv.slice(2);
 }
 
-const oxlintArgs = [
-  oxlintBin,
-  '-c',
-  oxlintConfig,
-  '--deny-warnings',
-  '--no-error-on-unmatched-pattern',
-  ...oxlintExtraArgs,
-];
+async function startOxlint() {
+  const { overrides, rest } = await cliOverrides(cliArgs, process.cwd());
+  const config = lintConfig(overrides);
+  const child = spawn(
+    process.execPath,
+    [
+      oxlintBin,
+      '-c',
+      config,
+      '--deny-warnings',
+      '--no-error-on-unmatched-pattern',
+      ...(rest.some((arg) => arg.startsWith('--threads'))
+        ? []
+        : ['--threads=2']),
+      ...rest,
+    ],
+    { stdio: 'inherit' },
+  );
+  lowerPriority(child.pid);
+  if (config !== oxlintConfig) {
+    child.on('close', () => fs.rmSync(config, { force: true }));
+  }
+  return child;
+}
 
 function handleOxlintError(err) {
   console.error('Error running oxlint:', err.message);
   process.exit(1);
 }
 
+function fail(err) {
+  console.error(`✖ [plumerialint] ${err.message}`);
+  process.exit(1);
+}
+
 if (!buildCommand) {
-  const child = spawn(process.execPath, oxlintArgs, { stdio: 'inherit' });
-  child.on('error', handleOxlintError);
-  child.on('close', (code) => {
-    process.exit(code || 0);
-  });
+  startOxlint().then((child) => {
+    child.on('error', handleOxlintError);
+    child.on('close', (code) => {
+      process.exit(code || 0);
+    });
+  }, fail);
 } else {
   let oxlintExited = false;
   let oxlintCode = null;
   let buildExited = false;
   let buildCode = null;
   let aborted = false;
-
-  const oxlintChild = spawn(process.execPath, oxlintArgs, { stdio: 'inherit' });
+  let oxlintChild = null;
 
   const fullBuildCommand =
     buildArgs.length > 0
@@ -78,16 +103,12 @@ if (!buildCommand) {
     } else if (failedSource === 'build') {
       console.error(`\n✖ [plumerialint] Build failed. Aborting lint...`);
       try {
-        oxlintChild.kill();
+        if (oxlintChild) oxlintChild.kill();
       } catch (e) {}
       process.exit(exitCode || 1);
     }
   }
 
-  oxlintChild.on('error', (err) => {
-    handleOxlintError(err);
-  });
-
   buildChild.on('error', (err) => {
     console.error(
       `Error running build command "${buildCommand}":`,
@@ -96,16 +117,6 @@ if (!buildCommand) {
     abort(1, 'build');
   });
 
-  oxlintChild.on('close', (code) => {
-    oxlintExited = true;
-    oxlintCode = code;
-    if (code !== 0) {
-      abort(code, 'lint');
-    } else if (buildExited) {
-      process.exit(buildCode || 0);
-    }
-  });
-
   buildChild.on('close', (code) => {
     buildExited = true;
     buildCode = code;
@@ -115,4 +126,22 @@ if (!buildCommand) {
       process.exit(oxlintCode || 0);
     }
   });
+
+  startOxlint().then((child) => {
+    if (aborted) {
+      child.kill();
+      return;
+    }
+    oxlintChild = child;
+    child.on('error', handleOxlintError);
+    child.on('close', (code) => {
+      oxlintExited = true;
+      oxlintCode = code;
+      if (code !== 0) {
+        abort(code, 'lint');
+      } else if (buildExited) {
+        process.exit(buildCode || 0);
+      }
+    });
+  }, fail);
 }

package/dist/cli.d.ts

@@ -0,0 +1,10 @@
+import { type LintOverrides } from './guard';
+export declare function takeStyleProp(args: string[]): {
+    styleProp?: string;
+    rest: string[];
+};
+export declare function stylePropFromESLint(cwd: string): Promise<string | undefined>;
+export declare function cliOverrides(args: string[], cwd: string): Promise<{
+    overrides: LintOverrides;
+    rest: string[];
+}>;

package/dist/cli.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeStyleProp = takeStyleProp;
+exports.stylePropFromESLint = stylePropFromESLint;
+exports.cliOverrides = cliOverrides;
+const path = __importStar(require("path"));
+const guard_1 = require("./guard");
+const STYLE_PROP_FLAG = '--style-prop';
+const PROBED_FILES = ['src/index.tsx', 'app/page.tsx', 'index.tsx', 'index.js'];
+function takeStyleProp(args) {
+    const rest = [];
+    let styleProp;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === STYLE_PROP_FLAG) {
+            styleProp = args[++i];
+            if (!styleProp)
+                throw new Error(`${STYLE_PROP_FLAG} needs a prop name`);
+        }
+        else if (arg.startsWith(`${STYLE_PROP_FLAG}=`)) {
+            styleProp = arg.slice(STYLE_PROP_FLAG.length + 1);
+            if (!styleProp)
+                throw new Error(`${STYLE_PROP_FLAG} needs a prop name`);
+        }
+        else {
+            rest.push(arg);
+        }
+    }
+    return { styleProp, rest };
+}
+async function stylePropFromESLint(cwd) {
+    let eslint;
+    try {
+        eslint = require(require.resolve('eslint', { paths: [cwd] }));
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const ESLint = eslint.loadESLint
+            ? await eslint.loadESLint({ useFlatConfig: true })
+            : eslint.ESLint;
+        const instance = new ESLint({ cwd });
+        for (const file of PROBED_FILES) {
+            const config = (await instance.calculateConfigForFile(path.join(cwd, file)));
+            const styleProp = config?.settings?.plumeria?.styleProp;
+            if (typeof styleProp === 'string')
+                return styleProp;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+async function cliOverrides(args, cwd) {
+    const { styleProp, rest } = takeStyleProp(args);
+    return {
+        overrides: (0, guard_1.lintOverrides)({
+            styleProp: styleProp ?? (await stylePropFromESLint(cwd)),
+        }),
+        rest,
+    };
+}

package/dist/guard.d.ts

@@ -1,10 +1,21 @@
 type Spelling = boolean | {
     sizes?: boolean;
 } | undefined;
-interface SpellingOptions {
+interface LintOptions {
     withoutLogicalProperties?: Spelling;
     withoutPhysicalProperties?: Spelling;
+    styleProp?: string;
 }
-export declare function spellingRules(options: SpellingOptions): Record<string, unknown>;
-export declare function startLintGuard(rules?: Record<string, unknown>): boolean;
+export interface LintOverrides {
+    rules?: Record<string, unknown>;
+    settings?: {
+        plumeria: {
+            styleProp: string;
+        };
+    };
+}
+export declare function lintOverrides(options: LintOptions): LintOverrides;
+export declare function lintConfig(overrides: LintOverrides): string;
+export declare function lowerPriority(pid: number | undefined): boolean;
+export declare function startLintGuard(overrides?: LintOverrides): boolean;
 export {};

package/dist/guard.js

@@ -33,7 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.spellingRules = spellingRules;
+exports.lintOverrides = lintOverrides;
+exports.lintConfig = lintConfig;
+exports.lowerPriority = lowerPriority;
 exports.startLintGuard = startLintGuard;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
@@ -48,7 +50,8 @@ function spellingRule(spelling) {
         ? ['error', { sizes: true }]
         : 'error';
 }
-function spellingRules(options) {
+function lintOverrides(options) {
+    const overrides = {};
     const rules = {};
     const logical = spellingRule(options.withoutLogicalProperties);
     const physical = spellingRule(options.withoutPhysicalProperties);
@@ -56,27 +59,45 @@ function spellingRules(options) {
         rules['@plumeria/no-logical-properties'] = logical;
     if (physical)
         rules['@plumeria/no-physical-properties'] = physical;
-    return rules;
+    if (logical || physical)
+        overrides.rules = rules;
+    if (options.styleProp) {
+        overrides.settings = { plumeria: { styleProp: options.styleProp } };
+    }
+    return overrides;
 }
-function lintConfig(rules) {
-    if (Object.keys(rules).length === 0)
+function lintConfig(overrides) {
+    if (!overrides.rules && !overrides.settings)
         return BASE_CONFIG;
     const file = path.join(os.tmpdir(), `plumeria-oxlint-${process.pid}.json`);
-    fs.writeFileSync(file, JSON.stringify({ extends: [BASE_CONFIG], rules }));
+    fs.writeFileSync(file, JSON.stringify({ extends: [BASE_CONFIG], ...overrides }));
     return file;
 }
-function startLintGuard(rules = {}) {
+function lowerPriority(pid) {
+    if (!pid)
+        return false;
+    try {
+        os.setPriority(pid, os.constants.priority.PRIORITY_LOW);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function startLintGuard(overrides = {}) {
     if (process.env[GUARD_ENV])
         return false;
     process.env[GUARD_ENV] = '1';
-    const config = lintConfig(rules);
+    const config = lintConfig(overrides);
     const child = (0, child_process_1.spawn)(process.execPath, [
         path.join(path.dirname(require.resolve('oxlint/package.json')), 'bin', 'oxlint'),
         '-c',
         config,
         '--deny-warnings',
         '--no-error-on-unmatched-pattern',
+        '--threads=2',
     ], { stdio: 'inherit' });
+    lowerPriority(child.pid);
     const exit = process.exit.bind(process);
     let lintCode = null;
     let pendingCode = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/eslint-plugin",
-  "version": "19.10.1",
+  "version": "19.10.3",
   "description": "Plumeria ESLint plugin",
   "author": "Refirst 11",
   "license": "MIT",
@@ -59,7 +59,7 @@
     "known-css-properties": "^0.37.0",
     "oxlint": "1.87.0",
     "zss-engine": "2.9.1",
-    "@plumeria/compiler": "19.10.1"
+    "@plumeria/compiler": "19.10.3"
   },
   "scripts": {
     "build": "rimraf dist && pnpm cjs",