freddi301/flow-validator

View on GitHub

Showing 30 of 207 total issues

File eslint_vx.x.x.js has 1947 lines of code (exceeds 250 allowed). Consider refactoring.
Open

// flow-typed signature: 5367bc47979239a7da6d0c201fc2e3fe
// flow-typed version: <<STUB>>/eslint_v3.17.1/flow_v0.47.0

/**
 * This is an autogenerated libdef stub for:
Severity: Major
Found in flow-typed/npm/eslint_vx.x.x.js - About 5 days to fix

    File documentation_vx.x.x.js has 351 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    // flow-typed signature: c0595b99c212691590357e4cec1dfa6b
    // flow-typed version: <<STUB>>/documentation_v4.0.0-beta.18/flow_v0.47.0
    
    /**
     * This is an autogenerated libdef stub for:
    Severity: Minor
    Found in flow-typed/npm/documentation_vx.x.x.js - About 4 hrs to fix

      Function mapping has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
      Open

      export function mapping<K: string, V>(
        keys: Type<K>,
        values: Type<V>
      ): MappingType<K, V> {
        const m = new MappingType(keys, values, v => {
      Severity: Minor
      Found in src/sync/mapping.js - About 3 hrs 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 Vmapping has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.
      Open

      export function Vmapping<K: string, V>(
        keys: VType<K>,
        values: VType<V>
      ): VMappingType<K, V> {
        const m = new VMappingType(keys, values, v => {
      Severity: Minor
      Found in src/sync/Vmapping.js - About 3 hrs 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

      File istanbul_vx.x.x.js has 285 lines of code (exceeds 250 allowed). Consider refactoring.
      Open

      // flow-typed signature: 4219e5764b90c5586b1f151478c2f4a6
      // flow-typed version: <<STUB>>/istanbul_v0.4.5/flow_v0.47.0
      
      /**
       * This is an autogenerated libdef stub for:
      Severity: Minor
      Found in flow-typed/npm/istanbul_vx.x.x.js - About 2 hrs to fix

        File eslint-plugin-flowtype_vx.x.x.js has 255 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        // flow-typed signature: 4ac6a7e18741c4faa645980a28e69262
        // flow-typed version: <<STUB>>/eslint-plugin-flowtype_v2.30.2/flow_v0.47.0
        
        /**
         * This is an autogenerated libdef stub for:
        Severity: Minor
        Found in flow-typed/npm/eslint-plugin-flowtype_vx.x.x.js - About 2 hrs to fix

          Function VobjectExact has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
          Open

          export function VobjectExact<S: { [key: string]: VType<any> }>(
            s: S
          ): VObjectExactType<S, $Exact<$ObjMap<S, <F>(v: VType<F>) => F>>> {
            const oes = new VObjectExactType(s, v => {
              const o = objectType.validate(v);
          Severity: Minor
          Found in src/sync/VobjectExact.js - About 2 hrs 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 objectExact has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
          Open

          export function objectExact<S: { [key: string]: Type<any> }>(
            s: S
          ): ObjectExactType<S, $Exact<$ObjMap<S, <F>(v: Type<F>) => F>>> {
            const oes = new ObjectExactType(s, v => {
              const o = objectType.validate(v);
          Severity: Minor
          Found in src/sync/objectExact.js - About 2 hrs 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 Vunion has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
          Open

          export function Vunion<A, B>(a: VType<A>, b: VType<B>): VUnionType<A, B> {
            const u = new VUnionType(a, b, v => {
              let left;
              let right;
              try {
          Severity: Minor
          Found in src/sync/Vunion.js - 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 union has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
          Open

          export function union<A, B>(a: Type<A>, b: Type<B>): UnionType<A, B> {
            const u = new UnionType(a, b, v => {
              let left;
              let right;
              try {
          Severity: Minor
          Found in src/sync/union.js - 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 asyncUnion has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
          Open

          export function asyncUnion<A, B>(
            a: AsyncType<A>,
            b: AsyncType<B>
          ): AsyncUnionType<A, B> {
            const u = new AsyncUnionType(a, b, async v => {
          Severity: Minor
          Found in src/async/asyncUnion.js - 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 asyncVunion has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
          Open

          export function asyncVunion<A, B>(
            a: AsyncVType<A>,
            b: AsyncVType<B>
          ): AsyncVUnionType<A, B> {
            const u = new AsyncVUnionType(a, b, async v => {
          Severity: Minor
          Found in src/async/asyncVunion.js - 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 asyncMapping has 34 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          export function asyncMapping<K: string, V>(
            keys: AsyncType<K>,
            values: AsyncType<V>
          ): AsyncMappingType<K, V> {
            const m = new AsyncMappingType(keys, values, async v => {
          Severity: Minor
          Found in src/async/asyncMapping.js - About 1 hr to fix

            Function mapping has 32 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            export function mapping<K: string, V>(
              keys: Type<K>,
              values: Type<V>
            ): MappingType<K, V> {
              const m = new MappingType(keys, values, v => {
            Severity: Minor
            Found in src/sync/mapping.js - About 1 hr to fix

              Function Vobject has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
              Open

              export function Vobject<S: { [key: string]: VType<any> }>(
                s: S
              ): VObjectType<S, $ObjMap<S, <F>(v: VType<F>) => F>> {
                const os = new VObjectType(s, v => {
                  const o = objectType.validate(v);
              Severity: Minor
              Found in src/sync/Vobject.js - 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 tuple has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
              Open

              export function tuple<S: Array<Type<any>>>(
                s: S
              ): TupleType<$TupleMap<S, <T>(v: Type<T>) => T>> {
                // eslint-disable-line no-redeclare
                const tt = new TupleType(s, v => {
              Severity: Minor
              Found in src/sync/tuple.js - 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 object has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
              Open

              export function object<S: { [key: string]: Type<any> }>(
                s: S
              ): ObjectType<S, $ObjMap<S, <F>(v: Type<F>) => F>> {
                const os = new ObjectType(s, v => {
                  const o = objectType.validate(v);
              Severity: Minor
              Found in src/sync/object.js - 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 Vtuple has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
              Open

              export function Vtuple<S: Array<VType<any>>>(
                s: S
              ): VTupleType<$TupleMap<S, <T>(v: Type<T>) => T>> {
                // eslint-disable-line no-redeclare
                const tt = new VTupleType(s, v => {
              Severity: Minor
              Found in src/sync/tuple.js - 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 m has 31 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                const m = new AsyncMappingType(keys, values, async v => {
                  const o = objectType.validate(await v);
                  const ks = Object.keys(o);
                  const result = {};
                  const errors = {};
              Severity: Minor
              Found in src/async/asyncMapping.js - About 1 hr to fix

                Function asyncVmapping has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                export function asyncVmapping<K: string, V>(
                  keys: AsyncVType<K>,
                  values: AsyncVType<V>
                ): AsyncVMappingType<K, V> {
                  const m = new AsyncVMappingType(keys, values, async v => {
                Severity: Minor
                Found in src/async/asyncVmapping.js - About 1 hr to fix
                  Severity
                  Category
                  Status
                  Source
                  Language