@sanity/orderable-document-list 1.5.0 → 2.0.0

package/lib/index.js

@@ -1,589 +0,0 @@
-import { defineField, useSchema, useDocumentVersionInfo, PreviewCard, Preview, DocumentStatusIndicator, DocumentStatus, usePerspective, useClient, isVersionId, getVersionFromId, isPublishedId, isDraftId, getPublishedId } from "sanity";
-import { LexoRank } from "lexorank";
-import { DragHandleIcon, ChevronUpIcon, ChevronDownIcon, SortIcon, GenerateIcon } from "@sanity/icons";
-import { jsx, jsxs, Fragment } from "react/jsx-runtime";
-import { createContext, useContext, useMemo, useState, useEffect, useCallback, Component } from "react";
-import { Flex, Box, Text, Button, Tooltip, Card, AvatarCounter, useToast, Spinner, Container, Stack } from "@sanity/ui";
-import { useListeningQuery, Feedback } from "sanity-plugin-utils";
-import { DragDropContext, Droppable, Draggable } from "@hello-pangea/dnd";
-import { usePaneRouter } from "sanity/structure";
-const ORDER_FIELD_NAME = "orderRank", API_VERSION = "v2025-06-27";
-function parseOrderRank(value, fallback) {
-  if (typeof value != "string")
-    return console.warn("[orderable-document-list] Invalid orderRank value (expected string):", value), fallback;
-  try {
-    return LexoRank.parse(value);
-  } catch (err) {
-    return console.warn(
-      "[orderable-document-list] Failed to parse orderRank value:",
-      value,
-      "Error:",
-      err instanceof Error ? err.message : String(err)
-    ), fallback;
-  }
-}
-function initialRank(compareRankValue = "", newItemPosition = "after") {
-  const compareRank = parseOrderRank(compareRankValue, LexoRank.min());
-  return (newItemPosition === "before" ? compareRank.genPrev().genPrev() : compareRank.genNext().genNext()).toString();
-}
-const orderRankField = (config) => {
-  if (!config?.type)
-    throw new Error(
-      `
-      type must be provided.
-      Example: orderRankField({type: 'category'})
-      `
-    );
-  const { type, newItemPosition = "after", ...rest } = config;
-  return defineField({
-    title: "Order Rank",
-    readOnly: !0,
-    hidden: !0,
-    ...rest,
-    name: ORDER_FIELD_NAME,
-    type: "string",
-    initialValue: async (p, { getClient }) => {
-      const direction = newItemPosition === "before" ? "asc" : "desc", lastDocOrderRank = await getClient({ apiVersion: API_VERSION }).fetch(
-        `*[_type == $type]|order(@[$order] ${direction})[0][$order]`,
-        { type, order: ORDER_FIELD_NAME },
-        { tag: "orderable-document-list.last-doc-order-rank" }
-      );
-      return initialRank(lastDocOrderRank, newItemPosition);
-    }
-  });
-}, orderRankOrdering = {
-  title: "Ordered",
-  name: "ordered",
-  by: [{ field: ORDER_FIELD_NAME, direction: "asc" }]
-}, OrderableContext = createContext({});
-function Document({
-  doc,
-  increment,
-  entities,
-  index,
-  isFirst,
-  isLast,
-  dragBadge
-}) {
-  const { showIncrements } = useContext(OrderableContext), schema = useSchema(), router = usePaneRouter(), versionsInfo = useDocumentVersionInfo(doc._id), { ChildLink, groupIndex, routerPanesState } = router, currentDoc = routerPanesState[groupIndex + 1]?.[0]?.id || !1, pressed = currentDoc === doc._id || currentDoc === doc._id.replace("drafts.", ""), selected = pressed && routerPanesState.length === groupIndex + 2, Link = useMemo(
-    () => function(linkProps) {
-      return /* @__PURE__ */ jsx(ChildLink, { ...linkProps, childId: doc._id });
-    },
-    [ChildLink, doc._id]
-  ), tooltip = /* @__PURE__ */ jsx(
-    DocumentStatus,
-    {
-      draft: versionsInfo.draft,
-      published: versionsInfo.published,
-      versions: versionsInfo.versions
-    }
-  );
-  return /* @__PURE__ */ jsx(
-    PreviewCard,
-    {
-      __unstable_focusRing: !0,
-      as: Link,
-      "data-as": "a",
-      "data-ui": "PaneItem",
-      radius: 2,
-      pressed,
-      selected,
-      sizing: "border",
-      tabIndex: -1,
-      tone: "inherit",
-      width: "100%",
-      flex: 1,
-      children: /* @__PURE__ */ jsxs(Flex, { align: "center", children: [
-        /* @__PURE__ */ jsx(Box, { paddingX: 2, style: { flexShrink: 0 }, children: /* @__PURE__ */ jsx(Text, { size: 2, children: /* @__PURE__ */ jsx(DragHandleIcon, { cursor: "grab" }) }) }),
-        showIncrements && /* @__PURE__ */ jsxs(Flex, { style: { flexShrink: 0 }, align: "center", gap: 1, paddingRight: 1, children: [
-          /* @__PURE__ */ jsx(
-            Button,
-            {
-              padding: 2,
-              mode: "ghost",
-              onClick: () => increment(index, index + -1, doc._id, entities),
-              disabled: isFirst,
-              icon: ChevronUpIcon
-            }
-          ),
-          /* @__PURE__ */ jsx(
-            Button,
-            {
-              padding: 2,
-              mode: "ghost",
-              disabled: isLast,
-              onClick: () => increment(index, index + 1, doc._id, entities),
-              icon: ChevronDownIcon
-            }
-          )
-        ] }),
-        /* @__PURE__ */ jsx(Box, { style: { width: "100%" }, children: /* @__PURE__ */ jsxs(Flex, { flex: 1, align: "center", justify: "space-between", paddingRight: 3, children: [
-          /* @__PURE__ */ jsx(
-            Preview,
-            {
-              layout: "default",
-              value: doc,
-              schemaType: schema.get(doc._type)
-            }
-          ),
-          /* @__PURE__ */ jsx(Tooltip, { content: tooltip, portal: !0, placement: "right", boundaryElement: null, children: /* @__PURE__ */ jsx(Flex, { align: "center", style: { flexShrink: 0 }, children: /* @__PURE__ */ jsx(
-            DocumentStatusIndicator,
-            {
-              draft: versionsInfo.draft,
-              published: versionsInfo.published,
-              versions: versionsInfo.versions
-            }
-          ) }) })
-        ] }) }),
-        dragBadge && /* @__PURE__ */ jsx(Card, { tone: "default", marginRight: 4, radius: 5, children: /* @__PURE__ */ jsx(AvatarCounter, { count: dragBadge }) })
-      ] })
-    }
-  );
-}
-function lexicographicalSort(a, b) {
-  return !a[ORDER_FIELD_NAME] || !b[ORDER_FIELD_NAME] ? 0 : a[ORDER_FIELD_NAME] < b[ORDER_FIELD_NAME] ? -1 : a[ORDER_FIELD_NAME] > b[ORDER_FIELD_NAME] ? 1 : 0;
-}
-const reorderDocuments = ({
-  entities,
-  selectedIds,
-  source,
-  destination
-}) => {
-  const startIndex = source.index, endIndex = destination.index, isMovingUp = startIndex > endIndex, selectedItems = entities.filter((item) => selectedIds.includes(item._id)), message = [
-    "Moved",
-    selectedItems.length === 1 ? "1 document" : `${selectedItems.length} documents`,
-    isMovingUp ? "up" : "down",
-    "from position",
-    `${startIndex + 1} to ${endIndex + 1}`
-  ].join(" "), { all, selected } = entities.reduce(
-    (acc, cur, curIndex) => {
-      if (selectedIds.includes(cur._id))
-        return { all: acc.all, selected: acc.selected };
-      if (curIndex === endIndex) {
-        const prevIndex = curIndex - 1, prevRank = parseOrderRank(entities[prevIndex]?.[ORDER_FIELD_NAME], LexoRank.min()), curRank = parseOrderRank(entities[curIndex][ORDER_FIELD_NAME], LexoRank.min()), nextIndex = curIndex + 1, nextRank = parseOrderRank(entities[nextIndex]?.[ORDER_FIELD_NAME], LexoRank.max());
-        let betweenRank = isMovingUp ? prevRank.between(curRank) : curRank.between(nextRank);
-        for (let selectedIndex = 0; selectedIndex < selectedItems.length; selectedIndex += 1)
-          selectedItems[selectedIndex][ORDER_FIELD_NAME] = betweenRank.toString(), betweenRank = isMovingUp ? betweenRank.between(curRank) : betweenRank.between(nextRank);
-        return {
-          // The `all` array gets sorted by order field later anyway
-          // so that this probably isn't necessary ¯\_(ツ)_/¯
-          all: isMovingUp ? [...acc.all, ...selectedItems, cur] : [...acc.all, cur, ...selectedItems],
-          selected: selectedItems
-        };
-      }
-      return { all: [...acc.all, cur], selected: acc.selected };
-    },
-    { all: [], selected: [] }
-  ), patches = selected.flatMap((doc) => {
-    const docPatches = [
-      [
-        doc._id,
-        {
-          set: {
-            [ORDER_FIELD_NAME]: doc[ORDER_FIELD_NAME]
-          }
-        }
-      ]
-    ];
-    return doc._id.startsWith("drafts.") && doc.hasPublished && docPatches.push([
-      doc._id.replace("drafts.", ""),
-      {
-        set: {
-          [ORDER_FIELD_NAME]: doc[ORDER_FIELD_NAME]
-        }
-      }
-    ]), docPatches;
-  });
-  return { newOrder: all.sort(lexicographicalSort), patches, message };
-};
-function useSanityClient() {
-  const { perspectiveStack } = usePerspective();
-  return useClient({ apiVersion: API_VERSION }).withConfig({ perspective: perspectiveStack });
-}
-const getItemStyle = (draggableStyle, itemIsUpdating) => ({
-  userSelect: "none",
-  transition: "opacity 500ms ease-in-out",
-  opacity: itemIsUpdating ? 0.2 : 1,
-  pointerEvents: itemIsUpdating ? "none" : void 0,
-  ...draggableStyle
-}), cardTone = (settings) => {
-  const { isDuplicate, isGhosting, isDragging, isSelected } = settings;
-  if (isGhosting) return "transparent";
-  if (isDragging || isSelected) return "primary";
-  if (isDuplicate) return "caution";
-};
-function DraggableList({ data, listIsUpdating, setListIsUpdating }) {
-  const toast = useToast(), router = usePaneRouter(), { groupIndex, routerPanesState } = router, currentDoc = routerPanesState[groupIndex + 1]?.[0]?.id || !1, [orderedData, setOrderedData] = useState(data);
-  useEffect(() => {
-    listIsUpdating || setOrderedData(data);
-  }, [data]);
-  const [draggingId, setDraggingId] = useState(""), [selectedIds, setSelectedIds] = useState(currentDoc ? [currentDoc] : []), clearSelected = useCallback(() => setSelectedIds([]), [setSelectedIds]), handleSelect = useCallback(
-    (clickedId, index, nativeEvent) => {
-      const isSelected = selectedIds.includes(clickedId), selectMultiple = nativeEvent.shiftKey, selectAdditional = navigator.appVersion.indexOf("Win") !== -1 ? nativeEvent.ctrlKey : nativeEvent.metaKey;
-      let updatedIds = [];
-      if (!selectMultiple && !selectAdditional)
-        return setSelectedIds([clickedId]);
-      if (selectMultiple && nativeEvent.preventDefault(), selectMultiple && !isSelected) {
-        const lastSelectedId = selectedIds[selectedIds.length - 1], lastSelectedIndex = orderedData.findIndex((item) => item._id === lastSelectedId), firstSelected = index < lastSelectedIndex ? index : lastSelectedIndex, lastSelected = index > lastSelectedIndex ? index : lastSelectedIndex, betweenIds = orderedData.filter((item, itemIndex) => itemIndex > firstSelected && itemIndex < lastSelected).map((item) => item._id);
-        updatedIds = [...selectedIds, ...betweenIds, clickedId];
-      } else isSelected ? updatedIds = selectedIds.filter((id) => id !== clickedId) : updatedIds = [...selectedIds, clickedId];
-      return setSelectedIds(updatedIds);
-    },
-    [setSelectedIds, orderedData, selectedIds]
-  ), client = useSanityClient(), transactPatches = useCallback(
-    async (patches, message) => {
-      const transaction = client.transaction();
-      patches.forEach(([docId, ops]) => transaction.patch(docId, ops));
-      try {
-        const updated = await transaction.commit({
-          visibility: "async",
-          tag: "orderable-document-list.reorder"
-        });
-        clearSelected(), setDraggingId(""), setListIsUpdating(!1), toast.push({
-          title: `${updated.results.length === 1 ? "1 document" : `${updated.results.length} documents`} reordered`,
-          status: "success",
-          description: message
-        });
-      } catch {
-        setDraggingId(""), setListIsUpdating(!1), toast.push({
-          title: "Reordering failed",
-          status: "error"
-        });
-      }
-    },
-    [client, setDraggingId, clearSelected, setListIsUpdating, toast]
-  ), handleDragEnd = useCallback(
-    (result, entities) => {
-      setDraggingId("");
-      const { source, destination, draggableId } = result ?? {};
-      if (source?.index === destination?.index || !entities?.length || !draggableId) return;
-      const effectedIds = selectedIds?.length ? selectedIds : [draggableId];
-      if (!effectedIds?.length) return;
-      setListIsUpdating(!0), setSelectedIds(effectedIds);
-      const { newOrder, patches, message } = reorderDocuments({
-        entities,
-        selectedIds: effectedIds,
-        source,
-        destination
-      });
-      newOrder?.length && setOrderedData(newOrder), patches?.length && transactPatches(patches, message);
-    },
-    [selectedIds, setDraggingId, setSelectedIds, transactPatches, setListIsUpdating]
-  ), handleDragStart = useCallback(
-    (start) => {
-      const id = start.draggableId;
-      selectedIds.includes(id) || clearSelected(), setDraggingId(id);
-    },
-    [selectedIds, clearSelected, setDraggingId]
-  ), incrementIndex = useCallback(
-    (shiftFrom, shiftTo, id, entities) => handleDragEnd({
-      draggableId: id,
-      source: { index: shiftFrom },
-      destination: { index: shiftTo }
-    }, entities),
-    [handleDragEnd]
-  ), onWindowKeyDown = useCallback(
-    (event) => {
-      event.key === "Escape" && clearSelected();
-    },
-    [clearSelected]
-  );
-  useEffect(() => (window.addEventListener("keydown", onWindowKeyDown), () => {
-    window.removeEventListener("keydown", onWindowKeyDown);
-  }), [onWindowKeyDown]);
-  const duplicateOrders = useMemo(() => {
-    if (!orderedData.length) return [];
-    const orderField = orderedData.map((item) => item[ORDER_FIELD_NAME]);
-    return orderField.filter((item, index) => orderField.indexOf(item) !== index);
-  }, [orderedData]), onDragEnd = useCallback(
-    (result) => handleDragEnd(result, orderedData),
-    [orderedData, handleDragEnd]
-  );
-  return /* @__PURE__ */ jsx(DragDropContext, { onDragStart: handleDragStart, onDragEnd, children: /* @__PURE__ */ jsx(Droppable, { droppableId: "documentSortZone", children: (provided) => /* @__PURE__ */ jsxs("div", { ...provided.droppableProps, ref: provided.innerRef, children: [
-    orderedData.map((item, index) => /* @__PURE__ */ jsx(
-      Draggable,
-      {
-        draggableId: item._id,
-        index,
-        children: (innerProvided, innerSnapshot) => {
-          const isSelected = selectedIds.includes(item._id), isDragging = innerSnapshot.isDragging, isGhosting = !!(!isDragging && draggingId && isSelected), isUpdating = listIsUpdating && isSelected, isDisabled = !item[ORDER_FIELD_NAME], isDuplicate = duplicateOrders.includes(item[ORDER_FIELD_NAME]), tone = cardTone({ isDuplicate, isGhosting, isDragging, isSelected }), selectedCount = selectedIds.length, dragBadge = isDragging && selectedCount > 1 ? selectedCount : !1;
-          return /* @__PURE__ */ jsx(
-            "div",
-            {
-              ref: innerProvided.innerRef,
-              ...innerProvided.draggableProps,
-              ...innerProvided.dragHandleProps,
-              style: isDisabled ? { opacity: 0.2, pointerEvents: "none" } : getItemStyle(innerProvided.draggableProps.style, isUpdating),
-              children: /* @__PURE__ */ jsx(Box, { paddingBottom: 1, children: /* @__PURE__ */ jsx(
-                Card,
-                {
-                  tone,
-                  shadow: isDragging ? 2 : void 0,
-                  radius: 2,
-                  onClick: (e) => handleSelect(item._id, index, e.nativeEvent),
-                  children: /* @__PURE__ */ jsx(
-                    Document,
-                    {
-                      doc: item,
-                      entities: orderedData,
-                      increment: incrementIndex,
-                      index,
-                      isFirst: index === 0,
-                      isLast: index === orderedData.length - 1,
-                      dragBadge
-                    }
-                  )
-                }
-              ) })
-            }
-          );
-        }
-      },
-      `${item._id}-${item[ORDER_FIELD_NAME]}`
-    )),
-    provided.placeholder
-  ] }) }) });
-}
-const DEFAULT_PARAMS = {};
-function getDocumentQuery({
-  type,
-  filter,
-  params = DEFAULT_PARAMS,
-  currentVersion
-}) {
-  let perspectiveFilter = null;
-  currentVersion === "published" ? perspectiveFilter = '!(_id in path("drafts.**")) && !(_id in path("versions.**"))' : currentVersion === "drafts" ? perspectiveFilter = `
-      (_id in path("drafts.**") || (!(_id in path("drafts.**")) && !(_id in path("versions.**"))))
-    ` : perspectiveFilter = '(sanity::partOfRelease($currentVersion) || (!(_id in path("drafts.**")) && !(_id in path("versions.**"))) || (_id in path("drafts.**")))';
-  const querySelect = `*[_type == $type ${perspectiveFilter ? `&& ${perspectiveFilter}` : ""}${filter ? `&& ${filter}` : ""}]`, queryOrder = "|order(@[$order] asc)", queryFields = `{_id, _type, ${ORDER_FIELD_NAME}}`, query = `${querySelect}${queryOrder}${queryFields}`, queryParams = {
-    ...params,
-    type,
-    order: ORDER_FIELD_NAME,
-    ...currentVersion && { currentVersion }
-  };
-  return { query, queryParams };
-}
-const isVersionForCurrentPerspective = (document, perspectiveName, publishedId) => document._id && isVersionId(document._id) && getVersionFromId(document._id) === perspectiveName && getPublishedId(document._id) === publishedId, getFilteredDedupedDocs = (documents, perspectiveName) => {
-  const flatDocuments = documents.flat();
-  return flatDocuments.reduce((acc, cur) => {
-    if (!cur._id)
-      return acc;
-    if (isVersionId(cur._id)) {
-      const isCorrectVersion = getVersionFromId(cur._id) === perspectiveName;
-      return perspectiveName && perspectiveName !== "drafts" && perspectiveName !== "published" && isCorrectVersion ? [...acc, cur] : acc;
-    }
-    if (perspectiveName === "published")
-      return isPublishedId(cur._id) ? [...acc, cur] : acc;
-    if (!isDraftId(cur._id)) {
-      const publishedId = getPublishedId(cur._id), countNrPublished = JSON.stringify(flatDocuments).match(`/${publishedId}/g`), hasMatchingVersion = perspectiveName && perspectiveName !== "drafts" && perspectiveName !== "published" ? flatDocuments.some(
-        (doc) => isVersionForCurrentPerspective(doc, perspectiveName, publishedId)
-      ) : !1, hasDraft = flatDocuments.some((doc) => doc._id === `drafts.${cur._id}`);
-      return hasMatchingVersion || hasDraft || countNrPublished ? acc : [...acc, cur];
-    }
-    if (perspectiveName && perspectiveName !== "drafts" && perspectiveName !== "published") {
-      const baseId = getPublishedId(cur._id);
-      if (flatDocuments.some(
-        (doc) => isVersionForCurrentPerspective(doc, perspectiveName, baseId)
-      ))
-        return acc;
-    }
-    return cur.hasPublished = flatDocuments.some((doc) => doc._id === cur._id.replace("drafts.", "")), [...acc, cur];
-  }, []);
-};
-function DocumentListQuery(props) {
-  const [listIsUpdating, setListIsUpdating] = useState(!1), [data, setData] = useState([]), { query, queryParams } = getDocumentQuery(props), {
-    data: _queryData,
-    loading,
-    error
-  } = useListeningQuery(query, {
-    params: queryParams,
-    initialValue: []
-  }), queryData = _queryData;
-  useEffect(() => {
-    if (queryData) {
-      const filteredDocuments = getFilteredDedupedDocs(queryData, props.currentVersion);
-      setData(filteredDocuments);
-    } else
-      setData([]);
-  }, [queryData]);
-  const unorderedDataCount = useMemo(
-    () => data?.length ? data.filter((doc) => !doc[ORDER_FIELD_NAME]).length : 0,
-    [data]
-  );
-  return loading ? /* @__PURE__ */ jsx(Flex, { style: { width: "100%", height: "100%" }, align: "center", justify: "center", children: /* @__PURE__ */ jsx(Spinner, {}) }) : error ? /* @__PURE__ */ jsx(Box, { padding: 2, children: /* @__PURE__ */ jsx(Feedback, { tone: "critical", title: "There was an error", description: "Please try again later" }) }) : !data || data?.length == 0 ? /* @__PURE__ */ jsx(Flex, { align: "center", direction: "column", height: "fill", justify: "center", children: /* @__PURE__ */ jsx(Container, { width: 1, children: /* @__PURE__ */ jsx(Box, { paddingX: 4, paddingY: 5, children: /* @__PURE__ */ jsx(Text, { align: "center", muted: !0, children: "No documents of this type" }) }) }) }) : /* @__PURE__ */ jsx(Stack, { space: 1, style: { overflow: "auto", height: "100%" }, children: /* @__PURE__ */ jsxs(Box, { padding: 2, children: [
-    unorderedDataCount > 0 && /* @__PURE__ */ jsx(Box, { marginBottom: 2, children: /* @__PURE__ */ jsx(
-      Feedback,
-      {
-        tone: "caution",
-        description: /* @__PURE__ */ jsxs(Fragment, { children: [
-          unorderedDataCount,
-          "/",
-          data?.length,
-          " documents have no order. Select",
-          " ",
-          /* @__PURE__ */ jsx("strong", { children: "Reset Order" }),
-          " from the menu above to fix."
-        ] })
-      }
-    ) }),
-    /* @__PURE__ */ jsx(
-      DraggableList,
-      {
-        data,
-        listIsUpdating,
-        setListIsUpdating
-      }
-    )
-  ] }) });
-}
-function DocumentListWrapper({
-  type,
-  showIncrements,
-  resetOrderTransaction,
-  filter,
-  params,
-  currentVersion
-}) {
-  const toast = useToast(), schema = useSchema();
-  useEffect(() => {
-    resetOrderTransaction?.title && resetOrderTransaction?.status && toast.push(resetOrderTransaction);
-  }, [resetOrderTransaction, toast]);
-  const schemaIsInvalid = useMemo(() => {
-    if (!type)
-      return /* @__PURE__ */ jsxs(Fragment, { children: [
-        "No ",
-        /* @__PURE__ */ jsx("code", { children: "type" }),
-        " was configured"
-      ] });
-    const typeSchema = schema.get(type);
-    return typeSchema ? !("fields" in typeSchema) || !typeSchema.fields.some((field) => field?.name === ORDER_FIELD_NAME) ? /* @__PURE__ */ jsxs(Fragment, { children: [
-      "Schema ",
-      /* @__PURE__ */ jsx("code", { children: type }),
-      " must have an ",
-      /* @__PURE__ */ jsx("code", { children: ORDER_FIELD_NAME }),
-      " field of type",
-      " ",
-      /* @__PURE__ */ jsx("code", { children: "string" })
-    ] }) : "fields" in typeSchema && typeSchema.fields.some(
-      (field) => field?.name === ORDER_FIELD_NAME && field?.type?.name !== "string"
-    ) ? /* @__PURE__ */ jsxs(Fragment, { children: [
-      /* @__PURE__ */ jsx("code", { children: ORDER_FIELD_NAME }),
-      " field on Schema ",
-      /* @__PURE__ */ jsx("code", { children: type }),
-      " must be",
-      " ",
-      /* @__PURE__ */ jsx("code", { children: "string" }),
-      " type"
-    ] }) : "" : /* @__PURE__ */ jsxs(Fragment, { children: [
-      "Schema ",
-      /* @__PURE__ */ jsx("code", { children: type }),
-      " not found"
-    ] });
-  }, [type, schema]);
-  return schemaIsInvalid ? /* @__PURE__ */ jsx(Box, { padding: 2, children: /* @__PURE__ */ jsx(Feedback, { description: schemaIsInvalid, tone: "caution" }) }) : /* @__PURE__ */ jsx(OrderableContext.Provider, { value: { showIncrements }, children: /* @__PURE__ */ jsx(
-    DocumentListQuery,
-    {
-      type,
-      filter,
-      params,
-      currentVersion
-    }
-  ) });
-}
-async function resetOrder(params) {
-  const { client, currentVersion, ...queryProps } = params, { query, queryParams } = getDocumentQuery({ ...queryProps, currentVersion }), documents = await client.fetch(query, queryParams, {
-    tag: "orderable-document-list.reset-order"
-  });
-  if (documents.length === 0)
-    return null;
-  let aLexoRank = LexoRank.min();
-  return documents.map((doc) => doc._id).reduce((trx, documentId) => (aLexoRank = aLexoRank.genNext().genNext(), trx.patch(documentId, {
-    set: { [ORDER_FIELD_NAME]: aLexoRank.toString() }
-  })), client.transaction()).commit({
-    visibility: "async",
-    tag: "orderable-document-list.reset-order"
-  });
-}
-class OrderableDocumentList extends Component {
-  constructor(props) {
-    super(props), this.state = {
-      showIncrements: !1,
-      resetOrderTransaction: {}
-    };
-  }
-  actionHandlers = {
-    showIncrements: () => {
-      this.setState((state) => ({
-        showIncrements: !state.showIncrements
-      }));
-    },
-    resetOrder: async () => {
-      this.setState(() => ({
-        resetOrderTransaction: {
-          status: "info",
-          title: "Reordering started...",
-          closable: !0
-        }
-      }));
-      const update = await resetOrder(this.props.options), reorderWasSuccessful = update?.results?.length;
-      this.setState(() => ({
-        resetOrderTransaction: {
-          status: reorderWasSuccessful ? "success" : "info",
-          title: reorderWasSuccessful ? `Reordered ${update.results.length === 1 ? "Document" : "Documents"}` : "Reordering failed",
-          closable: !0
-        }
-      }));
-    }
-  };
-  render() {
-    const type = this?.props?.options?.type;
-    return type ? /* @__PURE__ */ jsx(
-      DocumentListWrapper,
-      {
-        filter: this?.props?.options?.filter,
-        params: this?.props?.options?.params,
-        type,
-        showIncrements: this.state.showIncrements,
-        resetOrderTransaction: this.state.resetOrderTransaction,
-        currentVersion: this?.props?.options?.currentVersion
-      }
-    ) : null;
-  }
-}
-function orderableDocumentListDeskItem(config) {
-  if (!config?.type || !config.context || !config.S)
-    throw new Error(`
-    type, context and S (StructureBuilder) must be provided.
-    context and S are available when configuring structure.
-    Example: orderableDocumentListDeskItem({type: 'category'})
-    `);
-  const { type, filter, menuItems = [], createIntent, params, title, icon, id, context, S } = config, { schema, getClient } = context, perspectiveStack = context.perspectiveStack || [], client = getClient({ apiVersion: API_VERSION }), currentVersion = perspectiveStack[0], listTitle = title ?? `Orderable ${type}`, listId = id ?? `orderable-${type}`, listIcon = icon ?? SortIcon, typeTitle = schema.get(type)?.title ?? type;
-  return createIntent !== !1 && menuItems.push(
-    S.menuItem().title(`Create new ${typeTitle}`).intent({ type: "create", params: { type } }).serialize()
-  ), S.listItem().title(listTitle).id(listId).icon(listIcon).schemaType(type).child(
-    Object.assign(
-      S.documentTypeList(type).canHandleIntent(() => !!createIntent).serialize(),
-      {
-        // Prevents the component from re-rendering when switching documents
-        __preserveInstance: !0,
-        // Prevents the component from NOT re-rendering when switching listItems
-        key: listId,
-        type: "component",
-        component: OrderableDocumentList,
-        options: { type, filter, params, client, currentVersion },
-        menuItems: [
-          ...menuItems,
-          S.menuItem().title("Reset Order").icon(GenerateIcon).action("resetOrder").serialize(),
-          S.menuItem().title("Toggle Increments").icon(SortIcon).action("showIncrements").serialize()
-        ]
-      }
-    )
-  ).serialize();
-}
-export {
-  OrderableDocumentList,
-  orderRankField,
-  orderRankOrdering,
-  orderableDocumentListDeskItem
-};
-//# sourceMappingURL=index.js.map