@blinkk/selective-edit/dist/selective/validation.js

Selective structured text editor.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValidationResult = exports.Validation = exports.ValidationLevel = exports.DEFAULT_ZONE_KEY = void 0;
const mixins_1 = require("../mixins");
const uuid_1 = require("../mixins/uuid");
exports.DEFAULT_ZONE_KEY = 'default';
var ValidationLevel;
(function (ValidationLevel) {
    ValidationLevel["Info"] = "info";
    ValidationLevel["Warning"] = "warning";
    ValidationLevel["Error"] = "error";
})(ValidationLevel = exports.ValidationLevel || (exports.ValidationLevel = {}));
class Validation {
    constructor(rules) {
        this.rules = rules;
        this.zoneToResults = {};
    }
    addResult(result, zoneKey) {
        const resultsForZone = this.getResults(zoneKey);
        resultsForZone.push(result);
    }
    filterResults(level, zoneKey) {
        const resultsForZone = this.getResults(zoneKey);
        const filterFunc = (result) => {
            return result.level === level;
        };
        return resultsForZone.filter(filterFunc);
    }
    /**
     * Checks each of the rules to see if the field is required.
     */
    isRequired(zoneKey) {
        for (const rule of this.rules.getRulesForZone(zoneKey)) {
            if (rule.isRequired) {
                return true;
            }
        }
        return false;
    }
    getResults(zoneKey, maxLevel) {
        zoneKey = zoneKey || exports.DEFAULT_ZONE_KEY;
        if (!this.zoneToResults[zoneKey]) {
            this.zoneToResults[zoneKey] = [];
        }
        // Filter down the results if retrieving by level.
        if (maxLevel) {
            const filterFunc = (result) => {
                if (maxLevel === ValidationLevel.Info) {
                    return result.level === ValidationLevel.Info;
                }
                if (maxLevel === ValidationLevel.Warning) {
                    return (result.level === ValidationLevel.Info ||
                        result.level === ValidationLevel.Warning);
                }
                // Max error level matches all levels.
                return true;
            };
            return this.zoneToResults[zoneKey].filter(filterFunc);
        }
        return this.zoneToResults[zoneKey];
    }
    hasAnyResults(zoneKey, maxLevel) {
        // Check across all zones for results.
        if (zoneKey === null) {
            for (const zoneKey of this.zones) {
                if (this.hasAnyResults(zoneKey, maxLevel)) {
                    return true;
                }
            }
            return false;
        }
        // Check against specific zone for any matching results.
        return this.getResults(zoneKey, maxLevel).length > 0;
    }
    validate(value, zoneKey) {
        let hasErrors = false;
        for (const rule of this.rules.getRulesForZone(zoneKey)) {
            const result = rule.validate(value);
            if (result) {
                this.addResult(new ValidationResult(result, rule.level), zoneKey);
                hasErrors = true;
            }
        }
        return hasErrors;
    }
    get zones() {
        return Object.keys(this.zoneToResults);
    }
}
exports.Validation = Validation;
class ValidationResult extends (0, uuid_1.UuidMixin)(mixins_1.Base) {
    constructor(message, level = ValidationLevel.Error) {
        super();
        this.message = message;
        this.level = level;
    }
}
exports.ValidationResult = ValidationResult;
//# sourceMappingURL=validation.js.map