.config/coc/extensions/node_modules/coc-prettier/node_modules/table/node_modules/ajv/dist/compile/index.js

   1 "use strict";
   2 Object.defineProperty(exports, "__esModule", { value: true });
   3 exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0;
   4 const codegen_1 = require("./codegen");
   5 const validation_error_1 = require("../runtime/validation_error");
   6 const names_1 = require("./names");
   7 const resolve_1 = require("./resolve");
   8 const util_1 = require("./util");
   9 const validate_1 = require("./validate");
  10 const URI = require("uri-js");
  11 class SchemaEnv {
  12     constructor(env) {
  13         var _a;
  14         this.refs = {};
  15         this.dynamicAnchors = {};
  16         let schema;
  17         if (typeof env.schema == "object")
  18             schema = env.schema;
  19         this.schema = env.schema;
  20         this.schemaId = env.schemaId;
  21         this.root = env.root || this;
  22         this.baseId = (_a = env.baseId) !== null && _a !== void 0 ? _a : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env.schemaId || "$id"]);
  23         this.schemaPath = env.schemaPath;
  24         this.localRefs = env.localRefs;
  25         this.meta = env.meta;
  26         this.$async = schema === null || schema === void 0 ? void 0 : schema.$async;
  27         this.refs = {};
  28     }
  29 }
  30 exports.SchemaEnv = SchemaEnv;
  31 // let codeSize = 0
  32 // let nodeCount = 0
  33 // Compiles schema in SchemaEnv
  34 function compileSchema(sch) {
  35     // TODO refactor - remove compilations
  36     const _sch = getCompilingSchema.call(this, sch);
  37     if (_sch)
  38         return _sch;
  39     const rootId = (0, resolve_1.getFullPath)(sch.root.baseId); // TODO if getFullPath removed 1 tests fails
  40     const { es5, lines } = this.opts.code;
  41     const { ownProperties } = this.opts;
  42     const gen = new codegen_1.CodeGen(this.scope, { es5, lines, ownProperties });
  43     let _ValidationError;
  44     if (sch.$async) {
  45         _ValidationError = gen.scopeValue("Error", {
  46             ref: validation_error_1.default,
  47             code: (0, codegen_1._) `require("ajv/dist/runtime/validation_error").default`,
  48         });
  49     }
  50     const validateName = gen.scopeName("validate");
  51     sch.validateName = validateName;
  52     const schemaCxt = {
  53         gen,
  54         allErrors: this.opts.allErrors,
  55         data: names_1.default.data,
  56         parentData: names_1.default.parentData,
  57         parentDataProperty: names_1.default.parentDataProperty,
  58         dataNames: [names_1.default.data],
  59         dataPathArr: [codegen_1.nil],
  60         dataLevel: 0,
  61         dataTypes: [],
  62         definedProperties: new Set(),
  63         topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true
  64             ? { ref: sch.schema, code: (0, codegen_1.stringify)(sch.schema) }
  65             : { ref: sch.schema }),
  66         validateName,
  67         ValidationError: _ValidationError,
  68         schema: sch.schema,
  69         schemaEnv: sch,
  70         rootId,
  71         baseId: sch.baseId || rootId,
  72         schemaPath: codegen_1.nil,
  73         errSchemaPath: sch.schemaPath || (this.opts.jtd ? "" : "#"),
  74         errorPath: (0, codegen_1._) `""`,
  75         opts: this.opts,
  76         self: this,
  77     };
  78     let sourceCode;
  79     try {
  80         this._compilations.add(sch);
  81         (0, validate_1.validateFunctionCode)(schemaCxt);
  82         gen.optimize(this.opts.code.optimize);
  83         // gen.optimize(1)
  84         const validateCode = gen.toString();
  85         sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${validateCode}`;
  86         // console.log((codeSize += sourceCode.length), (nodeCount += gen.nodeCount))
  87         if (this.opts.code.process)
  88             sourceCode = this.opts.code.process(sourceCode, sch);
  89         // console.log("\n\n\n *** \n", sourceCode)
  90         const makeValidate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode);
  91         const validate = makeValidate(this, this.scope.get());
  92         this.scope.value(validateName, { ref: validate });
  93         validate.errors = null;
  94         validate.schema = sch.schema;
  95         validate.schemaEnv = sch;
  96         if (sch.$async)
  97             validate.$async = true;
  98         if (this.opts.code.source === true) {
  99             validate.source = { validateName, validateCode, scopeValues: gen._values };
 100         }
 101         if (this.opts.unevaluated) {
 102             const { props, items } = schemaCxt;
 103             validate.evaluated = {
 104                 props: props instanceof codegen_1.Name ? undefined : props,
 105                 items: items instanceof codegen_1.Name ? undefined : items,
 106                 dynamicProps: props instanceof codegen_1.Name,
 107                 dynamicItems: items instanceof codegen_1.Name,
 108             };
 109             if (validate.source)
 110                 validate.source.evaluated = (0, codegen_1.stringify)(validate.evaluated);
 111         }
 112         sch.validate = validate;
 113         return sch;
 114     }
 115     catch (e) {
 116         delete sch.validate;
 117         delete sch.validateName;
 118         if (sourceCode)
 119             this.logger.error("Error compiling schema, function code:", sourceCode);
 120         // console.log("\n\n\n *** \n", sourceCode, this.opts)
 121         throw e;
 122     }
 123     finally {
 124         this._compilations.delete(sch);
 125     }
 126 }
 127 exports.compileSchema = compileSchema;
 128 function resolveRef(root, baseId, ref) {
 129     var _a;
 130     ref = (0, resolve_1.resolveUrl)(baseId, ref);
 131     const schOrFunc = root.refs[ref];
 132     if (schOrFunc)
 133         return schOrFunc;
 134     let _sch = resolve.call(this, root, ref);
 135     if (_sch === undefined) {
 136         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref]; // TODO maybe localRefs should hold SchemaEnv
 137         const { schemaId } = this.opts;
 138         if (schema)
 139             _sch = new SchemaEnv({ schema, schemaId, root, baseId });
 140     }
 141     if (_sch === undefined)
 142         return;
 143     return (root.refs[ref] = inlineOrCompile.call(this, _sch));
 144 }
 145 exports.resolveRef = resolveRef;
 146 function inlineOrCompile(sch) {
 147     if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs))
 148         return sch.schema;
 149     return sch.validate ? sch : compileSchema.call(this, sch);
 150 }
 151 // Index of schema compilation in the currently compiled list
 152 function getCompilingSchema(schEnv) {
 153     for (const sch of this._compilations) {
 154         if (sameSchemaEnv(sch, schEnv))
 155             return sch;
 156     }
 157 }
 158 exports.getCompilingSchema = getCompilingSchema;
 159 function sameSchemaEnv(s1, s2) {
 160     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
 161 }
 162 // resolve and compile the references ($ref)
 163 // TODO returns AnySchemaObject (if the schema can be inlined) or validation function
 164 function resolve(root, // information about the root schema for the current schema
 165 ref // reference to resolve
 166 ) {
 167     let sch;
 168     while (typeof (sch = this.refs[ref]) == "string")
 169         ref = sch;
 170     return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
 171 }
 172 // Resolve schema, its root and baseId
 173 function resolveSchema(root, // root object with properties schema, refs TODO below SchemaEnv is assigned to it
 174 ref // reference to resolve
 175 ) {
 176     const p = URI.parse(ref);
 177     const refPath = (0, resolve_1._getFullPath)(p);
 178     let baseId = (0, resolve_1.getFullPath)(root.baseId);
 179     // TODO `Object.keys(root.schema).length > 0` should not be needed - but removing breaks 2 tests
 180     if (Object.keys(root.schema).length > 0 && refPath === baseId) {
 181         return getJsonPointer.call(this, p, root);
 182     }
 183     const id = (0, resolve_1.normalizeId)(refPath);
 184     const schOrRef = this.refs[id] || this.schemas[id];
 185     if (typeof schOrRef == "string") {
 186         const sch = resolveSchema.call(this, root, schOrRef);
 187         if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object")
 188             return;
 189         return getJsonPointer.call(this, p, sch);
 190     }
 191     if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object")
 192         return;
 193     if (!schOrRef.validate)
 194         compileSchema.call(this, schOrRef);
 195     if (id === (0, resolve_1.normalizeId)(ref)) {
 196         const { schema } = schOrRef;
 197         const { schemaId } = this.opts;
 198         const schId = schema[schemaId];
 199         if (schId)
 200             baseId = (0, resolve_1.resolveUrl)(baseId, schId);
 201         return new SchemaEnv({ schema, schemaId, root, baseId });
 202     }
 203     return getJsonPointer.call(this, p, schOrRef);
 204 }
 205 exports.resolveSchema = resolveSchema;
 206 const PREVENT_SCOPE_CHANGE = new Set([
 207     "properties",
 208     "patternProperties",
 209     "enum",
 210     "dependencies",
 211     "definitions",
 212 ]);
 213 function getJsonPointer(parsedRef, { baseId, schema, root }) {
 214     var _a;
 215     if (((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _a[0]) !== "/")
 216         return;
 217     for (const part of parsedRef.fragment.slice(1).split("/")) {
 218         if (typeof schema === "boolean")
 219             return;
 220         const partSchema = schema[(0, util_1.unescapeFragment)(part)];
 221         if (partSchema === undefined)
 222             return;
 223         schema = partSchema;
 224         // TODO PREVENT_SCOPE_CHANGE could be defined in keyword def?
 225         const schId = typeof schema === "object" && schema[this.opts.schemaId];
 226         if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {
 227             baseId = (0, resolve_1.resolveUrl)(baseId, schId);
 228         }
 229     }
 230     let env;
 231     if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
 232         const $ref = (0, resolve_1.resolveUrl)(baseId, schema.$ref);
 233         env = resolveSchema.call(this, root, $ref);
 234     }
 235     // even though resolution failed we need to return SchemaEnv to throw exception
 236     // so that compileAsync loads missing schema.
 237     const { schemaId } = this.opts;
 238     env = env || new SchemaEnv({ schema, schemaId, root, baseId });
 239     if (env.schema !== env.root.schema)
 240         return env;
 241     return undefined;
 242 }
 243 //# sourceMappingURL=index.js.map