@wordpress/editor 14.1.0 → 14.3.0

package/build-module/components/post-actions/actions.js

@@ -3,13 +3,15 @@
  */
 import { external, trash, backup } from '@wordpress/icons';
 import { addQueryArgs } from '@wordpress/url';
-import { useDispatch, useSelect } from '@wordpress/data';
+import { useDispatch, useSelect, useRegistry } from '@wordpress/data';
 import { decodeEntities } from '@wordpress/html-entities';
 import { store as coreStore } from '@wordpress/core-data';
 import { __, _n, sprintf, _x } from '@wordpress/i18n';
 import { store as noticesStore } from '@wordpress/notices';
 import { useMemo, useState } from '@wordpress/element';
 import { privateApis as patternsPrivateApis } from '@wordpress/patterns';
+import { parse } from '@wordpress/blocks';
+import { DataForm } from '@wordpress/dataviews';
 import { Button, TextControl, __experimentalText as Text, __experimentalHStack as HStack, __experimentalVStack as VStack } from '@wordpress/components';
 
 /**
@@ -18,9 +20,8 @@ import { Button, TextControl, __experimentalText as Text, __experimentalHStack a
 import { TEMPLATE_ORIGINS, TEMPLATE_PART_POST_TYPE, TEMPLATE_POST_TYPE, PATTERN_POST_TYPE } from '../../store/constants';
 import { store as editorStore } from '../../store';
 import { unlock } from '../../lock-unlock';
-import isTemplateRevertable from '../../store/utils/is-template-revertable';
-import { exportPatternAsJSONAction } from './export-pattern-action';
 import { CreateTemplatePartModalContents } from '../create-template-part-modal';
+import { getItemTitle } from '../../dataviews/actions/utils';
 
 // Patterns.
 import { jsx as _jsx } from "react/jsx-runtime";
@@ -31,6 +32,20 @@ const {
   useDuplicatePatternProps
 } = unlock(patternsPrivateApis);
 
+// TODO: this should be shared with other components (page-pages).
+const fields = [{
+  type: 'text',
+  header: __('Title'),
+  id: 'title',
+  placeholder: __('No title'),
+  getValue: ({
+    item
+  }) => item.title
+}];
+const form = {
+  visibleFields: ['title']
+};
+
 /**
  * Check if a template is removable.
  *
@@ -44,86 +59,8 @@ function isTemplateRemovable(template) {
   // In patterns list page we map the templates parts to a different object
   // than the one returned from the endpoint. This is why we need to check for
   // two props whether is custom or has a theme file.
-  return [template.source, template.templatePart?.source].includes(TEMPLATE_ORIGINS.custom) && !template.has_theme_file && !template.templatePart?.has_theme_file;
-}
-const canDeleteOrReset = item => {
-  const isTemplatePart = item.type === TEMPLATE_PART_POST_TYPE;
-  const isUserPattern = item.type === PATTERN_TYPES.user;
-  return isUserPattern || isTemplatePart && item.isCustom;
-};
-function getItemTitle(item) {
-  if (typeof item.title === 'string') {
-    return decodeEntities(item.title);
-  }
-  return decodeEntities(item.title?.rendered || '');
+  return template?.source === TEMPLATE_ORIGINS.custom && !template?.has_theme_file;
 }
-
-// This action is used for templates, patterns and template parts.
-// Every other post type uses the similar `trashPostAction` which
-// moves the post to trash.
-const deletePostAction = {
-  id: 'delete-post',
-  label: __('Delete'),
-  isPrimary: true,
-  icon: trash,
-  isEligible(post) {
-    if ([TEMPLATE_POST_TYPE, TEMPLATE_PART_POST_TYPE].includes(post.type)) {
-      return isTemplateRemovable(post);
-    }
-    // We can only remove user patterns.
-    return post.type === PATTERN_TYPES.user;
-  },
-  supportsBulk: true,
-  hideModalHeader: true,
-  RenderModal: ({
-    items,
-    closeModal,
-    onActionStart,
-    onActionPerformed
-  }) => {
-    const [isBusy, setIsBusy] = useState(false);
-    const {
-      removeTemplates
-    } = unlock(useDispatch(editorStore));
-    return /*#__PURE__*/_jsxs(VStack, {
-      spacing: "5",
-      children: [/*#__PURE__*/_jsx(Text, {
-        children: items.length > 1 ? sprintf(
-        // translators: %d: number of items to delete.
-        _n('Delete %d item?', 'Delete %d items?', items.length), items.length) : sprintf(
-        // translators: %s: The template or template part's titles
-        __('Delete "%s"?'), getItemTitle(items[0]))
-      }), /*#__PURE__*/_jsxs(HStack, {
-        justify: "right",
-        children: [/*#__PURE__*/_jsx(Button, {
-          variant: "tertiary",
-          onClick: closeModal,
-          disabled: isBusy,
-          __experimentalIsFocusable: true,
-          children: __('Cancel')
-        }), /*#__PURE__*/_jsx(Button, {
-          variant: "primary",
-          onClick: async () => {
-            setIsBusy(true);
-            if (onActionStart) {
-              onActionStart(items);
-            }
-            await removeTemplates(items, {
-              allowUndo: false
-            });
-            onActionPerformed?.(items);
-            setIsBusy(false);
-            closeModal();
-          },
-          isBusy: isBusy,
-          disabled: isBusy,
-          __experimentalIsFocusable: true,
-          children: __('Delete')
-        })]
-      })]
-    });
-  }
-};
 const trashPostAction = {
   id: 'move-to-trash',
   label: __('Move to Trash'),
@@ -137,7 +74,6 @@ const trashPostAction = {
   RenderModal: ({
     items,
     closeModal,
-    onActionStart,
     onActionPerformed
   }) => {
     const [isBusy, setIsBusy] = useState(false);
@@ -162,15 +98,12 @@ const trashPostAction = {
           variant: "tertiary",
           onClick: closeModal,
           disabled: isBusy,
-          __experimentalIsFocusable: true,
+          accessibleWhenDisabled: true,
           children: __('Cancel')
         }), /*#__PURE__*/_jsx(Button, {
           variant: "primary",
           onClick: async () => {
             setIsBusy(true);
-            if (onActionStart) {
-              onActionStart(items);
-            }
             const promiseResult = await Promise.allSettled(items.map(item => deleteEntityRecord('postType', item.type, item.id, {}, {
               throwOnError: true
             })));
@@ -182,12 +115,9 @@ const trashPostAction = {
               if (promiseResult.length === 1) {
                 successMessage = sprintf( /* translators: The item's title. */
                 __('"%s" moved to trash.'), getItemTitle(items[0]));
-              } else if (items[0].type === 'page') {
-                successMessage = sprintf( /* translators: The number of items. */
-                __('%s items moved to trash.'), items.length);
               } else {
-                successMessage = sprintf( /* translators: The number of posts. */
-                __('%s items move to trash.'), items.length);
+                successMessage = sprintf( /* translators: The number of items. */
+                _n('%s item moved to trash.', '%s items moved to trash.', items.length), items.length);
               }
               createSuccessNotice(successMessage, {
                 type: 'snackbar',
@@ -236,183 +166,201 @@ const trashPostAction = {
           },
           isBusy: isBusy,
           disabled: isBusy,
-          __experimentalIsFocusable: true,
+          accessibleWhenDisabled: true,
           children: __('Trash')
         })]
       })]
     });
   }
 };
-function usePermanentlyDeletePostAction() {
-  const {
-    createSuccessNotice,
-    createErrorNotice
-  } = useDispatch(noticesStore);
-  const {
-    deleteEntityRecord
-  } = useDispatch(coreStore);
+function useCanUserEligibilityCheckPostType(capability, resource, action) {
+  const registry = useRegistry();
   return useMemo(() => ({
-    id: 'permanently-delete',
-    label: __('Permanently delete'),
-    supportsBulk: true,
-    isEligible({
+    ...action,
+    isEligible(item) {
+      return action.isEligible(item) && registry.select(coreStore).canUser(capability, resource, item.id);
+    }
+  }), [action, registry, capability, resource]);
+}
+function useTrashPostAction(resource) {
+  return useCanUserEligibilityCheckPostType('delete', resource, trashPostAction);
+}
+const permanentlyDeletePostAction = {
+  id: 'permanently-delete',
+  label: __('Permanently delete'),
+  supportsBulk: true,
+  isEligible({
+    status
+  }) {
+    return status === 'trash';
+  },
+  async callback(posts, {
+    registry,
+    onActionPerformed
+  }) {
+    const {
+      createSuccessNotice,
+      createErrorNotice
+    } = registry.dispatch(noticesStore);
+    const {
+      deleteEntityRecord
+    } = registry.dispatch(coreStore);
+    const promiseResult = await Promise.allSettled(posts.map(post => {
+      return deleteEntityRecord('postType', post.type, post.id, {
+        force: true
+      }, {
+        throwOnError: true
+      });
+    }));
+    // If all the promises were fulfilled with success.
+    if (promiseResult.every(({
       status
-    }) {
-      return status === 'trash';
-    },
-    async callback(posts, onActionPerformed) {
-      const promiseResult = await Promise.allSettled(posts.map(post => {
-        return deleteEntityRecord('postType', post.type, post.id, {
-          force: true
-        }, {
-          throwOnError: true
-        });
-      }));
-      // If all the promises were fulfilled with success.
-      if (promiseResult.every(({
-        status
-      }) => status === 'fulfilled')) {
-        let successMessage;
-        if (promiseResult.length === 1) {
-          successMessage = sprintf( /* translators: The posts's title. */
-          __('"%s" permanently deleted.'), getItemTitle(posts[0]));
+    }) => status === 'fulfilled')) {
+      let successMessage;
+      if (promiseResult.length === 1) {
+        successMessage = sprintf( /* translators: The posts's title. */
+        __('"%s" permanently deleted.'), getItemTitle(posts[0]));
+      } else {
+        successMessage = __('The posts were permanently deleted.');
+      }
+      createSuccessNotice(successMessage, {
+        type: 'snackbar',
+        id: 'permanently-delete-post-action'
+      });
+      onActionPerformed?.(posts);
+    } else {
+      // If there was at lease one failure.
+      let errorMessage;
+      // If we were trying to permanently delete a single post.
+      if (promiseResult.length === 1) {
+        if (promiseResult[0].reason?.message) {
+          errorMessage = promiseResult[0].reason.message;
         } else {
-          successMessage = __('The posts were permanently deleted.');
-        }
-        createSuccessNotice(successMessage, {
-          type: 'snackbar',
-          id: 'permanently-delete-post-action'
-        });
-        if (onActionPerformed) {
-          onActionPerformed(posts);
+          errorMessage = __('An error occurred while permanently deleting the post.');
         }
+        // If we were trying to permanently delete multiple posts
       } else {
-        // If there was at lease one failure.
-        let errorMessage;
-        // If we were trying to permanently delete a single post.
-        if (promiseResult.length === 1) {
-          if (promiseResult[0].reason?.message) {
-            errorMessage = promiseResult[0].reason.message;
-          } else {
-            errorMessage = __('An error occurred while permanently deleting the post.');
+        const errorMessages = new Set();
+        const failedPromises = promiseResult.filter(({
+          status
+        }) => status === 'rejected');
+        for (const failedPromise of failedPromises) {
+          if (failedPromise.reason?.message) {
+            errorMessages.add(failedPromise.reason.message);
           }
-          // If we were trying to permanently delete multiple posts
+        }
+        if (errorMessages.size === 0) {
+          errorMessage = __('An error occurred while permanently deleting the posts.');
+        } else if (errorMessages.size === 1) {
+          errorMessage = sprintf( /* translators: %s: an error message */
+          __('An error occurred while permanently deleting the posts: %s'), [...errorMessages][0]);
         } else {
-          const errorMessages = new Set();
-          const failedPromises = promiseResult.filter(({
-            status
-          }) => status === 'rejected');
-          for (const failedPromise of failedPromises) {
-            if (failedPromise.reason?.message) {
-              errorMessages.add(failedPromise.reason.message);
-            }
-          }
-          if (errorMessages.size === 0) {
-            errorMessage = __('An error occurred while permanently deleting the posts.');
-          } else if (errorMessages.size === 1) {
-            errorMessage = sprintf( /* translators: %s: an error message */
-            __('An error occurred while permanently deleting the posts: %s'), [...errorMessages][0]);
-          } else {
-            errorMessage = sprintf( /* translators: %s: a list of comma separated error messages */
-            __('Some errors occurred while permanently deleting the posts: %s'), [...errorMessages].join(','));
-          }
+          errorMessage = sprintf( /* translators: %s: a list of comma separated error messages */
+          __('Some errors occurred while permanently deleting the posts: %s'), [...errorMessages].join(','));
         }
-        createErrorNotice(errorMessage, {
-          type: 'snackbar'
-        });
       }
+      createErrorNotice(errorMessage, {
+        type: 'snackbar'
+      });
     }
-  }), [createSuccessNotice, createErrorNotice, deleteEntityRecord]);
+  }
+};
+function usePermanentlyDeletePostAction(resource) {
+  return useCanUserEligibilityCheckPostType('delete', resource, permanentlyDeletePostAction);
 }
-function useRestorePostAction() {
-  const {
-    createSuccessNotice,
-    createErrorNotice
-  } = useDispatch(noticesStore);
-  const {
-    editEntityRecord,
-    saveEditedEntityRecord
-  } = useDispatch(coreStore);
-  return useMemo(() => ({
-    id: 'restore',
-    label: __('Restore'),
-    isPrimary: true,
-    icon: backup,
-    supportsBulk: true,
-    isEligible({
+const restorePostAction = {
+  id: 'restore',
+  label: __('Restore'),
+  isPrimary: true,
+  icon: backup,
+  supportsBulk: true,
+  isEligible({
+    status
+  }) {
+    return status === 'trash';
+  },
+  async callback(posts, {
+    registry,
+    onActionPerformed
+  }) {
+    const {
+      createSuccessNotice,
+      createErrorNotice
+    } = registry.dispatch(noticesStore);
+    const {
+      editEntityRecord,
+      saveEditedEntityRecord
+    } = registry.dispatch(coreStore);
+    await Promise.allSettled(posts.map(post => {
+      return editEntityRecord('postType', post.type, post.id, {
+        status: 'draft'
+      });
+    }));
+    const promiseResult = await Promise.allSettled(posts.map(post => {
+      return saveEditedEntityRecord('postType', post.type, post.id, {
+        throwOnError: true
+      });
+    }));
+    if (promiseResult.every(({
       status
-    }) {
-      return status === 'trash';
-    },
-    async callback(posts, onActionPerformed) {
-      await Promise.allSettled(posts.map(post => {
-        return editEntityRecord('postType', post.type, post.id, {
-          status: 'draft'
-        });
-      }));
-      const promiseResult = await Promise.allSettled(posts.map(post => {
-        return saveEditedEntityRecord('postType', post.type, post.id, {
-          throwOnError: true
-        });
-      }));
-      if (promiseResult.every(({
-        status
-      }) => status === 'fulfilled')) {
-        let successMessage;
-        if (posts.length === 1) {
-          successMessage = sprintf( /* translators: The number of posts. */
-          __('"%s" has been restored.'), getItemTitle(posts[0]));
-        } else if (posts[0].type === 'page') {
-          successMessage = sprintf( /* translators: The number of posts. */
-          __('%d pages have been restored.'), posts.length);
+    }) => status === 'fulfilled')) {
+      let successMessage;
+      if (posts.length === 1) {
+        successMessage = sprintf( /* translators: The number of posts. */
+        __('"%s" has been restored.'), getItemTitle(posts[0]));
+      } else if (posts[0].type === 'page') {
+        successMessage = sprintf( /* translators: The number of posts. */
+        __('%d pages have been restored.'), posts.length);
+      } else {
+        successMessage = sprintf( /* translators: The number of posts. */
+        __('%d posts have been restored.'), posts.length);
+      }
+      createSuccessNotice(successMessage, {
+        type: 'snackbar',
+        id: 'restore-post-action'
+      });
+      if (onActionPerformed) {
+        onActionPerformed(posts);
+      }
+    } else {
+      // If there was at lease one failure.
+      let errorMessage;
+      // If we were trying to move a single post to the trash.
+      if (promiseResult.length === 1) {
+        if (promiseResult[0].reason?.message) {
+          errorMessage = promiseResult[0].reason.message;
         } else {
-          successMessage = sprintf( /* translators: The number of posts. */
-          __('%d posts have been restored.'), posts.length);
-        }
-        createSuccessNotice(successMessage, {
-          type: 'snackbar',
-          id: 'restore-post-action'
-        });
-        if (onActionPerformed) {
-          onActionPerformed(posts);
+          errorMessage = __('An error occurred while restoring the post.');
         }
+        // If we were trying to move multiple posts to the trash
       } else {
-        // If there was at lease one failure.
-        let errorMessage;
-        // If we were trying to move a single post to the trash.
-        if (promiseResult.length === 1) {
-          if (promiseResult[0].reason?.message) {
-            errorMessage = promiseResult[0].reason.message;
-          } else {
-            errorMessage = __('An error occurred while restoring the post.');
+        const errorMessages = new Set();
+        const failedPromises = promiseResult.filter(({
+          status
+        }) => status === 'rejected');
+        for (const failedPromise of failedPromises) {
+          if (failedPromise.reason?.message) {
+            errorMessages.add(failedPromise.reason.message);
           }
-          // If we were trying to move multiple posts to the trash
+        }
+        if (errorMessages.size === 0) {
+          errorMessage = __('An error occurred while restoring the posts.');
+        } else if (errorMessages.size === 1) {
+          errorMessage = sprintf( /* translators: %s: an error message */
+          __('An error occurred while restoring the posts: %s'), [...errorMessages][0]);
         } else {
-          const errorMessages = new Set();
-          const failedPromises = promiseResult.filter(({
-            status
-          }) => status === 'rejected');
-          for (const failedPromise of failedPromises) {
-            if (failedPromise.reason?.message) {
-              errorMessages.add(failedPromise.reason.message);
-            }
-          }
-          if (errorMessages.size === 0) {
-            errorMessage = __('An error occurred while restoring the posts.');
-          } else if (errorMessages.size === 1) {
-            errorMessage = sprintf( /* translators: %s: an error message */
-            __('An error occurred while restoring the posts: %s'), [...errorMessages][0]);
-          } else {
-            errorMessage = sprintf( /* translators: %s: a list of comma separated error messages */
-            __('Some errors occurred while restoring the posts: %s'), [...errorMessages].join(','));
-          }
+          errorMessage = sprintf( /* translators: %s: a list of comma separated error messages */
+          __('Some errors occurred while restoring the posts: %s'), [...errorMessages].join(','));
         }
-        createErrorNotice(errorMessage, {
-          type: 'snackbar'
-        });
       }
+      createErrorNotice(errorMessage, {
+        type: 'snackbar'
+      });
     }
-  }), [createSuccessNotice, createErrorNotice, editEntityRecord, saveEditedEntityRecord]);
+  }
+};
+function useRestorePostAction(resource) {
+  return useCanUserEligibilityCheckPostType('update', resource, restorePostAction);
 }
 const viewPostAction = {
   id: 'view-post',
@@ -422,7 +370,9 @@ const viewPostAction = {
   isEligible(post) {
     return post.status !== 'trash';
   },
-  callback(posts, onActionPerformed) {
+  callback(posts, {
+    onActionPerformed
+  }) {
     const post = posts[0];
     window.open(post.link, '_blank');
     if (onActionPerformed) {
@@ -432,6 +382,7 @@ const viewPostAction = {
 };
 const postRevisionsAction = {
   id: 'view-post-revisions',
+  context: 'list',
   label(items) {
     var _items$0$_links$versi;
     const revisionsCount = (_items$0$_links$versi = items[0]._links?.['version-history']?.[0]?.count) !== null && _items$0$_links$versi !== void 0 ? _items$0$_links$versi : 0;
@@ -447,7 +398,9 @@ const postRevisionsAction = {
     const revisionsCount = (_post$_links$version = post?._links?.['version-history']?.[0]?.count) !== null && _post$_links$version !== void 0 ? _post$_links$version : 0;
     return lastRevisionId && revisionsCount > 1;
   },
-  callback(posts, onActionPerformed) {
+  callback(posts, {
+    onActionPerformed
+  }) {
     const post = posts[0];
     const href = addQueryArgs('revision.php', {
       revision: post?._links?.['predecessor-version']?.[0]?.id
@@ -479,8 +432,8 @@ const renamePostAction = {
     // In patterns list page we map the templates parts to a different object
     // than the one returned from the endpoint. This is why we need to check for
     // two props whether is custom or has a theme file.
-    const isCustomPattern = isUserPattern || isTemplatePart && (post.isCustom || post.source === TEMPLATE_ORIGINS.custom);
-    const hasThemeFile = isTemplatePart && (post.templatePart?.has_theme_file || post.has_theme_file);
+    const isCustomPattern = isUserPattern || isTemplatePart && post.source === TEMPLATE_ORIGINS.custom;
+    const hasThemeFile = post?.has_theme_file;
     return isCustomPattern && !hasThemeFile;
   },
   RenderModal: ({
@@ -489,8 +442,7 @@ const renamePostAction = {
     onActionPerformed
   }) => {
     const [item] = items;
-    const originalTitle = decodeEntities(typeof item.title === 'string' ? item.title : item.title.rendered);
-    const [title, setTitle] = useState(() => originalTitle);
+    const [title, setTitle] = useState(() => getItemTitle(item));
     const {
       editEntityRecord,
       saveEditedEntityRecord
@@ -554,42 +506,57 @@ const renamePostAction = {
     });
   }
 };
-const duplicatePostAction = {
-  id: 'duplicate-post',
-  label: _x('Duplicate', 'action label'),
-  isEligible({
-    status
-  }) {
-    return status !== 'trash';
-  },
-  RenderModal: ({
-    items,
-    closeModal,
-    onActionPerformed
-  }) => {
-    const [item] = items;
-    const [isCreatingPage, setIsCreatingPage] = useState(false);
-    const [title, setTitle] = useState(sprintf( /* translators: %s: Existing item title */
-    __('%s (Copy)'), getItemTitle(item)));
-    const {
-      saveEntityRecord
-    } = useDispatch(coreStore);
+function useRenamePostAction(resource) {
+  return useCanUserEligibilityCheckPostType('update', resource, renamePostAction);
+}
+const useDuplicatePostAction = postType => {
+  const {
+    userCanCreatePost
+  } = useSelect(select => {
     const {
-      createSuccessNotice,
-      createErrorNotice
-    } = useDispatch(noticesStore);
-    async function createPage(event) {
-      event.preventDefault();
-      if (isCreatingPage) {
-        return;
-      }
-      setIsCreatingPage(true);
-      try {
-        const newItem = await saveEntityRecord('postType', item.type, {
+      getPostType,
+      canUser
+    } = select(coreStore);
+    const resource = getPostType(postType)?.rest_base || '';
+    return {
+      userCanCreatePost: canUser('create', resource)
+    };
+  }, [postType]);
+  return useMemo(() => userCanCreatePost && {
+    id: 'duplicate-post',
+    label: _x('Duplicate', 'action label'),
+    isEligible({
+      status
+    }) {
+      return status !== 'trash';
+    },
+    RenderModal: ({
+      items,
+      closeModal,
+      onActionPerformed
+    }) => {
+      const [item, setItem] = useState({
+        ...items[0],
+        title: sprintf( /* translators: %s: Existing template title */
+        __('%s (Copy)'), getItemTitle(items[0]))
+      });
+      const [isCreatingPage, setIsCreatingPage] = useState(false);
+      const {
+        saveEntityRecord
+      } = useDispatch(coreStore);
+      const {
+        createSuccessNotice,
+        createErrorNotice
+      } = useDispatch(noticesStore);
+      async function createPage(event) {
+        event.preventDefault();
+        if (isCreatingPage) {
+          return;
+        }
+        const newItemOject = {
           status: 'draft',
-          title,
-          slug: title || __('No title'),
-          author: item.author,
+          title: item.title,
+          slug: item.title || __('No title'),
           comment_status: item.comment_status,
           content: typeof item.content === 'string' ? item.content : item.content.raw,
           excerpt: item.excerpt.raw,
@@ -600,158 +567,71 @@ const duplicatePostAction = {
           format: item.format,
           featured_media: item.featured_media,
           menu_order: item.menu_order,
-          ping_status: item.ping_status,
-          categories: item.categories,
-          tags: item.tags
-        }, {
-          throwOnError: true
-        });
-        createSuccessNotice(sprintf(
-        // translators: %s: Title of the created template e.g: "Category".
-        __('"%s" successfully created.'), decodeEntities(newItem.title?.rendered || title)), {
-          id: 'duplicate-post-action',
-          type: 'snackbar'
-        });
-        if (onActionPerformed) {
-          onActionPerformed([newItem]);
-        }
-      } catch (error) {
-        const errorMessage = error.message && error.code !== 'unknown_error' ? error.message : __('An error occurred while duplicating the page.');
-        createErrorNotice(errorMessage, {
-          type: 'snackbar'
+          ping_status: item.ping_status
+        };
+        const assignablePropertiesPrefix = 'wp:action-assign-';
+        // Get all the properties that the current user is able to assign normally author, categories, tags,
+        // and custom taxonomies.
+        const assignableProperties = Object.keys(item?._links || {}).filter(property => property.startsWith(assignablePropertiesPrefix)).map(property => property.slice(assignablePropertiesPrefix.length));
+        assignableProperties.forEach(property => {
+          if (item[property]) {
+            newItemOject[property] = item[property];
+          }
         });
-      } finally {
-        setIsCreatingPage(false);
-        closeModal();
-      }
-    }
-    return /*#__PURE__*/_jsx("form", {
-      onSubmit: createPage,
-      children: /*#__PURE__*/_jsxs(VStack, {
-        spacing: 3,
-        children: [/*#__PURE__*/_jsx(TextControl, {
-          label: __('Title'),
-          onChange: setTitle,
-          placeholder: __('No title'),
-          value: title
-        }), /*#__PURE__*/_jsxs(HStack, {
-          spacing: 2,
-          justify: "end",
-          children: [/*#__PURE__*/_jsx(Button, {
-            variant: "tertiary",
-            onClick: closeModal,
-            children: __('Cancel')
-          }), /*#__PURE__*/_jsx(Button, {
-            variant: "primary",
-            type: "submit",
-            isBusy: isCreatingPage,
-            "aria-disabled": isCreatingPage,
-            children: _x('Duplicate', 'action label')
-          })]
-        })]
-      })
-    });
-  }
-};
-const isTemplatePartRevertable = item => {
-  if (!item) {
-    return false;
-  }
-  const hasThemeFile = item.templatePart?.has_theme_file;
-  return canDeleteOrReset(item) && hasThemeFile;
-};
-const resetTemplateAction = {
-  id: 'reset-template',
-  label: __('Reset'),
-  isEligible: item => {
-    return item.type === TEMPLATE_PART_POST_TYPE ? isTemplatePartRevertable(item) : isTemplateRevertable(item);
-  },
-  icon: backup,
-  supportsBulk: true,
-  hideModalHeader: true,
-  RenderModal: ({
-    items,
-    closeModal,
-    onActionStart,
-    onActionPerformed
-  }) => {
-    const [isBusy, setIsBusy] = useState(false);
-    const {
-      revertTemplate,
-      removeTemplates
-    } = unlock(useDispatch(editorStore));
-    const {
-      saveEditedEntityRecord
-    } = useDispatch(coreStore);
-    const {
-      createSuccessNotice,
-      createErrorNotice
-    } = useDispatch(noticesStore);
-    const onConfirm = async () => {
-      try {
-        if (items[0].type === TEMPLATE_PART_POST_TYPE) {
-          await removeTemplates(items);
-        } else {
-          for (const template of items) {
-            if (template.type === TEMPLATE_POST_TYPE) {
-              await revertTemplate(template, {
-                allowUndo: false
-              });
-              await saveEditedEntityRecord('postType', template.type, template.id);
-            }
+        setIsCreatingPage(true);
+        try {
+          const newItem = await saveEntityRecord('postType', item.type, newItemOject, {
+            throwOnError: true
+          });
+          createSuccessNotice(sprintf(
+          // translators: %s: Title of the created template e.g: "Category".
+          __('"%s" successfully created.'), decodeEntities(newItem.title?.rendered || item.title)), {
+            id: 'duplicate-post-action',
+            type: 'snackbar'
+          });
+          if (onActionPerformed) {
+            onActionPerformed([newItem]);
           }
-          createSuccessNotice(items.length > 1 ? sprintf( /* translators: The number of items. */
-          __('%s items reset.'), items.length) : sprintf( /* translators: The template/part's name. */
-          __('"%s" reset.'), decodeEntities(getItemTitle(items[0]))), {
-            type: 'snackbar',
-            id: 'revert-template-action'
+        } catch (error) {
+          const errorMessage = error.message && error.code !== 'unknown_error' ? error.message : __('An error occurred while duplicating the page.');
+          createErrorNotice(errorMessage, {
+            type: 'snackbar'
           });
+        } finally {
+          setIsCreatingPage(false);
+          closeModal();
         }
-      } catch (error) {
-        let fallbackErrorMessage;
-        if (items[0].type === TEMPLATE_POST_TYPE) {
-          fallbackErrorMessage = items.length === 1 ? __('An error occurred while reverting the template.') : __('An error occurred while reverting the templates.');
-        } else {
-          fallbackErrorMessage = items.length === 1 ? __('An error occurred while reverting the template part.') : __('An error occurred while reverting the template parts.');
-        }
-        const errorMessage = error.message && error.code !== 'unknown_error' ? error.message : fallbackErrorMessage;
-        createErrorNotice(errorMessage, {
-          type: 'snackbar'
-        });
       }
-    };
-    return /*#__PURE__*/_jsxs(VStack, {
-      spacing: "5",
-      children: [/*#__PURE__*/_jsx(Text, {
-        children: __('Reset to default and clear all customizations?')
-      }), /*#__PURE__*/_jsxs(HStack, {
-        justify: "right",
-        children: [/*#__PURE__*/_jsx(Button, {
-          variant: "tertiary",
-          onClick: closeModal,
-          disabled: isBusy,
-          __experimentalIsFocusable: true,
-          children: __('Cancel')
-        }), /*#__PURE__*/_jsx(Button, {
-          variant: "primary",
-          onClick: async () => {
-            setIsBusy(true);
-            if (onActionStart) {
-              onActionStart(items);
-            }
-            await onConfirm(items);
-            onActionPerformed?.(items);
-            setIsBusy(false);
-            closeModal();
-          },
-          isBusy: isBusy,
-          disabled: isBusy,
-          __experimentalIsFocusable: true,
-          children: __('Reset')
-        })]
-      })]
-    });
-  }
+      return /*#__PURE__*/_jsx("form", {
+        onSubmit: createPage,
+        children: /*#__PURE__*/_jsxs(VStack, {
+          spacing: 3,
+          children: [/*#__PURE__*/_jsx(DataForm, {
+            data: item,
+            fields: fields,
+            form: form,
+            onChange: setItem
+          }), /*#__PURE__*/_jsxs(HStack, {
+            spacing: 2,
+            justify: "end",
+            children: [/*#__PURE__*/_jsx(Button, {
+              variant: "tertiary",
+              onClick: closeModal,
+              __next40pxDefaultSize: true,
+              children: __('Cancel')
+            }), /*#__PURE__*/_jsx(Button, {
+              variant: "primary",
+              type: "submit",
+              isBusy: isCreatingPage,
+              "aria-disabled": isCreatingPage,
+              __next40pxDefaultSize: true,
+              children: _x('Duplicate', 'action label')
+            })]
+          })]
+        })
+      });
+    }
+  }, [userCanCreatePost]);
 };
 export const duplicatePatternAction = {
   id: 'duplicate-pattern',
@@ -763,9 +643,8 @@ export const duplicatePatternAction = {
     closeModal
   }) => {
     const [item] = items;
-    const isThemePattern = item.type === PATTERN_TYPES.theme;
     const duplicatedProps = useDuplicatePatternProps({
-      pattern: isThemePattern || !item.patternPost ? item : item.patternPost,
+      pattern: item,
       onSuccess: () => closeModal()
     });
     return /*#__PURE__*/_jsx(CreatePatternModalContents, {
@@ -785,47 +664,70 @@ export const duplicateTemplatePartAction = {
     closeModal
   }) => {
     const [item] = items;
+    const blocks = useMemo(() => {
+      var _item$blocks;
+      return (_item$blocks = item.blocks) !== null && _item$blocks !== void 0 ? _item$blocks : parse(item.content.raw, {
+        __unstableSkipMigrationLogs: true
+      });
+    }, [item?.content?.raw, item.blocks]);
     const {
       createSuccessNotice
     } = useDispatch(noticesStore);
     function onTemplatePartSuccess() {
       createSuccessNotice(sprintf(
       // translators: %s: The new template part's title e.g. 'Call to action (copy)'.
-      __('"%s" duplicated.'), item.title), {
+      __('"%s" duplicated.'), getItemTitle(item)), {
         type: 'snackbar',
         id: 'edit-site-patterns-success'
       });
       closeModal();
     }
     return /*#__PURE__*/_jsx(CreateTemplatePartModalContents, {
-      blocks: item.blocks,
-      defaultArea: item.templatePart?.area || item.area,
+      blocks: blocks,
+      defaultArea: item.area,
       defaultTitle: sprintf( /* translators: %s: Existing template part title */
-      __('%s (Copy)'), item.title),
+      __('%s (Copy)'), getItemTitle(item)),
       onCreate: onTemplatePartSuccess,
       onError: closeModal,
       confirmLabel: _x('Duplicate', 'action label')
     });
   }
 };
-export function usePostActions(postType, onActionPerformed) {
+export function usePostActions({
+  postType,
+  onActionPerformed,
+  context
+}) {
   const {
     defaultActions,
-    postTypeObject
+    postTypeObject,
+    userCanCreatePostType,
+    resource,
+    cachedCanUserResolvers
   } = useSelect(select => {
     const {
-      getPostType
+      getPostType,
+      canUser,
+      getCachedResolvers
     } = select(coreStore);
     const {
       getEntityActions
     } = unlock(select(editorStore));
+    const _postTypeObject = getPostType(postType);
+    const _resource = _postTypeObject?.rest_base || '';
     return {
-      postTypeObject: getPostType(postType),
-      defaultActions: getEntityActions('postType', postType)
+      postTypeObject: _postTypeObject,
+      defaultActions: getEntityActions('postType', postType),
+      userCanCreatePostType: canUser('create', _resource),
+      resource: _resource,
+      cachedCanUserResolvers: getCachedResolvers()?.canUser
     };
   }, [postType]);
-  const permanentlyDeletePostAction = usePermanentlyDeletePostAction();
-  const restorePostAction = useRestorePostAction();
+  const duplicatePostAction = useDuplicatePostAction(postType);
+  const trashPostActionForPostType = useTrashPostAction(resource);
+  const permanentlyDeletePostActionForPostType = usePermanentlyDeletePostAction(resource);
+  const renamePostActionForPostType = useRenamePostAction(resource);
+  const restorePostActionForPostType = useRestorePostAction(resource);
   const isTemplateOrTemplatePart = [TEMPLATE_POST_TYPE, TEMPLATE_PART_POST_TYPE].includes(postType);
   const isPattern = postType === PATTERN_POST_TYPE;
   const isLoaded = !!postTypeObject;
@@ -835,19 +737,34 @@ export function usePostActions(postType, onActionPerformed) {
     if (!isLoaded) {
       return [];
     }
-    const actions = [postTypeObject?.viewable && viewPostAction, supportsRevisions && postRevisionsAction, globalThis.IS_GUTENBERG_PLUGIN ? !isTemplateOrTemplatePart && !isPattern && duplicatePostAction : false, isTemplateOrTemplatePart && duplicateTemplatePartAction, isPattern && duplicatePatternAction, supportsTitle && renamePostAction, isPattern && exportPatternAsJSONAction, isTemplateOrTemplatePart ? resetTemplateAction : restorePostAction, isTemplateOrTemplatePart || isPattern ? deletePostAction : trashPostAction, !isTemplateOrTemplatePart && permanentlyDeletePostAction, ...defaultActions].filter(Boolean);
+    let actions = [postTypeObject?.viewable && viewPostAction, supportsRevisions && postRevisionsAction, globalThis.IS_GUTENBERG_PLUGIN ? !isTemplateOrTemplatePart && !isPattern && duplicatePostAction : false, isTemplateOrTemplatePart && userCanCreatePostType && duplicateTemplatePartAction, isPattern && userCanCreatePostType && duplicatePatternAction, supportsTitle && renamePostActionForPostType, !isTemplateOrTemplatePart && restorePostActionForPostType, !isTemplateOrTemplatePart && !isPattern && trashPostActionForPostType, !isTemplateOrTemplatePart && permanentlyDeletePostActionForPostType, ...defaultActions].filter(Boolean);
+    // Filter actions based on provided context. If not provided
+    // all actions are returned. We'll have a single entry for getting the actions
+    // and the consumer should provide the context to filter the actions, if needed.
+    // Actions should also provide the `context` they support, if it's specific, to
+    // compare with the provided context to get all the actions.
+    // Right now the only supported context is `list`.
+    actions = actions.filter(action => {
+      if (!action.context) {
+        return true;
+      }
+      return action.context === context;
+    });
     if (onActionPerformed) {
       for (let i = 0; i < actions.length; ++i) {
         if (actions[i].callback) {
           const existingCallback = actions[i].callback;
           actions[i] = {
             ...actions[i],
-            callback: (items, _onActionPerformed) => {
-              existingCallback(items, _items => {
-                if (_onActionPerformed) {
-                  _onActionPerformed(_items);
+            callback: (items, argsObject) => {
+              existingCallback(items, {
+                ...argsObject,
+                onActionPerformed: _items => {
+                  if (argsObject.onActionPerformed) {
+                    argsObject.onActionPerformed(_items);
+                  }
+                  onActionPerformed(actions[i].id, _items);
                 }
-                onActionPerformed(actions[i].id, _items);
               });
             }
           };
@@ -872,6 +789,9 @@ export function usePostActions(postType, onActionPerformed) {
       }
     }
     return actions;
-  }, [defaultActions, isTemplateOrTemplatePart, isPattern, postTypeObject?.viewable, permanentlyDeletePostAction, restorePostAction, onActionPerformed, isLoaded, supportsRevisions, supportsTitle]);
+    // We are making this use memo depend on cachedCanUserResolvers as a way to make the component using this hook re-render
+    // when user capabilities are resolved. This makes sure the isEligible functions of actions dependent on capabilities are re-evaluated.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [defaultActions, userCanCreatePostType, isTemplateOrTemplatePart, isPattern, postTypeObject?.viewable, duplicatePostAction, trashPostActionForPostType, restorePostActionForPostType, renamePostActionForPostType, permanentlyDeletePostActionForPostType, onActionPerformed, isLoaded, supportsRevisions, supportsTitle, context, cachedCanUserResolvers]);
 }
 //# sourceMappingURL=actions.js.map