@pisell/materials 6.0.11 → 6.0.12

package/lib/components/pisellDraggable/components/TreeItem/TreeItem.js

@@ -0,0 +1,93 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/pisellDraggable/components/TreeItem/TreeItem.tsx
+var TreeItem_exports = {};
+__export(TreeItem_exports, {
+  TreeItem: () => TreeItem
+});
+module.exports = __toCommonJS(TreeItem_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_components = require("../../components");
+var import_TreeItem = require("./TreeItem.less");
+var TreeItem = (0, import_react.forwardRef)((props, ref) => {
+  const {
+    childCount,
+    clone,
+    depth,
+    disableSelection,
+    disableInteraction,
+    ghost,
+    handleProps,
+    indentationWidth,
+    indicator,
+    collapsed,
+    onCollapse,
+    onRemove,
+    style,
+    wrapperRef,
+    item,
+    renderItem,
+    ...otherProps
+  } = props;
+  if (renderItem) {
+    return renderItem(props);
+  }
+  return /* @__PURE__ */ import_react.default.createElement(
+    "li",
+    {
+      className: (0, import_classnames.default)(
+        "Wrapper",
+        clone && "clone",
+        ghost && "ghost",
+        indicator && "indicator",
+        disableSelection && "disableSelection",
+        disableInteraction && "disableInteraction"
+      ),
+      ref: wrapperRef,
+      style: {
+        "--spacing": `${indentationWidth * depth}px`
+      },
+      ...otherProps
+    },
+    /* @__PURE__ */ import_react.default.createElement("div", { className: "TreeItem", ref, style }, /* @__PURE__ */ import_react.default.createElement(import_components.Handle, { ...handleProps }), onCollapse && /* @__PURE__ */ import_react.default.createElement(
+      import_components.Action,
+      {
+        onClick: onCollapse,
+        className: (0, import_classnames.default)("Collapse", collapsed && "collapsed")
+      },
+      collapseIcon
+    ), /* @__PURE__ */ import_react.default.createElement("span", { className: "Text" }, item.id), !clone && onRemove && /* @__PURE__ */ import_react.default.createElement(import_components.Remove, { onClick: onRemove }), clone && childCount && childCount > 1 ? /* @__PURE__ */ import_react.default.createElement("span", { className: "Count" }, childCount) : null)
+  );
+});
+var collapseIcon = /* @__PURE__ */ import_react.default.createElement("svg", { width: "10", xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 70 41" }, /* @__PURE__ */ import_react.default.createElement("path", { d: "M30.76 39.2402C31.885 40.3638 33.41 40.995 35 40.995C36.59 40.995 38.115 40.3638 39.24 39.2402L68.24 10.2402C69.2998 9.10284 69.8768 7.59846 69.8494 6.04406C69.822 4.48965 69.1923 3.00657 68.093 1.90726C66.9937 0.807959 65.5106 0.178263 63.9562 0.150837C62.4018 0.123411 60.8974 0.700397 59.76 1.76024L35 26.5102L10.24 1.76024C9.10259 0.700397 7.59822 0.123411 6.04381 0.150837C4.4894 0.178263 3.00632 0.807959 1.90702 1.90726C0.807714 3.00657 0.178019 4.48965 0.150593 6.04406C0.123167 7.59846 0.700153 9.10284 1.75999 10.2402L30.76 39.2402Z" }));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TreeItem
+});

package/lib/components/pisellDraggable/components/TreeItem/TreeItem.less

@@ -0,0 +1,128 @@
+.Wrapper {
+  list-style: none;
+  box-sizing: border-box;
+  padding-left: var(--spacing);
+  margin-bottom: -1px;
+
+  &.clone {
+    display: inline-block;
+    pointer-events: none;
+    padding: 0;
+    padding-left: 10px;
+    padding-top: 5px;
+
+    .TreeItem {
+      --vertical-padding: 5px;
+
+      padding-right: 24px;
+      border-radius: 4px;
+      box-shadow: 0px 15px 15px 0 rgba(34, 33, 81, 0.1);
+    }
+  }
+
+  &.ghost {
+    &.indicator {
+      opacity: 1;
+      position: relative;
+      z-index: 1;
+      margin-bottom: -1px;
+
+      .TreeItem {
+        position: relative;
+        padding: 0;
+        height: 8px;
+        border-color: #2389ff;
+        background-color: #56a1f8;
+
+        &:before {
+          position: absolute;
+          left: -8px;
+          top: -4px;
+          display: block;
+          content: '';
+          width: 12px;
+          height: 12px;
+          border-radius: 50%;
+          border: 1px solid #2389ff;
+          background-color: #ffffff;
+        }
+
+        >* {
+          /* Items are hidden using height and opacity to retain focus */
+          opacity: 0;
+          height: 0;
+        }
+      }
+    }
+
+    &:not(.indicator) {
+      opacity: 0.5;
+    }
+
+    .TreeItem>* {
+      box-shadow: none;
+      background-color: transparent;
+    }
+  }
+}
+
+.TreeItem {
+  --vertical-padding: 10px;
+
+  position: relative;
+  display: flex;
+  align-items: center;
+  padding: var(--vertical-padding) 10px;
+  background-color: #fff;
+  border: 1px solid #dedede;
+  color: #222;
+  box-sizing: border-box;
+}
+
+.Text {
+  flex-grow: 1;
+  padding-left: 0.5rem;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  overflow: hidden;
+}
+
+.Count {
+  position: absolute;
+  top: -10px;
+  right: -10px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 24px;
+  height: 24px;
+  border-radius: 50%;
+  background-color: #2389ff;
+  font-size: 0.8rem;
+  font-weight: 600;
+  color: #fff;
+}
+
+.disableInteraction {
+  pointer-events: none;
+}
+
+.disableSelection,
+.clone {
+
+  .Text,
+  .Count {
+    user-select: none;
+    -webkit-user-select: none;
+  }
+}
+
+.Collapse {
+  svg {
+    transition: transform 250ms ease;
+  }
+
+  &.collapsed svg {
+    transform: rotate(-90deg);
+  }
+}

package/lib/components/pisellDraggable/components/TreeItem/index.d.ts

@@ -0,0 +1,2 @@
+export { TreeItem } from './TreeItem';
+export { SortableTreeItem } from './SortableTreeItem';

package/lib/components/pisellDraggable/components/TreeItem/index.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/pisellDraggable/components/TreeItem/index.ts
+var TreeItem_exports = {};
+__export(TreeItem_exports, {
+  SortableTreeItem: () => import_SortableTreeItem.SortableTreeItem,
+  TreeItem: () => import_TreeItem.TreeItem
+});
+module.exports = __toCommonJS(TreeItem_exports);
+var import_TreeItem = require("./TreeItem");
+var import_SortableTreeItem = require("./SortableTreeItem");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SortableTreeItem,
+  TreeItem
+});

package/lib/components/pisellDraggable/components/index.d.ts

@@ -0,0 +1,4 @@
+export { Action } from './Action';
+export { Handle } from './Handle';
+export { Remove } from './Remove';
+export { TreeItem, SortableTreeItem } from './TreeItem';

package/lib/components/pisellDraggable/components/index.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/pisellDraggable/components/index.ts
+var components_exports = {};
+__export(components_exports, {
+  Action: () => import_Action.Action,
+  Handle: () => import_Handle.Handle,
+  Remove: () => import_Remove.Remove,
+  SortableTreeItem: () => import_TreeItem.SortableTreeItem,
+  TreeItem: () => import_TreeItem.TreeItem
+});
+module.exports = __toCommonJS(components_exports);
+var import_Action = require("./Action");
+var import_Handle = require("./Handle");
+var import_Remove = require("./Remove");
+var import_TreeItem = require("./TreeItem");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Action,
+  Handle,
+  Remove,
+  SortableTreeItem,
+  TreeItem
+});

package/lib/components/pisellDraggable/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 可拖拽树形组件
+ * 基于@dnd-kit库实现，支持拖拽排序、展开折叠、删除等功能
+ */
+import React from 'react';
+import type { TreeItem, TreeItems } from './types';
+interface Props {
+    /** 是否支持折叠功能 */
+    collapsible?: boolean;
+    /** 初始树形数据，默认使用 initialItems */
+    value?: TreeItems;
+    /** 缩进宽度，控制子节点的缩进距离 */
+    indentationWidth?: number;
+    /** 是否显示拖拽指示器 */
+    indicator?: boolean;
+    /** 是否支持删除节点功能 */
+    removable?: boolean;
+    /** 自定义渲染树节点 */
+    renderItem?: (item: TreeItem) => React.ReactNode;
+    /** 树形数据变化回调 */
+    onChange?: (items: TreeItems) => void;
+    /** 删除节点前 */
+    onRemoveBefore?: (item: TreeItem) => Promise<boolean>;
+}
+export declare function SortableTree({ collapsible, value, indicator, indentationWidth, removable, renderItem, onChange, onRemoveBefore, }: Props): React.JSX.Element;
+declare const Demo: () => React.JSX.Element;
+export default Demo;

package/lib/components/pisellDraggable/index.js

@@ -0,0 +1,271 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/pisellDraggable/index.tsx
+var pisellDraggable_exports = {};
+__export(pisellDraggable_exports, {
+  SortableTree: () => SortableTree,
+  default: () => pisellDraggable_default
+});
+module.exports = __toCommonJS(pisellDraggable_exports);
+var import_core = require("@dnd-kit/core");
+var import_sortable = require("@dnd-kit/sortable");
+var import_react = __toESM(require("react"));
+var import_react_dom = require("react-dom");
+var import_utilities = require("@dnd-kit/utilities");
+var import_components = require("./components");
+var import_utilities2 = require("./utilities");
+var initialItems = [
+  {
+    id: "Home",
+    children: []
+  },
+  {
+    id: "Collections",
+    children: [
+      { id: "Spring", children: [] },
+      { id: "Summer", children: [] },
+      { id: "Fall", children: [] },
+      { id: "Winter", children: [] }
+    ]
+  },
+  {
+    id: "About Us",
+    children: []
+  },
+  {
+    id: "My Account",
+    children: [
+      { id: "Addresses", children: [] },
+      { id: "Order History", children: [] }
+    ]
+  }
+];
+var measuring = {
+  droppable: {
+    strategy: import_core.MeasuringStrategy.Always
+  }
+};
+var dropAnimationConfig = {
+  keyframes({ transform }) {
+    return [
+      { opacity: 1, transform: import_utilities.CSS.Transform.toString(transform.initial) },
+      {
+        opacity: 0,
+        transform: import_utilities.CSS.Transform.toString({
+          ...transform.final,
+          x: transform.final.x + 5,
+          y: transform.final.y + 5
+        })
+      }
+    ];
+  },
+  easing: "ease-out",
+  sideEffects({ active }) {
+    active.node.animate([{ opacity: 0 }, { opacity: 1 }], {
+      duration: import_core.defaultDropAnimation.duration,
+      easing: import_core.defaultDropAnimation.easing
+    });
+  }
+};
+function SortableTree({
+  collapsible = true,
+  value = initialItems,
+  indicator = false,
+  indentationWidth = 50,
+  removable = true,
+  renderItem,
+  onChange,
+  onRemoveBefore
+}) {
+  const [items, setItems] = (0, import_react.useState)([]);
+  const [activeId, setActiveId] = (0, import_react.useState)(null);
+  const [overId, setOverId] = (0, import_react.useState)(null);
+  const [offsetLeft, setOffsetLeft] = (0, import_react.useState)(0);
+  (0, import_react.useEffect)(() => {
+    console.log("初始化", value);
+    setItems(value);
+  }, [value]);
+  const flattenedItems = (0, import_react.useMemo)(() => {
+    const flattenedTree = (0, import_utilities2.flattenTree)(items);
+    const collapsedItems = flattenedTree.reduce(
+      (acc, { children, collapsed, id }) => collapsed && children.length ? [...acc, id] : acc,
+      []
+    );
+    return (0, import_utilities2.removeChildrenOf)(
+      flattenedTree,
+      activeId != null ? [activeId, ...collapsedItems] : collapsedItems
+    );
+  }, [activeId, items]);
+  const projected = activeId && overId ? (0, import_utilities2.getProjection)(
+    flattenedItems,
+    activeId,
+    overId,
+    offsetLeft,
+    indentationWidth
+  ) : null;
+  const sensorContext = (0, import_react.useRef)({
+    items: flattenedItems,
+    offset: offsetLeft
+  });
+  const sensors = (0, import_core.useSensors)((0, import_core.useSensor)(import_core.PointerSensor));
+  const sortedIds = (0, import_react.useMemo)(
+    () => flattenedItems.map(({ id }) => id),
+    [flattenedItems]
+  );
+  const activeItem = activeId ? flattenedItems.find(({ id }) => id === activeId) : null;
+  (0, import_react.useEffect)(() => {
+    sensorContext.current = {
+      items: flattenedItems,
+      offset: offsetLeft
+    };
+  }, [flattenedItems, offsetLeft]);
+  (0, import_react.useEffect)(() => {
+    document.body.id = "body";
+  }, []);
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_core.DndContext,
+    {
+      sensors,
+      collisionDetection: import_core.closestCenter,
+      measuring,
+      onDragStart: handleDragStart,
+      onDragMove: handleDragMove,
+      onDragOver: handleDragOver,
+      onDragEnd: handleDragEnd,
+      onDragCancel: handleDragCancel
+    },
+    /* @__PURE__ */ import_react.default.createElement(import_sortable.SortableContext, { items: sortedIds, strategy: import_sortable.verticalListSortingStrategy }, flattenedItems.map((item) => {
+      const { id, children, collapsed, depth } = item;
+      return /* @__PURE__ */ import_react.default.createElement(
+        import_components.SortableTreeItem,
+        {
+          key: id,
+          id,
+          item,
+          depth: id === activeId && projected ? projected.depth : depth,
+          indentationWidth,
+          indicator,
+          collapsed: Boolean(collapsed && children.length),
+          onCollapse: collapsible && children.length ? () => handleCollapse(id) : void 0,
+          onRemove: removable ? () => handleRemove(item) : void 0,
+          renderItem
+        }
+      );
+    }), (0, import_react_dom.createPortal)(
+      /* @__PURE__ */ import_react.default.createElement(
+        import_core.DragOverlay,
+        {
+          dropAnimation: dropAnimationConfig,
+          modifiers: indicator ? [adjustTranslate] : void 0
+        },
+        activeId && activeItem ? /* @__PURE__ */ import_react.default.createElement(
+          import_components.SortableTreeItem,
+          {
+            id: activeId,
+            depth: activeItem.depth,
+            clone: true,
+            childCount: (0, import_utilities2.getChildCount)(items, activeId) + 1,
+            item: activeItem,
+            indentationWidth,
+            renderItem
+          }
+        ) : null
+      ),
+      document.body
+    ))
+  );
+  function handleDragStart({ active: { id: activeId2 } }) {
+    setActiveId(activeId2);
+    setOverId(activeId2);
+    document.body.style.setProperty("cursor", "grabbing");
+  }
+  function handleDragMove({ delta }) {
+    setOffsetLeft(delta.x);
+  }
+  function handleDragOver({ over }) {
+    setOverId((over == null ? void 0 : over.id) ?? null);
+  }
+  function handleDragEnd({ active, over }) {
+    resetState();
+    if (projected && over) {
+      const { depth, parentId } = projected;
+      const clonedItems = JSON.parse(
+        JSON.stringify((0, import_utilities2.flattenTree)(items))
+      );
+      const overIndex = clonedItems.findIndex(({ id }) => id === over.id);
+      const activeIndex = clonedItems.findIndex(({ id }) => id === active.id);
+      const activeTreeItem = clonedItems[activeIndex];
+      clonedItems[activeIndex] = { ...activeTreeItem, depth, parentId };
+      const sortedItems = (0, import_sortable.arrayMove)(clonedItems, activeIndex, overIndex);
+      const newItems = (0, import_utilities2.buildTree)(sortedItems);
+      setItems(newItems);
+      onChange == null ? void 0 : onChange(newItems);
+    }
+  }
+  function handleDragCancel() {
+    resetState();
+  }
+  function resetState() {
+    setOverId(null);
+    setActiveId(null);
+    setOffsetLeft(0);
+    document.body.style.setProperty("cursor", "");
+  }
+  async function handleRemove(item) {
+    if (onRemoveBefore) {
+      let res = await (onRemoveBefore == null ? void 0 : onRemoveBefore(item));
+      if (!res) {
+        return;
+      }
+    }
+    setItems((items2) => (0, import_utilities2.removeItem)(items2, item.id));
+    onChange == null ? void 0 : onChange(items);
+  }
+  function handleCollapse(id) {
+    setItems(
+      (items2) => (0, import_utilities2.setProperty)(items2, id, "collapsed", (value2) => {
+        return !value2;
+      })
+    );
+  }
+}
+var adjustTranslate = ({ transform }) => {
+  return {
+    ...transform,
+    y: transform.y - 25
+  };
+};
+var Demo = () => {
+  return /* @__PURE__ */ import_react.default.createElement(SortableTree, null);
+};
+var pisellDraggable_default = Demo;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SortableTree
+});

package/lib/components/pisellDraggable/types.d.ts

@@ -0,0 +1,17 @@
+import type { MutableRefObject } from 'react';
+import type { UniqueIdentifier } from '@dnd-kit/core';
+export interface TreeItem {
+    id: UniqueIdentifier;
+    children: TreeItem[];
+    collapsed?: boolean;
+}
+export declare type TreeItems = TreeItem[];
+export interface FlattenedItem extends TreeItem {
+    parentId: UniqueIdentifier | null;
+    depth: number;
+    index: number;
+}
+export declare type SensorContext = MutableRefObject<{
+    items: FlattenedItem[];
+    offset: number;
+}>;

package/lib/components/pisellDraggable/types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/pisellDraggable/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/components/pisellDraggable/utilities.d.ts

@@ -0,0 +1,17 @@
+import type { UniqueIdentifier } from '@dnd-kit/core';
+import type { FlattenedItem, TreeItem, TreeItems } from './types';
+export declare const iOS: boolean;
+export declare function getProjection(items: FlattenedItem[], activeId: UniqueIdentifier, overId: UniqueIdentifier, dragOffset: number, indentationWidth: number): {
+    depth: number;
+    maxDepth: number;
+    minDepth: number;
+    parentId: UniqueIdentifier | null;
+};
+export declare function flattenTree(items: TreeItems): FlattenedItem[];
+export declare function buildTree(flattenedItems: FlattenedItem[]): TreeItems;
+export declare function findItem(items: TreeItem[], itemId: UniqueIdentifier): TreeItem | undefined;
+export declare function findItemDeep(items: TreeItems, itemId: UniqueIdentifier): TreeItem | undefined;
+export declare function removeItem(items: TreeItems, id: UniqueIdentifier): TreeItem[];
+export declare function setProperty<T extends keyof TreeItem>(items: TreeItems, id: UniqueIdentifier, property: T, setter: (value: TreeItem[T]) => TreeItem[T]): TreeItem[];
+export declare function getChildCount(items: TreeItems, id: UniqueIdentifier): number;
+export declare function removeChildrenOf(items: FlattenedItem[], ids: UniqueIdentifier[]): FlattenedItem[];