@sanity/hierarchical-document-list 0.1.1 → 1.0.0

package/lib/utils/idUtils.js

@@ -1,8 +1,13 @@
-export function unprefixId(_id) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDraft = exports.unprefixId = void 0;
+function unprefixId(_id) {
     if (_id === void 0) { _id = ''; }
     return _id.replace('drafts.', '');
 }
-export function isDraft(_id) {
+exports.unprefixId = unprefixId;
+function isDraft(_id) {
     if (_id === void 0) { _id = ''; }
     return _id.startsWith('drafts.');
 }
+exports.isDraft = isDraft;

package/lib/utils/injectNodeTypeInPatches.d.ts

@@ -0,0 +1,12 @@
+export declare function getSchemaTypeName(documentType: string, type: 'document' | 'node' | 'nodeValue' | 'array'): string;
+/**
+ * Temporary value of nodes' `_type` before they are normalized and persisted as the user-defined choice.
+ */
+export declare const DEFAULT_DOC_TYPE = "hierarchy.tree";
+export declare const INTERNAL_NODE_TYPE: string;
+export declare const INTERNAL_NODE_VALUE_TYPE: string;
+export declare const INTERNAL_NODE_ARRAY_TYPE: string;
+/**
+ * Barebones recursive utility to inject the desired nodeObjectType in patches generated in deeply nested components and utilities.
+ */
+export default function injectNodeTypeInPatches(patchData: any, documentType: string): any;

package/lib/utils/injectNodeTypeInPatches.js

@@ -0,0 +1,58 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERNAL_NODE_ARRAY_TYPE = exports.INTERNAL_NODE_VALUE_TYPE = exports.INTERNAL_NODE_TYPE = exports.DEFAULT_DOC_TYPE = exports.getSchemaTypeName = void 0;
+function getSchemaTypeName(documentType, type) {
+    switch (type) {
+        case 'document':
+            return documentType;
+        case 'array':
+            return "".concat(documentType, ".array");
+        case 'node':
+            return "".concat(documentType, ".node");
+        case 'nodeValue':
+            return "".concat(documentType, ".nodeValue");
+        default:
+            return documentType;
+    }
+}
+exports.getSchemaTypeName = getSchemaTypeName;
+/**
+ * Temporary value of nodes' `_type` before they are normalized and persisted as the user-defined choice.
+ */
+exports.DEFAULT_DOC_TYPE = 'hierarchy.tree';
+exports.INTERNAL_NODE_TYPE = getSchemaTypeName(exports.DEFAULT_DOC_TYPE, 'node');
+exports.INTERNAL_NODE_VALUE_TYPE = getSchemaTypeName(exports.DEFAULT_DOC_TYPE, 'nodeValue');
+exports.INTERNAL_NODE_ARRAY_TYPE = getSchemaTypeName(exports.DEFAULT_DOC_TYPE, 'array');
+/**
+ * Barebones recursive utility to inject the desired nodeObjectType in patches generated in deeply nested components and utilities.
+ */
+function injectNodeTypeInPatches(patchData, documentType) {
+    if (Array.isArray(patchData)) {
+        return patchData.map(function (child) { return injectNodeTypeInPatches(child, documentType); });
+    }
+    if (typeof patchData === 'object' && patchData !== null) {
+        return Object.keys(patchData).reduce(function (newObject, key) {
+            var _a, _b;
+            var value = patchData[key];
+            if (key === '_type' &&
+                typeof value === 'string' &&
+                [exports.INTERNAL_NODE_TYPE, exports.INTERNAL_NODE_VALUE_TYPE].includes(value)) {
+                return __assign(__assign({}, newObject), (_a = {}, _a[key] = getSchemaTypeName(documentType, value === exports.INTERNAL_NODE_TYPE ? 'node' : 'nodeValue'), _a));
+            }
+            return __assign(__assign({}, newObject), (_b = {}, _b[key] = injectNodeTypeInPatches(value, documentType), _b));
+        }, {});
+    }
+    return patchData;
+}
+exports.default = injectNodeTypeInPatches;

package/lib/utils/moveItemInArray.js

@@ -1,3 +1,4 @@
+"use strict";
 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)) {
@@ -7,7 +8,8 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-export default function moveItemInArray(_a) {
+Object.defineProperty(exports, "__esModule", { value: true });
+function moveItemInArray(_a) {
     var array = _a.array, fromIndex = _a.fromIndex, toIndex = _a.toIndex;
     if (fromIndex === toIndex) {
         return array;
@@ -21,3 +23,4 @@ export default function moveItemInArray(_a) {
     newArray[toIndex] = target;
     return newArray;
 }
+exports.default = moveItemInArray;

package/lib/utils/throwError.d.ts

@@ -0,0 +1,7 @@
+declare const ERROR_MESSAGES: {
+    invalidDocumentId: string;
+    invalidDocumentType: string;
+    invalidReferenceTo: string;
+};
+export default function throwError(message: keyof typeof ERROR_MESSAGES, extraContext?: string): void;
+export {};

package/lib/utils/throwError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ERROR_MESSAGES = {
+    invalidDocumentId: 'Please add a documentId to your tree',
+    invalidDocumentType: 'Please add a valid documentType to createHierarchicalSchemas',
+    invalidReferenceTo: "Missing valid 'referenceTo' value"
+};
+function throwError(message, extraContext) {
+    if (extraContext === void 0) { extraContext = ''; }
+    throw new Error("[hierarchical input] ".concat(ERROR_MESSAGES[message], " ").concat(extraContext));
+}
+exports.default = throwError;

package/lib/utils/treeData.js

@@ -1,3 +1,4 @@
+"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -29,12 +30,18 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     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 var dataToEditorTree = function (_a) {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeNodeForStorage = exports.getUnaddedItems = exports.flatTree = exports.dataToEditorTree = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var content_1 = require("@sanity/util/content");
+var DocumentInNode_1 = __importDefault(require("../components/DocumentInNode"));
+var NodeActions_1 = __importDefault(require("../components/NodeActions"));
+var flatDataToTree_1 = __importDefault(require("./flatDataToTree"));
+var injectNodeTypeInPatches_1 = require("./injectNodeTypeInPatches");
+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; })
@@ -45,23 +52,25 @@ export var dataToEditorTree = function (_a) {
         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 __assign(__assign({}, enhancedItem), { title: function (nodeProps) { return ((0, jsx_runtime_1.jsx)(DocumentInNode_1.default, { item: enhancedItem, action: (0, jsx_runtime_1.jsx)(NodeActions_1.default, { nodeProps: nodeProps }, void 0) }, void 0)); }, children: [] });
     });
-    return flatDataToTree(itemsWithTitle);
+    return (0, flatDataToTree_1.default)(itemsWithTitle);
 };
+exports.dataToEditorTree = dataToEditorTree;
 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',
+        _key: (0, content_1.randomKey)(12),
+        _type: injectNodeTypeInPatches_1.INTERNAL_NODE_TYPE,
         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: (_d = doc.published) === null || _d === void 0 ? void 0 : _d._updatedAt,
         value: {
+            _type: injectNodeTypeInPatches_1.INTERNAL_NODE_VALUE_TYPE,
             reference: {
                 _ref: doc.published._id,
                 _type: 'reference',
@@ -71,13 +80,14 @@ var documentPairToNode = function (doc) {
         }
     };
 };
-export var flatTree = function (tree) {
+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);
+        return __spreadArray(__spreadArray(__spreadArray([], flattened, true), [node], false), (Array.isArray(children) ? (0, exports.flatTree)(children) : []), true);
     }, []);
 };
-export var getUnaddedItems = function (data) {
+exports.flatTree = flatTree;
+var getUnaddedItems = function (data) {
     if (!data.tree) {
         return Object.entries(data.allItems)
             .map(function (value) { return documentPairToNode(value[1]); })
@@ -96,11 +106,13 @@ export var getUnaddedItems = function (data) {
     })
         .filter(Boolean);
 };
-export function normalizeNodeForStorage(item) {
+exports.getUnaddedItems = getUnaddedItems;
+function normalizeNodeForStorage(item) {
     return {
         _key: item._key,
-        _type: item._type || 'hierarchy.node',
+        _type: item._type || injectNodeTypeInPatches_1.INTERNAL_NODE_TYPE,
         value: item.value,
         parent: item.parent
     };
 }
+exports.normalizeNodeForStorage = normalizeNodeForStorage;

package/lib/utils/treePatches.js

@@ -1,3 +1,4 @@
+"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -9,6 +10,25 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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)) {
@@ -18,28 +38,35 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import * as Patch from '@sanity/form-builder/lib/patch/patches';
-import { randomKey } from '@sanity/util/content';
-import { getFlatDataFromTree } from 'react-sortable-tree';
-import getAdjescentNodes from './getAdjescentNodes';
-import moveItemInArray from './moveItemInArray';
-import { normalizeNodeForStorage } from './treeData';
-export function getAddItemPatch(item) {
-    var normalizedNode = normalizeNodeForStorage(item);
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMoveItemPatch = exports.getMovedNodePatch = exports.getRemoveItemPatch = exports.getDuplicateItemPatch = exports.getAddItemPatch = void 0;
+var Patch = __importStar(require("@sanity/form-builder/lib/patch/patches"));
+var content_1 = require("@sanity/util/content");
+var react_sortable_tree_1 = require("react-sortable-tree");
+var getAdjescentNodes_1 = __importDefault(require("./getAdjescentNodes"));
+var moveItemInArray_1 = __importDefault(require("./moveItemInArray"));
+var treeData_1 = require("./treeData");
+function getAddItemPatch(item) {
+    var normalizedNode = (0, treeData_1.normalizeNodeForStorage)(item);
     return [
         // Add the node to the end of the tree
         Patch.insert([normalizedNode], 'after', [-1])
     ];
 }
-export function getDuplicateItemPatch(nodeProps) {
-    var newItem = __assign(__assign({}, nodeProps.node), { _key: randomKey(12) });
-    var normalizedNode = normalizeNodeForStorage(newItem);
+exports.getAddItemPatch = getAddItemPatch;
+function getDuplicateItemPatch(nodeProps) {
+    var newItem = __assign(__assign({}, nodeProps.node), { _key: (0, content_1.randomKey)(12) });
+    var normalizedNode = (0, treeData_1.normalizeNodeForStorage)(newItem);
     return [
         // Add duplicated node before the existing one
         Patch.insert([normalizedNode], 'before', [{ _key: nodeProps.node._key }])
     ];
 }
-export function getRemoveItemPatch(_a) {
+exports.getDuplicateItemPatch = getDuplicateItemPatch;
+function getRemoveItemPatch(_a) {
     var node = _a.node;
     var keyPath = { _key: node._key };
     var children = getChildrenPaths(node);
@@ -48,7 +75,8 @@ export function getRemoveItemPatch(_a) {
         Patch.unset([keyPath])
     ], children.map(function (path) { return Patch.unset([{ _key: path }]); }), true);
 }
-export function getMovedNodePatch(data) {
+exports.getRemoveItemPatch = getRemoveItemPatch;
+function getMovedNodePatch(data) {
     var _a, _b;
     var nextParentNode = data.nextParentNode;
     var keyPath = { _key: data.node._key };
@@ -57,12 +85,12 @@ export function getMovedNodePatch(data) {
     if (!Array.isArray(data.nextPath)) {
         return getRemoveItemPatch({ node: data.node });
     }
-    var nextFlatTree = getFlatDataFromTree({
+    var nextFlatTree = (0, react_sortable_tree_1.getFlatDataFromTree)({
         treeData: data.treeData,
         getNodeKey: function (t) { return t.node._key; }
     });
-    var normalizedNode = normalizeNodeForStorage(data.node);
-    var _c = getAdjescentNodes({
+    var normalizedNode = (0, treeData_1.normalizeNodeForStorage)(data.node);
+    var _c = (0, getAdjescentNodes_1.default)({
         flatTree: nextFlatTree,
         node: data.node,
         treeIndex: data.nextTreeIndex
@@ -88,6 +116,7 @@ export function getMovedNodePatch(data) {
                 Patch.unset([keyPath, 'parent'])
     ];
 }
+exports.getMovedNodePatch = getMovedNodePatch;
 function getChildrenPaths(node) {
     if (!Array.isArray(node.children)) {
         return [];
@@ -96,26 +125,26 @@ function getChildrenPaths(node) {
         .reduce(function (keyPaths, child) { return __spreadArray(__spreadArray(__spreadArray([], keyPaths, true), [child._key], false), getChildrenPaths(child), true); }, [])
         .filter(Boolean);
 }
-export function getMoveItemPatch(_a) {
+function getMoveItemPatch(_a) {
     var _b, _c;
     var _d = _a.nodeProps, node = _d.node, treeIndex = _d.treeIndex, localTree = _a.localTree, _e = _a.direction, direction = _e === void 0 ? 'up' : _e;
     var keyPath = { _key: node._key };
     var nextTreeIndex = treeIndex + (direction === 'up' ? -1 : 1);
-    var flatTree = getFlatDataFromTree({
+    var flatTree = (0, react_sortable_tree_1.getFlatDataFromTree)({
         treeData: localTree,
         getNodeKey: function (t) { return t.node._key; }
     });
-    var nextFlatTree = moveItemInArray({
+    var nextFlatTree = (0, moveItemInArray_1.default)({
         array: flatTree,
         fromIndex: treeIndex,
         toIndex: nextTreeIndex
     });
-    var _f = getAdjescentNodes({
+    var _f = (0, getAdjescentNodes_1.default)({
         flatTree: nextFlatTree,
         node: node,
         treeIndex: nextTreeIndex
     }), leadingNode = _f.leadingNode, followingNode = _f.followingNode;
-    var normalizedNode = normalizeNodeForStorage(node);
+    var normalizedNode = (0, treeData_1.normalizeNodeForStorage)(node);
     // When moving up, look at following node to figure out what is the next parent.
     var nodeToInheritParent = direction === 'up' ? followingNode : leadingNode;
     var nextParentNode = nodeToInheritParent === null || nodeToInheritParent === void 0 ? void 0 : nodeToInheritParent.parentNode;
@@ -139,3 +168,4 @@ export function getMoveItemPatch(_a) {
                 Patch.unset([keyPath, 'parent'])
     ];
 }
+exports.getMoveItemPatch = getMoveItemPatch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/hierarchical-document-list",
-  "version": "0.1.1",
+  "version": "1.0.0",
   "author": "Sanity <hello@sanity.io>",
   "license": "MIT",
   "main": "lib/index.js",
@@ -41,7 +41,6 @@
     "styled-components": "^5.3.3",
     "typescript": "^4.5.5"
   },
-  "type": "module",
   "dependencies": {
     "assert": "^2.0.0",
     "react-sortable-tree": "^2.8.0"

package/tsconfig.json

@@ -5,11 +5,11 @@
     "lib": ["DOM", "DOM.Iterable", "ESNext"],
     "allowJs": false,
     "skipLibCheck": true,
-    "esModuleInterop": false,
-    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": false,
     "strict": true,
     "forceConsistentCasingInFileNames": true,
-    "module": "ESNext",
+    "module": "CommonJS",
     "moduleResolution": "Node",
     "resolveJsonModule": true,
     "isolatedModules": true,

package/lib/createHierarchicalField.d.ts

@@ -1,8 +0,0 @@
-import { ArraySchemaType } from '@sanity/types';
-import React from 'react';
-import { TreeFieldSchema } from './types';
-export default function createHierarchicalField({ name, title, options, ...rest }: TreeFieldSchema): Omit<ArraySchemaType, 'type' | 'jsonType' | 'of'> & {
-    type: string;
-    inputComponent: React.FC<any>;
-    of: any[];
-};

package/lib/createHierarchicalField.js

@@ -1,51 +0,0 @@
-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(_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 __assign(__assign({}, rest), { options: options, name: name, title: title, type: 'array', of: [
-            {
-                type: 'object',
-                fields: [
-                    { name: 'parent', type: 'string' },
-                    {
-                        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 });
-}

package/lib/utils/useTreeOperations.js

@@ -1,16 +0,0 @@
-import React from 'react';
-function placeholder() {
-    // no-op
-}
-export var TreeOperationsContext = React.createContext({
-    addItem: placeholder,
-    duplicateItem: placeholder,
-    removeItem: placeholder,
-    handleMovedNode: placeholder,
-    moveItemDown: placeholder,
-    moveItemUp: placeholder,
-    allItemsStatus: 'loading'
-});
-export default function useTreeOperations() {
-    return React.useContext(TreeOperationsContext);
-}

package/lib/utils/useTreeOperationsProvider.js

@@ -1,60 +0,0 @@
-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 * as Patch from '@sanity/form-builder/lib/patch/patches';
-import PatchEvent from '@sanity/form-builder/PatchEvent';
-import { getAddItemPatch, getDuplicateItemPatch, getMovedNodePatch, getMoveItemPatch, getRemoveItemPatch } from './treePatches';
-export default function useTreeOperationsProvider(props) {
-    var localTree = props.localTree;
-    function runPatches(patches) {
-        var finalPatches = __spreadArray([
-            // Ensure tree array exists before any operation
-            Patch.setIfMissing([])
-        ], (patches || []), true);
-        var patchEvent = PatchEvent.from(finalPatches);
-        if (props.patchPrefix) {
-            patchEvent = PatchEvent.from(finalPatches.map(function (patch) { return Patch.prefixPath(patch, props.patchPrefix); }));
-        }
-        props.onChange(patchEvent);
-    }
-    function handleMovedNode(data) {
-        runPatches(getMovedNodePatch(data));
-    }
-    function addItem(item) {
-        runPatches(getAddItemPatch(item));
-    }
-    function duplicateItem(nodeProps) {
-        runPatches(getDuplicateItemPatch(nodeProps));
-    }
-    function removeItem(nodeProps) {
-        runPatches(getRemoveItemPatch(nodeProps));
-    }
-    function moveItemUp(nodeProps) {
-        runPatches(getMoveItemPatch({
-            nodeProps: nodeProps,
-            localTree: localTree,
-            direction: 'up'
-        }));
-    }
-    function moveItemDown(nodeProps) {
-        runPatches(getMoveItemPatch({
-            nodeProps: nodeProps,
-            localTree: localTree,
-            direction: 'down'
-        }));
-    }
-    return {
-        handleMovedNode: handleMovedNode,
-        addItem: addItem,
-        removeItem: removeItem,
-        moveItemUp: moveItemUp,
-        moveItemDown: moveItemDown,
-        duplicateItem: duplicateItem
-    };
-}