lakutata/src/lib/base/internal/DataValidator.cjs

An IoC-based universal application framework.

"use strict";

Object.defineProperty(exports, Symbol.toStringTag, {
    value: "Module"
});

require("../../../../vendor/Package.4.cjs");

const r = require("node:util/types");

const t = require("../../../../vendor/Package.5.cjs");

const e = require("../../validation/VLD.cjs");

const n = require("../../helpers/As.cjs");

const a = require("../../../../vendor/Package.9.cjs");

const i = require("../../helpers/IsHtml.cjs");

const s = require("../../helpers/IsXML.cjs");

require("../../../../vendor/Package.11.cjs");

require("url");

require("../../../../vendor/Package.10.cjs");

require("util");

require("../../../exceptions/dto/InvalidValueException.cjs");

require("../abstracts/Exception.cjs");

require("./BasicInfo.cjs");

require("../../../../vendor/Package.6.cjs");

require("../../../../vendor/Package.7.cjs");

require("./ThrowWarning.cjs");

require("../../helpers/Templating.cjs");

require("./CamelCase.cjs");

require("../../helpers/NoCase.cjs");

var u = {};

"use strict";

var c = t.commonjsGlobal && t.commonjsGlobal.__assign || function() {
    c = Object.assign || function(r) {
        for (var t, e = 1, n = arguments.length; e < n; e++) {
            t = arguments[e];
            for (var a in t) if (Object.prototype.hasOwnProperty.call(t, a)) r[a] = t[a];
        }
        return r;
    };
    return c.apply(this, arguments);
};

Object.defineProperty(u, "__esModule", {
    value: true
});

var o = u.isValidCron = void 0;

var l = function(r) {
    if (/^\d+$/.test(r)) {
        return Number(r);
    } else {
        return NaN;
    }
};

var f = function(r) {
    return r === "*";
};

var d = function(r) {
    return r === "?";
};

var v = function(r, t, e) {
    return r >= t && r <= e;
};

var p = function(r, t, e) {
    var n = r.split("-");
    switch (n.length) {
      case 1:
        return f(r) || v(l(r), t, e);

      case 2:
        var a = n.map((function(r) {
            return l(r);
        })), i = a[0], s = a[1];
        return i <= s && v(i, t, e) && v(s, t, e);

      default:
        return false;
    }
};

var y = function(r) {
    return r === undefined || r.search(/[^\d]/) === -1 && l(r) > 0;
};

var h = function(r, t, e) {
    if (r.search(/[^\d-,\/*]/) !== -1) {
        return false;
    }
    var n = r.split(",");
    return n.every((function(r) {
        var n = r.split("/");
        if (r.trim().endsWith("/")) {
            return false;
        }
        if (n.length > 2) {
            return false;
        }
        var a = n[0], i = n[1];
        return p(a, t, e) && y(i);
    }));
};

var g = function(r) {
    return h(r, 0, 59);
};

var m = function(r) {
    return h(r, 0, 59);
};

var j = function(r) {
    return h(r, 0, 23);
};

var D = function(r, t) {
    return t && d(r) || h(r, 1, 31);
};

var V = {
    jan: "1",
    feb: "2",
    mar: "3",
    apr: "4",
    may: "5",
    jun: "6",
    jul: "7",
    aug: "8",
    sep: "9",
    oct: "10",
    nov: "11",
    dec: "12"
};

var A = function(r, t) {
    if (r.search(/\/[a-zA-Z]/) !== -1) {
        return false;
    }
    if (t) {
        var e = r.toLowerCase().replace(/[a-z]{3}/g, (function(r) {
            return V[r] === undefined ? r : V[r];
        }));
        return h(e, 1, 12);
    }
    return h(r, 1, 12);
};

var b = {
    sun: "0",
    mon: "1",
    tue: "2",
    wed: "3",
    thu: "4",
    fri: "5",
    sat: "6"
};

var q = function(r, t, e, n) {
    if (e && d(r)) {
        return true;
    } else if (!e && d(r)) {
        return false;
    }
    if (r.search(/\/[a-zA-Z]/) !== -1) {
        return false;
    }
    if (t) {
        var a = r.toLowerCase().replace(/[a-z]{3}/g, (function(r) {
            return b[r] === undefined ? r : b[r];
        }));
        return h(a, 0, n ? 7 : 6);
    }
    return h(r, 0, n ? 7 : 6);
};

var L = function(r, t, e) {
    return !(e && d(r) && d(t));
};

var w = function(r) {
    return r.trim().split(/\s+/);
};

var S = {
    alias: false,
    seconds: false,
    allowBlankDay: false,
    allowSevenAsSunday: false
};

o = u.isValidCron = function(r, t) {
    t = c(c({}, S), t);
    var e = w(r);
    if (e.length > (t.seconds ? 6 : 5) || e.length < 5) {
        return false;
    }
    var n = [];
    if (e.length === 6) {
        var a = e.shift();
        if (a) {
            n.push(g(a));
        }
    }
    var i = e[0], s = e[1], u = e[2], o = e[3], l = e[4];
    n.push(m(i));
    n.push(j(s));
    n.push(D(u, t.allowBlankDay));
    n.push(A(o, t.alias));
    n.push(q(l, t.alias, t.allowBlankDay, t.allowSevenAsSunday));
    n.push(L(u, l, t.allowBlankDay));
    return n.every(Boolean);
};

class DataValidator {
    static Any() {
        return e.VLD.any().strict(true);
    }
    static String() {
        return e.VLD.string().strict(true);
    }
    static Number() {
        return e.VLD.number().strict(true);
    }
    static Boolean() {
        return e.VLD.boolean().strict(true);
    }
    static Date() {
        return e.VLD.date().strict(true);
    }
    static Object(r) {
        return e.VLD.object(r).strict(true);
    }
    static Array(...r) {
        return e.VLD.array().items(...r).strict(true);
    }
    static Binary() {
        return e.VLD.binary().strict(true);
    }
    static Function() {
        return e.VLD.func().strict(true);
    }
    static AsyncFunction() {
        return this.Function().custom(((t, e) => {
            if (r.isAsyncFunction(t)) return t;
            return e.error("asyncFunc.invalid");
        }), "Async Function Validation").error((r => {
            for (const t of r) {
                if (t.code === "asyncFunc.invalid") {
                    t.message = "Expected AsyncFunction but got Function";
                    return t;
                }
            }
            return r[0];
        }));
    }
    static Class(r) {
        if (!r) return e.VLD.func().class();
        return this.Function().class().custom(((t, e) => {
            if (!n.As(r).prototype) r = n.As(r)();
            if (t instanceof n.As(r) || t["prototype"] instanceof n.As(r)) return t;
            return e.error("any.invalid");
        }), "Class Validation");
    }
    static InstanceOf(r) {
        return this.Any().custom(((t, e) => {
            if (t instanceof n.As(r) || t["prototype"] instanceof n.As(r)) return t;
            return e.error("any.invalid");
        }), "Class Instance Validation");
    }
    static Glob() {
        return this.String().custom(((r, t) => {
            if (typeof r === "string" && a.IsGlobString(r)) return r;
            return t.error("any.invalid");
        }), "Glob Validation");
    }
    static Cron(r) {
        return this.String().custom(((t, e) => {
            r = r ? r : {};
            r.alias = r.alias !== undefined ? r.alias : false;
            r.seconds = r.seconds !== undefined ? r.seconds : true;
            r.allowBlankDay = r.allowBlankDay !== undefined ? r.allowBlankDay : true;
            r.allowSevenAsSunday = r.allowSevenAsSunday !== undefined ? r.allowSevenAsSunday : true;
            if (typeof t === "string" && o(t, r)) return t;
            return e.error("any.invalid");
        }), "Cron Validation");
    }
    static HttpDocument() {
        return this.String().custom(((r, t) => {
            if (typeof r === "string" && (i.IsHtml(r) || s.IsXML(r))) return r;
            return t.error("any.invalid");
        }), "HttpDocument Validation");
    }
    static Symbol() {
        return e.VLD.symbol().strict(true);
    }
    static Alternatives(...r) {
        return e.VLD.alternatives(...r).strict(true);
    }
    static Ref(r, t) {
        return e.VLD.ref(r, t);
    }
    static In(r, t) {
        return e.VLD.in(r, t);
    }
    static Attempt(r, t, n) {
        return e.VLD.attempt(r, t, n);
    }
}

exports.DataValidator = DataValidator;