@pisell/materials 6.0.19 → 6.0.20

package/lib/components/pisellAnchor/index.js

@@ -0,0 +1,251 @@
+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/pisellAnchor/index.tsx
+var pisellAnchor_exports = {};
+__export(pisellAnchor_exports, {
+  default: () => pisellAnchor_default
+});
+module.exports = __toCommonJS(pisellAnchor_exports);
+var import_react = __toESM(require("react"));
+var import_classnames = __toESM(require("classnames"));
+var import_ahooks = require("ahooks");
+var import_ChevronLeft = __toESM(require("@pisell/icon/es/ChevronLeft"));
+var import_ChevronRight = __toESM(require("@pisell/icon/es/ChevronRight"));
+var import_index = require("./index.less");
+var PisellAnchor = (0, import_react.forwardRef)((props, ref) => {
+  const {
+    options = [],
+    tab,
+    className,
+    style,
+    onChange,
+    onTabClick,
+    containerRef,
+    platform = "pc"
+  } = props;
+  const contentRef = (0, import_react.useRef)(null);
+  const scrollTimeoutRef = (0, import_react.useRef)(null);
+  const isClickScrolling = (0, import_react.useRef)(false);
+  const clickedTabRef = (0, import_react.useRef)(null);
+  const [leftWidth, setLeftWidth] = (0, import_react.useState)(0);
+  const [rightWidth, setRightWidth] = (0, import_react.useState)(40);
+  const [showButtons, setShowButtons] = (0, import_react.useState)(false);
+  const [hoveredTab, setHoveredTab] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    if (contentRef.current) {
+      const { scrollWidth, clientWidth } = contentRef.current;
+      setShowButtons(scrollWidth > clientWidth);
+    }
+  }, [options]);
+  (0, import_react.useEffect)(() => {
+    return () => {
+      if (scrollTimeoutRef.current) {
+        clearTimeout(scrollTimeoutRef.current);
+      }
+    };
+  }, []);
+  const { run: onScrollDebounced } = (0, import_ahooks.useDebounceFn)(
+    (e) => {
+      const { scrollLeft, scrollWidth, clientWidth } = e.target;
+      setLeftWidth(scrollLeft > 0 ? 40 : 0);
+      setRightWidth(scrollLeft + clientWidth >= scrollWidth ? 0 : 40);
+    },
+    { wait: 200 }
+  );
+  const { run: handleScrollThrottled } = (0, import_ahooks.useThrottleFn)(
+    () => {
+      if (isClickScrolling.current) return;
+      if (!(containerRef == null ? void 0 : containerRef.current)) return;
+      const container = containerRef.current;
+      const headerHeight = 65;
+      const containerRect = container.getBoundingClientRect();
+      const scrollTop = container.scrollTop;
+      const containerHeight = containerRect.height;
+      const scrollHeight = container.scrollHeight;
+      const isAtBottom = scrollTop + containerHeight >= scrollHeight - 50;
+      if (isAtBottom) {
+        const lastOption = options[options.length - 1];
+        if (tab !== lastOption.id && lastOption.id !== clickedTabRef.current) {
+          onChange == null ? void 0 : onChange(lastOption.id);
+        }
+        return;
+      }
+      let closestOption = null;
+      let minDistance = Infinity;
+      for (const option of options) {
+        const elementById = document.getElementById(option.id);
+        const elementByDataAttr = document.querySelector(`[data-section="${option.id}"]`);
+        const element = elementById || elementByDataAttr;
+        if (element) {
+          const htmlElement = element;
+          const elementOffsetTop = htmlElement.offsetTop;
+          const elementHeight = htmlElement.offsetHeight;
+          const elementTopRelativeToViewport = elementOffsetTop - scrollTop;
+          const isTopVisible = elementTopRelativeToViewport >= headerHeight && elementTopRelativeToViewport <= containerHeight;
+          const isBottomVisible = elementTopRelativeToViewport + elementHeight >= headerHeight && elementTopRelativeToViewport + elementHeight <= containerHeight;
+          const isElementPartiallyVisible = isTopVisible || isBottomVisible || elementTopRelativeToViewport < headerHeight && elementTopRelativeToViewport + elementHeight > containerHeight;
+          const distance = Math.abs(elementTopRelativeToViewport - headerHeight);
+          if (distance < minDistance) {
+            minDistance = distance;
+            closestOption = option;
+          }
+        }
+      }
+      if (closestOption && tab !== closestOption.id && closestOption.id !== clickedTabRef.current && minDistance < 50) {
+        onChange == null ? void 0 : onChange(closestOption.id);
+      }
+    },
+    { wait: 150 }
+  );
+  (0, import_react.useEffect)(() => {
+    if (!(containerRef == null ? void 0 : containerRef.current)) return;
+    const handleScroll = () => {
+      if (!isClickScrolling.current) {
+        handleScrollThrottled();
+      }
+    };
+    const container = containerRef.current;
+    container.addEventListener("scroll", handleScroll);
+    return () => {
+      container.removeEventListener("scroll", handleScroll);
+    };
+  }, [handleScrollThrottled]);
+  const handleOptionClick = (item) => {
+    console.log("PisellAnchor: Tab clicked", item.id);
+    if (scrollTimeoutRef.current) {
+      clearTimeout(scrollTimeoutRef.current);
+    }
+    onChange == null ? void 0 : onChange(item.id);
+    onTabClick == null ? void 0 : onTabClick();
+    const elementById = document.getElementById(String(item.id));
+    const elementByDataAttr = document.querySelector(`[data-section="${String(item.id)}"]`);
+    const element = elementById || elementByDataAttr;
+    console.log("PisellAnchor: Target element found?", !!element);
+    console.log("PisellAnchor: Container ref exists?", !!(containerRef == null ? void 0 : containerRef.current));
+    if (element && (containerRef == null ? void 0 : containerRef.current)) {
+      isClickScrolling.current = true;
+      clickedTabRef.current = item.id;
+      requestAnimationFrame(() => {
+        if (!(containerRef == null ? void 0 : containerRef.current)) return;
+        const htmlElement = element;
+        const headerHeight = 65;
+        const elementOffsetTop = htmlElement.offsetTop;
+        console.log("PisellAnchor: Scrolling using offsetTop", {
+          elementOffsetTop,
+          targetScrollTop: elementOffsetTop - headerHeight
+        });
+        containerRef.current.scrollTo({
+          top: elementOffsetTop - headerHeight,
+          behavior: "smooth"
+        });
+        setTimeout(() => {
+          if (!(containerRef == null ? void 0 : containerRef.current)) return;
+          containerRef.current.scrollTo({
+            top: elementOffsetTop - headerHeight,
+            behavior: "auto"
+            // 使用即时滚动确保位置准确
+          });
+        }, 300);
+      });
+      scrollTimeoutRef.current = setTimeout(() => {
+        isClickScrolling.current = false;
+        clickedTabRef.current = null;
+      }, 1e3);
+    } else {
+      console.warn("PisellAnchor: Cannot scroll, element or container not found", {
+        elementId: item.id,
+        elementByIdExists: !!elementById,
+        elementByDataAttrExists: !!elementByDataAttr,
+        containerExists: !!(containerRef == null ? void 0 : containerRef.current)
+      });
+    }
+  };
+  const onPageChange = (type) => {
+    if (contentRef.current) {
+      const { scrollLeft, clientWidth } = contentRef.current;
+      const newScrollLeft = scrollLeft + (type === "left" ? -clientWidth : clientWidth);
+      contentRef.current.scrollTo({
+        left: newScrollLeft,
+        behavior: "smooth"
+      });
+    }
+  };
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)("pisell-anchor-tabs", className), style }, showButtons && /* @__PURE__ */ import_react.default.createElement(
+    "div",
+    {
+      className: "pisell-anchor-tabs-btn-left",
+      style: { width: leftWidth },
+      onClick: () => onPageChange("left")
+    },
+    /* @__PURE__ */ import_react.default.createElement(import_ChevronLeft.default, { className: "pisell-anchor-tabs-btn-icon" })
+  ), /* @__PURE__ */ import_react.default.createElement(
+    "div",
+    {
+      ref: contentRef,
+      className: "pisell-anchor-tabs-content",
+      id: `tab-${tab}-content`,
+      onScroll: onScrollDebounced
+    },
+    options.map((item) => /* @__PURE__ */ import_react.default.createElement(
+      "div",
+      {
+        key: item.id,
+        id: `tab-${item.id}`,
+        className: (0, import_classnames.default)("pisell-anchor-tabs-tab", {
+          "pisell-anchor-tabs-tab-active": tab === item.id
+        }),
+        onClick: () => {
+          console.log("PisellAnchor: Tab div clicked", item.id);
+          handleOptionClick(item);
+        }
+      },
+      /* @__PURE__ */ import_react.default.createElement(
+        "span",
+        {
+          className: "pisell-anchor-tabs-tab-content",
+          onClick: (e) => {
+            e.stopPropagation();
+            console.log("PisellAnchor: Tab span clicked", item.id);
+            handleOptionClick(item);
+          }
+        },
+        item.name
+      )
+    ))
+  ), showButtons && /* @__PURE__ */ import_react.default.createElement(
+    "div",
+    {
+      className: "pisell-anchor-tabs-btn-right",
+      style: { width: rightWidth },
+      onClick: () => onPageChange("right")
+    },
+    /* @__PURE__ */ import_react.default.createElement(import_ChevronRight.default, { className: "pisell-anchor-tabs-btn-icon" })
+  ));
+});
+var pisellAnchor_default = PisellAnchor;

package/lib/components/pisellAnchor/index.less

@@ -0,0 +1,197 @@
+.pisell-anchor-containers {
+  // display: flex;
+  // align-items: center;
+  // background-color: #fff;
+  // height: 40px;
+  .pisell-lowcode-anchor-wrapper {
+    &::before {
+      content: '';
+      display: none;
+    }
+    .pisell-lowcode-anchor {
+      height: 40px;
+      border-bottom: none !important;
+      background-color: #fff;
+
+      .pisell-lowcode-anchor-ink {
+        display: none;
+      }
+
+      .pisell-lowcode-anchor-link {
+        height: 100%;
+        padding: 0 16px;
+        display: flex;
+        align-items: center;
+
+        &-title {
+          color: var(--Gray-900, #101828);
+          font-family: Inter;
+          font-size: 16px;
+          font-weight: 600;
+          line-height: 40px;
+        }
+      }
+
+      .pisell-lowcode-anchor-link-active {
+        border-radius: 100px;
+        background: var(--theme-color, #7f56d9);
+        height: 40px;
+
+        .pisell-lowcode-anchor-link-title {
+          color: var(--White, #fff);
+          line-height: 40px;
+        }
+      }
+    }
+  }
+  .pisell-anchor-scroll {
+    height: 40px;
+    flex: 1;
+    overflow-x: auto;
+
+    // 隐藏滚动条 - Firefox
+    scrollbar-width: none;
+
+    // 隐藏滚动条 - IE and Edge
+    -ms-overflow-style: none;
+
+    // 隐藏滚动条 - Chrome, Safari, Opera
+    &::-webkit-scrollbar {
+      display: none;
+    }
+  }
+
+  .pisell-anchor-buttons {
+    display: flex;
+    gap: 8px;
+    margin-left: 16px;
+
+    .scroll-button {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      width: 24px;
+      height: 24px;
+      border: 1px solid #d9d9d9;
+      border-radius: 4px;
+      background: white;
+      cursor: pointer;
+      transition: all 0.3s;
+
+      &:hover:not(.disabled) {
+        color: #1890ff;
+        border-color: #1890ff;
+      }
+
+      &.disabled {
+        color: #d9d9d9;
+        cursor: not-allowed;
+        background: #f5f5f5;
+      }
+    }
+  }
+}
+
+.pisell-anchor-tabs {
+  display: flex;
+  align-items: center;
+  width: 100%;
+  height: 100%;
+  font-size: 17px;
+  font-weight: 400;
+  color: #0d1619;
+  cursor: default;
+  position: relative;
+
+  .pisell-anchor-tabs-btn-left,
+  .pisell-anchor-tabs-btn-right {
+    position: absolute;
+    top: 50%;
+    transform: translateY(-50%);
+    z-index: 1;
+    width: 40px;
+    height: 40px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: linear-gradient(90deg, #fff 30%, rgba(255, 255, 255, 0.8) 100%);
+    cursor: pointer;
+    transition: width 300ms ease;
+    user-select: none;
+
+    .pisell-anchor-tabs-btn-icon {
+      width: 24px;
+      height: 24px;
+      background: #f1f1f1;
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      color: #262626;
+      font-size: 20px;
+    }
+  }
+
+  .pisell-anchor-tabs-btn-left {
+    left: 0;
+    background: linear-gradient(270deg, rgba(255, 255, 255, 0.8) 0%, #fff 70%);
+  }
+
+  .pisell-anchor-tabs-btn-right {
+    right: 0;
+    background: linear-gradient(90deg, rgba(255, 255, 255, 0.8) 0%, #fff 70%);
+  }
+
+  .pisell-anchor-tabs-content {
+    flex: 1;
+    display: flex;
+    overflow-x: auto;
+    overflow-y: hidden;
+    scroll-behavior: smooth;
+    -webkit-overflow-scrolling: touch;
+    scrollbar-width: none;
+    -ms-overflow-style: none;
+    padding: 0;
+    gap: 16px;
+
+    &::-webkit-scrollbar {
+      display: none;
+    }
+
+    .pisell-anchor-tabs-tab {
+      flex: 0 0 auto;
+      padding: 0 16px;
+      cursor: pointer;
+      white-space: nowrap;
+      transition: all 0.3s;
+      height: 48px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 16px;
+      border-radius: 100px;
+
+      &:hover:not(.pisell-anchor-tabs-tab-active) {
+        color: var(--theme-color, #7f56d9);
+      }
+
+      &.pisell-anchor-tabs-tab-active {
+        color: #fff;
+        font-weight: 600;
+        background-color: var(--theme-color, #7f56d9);
+      }
+
+      .pisell-anchor-tabs-tab-content {
+        line-height: 24px;
+      }
+    }
+  }
+}
+
+.pisell-anchor {
+  border-bottom: 1px solid #EAECF0;
+
+  &.pisell-anchor-no-border {
+    border-bottom: none;
+  }
+}

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

@@ -1,4 +1,3 @@
-import React from 'react';
 import { CardProps } from 'antd';
 import './index.less';
 export interface PisellCardProps extends CardProps {
@@ -8,5 +7,5 @@ export interface PisellCardProps extends CardProps {
  * @param props
  * @constructor
  */
-declare const PisellCard: (props: PisellCardProps) => React.JSX.Element;
+declare const PisellCard: (props: PisellCardProps) => JSX.Element;
 export default PisellCard;

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

@@ -39,5 +39,5 @@ export interface PisellCardListProps extends Omit<PisellCheckboxGroupProps, 'opt
     /** 是否余额货币单位 */
     showBalanceSymbol?: boolean;
 }
-declare const _default: React.MemoExoticComponent<(props: PisellCardListProps) => React.JSX.Element>;
+declare const _default: React.MemoExoticComponent<(props: PisellCardListProps) => JSX.Element>;
 export default _default;

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

@@ -30,5 +30,5 @@ export interface PisellCheckboxGroupProps extends React.HTMLAttributes<HTMLDivEl
  * @Author: zhiwei.Wang
  * @Date: 2024-08-16 10:34
  */
-declare const PisellCheckboxGroup: (props: PisellCheckboxGroupProps) => React.JSX.Element;
+declare const PisellCheckboxGroup: (props: PisellCheckboxGroupProps) => JSX.Element;
 export default PisellCheckboxGroup;

package/lib/components/pisellCheckboxGroup/index.js

@@ -122,8 +122,7 @@ var PisellCheckboxGroup = (props) => {
           key: option[rowKey],
           gap: 10,
           onClick: () => {
-            if (option.disabled)
-              return;
+            if (option.disabled) return;
             handleSelectItem(option[rowKey], option);
           },
           leftContent: iconPosition === "left" && /* @__PURE__ */ import_react.default.createElement(

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

@@ -20,5 +20,5 @@ export declare type PisellCountdownProps = React.HTMLAttributes<HTMLSpanElement>
     /** 格式化倒计时展示 参考 dayjs */
     format?: string;
 };
-declare const PisellCountdown: (props: PisellCountdownProps) => React.JSX.Element;
+declare const PisellCountdown: (props: PisellCountdownProps) => JSX.Element;
 export default PisellCountdown;

package/lib/components/pisellDatePicker/datePickerCpt.d.ts

@@ -1,4 +1,3 @@
-import React from 'react';
 import { PickerDateProps } from 'antd/es/date-picker/generatePicker';
 import { Dayjs } from 'dayjs';
 import './detePickerCpt.less';
@@ -18,5 +17,5 @@ export interface DatePickerCptProps extends PickerDateProps<Dayjs> {
  * @param props
  * @constructor
  */
-declare const DatePickerCpt: (props: DatePickerCptProps) => React.JSX.Element;
+declare const DatePickerCpt: (props: DatePickerCptProps) => JSX.Element;
 export default DatePickerCpt;

package/lib/components/pisellDatePicker/datePickerCpt.js

@@ -66,8 +66,7 @@ var DatePickerInput = (props) => {
     let lastIndex = 0;
     for (let i = 0; i < parts.length; i++) {
       const part = parts[i];
-      if (!part)
-        continue;
+      if (!part) continue;
       const separator = separators[i] || "";
       const expectedLength = part.length;
       lastIndex = lastIndex + part.length + separator.length;

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

@@ -1,3 +1,2 @@
-/// <reference types="react" />
-declare const PisellDatePicker: (props: any) => import("react").JSX.Element;
+declare const PisellDatePicker: (props: any) => JSX.Element;
 export default PisellDatePicker;

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

@@ -1,3 +1,3 @@
-import React from 'react';
+/// <reference types="react" />
 import { ActionProps } from '../Action';
-export declare function Remove(props: ActionProps): React.JSX.Element;
+export declare function Remove(props: ActionProps): JSX.Element;

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

@@ -1,9 +1,9 @@
+/// <reference types="react" />
 import type { UniqueIdentifier } from '@dnd-kit/core';
-import React from 'react';
 import { Props as TreeItemProps } from './TreeItem';
 interface Props extends TreeItemProps {
     id: UniqueIdentifier;
     __designMode?: string;
 }
-export declare function SortableTreeItem({ id, depth, ...props }: Props): React.JSX.Element;
+export declare function SortableTreeItem({ id, depth, ...props }: Props): JSX.Element;
 export {};

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

@@ -27,6 +27,6 @@ interface Props {
     /** 最大层级 */
     maxLevel?: number;
 }
-export declare function SortableTree({ collapsible, value, indicator, indentationWidth, removable, renderItem, onChange, onRemoveBefore, __designMode, maxLevel, }: Props): React.JSX.Element;
-declare const Demo: (props: Props) => React.JSX.Element;
+export declare function SortableTree({ collapsible, value, indicator, indentationWidth, removable, renderItem, onChange, onRemoveBefore, __designMode, maxLevel, }: Props): JSX.Element;
+declare const Demo: (props: Props) => JSX.Element;
 export default Demo;

package/lib/components/pisellDraggable/index.js

@@ -155,13 +155,10 @@ function SortableTree({
   }, []);
   function checkSubtreeDepth(items2, itemId, baseDepth) {
     const item = items2.find((i) => i.id === itemId);
-    if (!item)
-      return false;
-    if (baseDepth >= maxLevel)
-      return true;
+    if (!item) return false;
+    if (baseDepth >= maxLevel) return true;
     const children = items2.filter((i) => i.parentId === itemId);
-    if (baseDepth >= maxLevel - 1 && children.length > 0)
-      return true;
+    if (baseDepth >= maxLevel - 1 && children.length > 0) return true;
     return children.some((child) => {
       const childNewDepth = baseDepth + 1;
       return childNewDepth >= maxLevel || checkSubtreeDepth(items2, child.id, childNewDepth);

package/lib/components/pisellDropSort/components/SortableItem/index.d.ts

@@ -21,5 +21,5 @@ interface SortableItemProps {
     /** 获取item样式 */
     getItemStyle?: (itemProps: TreeItem) => React.CSSProperties;
 }
-declare const SortableItem: (props: SortableItemProps) => React.JSX.Element;
+declare const SortableItem: (props: SortableItemProps) => JSX.Element;
 export default SortableItem;

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

@@ -14,5 +14,5 @@ export interface PisellEmptyProps extends EmptyProps {
     /** 最大宽度 */
     maxWidth?: number;
 }
-declare const PisellEmpty: (props: PisellEmptyProps) => React.JSX.Element;
+declare const PisellEmpty: (props: PisellEmptyProps) => JSX.Element;
 export default PisellEmpty;

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

@@ -13,5 +13,5 @@ export interface PisellFloatingPanelProps {
     style?: React.CSSProperties;
     retractIconStyle?: React.CSSProperties;
 }
-declare const PisellFloatingPanel: (props: PisellFloatingPanelProps) => React.JSX.Element;
+declare const PisellFloatingPanel: (props: PisellFloatingPanelProps) => JSX.Element;
 export default PisellFloatingPanel;

package/lib/components/pisellInformationEntry/Input/index.d.ts

@@ -4,5 +4,5 @@ export interface PisellEntryInputProps {
     onChange: (val: string) => void;
     searchDescribe?: React.ReactNode;
 }
-declare const PisellEntryInput: (props: PisellEntryInputProps) => React.JSX.Element;
+declare const PisellEntryInput: (props: PisellEntryInputProps) => JSX.Element;
 export default PisellEntryInput;

package/lib/components/pisellInformationEntry/Scan/index.d.ts

@@ -1,8 +1,7 @@
-import React from 'react';
 import './index.less';
 export interface ScanProps {
     onChange: (val: string) => void;
     onCancel: () => void;
 }
-declare const Scan: (props: ScanProps) => React.JSX.Element;
+declare const Scan: (props: ScanProps) => JSX.Element;
 export default Scan;

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

@@ -27,5 +27,5 @@ export interface PisellInformationEntryProps extends Omit<React.HTMLAttributes<H
     /** 录入信息值改变 */
     onChange?: (val: string) => void;
 }
-declare const PisellInformationEntry: (props: PisellInformationEntryProps) => React.JSX.Element;
+declare const PisellInformationEntry: (props: PisellInformationEntryProps) => JSX.Element;
 export default PisellInformationEntry;

package/lib/components/pisellInput/components/BankCard/index.d.ts

@@ -1,4 +1,3 @@
-import React from 'react';
 import { InputProps } from 'antd';
 import { PisellContextType } from "../../../pisell-config-provider/context";
 import './index.less';
@@ -7,5 +6,5 @@ export declare type BankCardProps = InputProps & {
     platform?: PisellContextType['platform'];
     onChange?: (val: string) => void;
 };
-declare const BankCard: (props: BankCardProps) => React.JSX.Element;
+declare const BankCard: (props: BankCardProps) => JSX.Element;
 export default BankCard;

package/lib/components/pisellInput/components/Copy/index.d.ts

@@ -1,4 +1,3 @@
-import React from 'react';
 import { InputProps, ButtonProps } from 'antd';
 import { PisellContextType } from "../../../pisell-config-provider/context";
 export interface CopyProps extends InputProps {
@@ -7,5 +6,5 @@ export interface CopyProps extends InputProps {
     /** 后缀button的透传配置 */
     buttonProps?: ButtonProps;
 }
-declare const Copy: (props: CopyProps) => React.JSX.Element;
+declare const Copy: (props: CopyProps) => JSX.Element;
 export default Copy;

package/lib/components/pisellInput/components/SecurityCode/index.d.ts

@@ -1,4 +1,3 @@
-import React from 'react';
 import { InputProps } from 'antd';
 import './index.less';
 import { PisellContextType } from "../../../pisell-config-provider/context";
@@ -8,5 +7,5 @@ export interface SecurityCodeProps extends Omit<InputProps, 'onChange'> {
     onChange?: (val: string) => void;
     showCVCIcon?: boolean;
 }
-declare const SecurityCode: (props: SecurityCodeProps) => React.JSX.Element;
+declare const SecurityCode: (props: SecurityCodeProps) => JSX.Element;
 export default SecurityCode;