Fix lint

Author: danez

eslint.config.mjs

@@ -89,7 +89,6 @@ export default tseslint.config([
       ],
 
       '@typescript-eslint/consistent-type-imports': 'error',
-      '@typescript-eslint/no-non-null-assertion': 'off',
       '@typescript-eslint/sort-type-constituents': 'error',
     },
   },

packages/react-docgen-cli/src/commands/parse/options/loadReactDocgenPlugin.ts

@@ -6,8 +6,10 @@ export default async function loadReactDocgenPlugin<T>(
   name: string,
   builtins?: Record<string, T>,
 ): Promise<T> {
-  if (builtins?.[input]) {
-    return builtins[input]!;
+  const builtin = builtins?.[input];
+
+  if (builtin !== undefined) {
+    return builtin;
   }
 
   const path = resolve(process.cwd(), input);

packages/react-docgen-cli/src/commands/parse/options/loadResolvers.ts

@@ -57,5 +57,11 @@ export default async function loadResolvers(
     });
   }
 
-  return loadResolver(input[0]!);
+  const [resolver] = input;
+
+  if (resolver === undefined) {
+    return;
+  }
+
+  return loadResolver(resolver);
 }

packages/react-docgen/src/handlers/componentDocblockHandler.ts

@@ -19,7 +19,11 @@ function getDocblockFromComponent(path: NodePath): string | null {
     // If we have a class declaration or expression, then the comment might be
     // attached to the last decorator instead as trailing comment.
     if (decorators && decorators.length > 0) {
-      description = getDocblock(decorators[decorators.length - 1]!, true);
+      const lastDecorator = decorators[decorators.length - 1];
+
+      if (lastDecorator) {
+        description = getDocblock(lastDecorator, true);
+      }
     }
   }
   if (description == null) {
@@ -41,9 +45,10 @@ function getDocblockFromComponent(path: NodePath): string | null {
     }
   }
   if (!description) {
-    const searchPath = isReactForwardRefCall(path)
-      ? path.get('arguments')[0]!
-      : path;
+    const [forwardRefArgument] = isReactForwardRefCall(path)
+      ? path.get('arguments')
+      : [];
+    const searchPath = forwardRefArgument ?? path;
     const inner = resolveToValue(searchPath);
 
     if (inner.node !== path.node) {

packages/react-docgen/src/handlers/componentMethodsHandler.ts

@@ -141,9 +141,13 @@ function findStatelessComponentBody(
       return body;
     }
   } else if (isReactForwardRefCall(componentDefinition)) {
-    const inner = resolveToValue(componentDefinition.get('arguments')[0]!);
+    const [forwardRefArgument] = componentDefinition.get('arguments');
 
-    return findStatelessComponentBody(inner);
+    if (forwardRefArgument) {
+      const inner = resolveToValue(forwardRefArgument);
+
+      return findStatelessComponentBody(inner);
+    }
   }
 
   return undefined;

packages/react-docgen/src/handlers/defaultPropsHandler.ts

@@ -23,7 +23,6 @@ import type { Handler } from './index.js';
 
 function getDefaultValue(path: NodePath): DefaultValueDescriptor | null {
   let defaultValue: string | undefined;
-  let resolvedPath = path;
   let valuePath = path;
 
   if (path.isBooleanLiteral()) {
@@ -33,6 +32,8 @@ function getDefaultValue(path: NodePath): DefaultValueDescriptor | null {
   } else if (path.isLiteral()) {
     defaultValue = path.node.extra?.raw as string;
   } else {
+    let resolvedPath: NodePath;
+
     if (path.isAssignmentPattern()) {
       resolvedPath = resolveToValue(path.get('right'));
     } else {
@@ -64,7 +65,13 @@ function getStatelessPropsPath(
   let value: NodePath = componentDefinition;
 
   if (isReactForwardRefCall(componentDefinition)) {
-    value = resolveToValue(componentDefinition.get('arguments')[0]!);
+    const [forwardRefArgument] = componentDefinition.get('arguments');
+
+    if (!forwardRefArgument) {
+      return undefined;
+    }
+
+    value = resolveToValue(forwardRefArgument);
   }
 
   if (!value.isFunction()) {

packages/react-docgen/src/utils/docblock.ts

@@ -35,7 +35,11 @@ export function getDocblock(path: NodePath, trailing = false): string | null {
   }
 
   if (comments.length > 0) {
-    return parseDocblock(comments[comments.length - 1]!.value);
+    const lastComment = comments[comments.length - 1];
+
+    if (lastComment) {
+      return parseDocblock(lastComment.value);
+    }
   }
 
   return null;
@@ -50,7 +54,11 @@ export function getDoclets(str: string): Record<string, string> {
   let match: RegExpExecArray | null;
 
   while ((match = DOCLET_PATTERN.exec(str))) {
-    doclets[match[1]!] = match[2] || true;
+    const [, name, value] = match;
+
+    if (name) {
+      doclets[name] = value || true;
+    }
   }
 
   return doclets;

packages/react-docgen/src/utils/findComponentDefinition.ts

@@ -24,7 +24,13 @@ function resolveComponentDefinition(
 ): NodePath<ComponentNode> | null {
   if (isReactCreateClassCall(definition)) {
     // return argument
-    const resolvedPath = resolveToValue(definition.get('arguments')[0]!);
+    const [argument] = definition.get('arguments');
+
+    if (!argument) {
+      return null;
+    }
+
+    const resolvedPath = resolveToValue(argument);
 
     if (resolvedPath.isObjectExpression()) {
       return resolvedPath;

packages/react-docgen/src/utils/getFlowType.ts

@@ -182,15 +182,13 @@ function handleGenericTypeAnnotation(
     );
   }
 
-  if (
-    typeParams &&
-    typeParams[type.name] &&
-    typeParams[type.name]!.isGenericTypeAnnotation()
-  ) {
+  const resolvedTypeParam = typeParams?.[type.name];
+
+  if (resolvedTypeParam?.isGenericTypeAnnotation()) {
     return type;
   }
 
-  if (typeParams && typeParams[type.name]) {
+  if (resolvedTypeParam) {
     type = getFlowTypeWithResolvedTypes(
       resolvedPath as NodePath<FlowType>,
       typeParams,
@@ -482,8 +480,10 @@ function getFlowTypeWithResolvedTypes(
     visitedTypes[parent.node.id.name] = true;
   }
 
-  if (path.node.type in flowTypes) {
-    type = { name: flowTypes[path.node.type]! };
+  const primitiveFlowType = flowTypes[path.node.type];
+
+  if (primitiveFlowType) {
+    type = { name: primitiveFlowType };
   } else if (path.node.type in flowLiteralTypes) {
     type = {
       name: 'literal',
@@ -499,8 +499,12 @@ function getFlowTypeWithResolvedTypes(
           ).node.value
         }`,
     };
-  } else if (path.node.type in namedTypes) {
-    type = namedTypes[path.node.type]!(path, typeParams);
+  } else {
+    const typeHandler = namedTypes[path.node.type];
+
+    if (typeHandler) {
+      type = typeHandler(path, typeParams);
+    }
   }
 
   if (!type) {

packages/react-docgen/src/utils/getMemberExpressionValuePath.ts

@@ -18,7 +18,13 @@ function resolveName(path: NodePath): string | undefined {
       );
     }
     // VariableDeclarator always has at least one declaration, hence the non-null-assertion
-    const id = declarations[0]!.get('id');
+    const [declaration] = declarations;
+
+    if (!declaration) {
+      return;
+    }
+
+    const id = declaration.get('id');
 
     if (id.isIdentifier()) {
       return id.node.name;