@kubb/agent 4.33.2 → 4.33.3

package/.output/server/node_modules/ajv/lib/compile/codegen/scope.ts

@@ -0,0 +1,215 @@
+import {_, nil, Code, Name} from "./code"
+
+interface NameGroup {
+  prefix: string
+  index: number
+}
+
+export interface NameValue {
+  ref: ValueReference // this is the reference to any value that can be referred to from generated code via `globals` var in the closure
+  key?: unknown // any key to identify a global to avoid duplicates, if not passed ref is used
+  code?: Code // this is the code creating the value needed for standalone code wit_out closure - can be a primitive value, function or import (`require`)
+}
+
+export type ValueReference = unknown // possibly make CodeGen parameterized type on this type
+
+class ValueError extends Error {
+  readonly value?: NameValue
+  constructor(name: ValueScopeName) {
+    super(`CodeGen: "code" for ${name} not defined`)
+    this.value = name.value
+  }
+}
+
+interface ScopeOptions {
+  prefixes?: Set<string>
+  parent?: Scope
+}
+
+interface ValueScopeOptions extends ScopeOptions {
+  scope: ScopeStore
+  es5?: boolean
+  lines?: boolean
+}
+
+export type ScopeStore = Record<string, ValueReference[] | undefined>
+
+type ScopeValues = {
+  [Prefix in string]?: Map<unknown, ValueScopeName>
+}
+
+export type ScopeValueSets = {
+  [Prefix in string]?: Set<ValueScopeName>
+}
+
+export enum UsedValueState {
+  Started,
+  Completed,
+}
+
+export type UsedScopeValues = {
+  [Prefix in string]?: Map<ValueScopeName, UsedValueState | undefined>
+}
+
+export const varKinds = {
+  const: new Name("const"),
+  let: new Name("let"),
+  var: new Name("var"),
+}
+
+export class Scope {
+  protected readonly _names: {[Prefix in string]?: NameGroup} = {}
+  protected readonly _prefixes?: Set<string>
+  protected readonly _parent?: Scope
+
+  constructor({prefixes, parent}: ScopeOptions = {}) {
+    this._prefixes = prefixes
+    this._parent = parent
+  }
+
+  toName(nameOrPrefix: Name | string): Name {
+    return nameOrPrefix instanceof Name ? nameOrPrefix : this.name(nameOrPrefix)
+  }
+
+  name(prefix: string): Name {
+    return new Name(this._newName(prefix))
+  }
+
+  protected _newName(prefix: string): string {
+    const ng = this._names[prefix] || this._nameGroup(prefix)
+    return `${prefix}${ng.index++}`
+  }
+
+  private _nameGroup(prefix: string): NameGroup {
+    if (this._parent?._prefixes?.has(prefix) || (this._prefixes && !this._prefixes.has(prefix))) {
+      throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`)
+    }
+    return (this._names[prefix] = {prefix, index: 0})
+  }
+}
+
+interface ScopePath {
+  property: string
+  itemIndex: number
+}
+
+export class ValueScopeName extends Name {
+  readonly prefix: string
+  value?: NameValue
+  scopePath?: Code
+
+  constructor(prefix: string, nameStr: string) {
+    super(nameStr)
+    this.prefix = prefix
+  }
+
+  setValue(value: NameValue, {property, itemIndex}: ScopePath): void {
+    this.value = value
+    this.scopePath = _`.${new Name(property)}[${itemIndex}]`
+  }
+}
+
+interface VSOptions extends ValueScopeOptions {
+  _n: Code
+}
+
+const line = _`\n`
+
+export class ValueScope extends Scope {
+  protected readonly _values: ScopeValues = {}
+  protected readonly _scope: ScopeStore
+  readonly opts: VSOptions
+
+  constructor(opts: ValueScopeOptions) {
+    super(opts)
+    this._scope = opts.scope
+    this.opts = {...opts, _n: opts.lines ? line : nil}
+  }
+
+  get(): ScopeStore {
+    return this._scope
+  }
+
+  name(prefix: string): ValueScopeName {
+    return new ValueScopeName(prefix, this._newName(prefix))
+  }
+
+  value(nameOrPrefix: ValueScopeName | string, value: NameValue): ValueScopeName {
+    if (value.ref === undefined) throw new Error("CodeGen: ref must be passed in value")
+    const name = this.toName(nameOrPrefix) as ValueScopeName
+    const {prefix} = name
+    const valueKey = value.key ?? value.ref
+    let vs = this._values[prefix]
+    if (vs) {
+      const _name = vs.get(valueKey)
+      if (_name) return _name
+    } else {
+      vs = this._values[prefix] = new Map()
+    }
+    vs.set(valueKey, name)
+
+    const s = this._scope[prefix] || (this._scope[prefix] = [])
+    const itemIndex = s.length
+    s[itemIndex] = value.ref
+    name.setValue(value, {property: prefix, itemIndex})
+    return name
+  }
+
+  getValue(prefix: string, keyOrRef: unknown): ValueScopeName | undefined {
+    const vs = this._values[prefix]
+    if (!vs) return
+    return vs.get(keyOrRef)
+  }
+
+  scopeRefs(scopeName: Name, values: ScopeValues | ScopeValueSets = this._values): Code {
+    return this._reduceValues(values, (name: ValueScopeName) => {
+      if (name.scopePath === undefined) throw new Error(`CodeGen: name "${name}" has no value`)
+      return _`${scopeName}${name.scopePath}`
+    })
+  }
+
+  scopeCode(
+    values: ScopeValues | ScopeValueSets = this._values,
+    usedValues?: UsedScopeValues,
+    getCode?: (n: ValueScopeName) => Code | undefined
+  ): Code {
+    return this._reduceValues(
+      values,
+      (name: ValueScopeName) => {
+        if (name.value === undefined) throw new Error(`CodeGen: name "${name}" has no value`)
+        return name.value.code
+      },
+      usedValues,
+      getCode
+    )
+  }
+
+  private _reduceValues(
+    values: ScopeValues | ScopeValueSets,
+    valueCode: (n: ValueScopeName) => Code | undefined,
+    usedValues: UsedScopeValues = {},
+    getCode?: (n: ValueScopeName) => Code | undefined
+  ): Code {
+    let code: Code = nil
+    for (const prefix in values) {
+      const vs = values[prefix]
+      if (!vs) continue
+      const nameSet = (usedValues[prefix] = usedValues[prefix] || new Map())
+      vs.forEach((name: ValueScopeName) => {
+        if (nameSet.has(name)) return
+        nameSet.set(name, UsedValueState.Started)
+        let c = valueCode(name)
+        if (c) {
+          const def = this.opts.es5 ? varKinds.var : varKinds.const
+          code = _`${code}${def} ${name} = ${c};${this.opts._n}`
+        } else if ((c = getCode?.(name))) {
+          code = _`${code}${c}${this.opts._n}`
+        } else {
+          throw new ValueError(name)
+        }
+        nameSet.set(name, UsedValueState.Completed)
+      })
+    }
+    return code
+  }
+}

package/.output/server/node_modules/ajv/lib/compile/errors.ts

@@ -0,0 +1,184 @@
+import type {KeywordErrorCxt, KeywordErrorDefinition} from "../types"
+import type {SchemaCxt} from "./index"
+import {CodeGen, _, str, strConcat, Code, Name} from "./codegen"
+import {SafeExpr} from "./codegen/code"
+import {getErrorPath, Type} from "./util"
+import N from "./names"
+
+export const keywordError: KeywordErrorDefinition = {
+  message: ({keyword}) => str`must pass "${keyword}" keyword validation`,
+}
+
+export const keyword$DataError: KeywordErrorDefinition = {
+  message: ({keyword, schemaType}) =>
+    schemaType
+      ? str`"${keyword}" keyword must be ${schemaType} ($data)`
+      : str`"${keyword}" keyword is invalid ($data)`,
+}
+
+export interface ErrorPaths {
+  instancePath?: Code
+  schemaPath?: string
+  parentSchema?: boolean
+}
+
+export function reportError(
+  cxt: KeywordErrorCxt,
+  error: KeywordErrorDefinition = keywordError,
+  errorPaths?: ErrorPaths,
+  overrideAllErrors?: boolean
+): void {
+  const {it} = cxt
+  const {gen, compositeRule, allErrors} = it
+  const errObj = errorObjectCode(cxt, error, errorPaths)
+  if (overrideAllErrors ?? (compositeRule || allErrors)) {
+    addError(gen, errObj)
+  } else {
+    returnErrors(it, _`[${errObj}]`)
+  }
+}
+
+export function reportExtraError(
+  cxt: KeywordErrorCxt,
+  error: KeywordErrorDefinition = keywordError,
+  errorPaths?: ErrorPaths
+): void {
+  const {it} = cxt
+  const {gen, compositeRule, allErrors} = it
+  const errObj = errorObjectCode(cxt, error, errorPaths)
+  addError(gen, errObj)
+  if (!(compositeRule || allErrors)) {
+    returnErrors(it, N.vErrors)
+  }
+}
+
+export function resetErrorsCount(gen: CodeGen, errsCount: Name): void {
+  gen.assign(N.errors, errsCount)
+  gen.if(_`${N.vErrors} !== null`, () =>
+    gen.if(
+      errsCount,
+      () => gen.assign(_`${N.vErrors}.length`, errsCount),
+      () => gen.assign(N.vErrors, null)
+    )
+  )
+}
+
+export function extendErrors({
+  gen,
+  keyword,
+  schemaValue,
+  data,
+  errsCount,
+  it,
+}: KeywordErrorCxt): void {
+  /* istanbul ignore if */
+  if (errsCount === undefined) throw new Error("ajv implementation error")
+  const err = gen.name("err")
+  gen.forRange("i", errsCount, N.errors, (i) => {
+    gen.const(err, _`${N.vErrors}[${i}]`)
+    gen.if(_`${err}.instancePath === undefined`, () =>
+      gen.assign(_`${err}.instancePath`, strConcat(N.instancePath, it.errorPath))
+    )
+    gen.assign(_`${err}.schemaPath`, str`${it.errSchemaPath}/${keyword}`)
+    if (it.opts.verbose) {
+      gen.assign(_`${err}.schema`, schemaValue)
+      gen.assign(_`${err}.data`, data)
+    }
+  })
+}
+
+function addError(gen: CodeGen, errObj: Code): void {
+  const err = gen.const("err", errObj)
+  gen.if(
+    _`${N.vErrors} === null`,
+    () => gen.assign(N.vErrors, _`[${err}]`),
+    _`${N.vErrors}.push(${err})`
+  )
+  gen.code(_`${N.errors}++`)
+}
+
+function returnErrors(it: SchemaCxt, errs: Code): void {
+  const {gen, validateName, schemaEnv} = it
+  if (schemaEnv.$async) {
+    gen.throw(_`new ${it.ValidationError as Name}(${errs})`)
+  } else {
+    gen.assign(_`${validateName}.errors`, errs)
+    gen.return(false)
+  }
+}
+
+const E = {
+  keyword: new Name("keyword"),
+  schemaPath: new Name("schemaPath"), // also used in JTD errors
+  params: new Name("params"),
+  propertyName: new Name("propertyName"),
+  message: new Name("message"),
+  schema: new Name("schema"),
+  parentSchema: new Name("parentSchema"),
+}
+
+function errorObjectCode(
+  cxt: KeywordErrorCxt,
+  error: KeywordErrorDefinition,
+  errorPaths?: ErrorPaths
+): Code {
+  const {createErrors} = cxt.it
+  if (createErrors === false) return _`{}`
+  return errorObject(cxt, error, errorPaths)
+}
+
+function errorObject(
+  cxt: KeywordErrorCxt,
+  error: KeywordErrorDefinition,
+  errorPaths: ErrorPaths = {}
+): Code {
+  const {gen, it} = cxt
+  const keyValues: [Name, SafeExpr | string][] = [
+    errorInstancePath(it, errorPaths),
+    errorSchemaPath(cxt, errorPaths),
+  ]
+  extraErrorProps(cxt, error, keyValues)
+  return gen.object(...keyValues)
+}
+
+function errorInstancePath({errorPath}: SchemaCxt, {instancePath}: ErrorPaths): [Name, Code] {
+  const instPath = instancePath
+    ? str`${errorPath}${getErrorPath(instancePath, Type.Str)}`
+    : errorPath
+  return [N.instancePath, strConcat(N.instancePath, instPath)]
+}
+
+function errorSchemaPath(
+  {keyword, it: {errSchemaPath}}: KeywordErrorCxt,
+  {schemaPath, parentSchema}: ErrorPaths
+): [Name, string | Code] {
+  let schPath = parentSchema ? errSchemaPath : str`${errSchemaPath}/${keyword}`
+  if (schemaPath) {
+    schPath = str`${schPath}${getErrorPath(schemaPath, Type.Str)}`
+  }
+  return [E.schemaPath, schPath]
+}
+
+function extraErrorProps(
+  cxt: KeywordErrorCxt,
+  {params, message}: KeywordErrorDefinition,
+  keyValues: [Name, SafeExpr | string][]
+): void {
+  const {keyword, data, schemaValue, it} = cxt
+  const {opts, propertyName, topSchemaRef, schemaPath} = it
+  keyValues.push(
+    [E.keyword, keyword],
+    [E.params, typeof params == "function" ? params(cxt) : params || _`{}`]
+  )
+  if (opts.messages) {
+    keyValues.push([E.message, typeof message == "function" ? message(cxt) : message])
+  }
+  if (opts.verbose) {
+    keyValues.push(
+      [E.schema, schemaValue],
+      [E.parentSchema, _`${topSchemaRef}${schemaPath}`],
+      [N.data, data]
+    )
+  }
+  if (propertyName) keyValues.push([E.propertyName, propertyName])
+}