@pisell/materials 6.0.10 → 6.0.12

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[];

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/pisellLayout/content.d.ts

@@ -0,0 +1,8 @@
+import type { LayoutProps } from 'antd';
+import React from 'react';
+export interface PisellContentProps extends Omit<LayoutProps, 'prefixCls'> {
+    children?: React.ReactNode;
+    __designMode?: string;
+}
+declare const PisellContent: React.FC<PisellContentProps>;
+export default PisellContent;

package/lib/components/pisellLayout/content.js

@@ -0,0 +1,50 @@
+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/pisellLayout/content.tsx
+var content_exports = {};
+__export(content_exports, {
+  default: () => content_default
+});
+module.exports = __toCommonJS(content_exports);
+var import_antd = require("antd");
+var import_react = __toESM(require("react"));
+var import_useEngineContext = __toESM(require("../../hooks/useEngineContext"));
+var { Content } = import_antd.Layout;
+var PisellContent = (props) => {
+  const { children, ...rest } = props;
+  const lowCodeProps = (0, import_useEngineContext.default)();
+  const pageContent = (0, import_react.useMemo)(() => {
+    if (props.__designMode === "design") {
+      return "Page content";
+    }
+    return lowCodeProps.children;
+  }, [props.__designMode]);
+  return /* @__PURE__ */ import_react.default.createElement(Content, { ...rest }, children, pageContent);
+};
+var content_default = PisellContent;

package/lib/components/pisellLayout/footer.d.ts

@@ -0,0 +1,7 @@
+import type { LayoutProps } from 'antd';
+import React from 'react';
+export interface PisellFooterProps extends Omit<LayoutProps, 'prefixCls'> {
+    children?: React.ReactNode;
+}
+declare const PisellFooter: React.FC<PisellFooterProps>;
+export default PisellFooter;

package/lib/components/pisellLayout/footer.js

@@ -0,0 +1,42 @@
+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/pisellLayout/footer.tsx
+var footer_exports = {};
+__export(footer_exports, {
+  default: () => footer_default
+});
+module.exports = __toCommonJS(footer_exports);
+var import_antd = require("antd");
+var import_react = __toESM(require("react"));
+var { Footer } = import_antd.Layout;
+var PisellFooter = (props) => {
+  const { children, ...rest } = props;
+  return /* @__PURE__ */ import_react.default.createElement(Footer, { ...rest }, children);
+};
+var footer_default = PisellFooter;

package/lib/components/pisellLayout/header.d.ts

@@ -0,0 +1,7 @@
+import type { LayoutProps } from 'antd';
+import React from 'react';
+export interface PisellHeaderProps extends Omit<LayoutProps, 'prefixCls'> {
+    children?: React.ReactNode;
+}
+declare const PisellHeader: React.FC<PisellHeaderProps>;
+export default PisellHeader;

package/lib/components/pisellLayout/header.js

@@ -0,0 +1,42 @@
+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/pisellLayout/header.tsx
+var header_exports = {};
+__export(header_exports, {
+  default: () => header_default
+});
+module.exports = __toCommonJS(header_exports);
+var import_antd = require("antd");
+var import_react = __toESM(require("react"));
+var { Header } = import_antd.Layout;
+var PisellHeader = (props) => {
+  const { children, ...rest } = props;
+  return /* @__PURE__ */ import_react.default.createElement(Header, { ...rest }, children);
+};
+var header_default = PisellHeader;