@fictjs/eslint-plugin 0.0.2

package/dist/index.cjs

@@ -0,0 +1,815 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  noDirectMutation: () => no_direct_mutation_default,
+  noEmptyEffect: () => no_empty_effect_default,
+  noInlineFunctions: () => no_inline_functions_default,
+  noMemoSideEffects: () => no_memo_side_effects_default,
+  noNestedComponents: () => no_nested_components_default,
+  noStateDestructureWrite: () => no_state_destructure_write_default,
+  noStateInLoop: () => no_state_in_loop_default,
+  requireComponentReturn: () => require_component_return_default,
+  requireListKey: () => require_list_key_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/rules/no-direct-mutation.ts
+var rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Warn against direct mutation of $state objects",
+      recommended: true
+    },
+    messages: {
+      noDirectMutation: "Direct mutation of nested $state properties may not trigger updates. Use spread syntax or $store for deep reactivity."
+    },
+    schema: []
+  },
+  create(context) {
+    const stateVariables = /* @__PURE__ */ new Set();
+    return {
+      VariableDeclarator(node) {
+        if (node.init?.type === "CallExpression" && node.init.callee.type === "Identifier" && node.init.callee.name === "$state" && node.id.type === "Identifier") {
+          stateVariables.add(node.id.name);
+        }
+      },
+      AssignmentExpression(node) {
+        if (node.left.type === "MemberExpression") {
+          const root = getRootIdentifier(node.left);
+          if (root && stateVariables.has(root.name)) {
+            if (isDeepAccess(node.left)) {
+              context.report({
+                node,
+                messageId: "noDirectMutation"
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+function getRootIdentifier(node) {
+  let current = node;
+  while (current.type === "MemberExpression") {
+    current = current.object;
+  }
+  return current.type === "Identifier" ? current : null;
+}
+function isDeepAccess(node) {
+  let depth = 0;
+  let current = node;
+  while (current.type === "MemberExpression") {
+    depth++;
+    current = current.object;
+  }
+  return depth > 1;
+}
+var no_direct_mutation_default = rule;
+
+// src/rules/no-empty-effect.ts
+var rule2 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow $effect bodies that do not read any reactive value (FICT-E001)",
+      recommended: true
+    },
+    messages: {
+      emptyEffect: "$effect should reference at least one reactive value (FICT-E001)."
+    },
+    schema: []
+  },
+  create(context) {
+    const builtinIgnore = /* @__PURE__ */ new Set([
+      "console",
+      "Math",
+      "Date",
+      "JSON",
+      "Number",
+      "String",
+      "Boolean",
+      "Symbol",
+      "BigInt",
+      "Reflect",
+      "RegExp"
+    ]);
+    const collectLocals = (node, locals) => {
+      if (!node || node.type !== "BlockStatement") return;
+      for (const stmt of node.body) {
+        if (stmt.type === "VariableDeclaration") {
+          for (const decl of stmt.declarations) {
+            if (decl.id.type === "Identifier") {
+              locals.add(decl.id.name);
+            } else if (decl.id.type === "ObjectPattern" || decl.id.type === "ArrayPattern") {
+              const visit = (p) => {
+                if (!p) return;
+                if (p.type === "Identifier") {
+                  locals.add(p.name);
+                } else if (p.type === "RestElement") {
+                  visit(p.argument);
+                } else if (p.type === "ObjectPattern") {
+                  for (const prop of p.properties) {
+                    if (prop.type === "Property") {
+                      visit(prop.value);
+                    } else if (prop.type === "RestElement") {
+                      visit(prop.argument);
+                    }
+                  }
+                } else if (p.type === "ArrayPattern") {
+                  p.elements.forEach(visit);
+                }
+              };
+              visit(decl.id);
+            }
+          }
+        }
+        if (stmt.type === "FunctionDeclaration" && stmt.id?.name) {
+          locals.add(stmt.id.name);
+        }
+      }
+    };
+    const hasOuterReference = (node, locals) => {
+      let found = false;
+      const visit = (n) => {
+        if (found) return;
+        if (!n) return;
+        if (n.type === "FunctionDeclaration" || n.type === "FunctionExpression" || n.type === "ArrowFunctionExpression") {
+          return;
+        }
+        if (n.type === "Identifier") {
+          if (!locals.has(n.name) && !builtinIgnore.has(n.name)) {
+            found = true;
+          }
+          return;
+        }
+        if (n.type === "MemberExpression") {
+          visit(n.object);
+          if (n.computed) {
+            visit(n.property);
+          }
+          return;
+        }
+        for (const key of Object.keys(n)) {
+          if (key === "parent") continue;
+          const value = n[key];
+          if (!value) continue;
+          if (Array.isArray(value)) {
+            for (const child of value) {
+              if (child && typeof child.type === "string") visit(child);
+            }
+          } else if (value && typeof value.type === "string") {
+            visit(value);
+          }
+        }
+      };
+      visit(node);
+      return found;
+    };
+    return {
+      CallExpression(node) {
+        if (node.callee.type === "Identifier" && node.callee.name === "$effect") {
+          const firstArg = node.arguments[0];
+          if (firstArg && (firstArg.type === "ArrowFunctionExpression" || firstArg.type === "FunctionExpression")) {
+            if (firstArg.body.type !== "BlockStatement") {
+              return;
+            }
+            const block = firstArg.body;
+            if (block.body.length === 0) {
+              context.report({ node, messageId: "emptyEffect" });
+              return;
+            }
+            const locals = /* @__PURE__ */ new Set();
+            firstArg.params.forEach((param) => {
+              if (param.type === "Identifier") locals.add(param.name);
+            });
+            collectLocals(block, locals);
+            if (!hasOuterReference(block, locals)) {
+              context.report({ node, messageId: "emptyEffect" });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+var no_empty_effect_default = rule2;
+
+// src/rules/no-inline-functions.ts
+var rule3 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow inline function definitions in JSX props that may cause unnecessary re-renders",
+      recommended: true
+    },
+    messages: {
+      // Message matches DiagnosticCode.FICT_X003
+      inlineFunction: "Inline function in JSX props may cause unnecessary re-renders. Consider memoizing with $memo or moving outside the render."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowEventHandlers: {
+            type: "boolean",
+            description: "Allow inline functions for event handlers (onClick, onChange, etc.)"
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    const allowEventHandlers = options.allowEventHandlers ?? true;
+    const eventHandlerPattern = /^on[A-Z]/;
+    return {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- JSX node type not available in base ESLint types
+      JSXAttribute(node) {
+        if (node.value && node.value.type === "JSXExpressionContainer" && node.value.expression.type !== "JSXEmptyExpression") {
+          const expr = node.value.expression;
+          if (expr.type === "ArrowFunctionExpression" || expr.type === "FunctionExpression") {
+            if (allowEventHandlers && node.name.type === "JSXIdentifier") {
+              const attrName = node.name.name;
+              if (eventHandlerPattern.test(attrName)) {
+                return;
+              }
+            }
+            context.report({
+              node: expr,
+              messageId: "inlineFunction"
+            });
+          }
+        }
+      }
+    };
+  }
+};
+var no_inline_functions_default = rule3;
+
+// src/rules/no-memo-side-effects.ts
+var rule4 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow obvious side effects inside $memo callbacks (FICT-M003)",
+      recommended: true
+    },
+    messages: {
+      sideEffectInMemo: "Avoid side effects inside $memo. Move mutations/effects outside or wrap them in $effect (FICT-M003)."
+    },
+    schema: []
+  },
+  create(context) {
+    const hasSideEffect = (node) => {
+      let found = false;
+      const visit = (n) => {
+        if (found) return;
+        if (n.type === "AssignmentExpression" || n.type === "UpdateExpression") {
+          found = true;
+          return;
+        }
+        if (n.type === "CallExpression") {
+          if (n.callee.type === "Identifier" && n.callee.name === "$effect") {
+            found = true;
+            return;
+          }
+        }
+        if (n.type === "FunctionDeclaration" || n.type === "FunctionExpression" || n.type === "ArrowFunctionExpression") {
+          return;
+        }
+        for (const key of Object.keys(n)) {
+          if (key === "parent") continue;
+          const value = n[key];
+          if (!value) continue;
+          if (Array.isArray(value)) {
+            for (const child of value) {
+              if (child && typeof child.type === "string") visit(child);
+            }
+          } else if (value && typeof value.type === "string") {
+            visit(value);
+          }
+        }
+      };
+      visit(node);
+      return found;
+    };
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier" || node.callee.name !== "$memo") return;
+        const first = node.arguments[0];
+        if (first && (first.type === "ArrowFunctionExpression" || first.type === "FunctionExpression")) {
+          const body = first.type === "ArrowFunctionExpression" && first.body.type !== "BlockStatement" ? first.body : first.body;
+          if (hasSideEffect(body)) {
+            context.report({ node, messageId: "sideEffectInMemo" });
+          }
+        }
+      }
+    };
+  }
+};
+var no_memo_side_effects_default = rule4;
+
+// src/rules/no-nested-components.ts
+var rule5 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow defining components inside other components (FICT-C003)",
+      recommended: true
+    },
+    messages: {
+      nestedComponent: "Do not define a component inside another component. Move {{name}} to module scope to avoid recreating it on every render."
+    },
+    schema: []
+  },
+  create(context) {
+    const componentStack = [];
+    const isUpperCaseName = (name) => !!name && /^[A-Z]/.test(name);
+    const getFunctionName = (node) => {
+      if (node.id?.name) {
+        return node.id.name;
+      }
+      const parent = node.parent;
+      if (parent?.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+        return parent.id.name;
+      }
+      return void 0;
+    };
+    const hasJSX = (node) => {
+      let found = false;
+      const visit = (n) => {
+        if (found) return;
+        const t = n.type;
+        if (t === "JSXElement" || t === "JSXFragment") {
+          found = true;
+          return;
+        }
+        if (n.type === "FunctionDeclaration" || n.type === "FunctionExpression" || n.type === "ArrowFunctionExpression") {
+          return;
+        }
+        for (const key of Object.keys(n)) {
+          if (key === "parent") continue;
+          const value = n[key];
+          if (!value) continue;
+          if (Array.isArray(value)) {
+            for (const child of value) {
+              if (child && typeof child.type === "string") visit(child);
+            }
+          } else if (value && typeof value.type === "string") {
+            visit(value);
+          }
+        }
+      };
+      visit(node);
+      return found;
+    };
+    const isComponentLike = (node) => {
+      const name = getFunctionName(node);
+      if (isUpperCaseName(name)) return true;
+      if (node.type === "ArrowFunctionExpression" && node.body) {
+        const bodyType = node.body.type;
+        if (bodyType === "JSXElement" || bodyType === "JSXFragment") return true;
+        if (bodyType === "BlockStatement" && hasJSX(node.body)) return true;
+      }
+      if (node.type !== "ArrowFunctionExpression" && node.body && hasJSX(node.body))
+        return true;
+      return false;
+    };
+    const enterFunction = (node) => {
+      const parentIsComponent = componentStack[componentStack.length - 1] ?? false;
+      const currentIsComponent = isComponentLike(node);
+      if (parentIsComponent && currentIsComponent) {
+        const name = getFunctionName(node) ?? "this component";
+        context.report({
+          node,
+          messageId: "nestedComponent",
+          data: { name }
+        });
+      }
+      componentStack.push(parentIsComponent || currentIsComponent);
+    };
+    const exitFunction = () => {
+      componentStack.pop();
+    };
+    return {
+      FunctionDeclaration: enterFunction,
+      "FunctionDeclaration:exit": exitFunction,
+      FunctionExpression: enterFunction,
+      "FunctionExpression:exit": exitFunction,
+      ArrowFunctionExpression: enterFunction,
+      "ArrowFunctionExpression:exit": exitFunction
+    };
+  }
+};
+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;
+
+// src/rules/no-state-destructure-write.ts
+var rule7 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow writing to destructured aliases from $state; write via the original state instead.",
+      recommended: true
+    },
+    messages: {
+      noWrite: "Do not write to '{name}' (destructured from $state). Update via the original state object (e.g. state.count++ or immutable update)."
+    },
+    schema: []
+  },
+  create(context) {
+    const stateVars = /* @__PURE__ */ new Set();
+    const destructuredAliases = /* @__PURE__ */ new Set();
+    const collectIds = (pattern) => {
+      const ids = [];
+      const visit = (p) => {
+        if (p.type === "Identifier") {
+          ids.push(p);
+          return;
+        }
+        if (p.type === "RestElement") {
+          visit(p.argument);
+          return;
+        }
+        if (p.type === "ObjectPattern") {
+          for (const prop of p.properties) {
+            if (prop.type === "Property") {
+              if (prop.value.type === "Identifier") {
+                ids.push(prop.value);
+              } else {
+                visit(prop.value);
+              }
+            } else if (prop.type === "RestElement") {
+              visit(prop.argument);
+            }
+          }
+          return;
+        }
+        if (p.type === "ArrayPattern") {
+          for (const el of p.elements) {
+            if (!el) continue;
+            visit(el);
+          }
+        }
+      };
+      visit(pattern);
+      return ids;
+    };
+    const markDestructure = (node) => {
+      if (!node.id || node.id.type !== "ObjectPattern" && node.id.type !== "ArrayPattern") return;
+      const init = node.init;
+      if (!init) return;
+      if (init.type === "Identifier" && stateVars.has(init.name)) {
+        collectIds(node.id).forEach((id) => destructuredAliases.add(id.name));
+      }
+    };
+    const isAliasWrite = (name) => destructuredAliases.has(name);
+    return {
+      VariableDeclarator(node) {
+        if (node.init?.type === "CallExpression" && node.init.callee.type === "Identifier" && node.init.callee.name === "$state" && node.id.type === "Identifier") {
+          stateVars.add(node.id.name);
+        }
+        markDestructure(node);
+      },
+      AssignmentExpression(node) {
+        if (node.left.type === "Identifier" && isAliasWrite(node.left.name)) {
+          context.report({
+            node,
+            messageId: "noWrite",
+            data: { name: node.left.name }
+          });
+        }
+      },
+      UpdateExpression(node) {
+        if (node.argument.type === "Identifier" && isAliasWrite(node.argument.name)) {
+          context.report({
+            node,
+            messageId: "noWrite",
+            data: { name: node.argument.name }
+          });
+        }
+      }
+    };
+  }
+};
+var no_state_destructure_write_default = rule7;
+
+// src/rules/require-component-return.ts
+var rule8 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require component functions to return a value (FICT-C004)",
+      recommended: true
+    },
+    messages: {
+      missingReturn: "Component should return JSX or null/undefined (FICT-C004)."
+    },
+    schema: []
+  },
+  create(context) {
+    const isUpperCaseName = (name) => !!name && /^[A-Z]/.test(name);
+    const getFunctionName = (node) => {
+      if (node.id?.name) {
+        return node.id.name;
+      }
+      const parent = node.parent;
+      if (parent?.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+        return parent.id.name;
+      }
+      return void 0;
+    };
+    const hasReturn = (node) => {
+      const visit = (n) => {
+        switch (n.type) {
+          case "ReturnStatement":
+            return true;
+          case "BlockStatement":
+            return n.body.some((stmt) => visit(stmt));
+          case "IfStatement":
+            return visit(n.consequent) || !!n.alternate && visit(n.alternate);
+          case "SwitchStatement":
+            return n.cases.some((c) => c.consequent.some(visit));
+          case "WhileStatement":
+          case "DoWhileStatement":
+          case "ForStatement":
+          case "ForInStatement":
+          case "ForOfStatement":
+            return visit(n.body);
+          case "TryStatement": {
+            const t = n;
+            return t.block && visit(t.block) || !!t.handler && visit(t.handler.body) || !!t.finalizer && visit(t.finalizer);
+          }
+          default:
+            if (n.type === "FunctionDeclaration" || n.type === "FunctionExpression" || n.type === "ArrowFunctionExpression" || n.type === "ClassDeclaration" || n.type === "ClassExpression") {
+              return false;
+            }
+            for (const key of Object.keys(n)) {
+              if (key === "parent") continue;
+              const value = n[key];
+              if (!value) continue;
+              if (Array.isArray(value)) {
+                if (value.some((child) => child && typeof child.type === "string" && visit(child))) {
+                  return true;
+                }
+              } else if (value && typeof value.type === "string") {
+                if (visit(value)) return true;
+              }
+            }
+            return false;
+        }
+      };
+      return visit(node);
+    };
+    const enter = (node) => {
+      const name = getFunctionName(node);
+      const isComponent = isUpperCaseName(name);
+      if (!isComponent) return;
+      if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+        return;
+      }
+      const body = node.type === "ArrowFunctionExpression" ? node.body : node.body;
+      if (body && body.type === "BlockStatement" && !hasReturn(body)) {
+        context.report({
+          node,
+          messageId: "missingReturn"
+        });
+      }
+    };
+    return {
+      FunctionDeclaration: enter,
+      FunctionExpression: enter,
+      ArrowFunctionExpression: enter
+    };
+  }
+};
+var require_component_return_default = rule8;
+
+// src/rules/require-list-key.ts
+var rule9 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require key on elements returned from Array.prototype.map in JSX (FICT-J002)",
+      recommended: true
+    },
+    messages: {
+      missingKey: "Elements returned from map() in JSX should have a stable key (FICT-J002). Add key={...}."
+    },
+    schema: []
+  },
+  create(context) {
+    const hasKeyAttribute = (node) => {
+      if (node.type === "JSXFragment") {
+        return false;
+      }
+      if (node.type !== "JSXElement") return false;
+      return (node.openingElement?.attributes ?? []).some((attr) => {
+        if (!attr || attr.type !== "JSXAttribute") return false;
+        return attr.name?.name === "key";
+      });
+    };
+    const collectReturnedJSX = (expr, out) => {
+      const target = expr.type === "ReturnStatement" ? expr.argument ?? void 0 : expr;
+      if (!target) return;
+      const t = target.type;
+      if (t === "JSXElement" || t === "JSXFragment") {
+        out.push(target);
+        return;
+      }
+      if (t === "ArrayExpression") {
+        for (const el of target.elements) {
+          if (!el || el.type === "SpreadElement") continue;
+          collectReturnedJSX(el, out);
+        }
+      }
+      if (t === "ConditionalExpression") {
+        collectReturnedJSX(target.consequent, out);
+        collectReturnedJSX(target.alternate, out);
+      }
+      if (t === "LogicalExpression") {
+        collectReturnedJSX(target.right, out);
+      }
+    };
+    const mapReturnsJSXWithoutKey = (call) => {
+      const callback = call.arguments[0];
+      if (!callback) return null;
+      if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression") {
+        return null;
+      }
+      const returned = [];
+      if (callback.type === "ArrowFunctionExpression") {
+        const body = callback.body;
+        const bodyType = body.type;
+        if (bodyType === "JSXElement" || bodyType === "JSXFragment") {
+          returned.push(body);
+        } else if (bodyType === "BlockStatement") {
+          for (const stmt of body.body) {
+            if (stmt.type === "ReturnStatement") {
+              collectReturnedJSX(stmt, returned);
+            }
+          }
+        } else {
+          collectReturnedJSX(body, returned);
+        }
+      } else {
+        for (const stmt of callback.body.body) {
+          if (stmt.type === "ReturnStatement") {
+            collectReturnedJSX(stmt, returned);
+          }
+        }
+      }
+      const missing = returned.find((node) => !hasKeyAttribute(node));
+      return missing ?? null;
+    };
+    return {
+      CallExpression(node) {
+        if (node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier" && node.callee.property.name === "map") {
+          const offending = mapReturnsJSXWithoutKey(node);
+          if (offending) {
+            context.report({
+              node: offending,
+              messageId: "missingKey"
+            });
+          }
+        }
+      }
+    };
+  }
+};
+var require_list_key_default = rule9;
+
+// src/index.ts
+var plugin = {
+  meta: {
+    name: "eslint-plugin-fict",
+    version: "0.0.1"
+  },
+  rules: {
+    "no-state-in-loop": no_state_in_loop_default,
+    "no-direct-mutation": no_direct_mutation_default,
+    "no-empty-effect": no_empty_effect_default,
+    "no-inline-functions": no_inline_functions_default,
+    "no-state-destructure-write": no_state_destructure_write_default,
+    "no-nested-components": no_nested_components_default,
+    "require-list-key": require_list_key_default,
+    "no-memo-side-effects": no_memo_side_effects_default,
+    "require-component-return": require_component_return_default
+  },
+  configs: {
+    recommended: {
+      plugins: ["fict"],
+      rules: {
+        "fict/no-state-in-loop": "error",
+        "fict/no-direct-mutation": "warn",
+        "fict/no-empty-effect": "warn",
+        // FICT-E001
+        "fict/no-inline-functions": "warn",
+        // FICT-X003
+        "fict/no-state-destructure-write": "error",
+        "fict/no-nested-components": "error",
+        // FICT-C003
+        "fict/require-list-key": "error",
+        // FICT-J002
+        "fict/no-memo-side-effects": "warn",
+        // FICT-M003
+        "fict/require-component-return": "warn"
+        // FICT-C004
+      }
+    }
+  }
+};
+var index_default = plugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  noDirectMutation,
+  noEmptyEffect,
+  noInlineFunctions,
+  noMemoSideEffects,
+  noNestedComponents,
+  noStateDestructureWrite,
+  noStateInLoop,
+  requireComponentReturn,
+  requireListKey
+});