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:
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:
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 => {
- Read upRead up
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 => {
- Read upRead up
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:
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:
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);
- Read upRead up
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);
- Read upRead up
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 {
- Read upRead up
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 {
- Read upRead up
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 => {
- Read upRead up
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 => {
- Read upRead up
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 => {
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 => {
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);
- Read upRead up
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 => {
- Read upRead up
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);
- Read upRead up
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 => {
- Read upRead up
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 = {};
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 => {