@tianjos/eslint-plugin-elegant 0.1.0 → 0.3.0

package/README.md

@@ -78,6 +78,11 @@ The `recommended` config enables every custom rule plus the native
 | `elegant/no-type-assertion`            | custom | `value as T` and `<T>value` assertions (`as const` is allowed)                  | `error`       |
 | `elegant/no-null-return`               | custom | `return null` statements                                                        | `error`       |
 | `elegant/no-public-mutable-props`      | custom | Public, non-`readonly` class properties and public constructor parameter props  | `error`       |
+| `elegant/no-logic-in-constructor`      | custom | Any constructor code beyond `this.field = value` stores and a `super(...)` call  | `error`       |
+| `elegant/no-getters-setters`           | custom | `get`/`set` accessors (and `getX`/`setX` methods with `{ methods: true }`)        | `error`       |
+| `elegant/no-instanceof`                | custom | Use of the `instanceof` operator                                                | `error`       |
+| `elegant/no-static-members`            | custom | Static methods, properties, accessors, and blocks (`allowReadonly` to permit constants) | `error` |
+| `elegant/no-null`                      | custom | The `null` literal as a value (type annotations and direct `return null` excepted) | `error`     |
 | `max-params`                           | native | Functions declaring more than `max` parameters                                  | `warn` (max 3) |
 
 ### Rule details
@@ -96,6 +101,33 @@ The `recommended` config enables every custom rule plus the native
 - **`no-public-mutable-props`** — public state should be `readonly` so callers
   cannot break an aggregate's invariants. `private`/`protected` members and
   `readonly` members are allowed.
+- **`no-logic-in-constructor`** — a constructor should only wire arguments to
+  fields. Validation, transformation, and I/O belong in a static factory or a
+  method, keeping object construction predictable. Parameter properties
+  (`constructor(private readonly x: T)`) and a leading `super(...)` are allowed;
+  computed right-hand sides (`this.x = x * 2`, `this.items = items.slice()`) and
+  any non-assignment statement are flagged.
+- **`no-getters-setters`** — getters and setters turn objects into data bags;
+  prefer methods that expose behavior. Native `get`/`set` accessors (and
+  `accessor` fields) are always flagged. The opt-in `{ methods: true }` option
+  also flags conventional `getX`/`setX` methods — useful for strict Elegant
+  Objects style, but noisy around repositories and framework hooks, so it stays
+  off in `recommended`.
+- **`no-instanceof`** — `instanceof` is type discrimination that belongs inside a
+  polymorphic method on the object. Pairs with `no-type-assertion` to keep
+  type-based branching out of the codebase.
+- **`no-static-members`** — static state and behavior cannot be injected,
+  substituted, or mocked. Prefer instances (with dependency injection) and a
+  module-level `const` for shared values. The `{ allowReadonly: true }` option
+  permits `static readonly` constants. Note this also flags `static` factory
+  methods (`static create()`), which are common; relax per-file if your design
+  relies on them.
+- **`no-null`** — completes `no-null-return` by banning the `null` literal as a
+  value everywhere (`const x = null`, `x === null`, `fn(null)`), pushing absence
+  into explicit types or `undefined`. `null` in type positions (`string | null`)
+  and a direct `return null` (owned by `no-null-return`) are left alone. This is
+  strict and will flag idioms like `JSON.stringify(x, null, 2)` — relax it in the
+  files where you interoperate with null-based APIs.
 
 ## Configuration
 

package/dist/index.d.ts

@@ -17,6 +17,25 @@ declare const rules: {
     'no-public-mutable-props': TSESLint.RuleModule<"mutableProp", [], unknown, TSESLint.RuleListener> & {
         name: string;
     };
+    'no-logic-in-constructor': TSESLint.RuleModule<"statement" | "computation", [], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'no-getters-setters': TSESLint.RuleModule<"accessor" | "namedAccessor", [{
+        methods: boolean;
+    }], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'no-instanceof': TSESLint.RuleModule<"noInstanceof", [], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'no-static-members': TSESLint.RuleModule<"staticMember", [{
+        allowReadonly: boolean;
+    }], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'no-null': TSESLint.RuleModule<"noNull", [], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
 };
 type Plugin = {
     meta: {

package/dist/index.js

@@ -4,8 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 const max_class_methods_1 = __importDefault(require("./rules/max-class-methods"));
 const no_boolean_param_1 = __importDefault(require("./rules/no-boolean-param"));
+const no_getters_setters_1 = __importDefault(require("./rules/no-getters-setters"));
+const no_instanceof_1 = __importDefault(require("./rules/no-instanceof"));
+const no_logic_in_constructor_1 = __importDefault(require("./rules/no-logic-in-constructor"));
+const no_null_1 = __importDefault(require("./rules/no-null"));
 const no_null_return_1 = __importDefault(require("./rules/no-null-return"));
 const no_public_mutable_props_1 = __importDefault(require("./rules/no-public-mutable-props"));
+const no_static_members_1 = __importDefault(require("./rules/no-static-members"));
 const no_type_assertion_1 = __importDefault(require("./rules/no-type-assertion"));
 const { name, version } = require('../package.json');
 const rules = {
@@ -14,6 +19,11 @@ const rules = {
     'no-type-assertion': no_type_assertion_1.default,
     'no-null-return': no_null_return_1.default,
     'no-public-mutable-props': no_public_mutable_props_1.default,
+    'no-logic-in-constructor': no_logic_in_constructor_1.default,
+    'no-getters-setters': no_getters_setters_1.default,
+    'no-instanceof': no_instanceof_1.default,
+    'no-static-members': no_static_members_1.default,
+    'no-null': no_null_1.default,
 };
 const plugin = {
     meta: { name, version },
@@ -29,6 +39,11 @@ plugin.configs.recommended = {
         'elegant/no-type-assertion': 'error',
         'elegant/no-null-return': 'error',
         'elegant/no-public-mutable-props': 'error',
+        'elegant/no-logic-in-constructor': 'error',
+        'elegant/no-getters-setters': 'error',
+        'elegant/no-instanceof': 'error',
+        'elegant/no-static-members': 'error',
+        'elegant/no-null': 'error',
         'max-params': ['warn', { max: 3 }],
     },
 };

package/dist/rules/no-getters-setters.d.ts

@@ -0,0 +1,8 @@
+type Options = [{
+    methods: boolean;
+}];
+type MessageIds = 'accessor' | 'namedAccessor';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-getters-setters.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const NAMED_ACCESSOR = /^(get|set)[A-Z]/;
+exports.default = (0, createRule_1.createRule)({
+    name: 'no-getters-setters',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow getters and setters, which expose objects as data bags instead of behavior-rich abstractions.',
+        },
+        messages: {
+            accessor: 'Avoid `get`/`set` accessors. Expose behavior through intention-revealing methods, not property access.',
+            namedAccessor: "Method '{{name}}' reads like a getter/setter. Expose behavior, not state.",
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: { methods: { type: 'boolean' } },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ methods: false }],
+    create(context, [{ methods }]) {
+        const reportKey = (key) => {
+            context.report({ node: key, messageId: 'accessor' });
+        };
+        return {
+            'MethodDefinition[kind="get"], MethodDefinition[kind="set"]'(node) {
+                reportKey(node.key);
+            },
+            'TSAbstractMethodDefinition[kind="get"], TSAbstractMethodDefinition[kind="set"]'(node) {
+                reportKey(node.key);
+            },
+            AccessorProperty(node) {
+                reportKey(node.key);
+            },
+            TSAbstractAccessorProperty(node) {
+                reportKey(node.key);
+            },
+            'MethodDefinition[kind="method"]'(node) {
+                if (methods &&
+                    node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    NAMED_ACCESSOR.test(node.key.name)) {
+                    context.report({
+                        node: node.key,
+                        messageId: 'namedAccessor',
+                        data: { name: node.key.name },
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-instanceof.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInstanceof", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-instanceof.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRule_1 = require("../utils/createRule");
+exports.default = (0, createRule_1.createRule)({
+    name: 'no-instanceof',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow the `instanceof` operator. Type discrimination breaks polymorphism; let the object decide via a method instead.',
+        },
+        messages: {
+            noInstanceof: 'Avoid `instanceof`. Replace type discrimination with a polymorphic method on the object.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            'BinaryExpression[operator="instanceof"]'(node) {
+                context.report({ node, messageId: 'noInstanceof' });
+            },
+        };
+    },
+});

package/dist/rules/no-logic-in-constructor.d.ts

@@ -0,0 +1,5 @@
+type MessageIds = 'statement' | 'computation';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-logic-in-constructor.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const isThisMember = (node) => node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+    node.object.type === utils_1.AST_NODE_TYPES.ThisExpression;
+const isSuperCall = (node) => node.type === utils_1.AST_NODE_TYPES.CallExpression &&
+    node.callee.type === utils_1.AST_NODE_TYPES.Super;
+/** Strip assertions/non-null so `this.x = y as T` is judged by its inner value. */
+const unwrap = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+        node.type === utils_1.AST_NODE_TYPES.TSNonNullExpression ||
+        node.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+        return unwrap(node.expression);
+    }
+    return node;
+};
+/** A value the constructor merely *stores*, as opposed to one it *computes*. */
+const isPlainValue = (node) => {
+    const inner = unwrap(node);
+    switch (inner.type) {
+        case utils_1.AST_NODE_TYPES.Identifier:
+        case utils_1.AST_NODE_TYPES.Literal:
+        case utils_1.AST_NODE_TYPES.ThisExpression:
+        case utils_1.AST_NODE_TYPES.MemberExpression:
+            return true;
+        default:
+            return false;
+    }
+};
+exports.default = (0, createRule_1.createRule)({
+    name: 'no-logic-in-constructor',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow logic in constructors. A constructor may only assign its arguments to fields; computation belongs in a static factory or a method.',
+        },
+        messages: {
+            statement: 'Constructors must be code-free: only `this.field = value` assignments and a `super(...)` call are allowed here.',
+            computation: 'Constructor assignments must store a plain value, not compute one. Move the logic to a static factory or use a default parameter value.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const checkBody = (body) => {
+            for (const statement of body) {
+                if (statement.type !== utils_1.AST_NODE_TYPES.ExpressionStatement) {
+                    context.report({ node: statement, messageId: 'statement' });
+                    continue;
+                }
+                const { expression } = statement;
+                if (isSuperCall(expression)) {
+                    continue;
+                }
+                if (expression.type !== utils_1.AST_NODE_TYPES.AssignmentExpression ||
+                    expression.operator !== '=' ||
+                    !isThisMember(expression.left)) {
+                    context.report({ node: statement, messageId: 'statement' });
+                    continue;
+                }
+                if (!isPlainValue(expression.right)) {
+                    context.report({
+                        node: expression.right,
+                        messageId: 'computation',
+                    });
+                }
+            }
+        };
+        return {
+            'MethodDefinition[kind="constructor"]'(node) {
+                if (node.value.body) {
+                    checkBody(node.value.body.body);
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-null.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noNull", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-null.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.default = (0, createRule_1.createRule)({
+    name: 'no-null',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow the `null` literal as a value. Model absence with an explicit domain type, an Optional/Maybe, or by throwing. Null inside type annotations is allowed; direct `return null` is owned by `no-null-return`.',
+        },
+        messages: {
+            noNull: 'Avoid the null literal. Model absence explicitly instead of leaking null into the code.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            Literal(node) {
+                if (node.value !== null || node.raw !== 'null') {
+                    return;
+                }
+                // Direct `return null;` is the domain of `no-null-return`.
+                const { parent } = node;
+                if (parent.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                    parent.argument === node) {
+                    return;
+                }
+                context.report({ node, messageId: 'noNull' });
+            },
+        };
+    },
+});

package/dist/rules/no-static-members.d.ts

@@ -0,0 +1,7 @@
+type Options = [{
+    allowReadonly: boolean;
+}];
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"staticMember", Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-static-members.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRule_1 = require("../utils/createRule");
+exports.default = (0, createRule_1.createRule)({
+    name: 'no-static-members',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow static members. Static state and behavior cannot be injected, substituted, or mocked; prefer instances and a module-level value when you need a constant.',
+        },
+        messages: {
+            staticMember: 'Avoid static members. Use an injectable instance, or a module-level constant for shared values.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: { allowReadonly: { type: 'boolean' } },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ allowReadonly: false }],
+    create(context, [{ allowReadonly }]) {
+        const reportKey = (key) => {
+            context.report({ node: key, messageId: 'staticMember' });
+        };
+        return {
+            MethodDefinition(node) {
+                if (node.static) {
+                    reportKey(node.key);
+                }
+            },
+            PropertyDefinition(node) {
+                if (node.static && !(allowReadonly && node.readonly)) {
+                    reportKey(node.key);
+                }
+            },
+            AccessorProperty(node) {
+                if (node.static) {
+                    reportKey(node.key);
+                }
+            },
+            StaticBlock(node) {
+                context.report({ node, messageId: 'staticMember' });
+            },
+        };
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tianjos/eslint-plugin-elegant",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Opinionated ESLint rules for elegant, behavior-rich TypeScript: no flag arguments, no type assertions, no null returns, no public mutable state, and small focused classes.",
   "keywords": [
     "eslint",