@dashadmin/dash-admin 1.3.72 → 1.3.74-srcfree.1

package/src/components/misc/MuiSimpleJsonTable.tsx

@@ -1,279 +0,0 @@
-import {
-    Paper,
-    Table,
-    TableBody,
-    TableCell,
-    TableContainer,
-    TableHead,
-    TableRow,
-    List,
-    ListItem,
-    ListItemText,
-    Box,
-    Chip,
-    Accordion,
-    AccordionSummary,
-    AccordionDetails,
-    Typography,
-} from '@mui/material';
-import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
-import { isComponent } from 'dash-auto-admin';
-
-import React, { FC, JSX, useEffect, useState } from 'react';
-
-interface IDictEntry {
-    [x: string]: any;
-}
-
-export interface MUISimpleJsonTable {
-    tableData: any;
-    vertical: boolean;
-    ignore?: string[];
-    include?: string[];
-    dict?: IDictEntry;
-    showKey?: boolean;
-    maxDepth?: number;
-    currentDepth?: number;
-}
-
-function isJSXElement(value: any): value is JSX.Element {
-    return (
-        value &&
-        typeof value === "object" &&
-        value.$typeof === Symbol.for("react.element")
-    );
-}
-
-function isReactNode(value: any): value is React.ReactNode {
-    return (
-        typeof value === "string" ||
-        typeof value === "number" ||
-        typeof value === "boolean" ||
-        value instanceof React.Component ||
-        value instanceof React.Fragment ||
-        Array.isArray(value) && value.every((item) => isReactNode(item))
-    );
-}
-
-function isReactNodeArrayOrJSXElementArray(value: any): boolean {
-    return (
-        Array.isArray(value) &&
-        (value.every((item) => isReactNode(item)) ||
-            value.every((item) => isJSXElement(item)))
-    );
-}
-
-function isArrayOfStrings(value: any): boolean {
-    return Array.isArray(value) && value.every((item) => typeof item === 'string');
-}
-
-// Improved helper function to detect plain objects
-function isPlainObject(value: any): boolean {
-    if (value === null || value === undefined) {
-        return false;
-    }
-    
-    if (typeof value !== 'object') {
-        return false;
-    }
-    
-    if (Array.isArray(value)) {
-        return false;
-    }
-    
-    if (isJSXElement(value)) {
-        return false;
-    }
-    
-    // Check if it's a plain object (not a class instance, Date, etc.)
-    return value.constructor === Object || value.constructor === undefined;
-}
-
-const MUISimpleJsonTable: FC<MUISimpleJsonTable> = ({
-    tableData,
-    vertical,
-    ignore,
-    include,
-    dict,
-    showKey,
-    maxDepth = 3,
-    currentDepth = 0,
-}) => {
-    if (!ignore) ignore = [];
-    if (!include) include = [];
-    if (!dict) dict = {};
-    const [column, setColumn] = useState<string[]>([]);
-
-    useEffect(() => {
-        if (tableData) {
-            let cols = Object.keys(tableData);
-            if (include.length) cols = cols.filter((key) => include.includes(key));
-            if (ignore.length) cols = cols.filter((key) => !ignore.includes(key));
-            setColumn(cols);
-        } else {
-            setColumn([]);
-        }
-    }, [tableData]);
-
-    const parseValue = (value: any, key?: string) => {
-        try {
-            // Add debug logging
-            //console.log(`Parsing value for key "${key}":`, value, typeof value);
-            
-            if (value === undefined || value === null) {
-                return "n/a";
-            }
-
-            // Check for plain objects FIRST, before other checks
-            if (isPlainObject(value) && currentDepth < maxDepth) {
-                const objectKeys = Object.keys(value);
-                //console.log(`Found plain object with keys:`, objectKeys);
-                
-                if (objectKeys.length > 0) {
-                    return (
-                        <Accordion sx={{ width: '100%', boxShadow: 1, margin: 0 }}>
-                            <AccordionSummary
-                                expandIcon={<ExpandMoreIcon />}
-                                sx={{
-                                    backgroundColor: 'rgba(0, 0, 0, 0.03)',
-                                    minHeight: 40,
-                                    '&.Mui-expanded': {
-                                        minHeight: 40,
-                                    },
-                                }}
-                            >
-                                <Typography variant="body2" sx={{ fontWeight: 500 }}>
-                                    {key ? `${key} (${objectKeys.length} properties)` : `Object (${objectKeys.length} properties)`}
-                                </Typography>
-                            </AccordionSummary>
-                            <AccordionDetails sx={{ padding: 1 }}>
-                                <MUISimpleJsonTable
-                                    tableData={value}
-                                    vertical={vertical}
-                                    ignore={ignore}
-                                    include={include}
-                                    dict={dict}
-                                    showKey={showKey}
-                                    maxDepth={maxDepth}
-                                    currentDepth={currentDepth + 1}
-                                />
-                            </AccordionDetails>
-                        </Accordion>
-                    );
-                }
-            }
-
-            // Array handling
-            if (Array.isArray(value)) {
-                return (
-                    <Chip
-                        label={
-                            <Box sx={{ maxHeight: 200, overflow: 'auto', width: '100%' }}>
-                                <List dense sx={{ py: 0 }}>
-                                    {value.map((item, index) => (
-                                        <ListItem key={index} sx={{ py: 0.5, px: 1 }}>
-                                            <ListItemText 
-                                                primary={String(item)} 
-                                                sx={{ 
-                                                    margin: 0,
-                                                    '& .MuiListItemText-primary': {
-                                                        fontSize: '0.875rem',
-                                                        lineHeight: 1.2
-                                                    }
-                                                }}
-                                            />
-                                        </ListItem>
-                                    ))}
-                                </List>
-                            </Box>
-                        }
-                        sx={{ 
-                            height: 'auto',
-                            '& .MuiChip-label': {
-                                display: 'block',
-                                whiteSpace: 'normal'
-                            }
-                        }}
-                    />
-                );
-            }
-
-            // Primitive values
-            if (typeof value !== 'object') {
-                if (dict.hasOwnProperty(value)) {
-                    return dict[value];
-                }
-                return String(value);
-            }
-
-            // React components
-            if (isComponent(value) || isReactNodeArrayOrJSXElementArray(value)) {
-                return value;
-            }
-
-            // Fallback for other objects
-            if (typeof value === 'object') {
-                //console.log(`Falling back to JSON.stringify for:`, value);
-                return JSON.stringify(value);
-            }
-
-            return value;
-
-        } catch (error) {
-            //console.error('Error in parseValue:', error);
-            return "n/a";
-        }
-    };
-
-    const ThData = () => {
-        return (
-            column &&
-            column.map((data, key) => (
-                <TableCell key={key}>{parseValue(data)}</TableCell>
-            ))
-        );
-    };
-
-    const tdData = () => {
-        return vertical ? (
-            column &&
-            column.map((v, key) => {
-                return (
-                    <TableRow key={key}>
-                        {showKey && <TableCell>{parseValue(v)}</TableCell>}
-                        <TableCell>{parseValue(tableData[v], v)}</TableCell>
-                    </TableRow>
-                );
-            })
-        ) : (
-            <TableRow>
-                {column &&
-                    column.map((v, key) => {
-                        return <TableCell key={key}>{parseValue(tableData[v], v)}</TableCell>;
-                    })}
-            </TableRow>
-        );
-    };
-
-    // Add debug info at the top level
-    //console.log('MUISimpleJsonTable render:', { tableData, column, currentDepth, maxDepth });
-
-    return vertical ? (
-        <TableContainer component={Paper}>
-            <Table>
-                <TableBody>{tdData()}</TableBody>
-            </Table>
-        </TableContainer>
-    ) : (
-        <TableContainer component={Paper}>
-            <Table>
-                <TableHead>
-                    <TableRow>{ThData()}</TableRow>
-                </TableHead>
-                <TableBody>{tdData()}</TableBody>
-            </Table>
-        </TableContainer>
-    );
-};
-
-export default MUISimpleJsonTable;

package/src/components/misc/MultiLevelTable.tsx

@@ -1,229 +0,0 @@
-import React, { useEffect, useRef, useState } from 'react';
-
-export interface IMultiLevelTableAction {
-  name: string;
-  callback: () => any;
-}
-export interface IMultiLevelTable {
-  data: any;
-  structure: any;
-  actionLabel?: string;
-  actions?: IMultiLevelTableAction[];
-  className?: {
-    table?: string;
-    head?: string;
-    body?: string;
-  };
-}
-
-const getFields = (structure) => [
-  ...structure.children.map((child) => child.display),
-  ...(structure.array ? getFields(structure.array) : []),
-];
-
-const addSelfToFirstChild = (childRows, structure, row) => {
-  childRows[0] = [
-    ...structure.children.map((child) => ({
-      text: row[child.field],
-      span: childRows.length,
-    })),
-    ...childRows[0],
-  ];
-};
-
-const dropdown =
-  (getChain, actions, actionLabel) =>
-    ({ indices }) => {
-      const [show, setShow] = useState<boolean>(false);
-      const ref = useRef<HTMLElement>(null);
-
-      useEffect(() => {
-        const listener = (event) => {
-          if (!ref.current) return;
-          if (ref.current.contains(event.target)) return;
-          setShow(false);
-        };
-
-        document.addEventListener('click', listener);
-
-        return () => {
-          document.removeEventListener('click', listener);
-        };
-      }, [ref]);
-
-      const getClickHandler = (action) => () => {
-        action.callback(getChain(indices));
-        setShow(false);
-      };
-
-      return (
-        <span ref={ref}>
-          <span
-            onClick={(_) => setShow(!show)}
-            className='flex flex-row items-center justify-center cursor-pointer'
-          >
-            {actionLabel}
-            {show ? <span>↑</span> : <span>↓</span>}
-          </span>
-          {show && (
-            <div className='flex flex-col absolute right-0 bg-white rounded-md shadow-md gap-2 p-2 whitespace-nowrap border border-gray-300'>
-              {actions &&
-                actions.map((action) => (
-                  <span
-                    key={action.name}
-                    onClick={getClickHandler(action)}
-                    className='flex flex-row items-center cursor-pointer text-md hover:bg-gray-300 p-2 rounded-md'
-                  >
-                    {action.name}
-                  </span>
-                ))}
-            </div>
-          )}
-        </span>
-      );
-    };
-const createGetColumns = (getChain, actions, actionLabel) => {
-
-  const Dropdown = dropdown(getChain, actions, actionLabel);
-  return (structure, data, indices) => [
-    ...structure.children.map((child) => ({
-      text: data[child.field],
-      span: 1,
-    })),
-    ...(actions.length
-      ? [
-        {
-          text: <Dropdown indices={indices} />,
-          span: 1,
-        },
-      ]
-      : []),
-  ];
-};
-
-const createGetRows = (getColumns) => {
-  const getRows = (structure, rows, memoizedIndices) =>
-    rows && !structure.array
-      ? rows.map((row, i) =>
-        getColumns(structure, row, [...memoizedIndices, i]),
-      )
-      : rows
-        ? rows.flatMap((row, i) => {
-          const childRows = getRows(
-            structure.array,
-            row[structure.array.name],
-            [...memoizedIndices, i], // Use a linked list of a wrapper to optimise this
-          );
-          childRows && addSelfToFirstChild(childRows, structure, row);
-          return childRows;
-        })
-        : null;
-
-  return getRows;
-};
-
-const getChain = (indices, structure, data) => {
-  const chain = {};
-  indices.forEach((i) => {
-    chain[structure.name] = data[i];
-    structure = structure.array;
-    data = structure && data[i][structure.name];
-  });
-  return chain;
-};
-
-const createGetChain = (structure, data) => (indices) =>
-  getChain(indices, structure, data);
-
-const TableHeader = ({ classNames, fields }) => (
-  <thead className={classNames?.head}>
-    <tr>
-      {fields.map((name) => (
-        <th className={classNames?.headCell + ' p-2 py-3'} key={name}>
-          {name}
-        </th>
-      ))}
-    </tr>
-  </thead>
-);
-
-const TableBody = ({ classNames, rows }) => (
-  <tbody className={classNames?.tableBody}>
-    {rows &&
-      rows.map((row, i) => (
-        <tr className={classNames?.tableRow} key={i}>
-          {row &&
-            row.map((col, j) => (
-              <td key={j} rowSpan={col.span}>
-                {col.text}
-              </td>
-            ))}
-        </tr>
-      ))}
-  </tbody>
-);
-
-const MultiLevelTable: React.FC<IMultiLevelTable> = ({
-  data,
-  structure,
-  actions,
-  actionLabel,
-  className,
-}) => {
-
-
-  const _actions = actions || [];
-  const _actionLabel = actionLabel || 'Action';
-
-
-  const getChain = createGetChain(structure, data);
-  const getColumns = createGetColumns(getChain, _actions, _actionLabel);
-  const getRows = createGetRows(getColumns);
-
-  const rows = getRows(structure, data, []);
-  const fields = [
-    ...getFields(structure),
-    ...(_actions.length ? [_actionLabel] : []),
-  ];
-
-  return (
-    rows && (
-      <table className={className?.table}>
-        <TableHeader fields={fields} classNames={className} />
-        <TableBody rows={rows} classNames={className} />
-      </table>
-    )
-  );
-};
-
-export default MultiLevelTable;
-
-/*
-MultiLevelTable.propTypes = {
-    data: PropTypes.arrayOf(PropTypes.object).isRequired,
-    structure: PropTypes.object.isRequired,
-    actionLabel: PropTypes.string,
-    actions: PropTypes.arrayOf(
-        PropTypes.exact({
-            name: PropTypes.string.isRequired,
-            callback: PropTypes.func.isRequired
-        })
-    ),
-    className: PropTypes.exact({
-        table: PropTypes.string,
-        head: PropTypes.string,
-        body: PropTypes.string
-    })
-}
-*/
-/*
-MultiLevelTable.defaultProps = {
-  actionLabel: 'Action',
-  actions: [],
-  className: {
-    table: 'w-full shadow-sm overflow-hidden rounded-lg text-center',
-    head: 'text-white bg-gray-700 text-center',
-    body: 'p-2 border-solid border border-light-blue-300',
-  },
-};
-*/

package/src/components/misc/NoResults.tsx

@@ -1,28 +0,0 @@
-import * as React from 'react';
-
-import { Card, CardContent, Typography } from '@mui/material';
-import InfoIcon from '@mui/icons-material/Info'	
-
-export interface INoResults extends React.PropsWithChildren {
-    title?: string;
-    description?: string;
-}
-export const NoResults: React.FC<INoResults> = (props) => {
-
-    const { title, description, children } = props;
-
-	return (
-        <Card sx={{ p: 0 }}>
-            <CardContent sx={{ display: 'flex', flexDirection: 'column', alignItems: 'left', gap: 2 }}>
-				<div style={{ display: 'flex', alignItems: 'center', gap: 2 }}>
-					<InfoIcon sx={{ fontSize: 32 }} />
-				{title ? <Typography variant="h5">{title}</Typography> : "No hay registros"}
-				</div>
-				{description && <Typography variant="body1" sx={{
-                    color: "text.secondary"
-                }}>{description}</Typography>}
-				{children ? children : <></>}
-			</CardContent>
-        </Card>
-    );
-};

package/src/components/misc/PDFViewer.tsx

@@ -1,85 +0,0 @@
-import { Button } from '@mui/material';
-import React, { useEffect, useState } from 'react';
-import { useRecordContext } from 'react-admin';
-import { Loading } from 'react-admin';
-import { initAxios } from '../../hooks/axios';
-import { saveAs } from 'file-saver';
-import { IDashAutoAdminCustomFieldComponent } from 'dash-auto-admin';
-
-const PDFViewerView: React.FC<IDashAutoAdminCustomFieldComponent> = ({
-	method,
-	attribute,
-}) => {
-	const record = useRecordContext();
-
-	const axios = initAxios();
-
-	const [PDFFile, setPDFFile] = useState<string>(null);
-
-	const filePath =
-		record && record[attribute.attribute] ? record[attribute.attribute] : null;
-	const fileName = 'nota-venta-' + record.id + '.pdf';
-
-	useEffect(() => {
-		record && record[attribute.attribute] && displayDocument();
-	}, [record]);
-
-	const displayDocument = async () => {
-		const { data } = await axios.get(filePath, {
-			responseType: 'blob',
-		});
-
-		const file = new Blob([data], {
-			type: 'application/pdf',
-		});
-
-		const fileURL = URL.createObjectURL(file);
-
-		setPDFFile(fileURL);
-	};
-
-	const downloadDocument = async () => {
-		const { data } = await axios.get(filePath, {
-			responseType: 'blob',
-		});
-
-		const file = new Blob([data], {
-			type: '',
-		});
-
-		saveAs(file, fileName);
-	};
-
-	return (
-		<>
-			{PDFFile ? (
-				<div>
-					<object
-						className='embed-pdf'
-						data={PDFFile}
-						type='application/pdf'
-						style={{ minHeight: 800, minWidth: 600 }}
-					>
-						<embed src={PDFFile} type='application/pdf' />
-					</object>
-					<hr />
-					<Button onClick={downloadDocument}>Descargar</Button>
-				</div>
-			) : (
-				<Loading />
-			)}
-		</>
-	);
-};
-
-const PDFViewer = ({ method, attribute, resourceConfig }: IDashAutoAdminCustomFieldComponent) => {
-	switch (method) {
-		case 'edit':
-		case 'create':
-			return <>edit</>;
-		case 'view':
-			return <PDFViewerView attribute={attribute} method={method} resourceConfig={resourceConfig} />;
-	}
-};
-
-export default PDFViewer;