.config/coc/extensions/node_modules/coc-prettier/node_modules/table/node_modules/ajv/lib/vocabularies/applicator/contains.ts

   1 import type {
   2   CodeKeywordDefinition,
   3   KeywordErrorDefinition,
   4   ErrorObject,
   5   AnySchema,
   6 } from "../../types"
   7 import type {KeywordCxt} from "../../compile/validate"
   8 import {_, str, Name} from "../../compile/codegen"
   9 import {alwaysValidSchema, checkStrictMode, Type} from "../../compile/util"
  10
  11 export type ContainsError = ErrorObject<
  12   "contains",
  13   {minContains: number; maxContains?: number},
  14   AnySchema
  15 >
  16
  17 const error: KeywordErrorDefinition = {
  18   message: ({params: {min, max}}) =>
  19     max === undefined
  20       ? str`must contain at least ${min} valid item(s)`
  21       : str`must contain at least ${min} and no more than ${max} valid item(s)`,
  22   params: ({params: {min, max}}) =>
  23     max === undefined ? _`{minContains: ${min}}` : _`{minContains: ${min}, maxContains: ${max}}`,
  24 }
  25
  26 const def: CodeKeywordDefinition = {
  27   keyword: "contains",
  28   type: "array",
  29   schemaType: ["object", "boolean"],
  30   before: "uniqueItems",
  31   trackErrors: true,
  32   error,
  33   code(cxt: KeywordCxt) {
  34     const {gen, schema, parentSchema, data, it} = cxt
  35     let min: number
  36     let max: number | undefined
  37     const {minContains, maxContains} = parentSchema
  38     if (it.opts.next) {
  39       min = minContains === undefined ? 1 : minContains
  40       max = maxContains
  41     } else {
  42       min = 1
  43     }
  44     const len = gen.const("len", _`${data}.length`)
  45     cxt.setParams({min, max})
  46     if (max === undefined && min === 0) {
  47       checkStrictMode(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`)
  48       return
  49     }
  50     if (max !== undefined && min > max) {
  51       checkStrictMode(it, `"minContains" > "maxContains" is always invalid`)
  52       cxt.fail()
  53       return
  54     }
  55     if (alwaysValidSchema(it, schema)) {
  56       let cond = _`${len} >= ${min}`
  57       if (max !== undefined) cond = _`${cond} && ${len} <= ${max}`
  58       cxt.pass(cond)
  59       return
  60     }
  61
  62     it.items = true
  63     const valid = gen.name("valid")
  64     if (max === undefined && min === 1) {
  65       validateItems(valid, () => gen.if(valid, () => gen.break()))
  66     } else if (min === 0) {
  67       gen.let(valid, true)
  68       if (max !== undefined) gen.if(_`${data}.length > 0`, validateItemsWithCount)
  69     } else {
  70       gen.let(valid, false)
  71       validateItemsWithCount()
  72     }
  73     cxt.result(valid, () => cxt.reset())
  74
  75     function validateItemsWithCount(): void {
  76       const schValid = gen.name("_valid")
  77       const count = gen.let("count", 0)
  78       validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)))
  79     }
  80
  81     function validateItems(_valid: Name, block: () => void): void {
  82       gen.forRange("i", 0, len, (i) => {
  83         cxt.subschema(
  84           {
  85             keyword: "contains",
  86             dataProp: i,
  87             dataPropType: Type.Num,
  88             compositeRule: true,
  89           },
  90           _valid
  91         )
  92         block()
  93       })
  94     }
  95
  96     function checkLimits(count: Name): void {
  97       gen.code(_`${count}++`)
  98       if (max === undefined) {
  99         gen.if(_`${count} >= ${min}`, () => gen.assign(valid, true).break())
 100       } else {
 101         gen.if(_`${count} > ${max}`, () => gen.assign(valid, false).break())
 102         if (min === 1) gen.assign(valid, true)
 103         else gen.if(_`${count} >= ${min}`, () => gen.assign(valid, true))
 104       }
 105     }
 106   },
 107 }
 108
 109 export default def