eslint-plugin-mobx 0.0.14 → 0.1.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # eslint-plugin-mobx
 
+## 0.1.0
+
+### Minor Changes
+
+-   [`f7af259df425280aebeb0ccdb13350ba6d24270a`](https://github.com/mobxjs/mobx/commit/f7af259df425280aebeb0ccdb13350ba6d24270a) [#4699](https://github.com/mobxjs/mobx/pull/4699) Thanks [@rakleed](https://github.com/rakleed)! - Add TypeScript types for `configs.recommended` and `flatConfigs.recommended`, so they're typed when used from a TypeScript `eslint.config.ts`.
+
 ## 0.0.14
 
 ### Patch Changes

package/dist/exhaustive-make-observable.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from "eslint";
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/exhaustive-make-observable.js

@@ -0,0 +1,154 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("./utils");
+// TODO support this.foo = 5; in constructor
+// TODO? report on field as well
+function create(context) {
+    var _a, _b, _c;
+    var sourceCode = (_a = context.sourceCode) !== null && _a !== void 0 ? _a : context.getSourceCode();
+    var autofixAnnotation = (_c = (_b = context.options[0]) === null || _b === void 0 ? void 0 : _b.autofixAnnotation) !== null && _c !== void 0 ? _c : 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 (makeObservable) {
+            var _a;
+            // Only interested about makeObservable(this, ...) in constructor or makeObservable({}, ...)
+            // ClassDeclaration
+            //   ClassBody
+            //     MethodDefinition[kind="constructor"]
+            //       FunctionExpression
+            //         BlockStatement
+            //           ExpressionStatement
+            //             CallExpression[callee.name="makeObservable"]
+            var _b = __read(makeObservable.arguments, 2), firstArg = _b[0], secondArg = _b[1];
+            if (!firstArg)
+                return;
+            var members;
+            if (firstArg.type === "ThisExpression") {
+                var closestFunction = (0, utils_1.findAncestor)(makeObservable, function (node) {
+                    return node.type === "FunctionExpression" || node.type === "FunctionDeclaration";
+                });
+                if (((_a = closestFunction === null || closestFunction === void 0 ? void 0 : closestFunction.parent) === null || _a === void 0 ? void 0 : _a.kind) !== "constructor")
+                    return;
+                members = closestFunction.parent.parent.parent.body.body;
+            }
+            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 _a;
+                if (member.static)
+                    return;
+                if (member.kind === "constructor")
+                    return;
+                //if (member.type !== 'MethodDefinition' && member.type !== 'ClassProperty') return;
+                hasAnyDecorator =
+                    hasAnyDecorator || ((_a = member.decorators) === null || _a === void 0 ? void 0 : _a.some(utils_1.isMobxDecorator)) || false;
+                if (!annotationProps.some(function (prop) { return 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({
+          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 }`.',
+        })
+      }
+      */
+            if (!hasAnyDecorator && nonAnnotatedMembers.length) {
+                // Set avoids reporting twice for setter+getter pair or actual duplicates
+                var keys_1 = __spreadArray([], __read(new Set(nonAnnotatedMembers.map(fieldToKey))), false);
+                var keyList = keys_1.map(function (key) { return "`".concat(key, "`"); }).join(", ");
+                var fix = function (fixer) {
+                    var annotationList = keys_1.map(function (key) { return "".concat(key, ": ").concat(autofixAnnotation); }).join(", ") + ",";
+                    if (!secondArg) {
+                        return fixer.insertTextAfter(firstArg, ", { ".concat(annotationList, " }"));
+                    }
+                    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",
+                    data: { keyList: keyList },
+                    fix: fix
+                });
+            }
+        }
+    };
+}
+var rule = {
+    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
+        },
+        messages: {
+            missingAnnotation: "Missing annotation for {{ keyList }}. To exclude a field, use `false` as annotation."
+        }
+    },
+    create: create
+};
+exports.default = rule;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import type { ESLint, Linter } from "eslint";
+declare const pluginMobx: ESLint.Plugin;
+declare const plugin: typeof pluginMobx & {
+    configs: {
+        recommended: Linter.LegacyConfig;
+    };
+    flatConfigs: {
+        recommended: Linter.Config;
+    };
+};
+export = plugin;