@majapisoftwares/ui 4.0.2

package/types.d.ts

@@ -0,0 +1,6 @@
+import { Dispatch, SetStateAction, useState } from "react";
+export type NoUndefinedState<T> = T extends [
+    infer S | undefined,
+    Dispatch<SetStateAction<infer S | undefined>>
+] ? [S, Dispatch<SetStateAction<S>>] : never;
+export type UseStateTuple<T> = NoUndefinedState<ReturnType<typeof useState<T>>>;

package/types.js

@@ -0,0 +1 @@
+export {};

package/utils/UseState.d.ts

@@ -0,0 +1,3 @@
+import { Dispatch, SetStateAction } from "react";
+type UseState<S> = [S, Dispatch<SetStateAction<S>>];
+export default UseState;

package/utils/UseState.js

@@ -0,0 +1 @@
+export {};

package/utils/blobToText.d.ts

@@ -0,0 +1 @@
+export default function blobToText(file: Blob, encoding?: string): Promise<string>;

package/utils/blobToText.js

@@ -0,0 +1,13 @@
+export default function blobToText(file, encoding) {
+    const reader = new FileReader();
+    return new Promise((resolve, reject) => {
+        reader.onload = function (e) {
+            const contents = e.target?.result;
+            resolve(contents);
+        };
+        reader.onerror = function (e) {
+            reject(e.target?.error);
+        };
+        reader.readAsText(file, encoding);
+    });
+}

package/utils/capitalize.d.ts

@@ -0,0 +1 @@
+export default function capitalize<T extends string | undefined>(text: T): T;

package/utils/capitalize.js

@@ -0,0 +1,6 @@
+export default function capitalize(text) {
+    return text
+        ?.split(" ")
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(" ");
+}

package/utils/clsx.d.ts

@@ -0,0 +1,2 @@
+import originalClsx from "clsx";
+export default function clsx(...args: Parameters<typeof originalClsx>): string;

package/utils/clsx.js

@@ -0,0 +1,5 @@
+import originalClsx from "clsx";
+import { twMerge } from "tailwind-merge";
+export default function clsx(...args) {
+    return twMerge(originalClsx(...args));
+}

package/utils/copy2DToClipboard.d.ts

@@ -0,0 +1 @@
+export default function copy2DToClipboard(array: (string | number)[][]): void;

package/utils/copy2DToClipboard.js

@@ -0,0 +1,44 @@
+// copied from https://stackoverflow.com/questions/400212/how-do-i-copy-to-the-clipboard-in-javascript
+function fallbackCopyTextToClipboard(text) {
+    const textArea = document.createElement("textarea");
+    textArea.value = text;
+    // Avoid scrolling to bottom
+    textArea.style.top = "0";
+    textArea.style.left = "0";
+    textArea.style.position = "fixed";
+    document.body.appendChild(textArea);
+    textArea.focus();
+    textArea.select();
+    try {
+        // noinspection JSDeprecatedSymbols
+        document.execCommand("copy");
+    }
+    catch (err) {
+        console.error("Fallback: Oops, unable to copy", err);
+    }
+    document.body.removeChild(textArea);
+}
+function copyTextToClipboard(text) {
+    if (!navigator.clipboard) {
+        fallbackCopyTextToClipboard(text);
+        return;
+    }
+    navigator.clipboard.writeText(text).then(function () {
+        // console.log('Async: Copying to clipboard was successful!');
+    }, function (err) {
+        console.error("Async: Could not copy text: ", err);
+    });
+}
+export default function copy2DToClipboard(array) {
+    let csv = "", row, cell;
+    for (row = 0; row < array.length; row++) {
+        for (cell = 0; cell < array[row].length; cell++) {
+            csv += (array[row][cell] + "").replace(/[\n\t]+/g, " ");
+            if (cell + 1 < array[row].length)
+                csv += "\t";
+        }
+        if (row + 1 < array.length)
+            csv += "\n";
+    }
+    copyTextToClipboard(csv);
+}

package/utils/cpfCpnjUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function formatCpfCnpj(input?: string): string;
+export declare function isCpf(cpf: string): boolean;
+export declare function stripCpfCnpjFormatting(value: string): string;

package/utils/cpfCpnjUtils.js

@@ -0,0 +1,43 @@
+export function formatCpfCnpj(input = "") {
+    // Remove any non-digit characters
+    const cleanInput = input.replace(/\D/g, "");
+    if (cleanInput.length === 11) {
+        // Format as CPF (Individual Taxpayer Registry)
+        return cleanInput.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, "$1.$2.$3-$4");
+    }
+    else if (cleanInput.length === 14) {
+        // Format as CNPJ (National Registry of Legal Entities)
+        return cleanInput.replace(/(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})/, "$1.$2.$3/$4-$5");
+    }
+    return cleanInput;
+}
+export function isCpf(cpf) {
+    cpf = cpf.replace(/\D+/g, "");
+    if (cpf.length !== 11 || /^(\d)\1{10}$/.test(cpf)) {
+        return false;
+    }
+    let sum = 0;
+    let rest;
+    // Valida o primeiro dígito verificador
+    for (let i = 1; i <= 9; i++) {
+        sum += parseInt(cpf.charAt(i - 1)) * (11 - i);
+    }
+    rest = (sum * 10) % 11;
+    if (rest === 10 || rest === 11)
+        rest = 0;
+    if (rest !== parseInt(cpf.charAt(9))) {
+        return false;
+    }
+    sum = 0;
+    // Valida o segundo dígito verificador
+    for (let i = 1; i <= 10; i++) {
+        sum += parseInt(cpf.charAt(i - 1)) * (12 - i);
+    }
+    rest = (sum * 10) % 11;
+    if (rest === 10 || rest === 11)
+        rest = 0;
+    return rest === parseInt(cpf.charAt(10));
+}
+export function stripCpfCnpjFormatting(value) {
+    return value.replace(/\D+/g, "");
+}

package/utils/createLocalStorageStateHydration.d.ts

@@ -0,0 +1 @@
+export default function createLocalStorageStateHydration<T extends object>(localStorageName: string, state: T, properties?: (keyof T)[]): void;

package/utils/createLocalStorageStateHydration.js

@@ -0,0 +1,18 @@
+import { snapshot, subscribe } from "valtio";
+import { omit } from "lodash-es";
+export default function createLocalStorageStateHydration(localStorageName, state, properties) {
+    const retypedState = state;
+    if (!retypedState._hydrated) {
+        retypedState._hydrated = true;
+        subscribe(state, () => {
+            localStorage.setItem(localStorageName, JSON.stringify(omit(snapshot(retypedState), [
+                "_hydrated",
+                ...Object.keys(retypedState).filter((p) => properties && !properties.includes(p)),
+            ])));
+        });
+        const hydratedState = localStorage.getItem(localStorageName);
+        if (hydratedState) {
+            Object.assign(retypedState, JSON.parse(hydratedState));
+        }
+    }
+}

package/utils/createStateHydration.d.ts

@@ -0,0 +1,3 @@
+import type { OptionsType } from "cookies-next";
+export default function createStateHydration<T extends object>(cookieName: string, state: T, properties?: (keyof T)[]): (cookies?: object) => void;
+export declare const getCookies: (options?: OptionsType) => Promise<Record<string, string>>;

package/utils/createStateHydration.js

@@ -0,0 +1,49 @@
+import { getCookies as cnGetCookies, setCookie } from "cookies-next";
+import ms from "ms";
+import { snapshot, subscribe } from "valtio";
+import { omit } from "lodash-es";
+export default function createStateHydration(cookieName, state, properties) {
+    const retypedState = state;
+    if (!retypedState._hydration) {
+        subscribe(state, () => {
+            setCookie(cookieName, omit(snapshot(retypedState), [
+                "_hydration",
+                ...Object.keys(retypedState).filter((p) => properties && !properties.includes(p)),
+            ]), {
+                maxAge: ms("30d"),
+                path: "/",
+            });
+        });
+    }
+    return function hydrate(cookies) {
+        const retypedCookies = cookies;
+        if (!retypedCookies?._lastUpdate ||
+            !retypedState._hydration ||
+            retypedState._hydration < +retypedCookies._lastUpdate) {
+            retypedState._hydration = retypedCookies?._lastUpdate
+                ? +retypedCookies._lastUpdate
+                : Date.now();
+            if (cookies?.[cookieName]) {
+                try {
+                    const cookieValueString = cookies[cookieName];
+                    const cookieValue = JSON.parse(cookieValueString);
+                    if (typeof cookieValue === "object") {
+                        for (const property of properties || Object.keys(state)) {
+                            if (cookieValue[property]) {
+                                state[property] = cookieValue[property];
+                            }
+                        }
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                }
+                catch (e) {
+                    // do nothing
+                }
+            }
+        }
+    };
+}
+export const getCookies = async (options) => ({
+    ...(await cnGetCookies(options)),
+    _lastUpdate: Date.now().toString(),
+});

package/utils/csvBlobToJson.d.ts

@@ -0,0 +1,2 @@
+import { ChangeEvent } from "react";
+export default function csvBlobToJson(event: ChangeEvent<HTMLInputElement>, encoding: "windows-1252" | "utf8"): Promise<Record<string, string>[] | null>;

package/utils/csvBlobToJson.js

@@ -0,0 +1,60 @@
+import { showNotification } from "../components/Notifications";
+import blobToText from "./blobToText";
+export default async function csvBlobToJson(event, encoding) {
+    if (!event.target.files?.[0]) {
+        showNotification({
+            icon: "error",
+            message: "Nenhum arquivo foi selecionado",
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const csv = await blobToText(event.target.files[0], encoding);
+    event.target.value = "";
+    const rows = csv.trim().split("\r\n");
+    const headers = rows
+        .shift()
+        ?.split(";")
+        .reduce((acc, header) => {
+        // existing header concatenate amount of headers with the same name
+        if (acc.includes(header)) {
+            const amount = acc.filter((h) => h === header).length;
+            acc.push(`${header} ${amount + 1}`);
+        }
+        else {
+            acc.push(header);
+        }
+        return acc;
+    }, []);
+    if (!headers) {
+        return null;
+    }
+    const wrongValues = [];
+    const json = [];
+    for (const row of rows) {
+        const object = {};
+        const values = row.split(";");
+        if (values.length !== headers.length) {
+            wrongValues.push(values);
+        }
+        else {
+            for (let i = 0; i < headers.length; i++) {
+                object[headers[i]] = values[i];
+            }
+            json.push(object);
+        }
+    }
+    if (wrongValues.length) {
+        showNotification({
+            icon: "error",
+            message: `A planilha está sendo importada em segundo plano mas ${wrongValues.length} items foram ignorados por estarem com o formato errado`,
+        });
+        console.error(wrongValues);
+    }
+    else {
+        showNotification({
+            icon: "success",
+            message: "A planilha está sendo importada em segundo plano",
+        });
+    }
+    return json;
+}

package/utils/downloadArrayAsCSV.d.ts

@@ -0,0 +1 @@
+export default function downloadArrayAsCSV(data: (string | undefined)[][], filename?: string): void;

package/utils/downloadArrayAsCSV.js

@@ -0,0 +1,34 @@
+export default function downloadArrayAsCSV(data, filename = "data.csv") {
+    // Function to escape fields with commas or double quotes
+    const escapeCSVField = (field) => {
+        if (field.includes('"')) {
+            field = field.replace(/"/g, '""'); // Escape double quotes
+        }
+        if (field.includes(",") || field.includes("\n")) {
+            field = `"${field}"`; // Enclose in double quotes
+        }
+        return field;
+    };
+    // Step 1: Convert the array to a CSV string with proper escaping
+    const csvContent = data
+        .map((row) => row.filter(Boolean).map(escapeCSVField).join(","))
+        .join("\n");
+    // Add BOM for UTF-8 encoding
+    const bom = "\uFEFF";
+    // Step 2: Create a Blob object from the CSV string with BOM
+    const blob = new Blob([bom + csvContent], {
+        type: "text/csv;charset=utf-8;",
+    });
+    // Step 3: Create a download link for the Blob and trigger a click event on the link
+    const link = document.createElement("a");
+    if (link.download !== undefined) {
+        // feature detection
+        const url = URL.createObjectURL(blob);
+        link.setAttribute("href", url);
+        link.setAttribute("download", filename);
+        link.style.visibility = "hidden";
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+    }
+}

package/utils/emailRegExp.d.ts

@@ -0,0 +1,2 @@
+declare const emailRegExp: RegExp;
+export default emailRegExp;

package/utils/emailRegExp.js

@@ -0,0 +1,3 @@
+/* eslint-disable no-useless-escape */
+const emailRegExp = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+export default emailRegExp;

package/utils/fakeArray.d.ts

@@ -0,0 +1 @@
+export default function fakeArray(n: number): number[];

package/utils/fakeArray.js

@@ -0,0 +1,3 @@
+export default function fakeArray(n) {
+    return Array.from(Array(n).keys());
+}

package/utils/filterBoolean.d.ts

@@ -0,0 +1 @@
+export default function filterBoolean<T>(array: (T | null | undefined)[]): T[];

package/utils/filterBoolean.js

@@ -0,0 +1,3 @@
+export default function filterBoolean(array) {
+    return array.filter(Boolean);
+}

package/utils/formatClock.d.ts

@@ -0,0 +1 @@
+export default function formatClock(time?: number): string;

package/utils/formatClock.js

@@ -0,0 +1,21 @@
+export default function formatClock(time) {
+    if (time === undefined) {
+        return "";
+    }
+    const totalSeconds = Math.floor(time / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const remainingSeconds = totalSeconds % 60;
+    let formattedTime = "";
+    if (hours > 0) {
+        formattedTime += `${hours.toString().padStart(2, "0")}:`;
+    }
+    if (minutes > 0) {
+        formattedTime += `${minutes.toString().padStart(2, "0")}:`;
+    }
+    else {
+        formattedTime += `00:`;
+    }
+    formattedTime += remainingSeconds.toString().padStart(2, "0");
+    return formattedTime.trim();
+}

package/utils/formatTime.d.ts

@@ -0,0 +1,2 @@
+export default function formatTime(time: number): string;
+export declare function parseFormattedTime(formattedTime: string): number;

package/utils/formatTime.js

@@ -0,0 +1,40 @@
+export default function formatTime(time) {
+    const totalSeconds = Math.floor(time / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const remainingSeconds = totalSeconds % 60;
+    let formattedTime = "";
+    if (hours > 0) {
+        formattedTime += `${hours}h `;
+    }
+    if (minutes > 0) {
+        formattedTime += `${minutes}m `;
+    }
+    if (remainingSeconds > 0) {
+        formattedTime += `${remainingSeconds}s`;
+    }
+    return formattedTime.trim();
+}
+export function parseFormattedTime(formattedTime) {
+    if (!formattedTime) {
+        return 0;
+    }
+    const timeParts = formattedTime.split(" ");
+    let totalMilliseconds = 0;
+    timeParts.forEach((part) => {
+        const unit = part.slice(-1); // Get the last character (h, m, or s)
+        const value = parseFloat(part.slice(0, -1)); // Get the numeric value
+        if (!isNaN(value)) {
+            if (unit === "h") {
+                totalMilliseconds += value * 3600000; // Convert hours to milliseconds
+            }
+            else if (unit === "m") {
+                totalMilliseconds += value * 60000; // Convert minutes to milliseconds
+            }
+            else if (unit === "s") {
+                totalMilliseconds += value * 1000; // Convert seconds to milliseconds
+            }
+        }
+    });
+    return totalMilliseconds;
+}

package/utils/getInitials.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Gets all the initials of a name.
+ */
+export default function getInitials(name: string, separator?: string): string;

package/utils/getInitials.js

@@ -0,0 +1,8 @@
+/**
+ * Gets all the initials of a name.
+ */
+export default function getInitials(name, separator = " ") {
+    const splitName = name.split(separator).slice(0, 2);
+    const splitInitials = splitName.map((n) => n.charAt(0));
+    return splitInitials.join("");
+}

package/utils/isBrowser.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Tells if the current scope is a browser.
+ */
+export declare const isBrowser: boolean;
+/**
+ * Tells if the current scope is a touch device.
+ */
+export declare const isTouchDevice: boolean;
+/**
+ * Tells if the current scope is a iOS device.
+ */
+export declare const is_iOS: boolean;

package/utils/isBrowser.js

@@ -0,0 +1,26 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* istanbul ignore file */
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Tells if the current scope is a browser.
+ */
+export const isBrowser = typeof window !== "undefined";
+/**
+ * Tells if the current scope is a touch device.
+ */
+export const isTouchDevice = isBrowser &&
+    (!!(typeof window !== "undefined" &&
+        ("ontouchstart" in window ||
+            // @ts-ignore: "DocumentTouch" exists on touch devices only
+            (window.DocumentTouch &&
+                typeof document !== "undefined" &&
+                // @ts-ignore: "DocumentTouch" exists on touch devices only
+                document instanceof window.DocumentTouch))) ||
+        !!(typeof navigator !== "undefined" &&
+            // @ts-ignore: "maxTouchPoints" exists on touch devices only
+            (navigator.maxTouchPoints || navigator.msMaxTouchPoints)));
+/**
+ * Tells if the current scope is a iOS device.
+ */
+export const is_iOS = typeof navigator !== "undefined" &&
+    /iPad|iPhone|iPod/.test(navigator.userAgent);

package/utils/ms.d.ts

@@ -0,0 +1,6 @@
+import { StringValue } from "ms";
+export declare function ms(value: number, options?: {
+    long: boolean;
+    locale?: string;
+}): string;
+export declare function ms(value: StringValue): number;

package/utils/ms.js

@@ -0,0 +1,31 @@
+import vms from "ms";
+const locale = {
+    ["en"]: {
+        day: "day",
+        hour: "hour",
+        minute: "minute",
+        second: "second",
+    },
+    ["pt-BR"]: {
+        day: "dia",
+        hour: "hora",
+        minute: "minuto",
+        second: "segundo",
+    },
+    ["undefined"]: {
+        day: "day",
+        hour: "hour",
+        second: "second",
+        minute: "minute",
+    },
+};
+export function ms(value, options) {
+    if (typeof value === "number") {
+        return vms(value, options)
+            .replace("day", locale[String(options?.locale)].day)
+            .replace("hour", locale[String(options?.locale)].hour)
+            .replace("minute", locale[String(options?.locale)].minute)
+            .replace("second", locale[String(options?.locale)].second);
+    }
+    return vms(value);
+}

package/utils/preventDefault.d.ts

@@ -0,0 +1 @@
+export default function preventDefault(event: Event): void;

package/utils/preventDefault.js

@@ -0,0 +1,3 @@
+export default function preventDefault(event) {
+    event.preventDefault();
+}

package/utils/recursiveChildrenMap.d.ts

@@ -0,0 +1,2 @@
+import { ReactElement, ReactNode } from "react";
+export default function recursiveChildrenMap<P>(children: ReactNode, fn: (child: ReactElement<P>) => ReactElement<P>): ReactNode;

package/utils/recursiveChildrenMap.js

@@ -0,0 +1,16 @@
+import { Children, cloneElement, isValidElement, } from "react";
+export default function recursiveChildrenMap(children, fn) {
+    return Children.map(children, (child) => {
+        if (!isValidElement(child)) {
+            return child;
+        }
+        const childProps = child.props;
+        if (childProps?.children) {
+            child = cloneElement(child, {
+                children: recursiveChildrenMap(childProps.children, fn),
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            });
+        }
+        return fn(child);
+    });
+}

package/utils/setSelectionRange.d.ts

@@ -0,0 +1 @@
+export default function setSelectionRange(el: Element, start: number, end: number): void;

package/utils/setSelectionRange.js

@@ -0,0 +1,55 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// noinspection JSUnresolvedReference
+function getTextNodesIn(node) {
+    const textNodes = [];
+    if (node.nodeType == 3) {
+        textNodes.push(node);
+    }
+    else {
+        const children = node.childNodes;
+        for (let i = 0, len = children.length; i < len; ++i) {
+            textNodes.push(...getTextNodesIn(children[i]));
+        }
+    }
+    return textNodes;
+}
+export default function setSelectionRange(el, start, end) {
+    if (document.createRange && window.getSelection) {
+        const range = document.createRange();
+        range.selectNodeContents(el);
+        const textNodes = getTextNodesIn(el);
+        let foundStart = false;
+        let charCount = 0, endCharCount;
+        for (let i = 0, textNode; (textNode = textNodes[i++]);) {
+            // @ts-ignore
+            endCharCount = charCount + textNode.length;
+            if (!foundStart &&
+                start >= charCount &&
+                (start < endCharCount ||
+                    (start == endCharCount && i <= textNodes.length))) {
+                range.setStart(textNode, start - charCount);
+                foundStart = true;
+            }
+            if (foundStart && end <= endCharCount) {
+                range.setEnd(textNode, end - charCount);
+                break;
+            }
+            charCount = endCharCount;
+        }
+        const sel = window.getSelection();
+        sel.removeAllRanges();
+        sel.addRange(range);
+    }
+    else {
+        // @ts-ignore
+        if (document.selection && document.body.createTextRange) {
+            // @ts-ignore
+            const textRange = document.body.createTextRange();
+            textRange.moveToElementText(el);
+            textRange.collapse(true);
+            textRange.moveEnd("character", end);
+            textRange.moveStart("character", start);
+            textRange.select();
+        }
+    }
+}

package/utils/smoothScrollToHref.d.ts

@@ -0,0 +1,2 @@
+import { MouseEvent } from "react";
+export default function smoothScrollToHref(event: MouseEvent): void;

package/utils/smoothScrollToHref.js

@@ -0,0 +1,10 @@
+export default function smoothScrollToHref(event) {
+    event.preventDefault();
+    const href = event.currentTarget.getAttribute("href");
+    if (href) {
+        const target = document.getElementById(href.split("#")[1]);
+        if (target) {
+            target.scrollIntoView({ behavior: "smooth" });
+        }
+    }
+}

package/utils/stopPropagation.d.ts

@@ -0,0 +1,2 @@
+import { MouseEvent, TouchEvent } from "react";
+export default function stopPropagation(event: MouseEvent | TouchEvent): void;

package/utils/stopPropagation.js

@@ -0,0 +1,3 @@
+export default function stopPropagation(event) {
+    event.stopPropagation();
+}

package/utils/stripHtml.d.ts

@@ -0,0 +1 @@
+export declare function stripHtml(input?: string): string | undefined;