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

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

@@ -0,0 +1,657 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var strapiAdmin = require('@strapi/admin/strapi-admin');
+var designSystem = require('@strapi/design-system');
+var Icons = require('@strapi/icons');
+var Symbols = require('@strapi/icons/symbols');
+var qs = require('qs');
+var reactIntl = require('react-intl');
+var reactRouterDom = require('react-router-dom');
+var styledComponents = require('styled-components');
+var InjectionZone = require('../../components/InjectionZone.js');
+var hooks = require('../../constants/hooks.js');
+var plugin = require('../../constants/plugin.js');
+var DocumentRBAC = require('../../features/DocumentRBAC.js');
+var useDocument = require('../../hooks/useDocument.js');
+var useDocumentLayout = require('../../hooks/useDocumentLayout.js');
+var usePersistentQueryParams = require('../../hooks/usePersistentQueryParams.js');
+var usePrev = require('../../hooks/usePrev.js');
+var documents = require('../../services/documents.js');
+var api = require('../../utils/api.js');
+var translations = require('../../utils/translations.js');
+var users = require('../../utils/users.js');
+var DocumentStatus = require('../EditView/components/DocumentStatus.js');
+var Actions = require('./components/BulkActions/Actions.js');
+var Filters = require('./components/Filters.js');
+var TableActions = require('./components/TableActions.js');
+var CellContent = require('./components/TableCells/CellContent.js');
+var ViewSettingsMenu = require('./components/ViewSettingsMenu.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+const { INJECT_COLUMN_IN_TABLE } = hooks.HOOKS;
+/* -------------------------------------------------------------------------------------------------
+ * ListViewPage
+ * -----------------------------------------------------------------------------------------------*/ const LayoutsHeaderCustom = styledComponents.styled(strapiAdmin.Layouts.Header)`
+  overflow-wrap: anywhere;
+`;
+const ListViewPage = ()=>{
+    const { trackUsage } = strapiAdmin.useTracking();
+    const navigate = reactRouterDom.useNavigate();
+    const { formatMessage } = reactIntl.useIntl();
+    const { toggleNotification } = strapiAdmin.useNotification();
+    const { copy } = strapiAdmin.useClipboard();
+    const { _unstableFormatAPIError: formatAPIError } = strapiAdmin.useAPIErrorHandler(translations.getTranslation);
+    const isMobile = strapiAdmin.useIsMobile();
+    const handleCopyDocumentId = React__namespace.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 } = useDocument.useDoc();
+    const { list, listViewConversionContext, isLoading: isLoadingLayout } = useDocumentLayout.useDocumentLayout(model);
+    const persistentQueryConfigs = React__namespace.useMemo(()=>({
+            [`STRAPI_LIST_VIEW_SETTINGS:${model}`]: {
+                paths: [
+                    'sort',
+                    'filters',
+                    'pageSize'
+                ],
+                scoped: true
+            },
+            STRAPI_LOCALE: {
+                paths: [
+                    'plugins.i18n.locale'
+                ],
+                scoped: false
+            }
+        }), [
+        model
+    ]);
+    const { isHydrated } = usePersistentQueryParams.usePersistentPartialQueryParams(persistentQueryConfigs);
+    const [displayedHeaderNames, setDisplayedHeaderNames] = strapiAdmin.useScopedPersistentState(`STRAPI_LIST_VIEW_DISPLAYED_HEADERS:${model}`, null);
+    const mapDisplayedHeaders = React__namespace.useCallback((headers)=>headers.map((header)=>header.name), []);
+    const displayedHeaders = React__namespace.useMemo(()=>{
+        if (!displayedHeaderNames || !list.metadatas || Object.keys(list.metadatas).length <= 0 || !schema?.attributes || !listViewConversionContext) return [];
+        return useDocumentLayout.convertListLayoutToFieldLayouts(displayedHeaderNames, schema.attributes, list.metadatas, {
+            configurations: listViewConversionContext.componentConfigurations,
+            schemas: listViewConversionContext.componentSchemas
+        }, listViewConversionContext.contentTypeSchemas);
+    }, [
+        displayedHeaderNames,
+        schema,
+        list,
+        listViewConversionContext
+    ]);
+    const handleSetHeaders = React__namespace.useCallback((headers)=>{
+        setDisplayedHeaderNames(headers);
+    }, [
+        setDisplayedHeaderNames
+    ]);
+    const handleResetHeaders = React__namespace.useCallback(()=>{
+        setDisplayedHeaderNames(mapDisplayedHeaders(list.layout));
+    }, [
+        list.layout,
+        mapDisplayedHeaders,
+        setDisplayedHeaderNames
+    ]);
+    /**
+   * If the persistent displayedHeaders are not yet initialized, set them to list.layout
+   */ React__namespace.useEffect(()=>{
+        // wait for list.layout to be loaded
+        if (list.layout.length === 0) {
+            return;
+        }
+        if (!displayedHeaderNames) {
+            handleResetHeaders();
+        }
+    }, [
+        displayedHeaderNames,
+        handleResetHeaders,
+        list.layout
+    ]);
+    React__namespace.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] = strapiAdmin.useQueryParams({
+        page: '1',
+        pageSize: list.settings.pageSize.toString(),
+        sort: list.settings.defaultSortBy ? `${list.settings.defaultSortBy}:${list.settings.defaultSortOrder}` : ''
+    });
+    const params = React__namespace.useMemo(()=>api.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__namespace.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 } = documents.useGetAllDocumentsQuery({
+        model,
+        params
+    }, {
+        skip: isLoadingLayout || !isHydrated
+    });
+    /**
+   * If the API returns an error, display a notification
+   */ React__namespace.useEffect(()=>{
+        if (error) {
+            toggleNotification({
+                type: 'danger',
+                message: formatAPIError(error)
+            });
+        }
+    }, [
+        error,
+        formatAPIError,
+        toggleNotification
+    ]);
+    const { results = [], pagination } = data ?? {};
+    React__namespace.useEffect(()=>{
+        if (pagination && pagination.pageCount > 0 && pagination.page > pagination.pageCount) {
+            navigate({
+                search: qs.stringify({
+                    ...query,
+                    page: pagination.pageCount
+                })
+            }, {
+                replace: true
+            });
+        }
+    }, [
+        pagination,
+        formatMessage,
+        query,
+        navigate
+    ]);
+    const { canCreate } = DocumentRBAC.useDocumentRBAC('ListViewPage', ({ canCreate })=>({
+            canCreate
+        }));
+    const runHookWaterfall = strapiAdmin.useStrapiApp('ListViewPage', ({ runHookWaterfall })=>runHookWaterfall);
+    /**
+   * Run the waterfall and then inject our additional table headers.
+   */ const tableHeaders = React__namespace.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: translations.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__*/ jsxRuntime.jsx(strapiAdmin.Page.Loading, {});
+    }
+    if (error) {
+        return /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.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: qs.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 CellContent.hasContent(value, header.mainField, header.attribute);
+        })?.name;
+    const isEmptyState = !isFetching && results.length === 0;
+    const endActions = /*#__PURE__*/ jsxRuntime.jsxs(jsxRuntime.Fragment, {
+        children: [
+            isMobile && list.settings.filterable && schema && /*#__PURE__*/ jsxRuntime.jsx(Filters.listViewFilters.Trigger, {}),
+            /*#__PURE__*/ jsxRuntime.jsx(InjectionZone.InjectionZone, {
+                area: "listView.actions"
+            }),
+            /*#__PURE__*/ jsxRuntime.jsx(ViewSettingsMenu.ViewSettingsMenu, {
+                setHeaders: handleSetHeaders,
+                resetHeaders: handleResetHeaders,
+                headers: displayedHeaderNames ?? []
+            })
+        ]
+    });
+    const searchInput = /*#__PURE__*/ jsxRuntime.jsx(jsxRuntime.Fragment, {
+        children: list.settings.searchable && /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.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__*/ jsxRuntime.jsxs(jsxRuntime.Fragment, {
+        children: [
+            searchInput,
+            !isMobile && list.settings.filterable && schema && /*#__PURE__*/ jsxRuntime.jsxs(jsxRuntime.Fragment, {
+                children: [
+                    /*#__PURE__*/ jsxRuntime.jsx(Filters.listViewFilters.Trigger, {}),
+                    /*#__PURE__*/ jsxRuntime.jsx(Filters.listViewFilters.List, {})
+                ]
+            })
+        ]
+    });
+    const actions = list.settings.filterable && schema ? /*#__PURE__*/ jsxRuntime.jsxs(Filters.listViewFilters.Root, {
+        schema: schema,
+        layout: list,
+        children: [
+            /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Layouts.Action, {
+                endActions: endActions,
+                startActions: startActions,
+                bottomActions: isMobile && hasAppliedFilters ? /*#__PURE__*/ jsxRuntime.jsx(Filters.listViewFilters.List, {}) : null
+            }),
+            /*#__PURE__*/ jsxRuntime.jsx(Filters.listViewFilters.Popover, {})
+        ]
+    }) : /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Layouts.Action, {
+        endActions: endActions,
+        startActions: startActions
+    });
+    return /*#__PURE__*/ jsxRuntime.jsxs(jsxRuntime.Fragment, {
+        children: [
+            /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.tours.contentManager.Introduction, {
+                children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Box, {})
+            }),
+            /*#__PURE__*/ jsxRuntime.jsxs(strapiAdmin.Page.Main, {
+                children: [
+                    /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Page.Title, {
+                        children: `${contentTypeTitle}`
+                    }),
+                    /*#__PURE__*/ jsxRuntime.jsx(LayoutsHeaderCustom, {
+                        primaryAction: canCreate ? /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.tours.contentManager.CreateNewEntry, {
+                            children: /*#__PURE__*/ jsxRuntime.jsx(CreateButton, {})
+                        }) : null,
+                        subtitle: formatMessage({
+                            id: translations.getTranslation('pages.ListView.header-subtitle'),
+                            defaultMessage: '{number, plural, =0 {# entries} one {# entry} other {# entries}} found'
+                        }, {
+                            number: pagination?.total
+                        }),
+                        title: contentTypeTitle,
+                        navigationAction: /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.BackButton, {})
+                    }),
+                    actions,
+                    /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Layouts.Content, {
+                        children: isEmptyState ? /*#__PURE__*/ jsxRuntime.jsx(designSystem.Box, {
+                            background: "neutral0",
+                            shadow: "filterShadow",
+                            hasRadius: true,
+                            children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.EmptyStateLayout, {
+                                action: canCreate && /*#__PURE__*/ jsxRuntime.jsx(designSystem.Box, {
+                                    children: /*#__PURE__*/ jsxRuntime.jsx(CreateButton, {
+                                        variant: "secondary"
+                                    })
+                                }),
+                                content: formatMessage({
+                                    id: 'app.components.EmptyStateLayout.content-document',
+                                    defaultMessage: 'No content found'
+                                }),
+                                hasRadius: true,
+                                icon: /*#__PURE__*/ jsxRuntime.jsx(Symbols.EmptyDocuments, {
+                                    width: "16rem"
+                                })
+                            })
+                        }) : /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
+                            gap: 4,
+                            direction: "column",
+                            alignItems: "stretch",
+                            children: [
+                                /*#__PURE__*/ jsxRuntime.jsxs(strapiAdmin.Table.Root, {
+                                    rows: results,
+                                    headers: tableHeaders,
+                                    isLoading: isFetching,
+                                    children: [
+                                        /*#__PURE__*/ jsxRuntime.jsx(TableActionsBar, {}),
+                                        /*#__PURE__*/ jsxRuntime.jsxs(strapiAdmin.Table.Content, {
+                                            children: [
+                                                /*#__PURE__*/ jsxRuntime.jsxs(strapiAdmin.Table.Head, {
+                                                    children: [
+                                                        /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Table.HeaderCheckboxCell, {}),
+                                                        tableHeaders.map((header)=>/*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Table.HeaderCell, {
+                                                                ...header
+                                                            }, header.name))
+                                                    ]
+                                                }),
+                                                /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Table.Loading, {}),
+                                                /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Table.Empty, {
+                                                    action: canCreate ? /*#__PURE__*/ jsxRuntime.jsx(CreateButton, {
+                                                        variant: "secondary"
+                                                    }) : null
+                                                }),
+                                                /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Table.Body, {
+                                                    children: results.map((row)=>{
+                                                        const rowLinkField = getRowLinkField(row);
+                                                        return /*#__PURE__*/ jsxRuntime.jsxs(strapiAdmin.Table.Row, {
+                                                            cursor: "pointer",
+                                                            onClick: handleRowClick(row.documentId),
+                                                            children: [
+                                                                /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Table.CheckboxCell, {
+                                                                    id: row.id
+                                                                }),
+                                                                tableHeaders.map(({ cellFormatter, ...header })=>{
+                                                                    if (header.name === 'status') {
+                                                                        const { status } = row;
+                                                                        return /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Table.Cell, {
+                                                                            children: /*#__PURE__*/ jsxRuntime.jsx(DocumentStatus.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__*/ jsxRuntime.jsx(strapiAdmin.Table.Cell, {
+                                                                            children: /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
+                                                                                textColor: "neutral800",
+                                                                                children: row[header.name.split('.')[0]] ? users.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__*/ jsxRuntime.jsx(strapiAdmin.Table.Cell, {
+                                                                            children: /*#__PURE__*/ jsxRuntime.jsxs(designSystem.Flex, {
+                                                                                gap: 2,
+                                                                                alignItems: "center",
+                                                                                width: "100%",
+                                                                                minWidth: 0,
+                                                                                children: [
+                                                                                    isDocumentIdLink ? /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
+                                                                                        tag: reactRouterDom.Link,
+                                                                                        to: {
+                                                                                            pathname: row.documentId,
+                                                                                            search: qs.stringify({
+                                                                                                plugins: query.plugins
+                                                                                            })
+                                                                                        },
+                                                                                        onClick: (e)=>e.stopPropagation(),
+                                                                                        textColor: "neutral800",
+                                                                                        maxWidth: "30rem",
+                                                                                        ellipsis: true,
+                                                                                        children: row.documentId
+                                                                                    }) : /*#__PURE__*/ jsxRuntime.jsx(designSystem.Typography, {
+                                                                                        textColor: "neutral800",
+                                                                                        maxWidth: "30rem",
+                                                                                        ellipsis: true,
+                                                                                        children: row.documentId || '-'
+                                                                                    }),
+                                                                                    row.documentId && /*#__PURE__*/ jsxRuntime.jsx(designSystem.IconButton, {
+                                                                                        variant: "ghost",
+                                                                                        size: "S",
+                                                                                        label: formatMessage({
+                                                                                            id: 'content-manager.actions.copy-documentId.label',
+                                                                                            defaultMessage: 'Copy'
+                                                                                        }),
+                                                                                        onClick: (e)=>handleCopyDocumentId(e, row.documentId),
+                                                                                        children: /*#__PURE__*/ jsxRuntime.jsx(Icons.Duplicate, {})
+                                                                                    })
+                                                                                ]
+                                                                            })
+                                                                        }, header.name);
+                                                                    }
+                                                                    if (typeof cellFormatter === 'function') {
+                                                                        return /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Table.Cell, {
+                                                                            children: cellFormatter(row, header, {
+                                                                                collectionType,
+                                                                                model
+                                                                            })
+                                                                        }, header.name);
+                                                                    }
+                                                                    return /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Table.Cell, {
+                                                                        children: /*#__PURE__*/ jsxRuntime.jsx(CellContent.CellContent, {
+                                                                            content: row[header.name.split('.')[0]],
+                                                                            rowId: row.documentId,
+                                                                            ...header,
+                                                                            linkTo: header.name === rowLinkField ? {
+                                                                                pathname: row.documentId,
+                                                                                search: qs.stringify({
+                                                                                    plugins: query.plugins
+                                                                                })
+                                                                            } : undefined
+                                                                        })
+                                                                    }, header.name);
+                                                                }),
+                                                                /*#__PURE__*/ jsxRuntime.jsx(ActionsCell, {
+                                                                    onClick: (e)=>e.stopPropagation(),
+                                                                    children: /*#__PURE__*/ jsxRuntime.jsx(TableActions.TableActions, {
+                                                                        document: row
+                                                                    })
+                                                                })
+                                                            ]
+                                                        }, row.id);
+                                                    })
+                                                })
+                                            ]
+                                        })
+                                    ]
+                                }),
+                                /*#__PURE__*/ jsxRuntime.jsxs(strapiAdmin.Pagination.Root, {
+                                    ...pagination,
+                                    onPageSizeChange: ()=>trackUsage('willChangeNumberOfEntriesPerPage'),
+                                    children: [
+                                        /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Pagination.PageSize, {}),
+                                        /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Pagination.Links, {})
+                                    ]
+                                })
+                            ]
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+};
+const ActionsCell = styledComponents.styled(strapiAdmin.Table.Cell)`
+  display: flex;
+  justify-content: flex-end;
+`;
+/* -------------------------------------------------------------------------------------------------
+ * TableActionsBar
+ * -----------------------------------------------------------------------------------------------*/ const TableActionsBar = ()=>{
+    const selectRow = strapiAdmin.useTable('TableActionsBar', (state)=>state.selectRow);
+    const [{ query }] = strapiAdmin.useQueryParams();
+    const locale = query?.plugins?.i18n?.locale;
+    const prevLocale = usePrev.usePrev(locale);
+    // TODO: find a better way to reset the selected rows when the locale changes across all the app
+    React__namespace.useEffect(()=>{
+        if (prevLocale !== locale) {
+            selectRow([]);
+        }
+    }, [
+        selectRow,
+        prevLocale,
+        locale
+    ]);
+    return /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Table.ActionBar, {
+        children: /*#__PURE__*/ jsxRuntime.jsx(Actions.BulkActionsRenderer, {})
+    });
+};
+const CreateButton = ({ variant })=>{
+    const { formatMessage } = reactIntl.useIntl();
+    const { trackUsage } = strapiAdmin.useTracking();
+    const [{ query }] = strapiAdmin.useQueryParams();
+    return /*#__PURE__*/ jsxRuntime.jsx(designSystem.Button, {
+        variant: variant,
+        tag: reactRouterDom.Link,
+        onClick: ()=>{
+            trackUsage('willCreateEntry', {
+                status: 'draft'
+            });
+        },
+        startIcon: /*#__PURE__*/ jsxRuntime.jsx(Icons.Plus, {}),
+        style: {
+            textDecoration: 'none'
+        },
+        to: {
+            pathname: 'create',
+            search: qs.stringify({
+                plugins: query.plugins
+            })
+        },
+        minWidth: "max-content",
+        fullWidth: true,
+        children: formatMessage({
+            id: translations.getTranslation('HeaderLayout.button.label-add-entry'),
+            defaultMessage: 'Create new entry'
+        })
+    });
+};
+/* -------------------------------------------------------------------------------------------------
+ * ProtectedListViewPage
+ * -----------------------------------------------------------------------------------------------*/ const ProtectedListViewPage = ()=>{
+    const { slug = '' } = reactRouterDom.useParams();
+    const { permissions = [], isLoading, error } = strapiAdmin.useRBAC(plugin.PERMISSIONS.map((action)=>({
+            action,
+            subject: slug
+        })));
+    if (isLoading) {
+        return /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Page.Loading, {});
+    }
+    if (error || !slug) {
+        return /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Page.Error, {});
+    }
+    return /*#__PURE__*/ jsxRuntime.jsx(strapiAdmin.Page.Protect, {
+        permissions: permissions,
+        children: ({ permissions })=>/*#__PURE__*/ jsxRuntime.jsx(DocumentRBAC.DocumentRBAC, {
+                permissions: permissions,
+                children: /*#__PURE__*/ jsxRuntime.jsx(ListViewPage, {}, slug)
+            })
+    });
+};
+
+exports.ListViewPage = ListViewPage;
+exports.ProtectedListViewPage = ProtectedListViewPage;
+//# sourceMappingURL=ListViewPage.js.map