@sanity/hierarchical-document-list 0.1.1 → 1.0.0

package/lib/createHierarchicalSchemas.js

@@ -0,0 +1,138 @@
+"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);
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHierarchicalField = void 0;
+var TreeDeskStructure_1 = require("./TreeDeskStructure");
+var TreeInputComponent_1 = __importDefault(require("./TreeInputComponent"));
+var injectNodeTypeInPatches_1 = require("./utils/injectNodeTypeInPatches");
+var throwError_1 = __importDefault(require("./utils/throwError"));
+function createHierarchicalNodeValueType(_a) {
+    var referenceTo = _a.referenceTo, referenceOptions = _a.referenceOptions, documentType = _a.documentType;
+    return {
+        // when used inside the field, name & type are overwritten by createHierarchicalNodeType
+        name: documentType ? (0, injectNodeTypeInPatches_1.getSchemaTypeName)(documentType, 'nodeValue') : injectNodeTypeInPatches_1.INTERNAL_NODE_VALUE_TYPE,
+        type: 'object',
+        title: "Hierarchical node value (".concat(documentType, ")"),
+        fields: [
+            { name: 'docType', type: 'string' },
+            {
+                name: 'reference',
+                type: 'reference',
+                weak: true,
+                to: referenceTo.map(function (type) { return ({ type: type }); }),
+                options: referenceOptions
+            }
+        ]
+    };
+}
+function createHierarchicalNodeType(options) {
+    return {
+        // name & type are overwritten by createHierarchicalField
+        name: options.documentType
+            ? (0, injectNodeTypeInPatches_1.getSchemaTypeName)(options.documentType, 'node')
+            : injectNodeTypeInPatches_1.INTERNAL_NODE_TYPE,
+        title: "Hierarchical node (".concat(options.documentType, ")"),
+        type: 'object',
+        fields: [
+            { name: 'parent', type: 'string' },
+            options.documentType
+                ? { name: 'value', type: (0, injectNodeTypeInPatches_1.getSchemaTypeName)(options.documentType, 'nodeValue') }
+                : // If no documentType is defined, use an anonymized inline object to avoid
+                 __assign(__assign({}, createHierarchicalNodeValueType(options)), { name: 'value', type: 'object' })
+        ]
+    };
+}
+function createHierarchicalArrayType(options) {
+    return {
+        // name & type are overwritten by createHierarchicalField
+        name: options.documentType
+            ? (0, injectNodeTypeInPatches_1.getSchemaTypeName)(options.documentType, 'array')
+            : injectNodeTypeInPatches_1.INTERNAL_NODE_ARRAY_TYPE,
+        title: "Hierarchical array of nodes (".concat(options.documentType, ")"),
+        type: 'array',
+        of: [
+            options.documentType
+                ? { type: (0, injectNodeTypeInPatches_1.getSchemaTypeName)(options.documentType, 'node') }
+                : createHierarchicalNodeType(options)
+        ]
+    };
+}
+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)) {
+        (0, throwError_1.default)('invalidReferenceTo', "(field of name \"".concat(name, "\")"));
+    }
+    return __assign(__assign(__assign({}, rest), { name: name, title: title, inputComponent: TreeInputComponent_1.default, options: options }), (options.documentType
+        ? { type: (0, injectNodeTypeInPatches_1.getSchemaTypeName)(options.documentType, 'array') }
+        : __assign(__assign({}, createHierarchicalArrayType(options)), { name: name })));
+}
+exports.createHierarchicalField = createHierarchicalField;
+function createHierarchicalDocType(options) {
+    return {
+        name: options.documentType,
+        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: options.fieldKeyInDocument || TreeDeskStructure_1.DEFAULT_FIELD_KEY,
+                title: 'Hierarchical Tree',
+                options: options
+            })
+        ],
+        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.")
+                };
+            }
+        }
+    };
+}
+function createHierarchicalSchemas(options) {
+    if (!Array.isArray(options.referenceTo) || options.referenceTo.length <= 0) {
+        (0, throwError_1.default)('invalidReferenceTo');
+    }
+    if (!options.documentType) {
+        (0, throwError_1.default)('invalidDocumentType');
+    }
+    return [
+        createHierarchicalDocType(options),
+        createHierarchicalArrayType(options),
+        createHierarchicalNodeType(options),
+        createHierarchicalNodeValueType(options)
+    ];
+}
+exports.default = createHierarchicalSchemas;

package/lib/{utils → hooks}/useAllItems.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,10 +10,33 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import sanityClient from 'part:@sanity/base/client';
-import React from 'react';
-import { isDraft, unprefixId } from './idUtils';
-var client = sanityClient.withConfig({
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var client_1 = __importDefault(require("part:@sanity/base/client"));
+var React = __importStar(require("react"));
+var idUtils_1 = require("../utils/idUtils");
+var client = client_1.default.withConfig({
     apiVersion: '2021-09-01'
 });
 function getDeskFilter(_a) {
@@ -29,8 +53,8 @@ function getDeskFilter(_a) {
 function updateItemInState(state, item) {
     var _a;
     var newState = __assign({}, state);
-    var publishedId = unprefixId(item._id);
-    newState[publishedId] = __assign(__assign({}, (newState[publishedId] || {})), (_a = {}, _a[isDraft(item._id) ? 'draft' : 'published'] = item, _a));
+    var publishedId = (0, idUtils_1.unprefixId)(item._id);
+    newState[publishedId] = __assign(__assign({}, (newState[publishedId] || {})), (_a = {}, _a[(0, idUtils_1.isDraft)(item._id) ? 'draft' : 'published'] = item, _a));
     return newState;
 }
 function allItemsReducer(state, action) {
@@ -40,8 +64,8 @@ function allItemsReducer(state, action) {
         return updateItemInState(state, action.item);
     }
     if (action.type === 'removeItem') {
-        var publishedId = unprefixId(action.itemId);
-        return __assign(__assign({}, state), (_a = {}, _a[publishedId] = isDraft(action.itemId)
+        var publishedId = (0, idUtils_1.unprefixId)(action.itemId);
+        return __assign(__assign({}, state), (_a = {}, _a[publishedId] = (0, idUtils_1.isDraft)(action.itemId)
             ? // If a draft, keep only published
                 {
                     published: (_c = state[publishedId]) === null || _c === void 0 ? void 0 : _c.published
@@ -55,7 +79,7 @@ function allItemsReducer(state, action) {
     }
     return state;
 }
-export default function useAllItems(options) {
+function useAllItems(options) {
     var _a = React.useState('loading'), status = _a[0], setStatus = _a[1];
     var _b = React.useReducer(allItemsReducer, {}), allItems = _b[0], dispatch = _b[1];
     function handleListener(event) {
@@ -92,3 +116,4 @@ export default function useAllItems(options) {
         allItems: allItems
     };
 }
+exports.default = useAllItems;

package/lib/{utils → hooks}/useLocalTree.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,8 +10,28 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import React from 'react';
-import { dataToEditorTree } from './treeData';
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var React = __importStar(require("react"));
+var treeData_1 = require("../utils/treeData");
 /**
  * Enhances tree data with information on:
  *   - `expanded` - native property of react-sortable-tree to determine collapsing & expanding of a node's children
@@ -19,7 +40,7 @@ import { dataToEditorTree } from './treeData';
  * Doesn't modify the main tree or has side-effects on data.
  * Has the added benefit of being local to the user, so external changes won't affect local visibility.
  */
-export default function useLocalTree(_a) {
+function useLocalTree(_a) {
     var tree = _a.tree, allItems = _a.allItems;
     var _b = React.useState({}), visibilityMap = _b[0], setVisibilityMap = _b[1];
     function handleVisibilityToggle(data) {
@@ -27,7 +48,7 @@ export default function useLocalTree(_a) {
         setVisibilityMap(__assign(__assign({}, visibilityMap), (_a = {}, _a[data.node._key] = data.expanded, _a)));
     }
     return {
-        localTree: dataToEditorTree({
+        localTree: (0, treeData_1.dataToEditorTree)({
             tree: tree,
             allItems: allItems,
             visibilityMap: visibilityMap
@@ -35,3 +56,4 @@ export default function useLocalTree(_a) {
         handleVisibilityToggle: handleVisibilityToggle
     };
 }
+exports.default = useLocalTree;

package/lib/{utils → hooks}/useTreeOperations.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import * as React from 'react';
 import useAllItems from './useAllItems';
 import useTreeOperationsProvider from './useTreeOperationsProvider';
 declare type ContextValue = ReturnType<typeof useTreeOperationsProvider> & {

package/lib/hooks/useTreeOperations.js

@@ -0,0 +1,39 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeOperationsContext = void 0;
+var React = __importStar(require("react"));
+function placeholder() {
+    // no-op
+}
+exports.TreeOperationsContext = React.createContext({
+    addItem: placeholder,
+    duplicateItem: placeholder,
+    removeItem: placeholder,
+    handleMovedNode: placeholder,
+    moveItemDown: placeholder,
+    moveItemUp: placeholder,
+    allItemsStatus: 'loading'
+});
+function useTreeOperations() {
+    return React.useContext(exports.TreeOperationsContext);
+}
+exports.default = useTreeOperations;

package/lib/{utils → hooks}/useTreeOperationsProvider.d.ts

@@ -1,5 +1,5 @@
 import { LocalTreeItem, NodeProps } from '../types';
-import { HandleMovedNode } from './treePatches';
+import { HandleMovedNode } from '../utils/treePatches';
 export default function useTreeOperationsProvider(props: {
     patchPrefix?: string;
     onChange: (patch: unknown) => void;

package/lib/hooks/useTreeOperationsProvider.js

@@ -0,0 +1,85 @@
+"use strict";
+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)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Patch = __importStar(require("@sanity/form-builder/lib/patch/patches"));
+var PatchEvent_1 = __importDefault(require("@sanity/form-builder/PatchEvent"));
+var treePatches_1 = require("../utils/treePatches");
+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_1.default.from(finalPatches);
+        if (props.patchPrefix) {
+            patchEvent = PatchEvent_1.default.from(finalPatches.map(function (patch) { return Patch.prefixPath(patch, props.patchPrefix); }));
+        }
+        props.onChange(patchEvent);
+    }
+    function handleMovedNode(data) {
+        runPatches((0, treePatches_1.getMovedNodePatch)(data));
+    }
+    function addItem(item) {
+        runPatches((0, treePatches_1.getAddItemPatch)(item));
+    }
+    function duplicateItem(nodeProps) {
+        runPatches((0, treePatches_1.getDuplicateItemPatch)(nodeProps));
+    }
+    function removeItem(nodeProps) {
+        runPatches((0, treePatches_1.getRemoveItemPatch)(nodeProps));
+    }
+    function moveItemUp(nodeProps) {
+        runPatches((0, treePatches_1.getMoveItemPatch)({
+            nodeProps: nodeProps,
+            localTree: localTree,
+            direction: 'up'
+        }));
+    }
+    function moveItemDown(nodeProps) {
+        runPatches((0, treePatches_1.getMoveItemPatch)({
+            nodeProps: nodeProps,
+            localTree: localTree,
+            direction: 'down'
+        }));
+    }
+    return {
+        handleMovedNode: handleMovedNode,
+        addItem: addItem,
+        removeItem: removeItem,
+        moveItemUp: moveItemUp,
+        moveItemDown: moveItemDown,
+        duplicateItem: duplicateItem
+    };
+}
+exports.default = useTreeOperationsProvider;

package/lib/index.d.ts

@@ -1,3 +1,3 @@
-export { default as createHierarchicalField } from './createHierarchicalField';
+export { default as createHierarchicalSchemas } from './createHierarchicalSchemas';
 export { default as createDeskHierarchy } from './createDeskHierarchy';
 export { default as flatDataToTree } from './utils/flatDataToTree';

package/lib/index.js

@@ -1,3 +1,12 @@
-export { default as createHierarchicalField } from './createHierarchicalField';
-export { default as createDeskHierarchy } from './createDeskHierarchy';
-export { default as flatDataToTree } from './utils/flatDataToTree';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatDataToTree = exports.createDeskHierarchy = exports.createHierarchicalSchemas = void 0;
+var createHierarchicalSchemas_1 = require("./createHierarchicalSchemas");
+Object.defineProperty(exports, "createHierarchicalSchemas", { enumerable: true, get: function () { return __importDefault(createHierarchicalSchemas_1).default; } });
+var createDeskHierarchy_1 = require("./createDeskHierarchy");
+Object.defineProperty(exports, "createDeskHierarchy", { enumerable: true, get: function () { return __importDefault(createDeskHierarchy_1).default; } });
+var flatDataToTree_1 = require("./utils/flatDataToTree");
+Object.defineProperty(exports, "flatDataToTree", { enumerable: true, get: function () { return __importDefault(flatDataToTree_1).default; } });

package/lib/schemas/hierarchy.tree.d.ts

@@ -1,23 +1,13 @@
-/// <reference types="react" />
 declare const _default: {
     name: string;
     title: string;
     type: string;
     liveEdit: boolean;
-    fields: (Omit<import("@sanity/types/dist/dts").ArraySchemaType<unknown>, "type" | "of" | "jsonType"> & {
+    fields: {
+        name: string;
+        title: string;
         type: string;
-        inputComponent: import("react").FC<any>;
-        of: any[];
-    })[];
-    preview: {
-        select: {
-            id: string;
-            tree: string;
-        };
-        prepare({ id, tree }: {
-            id: string;
-            tree: unknown[];
-        }): Record<string, string>;
-    };
+        hidden: boolean;
+    }[];
 };
 export default _default;

package/lib/schemas/hierarchy.tree.js

@@ -1,31 +1,19 @@
-import createHierarchicalField from '../createHierarchicalField';
-export default {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.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,
+    // Let's avoid defining the actual hierarchical field, else GraphQL users won't be able to deploy schemas
     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.")
-            };
+        {
+            name: 'unusedField',
+            title: 'Unused field',
+            type: 'string',
+            hidden: true
         }
-    }
+    ]
 };

package/lib/utils/flatDataToTree.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,9 +10,10 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { getTreeFromFlatData } from 'react-sortable-tree';
-export default function flatDataToTree(data) {
-    return getTreeFromFlatData({
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_sortable_tree_1 = require("react-sortable-tree");
+function flatDataToTree(data) {
+    return (0, react_sortable_tree_1.getTreeFromFlatData)({
         flatData: data.map(function (item) { return (__assign(__assign({}, item), { 
             // if parent: undefined, the tree won't be constructed
             parent: item.parent || null })); }),
@@ -21,3 +23,4 @@ export default function flatDataToTree(data) {
         rootKey: null
     });
 }
+exports.default = flatDataToTree;

package/lib/utils/getAdjescentNodes.js

@@ -1,7 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Gets adjescent non-children nodes of a given treeIndex.
  */
-export default function getAdjescentNodes(_a) {
+function getAdjescentNodes(_a) {
     var flatTree = _a.flatTree, node = _a.node, treeIndex = _a.treeIndex;
     var leadingNode = flatTree
         .slice(0, treeIndex)
@@ -14,3 +16,4 @@ export default function getAdjescentNodes(_a) {
         followingNode: followingNode
     };
 }
+exports.default = getAdjescentNodes;

package/lib/utils/getCommonTreeProps.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,19 +10,24 @@ var __assign = (this && this.__assign) || function () {
     };
     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(_a) {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var jsx_runtime_1 = require("react/jsx-runtime");
+var NodeContentRenderer_1 = __importDefault(require("../components/NodeContentRenderer"));
+var PlaceholderDropzone_1 = __importDefault(require("../components/PlaceholderDropzone"));
+var TreeNodeRenderer_1 = __importDefault(require("../components/TreeNodeRenderer"));
+var getTreeHeight_1 = require("./getTreeHeight");
+function getCommonTreeProps(_a) {
     var placeholder = _a.placeholder;
     return {
         theme: {
-            nodeContentRenderer: NodeContentRenderer,
-            placeholderRenderer: function (props) { return _jsx(PlaceholderDropzone, __assign({}, placeholder, props), void 0); },
-            treeNodeRenderer: TreeNodeRenderer,
-            rowHeight: ROW_HEIGHT
+            nodeContentRenderer: NodeContentRenderer_1.default,
+            placeholderRenderer: function (props) { return (0, jsx_runtime_1.jsx)(PlaceholderDropzone_1.default, __assign({}, placeholder, props), void 0); },
+            treeNodeRenderer: TreeNodeRenderer_1.default,
+            rowHeight: getTreeHeight_1.ROW_HEIGHT
         }
     };
 }
+exports.default = getCommonTreeProps;

package/lib/utils/getTreeHeight.js

@@ -1,7 +1,11 @@
-import { getVisibleNodeCount } from 'react-sortable-tree';
-export var ROW_HEIGHT = 51;
-export default function getTreeHeight(treeData) {
-    var visibleNodeCount = getVisibleNodeCount({ treeData: treeData });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROW_HEIGHT = void 0;
+var react_sortable_tree_1 = require("react-sortable-tree");
+exports.ROW_HEIGHT = 51;
+function getTreeHeight(treeData) {
+    var visibleNodeCount = (0, react_sortable_tree_1.getVisibleNodeCount)({ treeData: treeData });
     // prettier-ignore
-    return "".concat(50 + (ROW_HEIGHT * visibleNodeCount), "px");
+    return "".concat(50 + (exports.ROW_HEIGHT * visibleNodeCount), "px");
 }
+exports.default = getTreeHeight;

package/lib/utils/gradientPatchAdapter.js

@@ -1,12 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toGradient = void 0;
 // Adapted from @sanity/form-builder/src/sanity/utils/gradientPatchAdapter.ts
-import assert from 'assert';
-import { arrayToJSONMatchPath } from '@sanity/mutator';
-export function toGradient(patches) {
+var assert_1 = __importDefault(require("assert"));
+var mutator_1 = require("@sanity/mutator");
+function toGradient(patches) {
     return patches.map(toGradientPatch);
 }
+exports.toGradient = toGradient;
 function toGradientPatch(patch) {
     var _a, _b, _c, _d;
-    var matchPath = arrayToJSONMatchPath(patch.path || []);
+    var matchPath = (0, mutator_1.arrayToJSONMatchPath)(patch.path || []);
     if (patch.type === 'insert') {
         var position = patch.position, items = patch.items;
         return {
@@ -21,7 +28,7 @@ function toGradientPatch(patch) {
             unset: [matchPath]
         };
     }
-    assert(patch.type, "Missing patch type in patch ".concat(JSON.stringify(patch)));
+    (0, assert_1.default)(patch.type, "Missing patch type in patch ".concat(JSON.stringify(patch)));
     if (matchPath) {
         return _b = {},
             _b[patch.type] = (_c = {},