Sign upLogin

fbredius/storybook

View on GitHub
Star
addons/docs/src/blocks/ArgsTable.tsx

Summary

Maintainability
B
5 hrs
Test Coverage

Function StoryTable has 57 lines of code (exceeds 25 allowed). Consider refactoring.
Open

> = (props) => {
  const context = useContext(DocsContext);
  const { id: currentId, componentStories } = context;
  const {
    story: storyName,
Severity: Major
Found in addons/docs/src/blocks/ArgsTable.tsx - About 2 hrs to fix

    Function ArgsTable has 33 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    export const ArgsTable: FC<ArgsTableProps> = (props) => {
  const context = useContext(DocsContext);
  const { id, storyById } = context;
  const {
    parameters: { controls },
    Severity: Minor
    Found in addons/docs/src/blocks/ArgsTable.tsx - About 1 hr to fix

      Function StoryTable has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
      Open

      > = (props) => {
  const context = useContext(DocsContext);
  const { id: currentId, componentStories } = context;
  const {
    story: storyName,
      Severity: Minor
      Found in addons/docs/src/blocks/ArgsTable.tsx - About 1 hr to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function ArgsTable has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
      Open

      export const ArgsTable: FC<ArgsTableProps> = (props) => {
  const context = useContext(DocsContext);
  const { id, storyById } = context;
  const {
    parameters: { controls },
      Severity: Minor
      Found in addons/docs/src/blocks/ArgsTable.tsx - About 25 mins to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Identifier 'args' is never reassigned; use 'const' instead of 'let'.
      Open

          let [args, updateArgs, resetArgs] = useArgs(storyId, context);
      Severity: Minor
      Found in addons/docs/src/blocks/ArgsTable.tsx by tslint

      Rule: prefer-const

      Requires that variable declarations use const instead of let and var if possible.

      If a variable is only assigned to once when it is declared, it should be declared using 'const'

      Notes
      • Has Fix

      Config

      An optional object containing the property "destructuring" with two possible values:

      • "any" (default) - If any variable in destructuring can be const, this rule warns for those variables.
      • "all" - Only warns if all variables in destructuring can be const.
      Examples
      "prefer-const": true
      "prefer-const": true,[object Object]
      Schema
      {
  "type": "object",
  "properties": {
    "destructuring": {
      "type": "string",
      "enum": [
        "all",
        "any"
      ]
    }
  }
}

      For more information see this page.

      Type assertion on object literals is forbidden, use a type annotation instead.
      Open

          let tabs = { [mainLabel]: { rows: argTypes, args, updateArgs, resetArgs } } as Record<
      string,
      PureArgsTableProps
    >;
      Severity: Minor
      Found in addons/docs/src/blocks/ArgsTable.tsx by tslint

      Rule: no-object-literal-type-assertion

      Forbids an object literal to appear in a type assertion expression. Casting to any or to unknown is still allowed.

      Rationale

      Always prefer const x: T = { ... }; to const x = { ... } as T;. The type assertion in the latter case is either unnecessary or hides an error. The compiler will warn for excess properties with this syntax, but not missing required fields. For example: const x: { foo: number } = {} will fail to compile, but const x = {} as { foo: number } will succeed. Additionally, the const assertion const x = { foo: 1 } as const, introduced in TypeScript 3.4, is considered beneficial and is ignored by this rule.

      Notes
      • TypeScript Only

      Config

      One option may be configured:

      • allow-arguments allows type assertions to be used on object literals inside call expressions.
      Examples
      "no-object-literal-type-assertion": true
      "no-object-literal-type-assertion": true,[object Object]
      Schema
      {
  "type": "object",
  "properties": {
    "allow-arguments": {
      "type": "boolean"
    }
  },
  "additionalProperties": false
}

      For more information see this page.

      There are no issues that match your filters.

      Category
      Status