eslint-plugin-flawless 0.1.9 → 0.1.11

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:
@@ -185,6 +207,7 @@ Requires [type information](https://typescript-eslint.io/linting/typed-linting).
 | [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,48 @@
 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/jsx-shorthand-fragment/rule.d.ts
 declare const MESSAGE_ID_NAMED = "useNamedFragment";
@@ -24,7 +60,7 @@ interface JsxShorthandFragmentOptions {
    */
   readonly mode?: Mode;
 }
-type Options$3 = [JsxShorthandFragmentOptions?];
+type Options$4 = [JsxShorthandFragmentOptions?];
 type Mode = "element" | "syntax";
 //#endregion
 //#region src/rules/naming-convention/utils/enums.d.ts
@@ -135,7 +171,7 @@ interface NamingSelector {
 //#endregion
 //#region src/rules/naming-convention/rule.d.ts
 type MessageIds$2 = "doesNotMatchFormat" | "doesNotMatchFormatTrimmed" | "missingAffix" | "missingUnderscore" | "satisfyCustom" | "unexpectedUnderscore";
-type Options$2 = Array<NamingSelector>;
+type Options$3 = Array<NamingSelector>;
 //#endregion
 //#region src/rules/no-unnecessary-use-callback/rule.d.ts
 declare const MESSAGE_ID_DEFAULT$1 = "default";
@@ -147,6 +183,16 @@ declare const MESSAGE_ID_DEFAULT = "default";
 declare const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
 type MessageIds = typeof MESSAGE_ID_DEFAULT | typeof MESSAGE_ID_INSIDE_USE_EFFECT;
 //#endregion
+//#region src/rules/prefer-parameter-destructuring/rule.d.ts
+type Options$2 = [{
+  /**
+   * Whether the autofix may hoist pattern defaults and computed keys past
+   * earlier statements, reordering their side effects. Defaults to `true`;
+   * set to `false` to withhold the fix in those cases.
+   */
+  allowSideEffectReordering?: boolean;
+}];
+//#endregion
 //#region src/rules/purity/rule.d.ts
 interface PurityOptions {
   /**
@@ -179,30 +225,23 @@ 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$3, PluginDocumentation, TSESLint.RuleListener> & {
-      name: string;
-    };
-    "naming-convention": TSESLint.RuleModule<MessageIds$2, Options$2, PluginDocumentation, TSESLint.RuleListener> & {
+    "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", [], PluginDocumentation, TSESLint.RuleListener> & {
-      name: string;
-    };
-    purity: TSESLint.RuleModule<"impureCall", Options$1, PluginDocumentation, TSESLint.RuleListener> & {
+    "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;
     };
@@ -223,30 +262,23 @@ declare const _default: {
             version: string;
           };
           rules: {
-            "jsx-shorthand-boolean": import("${configDir}").RuleModule<"setAttributeValue", [], PluginDocumentation, import("${configDir}").RuleListener> & {
+            "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;
             };
-            "jsx-shorthand-fragment": import("${configDir}").RuleModule<MessageIds$3, Options$3, PluginDocumentation, import("${configDir}").RuleListener> & {
-              name: string;
-            };
-            "naming-convention": import("${configDir}").RuleModule<MessageIds$2, Options$2, 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", [], PluginDocumentation, import("${configDir}").RuleListener> & {
-              name: string;
-            };
-            purity: import("${configDir}").RuleModule<"impureCall", Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
+            "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;
             };
@@ -264,30 +296,23 @@ 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$3, PluginDocumentation, import("${configDir}").RuleListener> & {
-      name: string;
-    };
-    "naming-convention": import("${configDir}").RuleModule<MessageIds$2, Options$2, 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", [], PluginDocumentation, import("${configDir}").RuleListener> & {
+    "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;
     };
-    purity: import("${configDir}").RuleModule<"impureCall", Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
+    "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;
     };
@@ -296,8 +321,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 };