@fictjs/eslint-plugin 0.0.13 → 0.0.15

package/dist/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   default: () => index_default,
+  noComputedPropsKey: () => no_computed_props_key_default,
   noDirectMutation: () => no_direct_mutation_default,
   noEmptyEffect: () => no_empty_effect_default,
   noInlineFunctions: () => no_inline_functions_default,
@@ -29,13 +30,49 @@ __export(index_exports, {
   noStateDestructureWrite: () => no_state_destructure_write_default,
   noStateInLoop: () => no_state_in_loop_default,
   noStateOutsideComponent: () => no_state_outside_component_default,
+  noThirdPartyPropsSpread: () => no_third_party_props_spread_default,
+  noUnsafePropsSpread: () => no_unsafe_props_spread_default,
+  noUnsupportedPropsDestructure: () => no_unsupported_props_destructure_default,
   requireComponentReturn: () => require_component_return_default,
   requireListKey: () => require_list_key_default
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/rules/no-direct-mutation.ts
+// src/rules/no-computed-props-key.ts
 var rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow computed keys in JSX props object spreads",
+      recommended: true
+    },
+    messages: {
+      computedKey: "Computed props key may break fine-grained reactivity; use explicit props."
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      JSXSpreadAttribute(node) {
+        const expr = node.argument;
+        if (!expr || expr.type !== "ObjectExpression") return;
+        for (const prop of expr.properties ?? []) {
+          if (prop.type === "Property" && prop.computed) {
+            context.report({
+              node: prop,
+              messageId: "computedKey"
+            });
+            return;
+          }
+        }
+      }
+    };
+  }
+};
+var no_computed_props_key_default = rule;
+
+// src/rules/no-direct-mutation.ts
+var rule2 = {
   meta: {
     type: "suggestion",
     docs: {
@@ -87,10 +124,10 @@ function isDeepAccess(node) {
   }
   return depth > 1;
 }
-var no_direct_mutation_default = rule;
+var no_direct_mutation_default = rule2;
 
 // src/rules/no-empty-effect.ts
-var rule2 = {
+var rule3 = {
   meta: {
     type: "suggestion",
     docs: {
@@ -215,10 +252,10 @@ var rule2 = {
     };
   }
 };
-var no_empty_effect_default = rule2;
+var no_empty_effect_default = rule3;
 
 // src/rules/no-inline-functions.ts
-var rule3 = {
+var rule4 = {
   meta: {
     type: "suggestion",
     docs: {
@@ -268,10 +305,10 @@ var rule3 = {
     };
   }
 };
-var no_inline_functions_default = rule3;
+var no_inline_functions_default = rule4;
 
 // src/rules/no-memo-side-effects.ts
-var rule4 = {
+var rule5 = {
   meta: {
     type: "problem",
     docs: {
@@ -331,10 +368,10 @@ var rule4 = {
     };
   }
 };
-var no_memo_side_effects_default = rule4;
+var no_memo_side_effects_default = rule5;
 
 // src/rules/no-nested-components.ts
-var rule5 = {
+var rule6 = {
   meta: {
     type: "problem",
     docs: {
@@ -425,66 +462,7 @@ var rule5 = {
     };
   }
 };
-var no_nested_components_default = rule5;
-
-// src/rules/no-state-in-loop.ts
-var rule6 = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow $state declarations inside loops",
-      recommended: true
-    },
-    messages: {
-      noStateInLoop: "$state should not be declared inside a loop. Move it outside the loop."
-    },
-    schema: []
-  },
-  create(context) {
-    let loopDepth = 0;
-    return {
-      ForStatement() {
-        loopDepth++;
-      },
-      "ForStatement:exit"() {
-        loopDepth--;
-      },
-      ForInStatement() {
-        loopDepth++;
-      },
-      "ForInStatement:exit"() {
-        loopDepth--;
-      },
-      ForOfStatement() {
-        loopDepth++;
-      },
-      "ForOfStatement:exit"() {
-        loopDepth--;
-      },
-      WhileStatement() {
-        loopDepth++;
-      },
-      "WhileStatement:exit"() {
-        loopDepth--;
-      },
-      DoWhileStatement() {
-        loopDepth++;
-      },
-      "DoWhileStatement:exit"() {
-        loopDepth--;
-      },
-      CallExpression(node) {
-        if (loopDepth > 0 && node.callee.type === "Identifier" && node.callee.name === "$state") {
-          context.report({
-            node,
-            messageId: "noStateInLoop"
-          });
-        }
-      }
-    };
-  }
-};
-var no_state_in_loop_default = rule6;
+var no_nested_components_default = rule6;
 
 // src/rules/no-state-destructure-write.ts
 var rule7 = {
@@ -576,6 +554,65 @@ var rule7 = {
 };
 var no_state_destructure_write_default = rule7;
 
+// src/rules/no-state-in-loop.ts
+var rule8 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow $state declarations inside loops",
+      recommended: true
+    },
+    messages: {
+      noStateInLoop: "$state should not be declared inside a loop. Move it outside the loop."
+    },
+    schema: []
+  },
+  create(context) {
+    let loopDepth = 0;
+    return {
+      ForStatement() {
+        loopDepth++;
+      },
+      "ForStatement:exit"() {
+        loopDepth--;
+      },
+      ForInStatement() {
+        loopDepth++;
+      },
+      "ForInStatement:exit"() {
+        loopDepth--;
+      },
+      ForOfStatement() {
+        loopDepth++;
+      },
+      "ForOfStatement:exit"() {
+        loopDepth--;
+      },
+      WhileStatement() {
+        loopDepth++;
+      },
+      "WhileStatement:exit"() {
+        loopDepth--;
+      },
+      DoWhileStatement() {
+        loopDepth++;
+      },
+      "DoWhileStatement:exit"() {
+        loopDepth--;
+      },
+      CallExpression(node) {
+        if (loopDepth > 0 && node.callee.type === "Identifier" && node.callee.name === "$state") {
+          context.report({
+            node,
+            messageId: "noStateInLoop"
+          });
+        }
+      }
+    };
+  }
+};
+var no_state_in_loop_default = rule8;
+
 // src/rules/no-state-outside-component.ts
 var isUpperCaseName = (name) => !!name && /^[A-Z]/.test(name);
 var isHookName = (name) => !!name && /^use[A-Z]/.test(name);
@@ -637,7 +674,13 @@ var isInConditional = (ancestors) => ancestors.some(
     "LogicalExpression"
   ].includes(ancestor.type)
 );
-var rule8 = {
+var isDirectStateDeclaration = (node, ancestors) => {
+  const parent = ancestors[ancestors.length - 1];
+  if (!parent || parent.type !== "VariableDeclarator") return false;
+  if (parent.init !== node) return false;
+  return parent.id?.type === "Identifier";
+};
+var rule9 = {
   meta: {
     type: "problem",
     docs: {
@@ -647,7 +690,8 @@ var rule8 = {
     messages: {
       moduleScope: "$state must be declared inside a component or hook function body (not at module scope).",
       componentOnly: "$state should only be used inside a component function (PascalCase or JSX-returning) or a hook (useX).",
-      topLevel: "$state must be at the top level of the component or hook body (not inside conditionals or nested functions)."
+      topLevel: "$state must be at the top level of the component or hook body (not inside conditionals or nested functions).",
+      declarationOnly: "$state() must be assigned directly to a variable (e.g. let count = $state(0))."
     },
     schema: []
   },
@@ -656,6 +700,10 @@ var rule8 = {
       CallExpression(node) {
         if (node.callee.type !== "Identifier" || node.callee.name !== "$state") return;
         const ancestors = context.sourceCode.getAncestors(node);
+        if (!isDirectStateDeclaration(node, ancestors)) {
+          context.report({ node, messageId: "declarationOnly" });
+          return;
+        }
         const functionAncestors = ancestors.filter(
           (ancestor) => ["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"].includes(
             ancestor.type
@@ -681,10 +729,358 @@ var rule8 = {
     };
   }
 };
-var no_state_outside_component_default = rule8;
+var no_state_outside_component_default = rule9;
+
+// src/rules/no-third-party-props-spread.ts
+var rule10 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Warn on third-party object spreads in JSX props",
+      recommended: true
+    },
+    messages: {
+      thirdPartySpread: "Spreading third-party objects into props may hide reactive changes; prefer explicit props or map fields."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          includeCallExpressions: {
+            type: "boolean",
+            description: "Also warn when JSX spread comes from a third-party call expression."
+          },
+          allow: {
+            type: "array",
+            items: { type: "string" },
+            description: "Module specifiers to treat as internal."
+          },
+          internalPrefixes: {
+            type: "array",
+            items: { type: "string" },
+            description: 'Import path prefixes to treat as internal (e.g. "@/", "~/" ).'
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    const allow = new Set(options.allow ?? []);
+    const internalPrefixes = options.internalPrefixes ?? [];
+    const includeCallExpressions = options.includeCallExpressions === true;
+    const thirdPartyImports = /* @__PURE__ */ new Set();
+    const isThirdPartySource = (source) => {
+      if (allow.has(source)) return false;
+      if (source.startsWith(".") || source.startsWith("/")) return false;
+      if (internalPrefixes.some((prefix) => source.startsWith(prefix))) return false;
+      return true;
+    };
+    const isComponentName = (name) => {
+      if (name.type === "JSXIdentifier") {
+        return /^[A-Z]/.test(name.name);
+      }
+      if (name.type === "JSXMemberExpression") {
+        return true;
+      }
+      return false;
+    };
+    const unwrapExpression = (expr) => {
+      let current = expr;
+      while (current) {
+        if (current.type === "ChainExpression") {
+          current = current.expression;
+          continue;
+        }
+        if (current.type === "TSAsExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") {
+          current = current.expression;
+          continue;
+        }
+        break;
+      }
+      return current;
+    };
+    const getRootIdentifierName = (expr) => {
+      let current = unwrapExpression(expr);
+      while (current) {
+        if (current.type === "Identifier") return current.name;
+        if (current.type === "MemberExpression" || current.type === "OptionalMemberExpression") {
+          current = unwrapExpression(current.object);
+          continue;
+        }
+        if (includeCallExpressions && (current.type === "CallExpression" || current.type === "OptionalCallExpression")) {
+          current = unwrapExpression(current.callee);
+          continue;
+        }
+        return null;
+      }
+      return null;
+    };
+    return {
+      ImportDeclaration(node) {
+        if (!node.source?.value || typeof node.source.value !== "string") return;
+        if (!isThirdPartySource(node.source.value)) return;
+        for (const spec of node.specifiers ?? []) {
+          if (spec.local?.name) {
+            thirdPartyImports.add(spec.local.name);
+          }
+        }
+      },
+      JSXOpeningElement(node) {
+        if (!isComponentName(node.name)) return;
+        for (const attr of node.attributes ?? []) {
+          if (attr.type !== "JSXSpreadAttribute") continue;
+          const expr = attr.argument;
+          if (!expr) continue;
+          if (expr.type === "CallExpression" && expr.callee?.type === "Identifier" && expr.callee.name === "mergeProps") {
+            continue;
+          }
+          const root = getRootIdentifierName(expr);
+          if (root && thirdPartyImports.has(root)) {
+            context.report({
+              node: attr,
+              messageId: "thirdPartySpread"
+            });
+          }
+        }
+      }
+    };
+  }
+};
+var no_third_party_props_spread_default = rule10;
+
+// src/rules/no-unsafe-props-spread.ts
+var rule11 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Warn on JSX spread sources that are too dynamic to keep props reactive",
+      recommended: true
+    },
+    messages: {
+      unsafeSpread: "JSX spread source is too dynamic to keep props reactive. Consider passing explicit props or using mergeProps(() => source)."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          accessorNames: {
+            type: "array",
+            items: { type: "string" },
+            description: "Identifier names to treat as accessor functions."
+          },
+          accessorModules: {
+            type: "array",
+            items: { type: "string" },
+            description: "Module specifiers whose imports are accessor functions."
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    const accessorVars = new Set(options.accessorNames ?? []);
+    const accessorModules = new Set(options.accessorModules ?? []);
+    const isComponentName = (name) => {
+      if (name.type === "JSXIdentifier") {
+        return /^[A-Z]/.test(name.name);
+      }
+      if (name.type === "JSXMemberExpression") {
+        return true;
+      }
+      return false;
+    };
+    const recordAccessorVar = (node) => {
+      if (!node.init || node.id?.type !== "Identifier") return;
+      if (node.init.type !== "CallExpression") return;
+      if (node.init.callee?.type !== "Identifier") return;
+      const callee = node.init.callee.name;
+      if (callee === "$state" || callee === "$memo" || callee === "prop") {
+        accessorVars.add(node.id.name);
+      }
+    };
+    const isSafeAccessorExpr = (expr) => {
+      if (expr.type === "Identifier") return true;
+      if (expr.type === "CallExpression" && expr.callee?.type === "Identifier" && expr.arguments.length === 0 && accessorVars.has(expr.callee.name)) {
+        return true;
+      }
+      return false;
+    };
+    const isObviouslyDynamic = (expr) => expr.type === "ConditionalExpression" || expr.type === "LogicalExpression" || expr.type === "SequenceExpression" || expr.type === "AssignmentExpression" || expr.type === "UpdateExpression" || expr.type === "AwaitExpression" || expr.type === "NewExpression" || expr.type === "YieldExpression";
+    const hasUnsafeObjectLiteral = (obj) => {
+      for (const prop of obj.properties ?? []) {
+        if (prop.type === "SpreadElement") return true;
+        if (prop.type === "Property") {
+          if (prop.computed) return true;
+          if (prop.kind === "get" || prop.kind === "set") return true;
+        }
+      }
+      return false;
+    };
+    const shouldWarnForSpreadExpr = (expr) => {
+      if (isSafeAccessorExpr(expr)) return false;
+      if (expr.type === "CallExpression" && expr.callee?.type === "Identifier" && expr.callee.name === "mergeProps") {
+        return false;
+      }
+      if (expr.type === "ObjectExpression") {
+        return hasUnsafeObjectLiteral(expr);
+      }
+      if (isObviouslyDynamic(expr)) return true;
+      if (expr.type === "CallExpression") return true;
+      if (expr.type === "MemberExpression") return true;
+      return false;
+    };
+    return {
+      ImportDeclaration(node) {
+        if (!node.source?.value || typeof node.source.value !== "string") return;
+        if (!accessorModules.has(node.source.value)) return;
+        for (const spec of node.specifiers ?? []) {
+          if (spec.local?.name) {
+            accessorVars.add(spec.local.name);
+          }
+        }
+      },
+      VariableDeclarator: recordAccessorVar,
+      JSXOpeningElement(node) {
+        if (!isComponentName(node.name)) return;
+        for (const attr of node.attributes ?? []) {
+          if (attr.type !== "JSXSpreadAttribute") continue;
+          const expr = attr.argument;
+          if (!expr) continue;
+          if (shouldWarnForSpreadExpr(expr)) {
+            context.report({
+              node: attr,
+              messageId: "unsafeSpread"
+            });
+          }
+        }
+      }
+    };
+  }
+};
+var no_unsafe_props_spread_default = rule11;
+
+// src/rules/no-unsupported-props-destructure.ts
+var rule12 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Warn on unsupported props destructuring patterns in components",
+      recommended: true
+    },
+    messages: {
+      computedKey: "Computed property in props pattern cannot be made reactive.",
+      arrayRest: "Array rest in props destructuring falls back to non-reactive binding.",
+      nestedRest: "Nested props rest destructuring falls back to non-reactive binding; access props directly or use prop.",
+      nonFirstParam: "Props destructuring is only supported in the first parameter.",
+      fallback: "Props destructuring falls back to non-reactive binding."
+    },
+    schema: []
+  },
+  create(context) {
+    const isComponentName = (name) => /^[A-Z]/.test(name);
+    const getPropsPattern = (fnNode) => {
+      const params = fnNode?.params ?? [];
+      const first = params[0];
+      if (params.length > 1) {
+        params.slice(1).forEach((param) => {
+          if (!param) return;
+          const target = param.type === "AssignmentPattern" ? param.left : param;
+          if (target?.type === "ObjectPattern" || target?.type === "ArrayPattern") {
+            context.report({
+              node: target,
+              messageId: "nonFirstParam"
+            });
+          }
+        });
+      }
+      if (!first) return null;
+      if (first.type === "ObjectPattern") return first;
+      if (first.type === "AssignmentPattern" && first.left?.type === "ObjectPattern") {
+        return first.left;
+      }
+      if (first.type === "ArrayPattern") {
+        context.report({
+          node: first,
+          messageId: "fallback"
+        });
+        return null;
+      }
+      return null;
+    };
+    const reportOnce = (node, messageId) => {
+      context.report({
+        node,
+        messageId
+      });
+    };
+    const walkPattern = (pattern, depth) => {
+      if (!pattern) return;
+      if (pattern.type === "ObjectPattern") {
+        for (const prop of pattern.properties ?? []) {
+          if (prop.type === "RestElement") {
+            if (depth > 0) {
+              reportOnce(prop, "nestedRest");
+            }
+            continue;
+          }
+          if (prop.type !== "Property") {
+            reportOnce(prop, "fallback");
+            continue;
+          }
+          if (prop.computed) {
+            reportOnce(prop, "computedKey");
+            continue;
+          }
+          const value = prop.value;
+          if (value.type === "Identifier") {
+            continue;
+          }
+          if (value.type === "AssignmentPattern" && value.left?.type === "Identifier") {
+            continue;
+          }
+          if (value.type === "ObjectPattern") {
+            walkPattern(value, depth + 1);
+            continue;
+          }
+          if (value.type === "ArrayPattern") {
+            const hasRest = (value.elements ?? []).some((el) => el?.type === "RestElement");
+            reportOnce(value, hasRest ? "arrayRest" : "fallback");
+            continue;
+          }
+          reportOnce(value, "fallback");
+        }
+        return;
+      }
+      if (pattern.type === "ArrayPattern") {
+        reportOnce(pattern, "fallback");
+      }
+    };
+    return {
+      FunctionDeclaration(node) {
+        if (!node.id?.name || !isComponentName(node.id.name)) return;
+        const pattern = getPropsPattern(node);
+        if (pattern) walkPattern(pattern, 0);
+      },
+      VariableDeclarator(node) {
+        if (!node.id || node.id.type !== "Identifier" || !isComponentName(node.id.name)) return;
+        if (!node.init) return;
+        if (node.init.type !== "ArrowFunctionExpression" && node.init.type !== "FunctionExpression") {
+          return;
+        }
+        const pattern = getPropsPattern(node.init);
+        if (pattern) walkPattern(pattern, 0);
+      }
+    };
+  }
+};
+var no_unsupported_props_destructure_default = rule12;
 
 // src/rules/require-component-return.ts
-var rule9 = {
+var rule13 = {
   meta: {
     type: "problem",
     docs: {
@@ -772,10 +1168,10 @@ var rule9 = {
     };
   }
 };
-var require_component_return_default = rule9;
+var require_component_return_default = rule13;
 
 // src/rules/require-list-key.ts
-var rule10 = {
+var rule14 = {
   meta: {
     type: "problem",
     docs: {
@@ -866,7 +1262,7 @@ var rule10 = {
     };
   }
 };
-var require_list_key_default = rule10;
+var require_list_key_default = rule14;
 
 // src/index.ts
 var plugin = {
@@ -878,10 +1274,14 @@ var plugin = {
     "no-state-in-loop": no_state_in_loop_default,
     "no-direct-mutation": no_direct_mutation_default,
     "no-empty-effect": no_empty_effect_default,
+    "no-computed-props-key": no_computed_props_key_default,
     "no-inline-functions": no_inline_functions_default,
     "no-state-destructure-write": no_state_destructure_write_default,
     "no-state-outside-component": no_state_outside_component_default,
     "no-nested-components": no_nested_components_default,
+    "no-third-party-props-spread": no_third_party_props_spread_default,
+    "no-unsafe-props-spread": no_unsafe_props_spread_default,
+    "no-unsupported-props-destructure": no_unsupported_props_destructure_default,
     "require-list-key": require_list_key_default,
     "no-memo-side-effects": no_memo_side_effects_default,
     "require-component-return": require_component_return_default
@@ -894,12 +1294,16 @@ var plugin = {
         "fict/no-direct-mutation": "warn",
         "fict/no-empty-effect": "warn",
         // FICT-E001
+        "fict/no-computed-props-key": "warn",
         "fict/no-inline-functions": "warn",
         // FICT-X003
         "fict/no-state-destructure-write": "error",
         "fict/no-state-outside-component": "error",
         "fict/no-nested-components": "error",
         // FICT-C003
+        "fict/no-third-party-props-spread": "warn",
+        "fict/no-unsafe-props-spread": "warn",
+        "fict/no-unsupported-props-destructure": "warn",
         "fict/require-list-key": "error",
         // FICT-J002
         "fict/no-memo-side-effects": "warn",
@@ -913,6 +1317,7 @@ var plugin = {
 var index_default = plugin;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  noComputedPropsKey,
   noDirectMutation,
   noEmptyEffect,
   noInlineFunctions,
@@ -921,6 +1326,9 @@ var index_default = plugin;
   noStateDestructureWrite,
   noStateInLoop,
   noStateOutsideComponent,
+  noThirdPartyPropsSpread,
+  noUnsafePropsSpread,
+  noUnsupportedPropsDestructure,
   requireComponentReturn,
   requireListKey
 });