@tianjos/eslint-plugin-elegant 0.2.0 → 0.3.0

package/README.md

@@ -81,6 +81,8 @@ The `recommended` config enables every custom rule plus the native
 | `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
@@ -114,6 +116,18 @@ The `recommended` config enables every custom rule plus the native
 - **`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

@@ -28,6 +28,14 @@ declare const rules: {
     '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

@@ -7,8 +7,10 @@ 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 = {
@@ -20,6 +22,8 @@ const rules = {
     '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 },
@@ -38,6 +42,8 @@ plugin.configs.recommended = {
         '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-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.2.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",