@sanity/hierarchical-document-list 0.1.0 → 1.1.0

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

@@ -1,17 +1,17 @@
-import { OnVisibilityToggleData } from 'react-sortable-tree';
-import { AllItems, LocalTreeItem, StoredTreeItem } from '../types';
-/**
- * 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.
- */
-export default function useLocalTree({ tree, allItems }: {
-    tree: StoredTreeItem[];
-    allItems: AllItems;
-}): {
-    handleVisibilityToggle: (data: OnVisibilityToggleData) => void;
-    localTree: LocalTreeItem[];
-};
+import { OnVisibilityToggleData } from 'react-sortable-tree';
+import { AllItems, LocalTreeItem, StoredTreeItem } from '../types';
+/**
+ * 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.
+ */
+export default function useLocalTree({ tree, allItems }: {
+    tree: StoredTreeItem[];
+    allItems: AllItems;
+}): {
+    handleVisibilityToggle: (data: OnVisibilityToggleData) => void;
+    localTree: LocalTreeItem[];
+};

package/lib/{utils → hooks}/useLocalTree.js

@@ -1,37 +1,59 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-import React from 'react';
-import { dataToEditorTree } from './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.
- */
-export default 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: dataToEditorTree({
-            tree: tree,
-            allItems: allItems,
-            visibilityMap: visibilityMap
-        }),
-        handleVisibilityToggle: handleVisibilityToggle
-    };
-}
+"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,9 +1,9 @@
-import React from 'react';
-import useAllItems from './useAllItems';
-import useTreeOperationsProvider from './useTreeOperationsProvider';
-declare type ContextValue = ReturnType<typeof useTreeOperationsProvider> & {
-    allItemsStatus: ReturnType<typeof useAllItems>['status'];
-};
-export declare const TreeOperationsContext: React.Context<ContextValue>;
-export default function useTreeOperations(): ContextValue;
-export {};
+import * as React from 'react';
+import useAllItems from './useAllItems';
+import useTreeOperationsProvider from './useTreeOperationsProvider';
+declare type ContextValue = ReturnType<typeof useTreeOperationsProvider> & {
+    allItemsStatus: ReturnType<typeof useAllItems>['status'];
+};
+export declare const TreeOperationsContext: React.Context<ContextValue>;
+export default function useTreeOperations(): ContextValue;
+export {};

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,14 +1,14 @@
-import { LocalTreeItem, NodeProps } from '../types';
-import { HandleMovedNode } from './treePatches';
-export default function useTreeOperationsProvider(props: {
-    patchPrefix?: string;
-    onChange: (patch: unknown) => void;
-    localTree: LocalTreeItem[];
-}): {
-    handleMovedNode: HandleMovedNode;
-    addItem: (item: LocalTreeItem) => void;
-    duplicateItem: (nodeProps: NodeProps) => void;
-    removeItem: (nodeProps: NodeProps) => void;
-    moveItemUp: (nodeProps: NodeProps) => void;
-    moveItemDown: (nodeProps: NodeProps) => void;
-};
+import { LocalTreeItem, NodeProps } from '../types';
+import { HandleMovedNode } from '../utils/treePatches';
+export default function useTreeOperationsProvider(props: {
+    patchPrefix?: string;
+    onChange: (patch: unknown) => void;
+    localTree: LocalTreeItem[];
+}): {
+    handleMovedNode: HandleMovedNode;
+    addItem: (item: LocalTreeItem) => void;
+    duplicateItem: (nodeProps: NodeProps) => void;
+    removeItem: (nodeProps: NodeProps) => void;
+    moveItemUp: (nodeProps: NodeProps) => void;
+    moveItemDown: (nodeProps: NodeProps) => 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 createDeskHierarchy } from './createDeskHierarchy';
-export { default as flatDataToTree } from './utils/flatDataToTree';
+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"> & {
-        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>;
-    };
-};
-export default _default;
+declare const _default: {
+    name: string;
+    title: string;
+    type: string;
+    liveEdit: boolean;
+    fields: {
+        name: string;
+        title: string;
+        type: string;
+        hidden: boolean;
+    }[];
+};
+export default _default;

package/lib/schemas/hierarchy.tree.js

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

package/lib/types.d.ts

@@ -0,0 +1,128 @@
+import { SanityDocument } from '@sanity/client';
+import { ArraySchemaType, ObjectSchemaType } from '@sanity/types';
+import { NodeRendererProps, TreeItem } from 'react-sortable-tree';
+import { INTERNAL_NODE_TYPE, INTERNAL_NODE_VALUE_TYPE } from './utils/injectNodeTypeInPatches';
+interface SanityReference {
+    _type: 'reference';
+    _ref: string;
+    _weak?: boolean;
+}
+/**
+ * Objects saved to tree documents in Sanity's Content Lake
+ */
+export interface StoredTreeItem {
+    _key: string;
+    _type: typeof INTERNAL_NODE_TYPE | string;
+    value?: {
+        _type: typeof INTERNAL_NODE_VALUE_TYPE | string;
+        reference?: SanityReference;
+        docType?: string;
+    };
+    /**
+     * _key of parent node
+     */
+    parent?: string | null;
+}
+/**
+ * Tree items enhanced locally in the client with info from `allItems` and `visibilityMap`.
+ * `allItems` stop here and never become LocalTreeItems as they aren't added to react-sortable-tree.
+ *
+ * See `useLocalTree.ts` and `dataToEditorTree()`.
+ */
+export interface EnhancedTreeItem extends StoredTreeItem {
+    expanded?: boolean | undefined;
+    /**
+     * Used by DocumentInNode to render the preview for drafts if they exist.
+     * Also informs document status icons.
+     */
+    draftId?: string;
+    draftUpdatedAt?: string;
+    /**
+     * If not present, DocumentInNode will show up an error for invalid document.
+     *  - undefined `publishedId` could mean the document is either deleted, or it doesn't match GROQ filters anymore
+     */
+    publishedId?: string;
+    publishedUpdatedAt?: string;
+}
+/**
+ * Tree items as found in the sortable tree itself.
+ */
+export declare type LocalTreeItem = EnhancedTreeItem & Pick<TreeItem, 'title' | 'children'>;
+export interface TreeInputOptions {
+    /**
+     * What document types this hierarchy can refer to.
+     * Similar to the `to` property of the [reference field](https://www.sanity.io/docs/reference-type).
+     */
+    referenceTo: string[];
+    /**
+     * Used to provide fine-grained filtering for documents.
+     */
+    referenceOptions?: {
+        /**
+         * Static filter to apply to tree document queries.
+         */
+        filter?: string;
+        /**
+         * Parameters / variables to pass to the GROQ query ran to fetch documents.
+         */
+        filterParams?: Record<string, unknown>;
+    };
+    /**
+     * How deep should editors be allowed to nest items.
+     */
+    maxDepth?: number;
+    /**
+     * Schema type for your hierarchical documents.
+     * Refer to documentation on how to provide these schemas in your studio.
+     *
+     * Defautlt: 'hierarchy.tree' - this schema is bundled with the plugin
+     */
+    documentType?: string;
+}
+export interface TreeFieldSchema extends Omit<ArraySchemaType, 'of' | 'type' | 'inputComponent' | 'jsonType'> {
+    options: ArraySchemaType['options'] & TreeInputOptions;
+}
+export interface TreeNodeObjectSchema extends Omit<ObjectSchemaType, 'name' | 'fields' | 'type' | 'inputComponent' | 'jsonType'> {
+    options: ObjectSchemaType['options'] & TreeInputOptions;
+}
+export interface TreeDeskStructureProps extends TreeInputOptions {
+    /**
+     * _id of the document that will hold the tree data.
+     */
+    documentId: string;
+    /**
+     * (Optional)
+     * Key for the field representing the hierarchical tree inside the document.
+     * `tree` by default.
+     */
+    fieldKeyInDocument?: string;
+}
+export interface DocumentPair {
+    draft?: SanityDocument;
+    published?: SanityDocument;
+}
+export interface AllItems {
+    [publishedId: string]: DocumentPair | undefined;
+}
+declare type DocumentOperation<Payload = unknown> = {
+    execute?: (payload?: Payload) => void;
+    disabled?: boolean | string;
+};
+export interface DocumentOperations {
+    patch?: DocumentOperation<unknown[]>;
+    commit?: DocumentOperation;
+    del?: DocumentOperation;
+    delete?: DocumentOperation;
+    discardChanges?: DocumentOperation;
+    duplicate?: DocumentOperation;
+    restore?: DocumentOperation;
+    unpublish?: DocumentOperation;
+    publish?: DocumentOperation;
+}
+export interface VisibilityMap {
+    [_key: string]: boolean;
+}
+export interface NodeProps extends NodeRendererProps {
+    node: LocalTreeItem;
+}
+export {};

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/flatDataToTree.d.ts

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

package/lib/utils/flatDataToTree.js

@@ -1,23 +1,26 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-import { getTreeFromFlatData } from 'react-sortable-tree';
-export default function flatDataToTree(data) {
-    return getTreeFromFlatData({
-        flatData: data.map(function (item) { return (__assign(__assign({}, item), { 
-            // if parent: undefined, the tree won't be constructed
-            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
-    });
-}
+"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: 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.d.ts

@@ -1,12 +1,12 @@
-import { FlatDataItem, TreeItem } from 'react-sortable-tree';
-/**
- * Gets adjescent non-children nodes of a given treeIndex.
- */
-export default function getAdjescentNodes({ flatTree, node, treeIndex }: {
-    flatTree: FlatDataItem[];
-    node: TreeItem;
-    treeIndex: number;
-}): {
-    leadingNode?: FlatDataItem;
-    followingNode?: FlatDataItem;
-};
+import { FlatDataItem, TreeItem } from 'react-sortable-tree';
+/**
+ * Gets adjescent non-children nodes of a given treeIndex.
+ */
+export default function getAdjescentNodes({ flatTree, node, treeIndex }: {
+    flatTree: FlatDataItem[];
+    node: TreeItem;
+    treeIndex: number;
+}): {
+    leadingNode?: FlatDataItem;
+    followingNode?: FlatDataItem;
+};