Showing 26 of 44 total issues
Function resolveGraphQL
has a Cognitive Complexity of 59 (exceeds 10 allowed). Consider refactoring. Open
const resolveGraphQL = (
selector: ENTITY_SELECTOR,
options: {
include: Array<keyof any>;
prefix: string;
- 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 relatedEntity
has a Cognitive Complexity of 51 (exceeds 10 allowed). Consider refactoring. Open
export function relatedEntity<
STORE,
PARENT_ENTITY,
RELATED_ENTITY,
RELATED_KEY_IDS extends ID_FILTER_PROPS<PARENT_ENTITY, ID_TYPES>,
- 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 childrenEntities
has a Cognitive Complexity of 45 (exceeds 10 allowed). Consider refactoring. Open
export function childrenEntities<
STORE,
PARENT_ENTITY,
RELATED_ENTITY,
RELATED_KEY_IDS extends ID_FILTER_PROPS<RELATED_ENTITY, ID_TYPES>,
- 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 toGraphQL
has a Cognitive Complexity of 45 (exceeds 10 allowed). Consider refactoring. Open
export function toGraphQL(...queries: Array<any>): string {
const prefix = (window as any).ngrxGraphqlPrefix || '';
let query: string | undefined = '';
let selector: ENTITY_SELECTOR | undefined;
let params: Record<string, any> | null | string | undefined;
- 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 childrenEntities
has 119 lines of code (exceeds 25 allowed). Consider refactoring. Open
export function childrenEntities<
STORE,
PARENT_ENTITY,
RELATED_ENTITY,
RELATED_KEY_IDS extends ID_FILTER_PROPS<RELATED_ENTITY, ID_TYPES>,
Function relatedEntity
has 110 lines of code (exceeds 25 allowed). Consider refactoring. Open
export function relatedEntity<
STORE,
PARENT_ENTITY,
RELATED_ENTITY,
RELATED_KEY_IDS extends ID_FILTER_PROPS<PARENT_ENTITY, ID_TYPES>,
Function childEntity
has 89 lines of code (exceeds 25 allowed). Consider refactoring. Open
export function childEntity<
STORE,
PARENT_ENTITY,
RELATED_ENTITY,
RELATED_KEY_IDS extends ID_FILTER_PROPS<RELATED_ENTITY, ID_TYPES>,
Function callback
has 88 lines of code (exceeds 25 allowed). Consider refactoring. Open
const callback = (
cacheLevel: string,
state: STORE,
cache: CACHE<STORE>,
source: PARENT_ENTITY,
Function callback
has 85 lines of code (exceeds 25 allowed). Consider refactoring. Open
const callback = (cacheLevel: string, state: STORE, cache: CACHE<STORE>, source: PARENT_ENTITY) => {
// a bit magic to relax generic types.
const sourceKeyIdValue = source[keyId];
if (!sourceKeyIdValue) {
return;
Function rootEntity
has 80 lines of code (exceeds 25 allowed). Consider refactoring. Open
export function rootEntity<STORE, ENTITY, TRANSFORMED>(
featureSelector: FEATURE_SELECTOR<STORE, ENTITY>,
guess1?: TRANSFORMER<ENTITY, TRANSFORMED> | SELECTOR_META | HANDLER_RELATED_ENTITY<STORE, ENTITY>,
guess2?: SELECTOR_META | HANDLER_RELATED_ENTITY<STORE, ENTITY>,
): HANDLER_ROOT_ENTITY<STORE, ENTITY, ENTITY | TRANSFORMED, ID_TYPES> {
Function rootEntity
has a Cognitive Complexity of 27 (exceeds 10 allowed). Consider refactoring. Open
export function rootEntity<STORE, ENTITY, TRANSFORMED>(
featureSelector: FEATURE_SELECTOR<STORE, ENTITY>,
guess1?: TRANSFORMER<ENTITY, TRANSFORMED> | SELECTOR_META | HANDLER_RELATED_ENTITY<STORE, ENTITY>,
guess2?: SELECTOR_META | HANDLER_RELATED_ENTITY<STORE, ENTITY>,
): HANDLER_ROOT_ENTITY<STORE, ENTITY, ENTITY | TRANSFORMED, ID_TYPES> {
- 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 childEntity
has a Cognitive Complexity of 25 (exceeds 10 allowed). Consider refactoring. Open
export function childEntity<
STORE,
PARENT_ENTITY,
RELATED_ENTITY,
RELATED_KEY_IDS extends ID_FILTER_PROPS<RELATED_ENTITY, ID_TYPES>,
- 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 resolveGraphQL
has 66 lines of code (exceeds 25 allowed). Consider refactoring. Open
const resolveGraphQL = (
selector: ENTITY_SELECTOR,
options: {
include: Array<keyof any>;
prefix: string;
Function toGraphQL
has 61 lines of code (exceeds 25 allowed). Consider refactoring. Open
export function toGraphQL(...queries: Array<any>): string {
const prefix = (window as any).ngrxGraphqlPrefix || '';
let query: string | undefined = '';
let selector: ENTITY_SELECTOR | undefined;
let params: Record<string, any> | null | string | undefined;
Function callback
has 60 lines of code (exceeds 25 allowed). Consider refactoring. Open
const callback = (
cacheLevel: string,
state: STORE,
cache: CACHE<STORE>,
source: PARENT_ENTITY,
Function func
has 51 lines of code (exceeds 25 allowed). Consider refactoring. Open
export const func = (state: any, selector: ENTITY_SELECTOR, entity: any, meta?: {skipFields?: Array<keyof any>}) => {
if (typeof entity !== 'object') {
throw new Error('Entity is not an object');
}
const id = selector.idSelector(entity);
Function rootEntities
has 48 lines of code (exceeds 25 allowed). Consider refactoring. Open
export function rootEntities<STORE, ENTITY, TRANSFORMED>(
rootSelector: HANDLER_ROOT_ENTITY<STORE, ENTITY, TRANSFORMED, ID_TYPES>,
): HANDLER_ROOT_ENTITIES<STORE, ENTITY, ENTITY | TRANSFORMED, ID_TYPES> {
const cacheMap = new Map<string, Array<ENTITY | TRANSFORMED>>();
const emptyResult: Array<ENTITY | TRANSFORMED> = [];
Function rootEntities
has a Cognitive Complexity of 20 (exceeds 10 allowed). Consider refactoring. Open
export function rootEntities<STORE, ENTITY, TRANSFORMED>(
rootSelector: HANDLER_ROOT_ENTITY<STORE, ENTITY, TRANSFORMED, ID_TYPES>,
): HANDLER_ROOT_ENTITIES<STORE, ENTITY, ENTITY | TRANSFORMED, ID_TYPES> {
const cacheMap = new Map<string, Array<ENTITY | TRANSFORMED>>();
const emptyResult: Array<ENTITY | TRANSFORMED> = [];
- 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 callback
has 44 lines of code (exceeds 25 allowed). Consider refactoring. Open
const callback = (
state: STORE,
idOrSelector: undefined | null | ID_TYPES | STORE_SELECTOR<STORE, undefined | null | ID_TYPES>,
) => {
const id = typeof idOrSelector === 'function' ? idOrSelector(state) : idOrSelector;
Function func
has a Cognitive Complexity of 19 (exceeds 10 allowed). Consider refactoring. Open
export const func = (state: any, selector: ENTITY_SELECTOR, entity: any, meta?: {skipFields?: Array<keyof any>}) => {
if (typeof entity !== 'object') {
throw new Error('Entity is not an object');
}
const id = selector.idSelector(entity);
- 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"