@plone/volto 18.0.0-alpha.43 → 18.0.0-alpha.44

package/dist/server/assets/Order-DYralO8T.js

@@ -0,0 +1,586 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { forwardRef, useState, useMemo, useRef, useEffect } from "react";
+import { createPortal } from "react-dom";
+import { isArray, includes, min, find } from "lodash-es";
+import { j as getBlocksLayoutFieldname, cW as setUIState, I as Icon, $ as $149c1bd638913645$export$2e2bcd8739ae039, b6 as deleteSVG } from "../entry-server.js";
+import { useSortable, SortableContext, verticalListSortingStrategy, arrayMove } from "@dnd-kit/sortable";
+import { CSS } from "@dnd-kit/utilities";
+import cx from "classnames";
+import { useSelector, useDispatch } from "react-redux";
+import { d as dragSVG } from "./drag-DY7wFRIh.js";
+import { MeasuringStrategy, useSensors, useSensor, PointerSensor, DndContext, closestCenter, DragOverlay, defaultDropAnimation } from "@dnd-kit/core";
+import "react-intl";
+import "moment";
+import "react-router";
+import "prop-types";
+import "react-router-hash-link";
+import "tlds";
+import "prepend-http";
+import "semantic-ui-react";
+import "react-router-dom";
+import "redux";
+import "lodash-move";
+import "react-dom/server";
+import "react-transition-group";
+import "react-toastify";
+import "promise-file-reader";
+import "uuid";
+import "pretty-bytes";
+import "react-side-effect";
+import "github-slugger";
+import "slate";
+import "hoist-non-react-statics";
+import "query-string";
+import "slate-react";
+import "prettier/standalone";
+import "prettier/parser-html";
+import "prismjs/components/prism-core.js";
+import "react-animate-height";
+import "react-popper";
+import "react-sortable-hoc";
+import "react-dates/initialize.js";
+import "react-anchor-link-smooth-scroll";
+import "jwt-decode";
+import "react-router-config";
+import "react-fast-compare";
+import "object-assign";
+import "lodash-es/split.js";
+import "lodash-es/join.js";
+import "lodash-es/trim.js";
+import "react-cookie";
+import "react-intl-redux";
+import "universal-cookie";
+import "slate-hyperscript";
+import "is-hotkey";
+import "react-dropzone";
+import "react-intersection-observer";
+import "is-url";
+import "lodash-es/isUndefined.js";
+import "lodash-es/isString.js";
+import "redux-mock-store";
+import "serialize-javascript";
+import "superagent";
+import "connected-react-router";
+import "react-beautiful-dnd";
+import "detect-browser";
+import "locale";
+import "history";
+import "redux-thunk";
+import "redux-localstorage-simple";
+import "debug";
+import "express";
+import "http-proxy-middleware";
+function getDragDepth(offset, indentationWidth) {
+  return Math.round(offset / indentationWidth);
+}
+function getProjection(items, activeId, overId, dragOffset, indentationWidth, arrayMove2) {
+  const overItemIndex = items.findIndex(({ id }) => id === overId);
+  const activeItemIndex = items.findIndex(({ id }) => id === activeId);
+  const activeItem = items[activeItemIndex];
+  const newItems = arrayMove2(items, activeItemIndex, overItemIndex);
+  const previousItem = newItems[overItemIndex - 1];
+  const nextItem = newItems[overItemIndex + 1];
+  const dragDepth = getDragDepth(dragOffset, indentationWidth);
+  const projectedDepth = activeItem.depth + dragDepth;
+  const maxDepth = getMaxDepth({
+    previousItem
+  });
+  const minDepth = getMinDepth({ nextItem });
+  let depth = projectedDepth;
+  if (projectedDepth >= maxDepth) {
+    depth = maxDepth;
+  } else if (projectedDepth < minDepth) {
+    depth = minDepth;
+  }
+  return { depth, maxDepth, minDepth, parentId: getParentId() };
+  function getParentId() {
+    var _a;
+    if (depth === 0 || !previousItem) {
+      return null;
+    }
+    if (depth <= previousItem.depth) {
+      return previousItem.parentId;
+    }
+    if (depth > previousItem.depth) {
+      return previousItem.id;
+    }
+    const newParent = (_a = newItems.slice(0, overItemIndex).reverse().find((item) => item.depth === depth)) == null ? void 0 : _a.parentId;
+    return newParent ?? null;
+  }
+}
+function getMaxDepth({ previousItem }) {
+  var _a, _b;
+  const blocksLayoutFieldname = getBlocksLayoutFieldname(
+    (previousItem == null ? void 0 : previousItem.data) || {}
+  );
+  if (previousItem) {
+    return isArray((_b = (_a = previousItem.data) == null ? void 0 : _a[blocksLayoutFieldname]) == null ? void 0 : _b.items) ? previousItem.depth + 1 : previousItem.depth;
+  }
+  return 0;
+}
+function getMinDepth({ nextItem }) {
+  if (nextItem) {
+    return nextItem.depth;
+  }
+  return 0;
+}
+function flatten(items = [], parentId = null, depth = 0) {
+  return items.reduce((acc, item, index) => {
+    return [
+      ...acc,
+      { ...item, parentId, depth, index },
+      ...flatten(item.children, item.id, depth + 1)
+    ];
+  }, []);
+}
+function flattenTree(items) {
+  return flatten(items);
+}
+function removeChildrenOf(items, ids) {
+  const excludeParentIds = [...ids];
+  return items.filter((item) => {
+    if (item.parentId && excludeParentIds.includes(item.parentId)) {
+      if (item.children.length) {
+        excludeParentIds.push(item.id);
+      }
+      return false;
+    }
+    return true;
+  });
+}
+const Item = forwardRef(
+  ({
+    clone,
+    data,
+    depth,
+    disableSelection,
+    disableInteraction,
+    ghost,
+    id,
+    handleProps,
+    indentationWidth,
+    onRemove,
+    onSelectBlock,
+    parentId,
+    style,
+    value,
+    wrapperRef,
+    errors,
+    ...props
+  }, ref) => {
+    var _a, _b, _c;
+    const selected = useSelector((state) => state.form.ui.selected);
+    const hovered = useSelector((state) => state.form.ui.hovered);
+    const multiSelected = useSelector((state) => state.form.ui.multiSelected);
+    const gridSelected = useSelector((state) => state.form.ui.gridSelected);
+    const dispatch = useDispatch();
+    return /* @__PURE__ */ jsx(
+      "li",
+      {
+        className: cx(
+          "tree-item-wrapper",
+          clone && "clone",
+          ghost && "ghost",
+          disableSelection && "disable-selection",
+          disableInteraction && "disable-interaction"
+        ),
+        role: "presentation",
+        onMouseOver: () => dispatch(setUIState({ hovered: id })),
+        onFocus: () => dispatch(setUIState({ hovered: id })),
+        onMouseLeave: () => dispatch(setUIState({ hovered: null })),
+        onClick: (e) => {
+          if (depth === 0) {
+            const isMultipleSelection = e.shiftKey || e.ctrlKey || e.metaKey;
+            selected !== id && onSelectBlock(
+              id,
+              selected === id ? false : isMultipleSelection,
+              e
+            );
+          } else {
+            dispatch(
+              setUIState({
+                selected: parentId,
+                multiSelected: [],
+                gridSelected: id
+              })
+            );
+          }
+        },
+        ref: wrapperRef,
+        style: {
+          "--spacing": `${indentationWidth * depth}px`
+        },
+        ...props,
+        children: /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: cx(
+              "tree-item",
+              (selected === id || gridSelected === id) && "selected",
+              hovered === id && "hovered",
+              includes(multiSelected, id) && "multiSelected",
+              `depth-${depth}`
+            ),
+            ref,
+            style,
+            children: [
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  ref,
+                  ...handleProps,
+                  className: cx("action", "drag"),
+                  tabIndex: 0,
+                  "data-cypress": "draggable-handle",
+                  children: /* @__PURE__ */ jsx(Icon, { name: dragSVG, size: "16px" })
+                }
+              ),
+              /* @__PURE__ */ jsxs(
+                "span",
+                {
+                  className: cx("text", {
+                    errored: errors && Object.keys(errors).length > 0
+                  }),
+                  children: [
+                    ((_a = $149c1bd638913645$export$2e2bcd8739ae039.blocks.blocksConfig[data == null ? void 0 : data["@type"]]) == null ? void 0 : _a.icon) && /* @__PURE__ */ jsx(
+                      Icon,
+                      {
+                        name: (_b = $149c1bd638913645$export$2e2bcd8739ae039.blocks.blocksConfig[data == null ? void 0 : data["@type"]]) == null ? void 0 : _b.icon,
+                        size: "20px",
+                        style: { verticalAlign: "middle" }
+                      }
+                    ),
+                    " ",
+                    (data == null ? void 0 : data.plaintext) || ((_c = $149c1bd638913645$export$2e2bcd8739ae039.blocks.blocksConfig[data == null ? void 0 : data["@type"]]) == null ? void 0 : _c.title)
+                  ]
+                }
+              ),
+              !clone && onRemove && /* @__PURE__ */ jsx(
+                "button",
+                {
+                  onClick: onRemove,
+                  className: cx("action", "delete"),
+                  tabIndex: 0,
+                  children: /* @__PURE__ */ jsx(Icon, { name: deleteSVG, size: "18" })
+                }
+              )
+            ]
+          }
+        )
+      }
+    );
+  }
+);
+const animateLayoutChanges = ({ isSorting, wasDragging }) => isSorting || wasDragging ? false : true;
+function SortableItem({ id, depth, ...props }) {
+  const {
+    attributes,
+    isDragging,
+    isSorting,
+    listeners,
+    setDraggableNodeRef,
+    setDroppableNodeRef,
+    transform,
+    transition
+  } = useSortable({
+    id,
+    animateLayoutChanges
+  });
+  const style = {
+    transform: CSS.Translate.toString(transform),
+    transition
+  };
+  return /* @__PURE__ */ jsx(
+    Item,
+    {
+      ref: setDraggableNodeRef,
+      wrapperRef: setDroppableNodeRef,
+      style,
+      depth,
+      ghost: isDragging,
+      disableSelection: false,
+      disableInteraction: isSorting,
+      id,
+      handleProps: {
+        ...attributes,
+        ...listeners
+      },
+      ...props
+    }
+  );
+}
+function Order({
+  items = [],
+  onMoveBlock,
+  onDeleteBlock,
+  onSelectBlock,
+  indentationWidth = 25,
+  removable,
+  errors
+}) {
+  const [activeId, setActiveId] = useState(null);
+  const [overId, setOverId] = useState(null);
+  const [offsetLeft, setOffsetLeft] = useState(0);
+  const [currentPosition, setCurrentPosition] = useState(null);
+  const measuring = {
+    droppable: {
+      strategy: MeasuringStrategy.Always
+    }
+  };
+  const dropAnimationConfig = {
+    keyframes({ transform }) {
+      return [
+        { opacity: 1, transform: CSS.Transform.toString(transform.initial) },
+        {
+          opacity: 0,
+          transform: CSS.Transform.toString({
+            ...transform.final,
+            x: transform.final.x + 5,
+            y: transform.final.y + 5
+          })
+        }
+      ];
+    },
+    easing: "ease-out",
+    sideEffects({ active }) {
+      active.node.animate([{ opacity: 0 }, { opacity: 1 }], {
+        duration: defaultDropAnimation.duration,
+        easing: defaultDropAnimation.easing
+      });
+    }
+  };
+  const flattenedItems = useMemo(
+    () => removeChildrenOf(flattenTree(items), activeId ? [activeId] : []),
+    [activeId, items]
+  );
+  const projected = activeId && overId ? getProjection(
+    flattenedItems,
+    activeId,
+    overId,
+    offsetLeft,
+    indentationWidth,
+    arrayMove
+  ) : null;
+  const sensorContext = useRef({
+    items: flattenedItems,
+    offset: offsetLeft
+  });
+  const sensors = useSensors(useSensor(PointerSensor));
+  const sortedIds = useMemo(
+    () => flattenedItems.map(({ id }) => id),
+    [flattenedItems]
+  );
+  const activeItem = activeId ? flattenedItems.find(({ id }) => id === activeId) : null;
+  useEffect(() => {
+    sensorContext.current = {
+      items: flattenedItems,
+      offset: offsetLeft
+    };
+  }, [flattenedItems, offsetLeft]);
+  const announcements = {
+    onDragStart({ active }) {
+      return `Picked up ${active.id}.`;
+    },
+    onDragMove({ active, over }) {
+      return getMovementAnnouncement("onDragMove", active.id, over == null ? void 0 : over.id);
+    },
+    onDragOver({ active, over }) {
+      return getMovementAnnouncement("onDragOver", active.id, over == null ? void 0 : over.id);
+    },
+    onDragEnd({ active, over }) {
+      return getMovementAnnouncement("onDragEnd", active.id, over == null ? void 0 : over.id);
+    },
+    onDragCancel({ active }) {
+      return `Moving was cancelled. ${active.id} was dropped in its original position.`;
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    DndContext,
+    {
+      accessibility: { announcements },
+      sensors,
+      collisionDetection: closestCenter,
+      measuring,
+      onDragStart: handleDragStart,
+      onDragMove: handleDragMove,
+      onDragOver: handleDragOver,
+      onDragEnd: handleDragEnd,
+      onDragCancel: handleDragCancel,
+      children: /* @__PURE__ */ jsxs(SortableContext, { items: sortedIds, strategy: verticalListSortingStrategy, children: [
+        flattenedItems.map(({ id, parentId, depth, data }) => /* @__PURE__ */ jsx(
+          SortableItem,
+          {
+            id,
+            parentId,
+            data,
+            depth: min([
+              id === activeId && projected ? projected.depth : depth,
+              1
+            ]),
+            indentationWidth,
+            onRemove: removable ? () => handleRemove(id) : void 0,
+            onSelectBlock,
+            errors: (errors == null ? void 0 : errors[id]) || {}
+          },
+          id
+        )),
+        createPortal(
+          /* @__PURE__ */ jsx(DragOverlay, { dropAnimation: dropAnimationConfig, children: activeId && activeItem ? /* @__PURE__ */ jsx(
+            SortableItem,
+            {
+              id: activeId,
+              depth: activeItem.depth,
+              clone: true,
+              data: find(flattenedItems, { id: activeId }).data,
+              indentationWidth
+            }
+          ) : null }),
+          document.body
+        )
+      ] })
+    }
+  );
+  function handleDragStart({ active: { id: activeId2 } }) {
+    setActiveId(activeId2);
+    setOverId(activeId2);
+    const activeItem2 = flattenedItems.find(({ id }) => id === activeId2);
+    if (activeItem2) {
+      setCurrentPosition({
+        parentId: activeItem2.parentId,
+        overId: activeId2
+      });
+    }
+    document.body.style.setProperty("cursor", "grabbing");
+  }
+  function handleDragMove({ delta }) {
+    setOffsetLeft(delta.x);
+  }
+  function handleDragOver({ over }) {
+    setOverId((over == null ? void 0 : over.id) ?? null);
+  }
+  function handleDragEnd({ active, over }) {
+    if (projected && over) {
+      const { depth, parentId } = projected;
+      const clonedItems = JSON.parse(JSON.stringify(flattenedItems));
+      const overIndex = clonedItems.findIndex(({ id }) => id === over.id);
+      const activeIndex = clonedItems.findIndex(({ id }) => id === active.id);
+      const activeTreeItem = clonedItems[activeIndex];
+      const oldParentId = activeTreeItem.parentId;
+      clonedItems[activeIndex] = { ...activeTreeItem, depth, parentId };
+      if (parentId === oldParentId) {
+        let destIndex = clonedItems[overIndex].index;
+        if (clonedItems[overIndex].depth > clonedItems[activeIndex].depth) {
+          destIndex = find(clonedItems, {
+            id: clonedItems[overIndex].parentId
+          }).index;
+        }
+        onMoveBlock({
+          source: {
+            position: clonedItems[activeIndex].index,
+            parent: oldParentId,
+            id: active.id
+          },
+          destination: {
+            position: destIndex,
+            parent: parentId
+          }
+        });
+      } else if (parentId && oldParentId) {
+        onMoveBlock({
+          source: {
+            position: clonedItems[activeIndex].index,
+            parent: oldParentId,
+            id: active.id
+          },
+          destination: {
+            position: overIndex < activeIndex ? clonedItems[overIndex - 1].parentId ? clonedItems[overIndex - 1].index + 1 : clonedItems[overIndex].index : overIndex + 1 < clonedItems.length ? clonedItems[overIndex + 1].index : clonedItems[overIndex].index + 1,
+            parent: parentId
+          }
+        });
+      } else if (oldParentId) {
+        onMoveBlock({
+          source: {
+            position: clonedItems[activeIndex].index,
+            parent: oldParentId,
+            id: active.id
+          },
+          destination: {
+            position: overIndex > activeIndex ? overIndex + 1 < clonedItems.length ? clonedItems[overIndex + 1].index : clonedItems[overIndex].index + 1 : clonedItems[overIndex].index,
+            parent: parentId
+          }
+        });
+      } else {
+        onMoveBlock({
+          source: {
+            position: clonedItems[activeIndex].index,
+            parent: oldParentId,
+            id: active.id
+          },
+          destination: {
+            position: overIndex < activeIndex ? clonedItems[overIndex - 1].parentId ? clonedItems[overIndex - 1].index + 1 : clonedItems[overIndex].index : overIndex + 1 < clonedItems.length ? clonedItems[overIndex + 1].index : clonedItems[overIndex].index + 1,
+            parent: parentId
+          }
+        });
+      }
+    }
+    resetState();
+  }
+  function handleDragCancel() {
+    resetState();
+  }
+  function resetState() {
+    setOverId(null);
+    setActiveId(null);
+    setOffsetLeft(0);
+    setCurrentPosition(null);
+    document.body.style.setProperty("cursor", "");
+  }
+  function handleRemove(id) {
+    onDeleteBlock(id);
+  }
+  function getMovementAnnouncement(eventName, activeId2, overId2) {
+    if (overId2 && projected) {
+      if (eventName !== "onDragEnd") {
+        if (currentPosition && projected.parentId === currentPosition.parentId && overId2 === currentPosition.overId) {
+          return;
+        } else {
+          setCurrentPosition({
+            parentId: projected.parentId,
+            overId: overId2
+          });
+        }
+      }
+      const clonedItems = JSON.parse(JSON.stringify(flattenTree(items)));
+      const overIndex = clonedItems.findIndex(({ id }) => id === overId2);
+      const activeIndex = clonedItems.findIndex(({ id }) => id === activeId2);
+      const sortedItems = arrayMove(clonedItems, activeIndex, overIndex);
+      const previousItem = sortedItems[overIndex - 1];
+      let announcement;
+      const movedVerb = eventName === "onDragEnd" ? "dropped" : "moved";
+      const nestedVerb = eventName === "onDragEnd" ? "dropped" : "nested";
+      if (!previousItem) {
+        const nextItem = sortedItems[overIndex + 1];
+        announcement = `${activeId2} was ${movedVerb} before ${nextItem.id}.`;
+      } else {
+        if (projected.depth > previousItem.depth) {
+          announcement = `${activeId2} was ${nestedVerb} under ${previousItem.id}.`;
+        } else {
+          let previousSibling = previousItem;
+          while (previousSibling && projected.depth < previousSibling.depth) {
+            const parentId = previousSibling.parentId;
+            previousSibling = sortedItems.find(({ id }) => id === parentId);
+          }
+          if (previousSibling) {
+            announcement = `${activeId2} was ${movedVerb} after ${previousSibling.id}.`;
+          }
+        }
+      }
+      return announcement;
+    }
+    return;
+  }
+}
+export {
+  Order,
+  Order as default
+};

package/dist/server/assets/Pagination-DhaW_lzc.js

@@ -0,0 +1,98 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import "react";
+import { Menu } from "semantic-ui-react";
+import { I as Icon, au as paginationLeftSVG, ai as paginationRightSVG } from "../entry-server.js";
+import PropTypes from "prop-types";
+import { map } from "lodash-es";
+import { injectIntl, FormattedMessage } from "react-intl";
+const Pagination = ({
+  current,
+  total,
+  pageSize,
+  pageSizes,
+  onChangePage,
+  onChangePageSize
+}) => /* @__PURE__ */ jsxs(Menu, { secondary: true, attached: true, children: [
+  /* @__PURE__ */ jsxs(Menu.Menu, { children: [
+    current > 0 && /* @__PURE__ */ jsx(
+      Menu.Item,
+      {
+        value: current - 1,
+        icon: /* @__PURE__ */ jsx(Icon, { name: paginationLeftSVG, size: "23px" }),
+        className: "chevron-left-icon",
+        onClick: onChangePage
+      }
+    ),
+    current > 2 && /* @__PURE__ */ jsx(Menu.Item, { value: 0, onClick: onChangePage, children: "1" }),
+    current > 3 && /* @__PURE__ */ jsx(Menu.Item, { disabled: true, children: "..." }),
+    current > 1 && /* @__PURE__ */ jsx(Menu.Item, { value: current - 2, onClick: onChangePage, children: current - 1 }),
+    current > 0 && /* @__PURE__ */ jsx(Menu.Item, { value: current - 1, onClick: onChangePage, children: current }),
+    total > 1 && /* @__PURE__ */ jsx(Menu.Item, { value: current, active: true, onClick: onChangePage, children: current + 1 }),
+    total > current + 1 && /* @__PURE__ */ jsx(Menu.Item, { value: current + 1, onClick: onChangePage, children: current + 2 }),
+    total > current + 2 && /* @__PURE__ */ jsx(Menu.Item, { value: current + 2, onClick: onChangePage, children: current + 3 }),
+    total > current + 4 && /* @__PURE__ */ jsx(Menu.Item, { disabled: true, children: "..." }),
+    total > current + 3 && /* @__PURE__ */ jsx(Menu.Item, { value: total - 1, onClick: onChangePage, children: total }),
+    current < total - 1 && /* @__PURE__ */ jsx(
+      Menu.Item,
+      {
+        value: current + 1,
+        icon: /* @__PURE__ */ jsx(Icon, { name: paginationRightSVG, size: "23px" }),
+        className: "chevron-right-icon",
+        onClick: onChangePage
+      }
+    )
+  ] }),
+  pageSize && /* @__PURE__ */ jsxs(Menu.Menu, { position: "right", children: [
+    /* @__PURE__ */ jsxs(Menu.Item, { children: [
+      /* @__PURE__ */ jsx(FormattedMessage, { id: "Show", defaultMessage: "Show" }),
+      ":"
+    ] }),
+    map(pageSizes, (size) => /* @__PURE__ */ jsx(
+      Menu.Item,
+      {
+        value: size,
+        active: size === pageSize,
+        onClick: onChangePageSize,
+        children: size
+      },
+      size
+    ))
+  ] })
+] });
+Pagination.propTypes = {
+  /**
+   * Current page
+   */
+  current: PropTypes.number.isRequired,
+  /**
+   * Total number of pages
+   */
+  total: PropTypes.number.isRequired,
+  /**
+   * Number of items per page
+   */
+  pageSize: PropTypes.number,
+  /**
+   * Page sizes to choose from
+   */
+  pageSizes: PropTypes.arrayOf(
+    PropTypes.oneOfType([PropTypes.number, PropTypes.string])
+  ),
+  /**
+   * Handler called when changing the page
+   */
+  onChangePage: PropTypes.func.isRequired,
+  /**
+   * Handler called when changing the pagesize
+   */
+  onChangePageSize: PropTypes.func
+};
+Pagination.defaultProps = {
+  pageSize: null,
+  pageSizes: [],
+  onChangePageSize: null
+};
+const Pagination$1 = injectIntl(Pagination);
+export {
+  Pagination$1 as P
+};