@nikovirtala/projen-constructs 0.2.1 → 0.2.3

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

@@ -0,0 +1,113 @@
+import type {CodeKeywordDefinition, AnySchemaObject, KeywordErrorDefinition} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import {_, getProperty, Name} from "../../compile/codegen"
+import {DiscrError, DiscrErrorObj} from "../discriminator/types"
+import {resolveRef, SchemaEnv} from "../../compile"
+import MissingRefError from "../../compile/ref_error"
+import {schemaHasRulesButRef} from "../../compile/util"
+
+export type DiscriminatorError = DiscrErrorObj<DiscrError.Tag> | DiscrErrorObj<DiscrError.Mapping>
+
+const error: KeywordErrorDefinition = {
+  message: ({params: {discrError, tagName}}) =>
+    discrError === DiscrError.Tag
+      ? `tag "${tagName}" must be string`
+      : `value of tag "${tagName}" must be in oneOf`,
+  params: ({params: {discrError, tag, tagName}}) =>
+    _`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`,
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: "discriminator",
+  type: "object",
+  schemaType: "object",
+  error,
+  code(cxt: KeywordCxt) {
+    const {gen, data, schema, parentSchema, it} = cxt
+    const {oneOf} = parentSchema
+    if (!it.opts.discriminator) {
+      throw new Error("discriminator: requires discriminator option")
+    }
+    const tagName = schema.propertyName
+    if (typeof tagName != "string") throw new Error("discriminator: requires propertyName")
+    if (schema.mapping) throw new Error("discriminator: mapping is not supported")
+    if (!oneOf) throw new Error("discriminator: requires oneOf keyword")
+    const valid = gen.let("valid", false)
+    const tag = gen.const("tag", _`${data}${getProperty(tagName)}`)
+    gen.if(
+      _`typeof ${tag} == "string"`,
+      () => validateMapping(),
+      () => cxt.error(false, {discrError: DiscrError.Tag, tag, tagName})
+    )
+    cxt.ok(valid)
+
+    function validateMapping(): void {
+      const mapping = getMapping()
+      gen.if(false)
+      for (const tagValue in mapping) {
+        gen.elseIf(_`${tag} === ${tagValue}`)
+        gen.assign(valid, applyTagSchema(mapping[tagValue]))
+      }
+      gen.else()
+      cxt.error(false, {discrError: DiscrError.Mapping, tag, tagName})
+      gen.endIf()
+    }
+
+    function applyTagSchema(schemaProp?: number): Name {
+      const _valid = gen.name("valid")
+      const schCxt = cxt.subschema({keyword: "oneOf", schemaProp}, _valid)
+      cxt.mergeEvaluated(schCxt, Name)
+      return _valid
+    }
+
+    function getMapping(): {[T in string]?: number} {
+      const oneOfMapping: {[T in string]?: number} = {}
+      const topRequired = hasRequired(parentSchema)
+      let tagRequired = true
+      for (let i = 0; i < oneOf.length; i++) {
+        let sch = oneOf[i]
+        if (sch?.$ref && !schemaHasRulesButRef(sch, it.self.RULES)) {
+          const ref = sch.$ref
+          sch = resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref)
+          if (sch instanceof SchemaEnv) sch = sch.schema
+          if (sch === undefined) throw new MissingRefError(it.opts.uriResolver, it.baseId, ref)
+        }
+        const propSch = sch?.properties?.[tagName]
+        if (typeof propSch != "object") {
+          throw new Error(
+            `discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`
+          )
+        }
+        tagRequired = tagRequired && (topRequired || hasRequired(sch))
+        addMappings(propSch, i)
+      }
+      if (!tagRequired) throw new Error(`discriminator: "${tagName}" must be required`)
+      return oneOfMapping
+
+      function hasRequired({required}: AnySchemaObject): boolean {
+        return Array.isArray(required) && required.includes(tagName)
+      }
+
+      function addMappings(sch: AnySchemaObject, i: number): void {
+        if (sch.const) {
+          addMapping(sch.const, i)
+        } else if (sch.enum) {
+          for (const tagValue of sch.enum) {
+            addMapping(tagValue, i)
+          }
+        } else {
+          throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`)
+        }
+      }
+
+      function addMapping(tagValue: unknown, i: number): void {
+        if (typeof tagValue != "string" || tagValue in oneOfMapping) {
+          throw new Error(`discriminator: "${tagName}" values must be unique strings`)
+        }
+        oneOfMapping[tagValue] = i
+      }
+    }
+  },
+}
+
+export default def

package/node_modules/ajv/lib/vocabularies/discriminator/types.ts

@@ -0,0 +1,12 @@
+import type {ErrorObject} from "../../types"
+
+export enum DiscrError {
+  Tag = "tag",
+  Mapping = "mapping",
+}
+
+export type DiscrErrorObj<E extends DiscrError> = ErrorObject<
+  "discriminator",
+  {error: E; tag: string; tagValue: unknown},
+  string
+>

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

@@ -0,0 +1,23 @@
+import type {Vocabulary} from "../types"
+import coreVocabulary from "./core"
+import validationVocabulary from "./validation"
+import getApplicatorVocabulary from "./applicator"
+import dynamicVocabulary from "./dynamic"
+import nextVocabulary from "./next"
+import unevaluatedVocabulary from "./unevaluated"
+import formatVocabulary from "./format"
+import {metadataVocabulary, contentVocabulary} from "./metadata"
+
+const draft2020Vocabularies: Vocabulary[] = [
+  dynamicVocabulary,
+  coreVocabulary,
+  validationVocabulary,
+  getApplicatorVocabulary(true),
+  formatVocabulary,
+  metadataVocabulary,
+  contentVocabulary,
+  nextVocabulary,
+  unevaluatedVocabulary,
+]
+
+export default draft2020Vocabularies

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

@@ -0,0 +1,17 @@
+import type {Vocabulary} from "../types"
+import coreVocabulary from "./core"
+import validationVocabulary from "./validation"
+import getApplicatorVocabulary from "./applicator"
+import formatVocabulary from "./format"
+import {metadataVocabulary, contentVocabulary} from "./metadata"
+
+const draft7Vocabularies: Vocabulary[] = [
+  coreVocabulary,
+  validationVocabulary,
+  getApplicatorVocabulary(),
+  formatVocabulary,
+  metadataVocabulary,
+  contentVocabulary,
+]
+
+export default draft7Vocabularies

package/node_modules/ajv/lib/vocabularies/dynamic/dynamicAnchor.ts

@@ -0,0 +1,31 @@
+import type {CodeKeywordDefinition} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import {_, getProperty, Code} from "../../compile/codegen"
+import N from "../../compile/names"
+import {SchemaEnv, compileSchema} from "../../compile"
+import {getValidate} from "../core/ref"
+
+const def: CodeKeywordDefinition = {
+  keyword: "$dynamicAnchor",
+  schemaType: "string",
+  code: (cxt) => dynamicAnchor(cxt, cxt.schema),
+}
+
+export function dynamicAnchor(cxt: KeywordCxt, anchor: string): void {
+  const {gen, it} = cxt
+  it.schemaEnv.root.dynamicAnchors[anchor] = true
+  const v = _`${N.dynamicAnchors}${getProperty(anchor)}`
+  const validate = it.errSchemaPath === "#" ? it.validateName : _getValidate(cxt)
+  gen.if(_`!${v}`, () => gen.assign(v, validate))
+}
+
+function _getValidate(cxt: KeywordCxt): Code {
+  const {schemaEnv, schema, self} = cxt.it
+  const {root, baseId, localRefs, meta} = schemaEnv.root
+  const {schemaId} = self.opts
+  const sch = new SchemaEnv({schema, schemaId, root, baseId, localRefs, meta})
+  compileSchema.call(self, sch)
+  return getValidate(cxt, sch)
+}
+
+export default def

package/node_modules/ajv/lib/vocabularies/dynamic/dynamicRef.ts

@@ -0,0 +1,51 @@
+import type {CodeKeywordDefinition} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import {_, getProperty, Code, Name} from "../../compile/codegen"
+import N from "../../compile/names"
+import {callRef} from "../core/ref"
+
+const def: CodeKeywordDefinition = {
+  keyword: "$dynamicRef",
+  schemaType: "string",
+  code: (cxt) => dynamicRef(cxt, cxt.schema),
+}
+
+export function dynamicRef(cxt: KeywordCxt, ref: string): void {
+  const {gen, keyword, it} = cxt
+  if (ref[0] !== "#") throw new Error(`"${keyword}" only supports hash fragment reference`)
+  const anchor = ref.slice(1)
+  if (it.allErrors) {
+    _dynamicRef()
+  } else {
+    const valid = gen.let("valid", false)
+    _dynamicRef(valid)
+    cxt.ok(valid)
+  }
+
+  function _dynamicRef(valid?: Name): void {
+    // TODO the assumption here is that `recursiveRef: #` always points to the root
+    // of the schema object, which is not correct, because there may be $id that
+    // makes # point to it, and the target schema may not contain dynamic/recursiveAnchor.
+    // Because of that 2 tests in recursiveRef.json fail.
+    // This is a similar problem to #815 (`$id` doesn't alter resolution scope for `{ "$ref": "#" }`).
+    // (This problem is not tested in JSON-Schema-Test-Suite)
+    if (it.schemaEnv.root.dynamicAnchors[anchor]) {
+      const v = gen.let("_v", _`${N.dynamicAnchors}${getProperty(anchor)}`)
+      gen.if(v, _callRef(v, valid), _callRef(it.validateName, valid))
+    } else {
+      _callRef(it.validateName, valid)()
+    }
+  }
+
+  function _callRef(validate: Code, valid?: Name): () => void {
+    return valid
+      ? () =>
+          gen.block(() => {
+            callRef(cxt, validate)
+            gen.let(valid, true)
+          })
+      : () => callRef(cxt, validate)
+  }
+}
+
+export default def

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

@@ -0,0 +1,9 @@
+import type {Vocabulary} from "../../types"
+import dynamicAnchor from "./dynamicAnchor"
+import dynamicRef from "./dynamicRef"
+import recursiveAnchor from "./recursiveAnchor"
+import recursiveRef from "./recursiveRef"
+
+const dynamic: Vocabulary = [dynamicAnchor, dynamicRef, recursiveAnchor, recursiveRef]
+
+export default dynamic

package/node_modules/ajv/lib/vocabularies/dynamic/recursiveAnchor.ts

@@ -0,0 +1,14 @@
+import type {CodeKeywordDefinition} from "../../types"
+import {dynamicAnchor} from "./dynamicAnchor"
+import {checkStrictMode} from "../../compile/util"
+
+const def: CodeKeywordDefinition = {
+  keyword: "$recursiveAnchor",
+  schemaType: "boolean",
+  code(cxt) {
+    if (cxt.schema) dynamicAnchor(cxt, "")
+    else checkStrictMode(cxt.it, "$recursiveAnchor: false is ignored")
+  },
+}
+
+export default def

package/node_modules/ajv/lib/vocabularies/dynamic/recursiveRef.ts

@@ -0,0 +1,10 @@
+import type {CodeKeywordDefinition} from "../../types"
+import {dynamicRef} from "./dynamicRef"
+
+const def: CodeKeywordDefinition = {
+  keyword: "$recursiveRef",
+  schemaType: "string",
+  code: (cxt) => dynamicRef(cxt, cxt.schema),
+}
+
+export default def

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

@@ -0,0 +1,18 @@
+import type {TypeError} from "../compile/validate/dataType"
+import type {ApplicatorKeywordError} from "./applicator"
+import type {ValidationKeywordError} from "./validation"
+import type {FormatError} from "./format/format"
+import type {UnevaluatedPropertiesError} from "./unevaluated/unevaluatedProperties"
+import type {UnevaluatedItemsError} from "./unevaluated/unevaluatedItems"
+import type {DependentRequiredError} from "./validation/dependentRequired"
+import type {DiscriminatorError} from "./discriminator"
+
+export type DefinedError =
+  | TypeError
+  | ApplicatorKeywordError
+  | ValidationKeywordError
+  | FormatError
+  | UnevaluatedPropertiesError
+  | UnevaluatedItemsError
+  | DependentRequiredError
+  | DiscriminatorError

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

@@ -0,0 +1,120 @@
+import type {
+  AddedFormat,
+  FormatValidator,
+  AsyncFormatValidator,
+  CodeKeywordDefinition,
+  KeywordErrorDefinition,
+  ErrorObject,
+} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import {_, str, nil, or, Code, getProperty, regexpCode} from "../../compile/codegen"
+
+type FormatValidate =
+  | FormatValidator<string>
+  | FormatValidator<number>
+  | AsyncFormatValidator<string>
+  | AsyncFormatValidator<number>
+  | RegExp
+  | string
+  | true
+
+export type FormatError = ErrorObject<"format", {format: string}, string | {$data: string}>
+
+const error: KeywordErrorDefinition = {
+  message: ({schemaCode}) => str`must match format "${schemaCode}"`,
+  params: ({schemaCode}) => _`{format: ${schemaCode}}`,
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: "format",
+  type: ["number", "string"],
+  schemaType: "string",
+  $data: true,
+  error,
+  code(cxt: KeywordCxt, ruleType?: string) {
+    const {gen, data, $data, schema, schemaCode, it} = cxt
+    const {opts, errSchemaPath, schemaEnv, self} = it
+    if (!opts.validateFormats) return
+
+    if ($data) validate$DataFormat()
+    else validateFormat()
+
+    function validate$DataFormat(): void {
+      const fmts = gen.scopeValue("formats", {
+        ref: self.formats,
+        code: opts.code.formats,
+      })
+      const fDef = gen.const("fDef", _`${fmts}[${schemaCode}]`)
+      const fType = gen.let("fType")
+      const format = gen.let("format")
+      // TODO simplify
+      gen.if(
+        _`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`,
+        () => gen.assign(fType, _`${fDef}.type || "string"`).assign(format, _`${fDef}.validate`),
+        () => gen.assign(fType, _`"string"`).assign(format, fDef)
+      )
+      cxt.fail$data(or(unknownFmt(), invalidFmt()))
+
+      function unknownFmt(): Code {
+        if (opts.strictSchema === false) return nil
+        return _`${schemaCode} && !${format}`
+      }
+
+      function invalidFmt(): Code {
+        const callFormat = schemaEnv.$async
+          ? _`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))`
+          : _`${format}(${data})`
+        const validData = _`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`
+        return _`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`
+      }
+    }
+
+    function validateFormat(): void {
+      const formatDef: AddedFormat | undefined = self.formats[schema]
+      if (!formatDef) {
+        unknownFormat()
+        return
+      }
+      if (formatDef === true) return
+      const [fmtType, format, fmtRef] = getFormat(formatDef)
+      if (fmtType === ruleType) cxt.pass(validCondition())
+
+      function unknownFormat(): void {
+        if (opts.strictSchema === false) {
+          self.logger.warn(unknownMsg())
+          return
+        }
+        throw new Error(unknownMsg())
+
+        function unknownMsg(): string {
+          return `unknown format "${schema as string}" ignored in schema at path "${errSchemaPath}"`
+        }
+      }
+
+      function getFormat(fmtDef: AddedFormat): [string, FormatValidate, Code] {
+        const code =
+          fmtDef instanceof RegExp
+            ? regexpCode(fmtDef)
+            : opts.code.formats
+            ? _`${opts.code.formats}${getProperty(schema)}`
+            : undefined
+        const fmt = gen.scopeValue("formats", {key: schema, ref: fmtDef, code})
+        if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) {
+          return [fmtDef.type || "string", fmtDef.validate, _`${fmt}.validate`]
+        }
+
+        return ["string", fmtDef, fmt]
+      }
+
+      function validCondition(): Code {
+        if (typeof formatDef == "object" && !(formatDef instanceof RegExp) && formatDef.async) {
+          if (!schemaEnv.$async) throw new Error("async format in sync schema")
+          return _`await ${fmtRef}(${data})`
+        }
+        return typeof format == "function" ? _`${fmtRef}(${data})` : _`${fmtRef}.test(${data})`
+      }
+    }
+  },
+}
+
+export default def

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

@@ -0,0 +1,6 @@
+import type {Vocabulary} from "../../types"
+import formatKeyword from "./format"
+
+const format: Vocabulary = [formatKeyword]
+
+export default format

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

@@ -0,0 +1,89 @@
+import type {CodeKeywordDefinition, KeywordErrorDefinition} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import {_, not, getProperty, Name} from "../../compile/codegen"
+import {checkMetadata} from "./metadata"
+import {checkNullableObject} from "./nullable"
+import {typeErrorMessage, typeErrorParams, _JTDTypeError} from "./error"
+import {DiscrError, DiscrErrorObj} from "../discriminator/types"
+
+export type JTDDiscriminatorError =
+  | _JTDTypeError<"discriminator", "object", string>
+  | DiscrErrorObj<DiscrError.Tag>
+  | DiscrErrorObj<DiscrError.Mapping>
+
+const error: KeywordErrorDefinition = {
+  message: (cxt) => {
+    const {schema, params} = cxt
+    return params.discrError
+      ? params.discrError === DiscrError.Tag
+        ? `tag "${schema}" must be string`
+        : `value of tag "${schema}" must be in mapping`
+      : typeErrorMessage(cxt, "object")
+  },
+  params: (cxt) => {
+    const {schema, params} = cxt
+    return params.discrError
+      ? _`{error: ${params.discrError}, tag: ${schema}, tagValue: ${params.tag}}`
+      : typeErrorParams(cxt, "object")
+  },
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: "discriminator",
+  schemaType: "string",
+  implements: ["mapping"],
+  error,
+  code(cxt: KeywordCxt) {
+    checkMetadata(cxt)
+    const {gen, data, schema, parentSchema} = cxt
+    const [valid, cond] = checkNullableObject(cxt, data)
+
+    gen.if(cond)
+    validateDiscriminator()
+    gen.elseIf(not(valid))
+    cxt.error()
+    gen.endIf()
+    cxt.ok(valid)
+
+    function validateDiscriminator(): void {
+      const tag = gen.const("tag", _`${data}${getProperty(schema)}`)
+      gen.if(_`${tag} === undefined`)
+      cxt.error(false, {discrError: DiscrError.Tag, tag})
+      gen.elseIf(_`typeof ${tag} == "string"`)
+      validateMapping(tag)
+      gen.else()
+      cxt.error(false, {discrError: DiscrError.Tag, tag}, {instancePath: schema})
+      gen.endIf()
+    }
+
+    function validateMapping(tag: Name): void {
+      gen.if(false)
+      for (const tagValue in parentSchema.mapping) {
+        gen.elseIf(_`${tag} === ${tagValue}`)
+        gen.assign(valid, applyTagSchema(tagValue))
+      }
+      gen.else()
+      cxt.error(
+        false,
+        {discrError: DiscrError.Mapping, tag},
+        {instancePath: schema, schemaPath: "mapping", parentSchema: true}
+      )
+      gen.endIf()
+    }
+
+    function applyTagSchema(schemaProp: string): Name {
+      const _valid = gen.name("valid")
+      cxt.subschema(
+        {
+          keyword: "mapping",
+          schemaProp,
+          jtdDiscriminator: schema,
+        },
+        _valid
+      )
+      return _valid
+    }
+  },
+}
+
+export default def

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

@@ -0,0 +1,32 @@
+import type {CodeKeywordDefinition, SchemaObject} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import {alwaysValidSchema} from "../../compile/util"
+import {validateArray} from "../code"
+import {_, not} from "../../compile/codegen"
+import {checkMetadata} from "./metadata"
+import {checkNullable} from "./nullable"
+import {typeError, _JTDTypeError} from "./error"
+
+export type JTDElementsError = _JTDTypeError<"elements", "array", SchemaObject>
+
+const def: CodeKeywordDefinition = {
+  keyword: "elements",
+  schemaType: "object",
+  error: typeError("array"),
+  code(cxt: KeywordCxt) {
+    checkMetadata(cxt)
+    const {gen, data, schema, it} = cxt
+    if (alwaysValidSchema(it, schema)) return
+    const [valid] = checkNullable(cxt)
+    gen.if(not(valid), () =>
+      gen.if(
+        _`Array.isArray(${data})`,
+        () => gen.assign(valid, validateArray(cxt)),
+        () => cxt.error()
+      )
+    )
+    cxt.ok(valid)
+  },
+}
+
+export default def

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

@@ -0,0 +1,45 @@
+import type {CodeKeywordDefinition, KeywordErrorDefinition, ErrorObject} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import {_, or, and, Code} from "../../compile/codegen"
+import {checkMetadata} from "./metadata"
+import {checkNullable} from "./nullable"
+
+export type JTDEnumError = ErrorObject<"enum", {allowedValues: string[]}, string[]>
+
+const error: KeywordErrorDefinition = {
+  message: "must be equal to one of the allowed values",
+  params: ({schemaCode}) => _`{allowedValues: ${schemaCode}}`,
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: "enum",
+  schemaType: "array",
+  error,
+  code(cxt: KeywordCxt) {
+    checkMetadata(cxt)
+    const {gen, data, schema, schemaValue, parentSchema, it} = cxt
+    if (schema.length === 0) throw new Error("enum must have non-empty array")
+    if (schema.length !== new Set(schema).size) throw new Error("enum items must be unique")
+    let valid: Code
+    const isString = _`typeof ${data} == "string"`
+    if (schema.length >= it.opts.loopEnum) {
+      let cond: Code
+      ;[valid, cond] = checkNullable(cxt, isString)
+      gen.if(cond, loopEnum)
+    } else {
+      /* istanbul ignore if */
+      if (!Array.isArray(schema)) throw new Error("ajv implementation error")
+      valid = and(isString, or(...schema.map((value: string) => _`${data} === ${value}`)))
+      if (parentSchema.nullable) valid = or(_`${data} === null`, valid)
+    }
+    cxt.pass(valid)
+
+    function loopEnum(): void {
+      gen.forOf("v", schemaValue as Code, (v) =>
+        gen.if(_`${valid} = ${data} === ${v}`, () => gen.break())
+      )
+    }
+  },
+}
+
+export default def

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

@@ -0,0 +1,23 @@
+import type {KeywordErrorDefinition, KeywordErrorCxt, ErrorObject} from "../../types"
+import {_, Code} from "../../compile/codegen"
+
+export type _JTDTypeError<K extends string, T extends string, S> = ErrorObject<
+  K,
+  {type: T; nullable: boolean},
+  S
+>
+
+export function typeError(t: string): KeywordErrorDefinition {
+  return {
+    message: (cxt) => typeErrorMessage(cxt, t),
+    params: (cxt) => typeErrorParams(cxt, t),
+  }
+}
+
+export function typeErrorMessage({parentSchema}: KeywordErrorCxt, t: string): string {
+  return parentSchema?.nullable ? `must be ${t} or null` : `must be ${t}`
+}
+
+export function typeErrorParams({parentSchema}: KeywordErrorCxt, t: string): Code {
+  return _`{type: ${t}, nullable: ${!!parentSchema?.nullable}}`
+}

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

@@ -0,0 +1,37 @@
+import type {Vocabulary} from "../../types"
+import refKeyword from "./ref"
+import typeKeyword, {JTDTypeError} from "./type"
+import enumKeyword, {JTDEnumError} from "./enum"
+import elements, {JTDElementsError} from "./elements"
+import properties, {JTDPropertiesError} from "./properties"
+import optionalProperties from "./optionalProperties"
+import discriminator, {JTDDiscriminatorError} from "./discriminator"
+import values, {JTDValuesError} from "./values"
+import union from "./union"
+import metadata from "./metadata"
+
+const jtdVocabulary: Vocabulary = [
+  "definitions",
+  refKeyword,
+  typeKeyword,
+  enumKeyword,
+  elements,
+  properties,
+  optionalProperties,
+  discriminator,
+  values,
+  union,
+  metadata,
+  {keyword: "additionalProperties", schemaType: "boolean"},
+  {keyword: "nullable", schemaType: "boolean"},
+]
+
+export default jtdVocabulary
+
+export type JTDErrorObject =
+  | JTDTypeError
+  | JTDEnumError
+  | JTDElementsError
+  | JTDPropertiesError
+  | JTDDiscriminatorError
+  | JTDValuesError