eslint-plugin-flawless 0.1.10 → 0.1.12

package/README.md

@@ -97,6 +97,28 @@ export default [
 }
 ```
 
+### oxlint (via jsPlugins)
+
+The non-type-aware rules are also published as an
+[oxlint JS plugin](https://oxc.rs/docs/guide/usage/linter/writing-js-plugins) at
+the `eslint-plugin-awesome/oxlint` entry point, so the same rules run under
+oxlint without any code duplication. Add `@oxlint/plugins` and the plugin as
+runtime dependencies, then reference it from your oxlint config:
+
+```jsonc
+// .oxlintrc.json
+{
+	"jsPlugins": ["eslint-plugin-awesome/oxlint"],
+	"rules": {
+		"awesome/my-new-rule": "error",
+	},
+}
+```
+
+The plugin key stays the same as under ESLint (`awesome`). Rules that require
+TypeScript type information or a custom parser are ESLint-only, since oxlint's
+JS plugin API supports neither.
+
 ## Development
 
 Scripts you’ll use during development:
@@ -178,13 +200,16 @@ Requires [type information](https://typescript-eslint.io/linting/typed-linting).
 
 | Name                                                                                          | Description                                                                      | 🔧  | 💭  |
 | :-------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------- | :-- | :-- |
+| [arrow-return-style](src/rules/arrow-return-style/documentation.md)                           | Enforce arrow function return style based on line length                         | 🔧  |     |
 | [jsx-shorthand-boolean](src/rules/jsx-shorthand-boolean/documentation.md)                     | Disallow shorthand boolean JSX attributes                                        | 🔧  |     |
 | [jsx-shorthand-fragment](src/rules/jsx-shorthand-fragment/documentation.md)                   | Enforce a consistent fragment form: the shorthand `<>...</>` or a named fragment | 🔧  |     |
 | [naming-convention](src/rules/naming-convention/documentation.md)                             | Enforce naming conventions for everything across a codebase                      |     | 💭  |
+| [no-export-default-arrow](src/rules/no-export-default-arrow/documentation.md)                 | Disallow anonymous arrow functions as export default declarations                | 🔧  |     |
 | [no-unnecessary-use-callback](src/rules/no-unnecessary-use-callback/documentation.md)         | Disallow unnecessary usage of 'useCallback'                                      |     |     |
 | [no-unnecessary-use-memo](src/rules/no-unnecessary-use-memo/documentation.md)                 | Disallow unnecessary usage of 'useMemo'                                          |     |     |
 | [prefer-destructuring-assignment](src/rules/prefer-destructuring-assignment/documentation.md) | Enforce destructuring assignment for component props                             | 🔧  |     |
 | [prefer-parameter-destructuring](src/rules/prefer-parameter-destructuring/documentation.md)   | Enforce destructuring parameters in the function signature                       | 🔧  |     |
+| [prefer-read-only-props](src/rules/prefer-read-only-props/documentation.md)                   | Enforce that function component props are read-only                              | 🔧  | 💭  |
 | [purity](src/rules/purity/documentation.md)                                                   | Disallow impure calls such as `math.random` or `os.clock` during render          |     |     |
 | [toml-sort-keys](src/rules/toml-sort-keys/documentation.md)                                   | Enforce a configured sort order for TOML keys and tables                         | 🔧  |     |
 | [yaml-block-key-blank-lines](src/rules/yaml-block-key-blank-lines/documentation.md)           | Enforce blank lines around top-level YAML block collection keys                  | 🔧  |     |

package/dist/index.d.mts

@@ -1,12 +1,73 @@
 import { TSESLint } from "@typescript-eslint/utils";
 import { Linter } from "eslint";
-
 //#region src/util.d.ts
 interface PluginDocumentation {
   description: string;
   recommended?: boolean;
   requiresTypeChecking: boolean;
 }
+declare const createRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<import("${configDir}").RuleWithMetaAndName<Options, MessageIds, PluginDocumentation>>) => TSESLint.RuleModule<MessageIds, Options, PluginDocumentation, TSESLint.RuleListener> & {
+  name: string;
+};
+/**
+ * A rule context whose `sourceCode` is replaced with a custom type. YAML rules
+ * use this to receive a `YAMLSourceCode` (whose token/AST APIs accept YAML
+ * nodes) instead of the default ESLint `SourceCode`.
+ *
+ * @template MessageIds - The rule's message identifiers.
+ * @template Options - The rule's options tuple.
+ * @template SourceCode - The source code type exposed on `context.sourceCode`.
+ */
+type RuleContextWithSourceCode<MessageIds extends string, Options extends ReadonlyArray<unknown>, SourceCode> = Omit<Readonly<TSESLint.RuleContext<MessageIds, Options>>, "sourceCode"> & {
+  readonly sourceCode: SourceCode;
+};
+/**
+ * A rule listener extended with oxlint's `createOnce` per-file lifecycle hooks.
+ *
+ * `before` runs before AST traversal of each file (returning `false` skips the
+ * file); `after` runs once traversal completes. Under oxlint these map to the
+ * native hooks; under ESLint {@link createFlawlessRule} emulates them.
+ */
+type FlawlessRuleListener = TSESLint.RuleListener & {
+  after?: () => void;
+  before?: () => boolean | void;
+};
+/**
+ * An ESLint rule module that additionally carries oxlint's `createOnce` method,
+ * so a single definition runs on both linters.
+ *
+ * @template Options - The rule's options tuple.
+ * @template MessageIds - The rule's message identifiers.
+ * @template SourceCode - The source code type exposed on `context.sourceCode`.
+ */
+type FlawlessRuleModule<Options extends ReadonlyArray<unknown>, MessageIds extends string, SourceCode = Readonly<TSESLint.SourceCode>> = ReturnType<typeof createRule<Options, MessageIds>> & {
+  createOnce: (context: RuleContextWithSourceCode<MessageIds, Options, SourceCode>) => FlawlessRuleListener;
+};
+//#endregion
+//#region src/rules/arrow-return-style/rule.d.ts
+declare const IMPLICIT = "useImplicitReturn";
+declare const EXPLICIT = "useExplicitReturn";
+declare const COMPLEX_EXPLICIT = "useExplicitReturnComplex";
+type MessageIds$4 = typeof COMPLEX_EXPLICIT | typeof EXPLICIT | typeof IMPLICIT;
+type ObjectReturnStyle = "always-explicit" | "complex-explicit" | "off";
+type Options$5 = [{
+  /** Always use explicit returns for JSX bodies. */
+  jsxAlwaysUseExplicitReturn?: boolean;
+  /** Maximum emitted line length (tab-expanded) before requiring an explicit return. */
+  maxLen?: number;
+  /** Object property / array element count above which a literal body counts as complex. */
+  maxObjectProperties?: number;
+  /** Always use explicit returns for arrows assigned to named exports. */
+  namedExportsAlwaysUseExplicitReturn?: boolean;
+  /** When to force explicit returns for object/array literal bodies. */
+  objectReturnStyle?: ObjectReturnStyle;
+  /** Columns a tab occupies when measuring against `maxLen`. */
+  tabWidth?: number;
+  /** Consult oxfmt for boundary decisions; `printWidth` defaults to `maxLen`. */
+  useOxfmt?: boolean | {
+    printWidth?: number;
+  };
+}];
 //#endregion
 //#region src/rules/jsx-shorthand-fragment/rule.d.ts
 declare const MESSAGE_ID_NAMED = "useNamedFragment";
@@ -189,30 +250,25 @@ declare const plugin: {
     version: string;
   };
   rules: {
-    "jsx-shorthand-boolean": TSESLint.RuleModule<"setAttributeValue", [], PluginDocumentation, TSESLint.RuleListener> & {
-      name: string;
-    };
-    "jsx-shorthand-fragment": TSESLint.RuleModule<MessageIds$3, Options$4, PluginDocumentation, TSESLint.RuleListener> & {
-      name: string;
-    };
+    "arrow-return-style": FlawlessRuleModule<Options$5, MessageIds$4, Readonly<TSESLint.SourceCode>>;
+    "jsx-shorthand-boolean": FlawlessRuleModule<[], "setAttributeValue", Readonly<TSESLint.SourceCode>>;
+    "jsx-shorthand-fragment": FlawlessRuleModule<Options$4, MessageIds$3, Readonly<TSESLint.SourceCode>>;
     "naming-convention": TSESLint.RuleModule<MessageIds$2, Options$3, PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
-    "no-unnecessary-use-callback": TSESLint.RuleModule<MessageIds$1, [], PluginDocumentation, TSESLint.RuleListener> & {
-      name: string;
-    };
-    "no-unnecessary-use-memo": TSESLint.RuleModule<MessageIds, [], PluginDocumentation, TSESLint.RuleListener> & {
-      name: string;
-    };
-    "prefer-destructuring-assignment": TSESLint.RuleModule<"default", [], PluginDocumentation, TSESLint.RuleListener> & {
-      name: string;
-    };
-    "prefer-parameter-destructuring": TSESLint.RuleModule<"default", Options$2, PluginDocumentation, TSESLint.RuleListener> & {
-      name: string;
-    };
-    purity: TSESLint.RuleModule<"impureCall", Options$1, PluginDocumentation, TSESLint.RuleListener> & {
+    "no-export-default-arrow": FlawlessRuleModule<[], "disallowExportDefaultArrow", Readonly<TSESLint.SourceCode>>;
+    "no-unnecessary-use-callback": FlawlessRuleModule<[], MessageIds$1, Readonly<TSESLint.SourceCode>>;
+    "no-unnecessary-use-memo": FlawlessRuleModule<[], MessageIds, Readonly<TSESLint.SourceCode>>;
+    "prefer-destructuring-assignment": FlawlessRuleModule<[], "default", Readonly<TSESLint.SourceCode>>;
+    "prefer-parameter-destructuring": FlawlessRuleModule<Options$2, "default", Readonly<TSESLint.SourceCode>>;
+    "prefer-read-only-props": TSESLint.RuleModule<"preferReadOnlyProps", [{
+      fixStyle?: "modifier" | "wrap";
+      importSource?: string;
+      wrapperType?: string;
+    }], PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
+    purity: FlawlessRuleModule<Options$1, "impureCall", Readonly<TSESLint.SourceCode>>;
     "toml-sort-keys": TSESLint.RuleModule<"unsorted", Options, PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
@@ -233,30 +289,25 @@ declare const _default: {
             version: string;
           };
           rules: {
-            "jsx-shorthand-boolean": import("${configDir}").RuleModule<"setAttributeValue", [], PluginDocumentation, import("${configDir}").RuleListener> & {
-              name: string;
-            };
-            "jsx-shorthand-fragment": import("${configDir}").RuleModule<MessageIds$3, Options$4, PluginDocumentation, import("${configDir}").RuleListener> & {
-              name: string;
-            };
+            "arrow-return-style": FlawlessRuleModule<Options$5, MessageIds$4, Readonly<import("${configDir}").SourceCode>>;
+            "jsx-shorthand-boolean": FlawlessRuleModule<[], "setAttributeValue", Readonly<import("${configDir}").SourceCode>>;
+            "jsx-shorthand-fragment": FlawlessRuleModule<Options$4, MessageIds$3, Readonly<import("${configDir}").SourceCode>>;
             "naming-convention": import("${configDir}").RuleModule<MessageIds$2, Options$3, PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
-            "no-unnecessary-use-callback": import("${configDir}").RuleModule<MessageIds$1, [], PluginDocumentation, import("${configDir}").RuleListener> & {
-              name: string;
-            };
-            "no-unnecessary-use-memo": import("${configDir}").RuleModule<MessageIds, [], PluginDocumentation, import("${configDir}").RuleListener> & {
-              name: string;
-            };
-            "prefer-destructuring-assignment": import("${configDir}").RuleModule<"default", [], PluginDocumentation, import("${configDir}").RuleListener> & {
-              name: string;
-            };
-            "prefer-parameter-destructuring": import("${configDir}").RuleModule<"default", Options$2, PluginDocumentation, import("${configDir}").RuleListener> & {
-              name: string;
-            };
-            purity: import("${configDir}").RuleModule<"impureCall", Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
+            "no-export-default-arrow": FlawlessRuleModule<[], "disallowExportDefaultArrow", Readonly<import("${configDir}").SourceCode>>;
+            "no-unnecessary-use-callback": FlawlessRuleModule<[], MessageIds$1, Readonly<import("${configDir}").SourceCode>>;
+            "no-unnecessary-use-memo": FlawlessRuleModule<[], MessageIds, Readonly<import("${configDir}").SourceCode>>;
+            "prefer-destructuring-assignment": FlawlessRuleModule<[], "default", Readonly<import("${configDir}").SourceCode>>;
+            "prefer-parameter-destructuring": FlawlessRuleModule<Options$2, "default", Readonly<import("${configDir}").SourceCode>>;
+            "prefer-read-only-props": import("${configDir}").RuleModule<"preferReadOnlyProps", [{
+              fixStyle?: "modifier" | "wrap";
+              importSource?: string;
+              wrapperType?: string;
+            }], PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
+            purity: FlawlessRuleModule<Options$1, "impureCall", Readonly<import("${configDir}").SourceCode>>;
             "toml-sort-keys": import("${configDir}").RuleModule<"unsorted", Options, PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
@@ -274,30 +325,25 @@ declare const _default: {
     version: string;
   };
   rules: {
-    "jsx-shorthand-boolean": import("${configDir}").RuleModule<"setAttributeValue", [], PluginDocumentation, import("${configDir}").RuleListener> & {
-      name: string;
-    };
-    "jsx-shorthand-fragment": import("${configDir}").RuleModule<MessageIds$3, Options$4, PluginDocumentation, import("${configDir}").RuleListener> & {
-      name: string;
-    };
+    "arrow-return-style": FlawlessRuleModule<Options$5, MessageIds$4, Readonly<import("${configDir}").SourceCode>>;
+    "jsx-shorthand-boolean": FlawlessRuleModule<[], "setAttributeValue", Readonly<import("${configDir}").SourceCode>>;
+    "jsx-shorthand-fragment": FlawlessRuleModule<Options$4, MessageIds$3, Readonly<import("${configDir}").SourceCode>>;
     "naming-convention": import("${configDir}").RuleModule<MessageIds$2, Options$3, PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
-    "no-unnecessary-use-callback": import("${configDir}").RuleModule<MessageIds$1, [], PluginDocumentation, import("${configDir}").RuleListener> & {
-      name: string;
-    };
-    "no-unnecessary-use-memo": import("${configDir}").RuleModule<MessageIds, [], PluginDocumentation, import("${configDir}").RuleListener> & {
-      name: string;
-    };
-    "prefer-destructuring-assignment": import("${configDir}").RuleModule<"default", [], PluginDocumentation, import("${configDir}").RuleListener> & {
-      name: string;
-    };
-    "prefer-parameter-destructuring": import("${configDir}").RuleModule<"default", Options$2, PluginDocumentation, import("${configDir}").RuleListener> & {
-      name: string;
-    };
-    purity: import("${configDir}").RuleModule<"impureCall", Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
+    "no-export-default-arrow": FlawlessRuleModule<[], "disallowExportDefaultArrow", Readonly<import("${configDir}").SourceCode>>;
+    "no-unnecessary-use-callback": FlawlessRuleModule<[], MessageIds$1, Readonly<import("${configDir}").SourceCode>>;
+    "no-unnecessary-use-memo": FlawlessRuleModule<[], MessageIds, Readonly<import("${configDir}").SourceCode>>;
+    "prefer-destructuring-assignment": FlawlessRuleModule<[], "default", Readonly<import("${configDir}").SourceCode>>;
+    "prefer-parameter-destructuring": FlawlessRuleModule<Options$2, "default", Readonly<import("${configDir}").SourceCode>>;
+    "prefer-read-only-props": import("${configDir}").RuleModule<"preferReadOnlyProps", [{
+      fixStyle?: "modifier" | "wrap";
+      importSource?: string;
+      wrapperType?: string;
+    }], PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
+    purity: FlawlessRuleModule<Options$1, "impureCall", Readonly<import("${configDir}").SourceCode>>;
     "toml-sort-keys": import("${configDir}").RuleModule<"unsorted", Options, PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
@@ -306,8 +352,8 @@ declare const _default: {
     };
   };
 };
-type RuleOptions = { [K in keyof RuleDefinitions]: NonNullable<RuleDefinitions[K]["defaultOptions"]> };
-type Rules = { [K in keyof RuleOptions]: Linter.RuleEntry<RuleOptions[K]> };
+type RuleOptions = { [K in keyof RuleDefinitions]: NonNullable<RuleDefinitions[K]["defaultOptions"]>; };
+type Rules = { [K in keyof RuleOptions]: Linter.RuleEntry<RuleOptions[K]>; };
 type RuleDefinitions = typeof plugin.rules;
 //#endregion
 export { RuleOptions, Rules, _default as default };