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

package/lib/hooks/useAllItems.js

@@ -0,0 +1,119 @@
+"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 __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) {
+    var referenceTo = _a.referenceTo, referenceOptions = _a.referenceOptions;
+    var filterParts = ['_type in $docTypes'];
+    if (referenceOptions === null || referenceOptions === void 0 ? void 0 : referenceOptions.filter) {
+        filterParts.push(referenceOptions.filter);
+    }
+    return {
+        filter: filterParts.join(' && '),
+        params: __assign(__assign({}, ((referenceOptions === null || referenceOptions === void 0 ? void 0 : referenceOptions.filterParams) || {})), { docTypes: referenceTo.map(function (schemaType) { return schemaType; }) })
+    };
+}
+function updateItemInState(state, item) {
+    var _a;
+    var newState = __assign({}, state);
+    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) {
+    var _a;
+    var _b, _c, _d;
+    if (action.type === 'addOrEditItem' && ((_b = action.item) === null || _b === void 0 ? void 0 : _b._id)) {
+        return updateItemInState(state, action.item);
+    }
+    if (action.type === 'removeItem') {
+        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
+                }
+            : {
+                draft: (_d = state[publishedId]) === null || _d === void 0 ? void 0 : _d.draft
+            }, _a));
+    }
+    if (action.type === 'setInitialData') {
+        return action.items.reduce(updateItemInState, {});
+    }
+    return state;
+}
+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) {
+        if (event.type !== 'mutation') {
+            return;
+        }
+        if (event.result) {
+            dispatch({ type: 'addOrEditItem', item: event.result });
+        }
+        else {
+            dispatch({ type: 'removeItem', itemId: event.documentId });
+        }
+    }
+    function handleFirstLoad(items) {
+        dispatch({ type: 'setInitialData', items: items });
+        setStatus('success');
+    }
+    React.useEffect(function () {
+        var _a = getDeskFilter(options), filter = _a.filter, params = _a.params;
+        var query = "*[".concat(filter, "] {\n      _id,\n      _type,\n      _updatedAt,\n    }");
+        client
+            .fetch(query, params)
+            .then(handleFirstLoad)
+            .catch(function () {
+            setStatus('error');
+        });
+        var listener = client.listen(query, params).subscribe(handleListener);
+        return function () {
+            listener.unsubscribe();
+        };
+    }, []);
+    return {
+        status: status,
+        allItems: allItems
+    };
+}
+exports.default = useAllItems;

package/lib/hooks/useLocalTree.js

@@ -0,0 +1,59 @@
+"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;
+};
+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
+ *   - `draftId` & `publishedId` - refer to LocalTreeItem's type annotations
+ *
+ * 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.
+ */
+function useLocalTree(_a) {
+    var tree = _a.tree, allItems = _a.allItems;
+    var _b = React.useState({}), visibilityMap = _b[0], setVisibilityMap = _b[1];
+    function handleVisibilityToggle(data) {
+        var _a;
+        setVisibilityMap(__assign(__assign({}, visibilityMap), (_a = {}, _a[data.node._key] = data.expanded, _a)));
+    }
+    return {
+        localTree: (0, treeData_1.dataToEditorTree)({
+            tree: tree,
+            allItems: allItems,
+            visibilityMap: visibilityMap
+        }),
+        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,30 +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({ id, tree }) {
-            return {
-                title: `Hierarchical documents (ID: ${id})`,
-                subtitle: `${tree?.length || 0} document(s) in its list.`
-            };
+        {
+            name: 'unusedField',
+            title: 'Unused field',
+            type: 'string',
+            hidden: true
         }
-    }
+    ]
 };

package/lib/utils/flatDataToTree.js

@@ -1,14 +1,26 @@
-import { getTreeFromFlatData } from 'react-sortable-tree';
-export default function flatDataToTree(data) {
-    return getTreeFromFlatData({
-        flatData: data.map((item) => ({
-            ...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);
+};
+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
-        })),
-        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
     });
 }
+exports.default = flatDataToTree;

package/lib/utils/getAdjescentNodes.js

@@ -1,15 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Gets adjescent non-children nodes of a given treeIndex.
  */
-export default function getAdjescentNodes({ flatTree, node, treeIndex }) {
-    const leadingNode = flatTree
+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
     };
 }
+exports.default = getAdjescentNodes;

package/lib/utils/getCommonTreeProps.js

@@ -1,15 +1,33 @@
-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 }) {
+"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 __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: (props) => _jsx(PlaceholderDropzone, { ...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 const ROW_HEIGHT = 51;
-export default function getTreeHeight(treeData) {
-    const visibleNodeCount = getVisibleNodeCount({ 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 `${50 + (ROW_HEIGHT * visibleNodeCount)}px`;
+    return "".concat(50 + (exports.ROW_HEIGHT * visibleNodeCount), "px");
 }
+exports.default = getTreeHeight;

package/lib/utils/gradientPatchAdapter.js

@@ -1,18 +1,26 @@
+"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) {
-    const matchPath = arrayToJSONMatchPath(patch.path || []);
+    var _a, _b, _c, _d;
+    var matchPath = (0, mutator_1.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 +28,15 @@ function toGradientPatch(patch) {
             unset: [matchPath]
         };
     }
-    assert(patch.type, `Missing patch type in patch ${JSON.stringify(patch)}`);
+    (0, assert_1.default)(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,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;