source: imaps-frontend/node_modules/ajv/dist/core.js

main
Last change on this file was 79a0317, checked in by stefan toskovski <stefantoska84@…>, 3 days ago

F4 Finalna Verzija
  • Property mode set to 100644
File size: 24.6 KB
Line 
1"use strict";
2Object.defineProperty(exports, "__esModule", { value: true });
3exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;
4var validate_1 = require("./compile/validate");
5Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function () { return validate_1.KeywordCxt; } });
6var codegen_1 = require("./compile/codegen");
7Object.defineProperty(exports, "_", { enumerable: true, get: function () { return codegen_1._; } });
8Object.defineProperty(exports, "str", { enumerable: true, get: function () { return codegen_1.str; } });
9Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return codegen_1.stringify; } });
10Object.defineProperty(exports, "nil", { enumerable: true, get: function () { return codegen_1.nil; } });
11Object.defineProperty(exports, "Name", { enumerable: true, get: function () { return codegen_1.Name; } });
12Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function () { return codegen_1.CodeGen; } });
13const validation_error_1 = require("./runtime/validation_error");
14const ref_error_1 = require("./compile/ref_error");
15const rules_1 = require("./compile/rules");
16const compile_1 = require("./compile");
17const codegen_2 = require("./compile/codegen");
18const resolve_1 = require("./compile/resolve");
19const dataType_1 = require("./compile/validate/dataType");
20const util_1 = require("./compile/util");
21const $dataRefSchema = require("./refs/data.json");
22const uri_1 = require("./runtime/uri");
23const defaultRegExp = (str, flags) => new RegExp(str, flags);
24defaultRegExp.code = "new RegExp";
25const META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"];
26const EXT_SCOPE_NAMES = new Set([
27 "validate",
28 "serialize",
29 "parse",
30 "wrapper",
31 "root",
32 "schema",
33 "keyword",
34 "pattern",
35 "formats",
36 "validate$data",
37 "func",
38 "obj",
39 "Error",
40]);
41const removedOptions = {
42 errorDataPath: "",
43 format: "`validateFormats: false` can be used instead.",
44 nullable: '"nullable" keyword is supported by default.',
45 jsonPointers: "Deprecated jsPropertySyntax can be used instead.",
46 extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.",
47 missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.",
48 processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`",
49 sourceCode: "Use option `code: {source: true}`",
50 strictDefaults: "It is default now, see option `strict`.",
51 strictKeywords: "It is default now, see option `strict`.",
52 uniqueItems: '"uniqueItems" keyword is always validated.',
53 unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).",
54 cache: "Map is used as cache, schema object as key.",
55 serialize: "Map is used as cache, schema object as key.",
56 ajvErrors: "It is default now.",
57};
58const deprecatedOptions = {
59 ignoreKeywordsWithRef: "",
60 jsPropertySyntax: "",
61 unicode: '"minLength"/"maxLength" account for unicode characters by default.',
62};
63const MAX_EXPRESSION = 200;
64// eslint-disable-next-line complexity
65function requiredOptions(o) {
66 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, _0;
67 const s = o.strict;
68 const _optz = (_a = o.code) === null || _a === void 0 ? void 0 : _a.optimize;
69 const optimize = _optz === true || _optz === undefined ? 1 : _optz || 0;
70 const regExp = (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0 ? _c : defaultRegExp;
71 const uriResolver = (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default;
72 return {
73 strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !== null && _f !== void 0 ? _f : true,
74 strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !== null && _h !== void 0 ? _h : true,
75 strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !== null && _k !== void 0 ? _k : "log",
76 strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !== null && _m !== void 0 ? _m : "log",
77 strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !== null && _p !== void 0 ? _p : false,
78 code: o.code ? { ...o.code, optimize, regExp } : { optimize, regExp },
79 loopRequired: (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION,
80 loopEnum: (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION,
81 meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true,
82 messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true,
83 inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true,
84 schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : "$id",
85 addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true,
86 validateSchema: (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true,
87 validateFormats: (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true,
88 unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true,
89 int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true,
90 uriResolver: uriResolver,
91 };
92}
93class Ajv {
94 constructor(opts = {}) {
95 this.schemas = {};
96 this.refs = {};
97 this.formats = {};
98 this._compilations = new Set();
99 this._loading = {};
100 this._cache = new Map();
101 opts = this.opts = { ...opts, ...requiredOptions(opts) };
102 const { es5, lines } = this.opts.code;
103 this.scope = new codegen_2.ValueScope({ scope: {}, prefixes: EXT_SCOPE_NAMES, es5, lines });
104 this.logger = getLogger(opts.logger);
105 const formatOpt = opts.validateFormats;
106 opts.validateFormats = false;
107 this.RULES = (0, rules_1.getRules)();
108 checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED");
109 checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn");
110 this._metaOpts = getMetaSchemaOptions.call(this);
111 if (opts.formats)
112 addInitialFormats.call(this);
113 this._addVocabularies();
114 this._addDefaultMetaSchema();
115 if (opts.keywords)
116 addInitialKeywords.call(this, opts.keywords);
117 if (typeof opts.meta == "object")
118 this.addMetaSchema(opts.meta);
119 addInitialSchemas.call(this);
120 opts.validateFormats = formatOpt;
121 }
122 _addVocabularies() {
123 this.addKeyword("$async");
124 }
125 _addDefaultMetaSchema() {
126 const { $data, meta, schemaId } = this.opts;
127 let _dataRefSchema = $dataRefSchema;
128 if (schemaId === "id") {
129 _dataRefSchema = { ...$dataRefSchema };
130 _dataRefSchema.id = _dataRefSchema.$id;
131 delete _dataRefSchema.$id;
132 }
133 if (meta && $data)
134 this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);
135 }
136 defaultMeta() {
137 const { meta, schemaId } = this.opts;
138 return (this.opts.defaultMeta = typeof meta == "object" ? meta[schemaId] || meta : undefined);
139 }
140 validate(schemaKeyRef, // key, ref or schema object
141 // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
142 data // to be validated
143 ) {
144 let v;
145 if (typeof schemaKeyRef == "string") {
146 v = this.getSchema(schemaKeyRef);
147 if (!v)
148 throw new Error(`no schema with key or ref "${schemaKeyRef}"`);
149 }
150 else {
151 v = this.compile(schemaKeyRef);
152 }
153 const valid = v(data);
154 if (!("$async" in v))
155 this.errors = v.errors;
156 return valid;
157 }
158 compile(schema, _meta) {
159 const sch = this._addSchema(schema, _meta);
160 return (sch.validate || this._compileSchemaEnv(sch));
161 }
162 compileAsync(schema, meta) {
163 if (typeof this.opts.loadSchema != "function") {
164 throw new Error("options.loadSchema should be a function");
165 }
166 const { loadSchema } = this.opts;
167 return runCompileAsync.call(this, schema, meta);
168 async function runCompileAsync(_schema, _meta) {
169 await loadMetaSchema.call(this, _schema.$schema);
170 const sch = this._addSchema(_schema, _meta);
171 return sch.validate || _compileAsync.call(this, sch);
172 }
173 async function loadMetaSchema($ref) {
174 if ($ref && !this.getSchema($ref)) {
175 await runCompileAsync.call(this, { $ref }, true);
176 }
177 }
178 async function _compileAsync(sch) {
179 try {
180 return this._compileSchemaEnv(sch);
181 }
182 catch (e) {
183 if (!(e instanceof ref_error_1.default))
184 throw e;
185 checkLoaded.call(this, e);
186 await loadMissingSchema.call(this, e.missingSchema);
187 return _compileAsync.call(this, sch);
188 }
189 }
190 function checkLoaded({ missingSchema: ref, missingRef }) {
191 if (this.refs[ref]) {
192 throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`);
193 }
194 }
195 async function loadMissingSchema(ref) {
196 const _schema = await _loadSchema.call(this, ref);
197 if (!this.refs[ref])
198 await loadMetaSchema.call(this, _schema.$schema);
199 if (!this.refs[ref])
200 this.addSchema(_schema, ref, meta);
201 }
202 async function _loadSchema(ref) {
203 const p = this._loading[ref];
204 if (p)
205 return p;
206 try {
207 return await (this._loading[ref] = loadSchema(ref));
208 }
209 finally {
210 delete this._loading[ref];
211 }
212 }
213 }
214 // Adds schema to the instance
215 addSchema(schema, // If array is passed, `key` will be ignored
216 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`.
217 _meta, // true if schema is a meta-schema. Used internally, addMetaSchema should be used instead.
218 _validateSchema = this.opts.validateSchema // false to skip schema validation. Used internally, option validateSchema should be used instead.
219 ) {
220 if (Array.isArray(schema)) {
221 for (const sch of schema)
222 this.addSchema(sch, undefined, _meta, _validateSchema);
223 return this;
224 }
225 let id;
226 if (typeof schema === "object") {
227 const { schemaId } = this.opts;
228 id = schema[schemaId];
229 if (id !== undefined && typeof id != "string") {
230 throw new Error(`schema ${schemaId} must be string`);
231 }
232 }
233 key = (0, resolve_1.normalizeId)(key || id);
234 this._checkUnique(key);
235 this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true);
236 return this;
237 }
238 // Add schema that will be used to validate other schemas
239 // options in META_IGNORE_OPTIONS are alway set to false
240 addMetaSchema(schema, key, // schema key
241 _validateSchema = this.opts.validateSchema // false to skip schema validation, can be used to override validateSchema option for meta-schema
242 ) {
243 this.addSchema(schema, key, true, _validateSchema);
244 return this;
245 }
246 // Validate schema against its meta-schema
247 validateSchema(schema, throwOrLogError) {
248 if (typeof schema == "boolean")
249 return true;
250 let $schema;
251 $schema = schema.$schema;
252 if ($schema !== undefined && typeof $schema != "string") {
253 throw new Error("$schema must be a string");
254 }
255 $schema = $schema || this.opts.defaultMeta || this.defaultMeta();
256 if (!$schema) {
257 this.logger.warn("meta-schema not available");
258 this.errors = null;
259 return true;
260 }
261 const valid = this.validate($schema, schema);
262 if (!valid && throwOrLogError) {
263 const message = "schema is invalid: " + this.errorsText();
264 if (this.opts.validateSchema === "log")
265 this.logger.error(message);
266 else
267 throw new Error(message);
268 }
269 return valid;
270 }
271 // Get compiled schema by `key` or `ref`.
272 // (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id)
273 getSchema(keyRef) {
274 let sch;
275 while (typeof (sch = getSchEnv.call(this, keyRef)) == "string")
276 keyRef = sch;
277 if (sch === undefined) {
278 const { schemaId } = this.opts;
279 const root = new compile_1.SchemaEnv({ schema: {}, schemaId });
280 sch = compile_1.resolveSchema.call(this, root, keyRef);
281 if (!sch)
282 return;
283 this.refs[keyRef] = sch;
284 }
285 return (sch.validate || this._compileSchemaEnv(sch));
286 }
287 // Remove cached schema(s).
288 // If no parameter is passed all schemas but meta-schemas are removed.
289 // If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.
290 // Even if schema is referenced by other schemas it still can be removed as other schemas have local references.
291 removeSchema(schemaKeyRef) {
292 if (schemaKeyRef instanceof RegExp) {
293 this._removeAllSchemas(this.schemas, schemaKeyRef);
294 this._removeAllSchemas(this.refs, schemaKeyRef);
295 return this;
296 }
297 switch (typeof schemaKeyRef) {
298 case "undefined":
299 this._removeAllSchemas(this.schemas);
300 this._removeAllSchemas(this.refs);
301 this._cache.clear();
302 return this;
303 case "string": {
304 const sch = getSchEnv.call(this, schemaKeyRef);
305 if (typeof sch == "object")
306 this._cache.delete(sch.schema);
307 delete this.schemas[schemaKeyRef];
308 delete this.refs[schemaKeyRef];
309 return this;
310 }
311 case "object": {
312 const cacheKey = schemaKeyRef;
313 this._cache.delete(cacheKey);
314 let id = schemaKeyRef[this.opts.schemaId];
315 if (id) {
316 id = (0, resolve_1.normalizeId)(id);
317 delete this.schemas[id];
318 delete this.refs[id];
319 }
320 return this;
321 }
322 default:
323 throw new Error("ajv.removeSchema: invalid parameter");
324 }
325 }
326 // add "vocabulary" - a collection of keywords
327 addVocabulary(definitions) {
328 for (const def of definitions)
329 this.addKeyword(def);
330 return this;
331 }
332 addKeyword(kwdOrDef, def // deprecated
333 ) {
334 let keyword;
335 if (typeof kwdOrDef == "string") {
336 keyword = kwdOrDef;
337 if (typeof def == "object") {
338 this.logger.warn("these parameters are deprecated, see docs for addKeyword");
339 def.keyword = keyword;
340 }
341 }
342 else if (typeof kwdOrDef == "object" && def === undefined) {
343 def = kwdOrDef;
344 keyword = def.keyword;
345 if (Array.isArray(keyword) && !keyword.length) {
346 throw new Error("addKeywords: keyword must be string or non-empty array");
347 }
348 }
349 else {
350 throw new Error("invalid addKeywords parameters");
351 }
352 checkKeyword.call(this, keyword, def);
353 if (!def) {
354 (0, util_1.eachItem)(keyword, (kwd) => addRule.call(this, kwd));
355 return this;
356 }
357 keywordMetaschema.call(this, def);
358 const definition = {
359 ...def,
360 type: (0, dataType_1.getJSONTypes)(def.type),
361 schemaType: (0, dataType_1.getJSONTypes)(def.schemaType),
362 };
363 (0, util_1.eachItem)(keyword, definition.type.length === 0
364 ? (k) => addRule.call(this, k, definition)
365 : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t)));
366 return this;
367 }
368 getKeyword(keyword) {
369 const rule = this.RULES.all[keyword];
370 return typeof rule == "object" ? rule.definition : !!rule;
371 }
372 // Remove keyword
373 removeKeyword(keyword) {
374 // TODO return type should be Ajv
375 const { RULES } = this;
376 delete RULES.keywords[keyword];
377 delete RULES.all[keyword];
378 for (const group of RULES.rules) {
379 const i = group.rules.findIndex((rule) => rule.keyword === keyword);
380 if (i >= 0)
381 group.rules.splice(i, 1);
382 }
383 return this;
384 }
385 // Add format
386 addFormat(name, format) {
387 if (typeof format == "string")
388 format = new RegExp(format);
389 this.formats[name] = format;
390 return this;
391 }
392 errorsText(errors = this.errors, // optional array of validation errors
393 { separator = ", ", dataVar = "data" } = {} // optional options with properties `separator` and `dataVar`
394 ) {
395 if (!errors || errors.length === 0)
396 return "No errors";
397 return errors
398 .map((e) => `${dataVar}${e.instancePath} ${e.message}`)
399 .reduce((text, msg) => text + separator + msg);
400 }
401 $dataMetaSchema(metaSchema, keywordsJsonPointers) {
402 const rules = this.RULES.all;
403 metaSchema = JSON.parse(JSON.stringify(metaSchema));
404 for (const jsonPointer of keywordsJsonPointers) {
405 const segments = jsonPointer.split("/").slice(1); // first segment is an empty string
406 let keywords = metaSchema;
407 for (const seg of segments)
408 keywords = keywords[seg];
409 for (const key in rules) {
410 const rule = rules[key];
411 if (typeof rule != "object")
412 continue;
413 const { $data } = rule.definition;
414 const schema = keywords[key];
415 if ($data && schema)
416 keywords[key] = schemaOrData(schema);
417 }
418 }
419 return metaSchema;
420 }
421 _removeAllSchemas(schemas, regex) {
422 for (const keyRef in schemas) {
423 const sch = schemas[keyRef];
424 if (!regex || regex.test(keyRef)) {
425 if (typeof sch == "string") {
426 delete schemas[keyRef];
427 }
428 else if (sch && !sch.meta) {
429 this._cache.delete(sch.schema);
430 delete schemas[keyRef];
431 }
432 }
433 }
434 }
435 _addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
436 let id;
437 const { schemaId } = this.opts;
438 if (typeof schema == "object") {
439 id = schema[schemaId];
440 }
441 else {
442 if (this.opts.jtd)
443 throw new Error("schema must be object");
444 else if (typeof schema != "boolean")
445 throw new Error("schema must be object or boolean");
446 }
447 let sch = this._cache.get(schema);
448 if (sch !== undefined)
449 return sch;
450 baseId = (0, resolve_1.normalizeId)(id || baseId);
451 const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);
452 sch = new compile_1.SchemaEnv({ schema, schemaId, meta, baseId, localRefs });
453 this._cache.set(sch.schema, sch);
454 if (addSchema && !baseId.startsWith("#")) {
455 // TODO atm it is allowed to overwrite schemas without id (instead of not adding them)
456 if (baseId)
457 this._checkUnique(baseId);
458 this.refs[baseId] = sch;
459 }
460 if (validateSchema)
461 this.validateSchema(schema, true);
462 return sch;
463 }
464 _checkUnique(id) {
465 if (this.schemas[id] || this.refs[id]) {
466 throw new Error(`schema with key or id "${id}" already exists`);
467 }
468 }
469 _compileSchemaEnv(sch) {
470 if (sch.meta)
471 this._compileMetaSchema(sch);
472 else
473 compile_1.compileSchema.call(this, sch);
474 /* istanbul ignore if */
475 if (!sch.validate)
476 throw new Error("ajv implementation error");
477 return sch.validate;
478 }
479 _compileMetaSchema(sch) {
480 const currentOpts = this.opts;
481 this.opts = this._metaOpts;
482 try {
483 compile_1.compileSchema.call(this, sch);
484 }
485 finally {
486 this.opts = currentOpts;
487 }
488 }
489}
490Ajv.ValidationError = validation_error_1.default;
491Ajv.MissingRefError = ref_error_1.default;
492exports.default = Ajv;
493function checkOptions(checkOpts, options, msg, log = "error") {
494 for (const key in checkOpts) {
495 const opt = key;
496 if (opt in options)
497 this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`);
498 }
499}
500function getSchEnv(keyRef) {
501 keyRef = (0, resolve_1.normalizeId)(keyRef); // TODO tests fail without this line
502 return this.schemas[keyRef] || this.refs[keyRef];
503}
504function addInitialSchemas() {
505 const optsSchemas = this.opts.schemas;
506 if (!optsSchemas)
507 return;
508 if (Array.isArray(optsSchemas))
509 this.addSchema(optsSchemas);
510 else
511 for (const key in optsSchemas)
512 this.addSchema(optsSchemas[key], key);
513}
514function addInitialFormats() {
515 for (const name in this.opts.formats) {
516 const format = this.opts.formats[name];
517 if (format)
518 this.addFormat(name, format);
519 }
520}
521function addInitialKeywords(defs) {
522 if (Array.isArray(defs)) {
523 this.addVocabulary(defs);
524 return;
525 }
526 this.logger.warn("keywords option as map is deprecated, pass array");
527 for (const keyword in defs) {
528 const def = defs[keyword];
529 if (!def.keyword)
530 def.keyword = keyword;
531 this.addKeyword(def);
532 }
533}
534function getMetaSchemaOptions() {
535 const metaOpts = { ...this.opts };
536 for (const opt of META_IGNORE_OPTIONS)
537 delete metaOpts[opt];
538 return metaOpts;
539}
540const noLogs = { log() { }, warn() { }, error() { } };
541function getLogger(logger) {
542 if (logger === false)
543 return noLogs;
544 if (logger === undefined)
545 return console;
546 if (logger.log && logger.warn && logger.error)
547 return logger;
548 throw new Error("logger must implement log, warn and error methods");
549}
550const KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
551function checkKeyword(keyword, def) {
552 const { RULES } = this;
553 (0, util_1.eachItem)(keyword, (kwd) => {
554 if (RULES.keywords[kwd])
555 throw new Error(`Keyword ${kwd} is already defined`);
556 if (!KEYWORD_NAME.test(kwd))
557 throw new Error(`Keyword ${kwd} has invalid name`);
558 });
559 if (!def)
560 return;
561 if (def.$data && !("code" in def || "validate" in def)) {
562 throw new Error('$data keyword must have "code" or "validate" function');
563 }
564}
565function addRule(keyword, definition, dataType) {
566 var _a;
567 const post = definition === null || definition === void 0 ? void 0 : definition.post;
568 if (dataType && post)
569 throw new Error('keyword with "post" flag cannot have "type"');
570 const { RULES } = this;
571 let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);
572 if (!ruleGroup) {
573 ruleGroup = { type: dataType, rules: [] };
574 RULES.rules.push(ruleGroup);
575 }
576 RULES.keywords[keyword] = true;
577 if (!definition)
578 return;
579 const rule = {
580 keyword,
581 definition: {
582 ...definition,
583 type: (0, dataType_1.getJSONTypes)(definition.type),
584 schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType),
585 },
586 };
587 if (definition.before)
588 addBeforeRule.call(this, ruleGroup, rule, definition.before);
589 else
590 ruleGroup.rules.push(rule);
591 RULES.all[keyword] = rule;
592 (_a = definition.implements) === null || _a === void 0 ? void 0 : _a.forEach((kwd) => this.addKeyword(kwd));
593}
594function addBeforeRule(ruleGroup, rule, before) {
595 const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before);
596 if (i >= 0) {
597 ruleGroup.rules.splice(i, 0, rule);
598 }
599 else {
600 ruleGroup.rules.push(rule);
601 this.logger.warn(`rule ${before} is not defined`);
602 }
603}
604function keywordMetaschema(def) {
605 let { metaSchema } = def;
606 if (metaSchema === undefined)
607 return;
608 if (def.$data && this.opts.$data)
609 metaSchema = schemaOrData(metaSchema);
610 def.validateSchema = this.compile(metaSchema, true);
611}
612const $dataRef = {
613 $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
614};
615function schemaOrData(schema) {
616 return { anyOf: [schema, $dataRef] };
617}
618//# sourceMappingURL=core.js.map
Note: See TracBrowser for help on using the repository browser.