@gost-kit/eslint-plugin 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @gost-kit/eslint-plugin
 
+## 0.2.0
+
+### Minor Changes
+
+- 9f59da3: Add the opt-in ready-boolean-condition rule for Svelte if/else-if conditions.
+  Accept ready boolean reads and literals, report computations/truthiness, and
+  require typed parser services with strictNullChecks for reads. The Svelte config
+  registers the rule off; projects select business/UI-Kit scopes explicitly.
+
 ## 0.1.0
 
 ### Minor Changes

package/README.md

@@ -8,7 +8,8 @@ ESLint ^10.14.0 and TypeScript ^5.9.3.
 
 `@gost-kit/eslint-config-svelte` installs and enables the plugin for typed Svelte
 components and `.svelte.ts` modules. The selector rule is enabled by default;
-`gost/no-component-state` and `gost/single-intent-dispatch` require explicit
+`gost/no-component-state`, `gost/single-intent-dispatch` and
+`gost/ready-boolean-condition` require explicit
 consumer overrides for business component paths. UI-Kit paths can opt out.
 No separate plugin registration is needed.
 Other consumers may register the named public export in their flat config:
@@ -32,8 +33,8 @@ Nested common installations are supported; a direct common dependency of the
 application is not required for inferred Store detection.
 Local `$state.raw` bindings are recognized from their original lexical scope.
 For `require-feature-state-selector`, type information is required; an enabled typed rule without parser services
-reports a configuration error. Stateless and JavaScript-script components are
-skipped. Mixed components are checked per script: a typed module script does
+reports a configuration error. For the selector rule, stateless and JavaScript-script
+components are skipped. Mixed components are checked per script: a typed module script does
 not enable the rule for a JavaScript instance script. The Svelte config does not enable this typed rule for `.svelte.js`.
 
 `single-intent-dispatch` uses an `on*` name heuristic, including function-valued
@@ -44,3 +45,9 @@ ordinary optional data reads remain outside that gate check.
 
 See [RULES.md](RULES.md) for diagnostics, autofix boundaries and examples.
 Tests and test helpers are excluded from published artifacts.
+
+`ready-boolean-condition` checks Svelte if/else-if conditions: true/false or
+ready boolean identifier/static field reads. Computations and truthiness are
+reported; typed reads require strictNullChecks and parser services. JS/stateless
+reads are checked too when services are available. No autofix or presenter
+provenance guarantee is provided. See the inventory for opt-in boundaries.

package/RULES.md

@@ -247,3 +247,66 @@ a dispatch diagnostic, although it violates the business-component boundary.
 Event adaptation belongs in UI-Kit. Effects outside discovered UI callbacks may
 perform several dispatches. Presentation computations (including templates) are
 #19, boolean template conditions #18, and testable local UI-state #27.
+
+## gost/ready-boolean-condition
+
+Opt in for business `.svelte` files. `{#if}` and `{:else if}` read a ready
+boolean; ordinary else and conditional rendering remain available.
+
+```svelte
+{#if view.isLoaded}
+  <p>{view.name}</p>
+{:else if isFailed}
+  <p>Failed</p>
+{/if}
+```
+
+Allowed: boolean literals true/false, identifiers and static field chains rooted
+at an identifier (for example view.ready), including quoted keys and number-valued
+AST literal indexes such as flags[0] or flags[0x10]. The final type must be
+definitely boolean. this.isReady is outside the supported root form. Signed keys
+such as flags[-1] are unary expressions, and bigint keys such as flags[10n] are
+not number-valued literals; both are outside this first-version syntax boundary.
+Optional chains are accepted only when the complete expression excludes
+undefined/null. Boolean aliases, boolean-only unions and proven boolean generic
+constraints are accepted. TypeScript flow narrowing applies at the expression.
+
+Reported with `readyBoolean`: comparisons, logical operations, negation, calls,
+ternaries, dynamic keys, assertions/non-null assertions/satisfies wrappers,
+object/string/number truthiness, nullable booleans and any/unknown/never. Move
+the calculation to a pure presenter and read its named boolean result. There
+is no autofix or suggestion that invents a presenter/field name.
+
+Identifier/member reads require actual parser type services and strictNullChecks,
+either directly or via strict. Explicit strictNullChecks: false overrides strict.
+Missing services/null checking is a configuration error, not a successful check.
+Literal booleans and invalid syntax do not need services; components without
+conditions do not request them. Type services also cover JS-script and stateless
+components when the configured parser supplies a program. Inferred any in JS
+props is rejected just like TypeScript any. Script if statements, ordinary TS and
+rune modules are outside the rule.
+
+This checks shape and type, not provenance/purity. A local boolean or boolean
+getter is not proof of a presenter. Rule #19 addresses presentation calculations
+outside template conditions. Static indexed reads follow consumer TypeScript
+options; enable noUncheckedIndexedAccess to expose possible missing entries.
+The rule does not validate runtime input that the declared types conceal.
+
+`createSvelteConfig` registers it explicitly off. Enable with a later override:
+
+```ts
+{
+  files: ['src/**/*.svelte'],
+  rules: { 'gost/ready-boolean-condition': 'error' },
+}
+```
+
+Independent UI-Kit components may use a later matching off override while
+retaining the other TypeScript/Svelte checks.
+
+The current svelte-eslint-parser 1.10.1 models component generics as aliases to
+their constraints (unknown when unconstrained). Conditional types over those
+component generics may therefore resolve differently from a particular caller's
+instantiation. This rule checks the parser-provided program, not every generic
+instantiation; use an explicitly boolean view field for that boundary. It cannot
+recover source type distinctions already erased by the parser.

package/dist/index.js

@@ -1,3 +1,4 @@
+import { readyBooleanCondition } from './rules/ready-boolean-condition.js';
 import { singleIntentDispatch } from './rules/single-intent-dispatch.js';
 import { noComponentState } from './rules/no-component-state.js';
 import { requireFeatureStateSelector } from './rules/require-feature-state-selector.js';
@@ -6,6 +7,7 @@ export const plugin = {
     // typescript-eslint still types the legacy context members removed in ESLint 10.
     // At this public boundary the implementation uses only the current APIs.
     rules: {
+        'ready-boolean-condition': readyBooleanCondition,
         'single-intent-dispatch': singleIntentDispatch,
         'no-component-state': noComponentState,
         'require-feature-state-selector': requireFeatureStateSelector,

package/dist/lib/boolean-type.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare const booleanType: (checker: ts.TypeChecker, type: ts.Type) => boolean;

package/dist/lib/boolean-type.js

@@ -0,0 +1,14 @@
+import ts from 'typescript';
+export const booleanType = (checker, type) => {
+    if (type.flags &
+        (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) {
+        return false;
+    }
+    if (type.flags & ts.TypeFlags.TypeParameter) {
+        const constraint = checker.getBaseConstraintOfType(type);
+        return (constraint !== undefined &&
+            constraint !== type &&
+            booleanType(checker, constraint));
+    }
+    return checker.isTypeAssignableTo(type, checker.getBooleanType());
+};

package/dist/lib/member-key.d.ts

@@ -1,2 +1,4 @@
 import { type TSESTree } from '@typescript-eslint/utils';
-export declare const memberKey: (node: TSESTree.MemberExpression) => string | undefined;
+export declare const memberKey: (node: TSESTree.MemberExpression, { numeric }?: {
+    numeric?: boolean;
+}) => string | undefined;

package/dist/lib/member-key.js

@@ -1,13 +1,18 @@
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-export const memberKey = (node) => {
+export const memberKey = (node, { numeric = false } = {}) => {
     if (!node.computed && node.property.type === AST_NODE_TYPES.Identifier) {
         return node.property.name;
     }
     if (node.computed && node.property.type === AST_NODE_TYPES.Literal) {
-        return node.property.raw.startsWith("'") ||
-            node.property.raw.startsWith('"')
-            ? String(node.property.value)
-            : undefined;
+        if (node.property.raw.startsWith("'") ||
+            node.property.raw.startsWith('"')) {
+            return String(node.property.value);
+        }
+        // Match numeric AST literals, including values such as 1e999; finiteness
+        // would change syntax classification. Existing callers remain names-only.
+        if (numeric && typeof node.property.value === 'number') {
+            return String(node.property.value);
+        }
     }
     return undefined;
 };

package/dist/lib/ready-boolean-expression.d.ts

@@ -0,0 +1,2 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+export declare const readyBooleanExpression: (node: TSESTree.Expression) => boolean;

package/dist/lib/ready-boolean-expression.js

@@ -0,0 +1,17 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { memberKey } from './member-key.js';
+export const readyBooleanExpression = (node) => {
+    if (node.type === AST_NODE_TYPES.Identifier) {
+        return true;
+    }
+    if (node.type === AST_NODE_TYPES.ChainExpression) {
+        return readyBooleanExpression(node.expression);
+    }
+    if (node.type !== AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    const staticKey = memberKey(node, { numeric: true }) !== undefined;
+    return (staticKey &&
+        node.object.type !== AST_NODE_TYPES.Super &&
+        readyBooleanExpression(node.object));
+};

package/dist/rules/ready-boolean-condition.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const readyBooleanCondition: ESLintUtils.RuleModule<"readyBoolean", [], unknown, ESLintUtils.RuleListener>;

package/dist/rules/ready-boolean-condition.js

@@ -0,0 +1,49 @@
+import { AST_NODE_TYPES, ESLintUtils, } from '@typescript-eslint/utils';
+import { readyBooleanExpression } from '../lib/ready-boolean-expression.js';
+import { booleanType } from '../lib/boolean-type.js';
+export const readyBooleanCondition = ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Require ready boolean reads in Svelte if/else-if conditions.',
+        },
+        schema: [],
+        messages: {
+            readyBoolean: 'Prepare a named boolean in a presenter and read it here instead of computing a condition or using truthiness.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        if (!context.filename.endsWith('.svelte')) {
+            return {};
+        }
+        let checkType;
+        return {
+            SvelteIfBlock(node) {
+                const expression = node.expression;
+                if (expression.type === AST_NODE_TYPES.Literal &&
+                    (expression.value === true || expression.value === false)) {
+                    return;
+                }
+                if (!readyBooleanExpression(expression)) {
+                    context.report({ node: expression, messageId: 'readyBoolean' });
+                    return;
+                }
+                if (!checkType) {
+                    const services = ESLintUtils.getParserServices(context);
+                    const options = services.program.getCompilerOptions();
+                    if (!(options.strictNullChecks ?? options.strict ?? false)) {
+                        throw new Error('gost/ready-boolean-condition requires strictNullChecks (or strict) for typed conditions.');
+                    }
+                    const checker = services.program.getTypeChecker();
+                    checkType = (condition) => {
+                        return booleanType(checker, services.getTypeAtLocation(condition));
+                    };
+                }
+                if (!checkType(expression)) {
+                    context.report({ node: expression, messageId: 'readyBoolean' });
+                }
+            },
+        };
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gost-kit/eslint-plugin",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "GOST architecture rules for agent-assisted frontend development.",
   "type": "module",
   "license": "MIT",
@@ -43,8 +43,8 @@
     "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",
+    "@gost-kit/common": "0.3.0",
+    "@gost-kit/svelte": "0.2.0",
     "@typescript-eslint/rule-tester": "8.72.1"
   },
   "dependencies": {