@slip-stream-kit/eslint-plugin 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import type { ESLint, Linter } from 'eslint';
+import { rules } from './rules';
+declare const plugin: ESLint.Plugin & {
+    configs: Record<string, Linter.Config>;
+};
+export declare const meta: ESLint.Plugin['meta'];
+export declare const configs: Record<string, Linter.Config>;
+export { rules };
+export default plugin;

package/dist/index.js

@@ -0,0 +1,434 @@
+// src/utils/component.ts
+var COMPONENT_WRAPPER_CALLEES = /* @__PURE__ */ new Set(["memo", "forwardRef", "observer", "React.memo", "React.forwardRef"]);
+var NESTED_SCOPES = /* @__PURE__ */ new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+var isPascalCase = (name) => {
+  return /^[A-Z]/.test(name);
+};
+var isJsxNode = (node) => {
+  if (!node) {
+    return false;
+  }
+  const type = node.type;
+  return type === "JSXElement" || type === "JSXFragment";
+};
+var getParent = (node) => {
+  return node?.parent;
+};
+var getCalleeName = (callee) => {
+  if (callee.type === "Identifier") {
+    return callee.name;
+  }
+  if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.property.type === "Identifier") {
+    return `${callee.object.name}.${callee.property.name}`;
+  }
+  return null;
+};
+var getComponentName = (node) => {
+  if (node.type === "FunctionDeclaration") {
+    return node.id?.name ?? null;
+  }
+  let current = getParent(node);
+  while (current?.type === "CallExpression") {
+    const calleeName = getCalleeName(current.callee);
+    if (!calleeName || !COMPONENT_WRAPPER_CALLEES.has(calleeName)) {
+      break;
+    }
+    current = getParent(current);
+  }
+  if (current?.type === "VariableDeclarator" && current.id.type === "Identifier") {
+    return current.id.name;
+  }
+  return null;
+};
+var returnsJsx = (node) => {
+  if (node.body.type !== "BlockStatement") {
+    return isJsxNode(node.body);
+  }
+  let found = false;
+  const visit = (current) => {
+    if (found || !current || NESTED_SCOPES.has(current.type)) {
+      return;
+    }
+    if (current.type === "ReturnStatement") {
+      if (isJsxNode(current.argument)) {
+        found = true;
+      }
+      return;
+    }
+    if (current.type === "IfStatement") {
+      visit(current.consequent);
+      visit(current.alternate);
+      return;
+    }
+    if (current.type === "BlockStatement") {
+      current.body.forEach(visit);
+      return;
+    }
+    if (current.type === "SwitchStatement") {
+      for (const switchCase of current.cases) {
+        switchCase.consequent.forEach(visit);
+      }
+      return;
+    }
+    if (current.type === "TryStatement") {
+      visit(current.block);
+      visit(current.handler?.body);
+      visit(current.finalizer);
+      return;
+    }
+    if (current.type === "ForStatement" || current.type === "ForInStatement" || current.type === "ForOfStatement" || current.type === "WhileStatement" || current.type === "DoWhileStatement") {
+      visit(current.body);
+    }
+  };
+  node.body.body.forEach(visit);
+  return found;
+};
+var isComponent = (node) => {
+  const name = getComponentName(node);
+  if (name && isPascalCase(name)) {
+    return true;
+  }
+  return returnsJsx(node);
+};
+var isComponentFunctionNode = (node) => {
+  return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration";
+};
+var getComponentFunction = (node) => {
+  if (!node) {
+    return null;
+  }
+  if (isComponentFunctionNode(node)) {
+    return node;
+  }
+  if (node.type === "CallExpression") {
+    for (const argument of node.arguments) {
+      if (argument.type === "SpreadElement") {
+        continue;
+      }
+      const found = getComponentFunction(argument);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+};
+
+// src/utils/path-match.ts
+var REGEX_METACHARS = /* @__PURE__ */ new Set(["\\", "^", "$", ".", "|", "+", "(", ")", "[", "]", "{", "}"]);
+var globToRegExp = (glob) => {
+  let source = "";
+  for (let index = 0; index < glob.length; index++) {
+    const char = glob[index];
+    if (char === "*") {
+      if (glob[index + 1] === "*") {
+        source += ".*";
+        index++;
+        if (glob[index + 1] === "/") {
+          index++;
+        }
+      } else {
+        source += "[^/]*";
+      }
+    } else if (char === "?") {
+      source += "[^/]";
+    } else if (REGEX_METACHARS.has(char)) {
+      source += `\\${char}`;
+    } else {
+      source += char;
+    }
+  }
+  return new RegExp(source);
+};
+var matchesAnyGlob = (filename, patterns) => {
+  const normalized = filename.split("\\").join("/");
+  return patterns.some((pattern) => {
+    return globToRegExp(pattern).test(normalized);
+  });
+};
+
+// src/rules/component-file-order.ts
+var PROPS_SUFFIX = "Props";
+var unwrapExport = (statement) => {
+  if (statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration") {
+    return statement.declaration ?? null;
+  }
+  return statement;
+};
+var isPropsTypeDeclaration = (node) => {
+  if (!node) {
+    return false;
+  }
+  const named = node;
+  if (named.type !== "TSInterfaceDeclaration" && named.type !== "TSTypeAliasDeclaration") {
+    return false;
+  }
+  return named.id?.name?.endsWith(PROPS_SUFFIX) ?? false;
+};
+var declaresComponent = (node) => {
+  if (!node) {
+    return false;
+  }
+  if (node.type === "FunctionDeclaration") {
+    return isComponent(node);
+  }
+  if (node.type === "VariableDeclaration") {
+    return node.declarations.some((declaration) => {
+      const fn2 = getComponentFunction(declaration.init);
+      return fn2 ? isComponent(fn2) : false;
+    });
+  }
+  const fn = getComponentFunction(node);
+  return fn ? isComponent(fn) : false;
+};
+var componentFileOrder = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce a strict top-level order in React component files: imports first, then the component props interface/type, then the component declaration.",
+      recommended: true,
+      url: "https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          paths: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional glob patterns. When provided, the rule only runs for files whose path matches one of them."
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      importsFirst: "Imports must come before the component interface and declaration.",
+      interfaceBeforeComponent: "The component props interface must be declared before the component."
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const paths = options.paths ?? [];
+    if (paths.length > 0 && !matchesAnyGlob(context.filename, paths)) {
+      return {};
+    }
+    return {
+      Program(program) {
+        const body = program.body;
+        const importIndices = [];
+        const propsIndices = [];
+        let componentIndex = -1;
+        body.forEach((statement, index) => {
+          if (statement.type === "ImportDeclaration") {
+            importIndices.push(index);
+            return;
+          }
+          const declaration = unwrapExport(statement);
+          if (isPropsTypeDeclaration(declaration)) {
+            propsIndices.push(index);
+          }
+          if (componentIndex === -1 && declaresComponent(declaration)) {
+            componentIndex = index;
+          }
+        });
+        if (componentIndex === -1) {
+          return;
+        }
+        const importBoundary = Math.min(componentIndex, ...propsIndices);
+        for (const importIndex of importIndices) {
+          if (importIndex > importBoundary) {
+            context.report({ node: body[importIndex], messageId: "importsFirst" });
+          }
+        }
+        for (const propsIndex of propsIndices) {
+          if (propsIndex > componentIndex) {
+            context.report({ node: body[propsIndex], messageId: "interfaceBeforeComponent" });
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/rules/props-destructuring-blank-line.ts
+var isPropsDestructuring = (statement) => {
+  if (statement.type !== "VariableDeclaration") {
+    return false;
+  }
+  return statement.declarations.some((declaration) => {
+    return declaration.id.type === "ObjectPattern" && declaration.init?.type === "Identifier" && declaration.init.name === "props";
+  });
+};
+var propsDestructuringBlankLine = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require a blank line after the `const { ... } = props` destructuring statement at the top of a React component body.",
+      recommended: true,
+      url: "https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin"
+    },
+    fixable: "whitespace",
+    schema: [],
+    messages: {
+      blankLineAfterProps: "Add a blank line after destructuring props."
+    }
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const check = (node) => {
+      if (node.body.type !== "BlockStatement") {
+        return;
+      }
+      if (!isComponent(node)) {
+        return;
+      }
+      const statements = node.body.body;
+      const index = statements.findIndex(isPropsDestructuring);
+      if (index === -1) {
+        return;
+      }
+      const propsStatement = statements[index];
+      const nextStatement = statements[index + 1];
+      if (!propsStatement || !nextStatement) {
+        return;
+      }
+      const tokenAfter = sourceCode.getTokenAfter(propsStatement, { includeComments: true });
+      const referenceLine = (tokenAfter ?? nextStatement).loc.start.line;
+      if (referenceLine - propsStatement.loc.end.line >= 2) {
+        return;
+      }
+      context.report({
+        node: propsStatement,
+        messageId: "blankLineAfterProps",
+        fix(fixer) {
+          return fixer.insertTextAfter(propsStatement, "\n");
+        }
+      });
+    };
+    return {
+      ArrowFunctionExpression: check,
+      FunctionDeclaration: check,
+      FunctionExpression: check
+    };
+  }
+};
+
+// src/rules/props-destructuring-newline.ts
+var propsDestructuringNewline = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require React components to accept a single props parameter and destructure it on its own line in the body, rather than destructuring inline in the parameter list.",
+      recommended: true,
+      url: "https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      destructureOnNewLine: "Accept a single `props` parameter and destructure it on its own line in the component body instead of destructuring in the parameter list."
+    }
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const check = (node) => {
+      const firstParam = node.params[0];
+      if (!firstParam || firstParam.type !== "ObjectPattern") {
+        return;
+      }
+      if (!isComponent(node)) {
+        return;
+      }
+      const objectPattern = firstParam;
+      context.report({
+        node: firstParam,
+        messageId: "destructureOnNewLine",
+        fix(fixer) {
+          const text = sourceCode.getText();
+          const annotation = objectPattern.typeAnnotation;
+          const patternStart = objectPattern.range[0];
+          const patternEnd = annotation ? annotation.range[0] : objectPattern.range[1];
+          const fullEnd = annotation ? annotation.range[1] : objectPattern.range[1];
+          const patternText = text.slice(patternStart, patternEnd).trim();
+          const annotationText = annotation ? sourceCode.getText(annotation) : "";
+          const fixes = [fixer.replaceTextRange([patternStart, fullEnd], `props${annotationText}`)];
+          const destructureStatement = `const ${patternText} = props`;
+          const lines = sourceCode.getLines();
+          const declarationLine = lines[node.loc.start.line - 1] ?? "";
+          const baseIndent = declarationLine.slice(0, declarationLine.length - declarationLine.trimStart().length);
+          const innerIndent = `${baseIndent}  `;
+          if (node.body.type === "BlockStatement") {
+            const [firstStatement] = node.body.body;
+            if (firstStatement) {
+              const indent = " ".repeat(firstStatement.loc.start.column);
+              fixes.push(fixer.insertTextBefore(firstStatement, `${destructureStatement}
+
+${indent}`));
+            } else {
+              const openBrace = sourceCode.getFirstToken(node.body);
+              fixes.push(fixer.insertTextAfter(openBrace, `
+${innerIndent}${destructureStatement}
+${baseIndent}`));
+            }
+            return fixes;
+          }
+          const bodyText = sourceCode.getText(node.body);
+          fixes.push(
+            fixer.replaceText(
+              node.body,
+              `{
+${innerIndent}${destructureStatement}
+
+${innerIndent}return ${bodyText}
+${baseIndent}}`
+            )
+          );
+          return fixes;
+        }
+      });
+    };
+    return {
+      ArrowFunctionExpression: check,
+      FunctionDeclaration: check,
+      FunctionExpression: check
+    };
+  }
+};
+
+// src/rules/index.ts
+var rules = {
+  "props-destructuring-newline": propsDestructuringNewline,
+  "props-destructuring-blank-line": propsDestructuringBlankLine,
+  "component-file-order": componentFileOrder
+};
+
+// src/index.ts
+var PLUGIN_NAME = "@wl";
+var plugin = {
+  meta: {
+    name: "@wl/eslint-plugin",
+    version: "0.1.0"
+  },
+  rules,
+  configs: {}
+};
+plugin.configs.recommended = {
+  plugins: {
+    [PLUGIN_NAME]: plugin
+  },
+  rules: {
+    [`${PLUGIN_NAME}/props-destructuring-newline`]: "error",
+    [`${PLUGIN_NAME}/props-destructuring-blank-line`]: "error",
+    [`${PLUGIN_NAME}/component-file-order`]: "error"
+  }
+};
+var meta = plugin.meta;
+var configs = plugin.configs;
+var index_default = plugin;
+export {
+  configs,
+  index_default as default,
+  meta,
+  rules
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/utils/component.ts", "../src/utils/path-match.ts", "../src/rules/component-file-order.ts", "../src/rules/props-destructuring-blank-line.ts", "../src/rules/props-destructuring-newline.ts", "../src/rules/index.ts", "../src/index.ts"],
+  "sourcesContent": ["import type * as ESTree from 'estree'\n\nexport type ComponentFunction = ESTree.ArrowFunctionExpression | ESTree.FunctionDeclaration | ESTree.FunctionExpression\n\n// Minimal structural view over the `parent` back-reference ESLint adds to every node.\ninterface WithParent {\n  parent?: ESTree.Node\n}\n\n// Calls that wrap a component while preserving its identity (memo, forwardRef, observer, ...).\nconst COMPONENT_WRAPPER_CALLEES = new Set(['memo', 'forwardRef', 'observer', 'React.memo', 'React.forwardRef'])\n\n// Node types that introduce a new function scope \u2014 their returns are not the outer component's.\nconst NESTED_SCOPES = new Set(['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'])\n\nconst isPascalCase = (name: string): boolean => {\n  return /^[A-Z]/.test(name)\n}\n\nconst isJsxNode = (node: ESTree.Node | null | undefined): boolean => {\n  if (!node) {\n    return false\n  }\n\n  const type = node.type as string\n\n  return type === 'JSXElement' || type === 'JSXFragment'\n}\n\nconst getParent = (node: ESTree.Node | undefined): ESTree.Node | undefined => {\n  return (node as (WithParent & ESTree.Node) | undefined)?.parent\n}\n\n/** Best-effort name of a call's callee: `memo` for `memo(...)`, `React.memo` for `React.memo(...)`. */\nconst getCalleeName = (callee: ESTree.CallExpression['callee']): string | null => {\n  if (callee.type === 'Identifier') {\n    return callee.name\n  }\n\n  if (\n    callee.type === 'MemberExpression' &&\n    callee.object.type === 'Identifier' &&\n    callee.property.type === 'Identifier'\n  ) {\n    return `${callee.object.name}.${callee.property.name}`\n  }\n\n  return null\n}\n\n/**\n * Resolve the declared name of a function, looking through component wrappers\n * such as `memo`/`forwardRef` so that `const Comp = memo(({ a }) => ...)` is\n * still recognised by its PascalCase variable name.\n */\nconst getComponentName = (node: ComponentFunction): string | null => {\n  if (node.type === 'FunctionDeclaration') {\n    return node.id?.name ?? null\n  }\n\n  let current = getParent(node)\n\n  // Walk through wrapping call expressions (memo, forwardRef, React.memo, ...).\n  while (current?.type === 'CallExpression') {\n    const calleeName = getCalleeName(current.callee)\n\n    if (!calleeName || !COMPONENT_WRAPPER_CALLEES.has(calleeName)) {\n      break\n    }\n\n    current = getParent(current)\n  }\n\n  if (current?.type === 'VariableDeclarator' && current.id.type === 'Identifier') {\n    return current.id.name\n  }\n\n  return null\n}\n\n/** Whether a function returns JSX, scanning its own body without descending into nested functions. */\nconst returnsJsx = (node: ComponentFunction): boolean => {\n  if (node.body.type !== 'BlockStatement') {\n    return isJsxNode(node.body)\n  }\n\n  let found = false\n\n  const visit = (current: ESTree.Node | null | undefined): void => {\n    if (found || !current || NESTED_SCOPES.has(current.type)) {\n      return\n    }\n\n    if (current.type === 'ReturnStatement') {\n      if (isJsxNode(current.argument)) {\n        found = true\n      }\n\n      return\n    }\n\n    if (current.type === 'IfStatement') {\n      visit(current.consequent)\n      visit(current.alternate)\n\n      return\n    }\n\n    if (current.type === 'BlockStatement') {\n      current.body.forEach(visit)\n\n      return\n    }\n\n    if (current.type === 'SwitchStatement') {\n      for (const switchCase of current.cases) {\n        switchCase.consequent.forEach(visit)\n      }\n\n      return\n    }\n\n    if (current.type === 'TryStatement') {\n      visit(current.block)\n      visit(current.handler?.body)\n      visit(current.finalizer)\n\n      return\n    }\n\n    if (\n      current.type === 'ForStatement' ||\n      current.type === 'ForInStatement' ||\n      current.type === 'ForOfStatement' ||\n      current.type === 'WhileStatement' ||\n      current.type === 'DoWhileStatement'\n    ) {\n      visit(current.body)\n    }\n  }\n\n  node.body.body.forEach(visit)\n\n  return found\n}\n\n/** A function is treated as a React component when it is PascalCase-named or returns JSX. */\nexport const isComponent = (node: ComponentFunction): boolean => {\n  const name = getComponentName(node)\n\n  if (name && isPascalCase(name)) {\n    return true\n  }\n\n  return returnsJsx(node)\n}\n\nconst isComponentFunctionNode = (node: ESTree.Node): node is ComponentFunction => {\n  return (\n    node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration'\n  )\n}\n\n/**\n * Extract the component function from an expression, unwrapping a single layer of\n * component wrappers (`memo(fn)`, `forwardRef(fn)`, `React.memo(fn)`, ...). Returns\n * null when no function is found.\n */\nexport const getComponentFunction = (node: ESTree.Node | null | undefined): ComponentFunction | null => {\n  if (!node) {\n    return null\n  }\n\n  if (isComponentFunctionNode(node)) {\n    return node\n  }\n\n  if (node.type === 'CallExpression') {\n    for (const argument of node.arguments) {\n      if (argument.type === 'SpreadElement') {\n        continue\n      }\n\n      const found = getComponentFunction(argument)\n\n      if (found) {\n        return found\n      }\n    }\n  }\n\n  return null\n}\n", "// Characters that must be escaped when embedded literally into a RegExp source.\nconst REGEX_METACHARS = new Set(['\\\\', '^', '$', '.', '|', '+', '(', ')', '[', ']', '{', '}'])\n\n/**\n * Convert a glob pattern to an (unanchored) RegExp.\n *\n * - `**` matches any characters, including path separators.\n * - `*` matches any characters except a path separator.\n * - `?` matches a single non-separator character.\n *\n * The result is intentionally unanchored so a pattern matches anywhere in the\n * path (e.g. `features/**` matches `/repo/src/features/x/comp.tsx`).\n */\nconst globToRegExp = (glob: string): RegExp => {\n  let source = ''\n\n  for (let index = 0; index < glob.length; index++) {\n    const char = glob[index]!\n\n    if (char === '*') {\n      if (glob[index + 1] === '*') {\n        source += '.*'\n        index++\n\n        // Consume a trailing slash so `**/foo` also matches a bare `foo`.\n        if (glob[index + 1] === '/') {\n          index++\n        }\n      } else {\n        source += '[^/]*'\n      }\n    } else if (char === '?') {\n      source += '[^/]'\n    } else if (REGEX_METACHARS.has(char)) {\n      source += `\\\\${char}`\n    } else {\n      source += char\n    }\n  }\n\n  return new RegExp(source)\n}\n\n/** Whether `filename` matches at least one of the provided glob `patterns`. */\nexport const matchesAnyGlob = (filename: string, patterns: readonly string[]): boolean => {\n  const normalized = filename.split('\\\\').join('/')\n\n  return patterns.some((pattern) => {\n    return globToRegExp(pattern).test(normalized)\n  })\n}\n", "import type { Rule } from 'eslint'\nimport type * as ESTree from 'estree'\n\nimport { getComponentFunction, isComponent } from '../utils/component'\nimport { matchesAnyGlob } from '../utils/path-match'\n\ninterface Options {\n  paths?: string[]\n}\n\n// TS-only nodes are not modelled by estree; access their identifier structurally.\ninterface NamedDeclaration {\n  type: string\n  id?: { name?: string } | null\n}\n\nconst PROPS_SUFFIX = 'Props'\n\n/** Unwrap an `export ...` statement to the declaration it wraps (or the statement itself). */\nconst unwrapExport = (statement: ESTree.Statement | ESTree.ModuleDeclaration): ESTree.Node | null => {\n  if (statement.type === 'ExportNamedDeclaration' || statement.type === 'ExportDefaultDeclaration') {\n    return (statement.declaration as ESTree.Node | null) ?? null\n  }\n\n  return statement\n}\n\n/** Whether a declaration is a props interface/type alias (`SomethingProps`). */\nconst isPropsTypeDeclaration = (node: ESTree.Node | null): boolean => {\n  if (!node) {\n    return false\n  }\n\n  const named = node as NamedDeclaration\n\n  if (named.type !== 'TSInterfaceDeclaration' && named.type !== 'TSTypeAliasDeclaration') {\n    return false\n  }\n\n  return named.id?.name?.endsWith(PROPS_SUFFIX) ?? false\n}\n\n/** Whether a top-level declaration declares a React component. */\nconst declaresComponent = (node: ESTree.Node | null): boolean => {\n  if (!node) {\n    return false\n  }\n\n  if (node.type === 'FunctionDeclaration') {\n    return isComponent(node)\n  }\n\n  if (node.type === 'VariableDeclaration') {\n    return node.declarations.some((declaration) => {\n      const fn = getComponentFunction(declaration.init)\n\n      return fn ? isComponent(fn) : false\n    })\n  }\n\n  const fn = getComponentFunction(node)\n\n  return fn ? isComponent(fn) : false\n}\n\nexport const componentFileOrder: Rule.RuleModule = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description:\n        'Enforce a strict top-level order in React component files: imports first, then the component props interface/type, then the component declaration.',\n      recommended: true,\n      url: 'https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin',\n    },\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          paths: {\n            type: 'array',\n            items: { type: 'string' },\n            description:\n              'Optional glob patterns. When provided, the rule only runs for files whose path matches one of them.',\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n    messages: {\n      importsFirst: 'Imports must come before the component interface and declaration.',\n      interfaceBeforeComponent: 'The component props interface must be declared before the component.',\n    },\n  },\n\n  create(context) {\n    const options = (context.options[0] ?? {}) as Options\n    const paths = options.paths ?? []\n\n    if (paths.length > 0 && !matchesAnyGlob(context.filename, paths)) {\n      return {}\n    }\n\n    return {\n      Program(program) {\n        const body = program.body\n\n        const importIndices: number[] = []\n        const propsIndices: number[] = []\n        let componentIndex = -1\n\n        body.forEach((statement, index) => {\n          if (statement.type === 'ImportDeclaration') {\n            importIndices.push(index)\n\n            return\n          }\n\n          const declaration = unwrapExport(statement)\n\n          if (isPropsTypeDeclaration(declaration)) {\n            propsIndices.push(index)\n          }\n\n          if (componentIndex === -1 && declaresComponent(declaration)) {\n            componentIndex = index\n          }\n        })\n\n        // The rule only governs files that actually contain a component.\n        if (componentIndex === -1) {\n          return\n        }\n\n        // Imports must precede the first props interface and the component.\n        const importBoundary = Math.min(componentIndex, ...propsIndices)\n\n        for (const importIndex of importIndices) {\n          if (importIndex > importBoundary) {\n            context.report({ node: body[importIndex]!, messageId: 'importsFirst' })\n          }\n        }\n\n        // The props interface/type must precede the component declaration.\n        for (const propsIndex of propsIndices) {\n          if (propsIndex > componentIndex) {\n            context.report({ node: body[propsIndex]!, messageId: 'interfaceBeforeComponent' })\n          }\n        }\n      },\n    }\n  },\n}\n\nexport default componentFileOrder\n", "import type { Rule } from 'eslint'\nimport type * as ESTree from 'estree'\n\nimport type { ComponentFunction } from '../utils/component'\nimport { isComponent } from '../utils/component'\n\n/** Whether a statement is `const { ... } = props` (destructuring the `props` identifier). */\nconst isPropsDestructuring = (statement: ESTree.Statement): boolean => {\n  if (statement.type !== 'VariableDeclaration') {\n    return false\n  }\n\n  return statement.declarations.some((declaration) => {\n    return (\n      declaration.id.type === 'ObjectPattern' &&\n      declaration.init?.type === 'Identifier' &&\n      declaration.init.name === 'props'\n    )\n  })\n}\n\nexport const propsDestructuringBlankLine: Rule.RuleModule = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description:\n        'Require a blank line after the `const { ... } = props` destructuring statement at the top of a React component body.',\n      recommended: true,\n      url: 'https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin',\n    },\n    fixable: 'whitespace',\n    schema: [],\n    messages: {\n      blankLineAfterProps: 'Add a blank line after destructuring props.',\n    },\n  },\n\n  create(context) {\n    const sourceCode = context.sourceCode\n\n    const check = (node: ComponentFunction): void => {\n      if (node.body.type !== 'BlockStatement') {\n        return\n      }\n\n      if (!isComponent(node)) {\n        return\n      }\n\n      const statements = node.body.body\n      const index = statements.findIndex(isPropsDestructuring)\n\n      if (index === -1) {\n        return\n      }\n\n      const propsStatement = statements[index]\n      const nextStatement = statements[index + 1]\n\n      // `propsStatement` is defined because `index !== -1`; the guard also narrows the type.\n      // Nothing follows the destructuring \u2014 no separation needed.\n      if (!propsStatement || !nextStatement) {\n        return\n      }\n\n      // The token/comment that follows the destructuring statement; a comment on the\n      // next line still counts as \"no blank line\" until it is pushed down.\n      const tokenAfter = sourceCode.getTokenAfter(propsStatement, { includeComments: true })\n      const referenceLine = (tokenAfter ?? nextStatement).loc!.start.line\n\n      if (referenceLine - propsStatement.loc!.end.line >= 2) {\n        return\n      }\n\n      context.report({\n        node: propsStatement,\n        messageId: 'blankLineAfterProps',\n        fix(fixer) {\n          return fixer.insertTextAfter(propsStatement, '\\n')\n        },\n      })\n    }\n\n    return {\n      ArrowFunctionExpression: check,\n      FunctionDeclaration: check,\n      FunctionExpression: check,\n    }\n  },\n}\n\nexport default propsDestructuringBlankLine\n", "import type { Rule } from 'eslint'\nimport type * as ESTree from 'estree'\n\nimport type { ComponentFunction } from '../utils/component'\nimport { isComponent } from '../utils/component'\n\n// Minimal structural views over nodes that estree's types do not fully model:\n// the optional TS type annotation and `range` that the parser attaches to params.\ninterface WithRange {\n  range?: [number, number]\n}\ntype AnnotatedPattern = ESTree.ObjectPattern & { typeAnnotation?: ESTree.Node & WithRange } & WithRange\n\nexport const propsDestructuringNewline: Rule.RuleModule = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description:\n        'Require React components to accept a single props parameter and destructure it on its own line in the body, rather than destructuring inline in the parameter list.',\n      recommended: true,\n      url: 'https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin',\n    },\n    fixable: 'code',\n    schema: [],\n    messages: {\n      destructureOnNewLine:\n        'Accept a single `props` parameter and destructure it on its own line in the component body instead of destructuring in the parameter list.',\n    },\n  },\n\n  create(context) {\n    const sourceCode = context.sourceCode\n\n    const check = (node: ComponentFunction): void => {\n      const firstParam = node.params[0]\n\n      if (!firstParam || firstParam.type !== 'ObjectPattern') {\n        return\n      }\n\n      if (!isComponent(node)) {\n        return\n      }\n\n      const objectPattern = firstParam as AnnotatedPattern\n\n      context.report({\n        node: firstParam,\n        messageId: 'destructureOnNewLine',\n        fix(fixer) {\n          const text = sourceCode.getText()\n          const annotation = objectPattern.typeAnnotation\n\n          const patternStart = objectPattern.range![0]\n          const patternEnd = annotation ? annotation.range![0] : objectPattern.range![1]\n          const fullEnd = annotation ? annotation.range![1] : objectPattern.range![1]\n\n          const patternText = text.slice(patternStart, patternEnd).trim()\n          const annotationText = annotation ? sourceCode.getText(annotation) : ''\n\n          const fixes = [fixer.replaceTextRange([patternStart, fullEnd], `props${annotationText}`)]\n\n          const destructureStatement = `const ${patternText} = props`\n\n          // Indentation of the line the component is declared on, used as the base for inserted code.\n          const lines = sourceCode.getLines()\n          const declarationLine = lines[node.loc!.start.line - 1] ?? ''\n          const baseIndent = declarationLine.slice(0, declarationLine.length - declarationLine.trimStart().length)\n          const innerIndent = `${baseIndent}  `\n\n          if (node.body.type === 'BlockStatement') {\n            const [firstStatement] = node.body.body\n\n            if (firstStatement) {\n              const indent = ' '.repeat(firstStatement.loc!.start.column)\n\n              fixes.push(fixer.insertTextBefore(firstStatement, `${destructureStatement}\\n\\n${indent}`))\n            } else {\n              const openBrace = sourceCode.getFirstToken(node.body)!\n\n              fixes.push(fixer.insertTextAfter(openBrace, `\\n${innerIndent}${destructureStatement}\\n${baseIndent}`))\n            }\n\n            return fixes\n          }\n\n          // Expression-bodied arrow (implicit return) \u2014 wrap it in a block.\n          const bodyText = sourceCode.getText(node.body)\n\n          fixes.push(\n            fixer.replaceText(\n              node.body,\n              `{\\n${innerIndent}${destructureStatement}\\n\\n${innerIndent}return ${bodyText}\\n${baseIndent}}`,\n            ),\n          )\n\n          return fixes\n        },\n      })\n    }\n\n    return {\n      ArrowFunctionExpression: check,\n      FunctionDeclaration: check,\n      FunctionExpression: check,\n    }\n  },\n}\n\nexport default propsDestructuringNewline\n", "import type { Rule } from 'eslint'\n\nimport { componentFileOrder } from './component-file-order'\nimport { propsDestructuringBlankLine } from './props-destructuring-blank-line'\nimport { propsDestructuringNewline } from './props-destructuring-newline'\n\nexport const rules: Record<string, Rule.RuleModule> = {\n  'props-destructuring-newline': propsDestructuringNewline,\n  'props-destructuring-blank-line': propsDestructuringBlankLine,\n  'component-file-order': componentFileOrder,\n}\n", "import type { ESLint, Linter } from 'eslint'\n\nimport { rules } from './rules'\n\nconst PLUGIN_NAME = '@wl'\n\nconst plugin: ESLint.Plugin & { configs: Record<string, Linter.Config> } = {\n  meta: {\n    name: '@wl/eslint-plugin',\n    version: '0.1.0',\n  },\n  rules,\n  configs: {},\n}\n\n/**\n * Flat-config preset that registers the plugin and turns every rule on.\n *\n * @example\n * import wl from '@wl/eslint-plugin'\n *\n * export default [wl.configs.recommended]\n */\nplugin.configs.recommended = {\n  plugins: {\n    [PLUGIN_NAME]: plugin,\n  },\n  rules: {\n    [`${PLUGIN_NAME}/props-destructuring-newline`]: 'error',\n    [`${PLUGIN_NAME}/props-destructuring-blank-line`]: 'error',\n    [`${PLUGIN_NAME}/component-file-order`]: 'error',\n  },\n}\n\nexport const meta: ESLint.Plugin['meta'] = plugin.meta\nexport const configs: Record<string, Linter.Config> = plugin.configs\nexport { rules }\n\nexport default plugin\n"],
+  "mappings": "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",
+  "names": ["fn"]
+}

package/dist/rules/component-file-order.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+export declare const componentFileOrder: Rule.RuleModule;
+export default componentFileOrder;

package/dist/rules/index.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from 'eslint';
+export declare const rules: Record<string, Rule.RuleModule>;

package/dist/rules/props-destructuring-blank-line.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+export declare const propsDestructuringBlankLine: Rule.RuleModule;
+export default propsDestructuringBlankLine;

package/dist/rules/props-destructuring-newline.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+export declare const propsDestructuringNewline: Rule.RuleModule;
+export default propsDestructuringNewline;

package/dist/utils/component.d.ts

@@ -0,0 +1,10 @@
+import type * as ESTree from 'estree';
+export type ComponentFunction = ESTree.ArrowFunctionExpression | ESTree.FunctionDeclaration | ESTree.FunctionExpression;
+/** A function is treated as a React component when it is PascalCase-named or returns JSX. */
+export declare const isComponent: (node: ComponentFunction) => boolean;
+/**
+ * Extract the component function from an expression, unwrapping a single layer of
+ * component wrappers (`memo(fn)`, `forwardRef(fn)`, `React.memo(fn)`, ...). Returns
+ * null when no function is found.
+ */
+export declare const getComponentFunction: (node: ESTree.Node | null | undefined) => ComponentFunction | null;

package/dist/utils/path-match.d.ts

@@ -0,0 +1,2 @@
+/** Whether `filename` matches at least one of the provided glob `patterns`. */
+export declare const matchesAnyGlob: (filename: string, patterns: readonly string[]) => boolean;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@slip-stream-kit/eslint-plugin",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "Custom ESLint rules enforcing the white-label frontend architecture conventions",
+  "author": "Arthur Saenko <arthur.saenz7@gmail.com> (https://github.com/ArthurSaenz)",
+  "license": "MIT",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "react",
+    "props",
+    "destructuring"
+  ],
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=24.x"
+  },
+  "scripts": {
+    "build": "pnpm run clean-artifacts && node ./scripts/build.js",
+    "clean-artifacts": "rm -rf dist",
+    "clean-cache": "rm -rf node_modules/.cache .eslintcache tsconfig.tsbuildinfo .turbo",
+    "prettier-fix": "pnpm exec prettier **/* --write --no-error-on-unmatched-pattern --log-level silent --ignore-path ../../../.prettierignore",
+    "prettier-check": "pnpm exec prettier **/* --check --no-error-on-unmatched-pattern --log-level silent --ignore-path ../../../.prettierignore",
+    "eslint-check": "pnpm exec eslint --cache --quiet --report-unused-disable-directives ./src",
+    "eslint-fix": "pnpm exec eslint --cache --quiet --report-unused-disable-directives ./src --fix",
+    "ts-check": "tsc --noEmit",
+    "test": "pnpm exec vitest run --reporter=minimal",
+    "test-watch": "pnpm exec vitest --watch --silent passed-only",
+    "test-report": "pnpm exec vitest run --coverage --silent passed-only",
+    "qa": "pnpm run prettier-check && pnpm run eslint-check && pnpm run ts-check && pnpm run test && echo ✅ Success",
+    "fix": "pnpm run prettier-fix && pnpm run eslint-fix && pnpm run qa"
+  },
+  "peerDependencies": {
+    "eslint": ">=9"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "@typescript-eslint/parser": "^8.60.1",
+    "@wl/eslint-config": "workspace:*",
+    "esbuild": "^0.28.0",
+    "eslint": "^10.4.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
+  }
+}

package/readme.md

@@ -0,0 +1,135 @@
+# @wl/eslint-plugin
+
+Custom ESLint rules that enforce the white-label frontend architecture conventions.
+
+## Installation
+
+```bash
+pnpm add -D @wl/eslint-plugin
+```
+
+## Usage (flat config)
+
+Enable everything via the recommended preset:
+
+```js
+// eslint.config.js
+import wl from '@wl/eslint-plugin'
+
+export default [wl.configs.recommended]
+```
+
+Or register the plugin and pick rules manually:
+
+```js
+import wl from '@wl/eslint-plugin'
+
+export default [
+  {
+    plugins: { '@wl': wl },
+    rules: {
+      '@wl/props-destructuring-newline': 'error',
+    },
+  },
+]
+```
+
+## Rules
+
+### `props-destructuring-newline`
+
+🔧 Automatically fixable.
+
+React components must accept a single `props` parameter and destructure it on
+its own line inside the body, instead of destructuring inline in the parameter
+list.
+
+```tsx
+// ❌ Incorrect
+const UserCard = ({ user, className }: UserCardProps) => {
+  return <div className={className}>{user.name}</div>
+}
+
+// ✅ Correct
+const UserCard = (props: UserCardProps) => {
+  const { user, className } = props
+
+  return <div className={className}>{user.name}</div>
+}
+```
+
+A function is treated as a component when its name is PascalCase (looking
+through `memo`/`forwardRef`/`observer` wrappers) or when it returns JSX. Hooks,
+plain helpers, and any function whose first parameter is not an object pattern
+are ignored.
+
+### `props-destructuring-blank-line`
+
+🔧 Automatically fixable.
+
+Require a blank line after the `const { ... } = props` destructuring statement
+at the top of a component body.
+
+```tsx
+// ❌ Incorrect
+const UserCard = (props: UserCardProps) => {
+  const { user, className } = props
+  return <div className={className}>{user.name}</div>
+}
+
+// ✅ Correct
+const UserCard = (props: UserCardProps) => {
+  const { user, className } = props
+
+  return <div className={className}>{user.name}</div>
+}
+```
+
+The rule only triggers inside components (same detection as above) and only for
+a statement that destructures the `props` identifier. It is a no-op when the
+destructuring is the last statement in the body.
+
+### `component-file-order`
+
+Enforce a strict top-level order in files that contain a React component:
+**imports → component props interface/type → component declaration**. Constants
+and helpers between the interface and the component are allowed. Report-only (it
+does not auto-reorder code).
+
+```tsx
+// ❌ Incorrect — interface before imports, or component before its interface
+interface CardProps { title: string }
+import { cn } from '#root/lib/utils'
+
+// ✅ Correct
+import { cn } from '#root/lib/utils'
+
+interface CardProps {
+  title: string
+}
+
+const Card = (props: CardProps) => {
+  const { title } = props
+
+  return <div className={cn('card')}>{title}</div>
+}
+```
+
+The rule activates only when the file actually contains a component. The "props
+interface" is any top-level `interface`/`type` whose name ends in `Props`.
+
+#### Option: `paths` (optional)
+
+Restrict the rule to specific files via glob patterns. When omitted, it runs on
+every file (you can also scope it the usual way with flat-config `files`).
+
+```js
+{
+  rules: {
+    '@wl/component-file-order': ['error', { paths: ['**/features/**', 'apps/*/ui/**'] }],
+  },
+}
+```
+
+Glob support: `*` matches within a path segment, `**` matches across segments,
+`?` matches a single character. A file matches if any pattern matches its path.