eslint-plugin-boolean-trap 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 acus9345
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,93 @@
-# Temporary Holding Version
+# eslint-plugin-boolean-trap
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm](https://img.shields.io/npm/v/eslint-plugin-boolean-trap.svg)](https://www.npmjs.com/package/eslint-plugin-boolean-trap)
+[![CI](https://github.com/acus9345/eslint-plugin-boolean-trap/actions/workflows/ci.yml/badge.svg)](https://github.com/acus9345/eslint-plugin-boolean-trap/actions/workflows/ci.yml)
+[![license](https://img.shields.io/npm/l/eslint-plugin-boolean-trap.svg)](./LICENSE)
+
+ESLint rules that catch the **boolean trap**: bare `true` / `false` arguments that make call sites unreadable.
+
+```js
+el.addEventListener('click', onClick, true); // what does true mean here?
+render(data, false, true); // and which one is which?
+```
+
+```js
+el.addEventListener('click', onClick, { capture: true }); // ✅ obvious
+render(data, { animate: false, force: true }); // ✅ obvious
+render(data, /* animate= */ false, /* force= */ true); // ✅ labeled
+```
+
+Works with ESLint 9 and 10 (flat config), JavaScript and TypeScript.
+
+## Install
+
+```sh
+npm install --save-dev eslint-plugin-boolean-trap
+```
+
+## Usage
+
+```js
+// eslint.config.js
+import booleanTrap from 'eslint-plugin-boolean-trap';
+
+export default [
+  booleanTrap.configs.recommended,
+];
+```
+
+Or pick rules yourself:
+
+```js
+import booleanTrap from 'eslint-plugin-boolean-trap';
+
+export default [
+  {
+    plugins: { 'boolean-trap': booleanTrap },
+    rules: {
+      'boolean-trap/no-boolean-literal-args': ['error', { ignoreFunctions: ['classList.toggle'] }],
+      'boolean-trap/no-boolean-params': 'warn',
+    },
+  },
+];
+```
+
+For TypeScript files, use [`typescript-eslint`](https://typescript-eslint.io/)'s parser as usual. `no-boolean-params` then also reads `boolean` type annotations.
+
+## Rules
+
+| Rule | Description | recommended | strict |
+| --- | --- | :-: | :-: |
+| [`no-boolean-literal-args`](./docs/rules/no-boolean-literal-args.md) | Disallow passing boolean literals as positional arguments | ✅ | ✅ |
+| [`no-boolean-params`](./docs/rules/no-boolean-params.md) | Disallow positional boolean parameters in function signatures | ✅ | ✅ |
+
+## Configs
+
+| Config | What it does |
+| --- | --- |
+| `recommended` | Both rules as errors. Single-argument calls like `setVisible(true)` and single-parameter functions are allowed. |
+| `strict` | Both rules as errors, and single-argument calls and single-parameter functions are reported too. |
+
+## Tests and assertions
+
+Assertion libraries often take booleans positionally (`assert.equal(actual, true)`). Ignore them by name, or relax the rule for test files:
+
+```js
+export default [
+  booleanTrap.configs.recommended,
+  {
+    files: ['**/*.test.*'],
+    rules: {
+      'boolean-trap/no-boolean-literal-args': ['error', { ignoreFunctions: ['assert.*', 't.*'] }],
+    },
+  },
+];
+```
+
+## Why
+
+A positional boolean hides its meaning at every call site. To understand `fetchUser(id, true, false)` you have to open the function definition. Options objects, named constants or separate functions (`insert` / `upsert` instead of `save(item, overwrite)`) make the intent readable where the call happens.
+
+## License
+
+[MIT](./LICENSE) © acus9345

package/docs/rules/no-boolean-literal-args.md

@@ -0,0 +1,85 @@
+# boolean-trap/no-boolean-literal-args
+
+Disallow passing boolean literals as positional arguments.
+
+✅ Enabled in the `recommended` and `strict` configs.
+
+## Rule details
+
+A bare `true` or `false` in a call tells the reader nothing:
+
+```js
+el.addEventListener('click', onClick, true); // true = useCapture? once? passive?
+render(data, false, true); // which one is which?
+new Widget(parent, true);
+```
+
+This rule reports each boolean literal passed positionally to a function call or `new` expression.
+
+Examples of **incorrect** code:
+
+```js
+/* eslint boolean-trap/no-boolean-literal-args: "error" */
+
+el.addEventListener('click', onClick, true);
+render(data, false, true);
+new Widget(parent, true);
+this.store.save(item, false);
+```
+
+Examples of **correct** code:
+
+```js
+/* eslint boolean-trap/no-boolean-literal-args: "error" */
+
+el.addEventListener('click', onClick, { capture: true });
+render(data, { animate: false, force: true });
+
+const OVERWRITE = true;
+save(item, OVERWRITE);
+
+// Labeled arguments (Chromium / Java-style comments) are fine
+render(data, /* animate= */ false, /* force= */ true);
+save(
+  item,
+  true, // overwrite
+);
+
+// A single argument is usually clear from the function name
+setVisible(true);
+expect(value).toBe(false);
+```
+
+## Options
+
+```js
+'boolean-trap/no-boolean-literal-args': ['error', {
+  allowSingleArgument: true,
+  allowLabeledArguments: true,
+  ignoreFunctions: [],
+}]
+```
+
+### `allowSingleArgument`
+
+Default `true`. Calls with exactly one argument, such as `setVisible(true)` or `toBe(false)`, are allowed.
+Set to `false` (as the `strict` config does) to report them too: `repaint(false)` is still a trap.
+
+### `allowLabeledArguments`
+
+Default `true`. A comment directly before or after the literal, or a `//` comment after its trailing comma on the same line, counts as a label and silences the report.
+
+### `ignoreFunctions`
+
+Default `[]`. Names of functions whose boolean arguments are allowed. `*` matches any characters except `.`.
+A pattern matches the full call name or any trailing part of it, so `toggle` and `classList.toggle` both cover `el.classList.toggle(...)`, and `assert.*` covers `assert.equal(...)`.
+
+```js
+'boolean-trap/no-boolean-literal-args': ['error', {
+  ignoreFunctions: ['assert.*', 'classList.toggle', 'set*'],
+}]
+```
+
+## When not to use it
+
+If your code base relies heavily on a third-party API with positional boolean flags that you cannot change, add those functions to `ignoreFunctions` instead of turning the rule off.

package/docs/rules/no-boolean-params.md

@@ -0,0 +1,75 @@
+# boolean-trap/no-boolean-params
+
+Disallow positional boolean parameters in function signatures.
+
+✅ Enabled in the `recommended` and `strict` configs.
+
+## Rule details
+
+[`no-boolean-literal-args`](./no-boolean-literal-args.md) catches the boolean trap at the call site. This rule catches it where it is created: a function that takes a positional boolean forces every caller to write `true` or `false` with no hint of meaning.
+
+A parameter counts as a positional boolean when it:
+
+- has a boolean default value: `function load(url, cache = true)`
+- has a TypeScript `boolean` annotation, including `boolean | undefined` and `true | false | null`: `function load(url: string, cache?: boolean)`
+- is a TypeScript parameter property typed `boolean`: `constructor(private strict: boolean)`
+
+It checks function declarations, expressions, arrow functions, class and object methods, `declare function` signatures, abstract methods and interface method signatures.
+Destructured parameters are never reported, since an options object is the recommended fix. Setters, the TypeScript `this` parameter and function type aliases are ignored.
+
+Examples of **incorrect** code:
+
+```ts
+/* eslint boolean-trap/no-boolean-params: "error" */
+
+function load(url, cache = true) {}
+
+class Store {
+  save(item: Item, overwrite: boolean) {}
+}
+
+interface Api {
+  fetch(url: string, force?: boolean): Promise<Response>;
+}
+```
+
+Examples of **correct** code:
+
+```ts
+/* eslint boolean-trap/no-boolean-params: "error" */
+
+function load(url, { cache = true } = {}) {}
+
+class Store {
+  save(item: Item, options: { overwrite: boolean }) {}
+  // or two well-named methods
+  insert(item: Item) {}
+  upsert(item: Item) {}
+}
+
+// One boolean parameter is allowed by default
+function setVisible(visible: boolean) {}
+```
+
+## Options
+
+```js
+'boolean-trap/no-boolean-params': ['error', {
+  allowSingleParameter: true,
+  ignoreFunctions: [],
+}]
+```
+
+### `allowSingleParameter`
+
+Default `true`. Functions whose only parameter is a boolean, such as `setVisible(visible)`, are allowed.
+Set to `false` (as the `strict` config does) to report them too.
+
+### `ignoreFunctions`
+
+Default `[]`. Function or method names to skip. `*` matches any characters except `.`, so `legacy*` skips `legacyLoad` and `legacySave`.
+A pattern matches the full name or any trailing part of it, so `run` and `exports.run` both cover `module.exports.run = function (...) {}`.
+
+## When not to use it
+
+When you implement an interface defined elsewhere (a framework callback, a DOM API shim) you may have to accept positional booleans. Use `ignoreFunctions` or an inline disable comment for those.

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "eslint-plugin-boolean-trap",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "ESLint rules that catch the boolean trap: positional true/false arguments and boolean parameters that make call sites unreadable.",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "boolean-trap",
+    "boolean",
+    "readability",
+    "code-quality",
+    "typescript"
+  ],
+  "homepage": "https://github.com/acus9345/eslint-plugin-boolean-trap#readme",
+  "bugs": {
+    "url": "https://github.com/acus9345/eslint-plugin-boolean-trap/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/acus9345/eslint-plugin-boolean-trap.git"
+  },
+  "license": "MIT",
+  "author": "acus9345",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "types",
+    "docs"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "lint": "eslint .",
+    "check": "npm run lint && npm test"
+  },
+  "engines": {
+    "node": "^18.18.0 || >=20.9.0"
+  },
+  "peerDependencies": {
+    "eslint": "^9.0.0 || ^10.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@typescript-eslint/parser": "^8.71.2",
+    "eslint": "^10.13.0",
+    "globals": "^17.13.0",
+    "typescript": "~6.0.3"
+  }
+}

package/src/index.js

@@ -0,0 +1,35 @@
+import { createRequire } from 'node:module';
+import noBooleanLiteralArgs from './rules/no-boolean-literal-args.js';
+import noBooleanParams from './rules/no-boolean-params.js';
+
+const { name, version } = createRequire(import.meta.url)('../package.json');
+
+const plugin = {
+  meta: { name, version, namespace: 'boolean-trap' },
+  rules: {
+    'no-boolean-literal-args': noBooleanLiteralArgs,
+    'no-boolean-params': noBooleanParams,
+  },
+  configs: /** @type {Record<string, import('eslint').Linter.Config>} */ ({}),
+};
+
+Object.assign(plugin.configs, {
+  recommended: {
+    name: 'boolean-trap/recommended',
+    plugins: { 'boolean-trap': plugin },
+    rules: {
+      'boolean-trap/no-boolean-literal-args': 'error',
+      'boolean-trap/no-boolean-params': 'error',
+    },
+  },
+  strict: {
+    name: 'boolean-trap/strict',
+    plugins: { 'boolean-trap': plugin },
+    rules: {
+      'boolean-trap/no-boolean-literal-args': ['error', { allowSingleArgument: false }],
+      'boolean-trap/no-boolean-params': ['error', { allowSingleParameter: false }],
+    },
+  },
+});
+
+export default plugin;

package/src/rules/no-boolean-literal-args.js

@@ -0,0 +1,88 @@
+import { createNameMatcher, docsUrl, getStaticName, isBooleanLiteral, ordinal } from '../utils.js';
+
+const DEFAULTS = {
+  allowSingleArgument: true,
+  allowLabeledArguments: true,
+  ignoreFunctions: /** @type {string[]} */ ([]),
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow passing boolean literals as positional arguments',
+      recommended: true,
+      url: docsUrl('no-boolean-literal-args'),
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          allowSingleArgument: { type: 'boolean' },
+          allowLabeledArguments: { type: 'boolean' },
+          ignoreFunctions: { type: 'array', items: { type: 'string' }, uniqueItems: true },
+        },
+        additionalProperties: false,
+      },
+    ],
+    defaultOptions: [DEFAULTS],
+    messages: {
+      positionalBoolean:
+        '`{{value}}` passed as the {{position}} argument of {{callee}} says nothing about what it does. Use an options object, a named constant, or label it: `/* name= */ {{value}}`.',
+      positionalBooleanNoLabel:
+        '`{{value}}` passed as the {{position}} argument of {{callee}} says nothing about what it does. Use an options object or a named constant.',
+    },
+  },
+
+  create(context) {
+    const options = { ...DEFAULTS, ...context.options[0] };
+    const { sourceCode } = context;
+    const isIgnored = createNameMatcher(options.ignoreFunctions);
+
+    /**
+     * `fn(/* force *\/ true)`, `fn(true /* force *\/)` and a `// force` line comment
+     * right after the trailing comma all count as a label.
+     * @param {import('estree').Node} arg
+     */
+    function isLabeled(arg) {
+      if (sourceCode.getCommentsBefore(arg).length > 0) return true;
+      if (sourceCode.getCommentsAfter(arg).length > 0) return true;
+      const next = sourceCode.getTokenAfter(arg);
+      if (next?.value !== ',') return false;
+      return sourceCode
+        .getCommentsAfter(next)
+        .some((comment) => comment.type === 'Line' && comment.loc?.start.line === arg.loc?.end.line);
+    }
+
+    /** @param {import('estree').CallExpression | import('estree').NewExpression} node */
+    function check(node) {
+      const args = node.arguments;
+      if (options.allowSingleArgument && args.length === 1) return;
+      if (!args.some(isBooleanLiteral)) return;
+
+      const name = getStaticName(node.callee);
+      if (isIgnored(name)) return;
+      const callee = name ? `\`${name}\`` : 'this call';
+
+      args.forEach((arg, index) => {
+        if (!isBooleanLiteral(arg)) return;
+        if (options.allowLabeledArguments && isLabeled(arg)) return;
+        context.report({
+          node: arg,
+          messageId: options.allowLabeledArguments ? 'positionalBoolean' : 'positionalBooleanNoLabel',
+          data: {
+            value: String(/** @type {import('estree').Literal} */ (arg).value),
+            position: ordinal(index + 1),
+            callee,
+          },
+        });
+      });
+    }
+
+    return {
+      CallExpression: check,
+      NewExpression: check,
+    };
+  },
+};

package/src/rules/no-boolean-params.js

@@ -0,0 +1,116 @@
+import { createNameMatcher, docsUrl, getFunctionName, isBooleanLiteral } from '../utils.js';
+
+const DEFAULTS = {
+  allowSingleParameter: true,
+  ignoreFunctions: /** @type {string[]} */ ([]),
+};
+
+const NULLISH_TYPES = new Set(['TSUndefinedKeyword', 'TSNullKeyword']);
+
+/**
+ * `boolean`, or a union of `boolean`/`true`/`false` with `null`/`undefined`.
+ * @param {any} type
+ */
+function isBooleanType(type) {
+  if (type.type === 'TSBooleanKeyword') return true;
+  if (type.type !== 'TSUnionType') return false;
+  let hasBoolean = false;
+  for (const member of type.types) {
+    if (member.type === 'TSBooleanKeyword' || (member.type === 'TSLiteralType' && isBooleanLiteral(member.literal))) {
+      hasBoolean = true;
+    } else if (!NULLISH_TYPES.has(member.type)) {
+      return false;
+    }
+  }
+  return hasBoolean;
+}
+
+/** @param {any} identifier */
+const hasBooleanAnnotation = (identifier) =>
+  identifier.typeAnnotation?.typeAnnotation != null && isBooleanType(identifier.typeAnnotation.typeAnnotation);
+
+/**
+ * The identifier of a positional boolean parameter, or null.
+ * Destructured parameters are fine: that is the recommended fix.
+ * @param {any} param
+ */
+function getBooleanParam(param) {
+  const target = param.type === 'TSParameterProperty' ? param.parameter : param;
+  if (target.type === 'AssignmentPattern') {
+    if (target.left.type !== 'Identifier') return null;
+    return isBooleanLiteral(target.right) || hasBooleanAnnotation(target.left) ? target.left : null;
+  }
+  if (target.type === 'Identifier' && hasBooleanAnnotation(target)) return target;
+  return null;
+}
+
+/** @param {any} node */
+function isSetter(node) {
+  return (node.parent?.type === 'MethodDefinition' || node.parent?.type === 'Property') && node.parent.kind === 'set';
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow positional boolean parameters in function signatures',
+      recommended: true,
+      url: docsUrl('no-boolean-params'),
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          allowSingleParameter: { type: 'boolean' },
+          ignoreFunctions: { type: 'array', items: { type: 'string' }, uniqueItems: true },
+        },
+        additionalProperties: false,
+      },
+    ],
+    defaultOptions: [DEFAULTS],
+    messages: {
+      booleanParam:
+        'Positional boolean parameter `{{name}}` in {{fn}} forces callers to write bare `true`/`false`. Accept an options object (`{ {{name}} }`) or split it into well-named functions.',
+    },
+  },
+
+  create(context) {
+    const options = { ...DEFAULTS, ...context.options[0] };
+    const isIgnored = createNameMatcher(options.ignoreFunctions);
+
+    /** @param {any} node */
+    function check(node) {
+      if (isSetter(node)) return;
+      // A TypeScript `this` parameter is not passed by callers.
+      const params = node.params.filter(
+        (/** @type {any} */ param) => !(param.type === 'Identifier' && param.name === 'this'),
+      );
+      if (options.allowSingleParameter && params.length === 1) return;
+
+      const booleanParams = params.map(getBooleanParam).filter(Boolean);
+      if (booleanParams.length === 0) return;
+
+      const name = getFunctionName(node);
+      if (isIgnored(name)) return;
+      const fn = name ? `\`${name}\`` : 'an anonymous function';
+
+      for (const identifier of booleanParams) {
+        context.report({
+          node: identifier,
+          messageId: 'booleanParam',
+          data: { name: identifier.name, fn },
+        });
+      }
+    }
+
+    return {
+      FunctionDeclaration: check,
+      FunctionExpression: check,
+      ArrowFunctionExpression: check,
+      TSDeclareFunction: check,
+      TSEmptyBodyFunctionExpression: check,
+      TSMethodSignature: check,
+    };
+  },
+};

package/src/utils.js

@@ -0,0 +1,112 @@
+const DOCS_BASE = 'https://github.com/acus9345/eslint-plugin-boolean-trap/blob/main/docs/rules/';
+
+/** @param {string} ruleName */
+export const docsUrl = (ruleName) => `${DOCS_BASE}${ruleName}.md`;
+
+/** @param {any} node */
+export function isBooleanLiteral(node) {
+  return node?.type === 'Literal' && typeof node.value === 'boolean';
+}
+
+/**
+ * Name of a non-computed (or literal-computed) member/property key.
+ * @param {any} key
+ * @param {boolean} computed
+ * @returns {string | null}
+ */
+function getKeyName(key, computed) {
+  if (!computed && key.type === 'Identifier') return key.name;
+  if (key.type === 'PrivateIdentifier') return `#${key.name}`;
+  if (key.type === 'Literal' && (typeof key.value === 'string' || typeof key.value === 'number')) {
+    return String(key.value);
+  }
+  if (key.type === 'TemplateLiteral' && key.expressions.length === 0) {
+    return key.quasis[0].value.cooked;
+  }
+  return null;
+}
+
+/**
+ * Dotted name of an expression such as `foo`, `this.save`, `a.b.c` or `#run`.
+ * When only the last segment is known (`getThing().toggle`) that segment is returned.
+ * @param {any} node
+ * @returns {string | null}
+ */
+export function getStaticName(node) {
+  switch (node.type) {
+    case 'Identifier':
+      return node.name;
+    case 'PrivateIdentifier':
+      return `#${node.name}`;
+    case 'ThisExpression':
+      return 'this';
+    case 'Super':
+      return 'super';
+    case 'ChainExpression':
+    case 'TSNonNullExpression':
+    case 'TSAsExpression':
+      return getStaticName(node.expression);
+    case 'MemberExpression': {
+      const property = getKeyName(node.property, node.computed);
+      if (!property) return null;
+      const object = getStaticName(node.object);
+      return object ? `${object}.${property}` : property;
+    }
+    default:
+      return null;
+  }
+}
+
+/**
+ * Best-effort name for a function, method or method signature.
+ * @param {any} node
+ * @returns {string | null}
+ */
+export function getFunctionName(node) {
+  if (node.id?.type === 'Identifier') return node.id.name;
+  if (node.type === 'TSMethodSignature') return getKeyName(node.key, node.computed);
+
+  const { parent } = node;
+  switch (parent?.type) {
+    case 'VariableDeclarator':
+      return parent.id.type === 'Identifier' ? parent.id.name : null;
+    case 'MethodDefinition':
+    case 'TSAbstractMethodDefinition':
+    case 'Property':
+    case 'PropertyDefinition':
+      return getKeyName(parent.key, parent.computed);
+    case 'AssignmentExpression':
+      return getStaticName(parent.left);
+    default:
+      return null;
+  }
+}
+
+/** @param {string} text */
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/**
+ * Builds a predicate for `ignoreFunctions` patterns. `*` matches anything except `.`.
+ * A pattern matches the whole dotted name or any trailing segments of it,
+ * so `toggle` and `classList.toggle` both ignore `el.classList.toggle(...)`.
+ * @param {string[]} patterns
+ * @returns {(name: string | null) => boolean}
+ */
+export function createNameMatcher(patterns) {
+  const regexes = patterns.map(
+    (pattern) => new RegExp(`^${pattern.split('*').map(escapeRegExp).join('[^.]*')}$`),
+  );
+  return (name) => {
+    if (!name || regexes.length === 0) return false;
+    const segments = name.split('.');
+    const suffixes = segments.map((_, index) => segments.slice(index).join('.'));
+    return regexes.some((regex) => suffixes.some((suffix) => regex.test(suffix)));
+  };
+}
+
+/** @param {number} n */
+export function ordinal(n) {
+  const mod100 = n % 100;
+  if (mod100 >= 11 && mod100 <= 13) return `${n}th`;
+  return `${n}${{ 1: 'st', 2: 'nd', 3: 'rd' }[n % 10] ?? 'th'}`;
+}

package/types/index.d.ts

@@ -0,0 +1,15 @@
+import type { ESLint, Linter, Rule } from 'eslint';
+
+declare const plugin: ESLint.Plugin & {
+  meta: { name: string; version: string; namespace: 'boolean-trap' };
+  rules: {
+    'no-boolean-literal-args': Rule.RuleModule;
+    'no-boolean-params': Rule.RuleModule;
+  };
+  configs: {
+    recommended: Linter.Config;
+    strict: Linter.Config;
+  };
+};
+
+export default plugin;