File core.ts has 765 lines of code (exceeds 250 allowed). Consider refactoring.

Open

export {
  Format,
  FormatDefinition,
  AsyncFormatDefinition,
  KeywordDefinition,

File index.ts has 664 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import type {ScopeValueSets, NameValue, ValueScope, ValueScopeName} from "./scope"
import {_, nil, _Code, Code, Name, UsedNames, CodeItem, addCodeArg, _CodeOrName} from "./code"
import {Scope, varKinds} from "./scope"

export {_, str, strConcat, nil, getProperty, stringify, regexpCode, Name, Code} from "./code"

File index.ts has 515 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import type {
  AddedKeywordDefinition,
  AnySchema,
  AnySchemaObject,
  KeywordErrorCxt,

Function standaloneCode has a Cognitive Complexity of 43 (exceeds 5 allowed). Consider refactoring.

Open

function standaloneCode(
  ajv: AjvCore,
  refsOrFunc?: {[K in string]?: string} | AnyValidateFunction
): string {
  if (!ajv.opts.code.source) {

• Read up
  Read up

Function code has a Cognitive Complexity of 40 (exceeds 5 allowed). Consider refactoring.

Open

  code(cxt: KeywordCxt, ruleType?: string) {
    const {gen, data, $data, schema, schemaCode, it} = cxt
    const {opts, errSchemaPath, schemaEnv, self} = it
    if (!opts.validateFormats) return

• Read up
  Read up

CodeGen has 43 functions (exceeds 20 allowed). Consider refactoring.

Open

export class CodeGen {
  readonly _scope: Scope
  readonly _extScope: ValueScope
  readonly _values: ScopeValueSets = {}
  private readonly _nodes: ParentNode[]

Function code has a Cognitive Complexity of 37 (exceeds 5 allowed). Consider refactoring.

Open

  code(cxt: KeywordCxt) {
    const {gen, data, schema, parentSchema, it} = cxt
    const {oneOf} = parentSchema
    if (!it.opts.discriminator) {
      throw new Error("discriminator: requires discriminator option")

• Read up
  Read up

Function validateProperties has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.

Open

export function validateProperties(cxt: KeywordCxt): void {
  checkMetadata(cxt)
  const {gen, data, parentSchema, it} = cxt
  const {additionalProperties, nullable} = parentSchema
  if (it.jtdDiscriminator && nullable) throw new Error("JTD: nullable inside discriminator mapping")

• Read up
  Read up

File parse.ts has 373 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import type Ajv from "../../core"
import type {SchemaObject} from "../../types"
import {jtdForms, JTDForm, SchemaObjectMap} from "./types"
import {SchemaEnv, getCompilingSchema} from ".."
import {_, str, and, or, nil, not, CodeGen, Code, Name, SafeExpr} from "../codegen"

Function parseJsonString has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring.

Open

export function parseJsonString(s: string, pos: number): string | undefined {
  let str = ""
  let c: string | undefined
  parseJsonString.message = undefined
  // eslint-disable-next-line no-constant-condition, @typescript-eslint/no-unnecessary-condition

• Read up
  Read up

Function validateProperties has 112 lines of code (exceeds 25 allowed). Consider refactoring.

Open

export function validateProperties(cxt: KeywordCxt): void {
  checkMetadata(cxt)
  const {gen, data, parentSchema, it} = cxt
  const {additionalProperties, nullable} = parentSchema
  if (it.jtdDiscriminator && nullable) throw new Error("JTD: nullable inside discriminator mapping")

Function code has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.

Open

  code(cxt) {
    const {gen, schema, parentSchema, data, errsCount, it} = cxt
    /* istanbul ignore if */
    if (!errsCount) throw new Error("ajv implementation error")
    const {allErrors, opts} = it

• Read up
  Read up

Function callRef has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.

Open

export function callRef(cxt: KeywordCxt, v: Code, sch?: SchemaEnv, $async?: boolean): void {
  const {gen, it} = cxt
  const {allErrors, schemaEnv: env, opts} = it
  const passCxt = opts.passContext ? N.this : nil
  if ($async) callAsyncRef()

• Read up
  Read up

Function compileSchema has 82 lines of code (exceeds 25 allowed). Consider refactoring.

Open

export function compileSchema(this: Ajv, sch: SchemaEnv): SchemaEnv {
  // TODO refactor - remove compilations
  const _sch = getCompilingSchema.call(this, sch)
  if (_sch) return _sch
  const rootId = getFullPath(this.opts.uriResolver, sch.root.baseId) // TODO if getFullPath removed 1 tests fails

Function parseJsonNumber has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.

Open

export function parseJsonNumber(s: string, pos: number, maxDigits?: number): number | undefined {
  let numStr = ""
  let c: string
  parseJsonNumber.message = undefined
  if (s[pos] === "-") {

• Read up
  Read up

Function funcKeywordCode has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.

Open

export function funcKeywordCode(cxt: KeywordCxt, def: FuncKeywordDefinition): void {
  const {gen, keyword, schema, parentSchema, $data, it} = cxt
  checkAsyncKeyword(it, def)
  const validate =
    !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate

• Read up
  Read up

Function code has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.

Open

  code(cxt: KeywordCxt) {
    const {gen, schema, parentSchema, data, it} = cxt
    let min: number
    let max: number | undefined
    const {minContains, maxContains} = parentSchema

• Read up
  Read up

Function code has 76 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  code(cxt: KeywordCxt) {
    const {gen, data, schema, parentSchema, it} = cxt
    const {oneOf} = parentSchema
    if (!it.opts.discriminator) {
      throw new Error("discriminator: requires discriminator option")

Function standaloneCode has 75 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function standaloneCode(
  ajv: AjvCore,
  refsOrFunc?: {[K in string]?: string} | AnyValidateFunction
): string {
  if (!ajv.opts.code.source) {

Function code has 73 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  code(cxt) {
    const {gen, schema, parentSchema, data, errsCount, it} = cxt
    /* istanbul ignore if */
    if (!errsCount) throw new Error("ajv implementation error")
    const {allErrors, opts} = it