Showing 29 of 33 total issues
File getSet.ts
has 333 lines of code (exceeds 250 allowed). Consider refactoring. Open
/* eslint-disable security/detect-object-injection */
import mapAny from 'map-any'
import modify from './modify.js'
import {
getStateValue,
Function getSet
has 54 lines of code (exceeds 25 allowed). Consider refactoring. Open
function getSet(isSet = false) {
return (path: string | number): Operation => {
if (typeof path === 'string') {
if (path === '$modify') {
return modifyOnSet(isSet)
File definitionHelpers.ts
has 255 lines of code (exceeds 250 allowed). Consider refactoring. Open
import { getStateValue, setStateValue } from './stateHelpers.js'
import modifyOperationObject from './modifyOperationObject.js'
import { noopNext } from '../utils/stateHelpers.js'
import { isObject } from './is.js'
import { get } from '../operations/getSet.js'
Function sortIntoBuckets
has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring. Open
async function sortIntoBuckets(
getFn: DataMapperWithState | AsyncDataMapperWithState,
pipelines: PipelineWithKey[],
getGroupFn: DataMapperWithState | AsyncDataMapperWithState | undefined,
data: unknown,
- 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 operationFromObject
has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring. Open
function operationFromObject(
defRaw: OperationObject | TransformObject,
options: Options,
): Operation | Operation[] {
const def = modifyOperationObject(defRaw, options.modifyOperationObject)
- 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 getByPart
has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring. Open
(part: string | number, isArr: boolean) => (value: unknown) => {
if (typeof part === 'string') {
if (isObject(value)) {
const nextValue = value[part]
return isArr ? ensureArray(nextValue) : nextValue
- 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 doGetSet
has 39 lines of code (exceeds 25 allowed). Consider refactoring. Open
async function doGetSet(state) {
if (adjustIsSet(isSet, state)) {
// Set
// We'll go backwards first. Start by preparing target for the next set
const target = getTargetFromState(state)
Function setByPart
has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring. Open
(part: string | number, isArr: boolean, doIterate: boolean) =>
(value: unknown) => {
const data = isArr ? ensureArray(value) : value
if (typeof part === 'number') {
const arr = []
- 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 compare
has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring. Open
const compare = (direction: number) =>
function compare([a]: SortValue, [b]: SortValue) {
if (typeof a === 'number' && typeof b === 'number') {
return compareNumbers(a, b, direction)
} else if (a instanceof Date && b instanceof Date) {
- 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 defToOperations
has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring. Open
export const defToOperations = (
def: TransformDefinition | undefined,
options: Options,
): Operation[] | Operation =>
isPipeline(def)
- 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 operationFromObject
has 26 lines of code (exceeds 25 allowed). Consider refactoring. Open
function operationFromObject(
defRaw: OperationObject | TransformObject,
options: Options,
): Operation | Operation[] {
const def = modifyOperationObject(defRaw, options.modifyOperationObject)
Function filterValue
has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring. Open
async function filterValue(
values: unknown,
filterFn: DataMapperWithState | AsyncDataMapperWithState,
state: State,
) {
- 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 sort
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
const transformer: Transformer<Props> = function sort(props) {
return () => {
const { path, asc } = props || {}
if (typeof path !== 'string' && path !== undefined) {
throw new TypeError(
- 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 sortIntoBuckets
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
getFn: DataMapperWithState | AsyncDataMapperWithState,
pipelines: PipelineWithKey[],
getGroupFn: DataMapperWithState | AsyncDataMapperWithState | undefined,
data: unknown,
state: State,
Function shouldGoInBucket
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
function shouldGoInBucket(
options: Options,
condition?: TransformDefinition,
size?: number,
): AsyncDataMapperWithState {
- 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 createOperation
has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring. Open
<U extends OperationObject>(
operationFn: (
fn: DataMapperWithOptions | AsyncDataMapperWithOptions,
) => Operation,
fnProp: 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
Avoid too many return
statements within this function. Open
return props(def as TransformObject)
Avoid too many return
statements within this function. Open
return createConcatOperation(concat, def.$concat)
Avoid too many return
statements within this function. Open
return createAltOperation(alt, def)
Avoid too many return
statements within this function. Open
return (obj: Record<string, unknown>) => obj