| "use strict"; |
| Object.defineProperty(exports, "__esModule", { value: true }); |
| exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0; |
| var validate_1 = require("./compile/validate"); |
| Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function () { return validate_1.KeywordCxt; } }); |
| var codegen_1 = require("./compile/codegen"); |
| Object.defineProperty(exports, "_", { enumerable: true, get: function () { return codegen_1._; } }); |
| Object.defineProperty(exports, "str", { enumerable: true, get: function () { return codegen_1.str; } }); |
| Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return codegen_1.stringify; } }); |
| Object.defineProperty(exports, "nil", { enumerable: true, get: function () { return codegen_1.nil; } }); |
| Object.defineProperty(exports, "Name", { enumerable: true, get: function () { return codegen_1.Name; } }); |
| Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function () { return codegen_1.CodeGen; } }); |
| const validation_error_1 = require("./runtime/validation_error"); |
| const ref_error_1 = require("./compile/ref_error"); |
| const rules_1 = require("./compile/rules"); |
| const compile_1 = require("./compile"); |
| const codegen_2 = require("./compile/codegen"); |
| const resolve_1 = require("./compile/resolve"); |
| const dataType_1 = require("./compile/validate/dataType"); |
| const util_1 = require("./compile/util"); |
| const $dataRefSchema = require("./refs/data.json"); |
| const defaultRegExp = (str, flags) => new RegExp(str, flags); |
| defaultRegExp.code = "new RegExp"; |
| const META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"]; |
| const EXT_SCOPE_NAMES = new Set([ |
| "validate", |
| "serialize", |
| "parse", |
| "wrapper", |
| "root", |
| "schema", |
| "keyword", |
| "pattern", |
| "formats", |
| "validate$data", |
| "func", |
| "obj", |
| "Error", |
| ]); |
| const removedOptions = { |
| errorDataPath: "", |
| format: "`validateFormats: false` can be used instead.", |
| nullable: '"nullable" keyword is supported by default.', |
| jsonPointers: "Deprecated jsPropertySyntax can be used instead.", |
| extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.", |
| missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.", |
| processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`", |
| sourceCode: "Use option `code: {source: true}`", |
| strictDefaults: "It is default now, see option `strict`.", |
| strictKeywords: "It is default now, see option `strict`.", |
| uniqueItems: '"uniqueItems" keyword is always validated.', |
| unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).", |
| cache: "Map is used as cache, schema object as key.", |
| serialize: "Map is used as cache, schema object as key.", |
| ajvErrors: "It is default now.", |
| }; |
| const deprecatedOptions = { |
| ignoreKeywordsWithRef: "", |
| jsPropertySyntax: "", |
| unicode: '"minLength"/"maxLength" account for unicode characters by default.', |
| }; |
| const MAX_EXPRESSION = 200; |
| // eslint-disable-next-line complexity |
| function requiredOptions(o) { |
| var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z; |
| const s = o.strict; |
| const _optz = (_a = o.code) === null || _a === void 0 ? void 0 : _a.optimize; |
| const optimize = _optz === true || _optz === undefined ? 1 : _optz || 0; |
| const regExp = (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0 ? _c : defaultRegExp; |
| return { |
| strictSchema: (_e = (_d = o.strictSchema) !== null && _d !== void 0 ? _d : s) !== null && _e !== void 0 ? _e : true, |
| strictNumbers: (_g = (_f = o.strictNumbers) !== null && _f !== void 0 ? _f : s) !== null && _g !== void 0 ? _g : true, |
| strictTypes: (_j = (_h = o.strictTypes) !== null && _h !== void 0 ? _h : s) !== null && _j !== void 0 ? _j : "log", |
| strictTuples: (_l = (_k = o.strictTuples) !== null && _k !== void 0 ? _k : s) !== null && _l !== void 0 ? _l : "log", |
| strictRequired: (_o = (_m = o.strictRequired) !== null && _m !== void 0 ? _m : s) !== null && _o !== void 0 ? _o : false, |
| code: o.code ? { ...o.code, optimize, regExp } : { optimize, regExp }, |
| loopRequired: (_p = o.loopRequired) !== null && _p !== void 0 ? _p : MAX_EXPRESSION, |
| loopEnum: (_q = o.loopEnum) !== null && _q !== void 0 ? _q : MAX_EXPRESSION, |
| meta: (_r = o.meta) !== null && _r !== void 0 ? _r : true, |
| messages: (_s = o.messages) !== null && _s !== void 0 ? _s : true, |
| inlineRefs: (_t = o.inlineRefs) !== null && _t !== void 0 ? _t : true, |
| schemaId: (_u = o.schemaId) !== null && _u !== void 0 ? _u : "$id", |
| addUsedSchema: (_v = o.addUsedSchema) !== null && _v !== void 0 ? _v : true, |
| validateSchema: (_w = o.validateSchema) !== null && _w !== void 0 ? _w : true, |
| validateFormats: (_x = o.validateFormats) !== null && _x !== void 0 ? _x : true, |
| unicodeRegExp: (_y = o.unicodeRegExp) !== null && _y !== void 0 ? _y : true, |
| int32range: (_z = o.int32range) !== null && _z !== void 0 ? _z : true, |
| }; |
| } |
| class Ajv { |
| constructor(opts = {}) { |
| this.schemas = {}; |
| this.refs = {}; |
| this.formats = {}; |
| this._compilations = new Set(); |
| this._loading = {}; |
| this._cache = new Map(); |
| opts = this.opts = { ...opts, ...requiredOptions(opts) }; |
| const { es5, lines } = this.opts.code; |
| this.scope = new codegen_2.ValueScope({ scope: {}, prefixes: EXT_SCOPE_NAMES, es5, lines }); |
| this.logger = getLogger(opts.logger); |
| const formatOpt = opts.validateFormats; |
| opts.validateFormats = false; |
| this.RULES = (0, rules_1.getRules)(); |
| checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED"); |
| checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn"); |
| this._metaOpts = getMetaSchemaOptions.call(this); |
| if (opts.formats) |
| addInitialFormats.call(this); |
| this._addVocabularies(); |
| this._addDefaultMetaSchema(); |
| if (opts.keywords) |
| addInitialKeywords.call(this, opts.keywords); |
| if (typeof opts.meta == "object") |
| this.addMetaSchema(opts.meta); |
| addInitialSchemas.call(this); |
| opts.validateFormats = formatOpt; |
| } |
| _addVocabularies() { |
| this.addKeyword("$async"); |
| } |
| _addDefaultMetaSchema() { |
| const { $data, meta, schemaId } = this.opts; |
| let _dataRefSchema = $dataRefSchema; |
| if (schemaId === "id") { |
| _dataRefSchema = { ...$dataRefSchema }; |
| _dataRefSchema.id = _dataRefSchema.$id; |
| delete _dataRefSchema.$id; |
| } |
| if (meta && $data) |
| this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false); |
| } |
| defaultMeta() { |
| const { meta, schemaId } = this.opts; |
| return (this.opts.defaultMeta = typeof meta == "object" ? meta[schemaId] || meta : undefined); |
| } |
| validate(schemaKeyRef, // key, ref or schema object |
| data // to be validated |
| ) { |
| let v; |
| if (typeof schemaKeyRef == "string") { |
| v = this.getSchema(schemaKeyRef); |
| if (!v) |
| throw new Error(`no schema with key or ref "${schemaKeyRef}"`); |
| } |
| else { |
| v = this.compile(schemaKeyRef); |
| } |
| const valid = v(data); |
| if (!("$async" in v)) |
| this.errors = v.errors; |
| return valid; |
| } |
| compile(schema, _meta) { |
| const sch = this._addSchema(schema, _meta); |
| return (sch.validate || this._compileSchemaEnv(sch)); |
| } |
| compileAsync(schema, meta) { |
| if (typeof this.opts.loadSchema != "function") { |
| throw new Error("options.loadSchema should be a function"); |
| } |
| const { loadSchema } = this.opts; |
| return runCompileAsync.call(this, schema, meta); |
| async function runCompileAsync(_schema, _meta) { |
| await loadMetaSchema.call(this, _schema.$schema); |
| const sch = this._addSchema(_schema, _meta); |
| return sch.validate || _compileAsync.call(this, sch); |
| } |
| async function loadMetaSchema($ref) { |
| if ($ref && !this.getSchema($ref)) { |
| await runCompileAsync.call(this, { $ref }, true); |
| } |
| } |
| async function _compileAsync(sch) { |
| try { |
| return this._compileSchemaEnv(sch); |
| } |
| catch (e) { |
| if (!(e instanceof ref_error_1.default)) |
| throw e; |
| checkLoaded.call(this, e); |
| await loadMissingSchema.call(this, e.missingSchema); |
| return _compileAsync.call(this, sch); |
| } |
| } |
| function checkLoaded({ missingSchema: ref, missingRef }) { |
| if (this.refs[ref]) { |
| throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`); |
| } |
| } |
| async function loadMissingSchema(ref) { |
| const _schema = await _loadSchema.call(this, ref); |
| if (!this.refs[ref]) |
| await loadMetaSchema.call(this, _schema.$schema); |
| if (!this.refs[ref]) |
| this.addSchema(_schema, ref, meta); |
| } |
| async function _loadSchema(ref) { |
| const p = this._loading[ref]; |
| if (p) |
| return p; |
| try { |
| return await (this._loading[ref] = loadSchema(ref)); |
| } |
| finally { |
| delete this._loading[ref]; |
| } |
| } |
| } |
| // Adds schema to the instance |
| addSchema(schema, // If array is passed, `key` will be ignored |
| key, // Optional schema key. Can be passed to `validate` method instead of schema object or id/ref. One schema per instance can have empty `id` and `key`. |
| _meta, // true if schema is a meta-schema. Used internally, addMetaSchema should be used instead. |
| _validateSchema = this.opts.validateSchema // false to skip schema validation. Used internally, option validateSchema should be used instead. |
| ) { |
| if (Array.isArray(schema)) { |
| for (const sch of schema) |
| this.addSchema(sch, undefined, _meta, _validateSchema); |
| return this; |
| } |
| let id; |
| if (typeof schema === "object") { |
| const { schemaId } = this.opts; |
| id = schema[schemaId]; |
| if (id !== undefined && typeof id != "string") { |
| throw new Error(`schema ${schemaId} must be string`); |
| } |
| } |
| key = (0, resolve_1.normalizeId)(key || id); |
| this._checkUnique(key); |
| this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true); |
| return this; |
| } |
| // Add schema that will be used to validate other schemas |
| // options in META_IGNORE_OPTIONS are alway set to false |
| addMetaSchema(schema, key, // schema key |
| _validateSchema = this.opts.validateSchema // false to skip schema validation, can be used to override validateSchema option for meta-schema |
| ) { |
| this.addSchema(schema, key, true, _validateSchema); |
| return this; |
| } |
| // Validate schema against its meta-schema |
| validateSchema(schema, throwOrLogError) { |
| if (typeof schema == "boolean") |
| return true; |
| let $schema; |
| $schema = schema.$schema; |
| if ($schema !== undefined && typeof $schema != "string") { |
| throw new Error("$schema must be a string"); |
| } |
| $schema = $schema || this.opts.defaultMeta || this.defaultMeta(); |
| if (!$schema) { |
| this.logger.warn("meta-schema not available"); |
| this.errors = null; |
| return true; |
| } |
| const valid = this.validate($schema, schema); |
| if (!valid && throwOrLogError) { |
| const message = "schema is invalid: " + this.errorsText(); |
| if (this.opts.validateSchema === "log") |
| this.logger.error(message); |
| else |
| throw new Error(message); |
| } |
| return valid; |
| } |
| // Get compiled schema by `key` or `ref`. |
| // (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id) |
| getSchema(keyRef) { |
| let sch; |
| while (typeof (sch = getSchEnv.call(this, keyRef)) == "string") |
| keyRef = sch; |
| if (sch === undefined) { |
| const { schemaId } = this.opts; |
| const root = new compile_1.SchemaEnv({ schema: {}, schemaId }); |
| sch = compile_1.resolveSchema.call(this, root, keyRef); |
| if (!sch) |
| return; |
| this.refs[keyRef] = sch; |
| } |
| return (sch.validate || this._compileSchemaEnv(sch)); |
| } |
| // Remove cached schema(s). |
| // If no parameter is passed all schemas but meta-schemas are removed. |
| // If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed. |
| // Even if schema is referenced by other schemas it still can be removed as other schemas have local references. |
| removeSchema(schemaKeyRef) { |
| if (schemaKeyRef instanceof RegExp) { |
| this._removeAllSchemas(this.schemas, schemaKeyRef); |
| this._removeAllSchemas(this.refs, schemaKeyRef); |
| return this; |
| } |
| switch (typeof schemaKeyRef) { |
| case "undefined": |
| this._removeAllSchemas(this.schemas); |
| this._removeAllSchemas(this.refs); |
| this._cache.clear(); |
| return this; |
| case "string": { |
| const sch = getSchEnv.call(this, schemaKeyRef); |
| if (typeof sch == "object") |
| this._cache.delete(sch.schema); |
| delete this.schemas[schemaKeyRef]; |
| delete this.refs[schemaKeyRef]; |
| return this; |
| } |
| case "object": { |
| const cacheKey = schemaKeyRef; |
| this._cache.delete(cacheKey); |
| let id = schemaKeyRef[this.opts.schemaId]; |
| if (id) { |
| id = (0, resolve_1.normalizeId)(id); |
| delete this.schemas[id]; |
| delete this.refs[id]; |
| } |
| return this; |
| } |
| default: |
| throw new Error("ajv.removeSchema: invalid parameter"); |
| } |
| } |
| // add "vocabulary" - a collection of keywords |
| addVocabulary(definitions) { |
| for (const def of definitions) |
| this.addKeyword(def); |
| return this; |
| } |
| addKeyword(kwdOrDef, def // deprecated |
| ) { |
| let keyword; |
| if (typeof kwdOrDef == "string") { |
| keyword = kwdOrDef; |
| if (typeof def == "object") { |
| this.logger.warn("these parameters are deprecated, see docs for addKeyword"); |
| def.keyword = keyword; |
| } |
| } |
| else if (typeof kwdOrDef == "object" && def === undefined) { |
| def = kwdOrDef; |
| keyword = def.keyword; |
| if (Array.isArray(keyword) && !keyword.length) { |
| throw new Error("addKeywords: keyword must be string or non-empty array"); |
| } |
| } |
| else { |
| throw new Error("invalid addKeywords parameters"); |
| } |
| checkKeyword.call(this, keyword, def); |
| if (!def) { |
| (0, util_1.eachItem)(keyword, (kwd) => addRule.call(this, kwd)); |
| return this; |
| } |
| keywordMetaschema.call(this, def); |
| const definition = { |
| ...def, |
| type: (0, dataType_1.getJSONTypes)(def.type), |
| schemaType: (0, dataType_1.getJSONTypes)(def.schemaType), |
| }; |
| (0, util_1.eachItem)(keyword, definition.type.length === 0 |
| ? (k) => addRule.call(this, k, definition) |
| : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t))); |
| return this; |
| } |
| getKeyword(keyword) { |
| const rule = this.RULES.all[keyword]; |
| return typeof rule == "object" ? rule.definition : !!rule; |
| } |
| // Remove keyword |
| removeKeyword(keyword) { |
| // TODO return type should be Ajv |
| const { RULES } = this; |
| delete RULES.keywords[keyword]; |
| delete RULES.all[keyword]; |
| for (const group of RULES.rules) { |
| const i = group.rules.findIndex((rule) => rule.keyword === keyword); |
| if (i >= 0) |
| group.rules.splice(i, 1); |
| } |
| return this; |
| } |
| // Add format |
| addFormat(name, format) { |
| if (typeof format == "string") |
| format = new RegExp(format); |
| this.formats[name] = format; |
| return this; |
| } |
| errorsText(errors = this.errors, // optional array of validation errors |
| { separator = ", ", dataVar = "data" } = {} // optional options with properties `separator` and `dataVar` |
| ) { |
| if (!errors || errors.length === 0) |
| return "No errors"; |
| return errors |
| .map((e) => `${dataVar}${e.instancePath} ${e.message}`) |
| .reduce((text, msg) => text + separator + msg); |
| } |
| $dataMetaSchema(metaSchema, keywordsJsonPointers) { |
| const rules = this.RULES.all; |
| metaSchema = JSON.parse(JSON.stringify(metaSchema)); |
| for (const jsonPointer of keywordsJsonPointers) { |
| const segments = jsonPointer.split("/").slice(1); // first segment is an empty string |
| let keywords = metaSchema; |
| for (const seg of segments) |
| keywords = keywords[seg]; |
| for (const key in rules) { |
| const rule = rules[key]; |
| if (typeof rule != "object") |
| continue; |
| const { $data } = rule.definition; |
| const schema = keywords[key]; |
| if ($data && schema) |
| keywords[key] = schemaOrData(schema); |
| } |
| } |
| return metaSchema; |
| } |
| _removeAllSchemas(schemas, regex) { |
| for (const keyRef in schemas) { |
| const sch = schemas[keyRef]; |
| if (!regex || regex.test(keyRef)) { |
| if (typeof sch == "string") { |
| delete schemas[keyRef]; |
| } |
| else if (sch && !sch.meta) { |
| this._cache.delete(sch.schema); |
| delete schemas[keyRef]; |
| } |
| } |
| } |
| } |
| _addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) { |
| let id; |
| const { schemaId } = this.opts; |
| if (typeof schema == "object") { |
| id = schema[schemaId]; |
| } |
| else { |
| if (this.opts.jtd) |
| throw new Error("schema must be object"); |
| else if (typeof schema != "boolean") |
| throw new Error("schema must be object or boolean"); |
| } |
| let sch = this._cache.get(schema); |
| if (sch !== undefined) |
| return sch; |
| baseId = (0, resolve_1.normalizeId)(id || baseId); |
| const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId); |
| sch = new compile_1.SchemaEnv({ schema, schemaId, meta, baseId, localRefs }); |
| this._cache.set(sch.schema, sch); |
| if (addSchema && !baseId.startsWith("#")) { |
| // TODO atm it is allowed to overwrite schemas without id (instead of not adding them) |
| if (baseId) |
| this._checkUnique(baseId); |
| this.refs[baseId] = sch; |
| } |
| if (validateSchema) |
| this.validateSchema(schema, true); |
| return sch; |
| } |
| _checkUnique(id) { |
| if (this.schemas[id] || this.refs[id]) { |
| throw new Error(`schema with key or id "${id}" already exists`); |
| } |
| } |
| _compileSchemaEnv(sch) { |
| if (sch.meta) |
| this._compileMetaSchema(sch); |
| else |
| compile_1.compileSchema.call(this, sch); |
| /* istanbul ignore if */ |
| if (!sch.validate) |
| throw new Error("ajv implementation error"); |
| return sch.validate; |
| } |
| _compileMetaSchema(sch) { |
| const currentOpts = this.opts; |
| this.opts = this._metaOpts; |
| try { |
| compile_1.compileSchema.call(this, sch); |
| } |
| finally { |
| this.opts = currentOpts; |
| } |
| } |
| } |
| exports.default = Ajv; |
| Ajv.ValidationError = validation_error_1.default; |
| Ajv.MissingRefError = ref_error_1.default; |
| function checkOptions(checkOpts, options, msg, log = "error") { |
| for (const key in checkOpts) { |
| const opt = key; |
| if (opt in options) |
| this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`); |
| } |
| } |
| function getSchEnv(keyRef) { |
| keyRef = (0, resolve_1.normalizeId)(keyRef); // TODO tests fail without this line |
| return this.schemas[keyRef] || this.refs[keyRef]; |
| } |
| function addInitialSchemas() { |
| const optsSchemas = this.opts.schemas; |
| if (!optsSchemas) |
| return; |
| if (Array.isArray(optsSchemas)) |
| this.addSchema(optsSchemas); |
| else |
| for (const key in optsSchemas) |
| this.addSchema(optsSchemas[key], key); |
| } |
| function addInitialFormats() { |
| for (const name in this.opts.formats) { |
| const format = this.opts.formats[name]; |
| if (format) |
| this.addFormat(name, format); |
| } |
| } |
| function addInitialKeywords(defs) { |
| if (Array.isArray(defs)) { |
| this.addVocabulary(defs); |
| return; |
| } |
| this.logger.warn("keywords option as map is deprecated, pass array"); |
| for (const keyword in defs) { |
| const def = defs[keyword]; |
| if (!def.keyword) |
| def.keyword = keyword; |
| this.addKeyword(def); |
| } |
| } |
| function getMetaSchemaOptions() { |
| const metaOpts = { ...this.opts }; |
| for (const opt of META_IGNORE_OPTIONS) |
| delete metaOpts[opt]; |
| return metaOpts; |
| } |
| const noLogs = { log() { }, warn() { }, error() { } }; |
| function getLogger(logger) { |
| if (logger === false) |
| return noLogs; |
| if (logger === undefined) |
| return console; |
| if (logger.log && logger.warn && logger.error) |
| return logger; |
| throw new Error("logger must implement log, warn and error methods"); |
| } |
| const KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i; |
| function checkKeyword(keyword, def) { |
| const { RULES } = this; |
| (0, util_1.eachItem)(keyword, (kwd) => { |
| if (RULES.keywords[kwd]) |
| throw new Error(`Keyword ${kwd} is already defined`); |
| if (!KEYWORD_NAME.test(kwd)) |
| throw new Error(`Keyword ${kwd} has invalid name`); |
| }); |
| if (!def) |
| return; |
| if (def.$data && !("code" in def || "validate" in def)) { |
| throw new Error('$data keyword must have "code" or "validate" function'); |
| } |
| } |
| function addRule(keyword, definition, dataType) { |
| var _a; |
| const post = definition === null || definition === void 0 ? void 0 : definition.post; |
| if (dataType && post) |
| throw new Error('keyword with "post" flag cannot have "type"'); |
| const { RULES } = this; |
| let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType); |
| if (!ruleGroup) { |
| ruleGroup = { type: dataType, rules: [] }; |
| RULES.rules.push(ruleGroup); |
| } |
| RULES.keywords[keyword] = true; |
| if (!definition) |
| return; |
| const rule = { |
| keyword, |
| definition: { |
| ...definition, |
| type: (0, dataType_1.getJSONTypes)(definition.type), |
| schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType), |
| }, |
| }; |
| if (definition.before) |
| addBeforeRule.call(this, ruleGroup, rule, definition.before); |
| else |
| ruleGroup.rules.push(rule); |
| RULES.all[keyword] = rule; |
| (_a = definition.implements) === null || _a === void 0 ? void 0 : _a.forEach((kwd) => this.addKeyword(kwd)); |
| } |
| function addBeforeRule(ruleGroup, rule, before) { |
| const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before); |
| if (i >= 0) { |
| ruleGroup.rules.splice(i, 0, rule); |
| } |
| else { |
| ruleGroup.rules.push(rule); |
| this.logger.warn(`rule ${before} is not defined`); |
| } |
| } |
| function keywordMetaschema(def) { |
| let { metaSchema } = def; |
| if (metaSchema === undefined) |
| return; |
| if (def.$data && this.opts.$data) |
| metaSchema = schemaOrData(metaSchema); |
| def.validateSchema = this.compile(metaSchema, true); |
| } |
| const $dataRef = { |
| $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#", |
| }; |
| function schemaOrData(schema) { |
| return { anyOf: [schema, $dataRef] }; |
| } |
| //# sourceMappingURL=core.js.map |
