@sanity/hierarchical-document-list 0.1.0-next.1 → 0.1.1

package/lib/createDeskHierarchy.js

@@ -1,32 +1,45 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 import { jsx as _jsx } from "react/jsx-runtime";
 import S from '@sanity/desk-tool/structure-builder';
 import { AddIcon } from '@sanity/icons';
 import TreeDeskStructure from './TreeDeskStructure';
-const deskTreeValidator = (props) => {
-    const { documentId, referenceTo } = props;
+var deskTreeValidator = function (props) {
+    var documentId = props.documentId, referenceTo = props.referenceTo;
     if (typeof documentId !== 'string' && !documentId) {
         throw new Error('[hierarchical input] Please add a documentId to your tree');
     }
     if (!Array.isArray(referenceTo)) {
-        throw new Error(`[hierarchical input] Missing valid 'referenceTo' in createDeskHierarchy (documentId "${documentId}")`);
+        throw new Error("[hierarchical input] Missing valid 'referenceTo' in createDeskHierarchy (documentId \"".concat(documentId, "\")"));
     }
-    return (deskProps) => _jsx(TreeDeskStructure, { ...deskProps, options: props }, void 0);
+    return function (deskProps) { return _jsx(TreeDeskStructure, __assign({}, deskProps, { options: props }), void 0); };
 };
 export default function createDeskHierarchy(props) {
-    const { documentId, referenceTo, referenceOptions } = props;
-    let mainList = (referenceTo?.length === 1
+    var documentId = props.documentId, referenceTo = props.referenceTo, referenceOptions = props.referenceOptions;
+    var mainList = ((referenceTo === null || referenceTo === void 0 ? void 0 : referenceTo.length) === 1
         ? S.documentTypeList(referenceTo[0]).schemaType(referenceTo[0])
-        : S.documentList())
+        : S.documentList().filter('_type in $types').params({ types: referenceTo }))
         .id(documentId)
-        .menuItems((referenceTo || []).map((schemaType) => S.menuItem()
-        .intent({
-        type: 'create',
-        params: { type: schemaType, template: schemaType }
-    })
-        // @TODO: get the title for each schema type
-        .title(schemaType)
-        .icon(AddIcon)))
-        .canHandleIntent((intent, context) => {
+        .menuItems((referenceTo || []).map(function (schemaType) {
+        return S.menuItem()
+            .intent({
+            type: 'create',
+            params: { type: schemaType, template: schemaType }
+        })
+            // @TODO: get the title for each schema type
+            .title(schemaType)
+            .icon(AddIcon);
+    }))
+        .canHandleIntent(function (intent, context) {
         if (intent === 'edit' && context.id === props.documentId) {
             return true;
         }
@@ -35,18 +48,20 @@ export default function createDeskHierarchy(props) {
         }
         return false;
     });
-    if (referenceOptions?.filter) {
+    if (referenceOptions === null || referenceOptions === void 0 ? void 0 : referenceOptions.filter) {
         mainList = mainList.filter(referenceOptions.filter);
     }
-    if (referenceOptions?.filterParams) {
+    if (referenceOptions === null || referenceOptions === void 0 ? void 0 : referenceOptions.filterParams) {
         mainList = mainList.params(referenceOptions.filterParams);
     }
     return S.listItem()
         .id(documentId)
         .title(props.title || documentId)
+        .icon(props.icon)
         .child(Object.assign(mainList.serialize(), {
         type: 'component',
         component: deskTreeValidator(props),
-        options: props
+        options: props,
+        __preserveInstance: true
     }, props.title ? { title: props.title } : {}));
 }

package/lib/createHierarchicalField.js

@@ -1,30 +1,51 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 import TreeInputComponent from './TreeInputComponent';
-export default function createHierarchicalField({ name, title, options, ...rest }) {
-    if (!Array.isArray(options?.referenceTo)) {
-        throw new Error(`[hierarchical input] Missing valid options.referenceTo in createHierarchicalField (field of name "${name}")`);
+export default function createHierarchicalField(_a) {
+    var name = _a.name, title = _a.title, options = _a.options, rest = __rest(_a, ["name", "title", "options"]);
+    if (!Array.isArray(options === null || options === void 0 ? void 0 : options.referenceTo)) {
+        throw new Error("[hierarchical input] Missing valid options.referenceTo in createHierarchicalField (field of name \"".concat(name, "\")"));
     }
-    return {
-        ...rest,
-        options,
-        name,
-        title,
-        type: 'array',
-        of: [
+    return __assign(__assign({}, rest), { options: options, name: name, title: title, type: 'array', of: [
             {
                 type: 'object',
                 fields: [
                     { name: 'parent', type: 'string' },
-                    { name: 'nodeDocType', type: 'string' },
                     {
-                        name: 'node',
-                        type: 'reference',
-                        weak: true,
-                        to: options.referenceTo.map((type) => ({ type })),
-                        options: options.referenceOptions
+                        name: 'value',
+                        type: 'object',
+                        fields: [
+                            { name: 'docType', type: 'string' },
+                            {
+                                name: 'reference',
+                                type: 'reference',
+                                weak: true,
+                                to: options.referenceTo.map(function (type) { return ({ type: type }); }),
+                                options: options.referenceOptions
+                            }
+                        ]
                     }
                 ]
             }
-        ],
-        inputComponent: TreeInputComponent
-    };
+        ], inputComponent: TreeInputComponent });
 }

package/lib/schemas/hierarchy.tree.js

@@ -0,0 +1,31 @@
+import createHierarchicalField from '../createHierarchicalField';
+export default {
+    name: 'hierarchy.tree',
+    title: 'Hierarchical tree',
+    type: 'document',
+    // The plugin needs to define a `schemaType` with liveEdit enabled so that
+    // `useDocumentOperation` in TreeDeskStructure.tsx doesn't create drafts at every patch.
+    liveEdit: true,
+    fields: [
+        createHierarchicalField({
+            name: 'tree',
+            title: 'Tree',
+            options: {
+                referenceTo: ['image']
+            }
+        })
+    ],
+    preview: {
+        select: {
+            id: '_id',
+            tree: 'tree'
+        },
+        prepare: function (_a) {
+            var id = _a.id, tree = _a.tree;
+            return {
+                title: "Hierarchical documents (ID: ".concat(id, ")"),
+                subtitle: "".concat((tree === null || tree === void 0 ? void 0 : tree.length) || 0, " document(s) in its list.")
+            };
+        }
+    }
+};

package/lib/utils/flatDataToTree.d.ts

@@ -1,6 +1,6 @@
-import { SanityTreeItem } from '../types';
-interface TreeItemWithChildren extends SanityTreeItem {
+import { StoredTreeItem } from '../types';
+interface TreeItemWithChildren extends StoredTreeItem {
     children?: TreeItemWithChildren[];
 }
-export default function flatDataToTree(data: SanityTreeItem[]): TreeItemWithChildren[];
+export default function flatDataToTree(data: StoredTreeItem[]): TreeItemWithChildren[];
 export {};

package/lib/utils/flatDataToTree.js

@@ -1,13 +1,22 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 import { getTreeFromFlatData } from 'react-sortable-tree';
 export default function flatDataToTree(data) {
     return getTreeFromFlatData({
-        flatData: data.map((item) => ({
-            ...item,
+        flatData: data.map(function (item) { return (__assign(__assign({}, item), { 
             // if parent: undefined, the tree won't be constructed
-            parent: item.parent || null
-        })),
-        getKey: (item) => item._key,
-        getParentKey: (item) => item.parent,
+            parent: item.parent || null })); }),
+        getKey: function (item) { return item._key; },
+        getParentKey: function (item) { return item.parent; },
         // without rootKey, the tree won't be constructed
         rootKey: null
     });

package/lib/utils/getAdjescentNodes.js

@@ -1,15 +1,16 @@
 /**
  * Gets adjescent non-children nodes of a given treeIndex.
  */
-export default function getAdjescentNodes({ flatTree, node, treeIndex }) {
-    const leadingNode = flatTree
+export default function getAdjescentNodes(_a) {
+    var flatTree = _a.flatTree, node = _a.node, treeIndex = _a.treeIndex;
+    var leadingNode = flatTree
         .slice(0, treeIndex)
         .reverse()
         // Disregard children nodes - these include the current node's key in their `path` array
-        .find((item) => !item.path.includes(node._key));
-    const followingNode = flatTree.slice(treeIndex + 1).find((item) => !item.path.includes(node._key));
+        .find(function (item) { return !item.path.includes(node._key); });
+    var followingNode = flatTree.slice(treeIndex + 1).find(function (item) { return !item.path.includes(node._key); });
     return {
-        leadingNode,
-        followingNode
+        leadingNode: leadingNode,
+        followingNode: followingNode
     };
 }

package/lib/utils/getCommonTreeProps.js

@@ -1,13 +1,25 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 import { jsx as _jsx } from "react/jsx-runtime";
 import NodeContentRenderer from '../components/NodeContentRenderer';
 import PlaceholderDropzone from '../components/PlaceholderDropzone';
 import TreeNodeRenderer from '../components/TreeNodeRenderer';
 import { ROW_HEIGHT } from './getTreeHeight';
-export default function getCommonTreeProps({ placeholder }) {
+export default function getCommonTreeProps(_a) {
+    var placeholder = _a.placeholder;
     return {
         theme: {
             nodeContentRenderer: NodeContentRenderer,
-            placeholderRenderer: (props) => _jsx(PlaceholderDropzone, { ...placeholder, ...props }, void 0),
+            placeholderRenderer: function (props) { return _jsx(PlaceholderDropzone, __assign({}, placeholder, props), void 0); },
             treeNodeRenderer: TreeNodeRenderer,
             rowHeight: ROW_HEIGHT
         }

package/lib/utils/getTreeHeight.js

@@ -1,7 +1,7 @@
 import { getVisibleNodeCount } from 'react-sortable-tree';
-export const ROW_HEIGHT = 51;
+export var ROW_HEIGHT = 51;
 export default function getTreeHeight(treeData) {
-    const visibleNodeCount = getVisibleNodeCount({ treeData });
+    var visibleNodeCount = getVisibleNodeCount({ treeData: treeData });
     // prettier-ignore
-    return `${50 + (ROW_HEIGHT * visibleNodeCount)}px`;
+    return "".concat(50 + (ROW_HEIGHT * visibleNodeCount), "px");
 }

package/lib/utils/gradientPatchAdapter.js

@@ -5,14 +5,15 @@ export function toGradient(patches) {
     return patches.map(toGradientPatch);
 }
 function toGradientPatch(patch) {
-    const matchPath = arrayToJSONMatchPath(patch.path || []);
+    var _a, _b, _c, _d;
+    var matchPath = arrayToJSONMatchPath(patch.path || []);
     if (patch.type === 'insert') {
-        const { position, items } = patch;
+        var position = patch.position, items = patch.items;
         return {
-            insert: {
-                [position]: matchPath,
-                items: items
-            }
+            insert: (_a = {},
+                _a[position] = matchPath,
+                _a.items = items,
+                _a)
         };
     }
     if (patch.type === 'unset') {
@@ -20,15 +21,15 @@ function toGradientPatch(patch) {
             unset: [matchPath]
         };
     }
-    assert(patch.type, `Missing patch type in patch ${JSON.stringify(patch)}`);
+    assert(patch.type, "Missing patch type in patch ".concat(JSON.stringify(patch)));
     if (matchPath) {
-        return {
-            [patch.type]: {
-                [matchPath]: patch.value
-            }
-        };
+        return _b = {},
+            _b[patch.type] = (_c = {},
+                _c[matchPath] = patch.value,
+                _c),
+            _b;
     }
-    return {
-        [patch.type]: patch.value
-    };
+    return _d = {},
+        _d[patch.type] = patch.value,
+        _d;
 }

package/lib/utils/idUtils.js

@@ -1,6 +1,8 @@
-export function unprefixId(_id = '') {
+export function unprefixId(_id) {
+    if (_id === void 0) { _id = ''; }
     return _id.replace('drafts.', '');
 }
-export function isDraft(_id = '') {
+export function isDraft(_id) {
+    if (_id === void 0) { _id = ''; }
     return _id.startsWith('drafts.');
 }

package/lib/utils/moveItemInArray.js

@@ -1,11 +1,21 @@
-export default function moveItemInArray({ array, fromIndex, toIndex }) {
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+export default function moveItemInArray(_a) {
+    var array = _a.array, fromIndex = _a.fromIndex, toIndex = _a.toIndex;
     if (fromIndex === toIndex) {
         return array;
     }
-    const newArray = [...array];
-    const target = newArray[fromIndex];
-    const inc = toIndex < fromIndex ? -1 : 1;
-    for (let i = fromIndex; i !== toIndex; i += inc) {
+    var newArray = __spreadArray([], array, true);
+    var target = newArray[fromIndex];
+    var inc = toIndex < fromIndex ? -1 : 1;
+    for (var i = fromIndex; i !== toIndex; i += inc) {
         newArray[i] = newArray[i + inc];
     }
     newArray[toIndex] = target;

package/lib/utils/treeData.d.ts

@@ -1,18 +1,18 @@
 import { SanityDocument } from '@sanity/client';
 import { TreeItem } from 'react-sortable-tree';
-import { AllItems, SanityTreeItem, VisibilityMap } from '../types';
+import { AllItems, EnhancedTreeItem, LocalTreeItem, StoredTreeItem, VisibilityMap } from '../types';
 export declare const dataToEditorTree: ({ tree, allItems, visibilityMap }: {
-    tree: SanityTreeItem[];
+    tree: StoredTreeItem[];
     allItems: AllItems;
     visibilityMap: VisibilityMap;
-}) => TreeItem[];
+}) => LocalTreeItem[];
 export declare const flatTree: (tree: TreeItem[]) => TreeItem[];
 export interface FetchData {
-    mainTree?: SanityTreeItem[];
+    mainTree?: LocalTreeItem[];
     allItems?: SanityDocument[];
 }
 export declare const getUnaddedItems: (data: {
     allItems: AllItems;
-    tree: SanityTreeItem[];
-}) => SanityTreeItem[];
-export declare function normalizeNodeForStorage(item: TreeItem): SanityTreeItem;
+    tree: StoredTreeItem[];
+}) => EnhancedTreeItem[];
+export declare function normalizeNodeForStorage(item: LocalTreeItem): StoredTreeItem;

package/lib/utils/treeData.js

@@ -1,43 +1,66 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { jsx as _jsx } from "react/jsx-runtime";
 import { randomKey } from '@sanity/util/content';
 import DocumentInNode from '../components/DocumentInNode';
 import NodeActions from '../components/NodeActions';
 import flatDataToTree from './flatDataToTree';
-export const dataToEditorTree = ({ tree, allItems, visibilityMap }) => {
-    const itemsWithTitle = tree
-        .filter((item) => item?.value?.reference?._ref)
-        .map((item) => {
-        const refId = item.value?.reference?._ref;
-        const docPair = refId ? allItems[refId] : undefined;
-        const draftDoc = docPair?.draft;
-        const publishedDoc = docPair?.published;
-        const enhancedItem = {
-            ...item,
-            expanded: visibilityMap[item._key] !== false,
-            draftId: draftDoc?._id,
-            publishedId: publishedDoc?._id,
-            draftUpdatedAt: draftDoc?._updatedAt,
-            publishedUpdatedAt: publishedDoc?._updatedAt
-        };
-        return {
-            ...enhancedItem,
-            title: (nodeProps) => (_jsx(DocumentInNode, { item: enhancedItem, action: _jsx(NodeActions, { nodeProps: nodeProps }, void 0) }, void 0)),
-            children: []
-        };
+export var dataToEditorTree = function (_a) {
+    var tree = _a.tree, allItems = _a.allItems, visibilityMap = _a.visibilityMap;
+    var itemsWithTitle = tree
+        .filter(function (item) { var _a, _b; return (_b = (_a = item === null || item === void 0 ? void 0 : item.value) === null || _a === void 0 ? void 0 : _a.reference) === null || _b === void 0 ? void 0 : _b._ref; })
+        .map(function (item) {
+        var _a, _b;
+        var refId = (_b = (_a = item.value) === null || _a === void 0 ? void 0 : _a.reference) === null || _b === void 0 ? void 0 : _b._ref;
+        var docPair = refId ? allItems[refId] : undefined;
+        var draftDoc = docPair === null || docPair === void 0 ? void 0 : docPair.draft;
+        var publishedDoc = docPair === null || docPair === void 0 ? void 0 : docPair.published;
+        var enhancedItem = __assign(__assign({}, item), { expanded: visibilityMap[item._key] !== false, draftId: draftDoc === null || draftDoc === void 0 ? void 0 : draftDoc._id, publishedId: publishedDoc === null || publishedDoc === void 0 ? void 0 : publishedDoc._id, draftUpdatedAt: draftDoc === null || draftDoc === void 0 ? void 0 : draftDoc._updatedAt, publishedUpdatedAt: publishedDoc === null || publishedDoc === void 0 ? void 0 : publishedDoc._updatedAt });
+        return __assign(__assign({}, enhancedItem), { title: function (nodeProps) { return (_jsx(DocumentInNode, { item: enhancedItem, action: _jsx(NodeActions, { nodeProps: nodeProps }, void 0) }, void 0)); }, children: [] });
     });
     return flatDataToTree(itemsWithTitle);
 };
-const documentPairToNode = (doc) => {
-    if (!doc?.published?._id) {
+var documentPairToNode = function (doc) {
+    var _a, _b, _c, _d;
+    if (!((_a = doc === null || doc === void 0 ? void 0 : doc.published) === null || _a === void 0 ? void 0 : _a._id)) {
         return undefined;
     }
     return {
         _key: randomKey(12),
         _type: 'hierarchy.node',
-        draftId: doc.draft?._id,
-        draftUpdatedAt: doc.draft?._updatedAt,
+        draftId: (_b = doc.draft) === null || _b === void 0 ? void 0 : _b._id,
+        draftUpdatedAt: (_c = doc.draft) === null || _c === void 0 ? void 0 : _c._updatedAt,
         publishedId: doc.published._id,
-        publishedUpdatedAt: doc.published?._updatedAt,
+        publishedUpdatedAt: (_d = doc.published) === null || _d === void 0 ? void 0 : _d._updatedAt,
         value: {
             reference: {
                 _ref: doc.published._id,
@@ -48,23 +71,29 @@ const documentPairToNode = (doc) => {
         }
     };
 };
-export const flatTree = (tree) => {
-    return tree.reduce((flattened, item) => {
-        const { children, ...node } = item;
-        return [...flattened, node, ...(Array.isArray(children) ? flatTree(children) : [])];
+export var flatTree = function (tree) {
+    return tree.reduce(function (flattened, item) {
+        var children = item.children, node = __rest(item, ["children"]);
+        return __spreadArray(__spreadArray(__spreadArray([], flattened, true), [node], false), (Array.isArray(children) ? flatTree(children) : []), true);
     }, []);
 };
-export const getUnaddedItems = (data) => {
+export var getUnaddedItems = function (data) {
     if (!data.tree) {
         return Object.entries(data.allItems)
-            .map((value) => documentPairToNode(value[1]))
+            .map(function (value) { return documentPairToNode(value[1]); })
             .filter(Boolean);
     }
     return Object.entries(data.allItems)
-        .filter(([publishedId]) => publishedId &&
-        // unadded items shouldn't be in the tree
-        !data.tree.some((treeItem) => treeItem?.value?.reference?._ref === publishedId))
-        .map(([_publishedId, documentPair]) => documentPairToNode(documentPair))
+        .filter(function (_a) {
+        var publishedId = _a[0];
+        return publishedId &&
+            // unadded items shouldn't be in the tree
+            !data.tree.some(function (treeItem) { var _a, _b; return ((_b = (_a = treeItem === null || treeItem === void 0 ? void 0 : treeItem.value) === null || _a === void 0 ? void 0 : _a.reference) === null || _b === void 0 ? void 0 : _b._ref) === publishedId; });
+    })
+        .map(function (_a) {
+        var _publishedId = _a[0], documentPair = _a[1];
+        return documentPairToNode(documentPair);
+    })
         .filter(Boolean);
 };
 export function normalizeNodeForStorage(item) {

package/lib/utils/treePatches.d.ts

@@ -1,13 +1,15 @@
-import { FullTree, NodeData, NodeRendererProps, OnMovePreviousAndNextLocation, TreeItem } from 'react-sortable-tree';
-import { SanityTreeItem } from '../types';
-export declare type HandleMovedNodeData = Omit<NodeData & FullTree & OnMovePreviousAndNextLocation, 'prevPath' | 'prevTreeIndex' | 'path' | 'treeIndex'>;
+import { FullTree, NodeData, OnMovePreviousAndNextLocation, TreeItem } from 'react-sortable-tree';
+import { LocalTreeItem, NodeProps } from '../types';
+export declare type HandleMovedNodeData = Omit<NodeData & FullTree & OnMovePreviousAndNextLocation, 'prevPath' | 'prevTreeIndex' | 'path' | 'treeIndex' | 'node'> & {
+    node: LocalTreeItem;
+};
 export declare type HandleMovedNode = (moveData: HandleMovedNodeData) => void;
-export declare function getAddItemPatch(item: SanityTreeItem): unknown[];
-export declare function getDuplicateItemPatch(nodeProps: NodeRendererProps): unknown[];
-export declare function getRemoveItemPatch({ node }: Pick<NodeRendererProps, 'node'>): unknown[];
+export declare function getAddItemPatch(item: LocalTreeItem): unknown[];
+export declare function getDuplicateItemPatch(nodeProps: NodeProps): unknown[];
+export declare function getRemoveItemPatch({ node }: Pick<NodeProps, 'node'>): unknown[];
 export declare function getMovedNodePatch(data: HandleMovedNodeData): unknown[];
-export declare function getMoveItemPatch({ nodeProps: { node, treeIndex, parentNode }, localTree, direction }: {
-    nodeProps: NodeRendererProps;
+export declare function getMoveItemPatch({ nodeProps: { node, treeIndex }, localTree, direction }: {
+    nodeProps: NodeProps;
     localTree: TreeItem[];
     direction: 'up' | 'down';
 }): unknown[];