@pisell/materials 1.0.605 → 1.0.607

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

@@ -1,3 +1,27 @@
-import PisellDraggable from './PisellDraggable';
-export type { DraggableItem, PisellDraggableProps } from './types';
-export default PisellDraggable;
+/**
+ * 可拖拽树形组件
+ * 基于@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

@@ -29,8 +29,243 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/components/pisellDraggable/index.tsx
 var pisellDraggable_exports = {};
 __export(pisellDraggable_exports, {
+  SortableTree: () => SortableTree,
   default: () => pisellDraggable_default
 });
 module.exports = __toCommonJS(pisellDraggable_exports);
-var import_PisellDraggable = __toESM(require("./PisellDraggable"));
-var pisellDraggable_default = import_PisellDraggable.default;
+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

@@ -1,101 +1,17 @@
-import { CSSProperties, ReactNode } from 'react';
-/**
- * 可拖拽项的数据结构
- */
-export interface DraggableItem {
-    /** 唯一标识符 */
-    id: string | number;
-    /** 渲染的内容 */
-    content: ReactNode;
-    /** 子项列表 */
-    children?: DraggableItem[];
-    /** 父项ID */
-    parentId?: string | number;
-    /** 排序顺序 */
-    order?: number;
-    /** 当前项的层级（从0开始） */
-    level?: number;
+import type { MutableRefObject } from 'react';
+import type { UniqueIdentifier } from '@dnd-kit/core';
+export interface TreeItem {
+    id: UniqueIdentifier;
+    children: TreeItem[];
+    collapsed?: boolean;
 }
-/**
- * PisellDraggable 组件的属性定义
- */
-export interface PisellDraggableProps {
-    /** 自定义类名 */
-    className?: string;
-    /** 自定义样式 */
-    style?: CSSProperties;
-    /** 拖拽项数据列表 */
-    items: DraggableItem[];
-    /**
-     * 布局方向
-     * - vertical: 垂直排列（默认）
-     * - horizontal: 水平排列
-     * - grid: 网格布局
-     */
-    direction?: 'horizontal' | 'vertical' | 'grid';
-    /** 网格布局时的列数（仅在 direction='grid' 时生效） */
-    columns?: number;
-    /** 是否允许跨容器拖拽 */
-    allowCrossContainer?: boolean;
-    /**
-     * 拖拽开始时的回调
-     * @param activeId 被拖拽项的ID
-     */
-    onDragStart?: (activeId: string | number) => void;
-    /**
-     * 拖拽结束时的回调
-     * @param result 包含拖拽项和目标项的信息
-     */
-    onDragEnd?: (result: {
-        active: DraggableItem;
-        over: DraggableItem | null;
-    }) => void;
-    /**
-     * 数据变化时的回调
-     * @param items 更新后的数据列表
-     */
-    onChange?: (items: DraggableItem[]) => void;
-    /**
-     * 自定义渲染拖拽项
-     * @param item 当前项的数据
-     */
-    renderItem?: (item: DraggableItem) => ReactNode;
-    /** 拖拽手柄的自定义类名 */
-    handleClassName?: string;
-    /** 容器的自定义样式 */
-    containerStyle?: CSSProperties;
-    /** 是否禁用拖拽功能 */
-    disabled?: boolean;
-    /** 动画持续时间（毫秒） */
-    animationDuration?: number;
-    /**
-     * 拖动方式
-     * - handle: 仅通过手柄拖动（默认）
-     * - item: 整个项目可拖动
-     */
-    dragMode?: 'handle' | 'item';
-    /** 嵌套层级的缩进距离（像素） */
-    indentDistance?: number;
-    /**
-     * 最大嵌套深度
-     * - 0: 不限制深度（默认）
-     * - n: 最多允许n层嵌套
-     */
-    maxDepth?: number;
-    /**
-     * 自定义层级样式
-     * 可以为不同层级设置不同的样式，key为层级数（从0开始）
-     */
-    levelStyles?: Record<number, CSSProperties>;
-    /** 拖拽手柄的自定义图标 */
-    handleIcon?: ReactNode;
-    /**
-     * 拖拽时的动画曲线
-     * 支持 CSS transition-timing-function 的所有值
-     */
-    animationTiming?: 'ease' | 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
-    /** 拖拽时的缩放比例 */
-    dragScale?: number;
-    /** 当前嵌套层级（内部使用） */
-    currentLevel?: number;
+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/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[];

package/lib/components/pisellDraggable/utilities.js

@@ -0,0 +1,190 @@
+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/utilities.ts
+var utilities_exports = {};
+__export(utilities_exports, {
+  buildTree: () => buildTree,
+  findItem: () => findItem,
+  findItemDeep: () => findItemDeep,
+  flattenTree: () => flattenTree,
+  getChildCount: () => getChildCount,
+  getProjection: () => getProjection,
+  iOS: () => iOS,
+  removeChildrenOf: () => removeChildrenOf,
+  removeItem: () => removeItem,
+  setProperty: () => setProperty
+});
+module.exports = __toCommonJS(utilities_exports);
+var import_sortable = require("@dnd-kit/sortable");
+var iOS = /iPad|iPhone|iPod/.test(navigator.platform);
+function getDragDepth(offset, indentationWidth) {
+  return Math.round(offset / indentationWidth);
+}
+function getProjection(items, activeId, overId, dragOffset, indentationWidth) {
+  const overItemIndex = items.findIndex(({ id }) => id === overId);
+  const activeItemIndex = items.findIndex(({ id }) => id === activeId);
+  const activeItem = items[activeItemIndex];
+  const newItems = (0, import_sortable.arrayMove)(items, activeItemIndex, overItemIndex);
+  const previousItem = newItems[overItemIndex - 1];
+  const nextItem = newItems[overItemIndex + 1];
+  const dragDepth = getDragDepth(dragOffset, indentationWidth);
+  const projectedDepth = activeItem.depth + dragDepth;
+  const maxDepth = getMaxDepth({
+    previousItem
+  });
+  const minDepth = getMinDepth({ nextItem });
+  let depth = projectedDepth;
+  if (projectedDepth >= maxDepth) {
+    depth = maxDepth;
+  } else if (projectedDepth < minDepth) {
+    depth = minDepth;
+  }
+  return { depth, maxDepth, minDepth, parentId: getParentId() };
+  function getParentId() {
+    var _a;
+    if (depth === 0 || !previousItem) {
+      return null;
+    }
+    if (depth === previousItem.depth) {
+      return previousItem.parentId;
+    }
+    if (depth > previousItem.depth) {
+      return previousItem.id;
+    }
+    const newParent = (_a = newItems.slice(0, overItemIndex).reverse().find((item) => item.depth === depth)) == null ? void 0 : _a.parentId;
+    return newParent ?? null;
+  }
+}
+function getMaxDepth({ previousItem }) {
+  if (previousItem) {
+    return previousItem.depth + 1;
+  }
+  return 0;
+}
+function getMinDepth({ nextItem }) {
+  if (nextItem) {
+    return nextItem.depth;
+  }
+  return 0;
+}
+function flatten(items, parentId = null, depth = 0) {
+  return items.reduce((acc, item, index) => {
+    return [
+      ...acc,
+      { ...item, parentId, depth, index },
+      ...flatten(item.children, item.id, depth + 1)
+    ];
+  }, []);
+}
+function flattenTree(items) {
+  return flatten(items);
+}
+function buildTree(flattenedItems) {
+  const root = { id: "root", children: [] };
+  const nodes = { [root.id]: root };
+  const items = flattenedItems.map((item) => ({ ...item, children: [] }));
+  for (const item of items) {
+    const { id, children } = item;
+    const parentId = item.parentId ?? root.id;
+    const parent = nodes[parentId] ?? findItem(items, parentId);
+    nodes[id] = { id, children };
+    parent.children.push(item);
+  }
+  return root.children;
+}
+function findItem(items, itemId) {
+  return items.find(({ id }) => id === itemId);
+}
+function findItemDeep(items, itemId) {
+  for (const item of items) {
+    const { id, children } = item;
+    if (id === itemId) {
+      return item;
+    }
+    if (children.length) {
+      const child = findItemDeep(children, itemId);
+      if (child) {
+        return child;
+      }
+    }
+  }
+  return void 0;
+}
+function removeItem(items, id) {
+  const newItems = [];
+  for (const item of items) {
+    if (item.id === id) {
+      continue;
+    }
+    if (item.children.length) {
+      item.children = removeItem(item.children, id);
+    }
+    newItems.push(item);
+  }
+  return newItems;
+}
+function setProperty(items, id, property, setter) {
+  for (const item of items) {
+    if (item.id === id) {
+      item[property] = setter(item[property]);
+      continue;
+    }
+    if (item.children.length) {
+      item.children = setProperty(item.children, id, property, setter);
+    }
+  }
+  return [...items];
+}
+function countChildren(items, count = 0) {
+  return items.reduce((acc, { children }) => {
+    if (children.length) {
+      return countChildren(children, acc + 1);
+    }
+    return acc + 1;
+  }, count);
+}
+function getChildCount(items, id) {
+  const item = findItemDeep(items, id);
+  return item ? countChildren(item.children) : 0;
+}
+function removeChildrenOf(items, ids) {
+  const excludeParentIds = [...ids];
+  return items.filter((item) => {
+    if (item.parentId && excludeParentIds.includes(item.parentId)) {
+      if (item.children.length) {
+        excludeParentIds.push(item.id);
+      }
+      return false;
+    }
+    return true;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildTree,
+  findItem,
+  findItemDeep,
+  flattenTree,
+  getChildCount,
+  getProjection,
+  iOS,
+  removeChildrenOf,
+  removeItem,
+  setProperty
+});

package/lib/components/pisellModal/components/Information/index.js

@@ -44,7 +44,6 @@ var Information = (props) => {
       mobileModalHeight: "auto",
       headerDivider: false,
       footerDivider,
-      size: "small",
       transitionName: "pisell-move-down"
     },
     /* @__PURE__ */ import_react.default.createElement("div", { className: "pisell-modal-information-title" }, title),