Function callRef

docs/scripts/ajv-validator.js:5685–5747

(cxt, v, sch, $async)

            }
            exports.getValidate = getValidate;
            function callRef(cxt, v, sch, $async) {
                const { gen, it } = cxt;
                const { allErrors, schemaEnv: env, opts } = it;
                const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;
                if ($async)
                    callAsyncRef();
                else
                    callSyncRef();
                function callAsyncRef() {
                    if (!env.$async)
                        throw new Error("async schema referenced by sync schema");
                    const valid = gen.let("valid");
                    gen.try(() => {
                        gen.code((0, codegen_1._) `await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`);
                        addEvaluatedFrom(v); // TODO will not work with async, it has to be returned with the result
                        if (!allErrors)
                            gen.assign(valid, true);
                    }, (e) => {
                        gen.if((0, codegen_1._) `!(${e} instanceof ${it.ValidationError})`, () => gen.throw(e));
                        addErrorsFrom(e);
                        if (!allErrors)
                            gen.assign(valid, false);
                    });
                    cxt.ok(valid);
                }
                function callSyncRef() {
                    cxt.result((0, code_1.callValidateCode)(cxt, v, passCxt), () => addEvaluatedFrom(v), () => addErrorsFrom(v));
                }
                function addErrorsFrom(source) {
                    const errs = (0, codegen_1._) `${source}.errors`;
                    gen.assign(names_1.default.vErrors, (0, codegen_1._) `${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`); // TODO tagged
                    gen.assign(names_1.default.errors, (0, codegen_1._) `${names_1.default.vErrors}.length`);
                }
                function addEvaluatedFrom(source) {
                    var _a;
                    if (!it.opts.unevaluated)
                        return;
                    const schEvaluated = (_a = sch === null || sch === void 0 ? void 0 : sch.validate) === null || _a === void 0 ? void 0 : _a.evaluated;
                    // TODO refactor
                    if (it.props !== true) {
                        if (schEvaluated && !schEvaluated.dynamicProps) {
                            if (schEvaluated.props !== undefined) {
                                it.props = util_1.mergeEvaluated.props(gen, schEvaluated.props, it.props);
                            }
                        }
                        else {
                            const props = gen.var("props", (0, codegen_1._) `${source}.evaluated.props`);
                            it.props = util_1.mergeEvaluated.props(gen, props, it.props, codegen_1.Name);
                        }
                    }
                    if (it.items !== true) {
                        if (schEvaluated && !schEvaluated.dynamicItems) {
                            if (schEvaluated.items !== undefined) {
                                it.items = util_1.mergeEvaluated.items(gen, schEvaluated.items, it.items);
                            }
                        }
                        else {
                            const items = gen.var("items", (0, codegen_1._) `${source}.evaluated.items`);