@gost-kit/eslint-plugin 0.0.0-stage → 0.1.0

package/dist/rules/single-intent-dispatch.js

@@ -0,0 +1,89 @@
+import { AST_NODE_TYPES, ESLintUtils, } from '@typescript-eslint/utils';
+import { isOptionalCall } from '../lib/optional-call.js';
+import { createDispatchCheck } from '../lib/dispatch-type.js';
+import { createUiHandlerCollector } from '../lib/ui-handlers.js';
+import { visitHandlerBody } from '../lib/handler-body.js';
+import { scriptHasAttribute, svelteScripts } from '../lib/svelte-scripts.js';
+export const singleIntentDispatch = ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Forward one intent in business UI callbacks.' },
+        schema: [],
+        messages: {
+            multipleDispatch: 'Forward one intent action; move business transitions to the reducer.',
+            conditionalDispatch: 'Move business decisions to the reducer and browser event handling to a UI-Kit component.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const source = context.sourceCode;
+        const scripts = svelteScripts(source)?.filter((script) => {
+            return (scriptHasAttribute(script, 'lang', 'ts') &&
+                !scriptHasAttribute(script, 'module') &&
+                !scriptHasAttribute(script, 'context', 'module'));
+        });
+        if (!scripts?.length) {
+            return {};
+        }
+        const isDispatch = createDispatchCheck(ESLintUtils.getParserServices(context));
+        const collector = createUiHandlerCollector(source, scripts);
+        return {
+            SvelteAttribute: collector.attribute,
+            SvelteShorthandAttribute: collector.shorthand,
+            SvelteDirective: collector.directive,
+            'Program:exit'() {
+                collector.handlers.forEach((handler) => {
+                    let calls = 0;
+                    let condition;
+                    if (!handler.body) {
+                        return;
+                    }
+                    const inspect = (node) => {
+                        if (node.type === AST_NODE_TYPES.CallExpression &&
+                            isDispatch(node.callee)) {
+                            calls += 1;
+                            if (isOptionalCall(node)) {
+                                condition ??= node;
+                            }
+                            // A Dispatch default argument runs conditionally at invocation,
+                            // even though its AssignmentPattern is not a logical expression.
+                            condition ??= source.getAncestors(node).find((ancestor) => {
+                                return (ancestor.type === AST_NODE_TYPES.AssignmentPattern &&
+                                    handler.params.some((parameter) => {
+                                        return (ancestor.range[0] >= parameter.range[0] &&
+                                            ancestor.range[1] <= parameter.range[1]);
+                                    }));
+                            });
+                        }
+                        if (node.type === AST_NODE_TYPES.IfStatement ||
+                            node.type === AST_NODE_TYPES.SwitchStatement ||
+                            node.type === AST_NODE_TYPES.ForStatement ||
+                            node.type === AST_NODE_TYPES.ForInStatement ||
+                            node.type === AST_NODE_TYPES.ForOfStatement ||
+                            node.type === AST_NODE_TYPES.WhileStatement ||
+                            node.type === AST_NODE_TYPES.DoWhileStatement ||
+                            node.type === AST_NODE_TYPES.ConditionalExpression ||
+                            node.type === AST_NODE_TYPES.LogicalExpression ||
+                            (node.type === AST_NODE_TYPES.AssignmentExpression &&
+                                ['??=', '&&=', '||='].includes(node.operator))) {
+                            condition ??= node;
+                        }
+                    };
+                    handler.params.forEach((parameter) => {
+                        visitHandlerBody(parameter, source, inspect);
+                    });
+                    visitHandlerBody(handler.body, source, inspect);
+                    if (calls > 1) {
+                        context.report({ node: handler, messageId: 'multipleDispatch' });
+                    }
+                    else if (calls === 1 && condition) {
+                        context.report({
+                            node: condition,
+                            messageId: 'conditionalDispatch',
+                        });
+                    }
+                });
+            },
+        };
+    },
+});

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@gost-kit/eslint-plugin",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "GOST architecture rules for agent-assisted frontend development.",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": "^26.0.0"
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md",
+    "RULES.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "npm run clean && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "check": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "prepack": "npm run build",
+    "clean": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('dist', { recursive: true, force: true });\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/antonsmolko/gost-kit.git",
+    "directory": "packages/eslint-plugin"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "26.6.5",
+    "typescript": "5.9.3",
+    "tsc-alias": "1.9.9",
+    "vitest": "5.0.5",
+    "eslint": "10.14.0",
+    "svelte-eslint-parser": "1.10.1",
+    "typescript-eslint": "8.72.1",
+    "svelte": "5.57.2",
+    "@gost-kit/common": "0.2.1",
+    "@gost-kit/svelte": "0.1.1",
+    "@typescript-eslint/rule-tester": "8.72.1"
+  },
+  "dependencies": {
+    "@typescript-eslint/utils": "8.72.1"
+  },
+  "peerDependencies": {
+    "eslint": "^10.14.0",
+    "typescript": "^5.9.3"
+  }
+}