vality-core 1.0.0

package/dist/valueObjects/CpfCnpj.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const Cnpj_1 = __importDefault(require("./Cnpj"));
+const Cpf_1 = __importDefault(require("./Cpf"));
+class CpfCnpj {
+    constructor(nome) {
+        this._ehValido = true;
+        nome = CpfCnpj.formatar(nome);
+        this.validar(nome);
+        this._valor = nome;
+    }
+    set valor(v) {
+        v = CpfCnpj.formatar(v);
+        this.validar(v);
+        this._valor = v;
+    }
+    get valor() {
+        return this._valor;
+    }
+    get ehValido() {
+        return this._ehValido;
+    }
+    valueOf() {
+        return CpfCnpj.sanitizar(this._valor);
+    }
+    get tipo() {
+        const valorSanitizado = CpfCnpj.sanitizar(this._valor);
+        if (valorSanitizado.length === 11) {
+            return "CPF";
+        }
+        else if (valorSanitizado.length === 14) {
+            return "CNPJ";
+        }
+        else {
+            return null;
+        }
+    }
+    static sanitizar(valor) {
+        return valor.replace(/[^0-9]/g, "");
+    }
+    static formatarCpf(valor) {
+        let valorFormatado = valor;
+        if (valor.length > 3) {
+            valorFormatado =
+                valorFormatado.slice(0, 3) + "." + valorFormatado.slice(3);
+        }
+        if (valor.length > 6) {
+            valorFormatado =
+                valorFormatado.slice(0, 7) + "." + valorFormatado.slice(7);
+        }
+        if (valor.length > 9) {
+            valorFormatado =
+                valorFormatado.slice(0, 11) + "-" + valorFormatado.slice(11);
+        }
+        return valorFormatado.slice(0, 14);
+    }
+    static formatarCnpj(valor) {
+        let valorFormatado = valor;
+        if (valor.length > 2) {
+            valorFormatado = valor.slice(0, 2) + "." + valor.slice(2);
+        }
+        if (valor.length > 5) {
+            valorFormatado =
+                valorFormatado.slice(0, 6) + "." + valorFormatado.slice(6);
+        }
+        if (valor.length > 8) {
+            valorFormatado =
+                valorFormatado.slice(0, 10) + "/" + valorFormatado.slice(10);
+        }
+        if (valor.length > 12) {
+            valorFormatado =
+                valorFormatado.slice(0, 15) + "-" + valorFormatado.slice(15);
+        }
+        return valorFormatado.slice(0, 18);
+    }
+    static formatar(valor) {
+        const valorSanitizado = this.sanitizar(valor);
+        let valorFormatado = valorSanitizado;
+        if (valorSanitizado.length <= 11) {
+            valorFormatado = this.formatarCpf(valorSanitizado);
+        }
+        else {
+            valorFormatado = this.formatarCnpj(valorSanitizado);
+        }
+        return valorFormatado;
+    }
+    validar(valor) {
+        if ((0, utils_1.isEmpty)(valor)) {
+            this._ehValido = true;
+            return;
+        }
+        const cleanedValue = valor.replace(/\D/g, "");
+        if (cleanedValue.length === 11) {
+            const cpf = new Cpf_1.default(valor);
+            this._ehValido = cpf.ehValido;
+            return;
+        }
+        else if (cleanedValue.length > 11 && cleanedValue.length <= 14) {
+            const cnpj = new Cnpj_1.default(valor);
+            this._ehValido = cnpj.ehValido;
+            return;
+        }
+        else {
+            this._ehValido = "Insira um CPF ou CNPJ válido";
+        }
+    }
+}
+exports.default = CpfCnpj;

package/dist/valueObjects/DatePicker/DatePicker.d.ts

@@ -0,0 +1,28 @@
+import { IDatePicker } from "../../types";
+import { DatePickerOptions } from "./types";
+/** Data mínima padrão para o sistema (1900-01-01) */
+export declare const DATA_MINIMA_SISTEMA: Date;
+export default class DatePicker implements IDatePicker {
+    private _valor;
+    private _ehValido;
+    private _locale;
+    private _options;
+    private _formatar;
+    private _validar;
+    private _valueOf;
+    private _toISOString;
+    private _dateFormat;
+    constructor(data?: string, locale?: string, options?: DatePickerOptions);
+    get valor(): string;
+    set valor(v: string);
+    get ehValido(): string | true;
+    get locale(): string;
+    get options(): DatePickerOptions;
+    set options(o: DatePickerOptions);
+    get dateFormat(): string;
+    formatar(valor: string): string;
+    valueOf(): number;
+    toISOString(): string;
+    validar(valor: string): void;
+}
+//# sourceMappingURL=DatePicker.d.ts.map

package/dist/valueObjects/DatePicker/DatePicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatePicker.d.ts","sourceRoot":"","sources":["../../../src/valueObjects/DatePicker/DatePicker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAQ1C,OAAO,EACL,iBAAiB,EAKlB,MAAM,SAAS,CAAC;AAEjB,qDAAqD;AACrD,eAAO,MAAM,mBAAmB,MAAuB,CAAC;AAExD,MAAM,CAAC,OAAO,OAAO,UAAW,YAAW,WAAW;IACpD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,QAAQ,CAAoB;IACpC,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,QAAQ,CAAmB;IACnC,OAAO,CAAC,QAAQ,CAAkB;IAClC,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,WAAW,CAAmB;gBAGpC,IAAI,GAAE,MAAW,EACjB,MAAM,GAAE,MAAgB,EACxB,OAAO,GAAE,iBAER;IA2BH,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,KAAK,CAAC,CAAC,EAAE,MAAM,EAIlB;IAED,IAAI,QAAQ,kBAEX;IAED,IAAI,MAAM,WAET;IAED,IAAI,OAAO,IAII,iBAAiB,CAF/B;IAED,IAAI,OAAO,CAAC,CAAC,EAAE,iBAAiB,EAE/B;IAED,IAAI,UAAU,WAEb;IAEM,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAU/B,OAAO;IASP,WAAW;IAQX,OAAO,CAAC,KAAK,EAAE,MAAM;CAS7B"}

package/dist/valueObjects/DatePicker/DatePicker.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATA_MINIMA_SISTEMA = void 0;
+const pt_br_1 = require("./locales/pt-br");
+/** Data mínima padrão para o sistema (1900-01-01) */
+exports.DATA_MINIMA_SISTEMA = new Date(1900, 0, 1);
+class DatePicker {
+    constructor(data = "", locale = "pt-br", options = {
+        type: "date",
+    }) {
+        this._ehValido = true;
+        this._locale = "pt-br";
+        this._dateFormat = "d/M/Y";
+        const defaultOptions = {
+            type: "date",
+            separator: " às ",
+            maxDateLimit: new Date(),
+            minDateLimit: exports.DATA_MINIMA_SISTEMA,
+        };
+        this._locale = locale;
+        this._options = { ...defaultOptions, ...options };
+        // Quando houver mais de uma localidade, adicionar um switch case aqui
+        this._formatar = pt_br_1.formatarPtBr;
+        this._validar = pt_br_1.validarPtBr;
+        this._valueOf = pt_br_1.valueOfPtBr;
+        this._toISOString = pt_br_1.toISOStringPtBr;
+        this._dateFormat = (0, pt_br_1.dateFormatPtBr)(this._options.type, this._options.separator || " ");
+        data = this.formatar(data);
+        this.validar(data);
+        this._valor = data;
+    }
+    get valor() {
+        return this._valor;
+    }
+    set valor(v) {
+        v = this.formatar(v || "");
+        this.validar(v);
+        this._valor = v;
+    }
+    get ehValido() {
+        return this._ehValido;
+    }
+    get locale() {
+        return this._locale;
+    }
+    get options() {
+        return this._options;
+    }
+    set options(o) {
+        this._options = o;
+    }
+    get dateFormat() {
+        return this._dateFormat;
+    }
+    formatar(valor) {
+        return this._formatar(valor, this.options.type, {
+            separator: this.options.separator || " ",
+            minDate: this.options.minDateLimit,
+            maxDate: this.options.maxDateLimit,
+            minTime: this.options.minTimeLimit,
+            maxTime: this.options.maxTimeLimit,
+        });
+    }
+    valueOf() {
+        return this._valueOf(this.valor, this.options.type, this.options.separator || " ", this.ehValido);
+    }
+    toISOString() {
+        return this._toISOString(this.valor, this.options.type, this.options.separator || " ");
+    }
+    validar(valor) {
+        this._ehValido = this._validar(valor, this.options.type, {
+            separator: this.options.separator || " ",
+            minDate: this.options.minDate,
+            maxDate: this.options.maxDate,
+            minTime: this.options.minTime,
+            maxTime: this.options.maxTime,
+        });
+    }
+}
+exports.default = DatePicker;

package/dist/valueObjects/DatePicker/locales/pt-br.d.ts

@@ -0,0 +1,8 @@
+import { FormatFunction, ValidateFunction, ValueOfFunction } from "../types";
+declare const formatarPtBr: FormatFunction;
+declare const validarPtBr: ValidateFunction;
+declare const valueOfPtBr: ValueOfFunction;
+declare const dateFormatPtBr: (type: "date" | "datetime" | "time", separator: string) => string;
+declare const toISOStringPtBr: (valor: string, type: "date" | "datetime" | "time", separator: string) => string;
+export { dateFormatPtBr, formatarPtBr, toISOStringPtBr, validarPtBr, valueOfPtBr };
+//# sourceMappingURL=pt-br.d.ts.map

package/dist/valueObjects/DatePicker/locales/pt-br.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pt-br.d.ts","sourceRoot":"","sources":["../../../../src/valueObjects/DatePicker/locales/pt-br.ts"],"names":[],"mappings":"AACA,OAAO,EACL,cAAc,EAEd,gBAAgB,EAChB,eAAe,EAChB,MAAM,UAAU,CAAC;AAsMlB,QAAA,MAAM,YAAY,EAAE,cAsBnB,CAAC;AAEF,QAAA,MAAM,WAAW,EAAE,gBAoGlB,CAAC;AAEF,QAAA,MAAM,WAAW,EAAE,eAuBlB,CAAC;AAEF,QAAA,MAAM,cAAc,GAClB,MAAM,MAAM,GAAG,UAAU,GAAG,MAAM,EAClC,WAAW,MAAM,KAChB,MASF,CAAC;AAEF,QAAA,MAAM,eAAe,GACnB,OAAO,MAAM,EACb,MAAM,MAAM,GAAG,UAAU,GAAG,MAAM,EAClC,WAAW,MAAM,KAChB,MAmBF,CAAC;AAEF,OAAO,EACL,cAAc,EACd,YAAY,EACZ,eAAe,EACf,WAAW,EACX,WAAW,EACZ,CAAC"}

package/dist/valueObjects/DatePicker/locales/pt-br.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.valueOfPtBr = exports.validarPtBr = exports.toISOStringPtBr = exports.formatarPtBr = exports.dateFormatPtBr = void 0;
+const utils_1 = require("../../../utils");
+const validarDataMinMax = (v, minDate, maxDate) => {
+    let valor = `${v.slice(0, 2)}/${v.slice(2, 4)}/${v.slice(4, 8)}`;
+    if (minDate) {
+        const [dia, mes, ano] = valor.split("/");
+        const data = new Date(`${ano}-${mes}-${dia}`);
+        if (data < minDate) {
+            const min = minDate;
+            const dia = min.getDate().toString().padStart(2, "0");
+            const mes = (min.getMonth() + 1).toString().padStart(2, "0");
+            const ano = min.getFullYear();
+            valor = `${dia}/${mes}/${ano}`;
+            return "menor";
+        }
+    }
+    if (maxDate) {
+        const [dia, mes, ano] = valor.split("/");
+        const data = new Date(`${ano}-${mes}-${dia}`);
+        if (data > maxDate) {
+            const max = maxDate;
+            const dia = max.getDate().toString().padStart(2, "0");
+            const mes = (max.getMonth() + 1).toString().padStart(2, "0");
+            const ano = max.getFullYear();
+            valor = `${dia}/${mes}/${ano}`;
+            return "maior";
+        }
+    }
+    return true;
+};
+const formatarData = (valueSanatizado, minDate, maxDate) => {
+    let dataFormatada = valueSanatizado;
+    const getDia = (dia) => {
+        if (Number(dia) > 31)
+            return "31";
+        if (Number(dia) === 0)
+            return "01";
+        return dia;
+    };
+    const getMes = (mes) => {
+        if (Number(mes) > 12)
+            return "12";
+        if (Number(mes) === 0)
+            return "01";
+        return mes;
+    };
+    if (valueSanatizado.length > 4) {
+        const dia = getDia(valueSanatizado.slice(0, 2));
+        const mes = getMes(valueSanatizado.slice(2, 4));
+        const ano = valueSanatizado.slice(4, 8);
+        dataFormatada = `${dia}/${mes}/${ano}`;
+        if (valueSanatizado.length == 8) {
+            const valido = validarDataMinMax(valueSanatizado, minDate, maxDate);
+            if (minDate && valido == "menor") {
+                const min = minDate;
+                const dia = min.getDate().toString().padStart(2, "0");
+                const mes = (min.getMonth() + 1).toString().padStart(2, "0");
+                const ano = min.getFullYear();
+                dataFormatada = `${dia}/${mes}/${ano}`;
+            }
+            else if (maxDate && valido == "maior") {
+                const max = maxDate;
+                const dia = max.getDate().toString().padStart(2, "0");
+                const mes = (max.getMonth() + 1).toString().padStart(2, "0");
+                const ano = max.getFullYear();
+                dataFormatada = `${dia}/${mes}/${ano}`;
+            }
+        }
+    }
+    else if (valueSanatizado.length > 2) {
+        const dia = getDia(valueSanatizado.slice(0, 2));
+        const mes = valueSanatizado.slice(2);
+        dataFormatada = `${dia}/${mes}`;
+    }
+    return dataFormatada;
+};
+const validarTimeMinMax = (valueSanatizado, minTime, maxTime) => {
+    if (minTime) {
+        const { hour, minute } = minTime;
+        const time = Number(hour.toFixed(0).padStart(2, "0") + "" + minute.toFixed(0).padStart(2, "0"));
+        if (Number(valueSanatizado) <= time) {
+            return "menor";
+        }
+    }
+    if (maxTime) {
+        const { hour, minute } = maxTime;
+        const time = Number(hour.toFixed(0).padStart(2, "0") + "" + minute.toFixed(0).padStart(2, "0"));
+        if (Number(valueSanatizado) >= time) {
+            return "maior";
+        }
+    }
+    return true;
+};
+const formatarTime = (valueSanatizado, minTime, maxTime) => {
+    let timeFormatado = valueSanatizado;
+    const getHora = (hora) => {
+        const max = 23;
+        const min = 0;
+        if (Number(hora) > max)
+            return "" + max.toFixed(0).padStart(2, "0");
+        if (Number(hora) === min)
+            return "" + min.toFixed(0).padStart(2, "0");
+        return hora;
+    };
+    const getMinuto = (minuto) => {
+        const max = 59;
+        const min = 0;
+        if (Number(minuto) > max)
+            return "" + max.toFixed(0).padStart(2, "0");
+        if (Number(minuto) === min)
+            return "" + min.toFixed(0).padStart(2, "0");
+        return minuto;
+    };
+    if (valueSanatizado.length >= 4) {
+        const hour = getHora(valueSanatizado.slice(0, 2));
+        const minute = getMinuto(valueSanatizado.slice(2, 4));
+        timeFormatado = `${hour}:${minute}`;
+        const validar = validarTimeMinMax(valueSanatizado, minTime, maxTime);
+        if (minTime && validar == "menor") {
+            const { hour, minute } = minTime;
+            const hourFormat = hour.toFixed(0).padStart(2, "0");
+            const minuteFormat = minute.toFixed(0).padStart(2, "0");
+            timeFormatado = `${hourFormat}:${minuteFormat}`;
+        }
+        if (maxTime && validar == "maior") {
+            const { hour, minute } = maxTime;
+            const hourFormat = hour.toFixed(0).padStart(2, "0");
+            const minuteFormat = minute.toFixed(0).padStart(2, "0");
+            timeFormatado = `${hourFormat}:${minuteFormat}`;
+        }
+    }
+    else if (valueSanatizado.length > 2) {
+        const hour = getHora(valueSanatizado.slice(0, 2));
+        const minute = valueSanatizado.slice(2, 4);
+        timeFormatado = `${hour}:${minute}`;
+    }
+    else if (valueSanatizado.length > 1) {
+        timeFormatado = getHora(valueSanatizado.slice(0, 2));
+    }
+    return timeFormatado;
+};
+const formatarDateTime = (valueSanatizado, separator, minDate, maxDate) => {
+    let dateTimeFormatado = formatarData(valueSanatizado, minDate, maxDate);
+    if (valueSanatizado.length > 8) {
+        dateTimeFormatado =
+            formatarData(valueSanatizado, minDate, maxDate) +
+                separator +
+                formatarTime(valueSanatizado.slice(8));
+    }
+    return dateTimeFormatado;
+};
+const formatarPtBr = (valor, type, options = {
+    separator: " às ",
+}) => {
+    const dataSanitizada = valor.replace(/[^0-9]/g, "");
+    switch (type) {
+        case "date":
+            return formatarData(dataSanitizada, options.minDate, options.maxDate);
+        case "time":
+            return formatarTime(dataSanitizada, options.minTime, options.maxTime);
+        case "datetime":
+            return formatarDateTime(dataSanitizada, options.separator || " ", options.minDate, options.maxDate);
+    }
+};
+exports.formatarPtBr = formatarPtBr;
+const validarPtBr = (valor, type, options) => {
+    if ((0, utils_1.isEmpty)(valor)) {
+        return true;
+    }
+    switch (type) {
+        case "date":
+            const reg = new RegExp(/^\d{2}\/\d{2}\/\d{4}$/);
+            if (!reg.test(valor)) {
+                return "Data inválida";
+            }
+            else {
+                const dataSanitizada = valor.replace(/[^0-9]/g, "");
+                const valido = validarDataMinMax(dataSanitizada, options.minDate?.valor, options.maxDate?.valor);
+                if (options.minDate && valido == "menor") {
+                    return `Deve ser superior à ${options.minDate.campo
+                        ? options.minDate.campo
+                        : (0, utils_1.formatDate)(options.minDate.valor)}`;
+                }
+                else if (options.maxDate && valido == "maior") {
+                    return `Deve ser inferior à ${options.maxDate.campo
+                        ? options.maxDate.campo
+                        : (0, utils_1.formatDate)(options.maxDate.valor)}`;
+                }
+            }
+            return true;
+        case "time":
+            const regTime = new RegExp(/^\d{2}:\d{2}(:\d{2})?$/);
+            if (!regTime.test(valor)) {
+                return "Hora inválida";
+            }
+            else {
+                const timeSanatizado = valor.replace(/[^0-9]/g, "");
+                const valido = validarTimeMinMax(timeSanatizado, options.minTime, options.maxTime);
+                if (options.minTime && valido == "menor") {
+                    return `Hora mínima ${options.minTime.hour
+                        .toFixed(0)
+                        .padStart(2, "0")}:${options.minTime.minute
+                        .toFixed(0)
+                        .padStart(2, "0")}`;
+                }
+                else if (options.maxTime && valido == "maior") {
+                    return `Hora máxima ${options.maxTime.hour
+                        .toFixed(0)
+                        .padStart(2, "0")}:${options.maxTime.minute
+                        .toFixed(0)
+                        .padStart(2, "0")}`;
+                }
+            }
+            return true;
+        case "datetime":
+            const regDateTime = new RegExp(`^\\d{2}\\/\\d{2}\\/\\d{4}${options.separator || " "}\\d{2}:\\d{2}(:\\d{2})?$`);
+            if (!regDateTime.test(valor)) {
+                return "Data e hora inválida";
+            }
+            else {
+                let dataSanitizada = valor.split(options.separator || " ")[0];
+                dataSanitizada = dataSanitizada.replace(/[^0-9]/g, "");
+                const valido = validarDataMinMax(dataSanitizada, options.minDate?.valor, options.maxDate?.valor);
+                if (options.minDate && valido == "menor") {
+                    return `Deve ser superior à ${options.minDate.campo
+                        ? options.minDate.campo
+                        : (0, utils_1.formatDate)(options.minDate.valor)}`;
+                }
+                else if (options.maxDate && valido == "maior") {
+                    return `Deve ser inferior à ${options.maxDate.campo
+                        ? options.maxDate.campo
+                        : (0, utils_1.formatDate)(options.maxDate.valor)}`;
+                }
+            }
+            return true;
+    }
+};
+exports.validarPtBr = validarPtBr;
+const valueOfPtBr = (valor, type, separator, ehValido) => {
+    if (ehValido !== true)
+        return NaN;
+    switch (type) {
+        case "date":
+            const [dia, mes, ano] = valor.split("/");
+            return new Date(`${ano}-${mes}-${dia}T00:00:00`).valueOf();
+        case "time":
+            const [horas, minutos] = valor.split(":").map((item) => Number(item));
+            return horas * 3600 + minutos * 60;
+        case "datetime":
+            const [data, hora] = valor.split(separator);
+            const [d, m, Y] = data.split("/");
+            return new Date(`${Y}-${m}-${d}T${hora}`).valueOf();
+    }
+};
+exports.valueOfPtBr = valueOfPtBr;
+const dateFormatPtBr = (type, separator) => {
+    switch (type) {
+        case "date":
+            return "d/m/Y";
+        case "time":
+            return "H:i";
+        case "datetime":
+            return `d/m/Y${separator}H:i`;
+    }
+};
+exports.dateFormatPtBr = dateFormatPtBr;
+const toISOStringPtBr = (valor, type, separator) => {
+    try {
+        switch (type) {
+            case "time":
+                const [h, i] = valor.split(":");
+                return `${h}:${i}:00Z`;
+            case "datetime":
+                const [data, hora] = valor.split(separator);
+                const [d, m, Y] = data.split("/");
+                return new Date(`${Y}-${m}-${d}T${hora}`).toISOString();
+            default:
+                const [dia, mes, ano] = valor.split("/");
+                return new Date(`${ano}-${mes}-${dia}T00:00:00`).toISOString();
+        }
+    }
+    catch (e) {
+        throw new Error("Data inválida");
+    }
+};
+exports.toISOStringPtBr = toISOStringPtBr;

package/dist/valueObjects/DatePicker/types.d.ts

@@ -0,0 +1,53 @@
+export interface DatePickerOptions {
+    type: "date" | "datetime" | "time";
+    separator?: string;
+    minDate?: {
+        valor: Date;
+        campo?: string;
+    };
+    minDateLimit?: Date;
+    maxDate?: {
+        valor: Date;
+        campo?: string;
+    };
+    maxDateLimit?: Date;
+    minTime?: TimeLimiter;
+    minTimeLimit?: TimeLimiter;
+    maxTime?: TimeLimiter;
+    maxTimeLimit?: TimeLimiter;
+}
+export type TimeLimiter = {
+    hour: number;
+    minute: number;
+};
+export type FormatFunction = (valor: string, type: "date" | "datetime" | "time", options: {
+    minDate?: Date;
+    maxDate?: Date;
+    minTime?: TimeLimiter;
+    maxTime?: TimeLimiter;
+    separator?: string;
+}) => string;
+export type ValidateFunction = (valor: string, type: "date" | "datetime" | "time", options: {
+    separator: string;
+    minDate?: {
+        valor: Date;
+        campo?: string;
+    };
+    maxDate?: {
+        valor: Date;
+        campo?: string;
+    };
+    minTime?: {
+        hour: number;
+        minute: number;
+        campo?: string;
+    };
+    maxTime?: {
+        hour: number;
+        minute: number;
+        campo?: string;
+    };
+}) => true | string;
+export type ValueOfFunction = (valor: string, type: "date" | "datetime" | "time", separator: string, ehValido: true | string) => number;
+export type ToISOStringFunction = (valor: string, type: "date" | "datetime" | "time", separator: string) => string;
+//# sourceMappingURL=types.d.ts.map

package/dist/valueObjects/DatePicker/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/valueObjects/DatePicker/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE;QACR,KAAK,EAAE,IAAI,CAAC;QACZ,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB,OAAO,CAAC,EAAE;QACR,KAAK,EAAE,IAAI,CAAC;QACZ,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,YAAY,CAAC,EAAE,WAAW,CAAC;CAC5B;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,CAC3B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,EAClC,OAAO,EAAE;IACP,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,KACE,MAAM,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GAAG,CAC7B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,EAClC,OAAO,EAAE;IACP,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE;QACR,KAAK,EAAE,IAAI,CAAC;QACZ,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,OAAO,CAAC,EAAE;QACR,KAAK,EAAE,IAAI,CAAC;QACZ,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,OAAO,CAAC,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,OAAO,CAAC,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;CACH,KACE,IAAI,GAAG,MAAM,CAAC;AAEnB,MAAM,MAAM,eAAe,GAAG,CAC5B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,EAClC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,IAAI,GAAG,MAAM,KACpB,MAAM,CAAC;AAEZ,MAAM,MAAM,mBAAmB,GAAG,CAChC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,EAClC,SAAS,EAAE,MAAM,KACd,MAAM,CAAC"}

package/dist/valueObjects/DatePicker/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/valueObjects/Email.d.ts

@@ -0,0 +1,13 @@
+import { IEmail } from "../types";
+export default class Email implements IEmail {
+    private _valor;
+    private _ehValido;
+    constructor(nome: string);
+    set valor(v: string);
+    get valor(): string;
+    get ehValido(): string | true;
+    valueOf(): string;
+    sanitizar(valor: string): string;
+    validar(valor: string): void;
+}
+//# sourceMappingURL=Email.d.ts.map

package/dist/valueObjects/Email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Email.d.ts","sourceRoot":"","sources":["../../src/valueObjects/Email.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC,MAAM,CAAC,OAAO,OAAO,KAAM,YAAW,MAAM;IAC1C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAuB;gBAE5B,IAAI,EAAE,MAAM;IASxB,IAAI,KAAK,CAAC,CAAC,EAAE,MAAM,EAKlB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,QAAQ,kBAEX;IAED,OAAO,IAAI,MAAM;IAIV,SAAS,CAAC,KAAK,EAAE,MAAM;IAQvB,OAAO,CAAC,KAAK,EAAE,MAAM;CAe7B"}

package/dist/valueObjects/Email.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+class Email {
+    constructor(nome) {
+        this._ehValido = true;
+        this.validar(nome);
+        let valorSanitizado = this.sanitizar(nome);
+        this.validar(valorSanitizado);
+        this._valor = nome;
+        this._valor = valorSanitizado;
+    }
+    set valor(v) {
+        let valorSanitizado = this.sanitizar(v);
+        this.validar(valorSanitizado);
+        this._valor = valorSanitizado;
+    }
+    get valor() {
+        return this._valor;
+    }
+    get ehValido() {
+        return this._ehValido;
+    }
+    valueOf() {
+        return this._valor;
+    }
+    sanitizar(valor) {
+        let sanitizado = valor.replace(/\s+/g, "");
+        sanitizado = sanitizado.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+        return sanitizado;
+    }
+    validar(valor) {
+        if ((0, utils_1.isEmpty)(valor)) {
+            this._ehValido = true;
+            return;
+        }
+        const re = /^(?:[^<>()[\]\\.,;:\s@"]+(?:\.[^<>()[\]\\.,;:\s@"]+)*|".+")@(?:\[\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\]|(?:[a-z\-\d]+\.)+[a-z]{2,})$/i;
+        if (re.test(String(valor))) {
+            this._ehValido = true;
+            return;
+        }
+        this._ehValido = "O campo Email deve ser um email válido";
+    }
+}
+exports.default = Email;

package/dist/valueObjects/Moeda.d.ts

@@ -0,0 +1,16 @@
+import { IMoeda } from "../types";
+import Numero from "./Numero";
+export interface Options {
+    prefix?: string;
+    suffix?: string;
+    separator: string;
+    decimal: string;
+    precision?: number;
+    min?: number;
+    max?: number;
+}
+export declare const FORMATO_PADRAO_BR: Options;
+export default class Moeda extends Numero implements IMoeda {
+    constructor(valor: string | number | null, formatador?: Partial<Options>);
+}
+//# sourceMappingURL=Moeda.d.ts.map

package/dist/valueObjects/Moeda.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Moeda.d.ts","sourceRoot":"","sources":["../../src/valueObjects/Moeda.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,MAAM,MAAM,UAAU,CAAC;AAE9B,MAAM,WAAW,OAAO;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,eAAO,MAAM,iBAAiB,EAAE,OAM/B,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,KAAM,SAAQ,MAAO,YAAW,MAAM;gBAEvD,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,EAC7B,UAAU,GAAE,OAAO,CAAC,OAAO,CAAqB;CAInD"}