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

An IoC-based universal application framework.

/* Build Date: Mon Jan 05 2026 23:52:23 GMT+0800 (China Standard Time) */
"use strict";

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

require("../../../../vendor/Package.internal.1.cjs");

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

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

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

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

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

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

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

require("url");

require("util");

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

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

require("../../../../vendor/Package.internal.5.cjs");

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

require("./ThrowWarning.cjs");

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

require("./CamelCase.cjs");

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

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

var u = {};

var o = t.commonjsGlobal && t.commonjsGlobal.__assign || function() {
    o = 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 o.apply(this, arguments);
};

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

var c = 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 D = function(r) {
    return h(r, 0, 23);
};

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

var j = {
    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 b = 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 j[r] === undefined ? r : j[r];
        });
        return h(e, 1, 12);
    }
    return h(r, 1, 12);
};

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

var L = function(r, t) {
    var e = t.allowBlankDay, n = t.alias, a = t.allowSevenAsSunday, i = t.allowNthWeekdayOfMonth;
    if (e && d(r)) {
        return true;
    } else if (!e && d(r)) {
        return false;
    }
    if (r.search(/\/[a-zA-Z]/) !== -1) {
        return false;
    }
    var s = n ? r.toLowerCase().replace(/[a-z]{3}/g, function(r) {
        return A[r] === undefined ? r : A[r];
    }) : r;
    var u = a ? 7 : 6;
    var o = s.split("#");
    if (i && o.length >= 2) {
        var c = o[0], f = o[1], p = o.slice(2);
        if (p.length !== 0) {
            return false;
        }
        return v(l(f), 1, 5) && v(l(c), 0, u);
    }
    return h(s, 0, u);
};

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

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

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

c = u.isValidCron = function(r, t) {
    var e = o(o({}, S), t);
    var n = q(r);
    if (n.length > (e.seconds ? 6 : 5) || n.length < 5) {
        return false;
    }
    var a = [];
    if (n.length === 6) {
        var i = n.shift();
        if (i) {
            a.push(g(i));
        }
    }
    var s = n[0], u = n[1], c = n[2], l = n[3], f = n[4];
    a.push(m(s));
    a.push(D(u));
    a.push(V(c, e.allowBlankDay));
    a.push(b(l, e.alias));
    a.push(L(f, e));
    a.push(w(c, f, e.allowBlankDay));
    return a.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 BigInt() {
        return e.VLD.bigint().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" && c(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);
    }
    static Link(r) {
        return e.VLD.link(r);
    }
}

exports.DataValidator = DataValidator;