| import type { |
| CodeKeywordDefinition, |
| KeywordErrorDefinition, |
| ErrorObject, |
| AnySchema, |
| } from "../../types" |
| import type {KeywordCxt} from "../../compile/validate" |
| import {_, str, Name} from "../../compile/codegen" |
| import {alwaysValidSchema, checkStrictMode, Type} from "../../compile/util" |
| |
| export type ContainsError = ErrorObject< |
| "contains", |
| {minContains: number; maxContains?: number}, |
| AnySchema |
| > |
| |
| const error: KeywordErrorDefinition = { |
| message: ({params: {min, max}}) => |
| max === undefined |
| ? str`must contain at least ${min} valid item(s)` |
| : str`must contain at least ${min} and no more than ${max} valid item(s)`, |
| params: ({params: {min, max}}) => |
| max === undefined ? _`{minContains: ${min}}` : _`{minContains: ${min}, maxContains: ${max}}`, |
| } |
| |
| const def: CodeKeywordDefinition = { |
| keyword: "contains", |
| type: "array", |
| schemaType: ["object", "boolean"], |
| before: "uniqueItems", |
| trackErrors: true, |
| error, |
| code(cxt: KeywordCxt) { |
| const {gen, schema, parentSchema, data, it} = cxt |
| let min: number |
| let max: number | undefined |
| const {minContains, maxContains} = parentSchema |
| if (it.opts.next) { |
| min = minContains === undefined ? 1 : minContains |
| max = maxContains |
| } else { |
| min = 1 |
| } |
| const len = gen.const("len", _`${data}.length`) |
| cxt.setParams({min, max}) |
| if (max === undefined && min === 0) { |
| checkStrictMode(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`) |
| return |
| } |
| if (max !== undefined && min > max) { |
| checkStrictMode(it, `"minContains" > "maxContains" is always invalid`) |
| cxt.fail() |
| return |
| } |
| if (alwaysValidSchema(it, schema)) { |
| let cond = _`${len} >= ${min}` |
| if (max !== undefined) cond = _`${cond} && ${len} <= ${max}` |
| cxt.pass(cond) |
| return |
| } |
| |
| it.items = true |
| const valid = gen.name("valid") |
| if (max === undefined && min === 1) { |
| validateItems(valid, () => gen.if(valid, () => gen.break())) |
| } else if (min === 0) { |
| gen.let(valid, true) |
| if (max !== undefined) gen.if(_`${data}.length > 0`, validateItemsWithCount) |
| } else { |
| gen.let(valid, false) |
| validateItemsWithCount() |
| } |
| cxt.result(valid, () => cxt.reset()) |
| |
| function validateItemsWithCount(): void { |
| const schValid = gen.name("_valid") |
| const count = gen.let("count", 0) |
| validateItems(schValid, () => gen.if(schValid, () => checkLimits(count))) |
| } |
| |
| function validateItems(_valid: Name, block: () => void): void { |
| gen.forRange("i", 0, len, (i) => { |
| cxt.subschema( |
| { |
| keyword: "contains", |
| dataProp: i, |
| dataPropType: Type.Num, |
| compositeRule: true, |
| }, |
| _valid |
| ) |
| block() |
| }) |
| } |
| |
| function checkLimits(count: Name): void { |
| gen.code(_`${count}++`) |
| if (max === undefined) { |
| gen.if(_`${count} >= ${min}`, () => gen.assign(valid, true).break()) |
| } else { |
| gen.if(_`${count} > ${max}`, () => gen.assign(valid, false).break()) |
| if (min === 1) gen.assign(valid, true) |
| else gen.if(_`${count} >= ${min}`, () => gen.assign(valid, true)) |
| } |
| } |
| }, |
| } |
| |
| export default def |
