@sanity/hierarchical-document-list 0.1.0-next.3 → 1.0.0

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,13 +1,26 @@
-export default function moveItemInArray({ array, fromIndex, toIndex }) {
+"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)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
     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,44 +1,76 @@
-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: []
-        };
+"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 __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 });
+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; })
+        .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 ((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);
 };
-const documentPairToNode = (doc) => {
-    if (!doc?.published?._id) {
+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',
-        draftId: doc.draft?._id,
-        draftUpdatedAt: doc.draft?._updatedAt,
+        _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: doc.published?._updatedAt,
+        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',
@@ -48,30 +80,39 @@ const documentPairToNode = (doc) => {
         }
     };
 };
-export const flatTree = (tree) => {
-    return tree.reduce((flattened, item) => {
-        const { children, ...node } = item;
-        return [...flattened, node, ...(Array.isArray(children) ? flatTree(children) : [])];
+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) ? (0, exports.flatTree)(children) : []), true);
     }, []);
 };
-export const getUnaddedItems = (data) => {
+exports.flatTree = flatTree;
+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) {
+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,55 +1,100 @@
-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) {
-    const normalizedNode = normalizeNodeForStorage(item);
+"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 __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 });
+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) {
-    const newItem = {
-        ...nodeProps.node,
-        _key: randomKey(12)
-    };
-    const 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({ node }) {
-    const keyPath = { _key: node._key };
-    const children = getChildrenPaths(node);
-    return [
+exports.getDuplicateItemPatch = getDuplicateItemPatch;
+function getRemoveItemPatch(_a) {
+    var node = _a.node;
+    var keyPath = { _key: node._key };
+    var children = getChildrenPaths(node);
+    return __spreadArray([
         // 1. Unset the removed node
-        Patch.unset([keyPath]),
-        // 2. Unset its children
-        ...children.map((path) => Patch.unset([{ _key: path }]))
-    ];
+        Patch.unset([keyPath])
+    ], children.map(function (path) { return Patch.unset([{ _key: path }]); }), true);
 }
-export function getMovedNodePatch(data) {
-    const { nextParentNode } = data;
-    const keyPath = { _key: data.node._key };
+exports.getRemoveItemPatch = getRemoveItemPatch;
+function getMovedNodePatch(data) {
+    var _a, _b;
+    var nextParentNode = data.nextParentNode;
+    var keyPath = { _key: data.node._key };
     // === REMOVING NODE FROM TREE ===
     // `nextPath` will be null if the item is removed from tree
     if (!Array.isArray(data.nextPath)) {
         return getRemoveItemPatch({ node: data.node });
     }
-    const nextFlatTree = getFlatDataFromTree({
+    var nextFlatTree = (0, react_sortable_tree_1.getFlatDataFromTree)({
         treeData: data.treeData,
-        getNodeKey: (t) => t.node._key
+        getNodeKey: function (t) { return t.node._key; }
     });
-    const normalizedNode = normalizeNodeForStorage(data.node);
-    const { leadingNode, followingNode } = getAdjescentNodes({
+    var normalizedNode = (0, treeData_1.normalizeNodeForStorage)(data.node);
+    var _c = (0, getAdjescentNodes_1.default)({
         flatTree: nextFlatTree,
         node: data.node,
         treeIndex: data.nextTreeIndex
-    });
+    }), leadingNode = _c.leadingNode, followingNode = _c.followingNode;
     return [
         // 1. Unset the moved node
         // (will be ignored by Content Lake on new nodes with _key not yet in tree)
@@ -57,12 +102,12 @@ export function getMovedNodePatch(data) {
         // 2. SIBLING-BASED PLACEMENT
         // If we were to place solely based on nextTreeIndex, concurrent changes from other editors could put the new node in an unexpected position.
         // Let's instead anchor it to the _key of the sibling coming before or after it.
-        leadingNode?.node?._key
+        ((_a = leadingNode === null || leadingNode === void 0 ? void 0 : leadingNode.node) === null || _a === void 0 ? void 0 : _a._key)
             ? // After the sibling before it
                 Patch.insert([normalizedNode], 'after', [{ _key: leadingNode.node._key }])
             : // Or before the sibling right after it, in case there's no leading sibling node
                 // prettier-ignore
-                Patch.insert([normalizedNode], 'before', [followingNode?.node?._key ? { _key: followingNode.node._key } : data.nextTreeIndex]),
+                Patch.insert([normalizedNode], 'before', [((_b = followingNode === null || followingNode === void 0 ? void 0 : followingNode.node) === null || _b === void 0 ? void 0 : _b._key) ? { _key: followingNode.node._key } : data.nextTreeIndex]),
         // 3. Patch the new node with its new `parent`
         nextParentNode
             ? // If it has a parent node, set that parent's _key
@@ -71,46 +116,49 @@ export function getMovedNodePatch(data) {
                 Patch.unset([keyPath, 'parent'])
     ];
 }
+exports.getMovedNodePatch = getMovedNodePatch;
 function getChildrenPaths(node) {
     if (!Array.isArray(node.children)) {
         return [];
     }
     return node.children
-        .reduce((keyPaths, child) => [...keyPaths, child._key, ...getChildrenPaths(child)], [])
+        .reduce(function (keyPaths, child) { return __spreadArray(__spreadArray(__spreadArray([], keyPaths, true), [child._key], false), getChildrenPaths(child), true); }, [])
         .filter(Boolean);
 }
-export function getMoveItemPatch({ nodeProps: { node, treeIndex }, localTree, direction = 'up' }) {
-    const keyPath = { _key: node._key };
-    const nextTreeIndex = treeIndex + (direction === 'up' ? -1 : 1);
-    const flatTree = getFlatDataFromTree({
+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 = (0, react_sortable_tree_1.getFlatDataFromTree)({
         treeData: localTree,
-        getNodeKey: (t) => t.node._key
+        getNodeKey: function (t) { return t.node._key; }
     });
-    const nextFlatTree = moveItemInArray({
+    var nextFlatTree = (0, moveItemInArray_1.default)({
         array: flatTree,
         fromIndex: treeIndex,
         toIndex: nextTreeIndex
     });
-    const { leadingNode, followingNode } = getAdjescentNodes({
+    var _f = (0, getAdjescentNodes_1.default)({
         flatTree: nextFlatTree,
-        node,
+        node: node,
         treeIndex: nextTreeIndex
-    });
-    const normalizedNode = normalizeNodeForStorage(node);
+    }), leadingNode = _f.leadingNode, followingNode = _f.followingNode;
+    var normalizedNode = (0, treeData_1.normalizeNodeForStorage)(node);
     // When moving up, look at following node to figure out what is the next parent.
-    const nodeToInheritParent = direction === 'up' ? followingNode : leadingNode;
-    const nextParentNode = nodeToInheritParent?.parentNode;
+    var nodeToInheritParent = direction === 'up' ? followingNode : leadingNode;
+    var nextParentNode = nodeToInheritParent === null || nodeToInheritParent === void 0 ? void 0 : nodeToInheritParent.parentNode;
     return [
         // 1. Unset the moved node
         // (will be ignored by Content Lake on new nodes with _key not yet in tree)
         Patch.unset([keyPath]),
         // 2. SIBLING-BASED PLACEMENT
-        leadingNode?.node?._key
+        ((_b = leadingNode === null || leadingNode === void 0 ? void 0 : leadingNode.node) === null || _b === void 0 ? void 0 : _b._key)
             ? // After the sibling before it
                 Patch.insert([normalizedNode], 'after', [{ _key: leadingNode.node._key }])
             : // Or before the sibling right after it, in case there's no leading sibling node
                 Patch.insert([normalizedNode], 'before', [
-                    followingNode?.node?._key ? { _key: followingNode.node._key } : nextTreeIndex
+                    ((_c = followingNode === null || followingNode === void 0 ? void 0 : followingNode.node) === null || _c === void 0 ? void 0 : _c._key) ? { _key: followingNode.node._key } : nextTreeIndex
                 ]),
         // 3. Patch the new node with its new `parent`
         nextParentNode
@@ -120,3 +168,4 @@ export function getMoveItemPatch({ nodeProps: { node, treeIndex }, localTree, di
                 Patch.unset([keyPath, 'parent'])
     ];
 }
+exports.getMoveItemPatch = getMoveItemPatch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/hierarchical-document-list",
-  "version": "0.1.0-next.3",
+  "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

@@ -1,15 +1,15 @@
 {
   "compilerOptions": {
-    "target": "ESNext",
+    "target": "es5",
     "useDefineForClassFields": true,
     "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,36 +0,0 @@
-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}")`);
-    }
-    return {
-        ...rest,
-        options,
-        name,
-        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((type) => ({ type })),
-                                options: options.referenceOptions
-                            }
-                        ]
-                    }
-                ]
-            }
-        ],
-        inputComponent: TreeInputComponent
-    };
-}