@applica-software-guru/react-admin 1.3.143 → 1.3.145

package/src/components/ra-lists/Datagrid/Datagrid.tsx

@@ -0,0 +1,345 @@
+import {
+  DatagridProps as RaDatagridProps,
+  DatagridHeader,
+  DatagridLoading,
+  DatagridBody,
+  PureDatagridBody,
+  BulkDeleteButton,
+  ListNoResults,
+  DatagridClasses,
+  DatagridRoot
+} from 'react-admin';
+
+import * as React from 'react';
+import { cloneElement, createElement, isValidElement, useCallback, useRef, useEffect, FC, useMemo } from 'react';
+import PropTypes from 'prop-types';
+import { sanitizeListRestProps, useListContext, Identifier } from 'ra-core';
+import { Table } from '@mui/material';
+import clsx from 'clsx';
+import union from 'lodash/union';
+import difference from 'lodash/difference';
+import DatagridContextProvider from './DatagridContextProvider';
+import BulkActionsToolbar from '../BulkActionsToolbar';
+
+const defaultBulkActionButtons = <BulkDeleteButton />;
+
+export type DatagridProps = RaDatagridProps & {
+  /**
+   * An alternative to bulkActionButtons, to be used when the actions are too complex to be expressed.
+   * In this case you are free to fully control the rendering of the bulk actions toolbar.
+   * @see BulkActionsToolbar
+   * @example <caption>Using the BulkActionsToolbar component</caption>
+   * import { BulkActionsToolbar } from '@applica-software-guru/react-admin';
+   * import { BulkDeleteButton } from 'react-admin';
+   *
+   * const PostBulkActionButtons = props => (
+   *    <BulkActionsToolbar {...props}>
+   *       <BulkDeleteButton />
+   *      // add your custom actions here
+   *   </BulkActionsToolbar>
+   * );
+   *
+   * @example <caption>Using BulkFloatingActionsToolbar component</caption>
+   * import { BulkActionsToolbar } from '@applica-software-guru/react-admin';
+   * import { BulkDeleteButton } from 'react-admin';
+   *
+   * const PostBulkActionButtons = props => (
+   *   <BulkActionsToolbar {...props}>
+   *      <BulkDeleteButton />
+   *     // add your custom actions here
+   *   </BulkActionsToolbar>
+   * );
+   *
+   */
+  bulkActionsToolbar: React.ReactNode | React.FC | boolean;
+};
+
+/**
+ * The Datagrid component renders a list of records as a table.
+ * It is usually used as a child of the <List> and <ReferenceManyField> components.
+ *
+ * Props:
+ *  - body
+ *  - bulkActionButtons
+ *  - children
+ *  - empty
+ *  - expand
+ *  - header
+ *  - hover
+ *  - isRowExpandable
+ *  - isRowSelectable
+ *  - optimized
+ *  - rowClick
+ *  - rowSx
+ *  - size
+ *  - sx
+ *
+ * @example // Display all posts as a datagrid
+ * const postRowSx = (record, index) => ({
+ *     backgroundColor: record.nb_views >= 500 ? '#efe' : 'white',
+ * });
+ * export const PostList = () => (
+ *     <List>
+ *         <Datagrid rowSx={postRowSx}>
+ *             <TextField source="id" />
+ *             <TextField source="title" />
+ *             <TextField source="body" />
+ *             <EditButton />
+ *         </Datagrid>
+ *     </List>
+ * );
+ *
+ * @example // Display all the comments of the current post as a datagrid
+ * <ReferenceManyField reference="comments" target="post_id">
+ *     <Datagrid>
+ *         <TextField source="id" />
+ *         <TextField source="body" />
+ *         <DateField source="created_at" />
+ *         <EditButton />
+ *     </Datagrid>
+ * </ReferenceManyField>
+ *
+ * @example // Usage outside of a <List> or a <ReferenceManyField>.
+ *
+ * const sort = { field: 'published_at', order: 'DESC' };
+ *
+ * export const MyCustomList = (props) => {
+ *     const { data, total, isLoading } = useGetList(
+ *         'posts',
+ *         { pagination: { page: 1, perPage: 10 }, sort: sort }
+ *     );
+ *
+ *     return (
+ *         <Datagrid
+ *             data={data}
+ *             total={total}
+ *             isLoading={isLoading}
+ *             sort={sort}
+ *             selectedIds={[]}
+ *             setSort={() => {
+ *                 console.log('set sort');
+ *             }}
+ *             onSelect={() => {
+ *                 console.log('on select');
+ *             }}
+ *             onToggleItem={() => {
+ *                 console.log('on toggle item');
+ *             }}
+ *         >
+ *             <TextField source="id" />
+ *             <TextField source="title" />
+ *         </Datagrid>
+ *     );
+ * }
+ */
+export const Datagrid: FC<DatagridProps> = React.forwardRef((props, ref) => {
+  const {
+    optimized = false,
+    body = optimized ? PureDatagridBody : DatagridBody,
+    header = DatagridHeader,
+    children,
+    className,
+    empty = DefaultEmpty,
+    expand,
+    bulkActionsToolbar = false,
+    bulkActionButtons = defaultBulkActionButtons,
+    hover,
+    isRowSelectable,
+    isRowExpandable,
+    resource,
+    rowClick,
+    rowSx,
+    rowStyle,
+    size = 'small',
+    sx,
+    expandSingle = false,
+    ...rest
+  } = props;
+
+  const { sort, data, isLoading, onSelect, onToggleItem, selectedIds, setSort, total } = useListContext(props);
+
+  const hasBulkActions = !!bulkActionButtons !== false;
+
+  const contextValue = useMemo(() => ({ isRowExpandable, expandSingle }), [isRowExpandable, expandSingle]);
+
+  const lastSelected = useRef(null);
+
+  useEffect(() => {
+    if (!selectedIds || selectedIds.length === 0) {
+      lastSelected.current = null;
+    }
+  }, [JSON.stringify(selectedIds)]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  // we manage row selection at the datagrid level to allow shift+click to select an array of rows
+  const handleToggleItem = useCallback(
+    // @ts-ignore
+    (id, event) => {
+      const ids = data.map((record) => record.id);
+      const lastSelectedIndex = ids.indexOf(lastSelected.current);
+      lastSelected.current = event.target.checked ? id : null;
+
+      if (event.shiftKey && lastSelectedIndex !== -1) {
+        const index = ids.indexOf(id);
+        const idsBetweenSelections = ids.slice(Math.min(lastSelectedIndex, index), Math.max(lastSelectedIndex, index) + 1);
+
+        const newSelectedIds = event.target.checked
+          ? union(selectedIds, idsBetweenSelections)
+          : difference(selectedIds, idsBetweenSelections);
+
+        onSelect(
+          isRowSelectable
+            ? newSelectedIds.filter((id: Identifier) => isRowSelectable(data.find((record) => record.id === id)))
+            : newSelectedIds
+        );
+      } else {
+        onToggleItem(id);
+      }
+    },
+    [data, isRowSelectable, onSelect, onToggleItem, selectedIds]
+  );
+
+  if (isLoading === true) {
+    return (
+      <DatagridLoading
+        className={className}
+        expand={expand}
+        hasBulkActions={hasBulkActions}
+        nbChildren={React.Children.count(children)}
+        size={size}
+      />
+    );
+  }
+
+  /**
+   * Once loaded, the data for the list may be empty. Instead of
+   * displaying the table header with zero data rows,
+   * the Datagrid displays the empty component.
+   */
+  if (data == null || data.length === 0 || total === 0) {
+    if (empty) {
+      return empty;
+    }
+
+    return null;
+  }
+
+  /**
+   * After the initial load, if the data for the list isn't empty,
+   * and even if the data is refreshing (e.g. after a filter change),
+   * the datagrid displays the current data.
+   */
+  return (
+    <DatagridContextProvider value={contextValue}>
+      <DatagridRoot sx={sx} className={clsx(DatagridClasses.root, className)}>
+        {bulkActionsToolbar != null && isValidElement(bulkActionsToolbar) ? (
+          cloneElement<any>(bulkActionsToolbar, {
+            selectedIds,
+            total
+          })
+        ) : bulkActionButtons !== false ? (
+          <BulkActionsToolbar>{isValidElement(bulkActionButtons) ? bulkActionButtons : defaultBulkActionButtons}</BulkActionsToolbar>
+        ) : null}
+        <div className={DatagridClasses.tableWrapper}>
+          <Table ref={ref} className={DatagridClasses.table} size={size} {...sanitizeRestProps(rest)}>
+            {createOrCloneElement(
+              header,
+              {
+                children,
+                sort,
+                data,
+                hasExpand: !!expand,
+                hasBulkActions,
+                isRowSelectable,
+                onSelect,
+                resource,
+                selectedIds,
+                setSort
+              },
+              children
+            )}
+            {createOrCloneElement(
+              body,
+              {
+                expand,
+                rowClick,
+                data,
+                hasBulkActions,
+                hover,
+                onToggleItem: handleToggleItem,
+                resource,
+                rowSx,
+                rowStyle,
+                selectedIds,
+                isRowSelectable
+              },
+              children
+            )}
+          </Table>
+        </div>
+      </DatagridRoot>
+    </DatagridContextProvider>
+  );
+});
+
+// @ts-ignore
+const createOrCloneElement = (element, props, children) =>
+  isValidElement(element) ? cloneElement(element, props, children) : createElement(element, props, children);
+
+Datagrid.propTypes = {
+  // @ts-ignore
+  body: PropTypes.oneOfType([PropTypes.element, PropTypes.elementType]),
+  // @ts-ignore-line
+  bulkActionButtons: PropTypes.oneOfType([PropTypes.bool, PropTypes.element]),
+  children: PropTypes.node.isRequired,
+  className: PropTypes.string,
+  // @ts-ignore
+  sort: PropTypes.exact({
+    field: PropTypes.string,
+    order: PropTypes.oneOf(['ASC', 'DESC'] as const)
+  }),
+  data: PropTypes.arrayOf(PropTypes.any),
+  empty: PropTypes.element,
+  // @ts-ignore
+  expand: PropTypes.oneOfType([PropTypes.element, PropTypes.elementType]),
+  // @ts-ignore
+  header: PropTypes.oneOfType([PropTypes.element, PropTypes.elementType]),
+  hover: PropTypes.bool,
+  isLoading: PropTypes.bool,
+  onSelect: PropTypes.func,
+  onToggleItem: PropTypes.func,
+  resource: PropTypes.string,
+  // @ts-ignore
+  rowClick: PropTypes.oneOfType([PropTypes.string, PropTypes.func, PropTypes.bool]),
+  rowSx: PropTypes.func,
+  rowStyle: PropTypes.func,
+  selectedIds: PropTypes.arrayOf(PropTypes.any),
+  setSort: PropTypes.func,
+  total: PropTypes.number,
+  isRowSelectable: PropTypes.func,
+  isRowExpandable: PropTypes.func,
+  expandSingle: PropTypes.bool
+};
+
+const injectedProps = [
+  'isRequired',
+  'setFilter',
+  'setPagination',
+  'limitChoicesToValue',
+  'translateChoice',
+  // Datagrid may be used as an alternative to SelectInput
+  'field',
+  'fieldState',
+  'formState'
+];
+
+// @ts-ignore
+const sanitizeRestProps = (props) =>
+  Object.keys(sanitizeListRestProps(props))
+    .filter((propName) => !injectedProps.includes(propName))
+    .reduce((acc, key) => ({ ...acc, [key]: props[key] }), {});
+
+Datagrid.displayName = 'Datagrid';
+
+const DefaultEmpty = <ListNoResults />;
+
+export default Datagrid;

package/src/components/ra-lists/Datagrid/DatagridContext.ts

@@ -0,0 +1,13 @@
+import { createContext } from 'react';
+import { RaRecord } from 'ra-core';
+
+const DatagridContext = createContext<DatagridContextValue>({});
+
+DatagridContext.displayName = 'DatagridContext';
+
+export type DatagridContextValue = {
+    isRowExpandable?: (record: RaRecord) => boolean;
+    expandSingle?: boolean;
+};
+
+export default DatagridContext;

package/src/components/ra-lists/Datagrid/DatagridContextProvider.tsx

@@ -0,0 +1,8 @@
+import React, { ReactElement, ReactNode } from 'react';
+import DatagridContext, { DatagridContextValue } from './DatagridContext';
+
+const DatagridContextProvider = ({ children, value }: { children: ReactNode; value: DatagridContextValue }): ReactElement => (
+  <DatagridContext.Provider value={value}>{children}</DatagridContext.Provider>
+);
+
+export default DatagridContextProvider;

package/src/components/ra-lists/{Datagrid.tsx → Datagrid/index.tsx}

@@ -1,8 +1,9 @@
-import { DatagridProps, Datagrid as RaDatagrid } from 'react-admin';
+import { Datagrid as RaDatagrid } from './Datagrid';
+import { DatagridProps } from 'react-admin';
 
 import { styled } from '@mui/material/styles';
 
-const ApplicaStyledDatagrid = styled(RaDatagrid, {
+const StyledDatagrid = styled(RaDatagrid, {
   name: 'ApplicaDatagrid',
   slot: 'root'
 })(() => ({
@@ -40,13 +41,9 @@ const ApplicaStyledDatagrid = styled(RaDatagrid, {
  * @param {DatagridProps} props
  * @returns {JSX.Element}
  */
-const Datagrid = (props: DatagridProps): JSX.Element => <ApplicaStyledDatagrid {...props} />;
-
-Datagrid.propTypes = {
-  ...RaDatagrid.propTypes
-};
-Datagrid.defaultProps = {
-  ...RaDatagrid.defaultProps
+const Datagrid = (props: DatagridProps): JSX.Element => {
+  // @ts-ignore
+  return <StyledDatagrid {...props} />;
 };
 
 export default Datagrid;

package/src/components/ra-lists/index.ts

@@ -1,5 +1,6 @@
-import Datagrid from './Datagrid';
-import Empty from './Empty';
-import List from './List';
-import NotificationList from './NotificationList';
-export { Datagrid, Empty, NotificationList, List };
+export { default as Datagrid } from './Datagrid';
+export { default as Empty } from './Empty';
+export { default as NotificationList } from './NotificationList';
+export { default as List } from './List';
+export { default as BulkActionsToolbar } from './BulkActionsToolbar';
+export { default as BulkFloatingActionsToolbar } from './BulkFloatingActionsToolbar';

package/src/playground/components/ra-forms/TestModelForm.jsx

@@ -0,0 +1,18 @@
+import { LongForm, MainCard, TextInput } from '@applica-software-guru/react-admin';
+import { Grid } from '@mui/material';
+
+const TestModelForm = () => (
+  <LongForm>
+    <LongForm.Tab id="root" label="Root">
+      <MainCard title="Info">
+        <Grid container spacing={2}>
+          <Grid item xs={12}>
+            <TextInput source="name" fullWidth />
+          </Grid>
+        </Grid>
+      </MainCard>
+    </LongForm.Tab>
+  </LongForm>
+);
+
+export default TestModelForm;

package/vite.config.js

@@ -15,14 +15,14 @@ export default defineConfig((configEnv) => ({
     }
   },
   plugins: [
-    dts({
-      include: ['./src/**/*.{js,jsx,ts,tsx}']
-    }),
-    react(),
-    linterPlugin({
-      include: ['./src/**/*.{js,jsx,ts,tsx}'],
-      linters: [new EsLinter({ configEnv })]
-    })
+    // dts({
+    //   include: ['./src/**/*.{js,jsx,ts,tsx}']
+    // }),
+    react()
+    // linterPlugin({
+    //   include: ['./src/**/*.{js,jsx,ts,tsx}'],
+    //   linters: [new EsLinter({ configEnv })]
+    // })
   ],
   optimizeDeps: {
     include: ['react', 'react-dom', 'react-admin', 'ra-ui-materialui', 'ra-core', 'ra-i18n-polyglot']

package/dist/Admin.d.ts

@@ -1,10 +0,0 @@
-export default Admin;
-declare function Admin(props: any): import("react/jsx-runtime").JSX.Element;
-declare namespace Admin {
-    namespace defaultProps {
-        const store: import("react-admin").Store;
-        const title: string;
-    }
-    const propTypes: any;
-}
-//# sourceMappingURL=Admin.d.ts.map

package/dist/Admin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Admin.d.ts","sourceRoot":"","sources":["../../src/Admin.jsx"],"names":[],"mappings":";AAIA,4EAmDC"}

package/dist/AdminContext.d.ts

@@ -1,10 +0,0 @@
-import { CoreAdminContextProps } from 'react-admin';
-export type AdminContextProps = CoreAdminContextProps & {
-    theme?: any;
-};
-declare const AdminContext: {
-    ({ children, theme, ...props }: AdminContextProps): import("react/jsx-runtime").JSX.Element;
-    displayName: string;
-};
-export default AdminContext;
-//# sourceMappingURL=AdminContext.d.ts.map

package/dist/AdminContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AdminContext.d.ts","sourceRoot":"","sources":["../../src/AdminContext.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAoB,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAKtE,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,GAAG;IACtD,KAAK,CAAC,EAAE,GAAG,CAAC;CACb,CAAC;AACF,QAAA,MAAM,YAAY;oCAAmC,iBAAiB;;CASrE,CAAC;AAIF,eAAe,YAAY,CAAC"}

package/dist/ApplicaAdmin.d.ts

@@ -1,142 +0,0 @@
-import { AdminProps, AuthProvider, DataProvider } from 'react-admin';
-import { ThemeConfig } from './contexts';
-import React from 'react';
-import { MenuProps } from './types';
-import { IErrorEventHandler } from './dev/ErrorEventHandler';
-export type ApplicaAdminProps = AdminProps & {
-    /**
-     * Eventuali configurazioni aggiuntive da passare al tema.
-     * @remarks Questo tema è basato su Mantis Theme (https://mantisdashboard.io/)
-     *
-     * @see https://marmelab.com/react-admin/Theming.html
-     * @see https://material-ui.com/customization/theming/
-     */
-    theme: any;
-    /**
-     * Consente di personalizzare ulteriormente il tema in base alle specifiche esposte dal tema stesso.
-     * Divertiti con cautela a modificare variabili di configurazione del tema, se fai un casino Marco Colucci potrebbe usare l'estintore (ho detto tutto).
-     */
-    themeConfig: ThemeConfig;
-    /**
-     * URL dell'API da utilizzare nell'applicazione.
-     * Sebbene venga già definito un dataProvider ed authProvider di default, è possibile che l'app
-     * utilizzi l'apiUrl specificato per ulteriori operazioni (es. getstione delle notifiche).
-     */
-    apiUrl: string;
-    /**
-     * La lingua di default da utilizzare nell'applicazione.
-     */
-    defaultLocale: string;
-    /**
-     * Se impostato a true, l'applicazione lavora in modalità sviluppo.
-     * La modalità sviluppo è utile per effettuare test e debug ed esegue attività che non sono
-     * consigliate in produzione (es. cattura e inoltro dei messaggi non localizzati).
-     */
-    development: boolean;
-    /**
-     * Il logo da visualizzare nella barra laterale quando il menu è espanso lateralmente.
-     */
-    logoMain: any;
-    /**
-     * Eventuale logo da visualizzare nella barra laterale quando il menu è ridotto lateralmente.
-     */
-    logoIcon: any;
-    /**
-     * Configurazione del menu da visualizzare nell'applicazione.
-     */
-    menu: MenuProps;
-    /**
-     * Nome dell'applicazione da mostrare nell'header.
-     */
-    name: string;
-    /**
-     * Testo da mostrare nel footer. Default: '© Applica Software Guru for'.
-     */
-    copy: string;
-    /**
-     * Versione dell'applicazione da mostrare nel footer.
-     */
-    version: string;
-    /**
-     * Il provider di autenticazione da utilizzare nell'applicazione.
-     */
-    dataProvider: DataProvider;
-    /**
-     * Il provider di dati da utilizzare nell'applicazione.
-     */
-    authProvider: AuthProvider;
-    /**
-     * Indica l'eventuale handler da utilizzare per la gestione degli errori.
-     * Di default è eseguita una chiamata PUT /api/ui/error con il messaggio di errore "error".
-     * Puoi implementare un tuo handler per gestire gli errori in modo diverso.
-     */
-    errorHandler?: IErrorEventHandler | undefined;
-    /**
-     * Indica il componente da visualizzare in caso di errore.
-     */
-    error: React.Component;
-    /**
-     * Indica il nome della risorsa REST da utilizzare per la gestione delle notifiche.
-     * @default "entities/notification"
-     * @example
-     * // In questo caso, le notifiche verranno gestite tramite la risorsa "entities/notification"
-     * <ApplicaAdmin notification="entities/notification" />
-     */
-    notification: string;
-    /**
-     * Indica se le notifiche devono essere disabilitate.
-     * Se le notifiche sono abilitate comparirà automaticamente un'icona in alto a destra nell'header.
-     *
-     * @example
-     * <ApplicaAdmin enableNotification />
-     */
-    enableNotification: boolean;
-    /**
-     * Indica se la schermata di registrazione deve essere disabilitata.
-     * Se abilitata è necessario registrare una pagina, nelle rotte, che punti a /register
-     *
-     * @example
-     * // Pagina di base realizzata da Applica
-     * import { RegisterPage } from '.';
-     * <CustomRoutes noLayout>
-     *  <Route path="/register" component={RegisterPage} />
-     * </CustomRoutes>
-     */
-    enableRegistration: boolean;
-    /**
-     * Indica se la schermata di recupero password deve essere disabilitata.
-     * Se abilitata è necessario registrare una pagina, nelle rotte, che punti a /recover
-     *
-     * @example
-     * // Pagina di base realizzata da Applica
-     * import { RecoverPage } from '.';
-     * <CustomRoutes noLayout>
-     *  <Route path="/recover" component={RecoverPage} />
-     * </CustomRoutes>
-     */
-    enablePasswordRecover: boolean;
-};
-/**
- * Definisce un'applicazione super figa basata su React Admin, Mantis Theme ed il nostro stile.
- * @param {ApplicaAdminProps}
- * @returns {React.ReactElement}
- */
-declare const ApplicaAdmin: {
-    ({ theme, themeConfig, apiUrl, defaultLocale, development, logoMain, logoIcon, loginPage, menu, name, copy, version, dataProvider, authProvider, errorHandler, error, notification, enableNotification, enableRegistration, enablePasswordRecover, ...props }: ApplicaAdminProps): import("react/jsx-runtime").JSX.Element;
-    defaultProps: {
-        fileFields: never[];
-        defaultLocale: string;
-        development: boolean;
-        version: string;
-        notification: string;
-        enableNotification: boolean;
-        enableRegistration: boolean;
-        enableForgotPassword: boolean;
-        loginPage: import("react/jsx-runtime").JSX.Element;
-        store: import("react-admin").Store;
-        title: string;
-    };
-    propTypes: any;
-};
-export default ApplicaAdmin;
-//# sourceMappingURL=ApplicaAdmin.d.ts.map

package/dist/ApplicaAdmin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ApplicaAdmin.d.ts","sourceRoot":"","sources":["../../src/ApplicaAdmin.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EAAwD,WAAW,EAAuB,MAAM,YAAY,CAAC;AAGpH,OAAO,KAAkB,MAAM,OAAO,CAAC;AAGvC,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAIpC,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAS7D,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG;IAC3C;;;;;;OAMG;IACH,KAAK,EAAE,GAAG,CAAC;IACX;;;OAGG;IACH,WAAW,EAAE,WAAW,CAAC;IACzB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB;;OAEG;IACH,QAAQ,EAAE,GAAG,CAAC;IACd;;OAEG;IACH,QAAQ,EAAE,GAAG,CAAC;IACd;;OAEG;IACH,IAAI,EAAE,SAAS,CAAC;IAChB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,YAAY,EAAE,YAAY,CAAC;IAC3B;;OAEG;IACH,YAAY,EAAE,YAAY,CAAC;IAC3B;;;;OAIG;IACH,YAAY,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;IAC9C;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC;IACvB;;;;;;OAMG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAC5B;;;;;;;;;;OAUG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAC5B;;;;;;;;;;OAUG;IACH,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC;AAEF;;;;GAIG;AACH,QAAA,MAAM,YAAY;mQAsBf,iBAAiB;;;;;;;;;;;;;;;CAgGnB,CAAC;AAkCF,eAAe,YAAY,CAAC"}

package/dist/components/@extended/AnimateButton.d.ts

@@ -1,22 +0,0 @@
-declare function AnimateButton({ children, type, direction, offset, scale }: {
-    children: any;
-    type?: string | undefined;
-    direction?: string | undefined;
-    offset?: number | undefined;
-    scale?: {
-        hover: number;
-        tap: number;
-    } | undefined;
-}): import("react/jsx-runtime").JSX.Element;
-declare namespace AnimateButton {
-    namespace propTypes {
-        const children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
-        const offset: PropTypes.Requireable<number>;
-        const type: PropTypes.Requireable<string>;
-        const direction: PropTypes.Requireable<string>;
-        const scale: PropTypes.Requireable<NonNullable<number | object | null | undefined>>;
-    }
-}
-export default AnimateButton;
-import PropTypes from 'prop-types';
-//# sourceMappingURL=AnimateButton.d.ts.map

package/dist/components/@extended/AnimateButton.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AnimateButton.d.ts","sourceRoot":"","sources":["../../../../src/components/@extended/AnimateButton.jsx"],"names":[],"mappings":"AAOA;;;;;;;;;4CAwEC;;;;;;;;;;;sBA/EqB,YAAY"}

package/dist/components/@extended/Avatar.d.ts

@@ -1,20 +0,0 @@
-declare function Avatar({ variant, children, color, type, size, ...others }: {
-    [x: string]: any;
-    variant?: string | undefined;
-    children: any;
-    color?: string | undefined;
-    type: any;
-    size?: string | undefined;
-}): import("react/jsx-runtime").JSX.Element;
-declare namespace Avatar {
-    namespace propTypes {
-        const children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
-        const color: PropTypes.Requireable<string>;
-        const type: PropTypes.Requireable<string>;
-        const size: PropTypes.Requireable<string>;
-        const variant: PropTypes.Requireable<string>;
-    }
-}
-export default Avatar;
-import PropTypes from 'prop-types';
-//# sourceMappingURL=Avatar.d.ts.map

package/dist/components/@extended/Avatar.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Avatar.d.ts","sourceRoot":"","sources":["../../../../src/components/@extended/Avatar.jsx"],"names":[],"mappings":"AAqGA;;;;;;;4CAQC;;;;;;;;;;;sBAzGqB,YAAY"}