@zauru-sdk/hooks 1.0.13

package/dist/components/Alert.js

@@ -0,0 +1,97 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useRef, useEffect } from "react";
+import { ExitSvg } from "@zauru-sdk/icons";
+import { createRoot } from "react-dom/client";
+import { AnimatePresence, motion } from "framer-motion";
+const Alert = ({ type, title, description, onClose }) => {
+    const [, setLifetime] = useState(4000);
+    const [progress, setProgress] = useState(0);
+    const intervalRef = useRef(null);
+    const getColor = () => {
+        switch (type) {
+            case "success":
+                return "bg-green-100 text-green-800";
+            case "error":
+                return "bg-red-100 text-red-800";
+            case "info":
+                return "bg-blue-100 text-blue-800";
+            case "warning":
+                return "bg-yellow-100 text-yellow-800";
+            default:
+                return "bg-gray-100 text-gray-800";
+        }
+    };
+    useEffect(() => {
+        const startTimer = () => {
+            intervalRef.current = setInterval(() => {
+                setLifetime((lifetime) => {
+                    if (lifetime <= 0) {
+                        onClose && onClose();
+                        clearInterval(intervalRef.current);
+                        return 0;
+                    }
+                    else {
+                        setProgress((4000 - lifetime) / 4000);
+                        return lifetime - 50;
+                    }
+                });
+            }, 50);
+        };
+        const pauseTimer = () => {
+            clearInterval(intervalRef.current);
+        };
+        startTimer();
+        return () => {
+            pauseTimer();
+        };
+    }, [onClose]);
+    return (_jsxs(motion.div, { initial: { y: -50, opacity: 0 }, animate: { y: 0, opacity: 1 }, exit: { y: -50, opacity: 0 }, className: `fixed top-0 right-0 w-80 mt-10 mr-10 rounded-md shadow-lg ${getColor()} p-4 transition-transform duration-300`, style: {
+            zIndex: 1000,
+            transform: `translateY(calc(var(--alert-offset, 0)))`,
+        }, onMouseEnter: () => clearInterval(intervalRef.current), onMouseLeave: () => {
+            intervalRef.current = setInterval(() => {
+                setLifetime((lifetime) => {
+                    if (lifetime <= 0) {
+                        onClose && onClose();
+                        clearInterval(intervalRef.current);
+                        return 0;
+                    }
+                    else {
+                        setProgress((4000 - lifetime) / 4000);
+                        return lifetime - 50;
+                    }
+                });
+            }, 50);
+        }, children: [_jsxs("div", { className: "flex items-center justify-between", children: [_jsx("h3", { className: "font-semibold", children: title }), _jsx("button", { className: "text-gray-400 hover:text-gray-500 focus:outline-none focus:text-gray-500 transition duration-150 ease-in-out", onClick: () => {
+                            setLifetime(0);
+                            onClose && onClose();
+                        }, children: _jsx(ExitSvg, {}) })] }), _jsx("div", { className: "mt-2", children: _jsx("p", { className: "text-sm overflow-wrap break-words", children: description }) }), _jsx("div", { className: "relative h-1 mt-4 bg-gray-200 rounded", children: _jsx("div", { className: `absolute left-0 top-0 h-full ${getColor()} rounded`, style: { width: `${progress * 100}%` } }) })] }));
+};
+let activeAlerts = [];
+export const showAlert = (alertProps) => {
+    if (typeof document === "undefined") {
+        return;
+    }
+    const container = document.createElement("div");
+    document.body.appendChild(container);
+    const onClose = () => {
+        root.unmount();
+        container.remove();
+        activeAlerts = activeAlerts.filter((alert) => alert !== container);
+        updateAlertOffsets();
+    };
+    const asyncOnClose = () => {
+        setTimeout(() => {
+            onClose();
+        }, 0);
+    };
+    activeAlerts.push(container);
+    updateAlertOffsets();
+    const root = createRoot(container);
+    root.render(_jsx(AnimatePresence, { children: _jsx(Alert, { ...alertProps, onClose: asyncOnClose }) }));
+};
+const updateAlertOffsets = () => {
+    activeAlerts.forEach((alertContainer, index) => {
+        alertContainer.style.setProperty("--alert-offset", `${index * 100}px`);
+    });
+};

package/dist/components/index.d.ts

@@ -0,0 +1 @@
+export * from "./Alert";

package/dist/components/index.js

@@ -0,0 +1 @@
+export * from "./Alert";

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./components";
+export * from "./alerts";
+export * from "./automaticNumbers";
+export * from "./catalogs";
+export * from "./onlineStatus";
+export * from "./profiles";
+export * from "./receptions";
+export * from "./session";
+export * from "./templates";
+export * from "./useWindowDimensions";

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./components";
+export * from "./alerts";
+export * from "./automaticNumbers";
+export * from "./catalogs";
+export * from "./onlineStatus";
+export * from "./profiles";
+export * from "./receptions";
+export * from "./session";
+export * from "./templates";
+export * from "./useWindowDimensions";

package/dist/onlineStatus.d.ts

@@ -0,0 +1 @@
+export declare const useIsOnline: () => boolean;

package/dist/onlineStatus.js

@@ -0,0 +1,27 @@
+import { useState, useEffect } from "react";
+// Hook personalizado para verificar el estado de conexión
+export const useIsOnline = () => {
+    // Verificar si estamos en el entorno del servidor o del cliente
+    const isServer = typeof window === "undefined";
+    // Estado local para almacenar si la aplicación está en línea o no
+    const [isOnline, setIsOnline] = useState(!isServer && navigator.onLine);
+    // Función para manejar el cambio de estado de conexión
+    const handleConnectionChange = () => {
+        setIsOnline(navigator.onLine);
+    };
+    useEffect(() => {
+        if (isServer) {
+            // Si estamos en el servidor, no añadir los event listeners
+            return;
+        }
+        // Añadir event listeners
+        window.addEventListener("online", handleConnectionChange);
+        window.addEventListener("offline", handleConnectionChange);
+        // Limpiar event listeners al desmontar el componente
+        return () => {
+            window.removeEventListener("online", handleConnectionChange);
+            window.removeEventListener("offline", handleConnectionChange);
+        };
+    }, [isServer]);
+    return isOnline;
+};

package/dist/profiles.d.ts

@@ -0,0 +1,17 @@
+import type { AgencyGraphQL, EmployeeGraphQL, OauthProfile, ProfileResponse } from "@zauru-sdk/types";
+export declare const useGetAgencyProfile: () => {
+    loading: boolean;
+    data: AgencyGraphQL;
+};
+export declare const useGetUserProfile: () => {
+    loading: boolean;
+    data: ProfileResponse;
+};
+export declare const useGetOauthProfile: () => {
+    loading: boolean;
+    data: OauthProfile;
+};
+export declare const useGetEmployeeProfile: () => {
+    loading: boolean;
+    data: EmployeeGraphQL;
+};

package/dist/profiles.js

@@ -0,0 +1,57 @@
+import { useFetcher } from "@remix-run/react";
+import { useEffect, useState } from "react";
+import { showAlert } from "src";
+import { profileFetchStart, profileFetchSuccess, useAppDispatch, useAppSelector, } from "@zauru-sdk/redux";
+const useGetProfile = (PROFILE_NAME) => {
+    const fetcher = useFetcher();
+    const dispatch = useAppDispatch();
+    const profileData = useAppSelector((state) => state.profiles[PROFILE_NAME]);
+    const [data, setData] = useState({
+        data: Object.keys(profileData?.data)?.length
+            ? profileData?.data
+            : {},
+        loading: profileData?.loading,
+    });
+    useEffect(() => {
+        if (fetcher.data?.title) {
+            showAlert({
+                description: fetcher.data?.description?.toString(),
+                title: fetcher.data?.title?.toString(),
+                type: fetcher.data?.type?.toString(),
+            });
+        }
+    }, [fetcher.data]);
+    useEffect(() => {
+        if (fetcher.state === "idle" && fetcher.data != null) {
+            const receivedData = fetcher.data;
+            if (receivedData) {
+                setData({ data: receivedData[PROFILE_NAME], loading: false });
+                dispatch(profileFetchSuccess({
+                    name: PROFILE_NAME,
+                    data: receivedData[PROFILE_NAME],
+                }));
+            }
+        }
+    }, [fetcher, dispatch, PROFILE_NAME]);
+    useEffect(() => {
+        if (Object.keys(profileData?.data).length <= 0) {
+            try {
+                setData({ ...data, loading: true });
+                dispatch(profileFetchStart(PROFILE_NAME));
+                fetcher.load(`/api/profiles?profile=${PROFILE_NAME}`);
+            }
+            catch (ex) {
+                showAlert({
+                    type: "error",
+                    title: `Ocurrió un error al cargar el perfil: ${PROFILE_NAME}.`,
+                    description: "Error: " + ex,
+                });
+            }
+        }
+    }, []);
+    return data;
+};
+export const useGetAgencyProfile = () => useGetProfile("agencyProfile");
+export const useGetUserProfile = () => useGetProfile("userProfile");
+export const useGetOauthProfile = () => useGetProfile("oauthProfile");
+export const useGetEmployeeProfile = () => useGetProfile("employeeProfile");

package/dist/receptions.d.ts

@@ -0,0 +1,102 @@
+import { ItemAssociatedLots, ItemGraphQL, NewPurchaseOrderResponse, PayeeGraphQL, PurchaseOrderGeneralInfo, PurchaseOrderGraphQL, QueueFormReceptionWebAppTable, RejectionWebAppTableObject, WebAppRowGraphQL, GenericDynamicTableColumn } from "@zauru-sdk/types";
+type ConfigProps = {
+    online?: boolean;
+    wheres?: string[];
+};
+export declare const useGetProcesses: (config?: ConfigProps) => {
+    loading: boolean;
+    data: WebAppRowGraphQL<QueueFormReceptionWebAppTable>[];
+};
+export declare const useGetPOReceptions: (config?: ConfigProps) => {
+    loading: boolean;
+    data: PurchaseOrderGraphQL[];
+};
+export declare const useGetBasketLots: () => {
+    loading: boolean;
+    data: ItemAssociatedLots;
+};
+export declare const useGetRejectionInfo: () => {
+    loading: boolean;
+    data: RejectionWebAppTableObject;
+};
+export declare const useGetNewPurchaseOrderInfo: () => {
+    loading: boolean;
+    data: NewPurchaseOrderResponse;
+};
+export declare const useGetPurchaseOrderGeneralInfo: () => {
+    loading: boolean;
+    data: PurchaseOrderGeneralInfo;
+};
+/**
+ * ---------------- Hooks personalizados
+ */
+type FormInput = {
+    idNumberInput: string;
+    rType: string;
+    vendor: string;
+    porcentajeRechazo: string;
+    [key: string]: string | undefined;
+};
+type PesadaBody = {
+    id: number;
+    baskets: number;
+    totalWeight: number;
+    discount: number;
+    netWeight: string;
+    weightByBasket: string;
+    probableUtilization: number;
+    lbDiscounted: number;
+};
+type PesadaFooter = {
+    id: string;
+    baskets: string;
+    totalWeight: string;
+    discount: string;
+    netWeight: string;
+    weightByBasket: string;
+};
+export declare const useGetPesadas: (purchaseOrder: PurchaseOrderGraphQL) => [PesadaBody[], PesadaFooter, GenericDynamicTableColumn[]];
+/**
+ * Sirve para imprimir offline
+ * @param formInput
+ * @returns
+ */
+export declare const getPesadasByForm: (formInput: FormInput) => {
+    tempPesadas: PesadaBody[];
+    totales: {
+        id: string;
+        baskets: string;
+        totalWeight: string;
+        discount: string;
+        netWeight: string;
+        weightByBasket: string;
+        lbDiscounted: string;
+        probableUtilization: string;
+    };
+    headers: GenericDynamicTableColumn[];
+};
+type BasketDetailsBody = {
+    id: number;
+    total: number;
+    color: string;
+    cc: number;
+};
+type BasketDetailsFooter = {
+    id: string;
+    total: string;
+    cc: number;
+};
+export declare const useGetBasketDetails: (purchaseOrder: PurchaseOrderGraphQL) => [BasketDetailsBody[], BasketDetailsFooter, GenericDynamicTableColumn[]];
+/**
+ * Para imprimir en modo offline
+ * @param formInput
+ * @returns
+ */
+export declare const getBasketDetailsByForm: (formInput: FormInput) => {
+    basketDetailsArray: BasketDetailsBody[];
+    totales: BasketDetailsFooter;
+    headers: GenericDynamicTableColumn[];
+};
+export declare const useGetProviderNameByPurchaseOrder: (payees: PayeeGraphQL[], purchaseOrder: PurchaseOrderGraphQL) => string | null;
+export declare const useGetItemNameByPurchaseOrder: (items: ItemGraphQL[], purchaseOrder: PurchaseOrderGraphQL) => string | null;
+export {};

package/dist/receptions.js

@@ -0,0 +1,333 @@
+import { useFetcher } from "@remix-run/react";
+import { receptionFetchStart, receptionFetchSuccess, useAppDispatch, useAppSelector, } from "@zauru-sdk/redux";
+import { useEffect, useMemo, useState } from "react";
+import { showAlert } from "src";
+import { getBasketsSchema, reduceAdd, toFixedIfNeeded, } from "../../common/dist";
+const useGetReceptionObject = (RECEPTION_NAME, { online = false, wheres = [] } = {}) => {
+    const fetcher = useFetcher();
+    const dispatch = useAppDispatch();
+    const objectData = useAppSelector((state) => state.receptions[RECEPTION_NAME]);
+    const [data, setData] = useState({
+        data: Array.isArray(objectData?.data)
+            ? objectData?.data.length
+                ? objectData?.data
+                : []
+            : Object.keys(objectData?.data || {}).length
+                ? objectData?.data
+                : {},
+        loading: objectData.loading,
+    });
+    useEffect(() => {
+        if (fetcher.data?.title) {
+            showAlert({
+                description: fetcher.data?.description?.toString(),
+                title: fetcher.data?.title?.toString(),
+                type: fetcher.data?.type?.toString(),
+            });
+        }
+    }, [fetcher.data]);
+    useEffect(() => {
+        if (fetcher.state === "idle" && fetcher.data != null) {
+            const receivedData = fetcher.data;
+            if (receivedData) {
+                setData({ data: receivedData[RECEPTION_NAME], loading: false });
+                dispatch(receptionFetchSuccess({
+                    name: RECEPTION_NAME,
+                    data: receivedData[RECEPTION_NAME],
+                }));
+            }
+        }
+    }, [fetcher, dispatch, RECEPTION_NAME]);
+    useEffect(() => {
+        const isEmptyData = Array.isArray(objectData?.data)
+            ? objectData?.data.length <= 0
+            : Object.keys(objectData?.data || {}).length <= 0;
+        if (isEmptyData || objectData.reFetch || online) {
+            try {
+                setData({ ...data, loading: true });
+                dispatch(receptionFetchStart(RECEPTION_NAME));
+                // Convierte cada elemento del array a una cadena codificada para URL
+                const encodedWheres = wheres.map((where) => encodeURIComponent(where));
+                // Une los elementos codificados con '&'
+                const wheresQueryParam = encodedWheres.join("&");
+                fetcher.load(`/api/receptions?object=${RECEPTION_NAME}&wheres=${wheresQueryParam}`);
+            }
+            catch (ex) {
+                showAlert({
+                    type: "error",
+                    title: `Ocurrió un error al cargar el object de receptions: ${RECEPTION_NAME}.`,
+                    description: "Error: " + ex,
+                });
+            }
+        }
+    }, []);
+    return data;
+};
+export const useGetProcesses = (config) => useGetReceptionObject("queueNewReceptions", config);
+export const useGetPOReceptions = (config) => useGetReceptionObject("poReceptions", config);
+export const useGetBasketLots = () => useGetReceptionObject("basketLots");
+export const useGetRejectionInfo = () => useGetReceptionObject("rejectionInfo");
+export const useGetNewPurchaseOrderInfo = () => useGetReceptionObject("newPurchaseOrderInfo");
+export const useGetPurchaseOrderGeneralInfo = () => useGetReceptionObject("purchaseOrderGeneralInfo");
+export const useGetPesadas = (purchaseOrder) => {
+    const [pesadas, footerPesadas, headersPesadas] = useMemo(() => {
+        const tempPesadas = [
+            ...purchaseOrder.purchase_order_details?.map((x, index) => {
+                const parsedReference = x.reference?.split(","); //eg: "reference": "698,25,0", // peso neto, canastas, descuento
+                const totalWeight = parsedReference[0]
+                    ? Number(parsedReference[0]) ?? 0
+                    : 0;
+                const baskets = parsedReference[1]
+                    ? Number(parsedReference[1]) ?? 0
+                    : 0;
+                const discount = parsedReference[2]
+                    ? Number(parsedReference[2]) ?? 0
+                    : 0;
+                //TODO sacar el peso de la canasta de la API de Zauru
+                const basketWeight = 5;
+                let netWeight = totalWeight - baskets * basketWeight; //Se le resta el peso de las canastas
+                netWeight = netWeight * ((100 - discount) / 100); //Se le aplica el descuento
+                const weightByBasket = netWeight / baskets;
+                //Probable aprovechamiento en planta
+                const probableUtilization = netWeight * ((100 - purchaseOrder?.discount) / 100);
+                //libras o unidades descontadas
+                const lbDiscounted = netWeight - probableUtilization;
+                return {
+                    id: index + 1,
+                    baskets,
+                    totalWeight,
+                    discount,
+                    netWeight: toFixedIfNeeded(netWeight),
+                    weightByBasket: toFixedIfNeeded(weightByBasket),
+                    probableUtilization,
+                    lbDiscounted,
+                };
+            }),
+        ];
+        const totales = {
+            id: "",
+            baskets: toFixedIfNeeded(tempPesadas?.map((x) => x.baskets).reduce(reduceAdd, 0)),
+            totalWeight: toFixedIfNeeded(tempPesadas?.map((x) => x.totalWeight).reduce(reduceAdd, 0)),
+            discount: "-",
+            netWeight: toFixedIfNeeded(tempPesadas?.map((x) => Number(x.netWeight)).reduce(reduceAdd, 0)),
+            weightByBasket: "-",
+            lbDiscounted: toFixedIfNeeded(tempPesadas?.map((x) => Number(x.lbDiscounted)).reduce(reduceAdd, 0)),
+            probableUtilization: toFixedIfNeeded(tempPesadas
+                ?.map((x) => Number(x.probableUtilization))
+                .reduce(reduceAdd, 0)),
+        };
+        const headers = [
+            { label: "#", name: "id", type: "label", width: 5 },
+            { label: "Canastas", name: "baskets", type: "label" },
+            { label: "Peso báscula", name: "totalWeight", type: "label" },
+            { label: "Descuento (%)", name: "discount", type: "label" },
+            { label: "Peso Neto", name: "netWeight", type: "label" },
+            {
+                label: "Peso Neto - %Rechazo",
+                name: "probableUtilization",
+                type: "label",
+            },
+            {
+                label: "Lb o Unidades descontadas",
+                name: "lbDiscounted",
+                type: "label",
+            },
+            {
+                label: "Peso Neto por canasta",
+                name: "weightByBasket",
+                type: "label",
+            },
+        ];
+        return [tempPesadas, totales, headers];
+    }, [purchaseOrder]);
+    return [pesadas, footerPesadas, headersPesadas];
+};
+/**
+ * Sirve para imprimir offline
+ * @param formInput
+ * @returns
+ */
+export const getPesadasByForm = (formInput) => {
+    // Inicializar array de pesadas
+    const tempPesadas = [];
+    // Iterar sobre los campos del formulario y extraer la información de pesadas
+    let index = 0;
+    while (formInput.hasOwnProperty(`basket${index}`)) {
+        const baskets = Number(formInput[`basket${index}`] || 0);
+        const totalWeight = Number(formInput[`weight${index}`] || 0);
+        const discount = Number(formInput[`discount${index}`] || 0);
+        // Realizar los cálculos necesarios
+        const basketWeight = 5;
+        let netWeight = totalWeight - baskets * basketWeight;
+        netWeight = netWeight * ((100 - discount) / 100);
+        const weightByBasket = netWeight / baskets;
+        //Probable aprovechamiento en planta
+        const probableUtilization = netWeight * ((100 - (Number(formInput.porcentajeRechazo) ?? 0)) / 100);
+        //libras o unidades descontadas
+        const lbDiscounted = netWeight - probableUtilization;
+        // Añadir al array de pesadas
+        tempPesadas.push({
+            id: index + 1,
+            baskets,
+            totalWeight,
+            discount,
+            netWeight: toFixedIfNeeded(netWeight),
+            weightByBasket: toFixedIfNeeded(weightByBasket),
+            probableUtilization,
+            lbDiscounted,
+        });
+        index++;
+    }
+    const totales = {
+        id: "",
+        baskets: toFixedIfNeeded(tempPesadas?.map((x) => x.baskets).reduce(reduceAdd, 0)),
+        totalWeight: toFixedIfNeeded(tempPesadas?.map((x) => x.totalWeight).reduce(reduceAdd, 0)),
+        discount: "-",
+        netWeight: toFixedIfNeeded(tempPesadas?.map((x) => Number(x.netWeight)).reduce(reduceAdd, 0)),
+        weightByBasket: "-",
+        lbDiscounted: toFixedIfNeeded(tempPesadas?.map((x) => Number(x.lbDiscounted)).reduce(reduceAdd, 0)),
+        probableUtilization: toFixedIfNeeded(tempPesadas
+            ?.map((x) => Number(x.probableUtilization))
+            .reduce(reduceAdd, 0)),
+    };
+    const headers = [
+        { label: "#", name: "id", type: "label", width: 5 },
+        { label: "Canastas", name: "baskets", type: "label" },
+        { label: "Peso báscula", name: "totalWeight", type: "label" },
+        { label: "Descuento (%)", name: "discount", type: "label" },
+        { label: "Peso Neto", name: "netWeight", type: "label" },
+        {
+            label: "Peso Neto - %Rechazo",
+            name: "probableUtilization",
+            type: "label",
+        },
+        {
+            label: "Lb o Unidades descontadas",
+            name: "lbDiscounted",
+            type: "label",
+        },
+        {
+            label: "Peso Neto por canasta",
+            name: "weightByBasket",
+            type: "label",
+        },
+    ];
+    return { tempPesadas, totales, headers };
+};
+export const useGetBasketDetails = (purchaseOrder) => {
+    const [basketsJoined, footerBasketsJoined, headersBasketsJoined] = useMemo(() => {
+        const bsq = purchaseOrder?.lots
+            ?.map((x) => {
+            const basket = getBasketsSchema(x.description);
+            return basket;
+        })
+            .flat(2) ?? [];
+        const bsqToCC = getBasketsSchema(purchaseOrder.memo);
+        const joinedBaskets = [];
+        for (let i = 0; i < bsq.length; i++) {
+            const found = joinedBaskets.find((item) => item.color === bsq[i].color);
+            const foundCC = bsqToCC.find((item) => item.color === bsq[i].color);
+            if (found) {
+                found.total += bsq[i].total;
+            }
+            else {
+                joinedBaskets.push({
+                    id: i,
+                    total: bsq[i].total + (foundCC ? foundCC.total : 0),
+                    color: bsq[i].color,
+                    cc: foundCC ? foundCC.total : 0,
+                });
+            }
+        }
+        const totales = {
+            id: "",
+            total: toFixedIfNeeded(joinedBaskets?.map((x) => x.total).reduce(reduceAdd, 0)),
+            cc: joinedBaskets?.map((x) => x.cc).reduce(reduceAdd, 0),
+        };
+        const headers = [
+            { label: "Color", name: "color", type: "label" },
+            { label: "Canastas recibidas", name: "total", type: "label" },
+            { label: "Enviadas a CC", name: "cc", type: "label" },
+        ];
+        return [joinedBaskets, totales, headers];
+    }, [purchaseOrder]);
+    return [basketsJoined, footerBasketsJoined, headersBasketsJoined];
+};
+/**
+ * Para imprimir en modo offline
+ * @param formInput
+ * @returns
+ */
+export const getBasketDetailsByForm = (formInput) => {
+    const basketDetailsArray = [];
+    // Regex para identificar los campos relevantes
+    const recPattern = /^rec\d+-(.+)$/;
+    const qCPattern = /^qC\d+-(.+)$/;
+    for (const key in formInput) {
+        if (formInput.hasOwnProperty(key)) {
+            let match;
+            // Comprobar si la clave es un campo "rec" y extraer el color y la cantidad
+            if ((match = recPattern.exec(key))) {
+                const color = match[1];
+                const total = Number(formInput[key] || 0);
+                const existingBasket = basketDetailsArray.find((item) => item.color === color);
+                if (existingBasket) {
+                    existingBasket.total += total;
+                }
+                else {
+                    basketDetailsArray.push({
+                        id: basketDetailsArray.length,
+                        total,
+                        color,
+                        cc: 0, // Inicializar cc a 0, se actualizará más adelante si existe
+                    });
+                }
+            }
+            // Comprobar si la clave es un campo "qC" y actualizar el campo cc correspondiente
+            if ((match = qCPattern.exec(key))) {
+                const color = match[1];
+                const cc = Number(formInput[key] || 0);
+                const existingBasket = basketDetailsArray.find((item) => item.color === color);
+                if (existingBasket) {
+                    existingBasket.cc += cc;
+                }
+            }
+        }
+    }
+    // Calcular los totales para footerBasketsDetails
+    const totales = {
+        id: "",
+        total: basketDetailsArray
+            .map((x) => x.total)
+            .reduce((acc, val) => acc + val, 0)
+            .toFixed(2),
+        cc: basketDetailsArray.map((x) => x.cc).reduce((acc, val) => acc + val, 0),
+    };
+    // Definir los encabezados de la tabla
+    const headers = [
+        { label: "Color", name: "color", type: "label" },
+        { label: "Canastas recibidas", name: "total", type: "label" },
+        { label: "Enviadas a CC", name: "cc", type: "label" },
+    ];
+    return { basketDetailsArray, totales, headers };
+};
+export const useGetProviderNameByPurchaseOrder = (payees, purchaseOrder) => {
+    const providerName = useMemo(() => {
+        const provider = payees.find((x) => x.id == purchaseOrder.payee_id);
+        if (provider) {
+            return `<${provider.id_number}> ${provider.tin ? `${provider.tin} | ` : ""}${provider.name}`;
+        }
+        return null;
+    }, [payees, purchaseOrder]);
+    return providerName;
+};
+export const useGetItemNameByPurchaseOrder = (items, purchaseOrder) => {
+    const itemName = useMemo(() => {
+        if (purchaseOrder.purchase_order_details.length > 0 && items.length > 0) {
+            const item = items.find((x) => x.id == purchaseOrder.purchase_order_details[0].item_id);
+            return `${item?.id} - ${item?.code} - ${item?.name}`;
+        }
+        return null;
+    }, [items, purchaseOrder]);
+    return itemName;
+};

package/dist/session.d.ts

@@ -0,0 +1,7 @@
+export type SERVER_CONFIG_TYPES = "sessionAttribute" | "environment" | "sessionVariable";
+/**
+ *
+ * @param attribute
+ * @returns
+ */
+export declare const useGetSessionAttribute: (name: string, type: SERVER_CONFIG_TYPES) => string;