Rm vitest

Author: owjs3901

src/rules/app-page/index.ts

@@ -6,6 +6,15 @@ const createRule = ESLintUtils.RuleCreator(
     `https://github.com/dev-five-git/devup/tree/main/packages/eslint-plugin/src/rules/${name}`,
 )
 
+// Pre-compiled regex patterns
+const APP_DIR_PATTERN = /src[/\\]app[/\\]/
+const FILE_TYPE_PATTERN = /(page|layout|404)\.[jt]sx?$/
+const PATH_PARAMS_PATTERN = /\[.*?]/g
+
+function generateParamsType(pathParams: string[]): string {
+  return `{params}:{params:Promise<{${pathParams.map((param) => `${param.slice(1, -1)}:string`).join(';')}}>}`
+}
+
 export const appPage = createRule({
   name: 'app-page',
   defaultOptions: [],
@@ -29,86 +38,77 @@ export const appPage = createRule({
   create(context) {
     const filename = relative(context.cwd, context.physicalFilename)
 
-    if (!/src[/\\]app[/\\]/.test(filename)) return {}
-    const type = /page\.[j|t]sx?$/.test(filename)
-      ? 'page'
-      : /layout\.[j|t]sx?$/.test(filename)
-        ? 'layout'
-        : /404\.[j|t]sx?$/.test(filename)
-          ? '404'
-          : 'component'
-    if (type === 'component') return {}
+    if (!APP_DIR_PATTERN.test(filename)) return {}
+
+    const fileTypeMatch = FILE_TYPE_PATTERN.exec(filename)
+    if (!fileTypeMatch) return {}
+
+    const type = fileTypeMatch[1] as 'page' | 'layout' | '404'
 
     const functionSuffix = type === 'layout' ? 'Layout' : 'Page'
-    const pathParams = filename.match(/\[.*?]/g) ?? []
+    const pathParams = filename.match(PATH_PARAMS_PATTERN) ?? []
     // Ignore when only locale param exists
     const onlyLocale = pathParams.length === 1 && pathParams[0] === '[locale]'
 
+    const hasPathParams = pathParams.length > 0
+    const requiresParams = hasPathParams && !onlyLocale
+    const paramsType = hasPathParams ? generateParamsType(pathParams) : ''
+
     let ok = false
     return {
       ExportDefaultDeclaration(defaultExport) {
         ok = true
         const declaration = defaultExport.declaration
         if (declaration.type !== 'FunctionDeclaration') return
+
         if (
           declaration.id?.name &&
           !declaration.id.name.endsWith(functionSuffix)
         ) {
-          const func = declaration.id
           context.report({
-            node: func,
+            node: declaration.id,
             messageId: 'nameOfPageOrLayoutComponentShouldHaveSuffix',
-            fix(fixer) {
-              return fixer.replaceText(func, func.name + functionSuffix)
-            },
+            fix: (fixer) =>
+              fixer.replaceText(
+                declaration.id!,
+                declaration.id!.name + functionSuffix,
+              ),
           })
         }
+
         if (
           declaration.id &&
-          pathParams.length &&
-          declaration.params.length === 0 &&
-          !onlyLocale
+          requiresParams &&
+          declaration.params.length === 0
         ) {
           context.report({
             node: declaration,
             messageId: 'pathParamsShouldExist',
-            fix(fixer) {
-              return fixer.replaceTextRange(
+            fix: (fixer) =>
+              fixer.replaceTextRange(
                 [
                   declaration.id!.range[1],
-                  declaration.returnType
-                    ? declaration.returnType.range[0]
-                    : declaration.body.range[0],
+                  declaration.returnType?.range[0] ?? declaration.body.range[0],
                 ],
-                `({params}:{params:Promise<{${pathParams
-                  .map((param) => `${param.slice(1, -1)}:string`)
-                  .join(';')}}>})`,
-              )
-            },
+                `(${paramsType})`,
+              ),
           })
         }
-        return
       },
       'Program:exit'(program) {
-        // Auto-generate if source code is empty
         if (ok) return
+
+        const functionName = type === '404' ? 'NotFoundPage' : functionSuffix
+        const prefix = context.sourceCode.text.trim().length ? '\n' : ''
+
         context.report({
           node: program,
           messageId: 'pageOrLayoutComponentShouldDefaultExport',
-          fix(fixer) {
-            return fixer.insertTextAfter(
+          fix: (fixer) =>
+            fixer.insertTextAfter(
               program,
-              `${context.sourceCode.text.trim().length ? '\n' : ''}export default function ` +
-                (type === '404' ? 'NotFoundPage' : functionSuffix) +
-                `(${
-                  pathParams.length
-                    ? `{params}:{params:Promise<{${pathParams
-                        .map((param) => `${param.slice(1, -1)}:string`)
-                        .join(';')}}>}`
-                    : ''
-                }){return <></>}`,
-            )
-          },
+              `${prefix}export default function ${functionName}(${paramsType}){return <></>}`,
+            ),
         })
       },
     }

src/rules/component-interface/index.ts

@@ -5,6 +5,13 @@ const createRule = ESLintUtils.RuleCreator(
     `https://github.com/dev-five-git/devup/tree/main/packages/eslint-plugin/src/rules/${name}`,
 )
 
+const PASCAL_CASE_PATTERN = /^[A-Z]/
+const EXPORTABLE_PARENT_TYPES = new Set([
+  'Program',
+  'ExportNamedDeclaration',
+  'ExportDefaultDeclaration',
+])
+
 export const componentInterface = createRule({
   name: 'component-interface',
   defaultOptions: [],
@@ -22,41 +29,38 @@ export const componentInterface = createRule({
     },
   },
   create(context) {
-    const filename = context.physicalFilename
-
-    if (!filename.endsWith('.tsx')) return {}
+    if (!context.physicalFilename.endsWith('.tsx')) return {}
 
     return {
       FunctionDeclaration(node) {
         const funcName = node.id?.name
+        if (!funcName || !PASCAL_CASE_PATTERN.test(funcName)) return
 
+        const firstParam = node.params[0]
         if (
-          funcName &&
-          node.params.length === 1 &&
-          node.params[0].type === 'ObjectPattern' &&
-          !node.params[0].typeAnnotation &&
-          node.params[0].properties.length === 0 &&
-          (node.parent.type === 'Program' ||
-            node.parent.type === 'ExportNamedDeclaration' ||
-            node.parent.type === 'ExportDefaultDeclaration') &&
-          /^[A-Z]/.test(funcName)
+          node.params.length !== 1 ||
+          firstParam.type !== 'ObjectPattern' ||
+          firstParam.typeAnnotation ||
+          firstParam.properties.length !== 0 ||
+          !EXPORTABLE_PARENT_TYPES.has(node.parent.type)
         ) {
-          context.report({
-            node,
-            messageId:
-              'componentPropsShouldHaveTypeAnnotationWhenEmptyObjectPattern',
-            fix(fixer) {
-              return [
-                fixer.insertTextAfter(node.params[0], `:${funcName}Props`),
-                // Insert before the line
-                fixer.insertTextBefore(
-                  node.parent.type === 'Program' ? node : node.parent,
-                  `interface ${funcName}Props{}\n`,
-                ),
-              ]
-            },
-          })
+          return
         }
+
+        const insertTarget = node.parent.type === 'Program' ? node : node.parent
+
+        context.report({
+          node,
+          messageId:
+            'componentPropsShouldHaveTypeAnnotationWhenEmptyObjectPattern',
+          fix: (fixer) => [
+            fixer.insertTextAfter(firstParam, `:${funcName}Props`),
+            fixer.insertTextBefore(
+              insertTarget,
+              `interface ${funcName}Props{}\n`,
+            ),
+          ],
+        })
       },
     }
   },