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

An IoC-based universal application framework.

import "../../../../vendor/Package.4.mjs";

import { isAsyncFunction as r } from "node:util/types";

import { c as t } from "../../../../vendor/Package.5.mjs";

import { VLD as n } from "../../validation/VLD.mjs";

import { As as e } from "../../helpers/As.mjs";

import { I as a } from "../../../../vendor/Package.9.mjs";

import { IsHtml as i } from "../../helpers/IsHtml.mjs";

import { IsXML as s } from "../../helpers/IsXML.mjs";

import "../../../../vendor/Package.11.mjs";

import "url";

import "../../../../vendor/Package.10.mjs";

import "util";

import "../../../exceptions/dto/InvalidValueException.mjs";

import "../abstracts/Exception.mjs";

import "./BasicInfo.mjs";

import "../../../../vendor/Package.6.mjs";

import "../../../../vendor/Package.7.mjs";

import "./ThrowWarning.mjs";

import "../../helpers/Templating.mjs";

import "./CamelCase.mjs";

import "../../helpers/NoCase.mjs";

var u = {};

"use strict";

var o = t && t.__assign || function() {
    o = Object.assign || function(r) {
        for (var t, n = 1, e = arguments.length; n < e; n++) {
            t = arguments[n];
            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 m = function(r) {
    return r === "?";
};

var p = function(r, t, n) {
    return r >= t && r <= n;
};

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

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

      default:
        return false;
    }
};

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

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

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

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

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

var w = function(r, t) {
    return t && m(r) || y(r, 1, 31);
};

var b = {
    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 n = r.toLowerCase().replace(/[a-z]{3}/g, (function(r) {
            return b[r] === undefined ? r : b[r];
        }));
        return y(n, 1, 12);
    }
    return y(r, 1, 12);
};

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

var k = function(r, t, n, e) {
    if (n && m(r)) {
        return true;
    } else if (!n && m(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 S[r] === undefined ? r : S[r];
        }));
        return y(a, 0, e ? 7 : 6);
    }
    return y(r, 0, e ? 7 : 6);
};

var D = function(r, t, n) {
    return !(n && m(r) && m(t));
};

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

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

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

class DataValidator {
    static Any() {
        return n.any().strict(true);
    }
    static String() {
        return n.string().strict(true);
    }
    static Number() {
        return n.number().strict(true);
    }
    static Boolean() {
        return n.boolean().strict(true);
    }
    static Date() {
        return n.date().strict(true);
    }
    static Object(r) {
        return n.object(r).strict(true);
    }
    static Array(...r) {
        return n.array().items(...r).strict(true);
    }
    static Binary() {
        return n.binary().strict(true);
    }
    static Function() {
        return n.func().strict(true);
    }
    static AsyncFunction() {
        return this.Function().custom(((t, n) => {
            if (r(t)) return t;
            return n.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 n.func().class();
        return this.Function().class().custom(((t, n) => {
            if (!e(r).prototype) r = e(r)();
            if (t instanceof e(r) || t["prototype"] instanceof e(r)) return t;
            return n.error("any.invalid");
        }), "Class Validation");
    }
    static InstanceOf(r) {
        return this.Any().custom(((t, n) => {
            if (t instanceof e(r) || t["prototype"] instanceof e(r)) return t;
            return n.error("any.invalid");
        }), "Class Instance Validation");
    }
    static Glob() {
        return this.String().custom(((r, t) => {
            if (typeof r === "string" && a(r)) return r;
            return t.error("any.invalid");
        }), "Glob Validation");
    }
    static Cron(r) {
        return this.String().custom(((t, n) => {
            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 n.error("any.invalid");
        }), "Cron Validation");
    }
    static HttpDocument() {
        return this.String().custom(((r, t) => {
            if (typeof r === "string" && (i(r) || s(r))) return r;
            return t.error("any.invalid");
        }), "HttpDocument Validation");
    }
    static Symbol() {
        return n.symbol().strict(true);
    }
    static Alternatives(...r) {
        return n.alternatives(...r).strict(true);
    }
    static Ref(r, t) {
        return n.ref(r, t);
    }
    static In(r, t) {
        return n.in(r, t);
    }
    static Attempt(r, t, e) {
        return n.attempt(r, t, e);
    }
}

export { DataValidator };