eslint-plugin-mobx 0.0.8 → 0.0.10

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # eslint-plugin-mobx
 
+## 0.0.10
+
+### Patch Changes
+
+-   [`44a5fe07`](https://github.com/mobxjs/mobx/commit/44a5fe07fb95c2ba24d8df19f18b57ee92abb1a9) [#3881](https://github.com/mobxjs/mobx/pull/3881) Thanks [@kade-robertson](https://github.com/kade-robertson)! - Adds an option for the `mobx/exhaustive-make-observable` eslint rule to configure whether fields are annotated with `true` or `false` with the autofixer.
+
+    This option defaults to `true` if not present or an invalid value is received to maintain existing behavior.
+
+## 0.0.9
+
+### Patch Changes
+
+-   [`e63c2df0`](https://github.com/mobxjs/mobx/commit/e63c2df0ef166868675bce21892cd686a46db953) [#3443](https://github.com/mobxjs/mobx/pull/3443) Thanks [@urugator](https://github.com/urugator)! - changeset for PR #3423: deprecate no-anonymous-observer
+
 ## 0.0.8
 
 ### Patch Changes

package/README.md

@@ -35,10 +35,22 @@ module.exports = {
 ### mobx/exhaustive-make-observable
 
 Makes sure that `makeObservable` annotates all fields defined on class or object literal.<br>
-**Autofix** adds `field: true` for each missing field.<br>
 To exclude a field, annotate it using `field: false`.<br>
 Does not support fields introduced by constructor (`this.foo = 5`).<br>
-Does not warn about annotated non-existing fields (there is a runtime check, but the autofix removing the field could be handy...).
+Does not warn about annotated non-existing fields (there is a runtime check, but the autofix removing the field could be handy...).<br>
+**Autofix** adds `field: true` for each missing field by default. You can change this behaviour by specifying options in your eslint config:
+
+```json
+{
+    "rules": {
+        "mobx/exhaustive-make-observable": ["error", { "autofixAnnotation": false }]
+    }
+}
+```
+
+This is a boolean value that controls if the field is annotated with `true` or `false`.
+If you are migrating an existing project using `makeObservable` and do not want this rule to override
+your current usage (even if it may be wrong), you should run the autofix with the annotation set to `false` to maintain existing behaviour: `eslint --no-eslintrc --fix --rule='mobx/exhaustive-make-observable: [2, { "autofixAnnotation": false }]' .`
 
 ### mobx/missing-make-observable
 
@@ -82,9 +94,26 @@ It's a bit opinionated and can lead to a lot of false positives depending on you
 ]
 ```
 
-### mobx/no-anonymous-observer
+### mobx/no-anonymous-observer (deprecated)
+
+_Deprecated in favor of [react/display-name](https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/display-name.md) + [componentWrapperFunctions](https://github.com/jsx-eslint/eslint-plugin-react). Example of **.eslintrc**:_
+
+```
+{
+  "rules": {
+    "react/display-name": "warn"
+  },
+  "settings": {
+    "componentWrapperFunctions": [
+      "observer"
+    ]
+  }
+}
+```
+
+---
 
 Forbids anonymous functions or classes as `observer` components.
 Improves debugging experience and [avoids problem with inability to customize `displayName`](https://github.com/mobxjs/mobx/issues/2721).
-Plays nice with `eslint-plugin-react-hooks` and `mobx/missing-observer` as both of these don't not recognize anonymous function as component.
+Plays nice with `eslint-plugin-react-hooks` and `mobx/missing-observer` as both of these don't recognize anonymous function as component.
 **Autofix** infers the name from variable if possible.

package/dist/index.js

@@ -1,55 +1,47 @@
 'use strict';
 
+function _iterableToArrayLimit(arr, i) {
+  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
+  if (null != _i) {
+    var _s,
+      _e,
+      _x,
+      _r,
+      _arr = [],
+      _n = !0,
+      _d = !1;
+    try {
+      if (_x = (_i = _i.call(arr)).next, 0 === i) {
+        if (Object(_i) !== _i) return;
+        _n = !1;
+      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+}
 function _slicedToArray(arr, i) {
   return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
 }
-
 function _toConsumableArray(arr) {
   return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
 }
-
 function _arrayWithoutHoles(arr) {
   if (Array.isArray(arr)) return _arrayLikeToArray(arr);
 }
-
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
-
 function _iterableToArray(iter) {
   if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-
-function _iterableToArrayLimit(arr, i) {
-  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-
-  if (_i == null) return;
-  var _arr = [];
-  var _n = true;
-  var _d = false;
-
-  var _s, _e;
-
-  try {
-    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
-      _arr.push(_s.value);
-
-      if (i && _arr.length === i) break;
-    }
-  } catch (err) {
-    _d = true;
-    _e = err;
-  } finally {
-    try {
-      if (!_n && _i["return"] != null) _i["return"]();
-    } finally {
-      if (_d) throw _e;
-    }
-  }
-
-  return _arr;
-}
-
 function _unsupportedIterableToArray(o, minLen) {
   if (!o) return;
   if (typeof o === "string") return _arrayLikeToArray(o, minLen);
@@ -58,28 +50,21 @@ function _unsupportedIterableToArray(o, minLen) {
   if (n === "Map" || n === "Set") return Array.from(o);
   if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
 }
-
 function _arrayLikeToArray(arr, len) {
   if (len == null || len > arr.length) len = arr.length;
-
   for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-
   return arr2;
 }
-
 function _nonIterableSpread() {
   throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-
 function _nonIterableRest() {
   throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 
 var mobxDecorators = new Set(['observable', 'computed', 'action', 'flow', 'override']);
-
 function isMobxDecorator$2(decorator) {
   var _decorator$expression, _decorator$expression2;
-
   return mobxDecorators.has(decorator.expression.name) // @foo
   || mobxDecorators.has((_decorator$expression = decorator.expression.callee) === null || _decorator$expression === void 0 ? void 0 : _decorator$expression.name) // @foo()
   || mobxDecorators.has((_decorator$expression2 = decorator.expression.object) === null || _decorator$expression2 === void 0 ? void 0 : _decorator$expression2.name); // @foo.bar
@@ -91,67 +76,61 @@ function findAncestor$3(node, match) {
   if (match(parent)) return parent;
   return findAncestor$3(parent, match);
 }
-
 var utils = {
   findAncestor: findAncestor$3,
   isMobxDecorator: isMobxDecorator$2
 };
 
 var findAncestor$2 = utils.findAncestor,
-    isMobxDecorator$1 = utils.isMobxDecorator; // TODO support this.foo = 5; in constructor
-// TODO? report on field as well
+  isMobxDecorator$1 = utils.isMobxDecorator;
 
+// TODO support this.foo = 5; in constructor
+// TODO? report on field as well
 function create$4(context) {
+  var _context$options$0$au, _context$options$;
   var sourceCode = context.getSourceCode();
-
+  var autofixAnnotation = (_context$options$0$au = (_context$options$ = context.options[0]) === null || _context$options$ === void 0 ? void 0 : _context$options$.autofixAnnotation) !== null && _context$options$0$au !== void 0 ? _context$options$0$au : true;
   function fieldToKey(field) {
     // TODO cache on field?
     var key = sourceCode.getText(field.key);
     return field.computed ? "[".concat(key, "]") : key;
   }
-
   return {
     'CallExpression[callee.name="makeObservable"]': function CallExpressionCalleeNameMakeObservable(makeObservable) {
       // Only interested about makeObservable(this, ...) in constructor or makeObservable({}, ...)
-      // ClassDeclaration 
+      // ClassDeclaration
       //   ClassBody
       //     MethodDefinition[kind="constructor"]
       //       FunctionExpression
       //         BlockStatement
       //           ExpressionStatement
-      //             CallExpression[callee.name="makeObservable"]        
+      //             CallExpression[callee.name="makeObservable"]
       var _makeObservable$argum = _slicedToArray(makeObservable.arguments, 2),
-          firstArg = _makeObservable$argum[0],
-          secondArg = _makeObservable$argum[1];
-
+        firstArg = _makeObservable$argum[0],
+        secondArg = _makeObservable$argum[1];
       if (!firstArg) return;
       var members;
-
-      if (firstArg.type === 'ThisExpression') {
+      if (firstArg.type === "ThisExpression") {
         var _closestFunction$pare;
-
         var closestFunction = findAncestor$2(makeObservable, function (node) {
-          return node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration';
+          return node.type === "FunctionExpression" || node.type === "FunctionDeclaration";
         });
-        if ((closestFunction === null || closestFunction === void 0 ? void 0 : (_closestFunction$pare = closestFunction.parent) === null || _closestFunction$pare === void 0 ? void 0 : _closestFunction$pare.kind) !== 'constructor') return;
+        if ((closestFunction === null || closestFunction === void 0 ? void 0 : (_closestFunction$pare = closestFunction.parent) === null || _closestFunction$pare === void 0 ? void 0 : _closestFunction$pare.kind) !== "constructor") return;
         members = closestFunction.parent.parent.parent.body.body;
-      } else if (firstArg.type === 'ObjectExpression') {
+      } else if (firstArg.type === "ObjectExpression") {
         members = firstArg.properties;
       } else {
         return;
       }
-
       var annotationProps = (secondArg === null || secondArg === void 0 ? void 0 : secondArg.properties) || [];
       var nonAnnotatedMembers = [];
       var hasAnyDecorator = false;
       members.forEach(function (member) {
         var _member$decorators;
-
         if (member["static"]) return;
-        if (member.kind === "constructor") return; //if (member.type !== 'MethodDefinition' && member.type !== 'ClassProperty') return;                    
-
+        if (member.kind === "constructor") return;
+        //if (member.type !== 'MethodDefinition' && member.type !== 'ClassProperty') return;
         hasAnyDecorator = hasAnyDecorator || ((_member$decorators = member.decorators) === null || _member$decorators === void 0 ? void 0 : _member$decorators.some(isMobxDecorator$1)) || false;
-
         if (!annotationProps.some(function (prop) {
           return fieldToKey(prop) === fieldToKey(member);
         })) {
@@ -162,46 +141,42 @@ function create$4(context) {
       /*
       // With decorators, second arg must be null/undefined or not provided
       if (hasAnyDecorator && secondArg && secondArg.name !== "undefined" && secondArg.value !== null) {
-        context.report({
-          node: makeObservable,
-          message: 'When using decorators, second arg must be `null`, `undefined` or not provided.',
-        })
+      context.report({
+      node: makeObservable,
+      message: 'When using decorators, second arg must be `null`, `undefined` or not provided.',
+      })
       }
       // Without decorators, in constructor, second arg must be object literal
       if (!hasAnyDecorator && firstArg.type === 'ThisExpression' && (!secondArg || secondArg.type !== 'ObjectExpression')) {
-        context.report({
-          node: makeObservable,
-          message: 'Second argument must be object in form of `{ key: annotation }`.',
-        })
+      context.report({
+      node: makeObservable,
+      message: 'Second argument must be object in form of `{ key: annotation }`.',
+      })
       }
       */
 
       if (!hasAnyDecorator && nonAnnotatedMembers.length) {
         // Set avoids reporting twice for setter+getter pair or actual duplicates
         var keys = _toConsumableArray(new Set(nonAnnotatedMembers.map(fieldToKey)));
-
         var keyList = keys.map(function (key) {
           return "`".concat(key, "`");
-        }).join(', ');
-
+        }).join(", ");
         var fix = function fix(fixer) {
           var annotationList = keys.map(function (key) {
-            return "".concat(key, ": true");
-          }).join(', ') + ',';
-
+            return "".concat(key, ": ").concat(autofixAnnotation);
+          }).join(", ") + ",";
           if (!secondArg) {
             return fixer.insertTextAfter(firstArg, ", { ".concat(annotationList, " }"));
-          } else if (secondArg.type !== 'ObjectExpression') {
+          } else if (secondArg.type !== "ObjectExpression") {
             return fixer.replaceText(secondArg, "{ ".concat(annotationList, " }"));
           } else {
             var openingBracket = sourceCode.getFirstToken(secondArg);
             return fixer.insertTextAfter(openingBracket, " ".concat(annotationList, " "));
           }
         };
-
         context.report({
           node: makeObservable,
-          messageId: 'missingAnnotation',
+          messageId: "missingAnnotation",
           data: {
             keyList: keyList
           },
@@ -211,46 +186,50 @@ function create$4(context) {
     }
   };
 }
-
 var exhaustiveMakeObservable$1 = {
   meta: {
-    type: 'suggestion',
-    fixable: 'code',
+    type: "suggestion",
+    fixable: "code",
+    schema: [{
+      type: "object",
+      properties: {
+        autofixAnnotation: {
+          type: "boolean"
+        }
+      },
+      additionalProperties: false
+    }],
     docs: {
-      description: 'enforce all fields being listen in `makeObservable`',
+      description: "enforce all fields being listen in `makeObservable`",
       recommended: true,
       suggestion: false
     },
     messages: {
-      'missingAnnotation': 'Missing annotation for {{ keyList }}. To exclude a field, use `false` as annotation.'
+      missingAnnotation: "Missing annotation for {{ keyList }}. To exclude a field, use `false` as annotation."
     }
   },
   create: create$4
 };
 
 var findAncestor$1 = utils.findAncestor;
-
 function create$3(context) {
   return {
     'CallExpression[callee.name=/(makeObservable|makeAutoObservable)/]': function CallExpressionCalleeNameMakeObservableMakeAutoObservable(makeObservable) {
       var _closestFunction$pare;
-
       // Only iterested about makeObservable(this, ...) inside constructor and not inside nested bindable function
       var _makeObservable$argum = _slicedToArray(makeObservable.arguments, 1),
-          firstArg = _makeObservable$argum[0];
-
+        firstArg = _makeObservable$argum[0];
       if (!firstArg) return;
-      if (firstArg.type !== 'ThisExpression') return; //     MethodDefinition[key.name="constructor"][kind="constructor"]
+      if (firstArg.type !== 'ThisExpression') return;
+      //     MethodDefinition[key.name="constructor"][kind="constructor"]
       //       FunctionExpression
       //         BlockStatement
       //           ExpressionStatement
       //             CallExpression[callee.name="makeObservable"]
-
       var closestFunction = findAncestor$1(makeObservable, function (node) {
         return node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration';
       });
       if ((closestFunction === null || closestFunction === void 0 ? void 0 : (_closestFunction$pare = closestFunction.parent) === null || _closestFunction$pare === void 0 ? void 0 : _closestFunction$pare.kind) !== 'constructor') return;
-
       if (makeObservable.parent.parent.parent !== closestFunction) {
         context.report({
           node: makeObservable,
@@ -263,7 +242,6 @@ function create$3(context) {
     }
   };
 }
-
 var unconditionalMakeObservable$1 = {
   meta: {
     type: 'problem',
@@ -279,38 +257,32 @@ var unconditionalMakeObservable$1 = {
 };
 
 var findAncestor = utils.findAncestor,
-    isMobxDecorator = utils.isMobxDecorator;
-
+  isMobxDecorator = utils.isMobxDecorator;
 function create$2(context) {
   var sourceCode = context.getSourceCode();
   return {
     'Decorator': function Decorator(decorator) {
       var _clazz$body$body$find, _constructor$value$bo, _constructor$value$bo2;
-
       if (!isMobxDecorator(decorator)) return;
       var clazz = findAncestor(decorator, function (node) {
         return node.type === 'ClassDeclaration' || node.type === 'ClassExpression';
       });
-      if (!clazz) return; // ClassDeclaration > ClassBody > []
-
+      if (!clazz) return;
+      // ClassDeclaration > ClassBody > []
       var constructor = (_clazz$body$body$find = clazz.body.body.find(function (node) {
         return node.kind === 'constructor' && node.value.type === 'FunctionExpression';
       })) !== null && _clazz$body$body$find !== void 0 ? _clazz$body$body$find : clazz.body.body.find(function (node) {
         return node.kind === 'constructor';
-      }); // MethodDefinition > FunctionExpression > BlockStatement > []
-
+      });
+      // MethodDefinition > FunctionExpression > BlockStatement > []
       var isMakeObservable = function isMakeObservable(node) {
         var _node$expression, _node$expression$call, _node$expression2, _node$expression2$arg;
-
         return ((_node$expression = node.expression) === null || _node$expression === void 0 ? void 0 : (_node$expression$call = _node$expression.callee) === null || _node$expression$call === void 0 ? void 0 : _node$expression$call.name) === 'makeObservable' && ((_node$expression2 = node.expression) === null || _node$expression2 === void 0 ? void 0 : (_node$expression2$arg = _node$expression2.arguments[0]) === null || _node$expression2$arg === void 0 ? void 0 : _node$expression2$arg.type) === 'ThisExpression';
       };
-
       var makeObservable = constructor === null || constructor === void 0 ? void 0 : (_constructor$value$bo = constructor.value.body) === null || _constructor$value$bo === void 0 ? void 0 : (_constructor$value$bo2 = _constructor$value$bo.body.find(isMakeObservable)) === null || _constructor$value$bo2 === void 0 ? void 0 : _constructor$value$bo2.expression;
-
       if (makeObservable) {
         // make sure second arg is nullish
         var secondArg = makeObservable.arguments[1];
-
         if (secondArg && secondArg.value !== null && secondArg.name !== 'undefined') {
           context.report({
             node: makeObservable,
@@ -326,7 +298,6 @@ function create$2(context) {
           } else if (constructor) {
             // constructor() {}
             var _closingBracket = sourceCode.getLastToken(constructor.value.body);
-
             return fixer.insertTextBefore(_closingBracket, ';makeObservable(this);');
           } else {
             // class C {}
@@ -334,7 +305,6 @@ function create$2(context) {
             return fixer.insertTextAfter(openingBracket, '\nconstructor() { makeObservable(this); }');
           }
         };
-
         context.report({
           node: clazz,
           messageId: 'missingMakeObservable',
@@ -344,7 +314,6 @@ function create$2(context) {
     }
   };
 }
-
 var missingMakeObservable$1 = {
   meta: {
     type: 'problem',
@@ -367,15 +336,13 @@ function create$1(context) {
   return {
     'FunctionDeclaration,FunctionExpression,ArrowFunctionExpression,ClassDeclaration,ClassExpression': function FunctionDeclarationFunctionExpressionArrowFunctionExpressionClassDeclarationClassExpression(cmp) {
       var _cmp$id, _cmp$parent;
-
       // Already has observer
       if (cmp.parent && cmp.parent.type === 'CallExpression' && cmp.parent.callee.name === 'observer') return;
-      var name = (_cmp$id = cmp.id) === null || _cmp$id === void 0 ? void 0 : _cmp$id.name; // If anonymous try to infer name from variable declaration      
-
+      var name = (_cmp$id = cmp.id) === null || _cmp$id === void 0 ? void 0 : _cmp$id.name;
+      // If anonymous try to infer name from variable declaration      
       if (!name && ((_cmp$parent = cmp.parent) === null || _cmp$parent === void 0 ? void 0 : _cmp$parent.type) === 'VariableDeclarator') {
         name = cmp.parent.id.name;
       }
-
       if (cmp.type.startsWith('Class')) {
         // Must extend Component or React.Component
         var superClass = cmp.superClass;
@@ -384,15 +351,12 @@ function create$1(context) {
         if (superClassText !== 'Component' && superClassText !== 'React.Component') return;
       } else {
         var _name;
-
         // Name must start with uppercase letter
         if (!((_name = name) !== null && _name !== void 0 && _name.charAt(0).match(/^[A-Z]$/))) return;
       }
-
       var fix = function fix(fixer) {
         return [fixer.insertTextBefore(sourceCode.getFirstToken(cmp), (name && cmp.type.endsWith('Declaration') ? "const ".concat(name, " = ") : '') + 'observer('), fixer.insertTextAfter(sourceCode.getLastToken(cmp), ')')];
       };
-
       context.report({
         node: cmp,
         messageId: 'missingObserver',
@@ -404,7 +368,6 @@ function create$1(context) {
     }
   };
 }
-
 var missingObserver$1 = {
   meta: {
     type: 'problem',
@@ -425,40 +388,31 @@ function create(context) {
   return {
     'CallExpression[callee.name="observer"]': function CallExpressionCalleeNameObserver(observer) {
       var _cmp$id;
-
       var cmp = observer.arguments[0];
       if (!cmp) return;
       if (cmp !== null && cmp !== void 0 && (_cmp$id = cmp.id) !== null && _cmp$id !== void 0 && _cmp$id.name) return;
-
       var fix = function fix(fixer) {
         var _observer$parent;
-
         // Use name from variable for autofix
         var name = ((_observer$parent = observer.parent) === null || _observer$parent === void 0 ? void 0 : _observer$parent.type) === "VariableDeclarator" ? observer.parent.id.name : undefined;
         if (!name) return;
-
         if (cmp.type === "ArrowFunctionExpression") {
           var arrowToken = sourceCode.getTokenBefore(cmp.body);
           var fixes = [fixer.replaceText(arrowToken, ""), fixer.insertTextBefore(cmp, "function ".concat(name))];
-
           if (cmp.body.type !== "BlockStatement") {
             fixes.push(fixer.insertTextBefore(cmp.body, "{ return "), fixer.insertTextAfter(cmp.body, " }"));
           }
-
           return fixes;
         }
-
         if (cmp.type === "FunctionExpression") {
           var functionToken = sourceCode.getFirstToken(cmp);
           return fixer.replaceText(functionToken, "function ".concat(name));
         }
-
         if (cmp.type === "ClassExpression") {
           var classToken = sourceCode.getFirstToken(cmp);
           return fixer.replaceText(classToken, "class ".concat(name));
         }
       };
-
       context.report({
         node: cmp,
         messageId: "observerComponentMustHaveName",
@@ -467,7 +421,6 @@ function create(context) {
     }
   };
 }
-
 var noAnonymousObserver$1 = {
   meta: {
     type: "problem",
@@ -496,8 +449,7 @@ var src = {
         "mobx/exhaustive-make-observable": "warn",
         "mobx/unconditional-make-observable": "error",
         "mobx/missing-make-observable": "error",
-        "mobx/missing-observer": "warn",
-        "mobx/no-anonymous-observer": "warn"
+        "mobx/missing-observer": "warn"
       }
     }
   },

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-mobx",
-    "version": "0.0.8",
+    "version": "0.0.10",
     "description": "ESLint rules for MobX",
     "main": "dist/index.js",
     "repository": {
@@ -28,8 +28,8 @@
         "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
     },
     "devDependencies": {
-        "@typescript-eslint/eslint-plugin": "^4.29.3",
-        "@typescript-eslint/parser": "^4.0.0",
+        "@typescript-eslint/eslint-plugin": "^5.0.0",
+        "@typescript-eslint/parser": "^5.0.0",
         "eslint": "^7.0.0",
         "@babel/core": "^7.16.0",
         "@babel/preset-env": "^7.16.4",
@@ -47,6 +47,6 @@
     "scripts": {
         "test": "jest",
         "build": "yarn rollup --config",
-        "prepublish": "yarn build"
+        "prepublishOnly": "yarn build"
     }
 }

package/src/exhaustive-make-observable.js

@@ -1,55 +1,62 @@
-'use strict';
+"use strict"
 
-const { findAncestor, isMobxDecorator } = require('./utils.js');
+const { findAncestor, isMobxDecorator } = require("./utils.js")
 
 // TODO support this.foo = 5; in constructor
 // TODO? report on field as well
 function create(context) {
-  const sourceCode = context.getSourceCode();
+    const sourceCode = context.getSourceCode()
+    const autofixAnnotation = context.options[0]?.autofixAnnotation ?? true
 
-  function fieldToKey(field) {
-    // TODO cache on field?
-    const key = sourceCode.getText(field.key);
-    return field.computed ? `[${key}]` : key;
-  }
+    function fieldToKey(field) {
+        // TODO cache on field?
+        const key = sourceCode.getText(field.key)
+        return field.computed ? `[${key}]` : key
+    }
 
-  return {
-    'CallExpression[callee.name="makeObservable"]': makeObservable => {
-      // Only interested about makeObservable(this, ...) in constructor or makeObservable({}, ...)
-      // ClassDeclaration 
-      //   ClassBody
-      //     MethodDefinition[kind="constructor"]
-      //       FunctionExpression
-      //         BlockStatement
-      //           ExpressionStatement
-      //             CallExpression[callee.name="makeObservable"]        
-      const [firstArg, secondArg] = makeObservable.arguments;
-      if (!firstArg) return;
-      let members;
-      if (firstArg.type === 'ThisExpression') {
-        const closestFunction = findAncestor(makeObservable, node => node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration')
-        if (closestFunction?.parent?.kind !== 'constructor') return;
-        members = closestFunction.parent.parent.parent.body.body;
-      } else if (firstArg.type === 'ObjectExpression') {
-        members = firstArg.properties;
-      } else {
-        return;
-      }
+    return {
+        'CallExpression[callee.name="makeObservable"]': makeObservable => {
+            // Only interested about makeObservable(this, ...) in constructor or makeObservable({}, ...)
+            // ClassDeclaration
+            //   ClassBody
+            //     MethodDefinition[kind="constructor"]
+            //       FunctionExpression
+            //         BlockStatement
+            //           ExpressionStatement
+            //             CallExpression[callee.name="makeObservable"]
+            const [firstArg, secondArg] = makeObservable.arguments
+            if (!firstArg) return
+            let members
+            if (firstArg.type === "ThisExpression") {
+                const closestFunction = findAncestor(
+                    makeObservable,
+                    node =>
+                        node.type === "FunctionExpression" || node.type === "FunctionDeclaration"
+                )
+                if (closestFunction?.parent?.kind !== "constructor") return
+                members = closestFunction.parent.parent.parent.body.body
+            } else if (firstArg.type === "ObjectExpression") {
+                members = firstArg.properties
+            } else {
+                return
+            }
 
-      const annotationProps = secondArg?.properties || [];
-      const nonAnnotatedMembers = [];
-      let hasAnyDecorator = false;
+            const annotationProps = secondArg?.properties || []
+            const nonAnnotatedMembers = []
+            let hasAnyDecorator = false
 
-      members.forEach(member => {
-        if (member.static) return;
-        if (member.kind === "constructor") return;
-        //if (member.type !== 'MethodDefinition' && member.type !== 'ClassProperty') return;                    
-        hasAnyDecorator = hasAnyDecorator || member.decorators?.some(isMobxDecorator) || false;
-        if (!annotationProps.some(prop => fieldToKey(prop) === fieldToKey(member))) { // TODO optimize?
-          nonAnnotatedMembers.push(member);
-        }
-      })
-      /*
+            members.forEach(member => {
+                if (member.static) return
+                if (member.kind === "constructor") return
+                //if (member.type !== 'MethodDefinition' && member.type !== 'ClassProperty') return;
+                hasAnyDecorator =
+                    hasAnyDecorator || member.decorators?.some(isMobxDecorator) || false
+                if (!annotationProps.some(prop => fieldToKey(prop) === fieldToKey(member))) {
+                    // TODO optimize?
+                    nonAnnotatedMembers.push(member)
+                }
+            })
+            /*
       // With decorators, second arg must be null/undefined or not provided
       if (hasAnyDecorator && secondArg && secondArg.name !== "undefined" && secondArg.value !== null) {
         context.report({
@@ -66,46 +73,59 @@ function create(context) {
       }
       */
 
-      if (!hasAnyDecorator && nonAnnotatedMembers.length) {
-        // Set avoids reporting twice for setter+getter pair or actual duplicates
-        const keys = [...new Set(nonAnnotatedMembers.map(fieldToKey))];
-        const keyList = keys.map(key => `\`${key}\``).join(', ');
+            if (!hasAnyDecorator && nonAnnotatedMembers.length) {
+                // Set avoids reporting twice for setter+getter pair or actual duplicates
+                const keys = [...new Set(nonAnnotatedMembers.map(fieldToKey))]
+                const keyList = keys.map(key => `\`${key}\``).join(", ")
 
-        const fix = fixer => {
-          const annotationList = keys.map(key => `${key}: true`).join(', ') + ',';
-          if (!secondArg) {
-            return fixer.insertTextAfter(firstArg, `, { ${annotationList} }`);
-          } else if (secondArg.type !== 'ObjectExpression') {
-            return fixer.replaceText(secondArg, `{ ${annotationList} }`);
-          } else {
-            const openingBracket = sourceCode.getFirstToken(secondArg)
-            return fixer.insertTextAfter(openingBracket, ` ${annotationList} `);
-          }
-        };
+                const fix = fixer => {
+                    const annotationList =
+                        keys.map(key => `${key}: ${autofixAnnotation}`).join(", ") + ","
+                    if (!secondArg) {
+                        return fixer.insertTextAfter(firstArg, `, { ${annotationList} }`)
+                    } else if (secondArg.type !== "ObjectExpression") {
+                        return fixer.replaceText(secondArg, `{ ${annotationList} }`)
+                    } else {
+                        const openingBracket = sourceCode.getFirstToken(secondArg)
+                        return fixer.insertTextAfter(openingBracket, ` ${annotationList} `)
+                    }
+                }
 
-        context.report({
-          node: makeObservable,
-          messageId: 'missingAnnotation',
-          data: { keyList },
-          fix,
-        })
-      }
-    },
-  };
+                context.report({
+                    node: makeObservable,
+                    messageId: "missingAnnotation",
+                    data: { keyList },
+                    fix
+                })
+            }
+        }
+    }
 }
 
 module.exports = {
-  meta: {
-    type: 'suggestion',
-    fixable: 'code',
-    docs: {
-      description: 'enforce all fields being listen in `makeObservable`',
-      recommended: true,
-      suggestion: false,
-    },
-    messages: {
-      'missingAnnotation': 'Missing annotation for {{ keyList }}. To exclude a field, use `false` as annotation.',
+    meta: {
+        type: "suggestion",
+        fixable: "code",
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    autofixAnnotation: {
+                        type: "boolean"
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+        docs: {
+            description: "enforce all fields being listen in `makeObservable`",
+            recommended: true,
+            suggestion: false
+        },
+        messages: {
+            missingAnnotation:
+                "Missing annotation for {{ keyList }}. To exclude a field, use `false` as annotation."
+        }
     },
-  },
-  create,
-};
+    create
+}

package/src/index.js

@@ -14,8 +14,7 @@ module.exports = {
                 "mobx/exhaustive-make-observable": "warn",
                 "mobx/unconditional-make-observable": "error",
                 "mobx/missing-make-observable": "error",
-                "mobx/missing-observer": "warn",
-                "mobx/no-anonymous-observer": "warn"
+                "mobx/missing-observer": "warn"
             }
         }
     },