@bluefly/openstandardagents 0.4.6 → 0.4.9

package/node_modules/ajv/lib/vocabularies/applicator/not.ts

@@ -1,38 +0,0 @@
-import type {CodeKeywordDefinition, ErrorNoParams, AnySchema} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {alwaysValidSchema} from "../../compile/util"
-
-export type NotKeywordError = ErrorNoParams<"not", AnySchema>
-
-const def: CodeKeywordDefinition = {
-  keyword: "not",
-  schemaType: ["object", "boolean"],
-  trackErrors: true,
-  code(cxt: KeywordCxt) {
-    const {gen, schema, it} = cxt
-    if (alwaysValidSchema(it, schema)) {
-      cxt.fail()
-      return
-    }
-
-    const valid = gen.name("valid")
-    cxt.subschema(
-      {
-        keyword: "not",
-        compositeRule: true,
-        createErrors: false,
-        allErrors: false,
-      },
-      valid
-    )
-
-    cxt.failResult(
-      valid,
-      () => cxt.reset(),
-      () => cxt.error()
-    )
-  },
-  error: {message: "must NOT be valid"},
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/applicator/oneOf.ts

@@ -1,82 +0,0 @@
-import type {
-  CodeKeywordDefinition,
-  ErrorObject,
-  KeywordErrorDefinition,
-  AnySchema,
-} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, Name} from "../../compile/codegen"
-import {alwaysValidSchema} from "../../compile/util"
-import {SchemaCxt} from "../../compile"
-
-export type OneOfError = ErrorObject<
-  "oneOf",
-  {passingSchemas: [number, number] | null},
-  AnySchema[]
->
-
-const error: KeywordErrorDefinition = {
-  message: "must match exactly one schema in oneOf",
-  params: ({params}) => _`{passingSchemas: ${params.passing}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "oneOf",
-  schemaType: "array",
-  trackErrors: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, schema, parentSchema, it} = cxt
-    /* istanbul ignore if */
-    if (!Array.isArray(schema)) throw new Error("ajv implementation error")
-    if (it.opts.discriminator && parentSchema.discriminator) return
-    const schArr: AnySchema[] = schema
-    const valid = gen.let("valid", false)
-    const passing = gen.let("passing", null)
-    const schValid = gen.name("_valid")
-    cxt.setParams({passing})
-    // TODO possibly fail straight away (with warning or exception) if there are two empty always valid schemas
-
-    gen.block(validateOneOf)
-
-    cxt.result(
-      valid,
-      () => cxt.reset(),
-      () => cxt.error(true)
-    )
-
-    function validateOneOf(): void {
-      schArr.forEach((sch: AnySchema, i: number) => {
-        let schCxt: SchemaCxt | undefined
-        if (alwaysValidSchema(it, sch)) {
-          gen.var(schValid, true)
-        } else {
-          schCxt = cxt.subschema(
-            {
-              keyword: "oneOf",
-              schemaProp: i,
-              compositeRule: true,
-            },
-            schValid
-          )
-        }
-
-        if (i > 0) {
-          gen
-            .if(_`${schValid} && ${valid}`)
-            .assign(valid, false)
-            .assign(passing, _`[${passing}, ${i}]`)
-            .else()
-        }
-
-        gen.if(schValid, () => {
-          gen.assign(valid, true)
-          gen.assign(passing, i)
-          if (schCxt) cxt.mergeEvaluated(schCxt, Name)
-        })
-      })
-    }
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/applicator/patternProperties.ts

@@ -1,91 +0,0 @@
-import type {CodeKeywordDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {allSchemaProperties, usePattern} from "../code"
-import {_, not, Name} from "../../compile/codegen"
-import {alwaysValidSchema, checkStrictMode} from "../../compile/util"
-import {evaluatedPropsToName, Type} from "../../compile/util"
-import {AnySchema} from "../../types"
-
-const def: CodeKeywordDefinition = {
-  keyword: "patternProperties",
-  type: "object",
-  schemaType: "object",
-  code(cxt: KeywordCxt) {
-    const {gen, schema, data, parentSchema, it} = cxt
-    const {opts} = it
-    const patterns = allSchemaProperties(schema)
-    const alwaysValidPatterns = patterns.filter((p) =>
-      alwaysValidSchema(it, schema[p] as AnySchema)
-    )
-
-    if (
-      patterns.length === 0 ||
-      (alwaysValidPatterns.length === patterns.length &&
-        (!it.opts.unevaluated || it.props === true))
-    ) {
-      return
-    }
-
-    const checkProperties =
-      opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties
-    const valid = gen.name("valid")
-    if (it.props !== true && !(it.props instanceof Name)) {
-      it.props = evaluatedPropsToName(gen, it.props)
-    }
-    const {props} = it
-    validatePatternProperties()
-
-    function validatePatternProperties(): void {
-      for (const pat of patterns) {
-        if (checkProperties) checkMatchingProperties(pat)
-        if (it.allErrors) {
-          validateProperties(pat)
-        } else {
-          gen.var(valid, true) // TODO var
-          validateProperties(pat)
-          gen.if(valid)
-        }
-      }
-    }
-
-    function checkMatchingProperties(pat: string): void {
-      for (const prop in checkProperties) {
-        if (new RegExp(pat).test(prop)) {
-          checkStrictMode(
-            it,
-            `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`
-          )
-        }
-      }
-    }
-
-    function validateProperties(pat: string): void {
-      gen.forIn("key", data, (key) => {
-        gen.if(_`${usePattern(cxt, pat)}.test(${key})`, () => {
-          const alwaysValid = alwaysValidPatterns.includes(pat)
-          if (!alwaysValid) {
-            cxt.subschema(
-              {
-                keyword: "patternProperties",
-                schemaProp: pat,
-                dataProp: key,
-                dataPropType: Type.Str,
-              },
-              valid
-            )
-          }
-
-          if (it.opts.unevaluated && props !== true) {
-            gen.assign(_`${props}[${key}]`, true)
-          } else if (!alwaysValid && !it.allErrors) {
-            // can short-circuit if `unevaluatedProperties` is not supported (opts.next === false)
-            // or if all properties were evaluated (props === true)
-            gen.if(not(valid), () => gen.break())
-          }
-        })
-      })
-    }
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/applicator/prefixItems.ts

@@ -1,12 +0,0 @@
-import type {CodeKeywordDefinition} from "../../types"
-import {validateTuple} from "./items"
-
-const def: CodeKeywordDefinition = {
-  keyword: "prefixItems",
-  type: "array",
-  schemaType: ["array"],
-  before: "uniqueItems",
-  code: (cxt) => validateTuple(cxt, "items"),
-}
-
-export default def

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

@@ -1,57 +0,0 @@
-import type {CodeKeywordDefinition} from "../../types"
-import {KeywordCxt} from "../../compile/validate"
-import {propertyInData, allSchemaProperties} from "../code"
-import {alwaysValidSchema, toHash, mergeEvaluated} from "../../compile/util"
-import apDef from "./additionalProperties"
-
-const def: CodeKeywordDefinition = {
-  keyword: "properties",
-  type: "object",
-  schemaType: "object",
-  code(cxt: KeywordCxt) {
-    const {gen, schema, parentSchema, data, it} = cxt
-    if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === undefined) {
-      apDef.code(new KeywordCxt(it, apDef, "additionalProperties"))
-    }
-    const allProps = allSchemaProperties(schema)
-    for (const prop of allProps) {
-      it.definedProperties.add(prop)
-    }
-    if (it.opts.unevaluated && allProps.length && it.props !== true) {
-      it.props = mergeEvaluated.props(gen, toHash(allProps), it.props)
-    }
-    const properties = allProps.filter((p) => !alwaysValidSchema(it, schema[p]))
-    if (properties.length === 0) return
-    const valid = gen.name("valid")
-
-    for (const prop of properties) {
-      if (hasDefault(prop)) {
-        applyPropertySchema(prop)
-      } else {
-        gen.if(propertyInData(gen, data, prop, it.opts.ownProperties))
-        applyPropertySchema(prop)
-        if (!it.allErrors) gen.else().var(valid, true)
-        gen.endIf()
-      }
-      cxt.it.definedProperties.add(prop)
-      cxt.ok(valid)
-    }
-
-    function hasDefault(prop: string): boolean | undefined {
-      return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== undefined
-    }
-
-    function applyPropertySchema(prop: string): void {
-      cxt.subschema(
-        {
-          keyword: "properties",
-          schemaProp: prop,
-          dataProp: prop,
-        },
-        valid
-      )
-    }
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/applicator/propertyNames.ts

@@ -1,50 +0,0 @@
-import type {
-  CodeKeywordDefinition,
-  ErrorObject,
-  KeywordErrorDefinition,
-  AnySchema,
-} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, not} from "../../compile/codegen"
-import {alwaysValidSchema} from "../../compile/util"
-
-export type PropertyNamesError = ErrorObject<"propertyNames", {propertyName: string}, AnySchema>
-
-const error: KeywordErrorDefinition = {
-  message: "property name must be valid",
-  params: ({params}) => _`{propertyName: ${params.propertyName}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "propertyNames",
-  type: "object",
-  schemaType: ["object", "boolean"],
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, schema, data, it} = cxt
-    if (alwaysValidSchema(it, schema)) return
-    const valid = gen.name("valid")
-
-    gen.forIn("key", data, (key) => {
-      cxt.setParams({propertyName: key})
-      cxt.subschema(
-        {
-          keyword: "propertyNames",
-          data: key,
-          dataTypes: ["string"],
-          propertyName: key,
-          compositeRule: true,
-        },
-        valid
-      )
-      gen.if(not(valid), () => {
-        cxt.error(true)
-        if (!it.allErrors) gen.break()
-      })
-    })
-
-    cxt.ok(valid)
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/applicator/thenElse.ts

@@ -1,13 +0,0 @@
-import type {CodeKeywordDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {checkStrictMode} from "../../compile/util"
-
-const def: CodeKeywordDefinition = {
-  keyword: ["then", "else"],
-  schemaType: ["object", "boolean"],
-  code({keyword, parentSchema, it}: KeywordCxt) {
-    if (parentSchema.if === undefined) checkStrictMode(it, `"${keyword}" without "if" is ignored`)
-  },
-}
-
-export default def

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

@@ -1,168 +0,0 @@
-import type {AnySchema, SchemaMap} from "../types"
-import type {SchemaCxt} from "../compile"
-import type {KeywordCxt} from "../compile/validate"
-import {CodeGen, _, and, or, not, nil, strConcat, getProperty, Code, Name} from "../compile/codegen"
-import {alwaysValidSchema, Type} from "../compile/util"
-import N from "../compile/names"
-import {useFunc} from "../compile/util"
-export function checkReportMissingProp(cxt: KeywordCxt, prop: string): void {
-  const {gen, data, it} = cxt
-  gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
-    cxt.setParams({missingProperty: _`${prop}`}, true)
-    cxt.error()
-  })
-}
-
-export function checkMissingProp(
-  {gen, data, it: {opts}}: KeywordCxt,
-  properties: string[],
-  missing: Name
-): Code {
-  return or(
-    ...properties.map((prop) =>
-      and(noPropertyInData(gen, data, prop, opts.ownProperties), _`${missing} = ${prop}`)
-    )
-  )
-}
-
-export function reportMissingProp(cxt: KeywordCxt, missing: Name): void {
-  cxt.setParams({missingProperty: missing}, true)
-  cxt.error()
-}
-
-export function hasPropFunc(gen: CodeGen): Name {
-  return gen.scopeValue("func", {
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    ref: Object.prototype.hasOwnProperty,
-    code: _`Object.prototype.hasOwnProperty`,
-  })
-}
-
-export function isOwnProperty(gen: CodeGen, data: Name, property: Name | string): Code {
-  return _`${hasPropFunc(gen)}.call(${data}, ${property})`
-}
-
-export function propertyInData(
-  gen: CodeGen,
-  data: Name,
-  property: Name | string,
-  ownProperties?: boolean
-): Code {
-  const cond = _`${data}${getProperty(property)} !== undefined`
-  return ownProperties ? _`${cond} && ${isOwnProperty(gen, data, property)}` : cond
-}
-
-export function noPropertyInData(
-  gen: CodeGen,
-  data: Name,
-  property: Name | string,
-  ownProperties?: boolean
-): Code {
-  const cond = _`${data}${getProperty(property)} === undefined`
-  return ownProperties ? or(cond, not(isOwnProperty(gen, data, property))) : cond
-}
-
-export function allSchemaProperties(schemaMap?: SchemaMap): string[] {
-  return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : []
-}
-
-export function schemaProperties(it: SchemaCxt, schemaMap: SchemaMap): string[] {
-  return allSchemaProperties(schemaMap).filter(
-    (p) => !alwaysValidSchema(it, schemaMap[p] as AnySchema)
-  )
-}
-
-export function callValidateCode(
-  {schemaCode, data, it: {gen, topSchemaRef, schemaPath, errorPath}, it}: KeywordCxt,
-  func: Code,
-  context: Code,
-  passSchema?: boolean
-): Code {
-  const dataAndSchema = passSchema ? _`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data
-  const valCxt: [Name, Code | number][] = [
-    [N.instancePath, strConcat(N.instancePath, errorPath)],
-    [N.parentData, it.parentData],
-    [N.parentDataProperty, it.parentDataProperty],
-    [N.rootData, N.rootData],
-  ]
-  if (it.opts.dynamicRef) valCxt.push([N.dynamicAnchors, N.dynamicAnchors])
-  const args = _`${dataAndSchema}, ${gen.object(...valCxt)}`
-  return context !== nil ? _`${func}.call(${context}, ${args})` : _`${func}(${args})`
-}
-
-const newRegExp = _`new RegExp`
-
-export function usePattern({gen, it: {opts}}: KeywordCxt, pattern: string): Name {
-  const u = opts.unicodeRegExp ? "u" : ""
-  const {regExp} = opts.code
-  const rx = regExp(pattern, u)
-
-  return gen.scopeValue("pattern", {
-    key: rx.toString(),
-    ref: rx,
-    code: _`${regExp.code === "new RegExp" ? newRegExp : useFunc(gen, regExp)}(${pattern}, ${u})`,
-  })
-}
-
-export function validateArray(cxt: KeywordCxt): Name {
-  const {gen, data, keyword, it} = cxt
-  const valid = gen.name("valid")
-  if (it.allErrors) {
-    const validArr = gen.let("valid", true)
-    validateItems(() => gen.assign(validArr, false))
-    return validArr
-  }
-  gen.var(valid, true)
-  validateItems(() => gen.break())
-  return valid
-
-  function validateItems(notValid: () => void): void {
-    const len = gen.const("len", _`${data}.length`)
-    gen.forRange("i", 0, len, (i) => {
-      cxt.subschema(
-        {
-          keyword,
-          dataProp: i,
-          dataPropType: Type.Num,
-        },
-        valid
-      )
-      gen.if(not(valid), notValid)
-    })
-  }
-}
-
-export function validateUnion(cxt: KeywordCxt): void {
-  const {gen, schema, keyword, it} = cxt
-  /* istanbul ignore if */
-  if (!Array.isArray(schema)) throw new Error("ajv implementation error")
-  const alwaysValid = schema.some((sch: AnySchema) => alwaysValidSchema(it, sch))
-  if (alwaysValid && !it.opts.unevaluated) return
-
-  const valid = gen.let("valid", false)
-  const schValid = gen.name("_valid")
-
-  gen.block(() =>
-    schema.forEach((_sch: AnySchema, i: number) => {
-      const schCxt = cxt.subschema(
-        {
-          keyword,
-          schemaProp: i,
-          compositeRule: true,
-        },
-        schValid
-      )
-      gen.assign(valid, _`${valid} || ${schValid}`)
-      const merged = cxt.mergeValidEvaluated(schCxt, schValid)
-      // can short-circuit if `unevaluatedProperties/Items` not supported (opts.unevaluated !== true)
-      // or if all properties and items were evaluated (it.props === true && it.items === true)
-      if (!merged) gen.if(not(valid))
-    })
-  )
-
-  cxt.result(
-    valid,
-    () => cxt.reset(),
-    () => cxt.error(true)
-  )
-}

package/node_modules/ajv/lib/vocabularies/core/id.ts

@@ -1,10 +0,0 @@
-import type {CodeKeywordDefinition} from "../../types"
-
-const def: CodeKeywordDefinition = {
-  keyword: "id",
-  code() {
-    throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID')
-  },
-}
-
-export default def

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

@@ -1,16 +0,0 @@
-import type {Vocabulary} from "../../types"
-import idKeyword from "./id"
-import refKeyword from "./ref"
-
-const core: Vocabulary = [
-  "$schema",
-  "$id",
-  "$defs",
-  "$vocabulary",
-  {keyword: "$comment"},
-  "definitions",
-  idKeyword,
-  refKeyword,
-]
-
-export default core

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

@@ -1,129 +0,0 @@
-import type {CodeKeywordDefinition, AnySchema} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import MissingRefError from "../../compile/ref_error"
-import {callValidateCode} from "../code"
-import {_, nil, stringify, Code, Name} from "../../compile/codegen"
-import N from "../../compile/names"
-import {SchemaEnv, resolveRef} from "../../compile"
-import {mergeEvaluated} from "../../compile/util"
-
-const def: CodeKeywordDefinition = {
-  keyword: "$ref",
-  schemaType: "string",
-  code(cxt: KeywordCxt): void {
-    const {gen, schema: $ref, it} = cxt
-    const {baseId, schemaEnv: env, validateName, opts, self} = it
-    const {root} = env
-    if (($ref === "#" || $ref === "#/") && baseId === root.baseId) return callRootRef()
-    const schOrEnv = resolveRef.call(self, root, baseId, $ref)
-    if (schOrEnv === undefined) throw new MissingRefError(it.opts.uriResolver, baseId, $ref)
-    if (schOrEnv instanceof SchemaEnv) return callValidate(schOrEnv)
-    return inlineRefSchema(schOrEnv)
-
-    function callRootRef(): void {
-      if (env === root) return callRef(cxt, validateName, env, env.$async)
-      const rootName = gen.scopeValue("root", {ref: root})
-      return callRef(cxt, _`${rootName}.validate`, root, root.$async)
-    }
-
-    function callValidate(sch: SchemaEnv): void {
-      const v = getValidate(cxt, sch)
-      callRef(cxt, v, sch, sch.$async)
-    }
-
-    function inlineRefSchema(sch: AnySchema): void {
-      const schName = gen.scopeValue(
-        "schema",
-        opts.code.source === true ? {ref: sch, code: stringify(sch)} : {ref: sch}
-      )
-      const valid = gen.name("valid")
-      const schCxt = cxt.subschema(
-        {
-          schema: sch,
-          dataTypes: [],
-          schemaPath: nil,
-          topSchemaRef: schName,
-          errSchemaPath: $ref,
-        },
-        valid
-      )
-      cxt.mergeEvaluated(schCxt)
-      cxt.ok(valid)
-    }
-  },
-}
-
-export function getValidate(cxt: KeywordCxt, sch: SchemaEnv): Code {
-  const {gen} = cxt
-  return sch.validate
-    ? gen.scopeValue("validate", {ref: sch.validate})
-    : _`${gen.scopeValue("wrapper", {ref: sch})}.validate`
-}
-
-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()
-  else callSyncRef()
-
-  function callAsyncRef(): void {
-    if (!env.$async) throw new Error("async schema referenced by sync schema")
-    const valid = gen.let("valid")
-    gen.try(
-      () => {
-        gen.code(_`await ${callValidateCode(cxt, v, passCxt)}`)
-        addEvaluatedFrom(v) // TODO will not work with async, it has to be returned with the result
-        if (!allErrors) gen.assign(valid, true)
-      },
-      (e) => {
-        gen.if(_`!(${e} instanceof ${it.ValidationError as Name})`, () => gen.throw(e))
-        addErrorsFrom(e)
-        if (!allErrors) gen.assign(valid, false)
-      }
-    )
-    cxt.ok(valid)
-  }
-
-  function callSyncRef(): void {
-    cxt.result(
-      callValidateCode(cxt, v, passCxt),
-      () => addEvaluatedFrom(v),
-      () => addErrorsFrom(v)
-    )
-  }
-
-  function addErrorsFrom(source: Code): void {
-    const errs = _`${source}.errors`
-    gen.assign(N.vErrors, _`${N.vErrors} === null ? ${errs} : ${N.vErrors}.concat(${errs})`) // TODO tagged
-    gen.assign(N.errors, _`${N.vErrors}.length`)
-  }
-
-  function addEvaluatedFrom(source: Code): void {
-    if (!it.opts.unevaluated) return
-    const schEvaluated = sch?.validate?.evaluated
-    // TODO refactor
-    if (it.props !== true) {
-      if (schEvaluated && !schEvaluated.dynamicProps) {
-        if (schEvaluated.props !== undefined) {
-          it.props = mergeEvaluated.props(gen, schEvaluated.props, it.props)
-        }
-      } else {
-        const props = gen.var("props", _`${source}.evaluated.props`)
-        it.props = mergeEvaluated.props(gen, props, it.props, Name)
-      }
-    }
-    if (it.items !== true) {
-      if (schEvaluated && !schEvaluated.dynamicItems) {
-        if (schEvaluated.items !== undefined) {
-          it.items = mergeEvaluated.items(gen, schEvaluated.items, it.items)
-        }
-      } else {
-        const items = gen.var("items", _`${source}.evaluated.items`)
-        it.items = mergeEvaluated.items(gen, items, it.items, Name)
-      }
-    }
-  }
-}
-
-export default def