eslint-plugin-json-schema-validator/lib/utils/ajv-custom/limit-number.js

ESLint plugin that validates data using JSON Schema Validator.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.applyLimitNumberKeywords = void 0;
const ajv_1 = require("../ajv");
const ops = {
    GT: ajv_1._ `>`,
    GTE: ajv_1._ `>=`,
    LT: ajv_1._ `<`,
    LTE: ajv_1._ `<=`,
};
function applyLimitNumberKeywords(ajv) {
    const baseLimitNumbers = {
        maximum: ajv.getKeyword("maximum"),
        minimum: ajv.getKeyword("minimum"),
        exclusiveMaximum: ajv.getKeyword("exclusiveMaximum"),
        exclusiveMinimum: ajv.getKeyword("exclusiveMinimum"),
    };
    const minMax = {
        keyword: ["maximum", "minimum"],
        type: "number",
        schemaType: "number",
        $data: true,
        error: {
            message: (cxt) => {
                const { keyword, schemaCode, parentSchema } = cxt;
                if (keyword === "maximum" &&
                    parentSchema.exclusiveMaximum === true) {
                    return ajv_1.str `should be < ${schemaCode}`;
                }
                if (keyword === "minimum" &&
                    parentSchema.exclusiveMinimum === true) {
                    return ajv_1.str `should be > ${schemaCode}`;
                }
                return baseLimitNumbers[cxt.keyword].error.message(cxt);
            },
            params: (cxt) => {
                const { keyword, schemaCode, parentSchema } = cxt;
                if (keyword === "maximum" &&
                    parentSchema.exclusiveMaximum === true) {
                    return ajv_1._ `{comparison: "<", limit: ${schemaCode}}`;
                }
                if (keyword === "minimum" &&
                    parentSchema.exclusiveMinimum === true) {
                    return ajv_1._ `{comparison: ">", limit: ${schemaCode}}`;
                }
                return baseLimitNumbers[cxt.keyword].error.params(cxt);
            },
        },
        code(cxt) {
            const { keyword, data, schemaCode, parentSchema } = cxt;
            if (keyword === "maximum" &&
                parentSchema.exclusiveMaximum === true) {
                cxt.fail$data(ajv_1._ `${data} ${ops.GTE} ${schemaCode} || isNaN(${data})`);
                return;
            }
            if (keyword === "minimum" &&
                parentSchema.exclusiveMinimum === true) {
                cxt.fail$data(ajv_1._ `${data} ${ops.LTE} ${schemaCode} || isNaN(${data})`);
                return;
            }
            baseLimitNumbers[keyword].code(cxt);
        },
    };
    const exclusiveMinMax = {
        keyword: ["exclusiveMaximum", "exclusiveMinimum"],
        type: "number",
        schemaType: ["number", "boolean"],
        $data: true,
        error: {
            message: (cxt) => baseLimitNumbers[cxt.keyword].error.message(cxt),
            params: (cxt) => baseLimitNumbers[cxt.keyword].error.params(cxt),
        },
        code(cxt) {
            const { keyword, schemaValue } = cxt;
            if (typeof schemaValue === "boolean") {
                return;
            }
            baseLimitNumbers[keyword].code(cxt);
        },
    };
    ajv.removeKeyword("maximum");
    ajv.removeKeyword("minimum");
    ajv.removeKeyword("exclusiveMaximum");
    ajv.removeKeyword("exclusiveMinimum");
    ajv.addKeyword(minMax);
    ajv.addKeyword(exclusiveMinMax);
}
exports.applyLimitNumberKeywords = applyLimitNumberKeywords;