@sanity/orderable-document-list 0.0.10 → 1.0.0-v3-studio.2

package/lib/index.modern.js

@@ -0,0 +1,818 @@
+import {defineField as $jPEKE$defineField, useSchema as $jPEKE$useSchema, useClient as $jPEKE$useClient} from "sanity";
+import {LexoRank as $jPEKE$LexoRank} from "lexorank";
+import {SortIcon as $jPEKE$SortIcon, GenerateIcon as $jPEKE$GenerateIcon, DragHandleIcon as $jPEKE$DragHandleIcon, ChevronUpIcon as $jPEKE$ChevronUpIcon, ChevronDownIcon as $jPEKE$ChevronDownIcon} from "@sanity/icons";
+import {jsx as $jPEKE$jsx, jsxs as $jPEKE$jsxs, Fragment as $jPEKE$Fragment} from "react/jsx-runtime";
+import $jPEKE$react, {Component as $jPEKE$Component, useEffect as $jPEKE$useEffect, useMemo as $jPEKE$useMemo, useState as $jPEKE$useState, useCallback as $jPEKE$useCallback, useContext as $jPEKE$useContext} from "react";
+import {useToast as $jPEKE$useToast, Flex as $jPEKE$Flex, Spinner as $jPEKE$Spinner, Stack as $jPEKE$Stack, Box as $jPEKE$Box, Card as $jPEKE$Card, Text as $jPEKE$Text, Button as $jPEKE$Button} from "@sanity/ui";
+import {DragDropContext as $jPEKE$DragDropContext, Droppable as $jPEKE$Droppable, Draggable as $jPEKE$Draggable} from "react-beautiful-dnd";
+import {usePaneRouter as $jPEKE$usePaneRouter} from "sanity/desk";
+import {SanityPreview as $jPEKE$SanityPreview} from "sanity/_unstable";
+
+
+const $21d4b1fe36f88c6f$export$64f27603cb09ba16 = `orderRank`;
+
+
+
+function $27620c24e1768bdb$export$2e2bcd8739ae039(lastRankValue = ``) {
+    const lastRank = lastRankValue ? (0, $jPEKE$LexoRank).parse(lastRankValue) : (0, $jPEKE$LexoRank).min();
+    const nextRank = lastRank.genNext().genNext();
+    return nextRank.value;
+}
+
+
+const $0413292d5e32b5d9$export$64a609a9111ff100 = (config)=>{
+    if (!config?.type) throw new Error(`
+      type must be provided.
+      Example: orderRankField({type: 'category'})
+      `);
+    const { type: type  } = config;
+    return (0, $jPEKE$defineField)({
+        title: "Order Rank",
+        readOnly: true,
+        hidden: true,
+        ...config,
+        name: (0, $21d4b1fe36f88c6f$export$64f27603cb09ba16),
+        type: "string",
+        initialValue: async ({ getClient: getClient  })=>{
+            const lastDocOrderRank = await getClient({
+                apiVersion: "2021-09-01"
+            }).fetch(`*[_type == $type]|order(@[$order] desc)[0][$order]`, {
+                type: type,
+                order: (0, $21d4b1fe36f88c6f$export$64f27603cb09ba16)
+            });
+            return (0, $27620c24e1768bdb$export$2e2bcd8739ae039)(lastDocOrderRank);
+        }
+    });
+};
+
+
+
+const $e83e0ebbc2cf37df$export$db2ff2f898748a67 = {
+    title: "Ordered",
+    name: "ordered",
+    by: [
+        {
+            field: (0, $21d4b1fe36f88c6f$export$64f27603cb09ba16),
+            direction: "asc"
+        }
+    ]
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const $69dfcc58d43c2b6d$export$2a2017d0ec5437fa = (0, $jPEKE$react).createContext({});
+
+
+function $2e8241e9842bdebe$export$2e2bcd8739ae039({ doc: doc , increment: increment , entities: entities , handleSelect: handleSelect , index: index , isFirst: isFirst , isLast: isLast  }) {
+    const { showIncrements: showIncrements  } = (0, $jPEKE$useContext)((0, $69dfcc58d43c2b6d$export$2a2017d0ec5437fa));
+    const schema = (0, $jPEKE$useSchema)();
+    return /*#__PURE__*/ (0, $jPEKE$jsxs)((0, $jPEKE$Flex), {
+        align: "center",
+        children: [
+            /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Box), {
+                paddingX: 3,
+                style: {
+                    flexShrink: 0
+                },
+                children: /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Text), {
+                    size: 4,
+                    children: /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$DragHandleIcon), {})
+                })
+            }),
+            showIncrements && /*#__PURE__*/ (0, $jPEKE$jsxs)((0, $jPEKE$Flex), {
+                style: {
+                    flexShrink: 0
+                },
+                align: "center",
+                gap: 1,
+                paddingRight: 1,
+                children: [
+                    /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Button), {
+                        padding: 2,
+                        mode: "ghost",
+                        onClick: ()=>increment(index, index + -1, doc._id, entities),
+                        disabled: isFirst,
+                        icon: (0, $jPEKE$ChevronUpIcon)
+                    }),
+                    /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Button), {
+                        padding: 2,
+                        mode: "ghost",
+                        disabled: isLast,
+                        onClick: ()=>increment(index, index + 1, doc._id, entities),
+                        icon: (0, $jPEKE$ChevronDownIcon)
+                    })
+                ]
+            }),
+            /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Button), {
+                style: {
+                    width: `100%`
+                },
+                padding: 2,
+                mode: "bleed",
+                onClick: (e)=>handleSelect(doc._id, index, e.nativeEvent),
+                children: /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Flex), {
+                    flex: 1,
+                    align: "center",
+                    children: /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Box), {
+                        flex: 1,
+                        children: /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$SanityPreview), {
+                            layout: "default",
+                            value: doc,
+                            schemaType: schema.get(doc._type)
+                        })
+                    })
+                })
+            })
+        ]
+    });
+}
+
+
+
+
+function $793aacd9a77a8bc3$var$lexicographicalSort(a, b) {
+    if (a[0, $21d4b1fe36f88c6f$export$64f27603cb09ba16] < b[0, $21d4b1fe36f88c6f$export$64f27603cb09ba16]) return -1;
+    if (a[0, $21d4b1fe36f88c6f$export$64f27603cb09ba16] > b[0, $21d4b1fe36f88c6f$export$64f27603cb09ba16]) return 1;
+    return 0;
+}
+const $793aacd9a77a8bc3$export$1b86f2c90605ffb9 = ({ entities: entities , selectedIds: selectedIds , source: source , destination: destination , debug: debug = false  })=>{
+    const startIndex = source.index;
+    const endIndex = destination.index;
+    const isMovingUp = startIndex > endIndex;
+    const selectedItems = entities.filter((item)=>selectedIds.includes(item._id));
+    const message = [
+        `Moved`,
+        selectedItems.length === 1 ? `1 Document` : `${selectedItems.length} Documents`,
+        isMovingUp ? `up` : `down`,
+        `from position`,
+        `${startIndex + 1} to ${endIndex + 1}`, 
+    ].join(" ");
+    const { all: all , selected: selected  } = entities.reduce((acc, cur, curIndex)=>{
+        // Selected items get spread in below, so skip them here
+        if (selectedIds.includes(cur._id)) return {
+            all: acc.all,
+            selected: acc.selected
+        };
+        // Drop seleced items in
+        if (curIndex === endIndex) {
+            const prevIndex = curIndex - 1;
+            const prevRank = entities[prevIndex]?.[0, $21d4b1fe36f88c6f$export$64f27603cb09ba16] ? (0, $jPEKE$LexoRank).parse(entities[prevIndex]?.[0, $21d4b1fe36f88c6f$export$64f27603cb09ba16]) : (0, $jPEKE$LexoRank).min();
+            const curRank = (0, $jPEKE$LexoRank).parse(entities[curIndex][0, $21d4b1fe36f88c6f$export$64f27603cb09ba16]);
+            const nextIndex = curIndex + 1;
+            const nextRank = entities[nextIndex]?.[0, $21d4b1fe36f88c6f$export$64f27603cb09ba16] ? (0, $jPEKE$LexoRank).parse(entities[nextIndex]?.[0, $21d4b1fe36f88c6f$export$64f27603cb09ba16]) : (0, $jPEKE$LexoRank).max();
+            let betweenRank = isMovingUp ? prevRank.between(curRank) : curRank.between(nextRank);
+            // For each selected item, assign a new orderRank between now and next
+            for(let selectedIndex = 0; selectedIndex < selectedItems.length; selectedIndex += 1){
+                selectedItems[selectedIndex][0, $21d4b1fe36f88c6f$export$64f27603cb09ba16] = betweenRank.value;
+                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: []
+    });
+    const patches = selected.map((doc)=>{
+        return [
+            doc._id,
+            {
+                set: {
+                    [(0, $21d4b1fe36f88c6f$export$64f27603cb09ba16)]: doc[0, $21d4b1fe36f88c6f$export$64f27603cb09ba16]
+                }
+            }, 
+        ];
+    });
+    // Safety-check to make sure everything is in order
+    const allSorted = all.sort($793aacd9a77a8bc3$var$lexicographicalSort);
+    return {
+        newOrder: allSorted,
+        patches: patches,
+        message: message
+    };
+};
+
+
+
+
+function $f49f7a30883dbc1b$export$8d49af9be9632eba() {
+    return (0, $jPEKE$useClient)({
+        apiVersion: "2021-09-01"
+    });
+}
+
+
+const $e1f104d9525f6d72$var$getItemStyle = (draggableStyle, itemIsUpdating)=>({
+        userSelect: "none",
+        transition: `opacity 500ms ease-in-out`,
+        opacity: itemIsUpdating ? 0.2 : 1,
+        pointerEvents: itemIsUpdating ? `none` : undefined,
+        ...draggableStyle
+    });
+const $e1f104d9525f6d72$var$cardTone = (settings)=>{
+    const { isDuplicate: isDuplicate , isGhosting: isGhosting , isDragging: isDragging , isSelected: isSelected  } = settings;
+    if (isGhosting) return `transparent`;
+    if (isDragging || isSelected) return `primary`;
+    if (isDuplicate) return `caution`;
+    return undefined;
+};
+function $e1f104d9525f6d72$export$2e2bcd8739ae039({ data: data , type: type , listIsUpdating: listIsUpdating , setListIsUpdating: setListIsUpdating  }) {
+    const toast = (0, $jPEKE$useToast)();
+    const router = (0, $jPEKE$usePaneRouter)();
+    const { navigateIntent: navigateIntent  } = router;
+    // Maintains local state order before transaction completes
+    const [orderedData, setOrderedData] = (0, $jPEKE$useState)(data);
+    // Update local state when documents change from an outside source
+    (0, $jPEKE$useEffect)(()=>{
+        if (!listIsUpdating) setOrderedData(data);
+    /* eslint-disable-next-line react-hooks/exhaustive-deps */ }, [
+        data
+    ]);
+    const [draggingId, setDraggingId] = (0, $jPEKE$useState)(``);
+    const [selectedIds, setSelectedIds] = (0, $jPEKE$useState)([]);
+    const clearSelected = (0, $jPEKE$useCallback)(()=>setSelectedIds([]), [
+        setSelectedIds
+    ]);
+    const handleSelect = (0, $jPEKE$useCallback)((clickedId, index, nativeEvent)=>{
+        const isSelected = selectedIds.includes(clickedId);
+        const selectMultiple = nativeEvent.shiftKey;
+        const isUsingWindows = navigator.appVersion.indexOf("Win") !== -1;
+        const selectAdditional = isUsingWindows ? nativeEvent.ctrlKey : nativeEvent.metaKey;
+        let updatedIds = [];
+        // No modifier keys pressed during click:
+        // - update selected to just this one
+        // - open document
+        if (!selectMultiple && !selectAdditional) {
+            navigateIntent("edit", {
+                id: clickedId,
+                type: type
+            });
+            return setSelectedIds([
+                clickedId
+            ]);
+        }
+        // Shift key was held, add id's between last selected and this one
+        // ...before adding this one
+        if (selectMultiple && !isSelected) {
+            const lastSelectedId = selectedIds[selectedIds.length - 1];
+            const lastSelectedIndex = orderedData.findIndex((item)=>item._id === lastSelectedId);
+            const firstSelected = index < lastSelectedIndex ? index : lastSelectedIndex;
+            const lastSelected = index > lastSelectedIndex ? index : lastSelectedIndex;
+            const betweenIds = orderedData.filter((item, itemIndex)=>itemIndex > firstSelected && itemIndex < lastSelected).map((item)=>item._id);
+            updatedIds = [
+                ...selectedIds,
+                ...betweenIds,
+                clickedId
+            ];
+        } else if (isSelected) // Toggle off a single id
+        updatedIds = selectedIds.filter((id)=>id !== clickedId);
+        else // Toggle on a single id
+        updatedIds = [
+            ...selectedIds,
+            clickedId
+        ];
+        return setSelectedIds(updatedIds);
+    }, [
+        setSelectedIds,
+        navigateIntent,
+        orderedData,
+        selectedIds,
+        type
+    ]);
+    const client = (0, $f49f7a30883dbc1b$export$8d49af9be9632eba)();
+    const transactPatches = (0, $jPEKE$useCallback)(async (patches, message)=>{
+        const transaction = client.transaction();
+        patches.forEach(([docId, ops])=>transaction.patch(docId, ops));
+        await transaction.commit().then((updated)=>{
+            clearSelected();
+            setDraggingId(``);
+            setListIsUpdating(false);
+            toast.push({
+                title: `${updated.results.length === 1 ? `1 Document` : `${updated.results.length} Documents`} Reordered`,
+                status: `success`,
+                description: message
+            });
+        }).catch(()=>{
+            setDraggingId(``);
+            setListIsUpdating(false);
+            toast.push({
+                title: `Reordering failed`,
+                status: `error`
+            });
+        });
+    }, [
+        client,
+        setDraggingId,
+        clearSelected,
+        setListIsUpdating,
+        toast
+    ]);
+    const handleDragEnd = (0, $jPEKE$useCallback)((result, entities)=>{
+        setDraggingId(``);
+        const { source: source , destination: destination , draggableId: draggableId  } = result ?? {};
+        // Don't do anything if nothing changed
+        if (source?.index === destination?.index) return;
+        // Don't do anything if we don't have the entitites
+        if (!entities?.length || !draggableId) return;
+        // A document can be dragged without being one-of-many-selected
+        const effectedIds = selectedIds?.length ? selectedIds : [
+            draggableId
+        ];
+        // Don't do anything if we don't have ids to effect
+        if (!effectedIds?.length) return;
+        // Update state to update styles + prevent data refetching
+        setListIsUpdating(true);
+        setSelectedIds(effectedIds);
+        const { newOrder: newOrder , patches: patches , message: message  } = (0, $793aacd9a77a8bc3$export$1b86f2c90605ffb9)({
+            entities: entities,
+            selectedIds: effectedIds,
+            source: source,
+            destination: destination
+        });
+        // Update local state
+        if (newOrder?.length) setOrderedData(newOrder);
+        // Transact new order patches
+        if (patches?.length) transactPatches(patches, message);
+    }, [
+        selectedIds,
+        setDraggingId,
+        setSelectedIds,
+        transactPatches,
+        setListIsUpdating
+    ]);
+    const handleDragStart = (0, $jPEKE$useCallback)((start)=>{
+        const id = start.draggableId;
+        const selected = selectedIds.includes(id);
+        // if dragging an item that is not selected - unselect all items
+        if (!selected) clearSelected();
+        setDraggingId(id);
+    }, [
+        selectedIds,
+        clearSelected,
+        setDraggingId
+    ]);
+    // Move one document up or down one place, by fake invoking the drag function
+    const incrementIndex = (0, $jPEKE$useCallback)((shiftFrom, shiftTo, id, entities)=>{
+        const result = {
+            draggableId: id,
+            source: {
+                index: shiftFrom
+            },
+            destination: {
+                index: shiftTo
+            }
+        };
+        return handleDragEnd(result, entities);
+    }, [
+        handleDragEnd
+    ]);
+    const onWindowKeyDown = (0, $jPEKE$useCallback)((event)=>{
+        if (event.key === "Escape") clearSelected();
+    }, [
+        clearSelected
+    ]);
+    (0, $jPEKE$useEffect)(()=>{
+        window.addEventListener("keydown", onWindowKeyDown);
+        return ()=>{
+            window.removeEventListener("keydown", onWindowKeyDown);
+        };
+    }, [
+        onWindowKeyDown
+    ]);
+    // Find all items with duplicate order field
+    const duplicateOrders = (0, $jPEKE$useMemo)(()=>{
+        if (!orderedData.length) return [];
+        const orderField = orderedData.map((item)=>item[0, $21d4b1fe36f88c6f$export$64f27603cb09ba16]);
+        return orderField.filter((item, index)=>orderField.indexOf(item) !== index);
+    }, [
+        orderedData
+    ]);
+    const onDragEnd = (0, $jPEKE$useCallback)((result)=>handleDragEnd(result, orderedData), [
+        orderedData,
+        handleDragEnd
+    ]);
+    return /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$DragDropContext), {
+        onDragStart: handleDragStart,
+        onDragEnd: onDragEnd,
+        children: /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Droppable), {
+            droppableId: "documentSortZone",
+            children: (provided)=>/*#__PURE__*/ (0, $jPEKE$jsxs)("div", {
+                    ...provided.droppableProps,
+                    ref: provided.innerRef,
+                    children: [
+                        orderedData.map((item, index)=>/*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Draggable), {
+                                draggableId: item._id,
+                                index: index,
+                                children: (innerProvided, innerSnapshot)=>{
+                                    const isSelected = selectedIds.includes(item._id);
+                                    const isDragging = innerSnapshot.isDragging;
+                                    const isGhosting = Boolean(!isDragging && draggingId && isSelected);
+                                    const isUpdating = listIsUpdating && isSelected;
+                                    const isDisabled = Boolean(!item[0, $21d4b1fe36f88c6f$export$64f27603cb09ba16]);
+                                    const isDuplicate = duplicateOrders.includes(item[0, $21d4b1fe36f88c6f$export$64f27603cb09ba16]);
+                                    const tone = $e1f104d9525f6d72$var$cardTone({
+                                        isDuplicate: isDuplicate,
+                                        isGhosting: isGhosting,
+                                        isDragging: isDragging,
+                                        isSelected: isSelected
+                                    });
+                                    return /*#__PURE__*/ (0, $jPEKE$jsx)("div", {
+                                        ref: innerProvided.innerRef,
+                                        ...innerProvided.draggableProps,
+                                        ...innerProvided.dragHandleProps,
+                                        style: isDisabled ? {
+                                            opacity: 0.2,
+                                            pointerEvents: `none`
+                                        } : $e1f104d9525f6d72$var$getItemStyle(innerProvided.draggableProps.style, isUpdating),
+                                        children: /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Box), {
+                                            paddingBottom: 1,
+                                            children: /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Card), {
+                                                tone: tone,
+                                                shadow: isDragging ? 2 : undefined,
+                                                radius: 2,
+                                                children: /*#__PURE__*/ (0, $jPEKE$jsx)((0, $2e8241e9842bdebe$export$2e2bcd8739ae039), {
+                                                    doc: item,
+                                                    entities: orderedData,
+                                                    handleSelect: handleSelect,
+                                                    increment: incrementIndex,
+                                                    index: index,
+                                                    isFirst: index === 0,
+                                                    isLast: index === orderedData.length - 1
+                                                })
+                                            })
+                                        })
+                                    });
+                                }
+                            }, `${item._id}-${item[0, $21d4b1fe36f88c6f$export$64f27603cb09ba16]}`)),
+                        provided.placeholder
+                    ]
+                })
+        })
+    });
+}
+
+
+
+
+
+
+function $60d135b0057fb272$export$2e2bcd8739ae039({ children: children  }) {
+    return /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Box), {
+        padding: 3,
+        children: /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Card), {
+            padding: 4,
+            radius: 2,
+            shadow: 1,
+            tone: "caution",
+            children: /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Text), {
+                children: children
+            })
+        })
+    });
+}
+
+
+
+const $5e43324e27157fbc$var$DEFAULT_PARAMS = {};
+function $5e43324e27157fbc$export$2e2bcd8739ae039({ type: type , filter: filter , params: params = $5e43324e27157fbc$var$DEFAULT_PARAMS  }) {
+    const [isLoading, setIsLoading] = (0, $jPEKE$useState)(true);
+    const [listIsUpdating, setListIsUpdating] = (0, $jPEKE$useState)(false);
+    const [data, setData] = (0, $jPEKE$useState)([]);
+    const client = (0, $f49f7a30883dbc1b$export$8d49af9be9632eba)();
+    (0, $jPEKE$useEffect)(()=>{
+        const query = `*[_type == $type ${filter ? `&& ${filter}` : ""}]|order(@[$order] asc){
+      _id, _type, ${(0, $21d4b1fe36f88c6f$export$64f27603cb09ba16)}
+    }`;
+        const queryParams = Object.assign(params, {
+            type: type,
+            order: (0, $21d4b1fe36f88c6f$export$64f27603cb09ba16)
+        });
+        let subscription;
+        // eslint-disable-next-line require-await
+        const fetchData = async ()=>{
+            client.fetch(query, queryParams).then((documents)=>{
+                // Remove published document from list if draft also exists
+                const filteredDocuments = documents.reduce((acc, cur)=>{
+                    if (!cur._id.startsWith(`drafts.`)) {
+                        // eslint-disable-next-line max-nested-callbacks
+                        const alsoHasDraft = documents.some((doc)=>doc._id === `drafts.${cur._id}`);
+                        return alsoHasDraft ? acc : [
+                            ...acc,
+                            cur
+                        ];
+                    }
+                    return [
+                        ...acc,
+                        cur
+                    ];
+                }, []);
+                setData(filteredDocuments);
+                if (isLoading) setIsLoading(false);
+            });
+        };
+        const prepareData = async ()=>{
+            setIsLoading(true);
+            await fetchData();
+            if (!subscription) subscription = client.listen(query, queryParams).subscribe(()=>fetchData());
+        };
+        // Get data but only if a document isn't being patched or we don't yet have data
+        if (!listIsUpdating && !data.length) prepareData();
+        return ()=>subscription?.unsubscribe();
+    /* eslint-disable-next-line react-hooks/exhaustive-deps */ }, [
+        type
+    ]);
+    const unorderedDataCount = (0, $jPEKE$useMemo)(()=>data.length ? data.filter((doc)=>!doc[0, $21d4b1fe36f88c6f$export$64f27603cb09ba16]).length : 0, [
+        data
+    ]);
+    if (isLoading) return /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Flex), {
+        style: {
+            width: `100%`,
+            height: `100%`
+        },
+        align: "center",
+        justify: "center",
+        children: /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Spinner), {})
+    });
+    return /*#__PURE__*/ (0, $jPEKE$jsxs)((0, $jPEKE$Stack), {
+        space: 1,
+        style: {
+            overflow: `scroll`,
+            height: `100%`
+        },
+        children: [
+            unorderedDataCount > 0 && /*#__PURE__*/ (0, $jPEKE$jsxs)((0, $60d135b0057fb272$export$2e2bcd8739ae039), {
+                children: [
+                    unorderedDataCount,
+                    "/",
+                    data.length,
+                    " Documents have no Order. Select",
+                    " ",
+                    /*#__PURE__*/ (0, $jPEKE$jsx)("strong", {
+                        children: "Reset Order"
+                    }),
+                    " from the Menu above to fix."
+                ]
+            }),
+            /*#__PURE__*/ (0, $jPEKE$jsx)((0, $jPEKE$Box), {
+                padding: 1,
+                children: /*#__PURE__*/ (0, $jPEKE$jsx)((0, $e1f104d9525f6d72$export$2e2bcd8739ae039), {
+                    data: data,
+                    type: type,
+                    listIsUpdating: listIsUpdating,
+                    setListIsUpdating: setListIsUpdating
+                })
+            })
+        ]
+    });
+}
+
+
+
+
+
+function $c3ce662734af156c$export$2e2bcd8739ae039({ type: type , showIncrements: showIncrements , resetOrderTransaction: resetOrderTransaction , filter: filter , params: params  }) {
+    const toast = (0, $jPEKE$useToast)();
+    const schema = (0, $jPEKE$useSchema)();
+    (0, $jPEKE$useEffect)(()=>{
+        if (resetOrderTransaction?.title && resetOrderTransaction?.status) toast.push(resetOrderTransaction);
+    }, [
+        resetOrderTransaction,
+        toast
+    ]);
+    const schemaIsInvalid = (0, $jPEKE$useMemo)(()=>{
+        // Option not passed
+        if (!type) return /*#__PURE__*/ (0, $jPEKE$jsxs)((0, $jPEKE$Fragment), {
+            children: [
+                "No ",
+                /*#__PURE__*/ (0, $jPEKE$jsx)("code", {
+                    children: "type"
+                }),
+                " was configured"
+            ]
+        });
+        const typeSchema = schema.get(type);
+        // Schema not found
+        if (!typeSchema) return /*#__PURE__*/ (0, $jPEKE$jsxs)((0, $jPEKE$Fragment), {
+            children: [
+                "Schema ",
+                /*#__PURE__*/ (0, $jPEKE$jsx)("code", {
+                    children: type
+                }),
+                " not found"
+            ]
+        });
+        // Schema lacks an order field
+        if (!("fields" in typeSchema) || !typeSchema.fields.some((field)=>field?.name === (0, $21d4b1fe36f88c6f$export$64f27603cb09ba16))) return /*#__PURE__*/ (0, $jPEKE$jsxs)((0, $jPEKE$Fragment), {
+            children: [
+                "Schema ",
+                /*#__PURE__*/ (0, $jPEKE$jsx)("code", {
+                    children: type
+                }),
+                " must have an ",
+                /*#__PURE__*/ (0, $jPEKE$jsx)("code", {
+                    children: (0, $21d4b1fe36f88c6f$export$64f27603cb09ba16)
+                }),
+                " field of type",
+                " ",
+                /*#__PURE__*/ (0, $jPEKE$jsx)("code", {
+                    children: "string"
+                })
+            ]
+        });
+        // Schema's order field is not a string
+        if ("fields" in typeSchema && typeSchema.fields.some((field)=>field?.name === (0, $21d4b1fe36f88c6f$export$64f27603cb09ba16) && field?.type?.name !== "string")) return /*#__PURE__*/ (0, $jPEKE$jsxs)((0, $jPEKE$Fragment), {
+            children: [
+                /*#__PURE__*/ (0, $jPEKE$jsx)("code", {
+                    children: (0, $21d4b1fe36f88c6f$export$64f27603cb09ba16)
+                }),
+                " field on Schema ",
+                /*#__PURE__*/ (0, $jPEKE$jsx)("code", {
+                    children: type
+                }),
+                " must be",
+                " ",
+                /*#__PURE__*/ (0, $jPEKE$jsx)("code", {
+                    children: "string"
+                }),
+                " type"
+            ]
+        });
+        return "";
+    }, [
+        type,
+        schema
+    ]);
+    if (schemaIsInvalid) return /*#__PURE__*/ (0, $jPEKE$jsx)((0, $60d135b0057fb272$export$2e2bcd8739ae039), {
+        children: schemaIsInvalid
+    });
+    return /*#__PURE__*/ (0, $jPEKE$jsx)((0, $69dfcc58d43c2b6d$export$2a2017d0ec5437fa).Provider, {
+        value: {
+            showIncrements: showIncrements
+        },
+        children: /*#__PURE__*/ (0, $jPEKE$jsx)((0, $5e43324e27157fbc$export$2e2bcd8739ae039), {
+            type: type,
+            filter: filter,
+            params: params
+        })
+    });
+}
+
+
+
+
+async function $813ed27cf8814dcd$export$ee841d674ca80db0(type = ``, client) {
+    const query = `*[_type == $type]|order(@[$order] asc)._id`;
+    const queryParams = {
+        type: type,
+        order: (0, $21d4b1fe36f88c6f$export$64f27603cb09ba16)
+    };
+    const documents = await client.fetch(query, queryParams);
+    if (!documents.length) return null;
+    const transaction = client.transaction();
+    let aLexoRank = (0, $jPEKE$LexoRank).min();
+    for(let index = 0; index < documents.length; index += 1){
+        // Generate next rank before even the first document so there's room to move!
+        aLexoRank = aLexoRank.genNext().genNext();
+        transaction.patch(documents[index], {
+            set: {
+                [(0, $21d4b1fe36f88c6f$export$64f27603cb09ba16)]: aLexoRank.value
+            }
+        });
+    }
+    return transaction.commit().then((update)=>update).catch((err)=>err);
+}
+
+
+class $c149fdd435bcc1b3$export$2e2bcd8739ae039 extends (0, $jPEKE$Component) {
+    constructor(props){
+        super(props);
+        this.state = {
+            showIncrements: false,
+            resetOrderTransaction: {}
+        };
+    }
+    actionHandlers = {
+        showIncrements: ()=>{
+            this.setState((state)=>({
+                    showIncrements: !state.showIncrements
+                }));
+        },
+        resetOrder: async ()=>{
+            this.setState(()=>({
+                    resetOrderTransaction: {
+                        status: `info`,
+                        title: `Reordering started...`,
+                        closable: true
+                    }
+                }));
+            const update = await (0, $813ed27cf8814dcd$export$ee841d674ca80db0)(this.props.options.type, this.props.options.client);
+            const reorderWasSuccessful = update?.results?.length;
+            this.setState(()=>({
+                    resetOrderTransaction: {
+                        status: reorderWasSuccessful ? `success` : `info`,
+                        title: reorderWasSuccessful ? `Reordered ${update.results.length === 1 ? `Document` : `Documents`}` : `Reordering failed`,
+                        closable: true
+                    }
+                }));
+        }
+    };
+    render() {
+        const type = this?.props?.options?.type;
+        if (!type) return null;
+        return /*#__PURE__*/ (0, $jPEKE$jsx)((0, $c3ce662734af156c$export$2e2bcd8739ae039), {
+            filter: this?.props?.options?.filter,
+            params: this?.props?.options?.params,
+            type: type,
+            showIncrements: this.state.showIncrements,
+            resetOrderTransaction: this.state.resetOrderTransaction
+        });
+    }
+}
+
+
+function $24abac83e7f53d60$export$3b014deba4b8ca00(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: type , filter: filter , params: params , title: title , icon: icon , id: id , context: context , S: S  } = config;
+    const { schema: schema , getClient: getClient  } = context;
+    const client = getClient({
+        apiVersion: "2021-09-01"
+    });
+    const listTitle = title ?? `Orderable ${type}`;
+    const listId = id ?? `orderable-${type}`;
+    const listIcon = icon ?? (0, $jPEKE$SortIcon);
+    const typeTitle = schema.get(type)?.title ?? type;
+    return S.listItem().title(listTitle).id(listId).icon(listIcon).child(Object.assign(S.documentTypeList(type).serialize(), {
+        // Prevents the component from re-rendering when switching documents
+        __preserveInstance: true,
+        // Prevents the component from NOT re-rendering when switching listItems
+        key: listId,
+        type: "component",
+        component: (0, $c149fdd435bcc1b3$export$2e2bcd8739ae039),
+        options: {
+            type: type,
+            filter: filter,
+            params: params,
+            client: client
+        },
+        menuItems: [
+            S.menuItem().title(`Create new ${typeTitle}`).intent({
+                type: "create",
+                params: {
+                    type: type
+                }
+            }).serialize(),
+            S.menuItem().title(`Reset Order`).icon((0, $jPEKE$GenerateIcon)).action(`resetOrder`).serialize(),
+            S.menuItem().title(`Show Increments`).icon((0, $jPEKE$SortIcon)).action(`showIncrements`).serialize(), 
+        ]
+    })).serialize();
+}
+
+
+
+
+export {$0413292d5e32b5d9$export$64a609a9111ff100 as orderRankField, $e83e0ebbc2cf37df$export$db2ff2f898748a67 as orderRankOrdering, $24abac83e7f53d60$export$3b014deba4b8ca00 as orderableDocumentListDeskItem};
+//# sourceMappingURL=index.modern.js.map