zeiger-eslint-plugin 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Marek Honzal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+# zeiger-eslint-plugin
+
+ESLint plugin for [Zeiger](https://github.com/DNepovim/zeiger) - ensures proper usage of Zeiger hooks with dependency arrays.
+
+## Installation
+
+```bash
+npm install --save-dev zeiger-eslint-plugin
+# or
+pnpm add -D zeiger-eslint-plugin
+# or
+yarn add -D zeiger-eslint-plugin
+```
+
+## Usage
+
+### Flat Config (ESLint 9+)
+
+```js
+import zeigerPlugin from 'zeiger-eslint-plugin';
+
+export default [
+  {
+    plugins: {
+      zeiger: zeigerPlugin,
+    },
+    rules: {
+      ...zeigerPlugin.configs.recommended.rules,
+    },
+  },
+];
+```
+
+### Legacy Config (ESLint 8)
+
+```json
+{
+  "plugins": ["zeiger"],
+  "extends": ["plugin:zeiger/recommended"]
+}
+```
+
+## Rules
+
+### `zeiger/zeiger-deps`
+
+Ensures that Zeiger hooks created with `createCollectionPointer` or `createCollectionItemPointer` have:
+
+1. Non-empty dependency arrays
+2. All listed dependencies are actually used in the code
+
+#### Examples
+
+**❌ Empty dependency array:**
+
+```tsx
+const useUsersPointer = createCollectionPointer(useStore, 'users');
+const users = useUsersPointer([]); // Error: dependency array must not be empty
+```
+
+**❌ Unused dependency:**
+
+```tsx
+const useUserPointer = createCollectionItemPointer(useStore, 'users', 'id');
+const user = useUserPointer('1', ['firstName', 'surname', 'email']);
+
+// Only firstName and email are used
+return (
+  <div>
+    {user?.firstName} - {user?.email}
+  </div>
+);
+// Error: Property 'surname' is listed in dependency array but not used
+```
+
+**✅ Correct usage:**
+
+```tsx
+const useUserPointer = createCollectionItemPointer(useStore, 'users', 'id');
+const user = useUserPointer('1', ['firstName', 'email']);
+
+return (
+  <div>
+    {user?.firstName} - {user?.email}
+  </div>
+);
+```
+
+## Why This Plugin?
+
+Zeiger hooks use dependency arrays to specify which properties to subscribe to. This plugin helps you:
+
+- **Avoid unnecessary subscriptions** - Catch unused properties in dependency arrays
+- **Prevent empty arrays** - Ensure you're always subscribing to at least one property
+- **Maintain code quality** - Keep your Zeiger hooks clean and efficient
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,193 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>src
+});
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure zeiger hook dependency arrays are not empty and all dependencies are used'
+        },
+        messages: {
+            emptyDeps: 'Zeiger hook dependency array must not be empty. Provide at least one property.',
+            unusedDep: "Property '{{property}}' is listed in dependency array but not used in the code."
+        },
+        schema: []
+    },
+    create (context) {
+        const sourceCode = context.sourceCode;
+        function isZeigerHookCall(node) {
+            if ('CallExpression' !== node.type) return false;
+            const callNode = node;
+            const callee = callNode.callee;
+            if ('Identifier' !== callee.type) return false;
+            const hookName = callee.name;
+            if (!hookName.startsWith('use')) return false;
+            const scope = sourceCode.getScope(node);
+            const variable = scope.variables.find((v)=>v.name === hookName);
+            if (!variable) return false;
+            for (const def of variable.defs)if ('Variable' === def.type && def.node.init) {
+                const init = def.node.init;
+                if ('CallExpression' === init.type) {
+                    const initCall = init;
+                    const initCallee = initCall.callee;
+                    if ('Identifier' === initCallee.type) {
+                        const initName = initCallee.name;
+                        if ('createCollectionPointer' === initName || 'createCollectionItemPointer' === initName) return true;
+                    }
+                    if ('MemberExpression' === initCallee.type) {
+                        const member = initCallee;
+                        if ('Identifier' === member.property.type && ('createCollectionPointer' === member.property.name || 'createCollectionItemPointer' === member.property.name)) return true;
+                    }
+                }
+            }
+            return false;
+        }
+        function getDependencyArray(node) {
+            if ('CallExpression' !== node.type) return null;
+            const callNode = node;
+            const args = callNode.arguments;
+            if (0 === args.length) return null;
+            let depsArg = null;
+            if (1 === args.length) depsArg = args[0];
+            else if (2 === args.length) depsArg = args[1];
+            if (!depsArg || 'ArrayExpression' !== depsArg.type) return null;
+            const arrayNode = depsArg;
+            const deps = [];
+            for (const element of arrayNode.elements)if (element && 'Literal' === element.type && 'string' == typeof element.value) deps.push(element.value);
+            return deps;
+        }
+        function getUsedProperties(node, resultVarName) {
+            const used = new Set();
+            function traverse(currentNode) {
+                if ('MemberExpression' === currentNode.type) {
+                    const member = currentNode;
+                    const object = member.object;
+                    if ('Identifier' === object.type && object.name === resultVarName && 'Identifier' === member.property.type) used.add(member.property.name);
+                }
+                if ('ChainExpression' === currentNode.type) {
+                    const chain = currentNode;
+                    const expr = chain.expression;
+                    if ('MemberExpression' === expr.type) {
+                        const member = expr;
+                        const object = member.object;
+                        if ('Identifier' === object.type && object.name === resultVarName && 'Identifier' === member.property.type) used.add(member.property.name);
+                    }
+                }
+                for(const key in currentNode){
+                    if ('parent' === key || 'range' === key || 'loc' === key) continue;
+                    const value = currentNode[key];
+                    if (value && 'object' == typeof value) {
+                        if (Array.isArray(value)) {
+                            for (const item of value)if (item && 'object' == typeof item && 'type' in item) traverse(item);
+                        } else if (value && 'type' in value) traverse(value);
+                    }
+                }
+            }
+            traverse(node);
+            return used;
+        }
+        function getResultVariableName(node) {
+            if ('CallExpression' !== node.type) return null;
+            const parent = node.parent;
+            if (!parent) return null;
+            if ('VariableDeclarator' === parent.type) {
+                const declarator = parent;
+                if ('Identifier' === declarator.id.type) return declarator.id.name;
+            }
+            return null;
+        }
+        function findFunctionScope(scope) {
+            if ('function' === scope.type || 'class' === scope.type) return scope;
+            if (scope.upper) return findFunctionScope(scope.upper);
+            return null;
+        }
+        return {
+            CallExpression (node) {
+                if (!isZeigerHookCall(node)) return;
+                const deps = getDependencyArray(node);
+                if (null === deps) return;
+                if (0 === deps.length) return void context.report({
+                    node,
+                    messageId: 'emptyDeps'
+                });
+                const resultVarName = getResultVariableName(node);
+                if (!resultVarName) return;
+                const currentScope = sourceCode.getScope(node);
+                const functionScope = findFunctionScope(currentScope);
+                if (!functionScope || !functionScope.block) return;
+                const usedProperties = getUsedProperties(functionScope.block, resultVarName);
+                const callNode = node;
+                const depsArg = callNode.arguments.length > 0 ? callNode.arguments[callNode.arguments.length - 1] : null;
+                if (depsArg && 'ArrayExpression' === depsArg.type) {
+                    const arrayNode = depsArg;
+                    for(let i = 0; i < deps.length; i++){
+                        const dep = deps[i];
+                        if (!usedProperties.has(dep)) {
+                            const depElement = arrayNode.elements[i];
+                            if (depElement) context.report({
+                                node: depElement,
+                                messageId: 'unusedDep',
+                                data: {
+                                    property: dep
+                                }
+                            });
+                        }
+                    }
+                }
+            }
+        };
+    }
+};
+const zeiger_deps = rule;
+const src_plugin = {
+    meta: {
+        name: 'zeiger-eslint-plugin',
+        version: '1.0.0'
+    },
+    rules: {
+        'zeiger-deps': zeiger_deps
+    },
+    configs: {
+        recommended: {
+            plugins: [
+                'zeiger'
+            ],
+            rules: {
+                'zeiger/zeiger-deps': 'error'
+            }
+        }
+    }
+};
+const src = src_plugin;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { ESLint } from 'eslint';
+declare const plugin: ESLint.Plugin;
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGrC,QAAA,MAAM,MAAM,EAAE,MAAM,CAAC,MAgBpB,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/index.js

@@ -0,0 +1,159 @@
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure zeiger hook dependency arrays are not empty and all dependencies are used'
+        },
+        messages: {
+            emptyDeps: 'Zeiger hook dependency array must not be empty. Provide at least one property.',
+            unusedDep: "Property '{{property}}' is listed in dependency array but not used in the code."
+        },
+        schema: []
+    },
+    create (context) {
+        const sourceCode = context.sourceCode;
+        function isZeigerHookCall(node) {
+            if ('CallExpression' !== node.type) return false;
+            const callNode = node;
+            const callee = callNode.callee;
+            if ('Identifier' !== callee.type) return false;
+            const hookName = callee.name;
+            if (!hookName.startsWith('use')) return false;
+            const scope = sourceCode.getScope(node);
+            const variable = scope.variables.find((v)=>v.name === hookName);
+            if (!variable) return false;
+            for (const def of variable.defs)if ('Variable' === def.type && def.node.init) {
+                const init = def.node.init;
+                if ('CallExpression' === init.type) {
+                    const initCall = init;
+                    const initCallee = initCall.callee;
+                    if ('Identifier' === initCallee.type) {
+                        const initName = initCallee.name;
+                        if ('createCollectionPointer' === initName || 'createCollectionItemPointer' === initName) return true;
+                    }
+                    if ('MemberExpression' === initCallee.type) {
+                        const member = initCallee;
+                        if ('Identifier' === member.property.type && ('createCollectionPointer' === member.property.name || 'createCollectionItemPointer' === member.property.name)) return true;
+                    }
+                }
+            }
+            return false;
+        }
+        function getDependencyArray(node) {
+            if ('CallExpression' !== node.type) return null;
+            const callNode = node;
+            const args = callNode.arguments;
+            if (0 === args.length) return null;
+            let depsArg = null;
+            if (1 === args.length) depsArg = args[0];
+            else if (2 === args.length) depsArg = args[1];
+            if (!depsArg || 'ArrayExpression' !== depsArg.type) return null;
+            const arrayNode = depsArg;
+            const deps = [];
+            for (const element of arrayNode.elements)if (element && 'Literal' === element.type && 'string' == typeof element.value) deps.push(element.value);
+            return deps;
+        }
+        function getUsedProperties(node, resultVarName) {
+            const used = new Set();
+            function traverse(currentNode) {
+                if ('MemberExpression' === currentNode.type) {
+                    const member = currentNode;
+                    const object = member.object;
+                    if ('Identifier' === object.type && object.name === resultVarName && 'Identifier' === member.property.type) used.add(member.property.name);
+                }
+                if ('ChainExpression' === currentNode.type) {
+                    const chain = currentNode;
+                    const expr = chain.expression;
+                    if ('MemberExpression' === expr.type) {
+                        const member = expr;
+                        const object = member.object;
+                        if ('Identifier' === object.type && object.name === resultVarName && 'Identifier' === member.property.type) used.add(member.property.name);
+                    }
+                }
+                for(const key in currentNode){
+                    if ('parent' === key || 'range' === key || 'loc' === key) continue;
+                    const value = currentNode[key];
+                    if (value && 'object' == typeof value) {
+                        if (Array.isArray(value)) {
+                            for (const item of value)if (item && 'object' == typeof item && 'type' in item) traverse(item);
+                        } else if (value && 'type' in value) traverse(value);
+                    }
+                }
+            }
+            traverse(node);
+            return used;
+        }
+        function getResultVariableName(node) {
+            if ('CallExpression' !== node.type) return null;
+            const parent = node.parent;
+            if (!parent) return null;
+            if ('VariableDeclarator' === parent.type) {
+                const declarator = parent;
+                if ('Identifier' === declarator.id.type) return declarator.id.name;
+            }
+            return null;
+        }
+        function findFunctionScope(scope) {
+            if ('function' === scope.type || 'class' === scope.type) return scope;
+            if (scope.upper) return findFunctionScope(scope.upper);
+            return null;
+        }
+        return {
+            CallExpression (node) {
+                if (!isZeigerHookCall(node)) return;
+                const deps = getDependencyArray(node);
+                if (null === deps) return;
+                if (0 === deps.length) return void context.report({
+                    node,
+                    messageId: 'emptyDeps'
+                });
+                const resultVarName = getResultVariableName(node);
+                if (!resultVarName) return;
+                const currentScope = sourceCode.getScope(node);
+                const functionScope = findFunctionScope(currentScope);
+                if (!functionScope || !functionScope.block) return;
+                const usedProperties = getUsedProperties(functionScope.block, resultVarName);
+                const callNode = node;
+                const depsArg = callNode.arguments.length > 0 ? callNode.arguments[callNode.arguments.length - 1] : null;
+                if (depsArg && 'ArrayExpression' === depsArg.type) {
+                    const arrayNode = depsArg;
+                    for(let i = 0; i < deps.length; i++){
+                        const dep = deps[i];
+                        if (!usedProperties.has(dep)) {
+                            const depElement = arrayNode.elements[i];
+                            if (depElement) context.report({
+                                node: depElement,
+                                messageId: 'unusedDep',
+                                data: {
+                                    property: dep
+                                }
+                            });
+                        }
+                    }
+                }
+            }
+        };
+    }
+};
+const zeiger_deps = rule;
+const src_plugin = {
+    meta: {
+        name: 'zeiger-eslint-plugin',
+        version: '1.0.0'
+    },
+    rules: {
+        'zeiger-deps': zeiger_deps
+    },
+    configs: {
+        recommended: {
+            plugins: [
+                'zeiger'
+            ],
+            rules: {
+                'zeiger/zeiger-deps': 'error'
+            }
+        }
+    }
+};
+const src = src_plugin;
+export { src as default };

package/dist/rules/zeiger-deps.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=zeiger-deps.d.ts.map

package/dist/rules/zeiger-deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zeiger-deps.d.ts","sourceRoot":"","sources":["../../src/rules/zeiger-deps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA2VhB,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "zeiger-eslint-plugin",
+  "description": "ESLint plugin for Zeiger library",
+  "homepage": "https://github.com/DNepovim/zeiger",
+  "repository": "https://github.com/DNepovim/zeiger",
+  "author": "Dominik Bláha <iam@dominikblaha.cz>",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rslib build",
+    "dev": "rslib build --watch",
+    "lint:check": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "format:check": "prettier --check .",
+    "format:fix": "prettier --write .",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "knip": "knip"
+  },
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "zeiger"
+  ],
+  "peerDependencies": {
+    "eslint": ">=8.0.0"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.18.4",
+    "@types/estree": "^1.0.8",
+    "@types/node": "^24.10.1",
+    "knip": "^5.82.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.15"
+  }
+}