datatypes-validation/dist/lib/data/Rules/SingleRulesFunctions/isDate.js

     

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const dateformat_1 = __importDefault(require("dateformat"));
const DateRules_1 = require("../types/DateRules");
const isDateCallback = (options = {}) => {
    const { longMessage, shortMessage, format, mask, withTime } = options;
    const getMask = () => {
        if (!mask) {
            throw new Error('The method isDateCallback needs a mask (it is currently undefined)');
        }
        const maskValue = (withTime) ? `${mask}-WITH-TIME` : mask;
        switch (maskValue) {
            case "BR":
                return /^([\d]{2})\/([\d]{2})\/([\d]{4})$/;
            case "BR-WITH-TIME":
                return /^([\d]{2})\/([\d]{2})\/([\d]{4})\s([\d]{2}):([\d]{2}|[\d]{2}\:[\d]{2})$/;
            case "EN":
                return /^([\d]{4})-([\d]{2})-([\d]{2})$/;
            case "EN-WITH-TIME":
                return /^([\d]{4})-([\d]{2})-([\d]{2})\s([\d]{2}):([\d]{2}|[\d]{2}\:[\d]{2})$/;
        }
    };
    const getValidDate = (year, month, day, hour, minute, seconds) => {
        const withSeconds = (seconds) ? `:${seconds}` : ``;
        const time = (hour && minute) ? `${hour}:${minute}${withSeconds}` : ``;
        const date = new Date(`${year}-${month}-${day} ${time}`);
        return (date.toString() === "Invalid Date") ? false : date;
    };
    const testAndGetValidDate = (value) => {
        const [dateString, timeString] = (value).split(' ');
        let dateArgs = [];
        if (mask === "BR") {
            dateArgs = dateString.split('/').reverse();
        }
        else {
            dateArgs = dateString.split('-');
        }
        const timeArgs = timeString ? timeString.split(':') : [];
        const [year, month, day] = dateArgs;
        const [hour, minute, seconds] = timeArgs;
        return getValidDate(year, month, day, hour, minute, seconds);
    };
    const getFormatForContextMessage = () => {
        if (mask === "BR" && withTime) {
            return "xx/xx/xxxx xx:xx";
        }
        else if (mask === "BR") {
            return "xx/xx/xxxx";
        }
        else if (mask === "EN" && withTime) {
            return "xxxx-xx-xx xx:xx";
        }
        else if (mask === "EN") {
            return "xxxx-xx-xx";
        }
        else {
            throw new Error('getFormatForContextMessage needs a make to continue...');
        }
    };
    return (field) => __awaiter(this, void 0, void 0, function* () {
        const isNull = field.value === undefined || field.value === null;
        if (!isNull) {
            if (!new RegExp(getMask()).test(field.value)) {
                const context = { format: getFormatForContextMessage() };
                field.applyError('dateFormat', { longMessage, shortMessage, context });
            }
            else {
                const date = testAndGetValidDate(field.value);
                if (!date) {
                    field.applyError('date', { longMessage, shortMessage });
                }
                else {
                    field.shadowValue = date;
                    field.value = dateformat_1.default(date, format);
                }
            }
        }
    });
};
function isDate(options = {}) {
    const { longMessage, shortMessage, withTime } = options;
    const mask = (options.mask || ((!withTime) ? DateRules_1.DateRules.settingsDefault.date.mask : DateRules_1.DateRules.settingsDefault.datetime.mask));
    const format = options.format || ((!withTime) ? DateRules_1.DateRules.settingsDefault.date.format : DateRules_1.DateRules.settingsDefault.datetime.format);
    return isDateCallback({
        longMessage,
        shortMessage,
        withTime,
        mask,
        format
    });
}
exports.isDate = isDate;
//# sourceMappingURL=isDate.js.map