@jsonstudio/rcc 0.89.611 → 0.89.683

package/node_modules/ajv/lib/vocabularies/jtd/metadata.ts

@@ -1,24 +0,0 @@
-import {KeywordCxt} from "../../ajv"
-import type {CodeKeywordDefinition} from "../../types"
-import {alwaysValidSchema} from "../../compile/util"
-
-const def: CodeKeywordDefinition = {
-  keyword: "metadata",
-  schemaType: "object",
-  code(cxt: KeywordCxt) {
-    checkMetadata(cxt)
-    const {gen, schema, it} = cxt
-    if (alwaysValidSchema(it, schema)) return
-    const valid = gen.name("valid")
-    cxt.subschema({keyword: "metadata", jtdMetadata: true}, valid)
-    cxt.ok(valid)
-  },
-}
-
-export function checkMetadata({it, keyword}: KeywordCxt, metadata?: boolean): void {
-  if (it.jtdMetadata !== metadata) {
-    throw new Error(`JTD: "${keyword}" cannot be used in this schema location`)
-  }
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/jtd/nullable.ts

@@ -1,21 +0,0 @@
-import type {KeywordCxt} from "../../compile/validate"
-import {_, not, nil, Code, Name} from "../../compile/codegen"
-
-export function checkNullable(
-  {gen, data, parentSchema}: KeywordCxt,
-  cond: Code = nil
-): [Name, Code] {
-  const valid = gen.name("valid")
-  if (parentSchema.nullable) {
-    gen.let(valid, _`${data} === null`)
-    cond = not(valid)
-  } else {
-    gen.let(valid, false)
-  }
-  return [valid, cond]
-}
-
-export function checkNullableObject(cxt: KeywordCxt, cond: Code): [Name, Code] {
-  const [valid, cond_] = checkNullable(cxt, cond)
-  return [valid, _`${cond_} && typeof ${cxt.data} == "object" && !Array.isArray(${cxt.data})`]
-}

package/node_modules/ajv/lib/vocabularies/jtd/optionalProperties.ts

@@ -1,15 +0,0 @@
-import type {CodeKeywordDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {validateProperties, error} from "./properties"
-
-const def: CodeKeywordDefinition = {
-  keyword: "optionalProperties",
-  schemaType: "object",
-  error,
-  code(cxt: KeywordCxt) {
-    if (cxt.parentSchema.properties) return
-    validateProperties(cxt)
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/jtd/properties.ts

@@ -1,184 +0,0 @@
-import type {
-  CodeKeywordDefinition,
-  ErrorObject,
-  KeywordErrorDefinition,
-  SchemaObject,
-} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {propertyInData, allSchemaProperties, isOwnProperty} from "../code"
-import {alwaysValidSchema, schemaRefOrVal} from "../../compile/util"
-import {_, and, not, Code, Name} from "../../compile/codegen"
-import {checkMetadata} from "./metadata"
-import {checkNullableObject} from "./nullable"
-import {typeErrorMessage, typeErrorParams, _JTDTypeError} from "./error"
-
-enum PropError {
-  Additional = "additional",
-  Missing = "missing",
-}
-
-type PropKeyword = "properties" | "optionalProperties"
-
-type PropSchema = {[P in string]?: SchemaObject}
-
-export type JTDPropertiesError =
-  | _JTDTypeError<PropKeyword, "object", PropSchema>
-  | ErrorObject<PropKeyword, {error: PropError.Additional; additionalProperty: string}, PropSchema>
-  | ErrorObject<PropKeyword, {error: PropError.Missing; missingProperty: string}, PropSchema>
-
-export const error: KeywordErrorDefinition = {
-  message: (cxt) => {
-    const {params} = cxt
-    return params.propError
-      ? params.propError === PropError.Additional
-        ? "must NOT have additional properties"
-        : `must have property '${params.missingProperty}'`
-      : typeErrorMessage(cxt, "object")
-  },
-  params: (cxt) => {
-    const {params} = cxt
-    return params.propError
-      ? params.propError === PropError.Additional
-        ? _`{error: ${params.propError}, additionalProperty: ${params.additionalProperty}}`
-        : _`{error: ${params.propError}, missingProperty: ${params.missingProperty}}`
-      : typeErrorParams(cxt, "object")
-  },
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "properties",
-  schemaType: "object",
-  error,
-  code: validateProperties,
-}
-
-// const error: KeywordErrorDefinition = {
-//   message: "should NOT have additional properties",
-//   params: ({params}) => _`{additionalProperty: ${params.additionalProperty}}`,
-// }
-
-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")
-  if (commonProperties()) {
-    throw new Error("JTD: properties and optionalProperties have common members")
-  }
-  const [allProps, properties] = schemaProperties("properties")
-  const [allOptProps, optProperties] = schemaProperties("optionalProperties")
-  if (properties.length === 0 && optProperties.length === 0 && additionalProperties) {
-    return
-  }
-
-  const [valid, cond] =
-    it.jtdDiscriminator === undefined
-      ? checkNullableObject(cxt, data)
-      : [gen.let("valid", false), true]
-  gen.if(cond, () =>
-    gen.assign(valid, true).block(() => {
-      validateProps(properties, "properties", true)
-      validateProps(optProperties, "optionalProperties")
-      if (!additionalProperties) validateAdditional()
-    })
-  )
-  cxt.pass(valid)
-
-  function commonProperties(): boolean {
-    const props = parentSchema.properties as Record<string, any> | undefined
-    const optProps = parentSchema.optionalProperties as Record<string, any> | undefined
-    if (!(props && optProps)) return false
-    for (const p in props) {
-      if (Object.prototype.hasOwnProperty.call(optProps, p)) return true
-    }
-    return false
-  }
-
-  function schemaProperties(keyword: string): [string[], string[]] {
-    const schema = parentSchema[keyword]
-    const allPs = schema ? allSchemaProperties(schema) : []
-    if (it.jtdDiscriminator && allPs.some((p) => p === it.jtdDiscriminator)) {
-      throw new Error(`JTD: discriminator tag used in ${keyword}`)
-    }
-    const ps = allPs.filter((p) => !alwaysValidSchema(it, schema[p]))
-    return [allPs, ps]
-  }
-
-  function validateProps(props: string[], keyword: string, required?: boolean): void {
-    const _valid = gen.var("valid")
-    for (const prop of props) {
-      gen.if(
-        propertyInData(gen, data, prop, it.opts.ownProperties),
-        () => applyPropertySchema(prop, keyword, _valid),
-        () => missingProperty(prop)
-      )
-      cxt.ok(_valid)
-    }
-
-    function missingProperty(prop: string): void {
-      if (required) {
-        gen.assign(_valid, false)
-        cxt.error(false, {propError: PropError.Missing, missingProperty: prop}, {schemaPath: prop})
-      } else {
-        gen.assign(_valid, true)
-      }
-    }
-  }
-
-  function applyPropertySchema(prop: string, keyword: string, _valid: Name): void {
-    cxt.subschema(
-      {
-        keyword,
-        schemaProp: prop,
-        dataProp: prop,
-      },
-      _valid
-    )
-  }
-
-  function validateAdditional(): void {
-    gen.forIn("key", data, (key: Name) => {
-      const addProp = isAdditional(key, allProps, "properties", it.jtdDiscriminator)
-      const addOptProp = isAdditional(key, allOptProps, "optionalProperties")
-      const extra =
-        addProp === true ? addOptProp : addOptProp === true ? addProp : and(addProp, addOptProp)
-      gen.if(extra, () => {
-        if (it.opts.removeAdditional) {
-          gen.code(_`delete ${data}[${key}]`)
-        } else {
-          cxt.error(
-            false,
-            {propError: PropError.Additional, additionalProperty: key},
-            {instancePath: key, parentSchema: true}
-          )
-          if (!it.opts.allErrors) gen.break()
-        }
-      })
-    })
-  }
-
-  function isAdditional(
-    key: Name,
-    props: string[],
-    keyword: string,
-    jtdDiscriminator?: string
-  ): Code | true {
-    let additional: Code | boolean
-    if (props.length > 8) {
-      // TODO maybe an option instead of hard-coded 8?
-      const propsSchema = schemaRefOrVal(it, parentSchema[keyword], keyword)
-      additional = not(isOwnProperty(gen, propsSchema as Code, key))
-      if (jtdDiscriminator !== undefined) {
-        additional = and(additional, _`${key} !== ${jtdDiscriminator}`)
-      }
-    } else if (props.length || jtdDiscriminator !== undefined) {
-      const ps = jtdDiscriminator === undefined ? props : [jtdDiscriminator].concat(props)
-      additional = and(...ps.map((p) => _`${key} !== ${p}`))
-    } else {
-      additional = true
-    }
-    return additional
-  }
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/jtd/ref.ts

@@ -1,76 +0,0 @@
-import type {CodeKeywordDefinition, AnySchemaObject} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {compileSchema, SchemaEnv} from "../../compile"
-import {_, not, nil, stringify} from "../../compile/codegen"
-import MissingRefError from "../../compile/ref_error"
-import N from "../../compile/names"
-import {getValidate, callRef} from "../core/ref"
-import {checkMetadata} from "./metadata"
-
-const def: CodeKeywordDefinition = {
-  keyword: "ref",
-  schemaType: "string",
-  code(cxt: KeywordCxt) {
-    checkMetadata(cxt)
-    const {gen, data, schema: ref, parentSchema, it} = cxt
-    const {
-      schemaEnv: {root},
-    } = it
-    const valid = gen.name("valid")
-    if (parentSchema.nullable) {
-      gen.var(valid, _`${data} === null`)
-      gen.if(not(valid), validateJtdRef)
-    } else {
-      gen.var(valid, false)
-      validateJtdRef()
-    }
-    cxt.ok(valid)
-
-    function validateJtdRef(): void {
-      const refSchema = (root.schema as AnySchemaObject).definitions?.[ref]
-      if (!refSchema) {
-        throw new MissingRefError(it.opts.uriResolver, "", ref, `No definition ${ref}`)
-      }
-      if (hasRef(refSchema) || !it.opts.inlineRefs) callValidate(refSchema)
-      else inlineRefSchema(refSchema)
-    }
-
-    function callValidate(schema: AnySchemaObject): void {
-      const sch = compileSchema.call(
-        it.self,
-        new SchemaEnv({schema, root, schemaPath: `/definitions/${ref}`})
-      )
-      const v = getValidate(cxt, sch)
-      const errsCount = gen.const("_errs", N.errors)
-      callRef(cxt, v, sch, sch.$async)
-      gen.assign(valid, _`${errsCount} === ${N.errors}`)
-    }
-
-    function inlineRefSchema(schema: AnySchemaObject): void {
-      const schName = gen.scopeValue(
-        "schema",
-        it.opts.code.source === true ? {ref: schema, code: stringify(schema)} : {ref: schema}
-      )
-      cxt.subschema(
-        {
-          schema,
-          dataTypes: [],
-          schemaPath: nil,
-          topSchemaRef: schName,
-          errSchemaPath: `/definitions/${ref}`,
-        },
-        valid
-      )
-    }
-  },
-}
-
-export function hasRef(schema: AnySchemaObject): boolean {
-  for (const key in schema) {
-    let sch: AnySchemaObject
-    if (key === "ref" || (typeof (sch = schema[key]) == "object" && hasRef(sch))) return true
-  }
-  return false
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/jtd/type.ts

@@ -1,75 +0,0 @@
-import type {CodeKeywordDefinition, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, nil, or, Code} from "../../compile/codegen"
-import validTimestamp from "../../runtime/timestamp"
-import {useFunc} from "../../compile/util"
-import {checkMetadata} from "./metadata"
-import {typeErrorMessage, typeErrorParams, _JTDTypeError} from "./error"
-
-export type JTDTypeError = _JTDTypeError<"type", JTDType, JTDType>
-
-export type IntType = "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32"
-
-export const intRange: {[T in IntType]: [number, number, number]} = {
-  int8: [-128, 127, 3],
-  uint8: [0, 255, 3],
-  int16: [-32768, 32767, 5],
-  uint16: [0, 65535, 5],
-  int32: [-2147483648, 2147483647, 10],
-  uint32: [0, 4294967295, 10],
-}
-
-export type JTDType = "boolean" | "string" | "timestamp" | "float32" | "float64" | IntType
-
-const error: KeywordErrorDefinition = {
-  message: (cxt) => typeErrorMessage(cxt, cxt.schema),
-  params: (cxt) => typeErrorParams(cxt, cxt.schema),
-}
-
-function timestampCode(cxt: KeywordCxt): Code {
-  const {gen, data, it} = cxt
-  const {timestamp, allowDate} = it.opts
-  if (timestamp === "date") return _`${data} instanceof Date `
-  const vts = useFunc(gen, validTimestamp)
-  const allowDateArg = allowDate ? _`, true` : nil
-  const validString = _`typeof ${data} == "string" && ${vts}(${data}${allowDateArg})`
-  return timestamp === "string" ? validString : or(_`${data} instanceof Date`, validString)
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "type",
-  schemaType: "string",
-  error,
-  code(cxt: KeywordCxt) {
-    checkMetadata(cxt)
-    const {data, schema, parentSchema, it} = cxt
-    let cond: Code
-    switch (schema) {
-      case "boolean":
-      case "string":
-        cond = _`typeof ${data} == ${schema}`
-        break
-      case "timestamp": {
-        cond = timestampCode(cxt)
-        break
-      }
-      case "float32":
-      case "float64":
-        cond = _`typeof ${data} == "number"`
-        break
-      default: {
-        const sch = schema as IntType
-        cond = _`typeof ${data} == "number" && isFinite(${data}) && !(${data} % 1)`
-        if (!it.opts.int32range && (sch === "int32" || sch === "uint32")) {
-          if (sch === "uint32") cond = _`${cond} && ${data} >= 0`
-        } else {
-          const [min, max] = intRange[sch]
-          cond = _`${cond} && ${data} >= ${min} && ${data} <= ${max}`
-        }
-      }
-    }
-    cxt.pass(parentSchema.nullable ? or(_`${data} === null`, cond) : cond)
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/jtd/union.ts

@@ -1,12 +0,0 @@
-import type {CodeKeywordDefinition} from "../../types"
-import {validateUnion} from "../code"
-
-const def: CodeKeywordDefinition = {
-  keyword: "union",
-  schemaType: "array",
-  trackErrors: true,
-  code: validateUnion,
-  error: {message: "must match a schema in union"},
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/jtd/values.ts

@@ -1,58 +0,0 @@
-import type {CodeKeywordDefinition, SchemaObject} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {alwaysValidSchema, Type} from "../../compile/util"
-import {not, or, Name} from "../../compile/codegen"
-import {checkMetadata} from "./metadata"
-import {checkNullableObject} from "./nullable"
-import {typeError, _JTDTypeError} from "./error"
-
-export type JTDValuesError = _JTDTypeError<"values", "object", SchemaObject>
-
-const def: CodeKeywordDefinition = {
-  keyword: "values",
-  schemaType: "object",
-  error: typeError("object"),
-  code(cxt: KeywordCxt) {
-    checkMetadata(cxt)
-    const {gen, data, schema, it} = cxt
-    const [valid, cond] = checkNullableObject(cxt, data)
-    if (alwaysValidSchema(it, schema)) {
-      gen.if(not(or(cond, valid)), () => cxt.error())
-    } else {
-      gen.if(cond)
-      gen.assign(valid, validateMap())
-      gen.elseIf(not(valid))
-      cxt.error()
-      gen.endIf()
-    }
-    cxt.ok(valid)
-
-    function validateMap(): Name | boolean {
-      const _valid = gen.name("valid")
-      if (it.allErrors) {
-        const validMap = gen.let("valid", true)
-        validateValues(() => gen.assign(validMap, false))
-        return validMap
-      }
-      gen.var(_valid, true)
-      validateValues(() => gen.break())
-      return _valid
-
-      function validateValues(notValid: () => void): void {
-        gen.forIn("key", data, (key) => {
-          cxt.subschema(
-            {
-              keyword: "values",
-              dataProp: key,
-              dataPropType: Type.Str,
-            },
-            _valid
-          )
-          gen.if(not(_valid), notValid)
-        })
-      }
-    }
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/metadata.ts

@@ -1,17 +0,0 @@
-import type {Vocabulary} from "../types"
-
-export const metadataVocabulary: Vocabulary = [
-  "title",
-  "description",
-  "default",
-  "deprecated",
-  "readOnly",
-  "writeOnly",
-  "examples",
-]
-
-export const contentVocabulary: Vocabulary = [
-  "contentMediaType",
-  "contentEncoding",
-  "contentSchema",
-]

package/node_modules/ajv/lib/vocabularies/next.ts

@@ -1,8 +0,0 @@
-import type {Vocabulary} from "../types"
-import dependentRequired from "./validation/dependentRequired"
-import dependentSchemas from "./applicator/dependentSchemas"
-import limitContains from "./validation/limitContains"
-
-const next: Vocabulary = [dependentRequired, dependentSchemas, limitContains]
-
-export default next

package/node_modules/ajv/lib/vocabularies/unevaluated/index.ts

@@ -1,7 +0,0 @@
-import type {Vocabulary} from "../../types"
-import unevaluatedProperties from "./unevaluatedProperties"
-import unevaluatedItems from "./unevaluatedItems"
-
-const unevaluated: Vocabulary = [unevaluatedProperties, unevaluatedItems]
-
-export default unevaluated

package/node_modules/ajv/lib/vocabularies/unevaluated/unevaluatedItems.ts

@@ -1,47 +0,0 @@
-import type {
-  CodeKeywordDefinition,
-  ErrorObject,
-  KeywordErrorDefinition,
-  AnySchema,
-} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, not, Name} from "../../compile/codegen"
-import {alwaysValidSchema, Type} from "../../compile/util"
-
-export type UnevaluatedItemsError = ErrorObject<"unevaluatedItems", {limit: number}, AnySchema>
-
-const error: KeywordErrorDefinition = {
-  message: ({params: {len}}) => str`must NOT have more than ${len} items`,
-  params: ({params: {len}}) => _`{limit: ${len}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "unevaluatedItems",
-  type: "array",
-  schemaType: ["boolean", "object"],
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, schema, data, it} = cxt
-    const items = it.items || 0
-    if (items === true) return
-    const len = gen.const("len", _`${data}.length`)
-    if (schema === false) {
-      cxt.setParams({len: items})
-      cxt.fail(_`${len} > ${items}`)
-    } else if (typeof schema == "object" && !alwaysValidSchema(it, schema)) {
-      const valid = gen.var("valid", _`${len} <= ${items}`)
-      gen.if(not(valid), () => validateItems(valid, items))
-      cxt.ok(valid)
-    }
-    it.items = true
-
-    function validateItems(valid: Name, from: Name | number): void {
-      gen.forRange("i", from, len, (i) => {
-        cxt.subschema({keyword: "unevaluatedItems", dataProp: i, dataPropType: Type.Num}, valid)
-        if (!it.allErrors) gen.if(not(valid), () => gen.break())
-      })
-    }
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/unevaluated/unevaluatedProperties.ts

@@ -1,85 +0,0 @@
-import type {
-  CodeKeywordDefinition,
-  KeywordErrorDefinition,
-  ErrorObject,
-  AnySchema,
-} from "../../types"
-import {_, not, and, Name, Code} from "../../compile/codegen"
-import {alwaysValidSchema, Type} from "../../compile/util"
-import N from "../../compile/names"
-
-export type UnevaluatedPropertiesError = ErrorObject<
-  "unevaluatedProperties",
-  {unevaluatedProperty: string},
-  AnySchema
->
-
-const error: KeywordErrorDefinition = {
-  message: "must NOT have unevaluated properties",
-  params: ({params}) => _`{unevaluatedProperty: ${params.unevaluatedProperty}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "unevaluatedProperties",
-  type: "object",
-  schemaType: ["boolean", "object"],
-  trackErrors: true,
-  error,
-  code(cxt) {
-    const {gen, schema, data, errsCount, it} = cxt
-    /* istanbul ignore if */
-    if (!errsCount) throw new Error("ajv implementation error")
-    const {allErrors, props} = it
-    if (props instanceof Name) {
-      gen.if(_`${props} !== true`, () =>
-        gen.forIn("key", data, (key: Name) =>
-          gen.if(unevaluatedDynamic(props, key), () => unevaluatedPropCode(key))
-        )
-      )
-    } else if (props !== true) {
-      gen.forIn("key", data, (key: Name) =>
-        props === undefined
-          ? unevaluatedPropCode(key)
-          : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key))
-      )
-    }
-    it.props = true
-    cxt.ok(_`${errsCount} === ${N.errors}`)
-
-    function unevaluatedPropCode(key: Name): void {
-      if (schema === false) {
-        cxt.setParams({unevaluatedProperty: key})
-        cxt.error()
-        if (!allErrors) gen.break()
-        return
-      }
-
-      if (!alwaysValidSchema(it, schema)) {
-        const valid = gen.name("valid")
-        cxt.subschema(
-          {
-            keyword: "unevaluatedProperties",
-            dataProp: key,
-            dataPropType: Type.Str,
-          },
-          valid
-        )
-        if (!allErrors) gen.if(not(valid), () => gen.break())
-      }
-    }
-
-    function unevaluatedDynamic(evaluatedProps: Name, key: Name): Code {
-      return _`!${evaluatedProps} || !${evaluatedProps}[${key}]`
-    }
-
-    function unevaluatedStatic(evaluatedProps: {[K in string]?: true}, key: Name): Code {
-      const ps: Code[] = []
-      for (const p in evaluatedProps) {
-        if (evaluatedProps[p] === true) ps.push(_`${key} !== ${p}`)
-      }
-      return and(...ps)
-    }
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/validation/const.ts

@@ -1,28 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_} from "../../compile/codegen"
-import {useFunc} from "../../compile/util"
-import equal from "../../runtime/equal"
-
-export type ConstError = ErrorObject<"const", {allowedValue: any}>
-
-const error: KeywordErrorDefinition = {
-  message: "must be equal to constant",
-  params: ({schemaCode}) => _`{allowedValue: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "const",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, data, $data, schemaCode, schema} = cxt
-    if ($data || (schema && typeof schema == "object")) {
-      cxt.fail$data(_`!${useFunc(gen, equal)}(${data}, ${schemaCode})`)
-    } else {
-      cxt.fail(_`${schema} !== ${data}`)
-    }
-  },
-}
-
-export default def