@sanity/hierarchical-document-list 1.0.0 → 1.1.0

package/lib/hooks/useTreeOperationsProvider.js

@@ -1,85 +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;
+"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 createHierarchicalSchemas } from './createHierarchicalSchemas';
-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,12 +1,12 @@
-"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; } });
+"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,13 +1,13 @@
-declare const _default: {
-    name: string;
-    title: string;
-    type: string;
-    liveEdit: boolean;
-    fields: {
-        name: string;
-        title: string;
-        type: string;
-        hidden: boolean;
-    }[];
-};
-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,19 +1,19 @@
-"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
-        }
-    ]
-};
+"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,26 +1,26 @@
-"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;
+"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;
+};

package/lib/utils/getAdjescentNodes.js

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

package/lib/utils/getCommonTreeProps.d.ts

@@ -1,7 +1,7 @@
-import { ReactSortableTreeProps } from 'react-sortable-tree';
-export default function getCommonTreeProps({ placeholder }: {
-    placeholder: {
-        title: string;
-        subtitle?: string;
-    };
-}): Partial<ReactSortableTreeProps>;
+import { ReactSortableTreeProps } from 'react-sortable-tree';
+export default function getCommonTreeProps({ placeholder }: {
+    placeholder: {
+        title: string;
+        subtitle?: string;
+    };
+}): Partial<ReactSortableTreeProps>;

package/lib/utils/getCommonTreeProps.js

@@ -1,33 +1,33 @@
-"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_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;
+"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_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.d.ts

@@ -1,3 +1,3 @@
-import { TreeItem } from 'react-sortable-tree';
-export declare const ROW_HEIGHT = 51;
-export default function getTreeHeight(treeData: TreeItem[]): string;
+import { TreeItem } from 'react-sortable-tree';
+export declare const ROW_HEIGHT = 51;
+export default function getTreeHeight(treeData: TreeItem[]): string;

package/lib/utils/getTreeHeight.js

@@ -1,11 +1,11 @@
-"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 + (exports.ROW_HEIGHT * visibleNodeCount), "px");
-}
-exports.default = getTreeHeight;
+"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 + (exports.ROW_HEIGHT * visibleNodeCount), "px");
+}
+exports.default = getTreeHeight;