@akbarsafari00/bonyan-content-manager 5.52.1-fa.2

package/dist/admin/pages/ListView/ListViewPage.mjs

@@ -0,0 +1,634 @@
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import * as React from 'react';
+import { useRBAC, Page, useTracking, useNotification, useClipboard, useAPIErrorHandler, useIsMobile, useScopedPersistentState, useQueryParams, useStrapiApp, SearchInput, Layouts, tours, BackButton, Table, Pagination, useTable } from '@strapi/admin/strapi-admin';
+import { Box, EmptyStateLayout, Flex, Typography, IconButton, Button } from '@strapi/design-system';
+import { Duplicate, Plus } from '@strapi/icons';
+import { EmptyDocuments } from '@strapi/icons/symbols';
+import { stringify } from 'qs';
+import { useIntl } from 'react-intl';
+import { useParams, useNavigate, Link } from 'react-router-dom';
+import { styled } from 'styled-components';
+import { InjectionZone } from '../../components/InjectionZone.mjs';
+import { HOOKS } from '../../constants/hooks.mjs';
+import { PERMISSIONS } from '../../constants/plugin.mjs';
+import { DocumentRBAC, useDocumentRBAC } from '../../features/DocumentRBAC.mjs';
+import { useDoc } from '../../hooks/useDocument.mjs';
+import { useDocumentLayout, convertListLayoutToFieldLayouts } from '../../hooks/useDocumentLayout.mjs';
+import { usePersistentPartialQueryParams } from '../../hooks/usePersistentQueryParams.mjs';
+import { usePrev } from '../../hooks/usePrev.mjs';
+import { useGetAllDocumentsQuery } from '../../services/documents.mjs';
+import { buildValidParams } from '../../utils/api.mjs';
+import { getTranslation } from '../../utils/translations.mjs';
+import { getDisplayName } from '../../utils/users.mjs';
+import { DocumentStatus } from '../EditView/components/DocumentStatus.mjs';
+import { BulkActionsRenderer } from './components/BulkActions/Actions.mjs';
+import { listViewFilters } from './components/Filters.mjs';
+import { TableActions } from './components/TableActions.mjs';
+import { CellContent, hasContent } from './components/TableCells/CellContent.mjs';
+import { ViewSettingsMenu } from './components/ViewSettingsMenu.mjs';
+
+const { INJECT_COLUMN_IN_TABLE } = HOOKS;
+/* -------------------------------------------------------------------------------------------------
+ * ListViewPage
+ * -----------------------------------------------------------------------------------------------*/ const LayoutsHeaderCustom = styled(Layouts.Header)`
+  overflow-wrap: anywhere;
+`;
+const ListViewPage = ()=>{
+    const { trackUsage } = useTracking();
+    const navigate = useNavigate();
+    const { formatMessage } = useIntl();
+    const { toggleNotification } = useNotification();
+    const { copy } = useClipboard();
+    const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler(getTranslation);
+    const isMobile = useIsMobile();
+    const handleCopyDocumentId = React.useCallback(async (e, documentId)=>{
+        e.stopPropagation();
+        if (!documentId) return;
+        const didCopy = await copy(documentId);
+        if (didCopy) {
+            toggleNotification({
+                type: 'success',
+                message: formatMessage({
+                    id: 'content-manager.actions.copy-documentId.success',
+                    defaultMessage: 'Document ID copied to clipboard'
+                })
+            });
+        }
+    }, [
+        copy,
+        formatMessage,
+        toggleNotification
+    ]);
+    const { collectionType, model, schema } = useDoc();
+    const { list, listViewConversionContext, isLoading: isLoadingLayout } = useDocumentLayout(model);
+    const persistentQueryConfigs = React.useMemo(()=>({
+            [`STRAPI_LIST_VIEW_SETTINGS:${model}`]: {
+                paths: [
+                    'sort',
+                    'filters',
+                    'pageSize'
+                ],
+                scoped: true
+            },
+            STRAPI_LOCALE: {
+                paths: [
+                    'plugins.i18n.locale'
+                ],
+                scoped: false
+            }
+        }), [
+        model
+    ]);
+    const { isHydrated } = usePersistentPartialQueryParams(persistentQueryConfigs);
+    const [displayedHeaderNames, setDisplayedHeaderNames] = useScopedPersistentState(`STRAPI_LIST_VIEW_DISPLAYED_HEADERS:${model}`, null);
+    const mapDisplayedHeaders = React.useCallback((headers)=>headers.map((header)=>header.name), []);
+    const displayedHeaders = React.useMemo(()=>{
+        if (!displayedHeaderNames || !list.metadatas || Object.keys(list.metadatas).length <= 0 || !schema?.attributes || !listViewConversionContext) return [];
+        return convertListLayoutToFieldLayouts(displayedHeaderNames, schema.attributes, list.metadatas, {
+            configurations: listViewConversionContext.componentConfigurations,
+            schemas: listViewConversionContext.componentSchemas
+        }, listViewConversionContext.contentTypeSchemas);
+    }, [
+        displayedHeaderNames,
+        schema,
+        list,
+        listViewConversionContext
+    ]);
+    const handleSetHeaders = React.useCallback((headers)=>{
+        setDisplayedHeaderNames(headers);
+    }, [
+        setDisplayedHeaderNames
+    ]);
+    const handleResetHeaders = React.useCallback(()=>{
+        setDisplayedHeaderNames(mapDisplayedHeaders(list.layout));
+    }, [
+        list.layout,
+        mapDisplayedHeaders,
+        setDisplayedHeaderNames
+    ]);
+    /**
+   * If the persistent displayedHeaders are not yet initialized, set them to list.layout
+   */ React.useEffect(()=>{
+        // wait for list.layout to be loaded
+        if (list.layout.length === 0) {
+            return;
+        }
+        if (!displayedHeaderNames) {
+            handleResetHeaders();
+        }
+    }, [
+        displayedHeaderNames,
+        handleResetHeaders,
+        list.layout
+    ]);
+    React.useEffect(()=>{
+        if (!schema?.attributes) return;
+        if (!displayedHeaderNames || displayedHeaderNames.length === 0) return;
+        if (schema.uid !== model) return;
+        const allowedDisplayHeaders = displayedHeaderNames.filter((header)=>Object.keys(schema?.attributes).includes(header));
+        if (allowedDisplayHeaders.length !== displayedHeaderNames.length) {
+            handleSetHeaders(allowedDisplayHeaders);
+        }
+    }, [
+        displayedHeaderNames,
+        handleSetHeaders,
+        model,
+        schema?.attributes,
+        schema?.uid
+    ]);
+    const [{ query }, setQuery] = useQueryParams({
+        page: '1',
+        pageSize: list.settings.pageSize.toString(),
+        sort: list.settings.defaultSortBy ? `${list.settings.defaultSortBy}:${list.settings.defaultSortOrder}` : ''
+    });
+    const params = React.useMemo(()=>buildValidParams(query), [
+        query
+    ]);
+    const hasAppliedFilters = (query.filters?.$and?.length ?? 0) > 0;
+    const hasStatusFilter = Boolean(query.filters?.$and?.some((filter)=>filter.__status?.$eq !== undefined && filter.__status.$eq !== null));
+    // If a __status filter becomes active while sort=status:* is in the URL, strip the status sort.
+    React.useEffect(()=>{
+        if (hasStatusFilter && typeof query.sort === 'string' && /(?:^|,)\s*status:/i.test(query.sort)) {
+            const cleaned = query.sort.split(',').map((s)=>s.trim()).filter((s)=>!/^status:(ASC|DESC)$/i.test(s)).join(',');
+            setQuery({
+                sort: cleaned || undefined
+            }, 'push', true);
+        }
+    }, [
+        hasStatusFilter,
+        query.sort,
+        setQuery
+    ]);
+    const { data, error, isLoading, isFetching } = useGetAllDocumentsQuery({
+        model,
+        params
+    }, {
+        skip: isLoadingLayout || !isHydrated
+    });
+    /**
+   * If the API returns an error, display a notification
+   */ React.useEffect(()=>{
+        if (error) {
+            toggleNotification({
+                type: 'danger',
+                message: formatAPIError(error)
+            });
+        }
+    }, [
+        error,
+        formatAPIError,
+        toggleNotification
+    ]);
+    const { results = [], pagination } = data ?? {};
+    React.useEffect(()=>{
+        if (pagination && pagination.pageCount > 0 && pagination.page > pagination.pageCount) {
+            navigate({
+                search: stringify({
+                    ...query,
+                    page: pagination.pageCount
+                })
+            }, {
+                replace: true
+            });
+        }
+    }, [
+        pagination,
+        formatMessage,
+        query,
+        navigate
+    ]);
+    const { canCreate } = useDocumentRBAC('ListViewPage', ({ canCreate })=>({
+            canCreate
+        }));
+    const runHookWaterfall = useStrapiApp('ListViewPage', ({ runHookWaterfall })=>runHookWaterfall);
+    /**
+   * Run the waterfall and then inject our additional table headers.
+   */ const tableHeaders = React.useMemo(()=>{
+        const headers = runHookWaterfall(INJECT_COLUMN_IN_TABLE, {
+            displayedHeaders,
+            layout: list
+        });
+        const formattedHeaders = headers.displayedHeaders.map((header)=>{
+            /**
+       * When the header label is a string, it is an attribute on the current content-type:
+       * Use the attribute name value to compute the translation.
+       * Otherwise, it should be a  translation object coming from a plugin that injects into the table (ie i18n, content-releases, review-workflows):
+       * Use the translation object as is.
+       */ const translation = typeof header.label === 'string' ? {
+                id: `content-manager.content-types.${model}.${header.name}`,
+                defaultMessage: header.label
+            } : header.label;
+            return {
+                ...header,
+                label: formatMessage(translation),
+                name: `${header.name}${header.mainField?.name ? `.${header.mainField.name}` : ''}`
+            };
+        });
+        if (schema?.options?.draftAndPublish) {
+            formattedHeaders.push({
+                attribute: {
+                    type: 'custom'
+                },
+                name: 'status',
+                label: formatMessage({
+                    id: getTranslation(`containers.list.table-headers.status`),
+                    defaultMessage: 'status'
+                }),
+                searchable: false,
+                sortable: !hasStatusFilter
+            });
+        }
+        return formattedHeaders;
+    }, [
+        displayedHeaders,
+        formatMessage,
+        hasStatusFilter,
+        list,
+        runHookWaterfall,
+        schema?.options?.draftAndPublish,
+        model
+    ]);
+    if (isLoadingLayout || !isHydrated || isLoading) {
+        return /*#__PURE__*/ jsx(Page.Loading, {});
+    }
+    if (error) {
+        return /*#__PURE__*/ jsx(Page.Error, {});
+    }
+    const contentTypeTitle = schema?.info.displayName ? formatMessage({
+        id: schema.info.displayName,
+        defaultMessage: schema.info.displayName
+    }) : formatMessage({
+        id: 'content-manager.containers.untitled',
+        defaultMessage: 'Untitled'
+    });
+    const handleRowClick = (id)=>()=>{
+            trackUsage('willEditEntryFromList');
+            navigate({
+                pathname: id.toString(),
+                search: stringify({
+                    plugins: query.plugins
+                })
+            });
+        };
+    /**
+   * The entry link is rendered on the first non-interactive column *that has a
+   * value for the row* (resolved per row, so an empty cell — rendered as "-" —
+   * is skipped and the next candidate carries the link instead). Any scalar
+   * column qualifies — text, numbers, dates (createdAt/updatedAt), `id`, and
+   * `documentId` (its id text becomes the link, the copy button stays separate).
+   * Only genuinely interactive cells are skipped: relations, media, components,
+   * dynamic zones (they embed their own links/menus), plugin-formatted columns
+   * (`cellFormatter`), and the synthetic `status` column.
+   */ const NON_LINKABLE_TYPES = [
+        'media',
+        'relation',
+        'component',
+        'dynamiczone'
+    ];
+    const linkCandidates = tableHeaders.filter(({ name, attribute, cellFormatter })=>name !== 'status' && typeof cellFormatter !== 'function' && attribute && !NON_LINKABLE_TYPES.includes(attribute.type));
+    // The link column for a given row: the first candidate that actually has a
+    // value (uses CellContent's own hasContent so it matches the "-" the cell
+    // would otherwise render). documentId is checked directly (its own cell).
+    const getRowLinkField = (row)=>linkCandidates.find((header)=>{
+            if (header.name === 'documentId') {
+                return Boolean(row.documentId);
+            }
+            const value = row[header.name.split('.')[0]];
+            return hasContent(value, header.mainField, header.attribute);
+        })?.name;
+    const isEmptyState = !isFetching && results.length === 0;
+    const endActions = /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            isMobile && list.settings.filterable && schema && /*#__PURE__*/ jsx(listViewFilters.Trigger, {}),
+            /*#__PURE__*/ jsx(InjectionZone, {
+                area: "listView.actions"
+            }),
+            /*#__PURE__*/ jsx(ViewSettingsMenu, {
+                setHeaders: handleSetHeaders,
+                resetHeaders: handleResetHeaders,
+                headers: displayedHeaderNames ?? []
+            })
+        ]
+    });
+    const searchInput = /*#__PURE__*/ jsx(Fragment, {
+        children: list.settings.searchable && /*#__PURE__*/ jsx(SearchInput, {
+            label: formatMessage({
+                id: 'app.component.search.label',
+                defaultMessage: 'Search for {target}'
+            }, {
+                target: contentTypeTitle
+            }),
+            placeholder: formatMessage({
+                id: 'global.search',
+                defaultMessage: 'Search'
+            }),
+            trackedEvent: "didSearch"
+        })
+    });
+    const startActions = /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            searchInput,
+            !isMobile && list.settings.filterable && schema && /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx(listViewFilters.Trigger, {}),
+                    /*#__PURE__*/ jsx(listViewFilters.List, {})
+                ]
+            })
+        ]
+    });
+    const actions = list.settings.filterable && schema ? /*#__PURE__*/ jsxs(listViewFilters.Root, {
+        schema: schema,
+        layout: list,
+        children: [
+            /*#__PURE__*/ jsx(Layouts.Action, {
+                endActions: endActions,
+                startActions: startActions,
+                bottomActions: isMobile && hasAppliedFilters ? /*#__PURE__*/ jsx(listViewFilters.List, {}) : null
+            }),
+            /*#__PURE__*/ jsx(listViewFilters.Popover, {})
+        ]
+    }) : /*#__PURE__*/ jsx(Layouts.Action, {
+        endActions: endActions,
+        startActions: startActions
+    });
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(tours.contentManager.Introduction, {
+                children: /*#__PURE__*/ jsx(Box, {})
+            }),
+            /*#__PURE__*/ jsxs(Page.Main, {
+                children: [
+                    /*#__PURE__*/ jsx(Page.Title, {
+                        children: `${contentTypeTitle}`
+                    }),
+                    /*#__PURE__*/ jsx(LayoutsHeaderCustom, {
+                        primaryAction: canCreate ? /*#__PURE__*/ jsx(tours.contentManager.CreateNewEntry, {
+                            children: /*#__PURE__*/ jsx(CreateButton, {})
+                        }) : null,
+                        subtitle: formatMessage({
+                            id: getTranslation('pages.ListView.header-subtitle'),
+                            defaultMessage: '{number, plural, =0 {# entries} one {# entry} other {# entries}} found'
+                        }, {
+                            number: pagination?.total
+                        }),
+                        title: contentTypeTitle,
+                        navigationAction: /*#__PURE__*/ jsx(BackButton, {})
+                    }),
+                    actions,
+                    /*#__PURE__*/ jsx(Layouts.Content, {
+                        children: isEmptyState ? /*#__PURE__*/ jsx(Box, {
+                            background: "neutral0",
+                            shadow: "filterShadow",
+                            hasRadius: true,
+                            children: /*#__PURE__*/ jsx(EmptyStateLayout, {
+                                action: canCreate && /*#__PURE__*/ jsx(Box, {
+                                    children: /*#__PURE__*/ jsx(CreateButton, {
+                                        variant: "secondary"
+                                    })
+                                }),
+                                content: formatMessage({
+                                    id: 'app.components.EmptyStateLayout.content-document',
+                                    defaultMessage: 'No content found'
+                                }),
+                                hasRadius: true,
+                                icon: /*#__PURE__*/ jsx(EmptyDocuments, {
+                                    width: "16rem"
+                                })
+                            })
+                        }) : /*#__PURE__*/ jsxs(Flex, {
+                            gap: 4,
+                            direction: "column",
+                            alignItems: "stretch",
+                            children: [
+                                /*#__PURE__*/ jsxs(Table.Root, {
+                                    rows: results,
+                                    headers: tableHeaders,
+                                    isLoading: isFetching,
+                                    children: [
+                                        /*#__PURE__*/ jsx(TableActionsBar, {}),
+                                        /*#__PURE__*/ jsxs(Table.Content, {
+                                            children: [
+                                                /*#__PURE__*/ jsxs(Table.Head, {
+                                                    children: [
+                                                        /*#__PURE__*/ jsx(Table.HeaderCheckboxCell, {}),
+                                                        tableHeaders.map((header)=>/*#__PURE__*/ jsx(Table.HeaderCell, {
+                                                                ...header
+                                                            }, header.name))
+                                                    ]
+                                                }),
+                                                /*#__PURE__*/ jsx(Table.Loading, {}),
+                                                /*#__PURE__*/ jsx(Table.Empty, {
+                                                    action: canCreate ? /*#__PURE__*/ jsx(CreateButton, {
+                                                        variant: "secondary"
+                                                    }) : null
+                                                }),
+                                                /*#__PURE__*/ jsx(Table.Body, {
+                                                    children: results.map((row)=>{
+                                                        const rowLinkField = getRowLinkField(row);
+                                                        return /*#__PURE__*/ jsxs(Table.Row, {
+                                                            cursor: "pointer",
+                                                            onClick: handleRowClick(row.documentId),
+                                                            children: [
+                                                                /*#__PURE__*/ jsx(Table.CheckboxCell, {
+                                                                    id: row.id
+                                                                }),
+                                                                tableHeaders.map(({ cellFormatter, ...header })=>{
+                                                                    if (header.name === 'status') {
+                                                                        const { status } = row;
+                                                                        return /*#__PURE__*/ jsx(Table.Cell, {
+                                                                            children: /*#__PURE__*/ jsx(DocumentStatus, {
+                                                                                status: status,
+                                                                                maxWidth: 'min-content'
+                                                                            })
+                                                                        }, header.name);
+                                                                    }
+                                                                    if ([
+                                                                        'createdBy',
+                                                                        'updatedBy'
+                                                                    ].includes(header.name.split('.')[0])) {
+                                                                        // Display the users full name
+                                                                        // Some entries doesn't have a user assigned as creator/updater (ex: entries created through content API)
+                                                                        // In this case, we display a dash
+                                                                        return /*#__PURE__*/ jsx(Table.Cell, {
+                                                                            children: /*#__PURE__*/ jsx(Typography, {
+                                                                                textColor: "neutral800",
+                                                                                children: row[header.name.split('.')[0]] ? getDisplayName(row[header.name.split('.')[0]]) : '-'
+                                                                            })
+                                                                        }, header.name);
+                                                                    }
+                                                                    if (header.name === 'documentId') {
+                                                                        // When documentId is the primary link column, only its
+                                                                        // id text becomes the link; the copy button stays outside.
+                                                                        const isDocumentIdLink = header.name === rowLinkField && Boolean(row.documentId);
+                                                                        return /*#__PURE__*/ jsx(Table.Cell, {
+                                                                            children: /*#__PURE__*/ jsxs(Flex, {
+                                                                                gap: 2,
+                                                                                alignItems: "center",
+                                                                                width: "100%",
+                                                                                minWidth: 0,
+                                                                                children: [
+                                                                                    isDocumentIdLink ? /*#__PURE__*/ jsx(Typography, {
+                                                                                        tag: Link,
+                                                                                        to: {
+                                                                                            pathname: row.documentId,
+                                                                                            search: stringify({
+                                                                                                plugins: query.plugins
+                                                                                            })
+                                                                                        },
+                                                                                        onClick: (e)=>e.stopPropagation(),
+                                                                                        textColor: "neutral800",
+                                                                                        maxWidth: "30rem",
+                                                                                        ellipsis: true,
+                                                                                        children: row.documentId
+                                                                                    }) : /*#__PURE__*/ jsx(Typography, {
+                                                                                        textColor: "neutral800",
+                                                                                        maxWidth: "30rem",
+                                                                                        ellipsis: true,
+                                                                                        children: row.documentId || '-'
+                                                                                    }),
+                                                                                    row.documentId && /*#__PURE__*/ jsx(IconButton, {
+                                                                                        variant: "ghost",
+                                                                                        size: "S",
+                                                                                        label: formatMessage({
+                                                                                            id: 'content-manager.actions.copy-documentId.label',
+                                                                                            defaultMessage: 'Copy'
+                                                                                        }),
+                                                                                        onClick: (e)=>handleCopyDocumentId(e, row.documentId),
+                                                                                        children: /*#__PURE__*/ jsx(Duplicate, {})
+                                                                                    })
+                                                                                ]
+                                                                            })
+                                                                        }, header.name);
+                                                                    }
+                                                                    if (typeof cellFormatter === 'function') {
+                                                                        return /*#__PURE__*/ jsx(Table.Cell, {
+                                                                            children: cellFormatter(row, header, {
+                                                                                collectionType,
+                                                                                model
+                                                                            })
+                                                                        }, header.name);
+                                                                    }
+                                                                    return /*#__PURE__*/ jsx(Table.Cell, {
+                                                                        children: /*#__PURE__*/ jsx(CellContent, {
+                                                                            content: row[header.name.split('.')[0]],
+                                                                            rowId: row.documentId,
+                                                                            ...header,
+                                                                            linkTo: header.name === rowLinkField ? {
+                                                                                pathname: row.documentId,
+                                                                                search: stringify({
+                                                                                    plugins: query.plugins
+                                                                                })
+                                                                            } : undefined
+                                                                        })
+                                                                    }, header.name);
+                                                                }),
+                                                                /*#__PURE__*/ jsx(ActionsCell, {
+                                                                    onClick: (e)=>e.stopPropagation(),
+                                                                    children: /*#__PURE__*/ jsx(TableActions, {
+                                                                        document: row
+                                                                    })
+                                                                })
+                                                            ]
+                                                        }, row.id);
+                                                    })
+                                                })
+                                            ]
+                                        })
+                                    ]
+                                }),
+                                /*#__PURE__*/ jsxs(Pagination.Root, {
+                                    ...pagination,
+                                    onPageSizeChange: ()=>trackUsage('willChangeNumberOfEntriesPerPage'),
+                                    children: [
+                                        /*#__PURE__*/ jsx(Pagination.PageSize, {}),
+                                        /*#__PURE__*/ jsx(Pagination.Links, {})
+                                    ]
+                                })
+                            ]
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+};
+const ActionsCell = styled(Table.Cell)`
+  display: flex;
+  justify-content: flex-end;
+`;
+/* -------------------------------------------------------------------------------------------------
+ * TableActionsBar
+ * -----------------------------------------------------------------------------------------------*/ const TableActionsBar = ()=>{
+    const selectRow = useTable('TableActionsBar', (state)=>state.selectRow);
+    const [{ query }] = useQueryParams();
+    const locale = query?.plugins?.i18n?.locale;
+    const prevLocale = usePrev(locale);
+    // TODO: find a better way to reset the selected rows when the locale changes across all the app
+    React.useEffect(()=>{
+        if (prevLocale !== locale) {
+            selectRow([]);
+        }
+    }, [
+        selectRow,
+        prevLocale,
+        locale
+    ]);
+    return /*#__PURE__*/ jsx(Table.ActionBar, {
+        children: /*#__PURE__*/ jsx(BulkActionsRenderer, {})
+    });
+};
+const CreateButton = ({ variant })=>{
+    const { formatMessage } = useIntl();
+    const { trackUsage } = useTracking();
+    const [{ query }] = useQueryParams();
+    return /*#__PURE__*/ jsx(Button, {
+        variant: variant,
+        tag: Link,
+        onClick: ()=>{
+            trackUsage('willCreateEntry', {
+                status: 'draft'
+            });
+        },
+        startIcon: /*#__PURE__*/ jsx(Plus, {}),
+        style: {
+            textDecoration: 'none'
+        },
+        to: {
+            pathname: 'create',
+            search: stringify({
+                plugins: query.plugins
+            })
+        },
+        minWidth: "max-content",
+        fullWidth: true,
+        children: formatMessage({
+            id: getTranslation('HeaderLayout.button.label-add-entry'),
+            defaultMessage: 'Create new entry'
+        })
+    });
+};
+/* -------------------------------------------------------------------------------------------------
+ * ProtectedListViewPage
+ * -----------------------------------------------------------------------------------------------*/ const ProtectedListViewPage = ()=>{
+    const { slug = '' } = useParams();
+    const { permissions = [], isLoading, error } = useRBAC(PERMISSIONS.map((action)=>({
+            action,
+            subject: slug
+        })));
+    if (isLoading) {
+        return /*#__PURE__*/ jsx(Page.Loading, {});
+    }
+    if (error || !slug) {
+        return /*#__PURE__*/ jsx(Page.Error, {});
+    }
+    return /*#__PURE__*/ jsx(Page.Protect, {
+        permissions: permissions,
+        children: ({ permissions })=>/*#__PURE__*/ jsx(DocumentRBAC, {
+                permissions: permissions,
+                children: /*#__PURE__*/ jsx(ListViewPage, {}, slug)
+            })
+    });
+};
+
+export { ListViewPage, ProtectedListViewPage };
+//# sourceMappingURL=ListViewPage.mjs.map