@strapi/admin 4.19.1 → 4.20.1

package/dist/_chunks/{index-8XZny-tn.js → index-Cgd3dGa5.js}

@@ -2099,11 +2099,11 @@ const AuthPage = ({ hasAdmin }) => {
   const authType = match?.params.authType;
   const Login$1 = useEnterprise(
     Login,
-    async () => (await Promise.resolve().then(() => require("./Login-Vr4FnBhc.js"))).LoginEE
+    async () => (await Promise.resolve().then(() => require("./Login-7WAjQzlh.js"))).LoginEE
   );
   const forms = useEnterprise(
     FORMS,
-    async () => (await Promise.resolve().then(() => require("./constants-Nt1Jcadb.js"))).FORMS,
+    async () => (await Promise.resolve().then(() => require("./constants-Z-tu-qfL.js"))).FORMS,
     {
       combine(ceForms, eeForms) {
         return {
@@ -2340,12 +2340,12 @@ const createRoute = (loadComponent, to, exact = false) => {
 };
 const ROUTES_CE = null;
 const AuthenticatedApp = React__namespace.lazy(
-  () => Promise.resolve().then(() => require("./AuthenticatedApp-_KGmPDjE.js")).then((n) => n.AuthenticatedApp).then((mod) => ({ default: mod.AuthenticatedApp }))
+  () => Promise.resolve().then(() => require("./AuthenticatedApp-yPEMtCNB.js")).then((n) => n.AuthenticatedApp).then((mod) => ({ default: mod.AuthenticatedApp }))
 );
 const App$2 = ({ authLogo, menuLogo, showReleaseNotification, showTutorials }) => {
   const adminPermissions = useEnterprise(
     ADMIN_PERMISSIONS_CE,
-    async () => (await Promise.resolve().then(() => require("./constants-eKDRAcnv.js"))).ADMIN_PERMISSIONS_EE,
+    async () => (await Promise.resolve().then(() => require("./constants-_KHV_ADp.js"))).ADMIN_PERMISSIONS_EE,
     {
       combine(cePermissions, eePermissions) {
         return merge__default.default({}, cePermissions, eePermissions);
@@ -2355,7 +2355,7 @@ const App$2 = ({ authLogo, menuLogo, showReleaseNotification, showTutorials }) =
   );
   const routes = useEnterprise(
     ROUTES_CE,
-    async () => (await Promise.resolve().then(() => require("./constants-eKDRAcnv.js"))).ROUTES_EE,
+    async () => (await Promise.resolve().then(() => require("./constants-_KHV_ADp.js"))).ROUTES_EE,
     {
       defaultValue: []
     }
@@ -6733,6 +6733,7 @@ const ContentTypeFormWrapper = ({
       dispatch(resetProps$2());
     };
   }, [dispatch]);
+  const validParams = React__namespace.useMemo(() => buildValidGetParams(query), [query]);
   React__namespace.useEffect(() => {
     const CancelToken = axios__default.default.CancelToken;
     const source = CancelToken.source();
@@ -6744,7 +6745,7 @@ const ContentTypeFormWrapper = ({
       try {
         const { data: data2 } = await fetchClient.get(requestURL, {
           cancelToken: source2.token,
-          params: buildValidGetParams(query)
+          params: validParams
         });
         dispatch(getDataSucceeded$1(cleanReceivedData(data2)));
       } catch (err) {
@@ -6793,7 +6794,7 @@ const ContentTypeFormWrapper = ({
     redirectionLink,
     toggleNotification,
     isSingleType,
-    query
+    validParams
   ]);
   const displayErrors = React__namespace.useCallback(
     (err) => {
@@ -6848,7 +6849,7 @@ const ContentTypeFormWrapper = ({
           isCloning ? `/content-manager/${collectionType}/${slug}/clone/${origin}` : `/content-manager/${collectionType}/${slug}`,
           isCloning ? restBody : body,
           {
-            params: query
+            params: validParams
           }
         );
         trackUsage("didCreateEntry", trackerProperty);
@@ -6880,7 +6881,7 @@ const ContentTypeFormWrapper = ({
       put,
       post,
       slug,
-      query,
+      validParams,
       trackUsage,
       toggleNotification,
       setCurrentStep,
@@ -6917,7 +6918,11 @@ const ContentTypeFormWrapper = ({
       trackUsage("willPublishEntry");
       dispatch(setStatus("publish-pending"));
       const { data: data2 } = await post(
-        isSingleType ? `/content-manager/${collectionType}/${slug}/actions/publish` : `/content-manager/${collectionType}/${slug}/${id}/actions/publish`
+        isSingleType ? `/content-manager/${collectionType}/${slug}/actions/publish` : `/content-manager/${collectionType}/${slug}/${id}/actions/publish`,
+        void 0,
+        {
+          params: validParams
+        }
       );
       trackUsage("didPublishEntry");
       dispatch(submitSucceeded(cleanReceivedData(data2)));
@@ -6942,6 +6947,7 @@ const ContentTypeFormWrapper = ({
     collectionType,
     slug,
     id,
+    validParams,
     cleanReceivedData,
     toggleNotification,
     displayErrors
@@ -6952,7 +6958,7 @@ const ContentTypeFormWrapper = ({
         trackUsage("willEditEntry", trackerProperty);
         dispatch(setStatus("submit-pending"));
         const { data: data2 } = await put(`/content-manager/${collectionType}/${slug}/${id}`, body, {
-          params: query
+          params: validParams
         });
         trackUsage("didEditEntry", trackerProperty);
         toggleNotification({
@@ -6979,6 +6985,7 @@ const ContentTypeFormWrapper = ({
       collectionType,
       slug,
       id,
+      validParams,
       toggleNotification,
       queryClient2,
       cleanReceivedData,
@@ -6990,7 +6997,11 @@ const ContentTypeFormWrapper = ({
     try {
       trackUsage("willUnpublishEntry");
       const { data: data2 } = await post(
-        isSingleType ? `/content-manager/${collectionType}/${slug}/actions/unpublish` : `/content-manager/${collectionType}/${slug}/${id}/actions/unpublish`
+        isSingleType ? `/content-manager/${collectionType}/${slug}/actions/unpublish` : `/content-manager/${collectionType}/${slug}/${id}/actions/unpublish`,
+        void 0,
+        {
+          params: validParams
+        }
       );
       trackUsage("didUnpublishEntry");
       toggleNotification({
@@ -7014,6 +7025,7 @@ const ContentTypeFormWrapper = ({
     collectionType,
     slug,
     id,
+    validParams,
     toggleNotification,
     cleanReceivedData,
     displayErrors
@@ -7337,12 +7349,16 @@ const Hint = ({ id, error, name: name2, hint = "" }) => {
   return /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { as: "p", variant: "pi", id: `${id || name2}-hint`, textColor: "neutral600", children: hint });
 };
 const baseHandleConvert = (editor, attributesToSet) => {
+  const [_, lastNodePath] = slate.Editor.last(editor, []);
   slate.Transforms.unwrapNodes(editor, {
     match: (node) => !slate.Editor.isEditor(node) && node.type === "list",
-    split: true
+    split: true,
+    at: editor.selection ?? lastNodePath
   });
+  const [, updatedLastNodePath] = slate.Editor.last(editor, []);
   const entry = slate.Editor.above(editor, {
-    match: (node) => !slate.Editor.isEditor(node) && node.type !== "text" && node.type !== "link"
+    match: (node) => !slate.Editor.isEditor(node) && node.type !== "text" && node.type !== "link",
+    at: editor.selection ?? updatedLastNodePath
   });
   if (!entry || slate.Editor.isEditor(entry[0])) {
     return;
@@ -7777,7 +7793,9 @@ const LinkContent = React__namespace.forwardRef(
       setIsSaveDisabled(false);
       setLinkUrl(e.target.value);
       try {
-        new URL(e.target.value);
+        new URL(
+          e.target.value?.startsWith("/") ? `https://strapi.io${e.target.value}` : e.target.value
+        );
       } catch (error) {
         setIsSaveDisabled(true);
       }
@@ -7902,7 +7920,7 @@ const linkBlocks = {
 const listStyle = styled.css`
   display: flex;
   flex-direction: column;
-  gap: ${({ theme }) => theme.spaces[1]};
+  gap: ${({ theme }) => theme.spaces[2]};
   margin-inline-start: ${({ theme }) => theme.spaces[0]};
   margin-inline-end: ${({ theme }) => theme.spaces[0]};
   padding-inline-start: ${({ theme }) => theme.spaces[2]};
@@ -7918,21 +7936,26 @@ const listStyle = styled.css`
   }
 `;
 const Orderedlist = styled__default.default.ol`
-  list-style-type: decimal;
+  list-style-type: ${(props) => props.listStyleType};
   ${listStyle}
 `;
 const Unorderedlist = styled__default.default.ul`
-  list-style-type: disc;
+  list-style-type: ${(props) => props.listStyleType};
   ${listStyle}
 `;
+const orderedStyles = ["decimal", "lower-alpha", "upper-roman"];
+const unorderedStyles = ["disc", "circle", "square"];
 const List = ({ attributes, children, element }) => {
   if (!isListNode$1(element)) {
     return null;
   }
+  const listStyles = element.format === "ordered" ? orderedStyles : unorderedStyles;
+  const nextIndex = (element.indentLevel || 0) % listStyles.length;
+  const listStyleType = listStyles[nextIndex];
   if (element.format === "ordered") {
-    return /* @__PURE__ */ jsxRuntime.jsx(Orderedlist, { ...attributes, children });
+    return /* @__PURE__ */ jsxRuntime.jsx(Orderedlist, { listStyleType, ...attributes, children });
   }
-  return /* @__PURE__ */ jsxRuntime.jsx(Unorderedlist, { ...attributes, children });
+  return /* @__PURE__ */ jsxRuntime.jsx(Unorderedlist, { listStyleType, ...attributes, children });
 };
 const replaceListWithEmptyBlock = (editor, currentListPath) => {
   slate.Transforms.removeNodes(editor, { at: currentListPath });
@@ -7957,27 +7980,44 @@ const handleBackspaceKeyOnList = (editor, event) => {
   const [currentListItem, currentListItemPath] = slate.Editor.parent(editor, editor.selection.anchor);
   const [currentList, currentListPath] = slate.Editor.parent(editor, currentListItemPath);
   const isListEmpty = currentList.children.length === 1 && isText$1(currentListItem.children[0]) && currentListItem.children[0].text === "";
-  const isNodeStart = slate.Editor.isStart(editor, editor.selection.anchor, currentListItemPath);
-  const isFocusAtTheBeginningOfAChild = editor.selection.focus.offset === 0 && editor.selection.focus.path.at(-1) === 0;
+  const isListItemEmpty = currentListItem.children.length === 1 && isText$1(currentListItem.children[0]) && currentListItem.children[0].text === "";
+  const isFocusAtTheBeginningOfAChild = editor.selection.focus.offset === 0 && editor.selection.focus.path.at(-2) === 0;
   if (isListEmpty) {
-    event.preventDefault();
-    replaceListWithEmptyBlock(editor, currentListPath);
-  } else if (isNodeStart) {
-    slate.Transforms.liftNodes(editor, {
-      match: (node) => !slate.Editor.isEditor(node) && node.type === "list-item"
+    const parentListEntry = slate.Editor.above(editor, {
+      at: currentListPath,
+      match: (node) => !slate.Editor.isEditor(node) && node.type === "list"
     });
-    slate.Transforms.setNodes(
-      editor,
-      { type: "paragraph" },
-      {
-        hanging: true
-      }
-    );
+    if (!parentListEntry) {
+      event.preventDefault();
+      replaceListWithEmptyBlock(editor, currentListPath);
+    }
   } else if (isFocusAtTheBeginningOfAChild) {
     slate.Transforms.liftNodes(editor, {
       match: (node) => !slate.Editor.isEditor(node) && node.type === "list-item"
     });
     slate.Transforms.setNodes(editor, { type: "paragraph" });
+  } else if (isListItemEmpty) {
+    const previousEntry = slate.Editor.previous(editor, {
+      at: currentListItemPath
+    });
+    const nextEntry = slate.Editor.next(editor, {
+      at: currentListItemPath
+    });
+    if (previousEntry && nextEntry) {
+      event.preventDefault();
+      slate.Transforms.removeNodes(editor, {
+        at: currentListItemPath
+      });
+      const [previousList] = previousEntry;
+      const [nextList] = nextEntry;
+      if (!slate.Editor.isEditor(previousList) && !isText$1(previousList) && isListNode$1(previousList) && !slate.Editor.isEditor(nextList) && !isText$1(nextList) && isListNode$1(nextList)) {
+        if (previousList.type === "list" && nextList.type === "list" && previousList.format === nextList.format && previousList.indentLevel === nextList.indentLevel) {
+          slate.Transforms.mergeNodes(editor, {
+            at: currentListItemPath
+          });
+        }
+      }
+    }
   }
 };
 const handleEnterKeyOnList = (editor) => {
@@ -7991,17 +8031,40 @@ const handleEnterKeyOnList = (editor) => {
   const [currentList, currentListPath] = slate.Editor.parent(editor, currentListItemPath);
   const isListEmpty = currentList.children.length === 1 && isText$1(currentListItem.children[0]) && currentListItem.children[0].text === "";
   const isListItemEmpty = currentListItem.children.length === 1 && isText$1(currentListItem.children[0]) && currentListItem.children[0].text === "";
+  const isFocusAtTheBeginningOfAChild = editor.selection.focus.offset === 0 && editor.selection.focus.path.at(-1) === 0;
   if (isListEmpty) {
     replaceListWithEmptyBlock(editor, currentListPath);
+  } else if (isFocusAtTheBeginningOfAChild && !isListItemEmpty) {
+    const currentNode = slate.Editor.above(editor, { at: editor.selection.anchor });
+    slate.Transforms.insertNodes(editor, { type: "list-item", children: [{ type: "text", text: "" }] });
+    if (currentNode) {
+      const path = currentNode[1];
+      const updatedPath = [...path.slice(0, -1), path[path.length - 1] + 1];
+      slate.Transforms.select(editor, {
+        anchor: { path: updatedPath.concat(0), offset: 0 },
+        focus: { path: updatedPath.concat(0), offset: 0 }
+      });
+    }
   } else if (isListItemEmpty) {
-    slate.Transforms.removeNodes(editor, { at: currentListItemPath });
-    const listNodeEntry = slate.Editor.above(editor, {
-      match: (node) => !slate.Editor.isEditor(node) && node.type === "list"
-    });
-    if (!listNodeEntry) {
-      return;
+    if (!slate.Editor.isEditor(currentList) && isListNode$1(currentList) && currentList?.indentLevel && currentList.indentLevel > 0) {
+      const previousIndentLevel = currentList.indentLevel - 1;
+      const parentListNodeEntry = slate.Editor.above(editor, {
+        match: (node) => !slate.Editor.isEditor(node) && node.type === "list" && (node.indentLevel || 0) === previousIndentLevel
+      });
+      if (parentListNodeEntry) {
+        const modifiedPath = currentListItemPath.slice(0, -1);
+        if (modifiedPath.length > 0) {
+          modifiedPath[modifiedPath.length - 1] += 1;
+        }
+        slate.Transforms.moveNodes(editor, {
+          at: currentListItemPath,
+          to: modifiedPath
+        });
+        return;
+      }
     }
-    const createdParagraphPath = slate.Path.next(listNodeEntry[1]);
+    slate.Transforms.removeNodes(editor, { at: currentListItemPath });
+    const createdParagraphPath = slate.Path.next(currentListPath);
     slate.Transforms.insertNodes(
       editor,
       {
@@ -8026,6 +8089,37 @@ const handleConvertToList = (editor, format) => {
     return;
   slate.Transforms.wrapNodes(editor, { type: "list", format, children: [] }, { at: convertedPath });
 };
+const handleTabOnList = (editor) => {
+  const currentListItemEntry = slate.Editor.above(editor, {
+    match: (node) => !slate.Editor.isEditor(node) && node.type === "list-item"
+  });
+  if (!currentListItemEntry || !editor.selection) {
+    return;
+  }
+  const [currentListItem, currentListItemPath] = currentListItemEntry;
+  const [currentList] = slate.Editor.parent(editor, currentListItemPath);
+  if (currentListItem === currentList.children[0])
+    return;
+  const currentListItemIndex = currentList.children.findIndex((item) => item === currentListItem);
+  const previousNode = currentList.children[currentListItemIndex - 1];
+  if (previousNode.type === "list") {
+    const nodePath = slateReact.ReactEditor.findPath(editor, previousNode);
+    const insertAtPath = previousNode.children.length;
+    slate.Transforms.moveNodes(editor, {
+      at: currentListItemPath,
+      to: nodePath.concat(insertAtPath)
+    });
+    return;
+  }
+  if (!slate.Editor.isEditor(currentList) && isListNode$1(currentList)) {
+    slate.Transforms.wrapNodes(editor, {
+      type: "list",
+      format: currentList.format,
+      indentLevel: (currentList.indentLevel || 0) + 1,
+      children: []
+    });
+  }
+};
 const listBlocks = {
   "list-ordered": {
     renderElement: (props) => /* @__PURE__ */ jsxRuntime.jsx(List, { ...props }),
@@ -8039,6 +8133,7 @@ const listBlocks = {
     handleConvert: (editor) => handleConvertToList(editor, "ordered"),
     handleEnterKey: handleEnterKeyOnList,
     handleBackspaceKey: handleBackspaceKeyOnList,
+    handleTab: handleTabOnList,
     snippets: ["1."]
   },
   "list-unordered": {
@@ -8053,6 +8148,7 @@ const listBlocks = {
     handleConvert: (editor) => handleConvertToList(editor, "unordered"),
     handleEnterKey: handleEnterKeyOnList,
     handleBackspaceKey: handleBackspaceKeyOnList,
+    handleTab: handleTabOnList,
     snippets: ["-", "*", "+"]
   },
   "list-item": {
@@ -8253,7 +8349,7 @@ const BlocksDropdown = () => {
     return block.isInBlocksSelector ? [...currentKeys, key] : currentKeys;
   }, []);
   const [blockSelected, setBlockSelected] = React__namespace.useState("paragraph");
-  const selectOption = (optionKey) => {
+  const handleSelect = (optionKey) => {
     if (!isSelectorBlockKey(optionKey)) {
       return;
     }
@@ -8273,6 +8369,19 @@ const BlocksDropdown = () => {
     } else if (!editor.selection && editorIsEmpty) {
       slate.Transforms.select(editor, slate.Editor.start(editor, [0, 0]));
     }
+    const currentListEntry = slate.Editor.above(editor, {
+      match: (node) => !slate.Editor.isEditor(node) && node.type === "list"
+    });
+    if (currentListEntry && ["list-ordered", "list-unordered"].includes(optionKey)) {
+      const [currentList, currentListPath] = currentListEntry;
+      const format = optionKey === "list-ordered" ? "ordered" : "unordered";
+      if (!slate.Editor.isEditor(currentList) && isListNode(currentList)) {
+        if (currentList.format !== format) {
+          slate.Transforms.setNodes(editor, { format }, { at: currentListPath });
+        }
+      }
+      return;
+    }
     const maybeRenderModal = blocks[optionKey].handleConvert?.(editor);
     handleConversionResult(maybeRenderModal);
     setBlockSelected(optionKey);
@@ -8281,12 +8390,28 @@ const BlocksDropdown = () => {
   const preventSelectFocus = (e) => e.preventDefault();
   React__namespace.useEffect(() => {
     if (editor.selection) {
-      const [anchorNode] = slate.Editor.parent(editor, editor.selection.anchor, {
-        edge: "start",
-        depth: 2
+      let selectedNode;
+      const currentListEntry = slate.Editor.above(editor, {
+        match: (node) => !slate.Editor.isEditor(node) && node.type === "list",
+        at: editor.selection.anchor
       });
+      if (currentListEntry) {
+        const [currentList] = currentListEntry;
+        selectedNode = currentList;
+      } else {
+        const [anchorNode] = slate.Editor.parent(editor, editor.selection.anchor, {
+          edge: "start",
+          depth: 2
+        });
+        if (anchorNode.type === "list-item") {
+          slate.Transforms.setNodes(editor, { type: "paragraph" });
+          selectedNode = { ...anchorNode, type: "paragraph" };
+        } else {
+          selectedNode = anchorNode;
+        }
+      }
       const anchorBlockKey = getKeys(blocks).find(
-        (blockKey) => !slate.Editor.isEditor(anchorNode) && blocks[blockKey].matchNode(anchorNode)
+        (blockKey) => !slate.Editor.isEditor(selectedNode) && blocks[blockKey].matchNode(selectedNode)
       );
       if (anchorBlockKey && anchorBlockKey !== blockSelected) {
         setBlockSelected(anchorBlockKey);
@@ -8298,7 +8423,7 @@ const BlocksDropdown = () => {
       designSystem.SingleSelect,
       {
         startIcon: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Icon, { as: blocks[blockSelected].icon }),
-        onChange: selectOption,
+        onChange: handleSelect,
         placeholder: formatMessage(blocks[blockSelected].label),
         value: blockSelected,
         onCloseAutoFocus: preventSelectFocus,
@@ -8337,75 +8462,57 @@ const BlockOption = ({ value, icon, label, blockSelected }) => {
 const isListNode = (node) => {
   return slate.Node.isNode(node) && !slate.Editor.isEditor(node) && node.type === "list";
 };
-const isListActive = (editor, matchNode) => {
-  const { selection } = editor;
-  if (!selection)
-    return false;
-  const [match] = Array.from(
-    slate.Editor.nodes(editor, {
-      at: slate.Editor.unhangRange(editor, selection),
-      match: matchNode
-    })
-  );
-  return Boolean(match);
-};
-const toggleList = (editor, isActive, format) => {
-  if (editor.selection) {
-    slate.Transforms.unwrapNodes(editor, {
-      match: (node) => isListNode(node) && ["ordered", "unordered"].includes(node.format),
-      split: true
-    });
-    slate.Transforms.setNodes(editor, {
-      type: isActive ? "paragraph" : "list-item"
+const ListButton = ({ block, format }) => {
+  const { editor, disabled, blocks } = useBlocksEditorContext("ListButton");
+  const isListActive = () => {
+    if (!editor.selection)
+      return false;
+    const currentListEntry = slate.Editor.above(editor, {
+      match: (node) => !slate.Editor.isEditor(node) && node.type === "list",
+      at: editor.selection.anchor
     });
-    if (!isActive) {
-      const block = { type: "list", format, children: [] };
-      slate.Transforms.wrapNodes(editor, block);
+    if (currentListEntry) {
+      const [currentList] = currentListEntry;
+      if (!slate.Editor.isEditor(currentList) && isListNode(currentList) && currentList.format === format)
+        return true;
     }
-  } else {
-    const [, lastNodePath] = slate.Editor.last(editor, []);
-    const [parentNode] = slate.Editor.parent(editor, lastNodePath);
-    slate.Transforms.removeNodes(editor, {
-      voids: true,
-      hanging: true,
-      at: {
-        anchor: { path: lastNodePath, offset: 0 },
-        focus: { path: lastNodePath, offset: 0 }
-      }
-    });
-    slate.Transforms.insertNodes(
-      editor,
-      {
-        type: isActive ? "paragraph" : "list-item",
-        children: [...parentNode.children]
-      },
-      {
-        at: [lastNodePath[0]],
-        select: true
+    return false;
+  };
+  const toggleList = (format2) => {
+    let currentListEntry;
+    if (editor.selection) {
+      currentListEntry = slate.Editor.above(editor, {
+        match: (node) => !slate.Editor.isEditor(node) && node.type === "list"
+      });
+    } else {
+      const [_, lastNodePath] = slate.Editor.last(editor, []);
+      currentListEntry = slate.Editor.above(editor, {
+        match: (node) => !slate.Editor.isEditor(node) && node.type === "list",
+        at: lastNodePath
+      });
+    }
+    if (!currentListEntry) {
+      blocks[`list-${format2}`].handleConvert(editor);
+      return;
+    }
+    const [currentList, currentListPath] = currentListEntry;
+    if (!slate.Editor.isEditor(currentList) && isListNode(currentList)) {
+      if (currentList.format !== format2) {
+        slate.Transforms.setNodes(editor, { format: format2 }, { at: currentListPath });
+      } else {
+        blocks["paragraph"].handleConvert(editor);
       }
-    );
-    if (!isActive) {
-      const block = { type: "list", format, children: [] };
-      slate.Transforms.wrapNodes(editor, block);
     }
-  }
-};
-const ListButton = ({ block, format }) => {
-  const { editor, disabled } = useBlocksEditorContext("ListButton");
-  const { icon, matchNode, label } = block;
-  const isActive = isListActive(
-    editor,
-    (node) => !slate.Editor.isEditor(node) && node.type !== "text" && matchNode(node)
-  );
+  };
   return /* @__PURE__ */ jsxRuntime.jsx(
     ToolbarButton,
     {
-      icon,
+      icon: block.icon,
       name: format,
-      label,
-      isActive,
+      label: block.label,
+      isActive: isListActive(),
       disabled,
-      handleClick: () => toggleList(editor, isActive, format)
+      handleClick: () => toggleList(format)
     }
   );
 };
@@ -8590,8 +8697,6 @@ const DragAndDropElement = ({
   const [dragVisibility, setDragVisibility] = React__namespace.useState("hidden");
   const handleMoveBlock = React__namespace.useCallback(
     (newIndex, currentIndex) => {
-      const [newNode] = slate.Editor.node(editor, newIndex);
-      const [draggedNode] = slate.Editor.node(editor, currentIndex);
       slate.Transforms.moveNodes(editor, {
         at: currentIndex,
         to: newIndex
@@ -8610,50 +8715,6 @@ const DragAndDropElement = ({
           }
         )
       );
-      if (slate.Element.isElement(newNode) && slate.Element.isElement(draggedNode)) {
-        if (newNode.type === "list-item" && draggedNode.type !== "list-item") {
-          slate.Transforms.setNodes(
-            editor,
-            { ...getAttributesToClear(draggedNode), type: "list-item" },
-            {
-              at: newIndex[0] > currentIndex[0] ? [newIndex[0] - 1, ...newIndex.slice(1)] : newIndex
-            }
-          );
-          if (newIndex[0] > currentIndex[0]) {
-            slate.Transforms.moveNodes(editor, {
-              at: [newIndex[0] - 1, ...newIndex.slice(1)],
-              to: [newIndex[0] - 1, newIndex[1] + 1, ...newIndex.slice(2)]
-            });
-          }
-        }
-        if (newNode.type !== "list-item" && draggedNode.type === "list-item") {
-          slate.Transforms.setNodes(editor, { type: "paragraph" }, { at: newIndex });
-          if (newIndex[0] < currentIndex[0]) {
-            currentIndex[0] += 1;
-          }
-          if (newIndex[0] > currentIndex[0]) {
-            slate.Transforms.moveNodes(editor, {
-              at: newIndex,
-              to: [newIndex[0] + 1]
-            });
-          }
-        }
-        if (newNode.type === "list-item" && draggedNode.type === "list-item") {
-          if (newIndex[0] > currentIndex[0]) {
-            slate.Transforms.moveNodes(editor, {
-              at: newIndex,
-              to: [newIndex[0], newIndex[1] + 1, ...newIndex.slice(2)]
-            });
-          }
-        }
-        if (draggedNode.type === "list-item") {
-          const [listNode, listNodePath] = slate.Editor.parent(editor, currentIndex);
-          const isListEmpty = listNode.children?.length === 1 && listNode.children?.[0].type === "text" && listNode.children?.[0].text === "";
-          if (isListEmpty) {
-            slate.Transforms.removeNodes(editor, { at: listNodePath });
-          }
-        }
-      }
     },
     [editor, formatMessage, name2, setLiveText]
   );
@@ -8778,11 +8839,13 @@ const baseRenderElement = ({
   setDragDirection,
   dragDirection
 }) => {
-  const blockMatch = Object.values(blocks).find((block2) => block2.matchNode(props.element));
+  const { element } = props;
+  const blockMatch = Object.values(blocks).find((block2) => block2.matchNode(element));
   const block = blockMatch || blocks.paragraph;
-  const nodePath = slateReact.ReactEditor.findPath(editor, props.element);
-  if (isLinkNode(props.element) || isListNode$1(props.element))
+  const nodePath = slateReact.ReactEditor.findPath(editor, element);
+  if (isLinkNode(element) || isListNode$1(element) && element.indentLevel && element.indentLevel > 0 || element.type === "list-item") {
     return block.renderElement(props);
+  }
   return /* @__PURE__ */ jsxRuntime.jsx(
     DragAndDropElement,
     {
@@ -8794,7 +8857,7 @@ const baseRenderElement = ({
     }
   );
 };
-const BlocksContent = ({ placeholder }) => {
+const BlocksContent = ({ placeholder, ariaLabelId }) => {
   const { editor, disabled, blocks, modifiers: modifiers2, setLiveText, isExpandedMode } = useBlocksEditorContext("BlocksContent");
   const blocksRef = React__namespace.useRef(null);
   const { formatMessage } = reactIntl.useIntl();
@@ -8897,6 +8960,20 @@ const BlocksContent = ({ placeholder }) => {
       selectedBlock.handleBackspaceKey(editor, event);
     }
   };
+  const handleTab = (event) => {
+    if (!editor.selection) {
+      return;
+    }
+    const selectedNode = editor.children[editor.selection.anchor.path[0]];
+    const selectedBlock = Object.values(blocks).find((block) => block.matchNode(selectedNode));
+    if (!selectedBlock) {
+      return;
+    }
+    if (selectedBlock.handleTab) {
+      event.preventDefault();
+      selectedBlock.handleTab(editor);
+    }
+  };
   const handleKeyboardShortcuts = (event) => {
     const isCtrlOrCmd = event.metaKey || event.ctrlKey;
     if (isCtrlOrCmd) {
@@ -8912,12 +8989,16 @@ const BlocksContent = ({ placeholder }) => {
     }
   };
   const handleKeyDown = (event) => {
-    if (event.key === "Enter") {
-      event.preventDefault();
-      return handleEnter(event);
-    }
-    if (event.key === "Backspace") {
-      return handleBackspaceEvent(event);
+    switch (event.key) {
+      case "Enter":
+        event.preventDefault();
+        return handleEnter(event);
+      case "Backspace":
+        return handleBackspaceEvent(event);
+      case "Tab":
+        return handleTab(event);
+      case "Escape":
+        return slateReact.ReactEditor.blur(editor);
     }
     handleKeyboardShortcuts(event);
     if (event.key === " ") {
@@ -8960,6 +9041,7 @@ const BlocksContent = ({ placeholder }) => {
         /* @__PURE__ */ jsxRuntime.jsx(
           StyledEditable,
           {
+            "aria-labelledby": ariaLabelId,
             readOnly: disabled,
             placeholder,
             isExpandedMode,
@@ -9268,7 +9350,7 @@ function useResetKey(value) {
 }
 const pipe = (...fns) => (value) => fns.reduce((prev, fn) => fn(prev), value);
 const BlocksEditor = React__namespace.forwardRef(
-  ({ disabled = false, name: name2, placeholder, onChange, value, error }, forwardedRef) => {
+  ({ disabled = false, name: name2, onChange, value, error, ...contentProps }, forwardedRef) => {
     const { formatMessage } = reactIntl.useIntl();
     const [editor] = React__namespace.useState(
       () => pipe(slateHistory.withHistory, withImages, withStrapiSchema, slateReact.withReact, withLinks)(slate.createEditor())
@@ -9276,7 +9358,6 @@ const BlocksEditor = React__namespace.forwardRef(
     const [liveText, setLiveText] = React__namespace.useState("");
     const ariaDescriptionId = React__namespace.useId();
     const [isExpandedMode, setIsExpandedMode] = React__namespace.useState(false);
-    const formattedPlaceholder = placeholder && formatMessage({ id: placeholder.id, defaultMessage: placeholder.defaultMessage });
     const handleToggleExpand = () => {
       setIsExpandedMode((prev) => !prev);
     };
@@ -9341,7 +9422,7 @@ const BlocksEditor = React__namespace.forwardRef(
                   children: [
                     /* @__PURE__ */ jsxRuntime.jsx(BlocksToolbar, {}),
                     /* @__PURE__ */ jsxRuntime.jsx(EditorDivider, { width: "100%" }),
-                    /* @__PURE__ */ jsxRuntime.jsx(BlocksContent, { placeholder: formattedPlaceholder }),
+                    /* @__PURE__ */ jsxRuntime.jsx(BlocksContent, { ...contentProps }),
                     !isExpandedMode && /* @__PURE__ */ jsxRuntime.jsx(
                       ExpandIconButton,
                       {
@@ -9370,19 +9451,50 @@ const LabelAction$2 = styled__default.default(designSystem.Box)`
   }
 `;
 const BlocksInput = React__namespace.forwardRef(
-  ({ intlLabel, labelAction, name: name2, required = false, error = "", hint, ...editorProps }, forwardedRef) => {
+  ({
+    intlLabel,
+    labelAction,
+    name: name2,
+    required = false,
+    error = "",
+    hint,
+    placeholder,
+    ...editorProps
+  }, forwardedRef) => {
     const { formatMessage } = reactIntl.useIntl();
+    const uniqueId = React__namespace.useId();
     const label = intlLabel.id ? formatMessage(intlLabel) : name2;
+    const formattedPlaceholder = placeholder && formatMessage({ id: placeholder.id, defaultMessage: placeholder.defaultMessage });
     return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
       /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "stretch", gap: 1, children: [
         /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 1, children: [
-          /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { variant: "pi", fontWeight: "bold", textColor: "neutral800", children: [
-            label,
-            required && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "danger600", lineHeight: "0px", children: "*" })
-          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            designSystem.Typography,
+            {
+              variant: "pi",
+              fontWeight: "bold",
+              textColor: "neutral800",
+              as: "label",
+              id: uniqueId,
+              children: [
+                label,
+                required && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "danger600", lineHeight: "0px", children: "*" })
+              ]
+            }
+          ),
           labelAction && /* @__PURE__ */ jsxRuntime.jsx(LabelAction$2, { paddingLeft: 1, children: labelAction })
         ] }),
-        /* @__PURE__ */ jsxRuntime.jsx(BlocksEditor, { name: name2, error, ref: forwardedRef, ...editorProps }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          BlocksEditor,
+          {
+            name: name2,
+            error,
+            ref: forwardedRef,
+            ...editorProps,
+            ariaLabelId: uniqueId,
+            placeholder: formattedPlaceholder
+          }
+        ),
         /* @__PURE__ */ jsxRuntime.jsx(Hint, { hint, name: name2, error })
       ] }),
       error && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 1, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "danger600", "data-strapi-field-error": true, children: error }) })
@@ -14270,7 +14382,7 @@ const EditViewPage = ({
   const toggleNotification = helperPlugin.useNotification();
   const Information2 = useEnterprise(
     InformationBoxCE,
-    async () => (await Promise.resolve().then(() => require("./InformationBoxEE-mYmnrztj.js"))).InformationBoxEE
+    async () => (await Promise.resolve().then(() => require("./InformationBoxEE-4etf9EMS.js"))).InformationBoxEE
   );
   useOnce(() => {
     if (location?.state && "error" in location.state) {
@@ -15499,6 +15611,7 @@ const usersService = adminApi.injectEndpoints({
         method: "POST",
         data: body
       }),
+      transformResponse: (response) => response.data,
       invalidatesTags: ["LicenseLimits", { type: "User", id: "LIST" }]
     }),
     updateUser: builder.mutation({
@@ -17201,7 +17314,7 @@ const ListViewPage = ({
   const hasReviewWorkflows = options2?.reviewWorkflows ?? false;
   const reviewWorkflowColumns = useEnterprise(
     REVIEW_WORKFLOW_COLUMNS_CE,
-    async () => (await Promise.resolve().then(() => require("./constants-5YB6pnhW.js"))).REVIEW_WORKFLOW_COLUMNS_EE,
+    async () => (await Promise.resolve().then(() => require("./constants-2_a_PrR3.js"))).REVIEW_WORKFLOW_COLUMNS_EE,
     {
       enabled: !!options2?.reviewWorkflows
     }
@@ -17209,7 +17322,7 @@ const ListViewPage = ({
   const ReviewWorkflowsColumns = useEnterprise(
     REVIEW_WORKFLOW_COLUMNS_CELL_CE,
     async () => {
-      const { ReviewWorkflowsStageEE, ReviewWorkflowsAssigneeEE } = await Promise.resolve().then(() => require("./ReviewWorkflowsColumn-z1r1fj49.js"));
+      const { ReviewWorkflowsStageEE, ReviewWorkflowsAssigneeEE } = await Promise.resolve().then(() => require("./ReviewWorkflowsColumn-FblPzVJS.js"));
       return { ReviewWorkflowsStageEE, ReviewWorkflowsAssigneeEE };
     },
     {
@@ -17218,7 +17331,7 @@ const ListViewPage = ({
   );
   const reviewWorkflowFilter = useEnterprise(
     REVIEW_WORKFLOW_FILTER_CE,
-    async () => (await Promise.resolve().then(() => require("./constants-5YB6pnhW.js"))).REVIEW_WORKFLOW_FILTERS,
+    async () => (await Promise.resolve().then(() => require("./constants-2_a_PrR3.js"))).REVIEW_WORKFLOW_FILTERS,
     {
       combine(ceFilters, eeFilters) {
         return [
@@ -18333,6 +18446,11 @@ const injectReducerStoreEnhancer = (appReducers) => (next) => (...args) => {
 };
 const configureStoreImpl = (preloadedState = {}, appMiddlewares = [], injectedReducers = {}) => {
   const coreReducers = { ...staticReducers, ...injectedReducers };
+  const defaultMiddlewareOptions = {};
+  if (process.env.NODE_ENV === "test") {
+    defaultMiddlewareOptions.serializableCheck = false;
+    defaultMiddlewareOptions.immutableCheck = false;
+  }
   const store = toolkit.configureStore({
     preloadedState: {
       admin_app: preloadedState.admin_app
@@ -18340,7 +18458,7 @@ const configureStoreImpl = (preloadedState = {}, appMiddlewares = [], injectedRe
     reducer: coreReducers,
     devTools: process.env.NODE_ENV !== "production",
     middleware: (getDefaultMiddleware) => [
-      ...getDefaultMiddleware(),
+      ...getDefaultMiddleware(defaultMiddlewareOptions),
       adminApi.middleware,
       ...appMiddlewares.map((m) => m())
     ],
@@ -18930,6 +19048,23 @@ function useDocument() {
   };
   return { validate };
 }
+function useLicenseLimits({ enabled } = { enabled: true }) {
+  const { data, isError, isLoading } = useGetLicenseLimitsQuery(void 0, {
+    skip: !enabled
+  });
+  const getFeature = React__namespace.useCallback(
+    (name2) => {
+      const feature = data?.data?.features.find((feature2) => feature2.name === name2);
+      if (feature && "options" in feature) {
+        return feature.options;
+      } else {
+        return {};
+      }
+    },
+    [data]
+  );
+  return { license: data?.data, getFeature, isError, isLoading };
+}
 exports.App = App$1;
 exports.Column = Column;
 exports.DefaultDocument = DefaultDocument;
@@ -18965,7 +19100,6 @@ exports.useDeleteManyUsersMutation = useDeleteManyUsersMutation;
 exports.useDocument = useDocument;
 exports.useDragAndDrop = useDragAndDrop;
 exports.useEnterprise = useEnterprise;
-exports.useGetLicenseLimitsQuery = useGetLicenseLimitsQuery;
 exports.useGetMyPermissionsQuery = useGetMyPermissionsQuery;
 exports.useGetPluginsQuery = useGetPluginsQuery;
 exports.useGetProviderOptionsQuery = useGetProviderOptionsQuery;
@@ -18975,6 +19109,7 @@ exports.useGetRolePermissionsQuery = useGetRolePermissionsQuery;
 exports.useGetRolesQuery = useGetRolesQuery;
 exports.useInformationQuery = useInformationQuery;
 exports.useIsSSOLockedQuery = useIsSSOLockedQuery;
+exports.useLicenseLimits = useLicenseLimits;
 exports.useOnce = useOnce;
 exports.useRegenerateTokenMutation = useRegenerateTokenMutation;
 exports.useTypedDispatch = useTypedDispatch;
@@ -18985,4 +19120,4 @@ exports.useUpdateProviderOptionsMutation = useUpdateProviderOptionsMutation;
 exports.useUpdateRoleMutation = useUpdateRoleMutation;
 exports.useUpdateRolePermissionsMutation = useUpdateRolePermissionsMutation;
 exports.useUpdateUserMutation = useUpdateUserMutation;
-//# sourceMappingURL=index-8XZny-tn.js.map
+//# sourceMappingURL=index-Cgd3dGa5.js.map