@dtjoy/dt-design 1.0.1 → 1.0.3

package/lib/splitter/hooks/useResize.js

@@ -0,0 +1,142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useResize;
+var React = _interopRequireWildcard(require("react"));
+var _useSizes = require("./useSizes");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Handle user drag resize logic.
+ */
+function useResize(items, resizableInfos, percentSizes, containerSize, updateSizes, isRTL) {
+  const limitSizes = items.map(item => [item.min, item.max]);
+  const mergedContainerSize = containerSize || 0;
+  const ptg2px = ptg => ptg * mergedContainerSize;
+
+  // ======================== Resize ========================
+  function getLimitSize(str, defaultLimit) {
+    if (typeof str === 'string') {
+      return ptg2px((0, _useSizes.getPtg)(str));
+    }
+    return str ?? defaultLimit;
+  }
+
+  // Real px sizes
+  const [cacheSizes, setCacheSizes] = React.useState([]);
+  const cacheCollapsedSize = React.useRef([]);
+
+  /**
+   * When start drag, check the direct is `start` or `end`.
+   * This will handle when 2 splitter bar are in the same position.
+   */
+  const [movingIndex, setMovingIndex] = React.useState(null);
+  const getPxSizes = () => percentSizes.map(ptg2px);
+  const onOffsetStart = index => {
+    setCacheSizes(getPxSizes());
+    setMovingIndex({
+      index,
+      confirmed: false
+    });
+  };
+  const onOffsetUpdate = (index, offset) => {
+    // First time trigger move index update is not sync in the state
+    let confirmedIndex = null;
+
+    // We need to know what the real index is.
+    if ((!movingIndex || !movingIndex.confirmed) && offset !== 0) {
+      // Search for the real index
+      if (offset > 0) {
+        confirmedIndex = index;
+        setMovingIndex({
+          index,
+          confirmed: true
+        });
+      } else {
+        for (let i = index; i >= 0; i -= 1) {
+          if (cacheSizes[i] > 0 && resizableInfos[i].resizable) {
+            confirmedIndex = i;
+            setMovingIndex({
+              index: i,
+              confirmed: true
+            });
+            break;
+          }
+        }
+      }
+    }
+    const mergedIndex = confirmedIndex ?? movingIndex?.index ?? index;
+    const numSizes = [...cacheSizes];
+    const nextIndex = mergedIndex + 1;
+
+    // Get boundary
+    const startMinSize = getLimitSize(limitSizes[mergedIndex][0], 0);
+    const endMinSize = getLimitSize(limitSizes[nextIndex][0], 0);
+    const startMaxSize = getLimitSize(limitSizes[mergedIndex][1], mergedContainerSize);
+    const endMaxSize = getLimitSize(limitSizes[nextIndex][1], mergedContainerSize);
+    let mergedOffset = offset;
+
+    // Align with the boundary
+    if (numSizes[mergedIndex] + mergedOffset < startMinSize) {
+      mergedOffset = startMinSize - numSizes[mergedIndex];
+    }
+    if (numSizes[nextIndex] - mergedOffset < endMinSize) {
+      mergedOffset = numSizes[nextIndex] - endMinSize;
+    }
+    if (numSizes[mergedIndex] + mergedOffset > startMaxSize) {
+      mergedOffset = startMaxSize - numSizes[mergedIndex];
+    }
+    if (numSizes[nextIndex] - mergedOffset > endMaxSize) {
+      mergedOffset = numSizes[nextIndex] - endMaxSize;
+    }
+
+    // Do offset
+    numSizes[mergedIndex] += mergedOffset;
+    numSizes[nextIndex] -= mergedOffset;
+    updateSizes(numSizes);
+    return numSizes;
+  };
+  const onOffsetEnd = () => {
+    setMovingIndex(null);
+  };
+
+  // ======================= Collapse =======================
+  const onCollapse = (index, type) => {
+    const currentSizes = getPxSizes();
+    const adjustedType = isRTL ? type === 'start' ? 'end' : 'start' : type;
+    const currentIndex = adjustedType === 'start' ? index : index + 1;
+    const targetIndex = adjustedType === 'start' ? index + 1 : index;
+    const currentSize = currentSizes[currentIndex];
+    const targetSize = currentSizes[targetIndex];
+    if (currentSize !== 0 && targetSize !== 0) {
+      // Collapse directly
+      currentSizes[currentIndex] = 0;
+      currentSizes[targetIndex] += currentSize;
+      cacheCollapsedSize.current[index] = currentSize;
+    } else {
+      const totalSize = currentSize + targetSize;
+      const currentSizeMin = getLimitSize(limitSizes[currentIndex][0], 0);
+      const currentSizeMax = getLimitSize(limitSizes[currentIndex][1], mergedContainerSize);
+      const targetSizeMin = getLimitSize(limitSizes[targetIndex][0], 0);
+      const targetSizeMax = getLimitSize(limitSizes[targetIndex][1], mergedContainerSize);
+      const limitStart = Math.max(currentSizeMin, totalSize - targetSizeMax);
+      const limitEnd = Math.min(currentSizeMax, totalSize - targetSizeMin);
+      const halfOffset = targetSizeMin || (limitEnd - limitStart) / 2;
+      const targetCacheCollapsedSize = cacheCollapsedSize.current[index];
+      const currentCacheCollapsedSize = totalSize - targetCacheCollapsedSize;
+      const shouldUseCache = targetCacheCollapsedSize && targetCacheCollapsedSize <= targetSizeMax && targetCacheCollapsedSize >= targetSizeMin && currentCacheCollapsedSize <= currentSizeMax && currentCacheCollapsedSize >= currentSizeMin;
+      if (shouldUseCache) {
+        currentSizes[targetIndex] = targetCacheCollapsedSize;
+        currentSizes[currentIndex] = currentCacheCollapsedSize;
+      } else {
+        currentSizes[currentIndex] -= halfOffset;
+        currentSizes[targetIndex] += halfOffset;
+      }
+    }
+    updateSizes(currentSizes);
+    return currentSizes;
+  };
+  return [onOffsetStart, onOffsetUpdate, onOffsetEnd, onCollapse, movingIndex?.index];
+}

package/lib/splitter/hooks/useSizes.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PanelProps } from '../interface';
+export declare function getPtg(str: string): number;
+export default function useSizes(items: PanelProps[], containerSize?: number): readonly [(string | number | undefined)[], number[], number[], number[], number[], React.Dispatch<React.SetStateAction<(string | number | undefined)[]>>];

package/lib/splitter/hooks/useSizes.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useSizes;
+exports.getPtg = getPtg;
+var _react = _interopRequireDefault(require("react"));
+var _sizeUtil = require("./sizeUtil");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function getPtg(str) {
+  return Number(str.slice(0, -1)) / 100;
+}
+function isPtg(itemSize) {
+  return typeof itemSize === 'string' && itemSize.endsWith('%');
+}
+function useSizes(items, containerSize) {
+  const propSizes = items.map(item => item.size);
+  const itemsCount = items.length;
+  const mergedContainerSize = containerSize || 0;
+  const ptg2px = ptg => ptg * mergedContainerSize;
+  const [innerSizes, setInnerSizes] = _react.default.useState(() => items.map(item => item.defaultSize));
+  const sizes = _react.default.useMemo(() => {
+    const mergedSizes = [];
+    for (let i = 0; i < itemsCount; i += 1) {
+      mergedSizes[i] = propSizes[i] ?? innerSizes[i];
+    }
+    return mergedSizes;
+  }, [itemsCount, innerSizes, propSizes]);
+  const postPercentMinSizes = _react.default.useMemo(() => items.map(item => {
+    if (isPtg(item.min)) {
+      return getPtg(item.min);
+    }
+    return (item.min || 0) / mergedContainerSize;
+  }), [items, mergedContainerSize]);
+  const postPercentMaxSizes = _react.default.useMemo(() => items.map(item => {
+    if (isPtg(item.max)) {
+      return getPtg(item.max);
+    }
+    return (item.max || mergedContainerSize) / mergedContainerSize;
+  }), [items, mergedContainerSize]);
+  const postPercentSizes = _react.default.useMemo(() => {
+    const ptgList = [];
+    for (let i = 0; i < itemsCount; i += 1) {
+      const itemSize = sizes[i];
+      if (isPtg(itemSize)) {
+        ptgList[i] = getPtg(itemSize);
+      } else if (itemSize || itemSize === 0) {
+        const num = Number(itemSize);
+        if (!Number.isNaN(num)) {
+          ptgList[i] = num / mergedContainerSize;
+        }
+      } else {
+        ptgList[i] = undefined;
+      }
+    }
+    return (0, _sizeUtil.autoPtgSizes)(ptgList, postPercentMinSizes, postPercentMaxSizes);
+  }, [sizes, mergedContainerSize, postPercentMinSizes, postPercentMaxSizes]);
+  const postPxSizes = _react.default.useMemo(() => postPercentSizes.map(ptg2px), [postPercentSizes, mergedContainerSize]);
+  const panelSizes = _react.default.useMemo(() => containerSize ? postPxSizes : sizes, [postPxSizes, containerSize]);
+  return [panelSizes, postPxSizes, postPercentSizes, postPercentMinSizes, postPercentMaxSizes, setInnerSizes];
+}

package/lib/splitter/index.d.ts

@@ -0,0 +1,8 @@
+import Panel from './Panel';
+import SplitterComp from './Splitter';
+export type { SplitterProps } from './interface';
+declare type CompoundedComponent = typeof SplitterComp & {
+    Panel: typeof Panel;
+};
+declare const Splitter: CompoundedComponent;
+export default Splitter;

package/lib/splitter/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Panel = _interopRequireDefault(require("./Panel"));
+var _Splitter = _interopRequireDefault(require("./Splitter"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const Splitter = _Splitter.default;
+Splitter.Panel = _Panel.default;
+var _default = exports.default = Splitter;

package/lib/splitter/interface.d.ts

@@ -0,0 +1,68 @@
+/// <reference types="react" />
+import { ShowCollapsibleIconMode } from './SplitBar';
+export interface SplitterProps {
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    rootClassName?: string;
+    layout?: 'horizontal' | 'vertical';
+    onResizeStart?: (sizes: number[]) => void;
+    onResize?: (sizes: number[]) => void;
+    onResizeEnd?: (sizes: number[]) => void;
+    lazy?: boolean;
+}
+export interface PanelProps {
+    className?: string;
+    style?: React.CSSProperties;
+    min?: number | string;
+    max?: number | string;
+    size?: number | string;
+    collapsible?: boolean | {
+        start?: boolean;
+        end?: boolean;
+        showCollapsibleIcon?: ShowCollapsibleIconMode;
+    };
+    resizable?: boolean;
+    defaultSize?: number | string;
+}
+export interface InternalPanelProps extends PanelProps {
+    className?: string;
+    prefixCls?: string;
+}
+export interface UseResizeProps extends Pick<SplitterProps, 'onResize'> {
+    basicsState: number[];
+    items: PanelProps[];
+    panelsRef: React.RefObject<(HTMLDivElement | null)[]>;
+    reverse: boolean;
+    setBasicsState: React.Dispatch<React.SetStateAction<number[]>>;
+}
+export interface UseResize {
+    setSize: (data: {
+        size: number;
+        index: number;
+    }[]) => void;
+    setOffset: (offset: number, containerSize: number, index: number) => void;
+}
+export interface UseHandleProps extends Pick<SplitterProps, 'layout' | 'onResizeStart' | 'onResizeEnd'> {
+    basicsState: number[];
+    containerRef?: React.RefObject<HTMLDivElement | null>;
+    setOffset: UseResize['setOffset'];
+    setResizing: React.Dispatch<React.SetStateAction<boolean>>;
+}
+export interface UseHandle {
+    onStart: (x: number, y: number, index: number) => void;
+}
+export interface UseCollapsibleProps {
+    basicsState: number[];
+    collapsible?: PanelProps['collapsible'];
+    index: number;
+    reverse: boolean;
+    setSize?: UseResize['setSize'];
+}
+export interface UseCollapsible {
+    nextIcon: boolean;
+    overlap: boolean;
+    previousIcon: boolean;
+    onFold: (type: 'previous' | 'next') => void;
+    setOldBasics: () => void;
+}

package/lib/splitter/interface.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/splitter/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style';
+import './index.less';

package/lib/splitter/style/index.js

@@ -0,0 +1,4 @@
+"use strict";
+
+require("../../style");
+require("./index.less");

package/lib/splitter/style/index.less

@@ -0,0 +1,312 @@
+@import '../../style/themes/index.less';
+        
+@splitter-prefix-cls: ~'@{ant-prefix}-splitter';
+
+@splitter-resize-spinner-size: 20px;
+@splitter-split-bar-draggable-size: @splitter-resize-spinner-size;
+@splitter-split-bar-size: 2px;
+@splitter-split-trigger-size: 6px;
+
+@splitterBarPreviewOffsetVar: ~'@{splitter-prefix-cls}-bar-preview-offset';
+@splitter-transform-x: ~'translateX(var(--@{splitterBarPreviewOffsetVar}))';
+@splitter-transform-y: ~'translateY(var(--@{splitterBarPreviewOffsetVar}))';
+
+.center-position() {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+}
+
+.@{splitter-prefix-cls} {
+    display: flex;
+    width: 100%;
+    height: 100%;
+    align-items: stretch;
+
+    & > .@{splitter-prefix-cls}-bar {
+        flex: none;
+        position: relative;
+        user-select: none;
+
+        .@{splitter-prefix-cls}-bar-dragger {
+            .center-position();
+            z-index: 1;
+            pointer-events: auto;
+
+            &::before {
+                content: '';
+                background: @item-hover-bg;
+                .center-position();
+            }
+
+            &::after {
+                content: '';
+                background: rgba(0, 0, 0, 0.15);
+                .center-position();
+            }
+
+            &:hover:not(.@{splitter-prefix-cls}-bar-dragger-active) {
+                &::before {
+                    background: @item-active-bg;
+                }
+            }
+
+            &.@{splitter-prefix-cls}-bar-dragger-active {
+                z-index: 2;
+
+                &::before {
+                    background: @item-active-bg;
+                }
+            }
+
+            &.@{splitter-prefix-cls}-bar-dragger-disabled {
+                z-index: 0;
+                cursor: default;
+
+                &,
+                &:hover,
+                &.@{splitter-prefix-cls}-bar-dragger-active {
+                    &::before {
+                        background: @disabled-bg;
+                    }
+                }
+
+                &::after {
+                    display: none;
+                }
+            }
+        }
+
+        .@{splitter-prefix-cls}-bar-collapse-bar {
+            .center-position();
+            z-index: @zindex-popover;
+            background: @item-hover-bg;
+            font-size: @font-size-base;
+            border-radius: @border-radius-base;
+            color: @text-color;
+            cursor: pointer;
+            opacity: 0;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+
+            &:hover {
+                background: @item-active-bg;
+            }
+
+            &:active {
+                background: @item-active-bg;
+            }
+        }
+
+        &:hover,
+        &:active {
+            .@{splitter-prefix-cls}-bar-collapse-bar-hover-only {
+                opacity: 1;
+            }
+        }
+
+        .@{splitter-prefix-cls}-bar-collapse-bar-hover-only {
+            @media (hover: none) {
+                opacity: 1;
+            }
+        }
+
+        .@{splitter-prefix-cls}-bar-collapse-bar-always-hidden {
+            display: none;
+        }
+
+        .@{splitter-prefix-cls}-bar-collapse-bar-always-visible {
+            opacity: 1;
+        }
+    }
+
+    .@{splitter-prefix-cls}-mask {
+        position: fixed;
+        z-index: 9999;
+        top: 0;
+        right: 0;
+        bottom: 0;
+        left: 0;
+        background: transparent;
+
+        &.@{splitter-prefix-cls}-mask-horizontal {
+            cursor: col-resize;
+        }
+
+        &.@{splitter-prefix-cls}-mask-vertical {
+            cursor: row-resize;
+        }
+    }
+
+    &.@{splitter-prefix-cls}-horizontal {
+        flex-direction: row;
+
+        & > .@{splitter-prefix-cls}-bar {
+            width: 0;
+
+            .@{splitter-prefix-cls}-bar-preview {
+                height: 100%;
+                width: @splitter-split-bar-size;
+                position: absolute;
+                background: @primary-color;
+                opacity: 0.2;
+                pointer-events: none;
+                transition: none;
+                z-index: 1;
+                display: none;
+
+                &.@{splitter-prefix-cls}-bar-preview-active {
+                    display: block;
+
+                    transform: @splitter-transform-x;
+                }
+            }
+
+            .@{splitter-prefix-cls}-bar-dragger {
+                cursor: col-resize;
+                height: 100%;
+                width: @splitter-split-trigger-size;
+
+                &::before {
+                    height: 100%;
+                    width: @splitter-split-bar-size;
+                }
+
+                &::after {
+                    height: @splitter-split-bar-draggable-size;
+                    width: @splitter-split-bar-size;
+                }
+            }
+
+            .@{splitter-prefix-cls}-bar-collapse-bar {
+                width: @font-size-sm;
+                height: @btn-height-sm;
+
+                &.@{splitter-prefix-cls}-bar-collapse-bar-start {
+                    left: auto;
+                    right: (@splitter-split-trigger-size / 2);
+                    transform: translateY(-50%);
+                }
+
+                &.@{splitter-prefix-cls}-bar-collapse-bar-end {
+                    left: (@splitter-split-trigger-size / 2);
+                    right: auto;
+                    transform: translateY(-50%);
+                }
+            }
+        }
+    }
+
+    &.@{splitter-prefix-cls}-vertical {
+        flex-direction: column;
+
+        & > .@{splitter-prefix-cls}-bar {
+            height: 0;
+
+            .@{splitter-prefix-cls}-bar-preview {
+                height: @splitter-split-bar-size;
+                width: 100%;
+                position: absolute;
+                background: @primary-color;
+                opacity: 0.2;
+                pointer-events: none;
+                transition: none;
+                z-index: 1;
+                display: none;
+
+                &.@{splitter-prefix-cls}-bar-preview-active {
+                    display: block;
+                    transform: @splitter-transform-y;
+                }
+            }
+
+            .@{splitter-prefix-cls}-bar-dragger {
+                cursor: row-resize;
+                width: 100%;
+                height: @splitter-split-trigger-size;
+
+                &::before {
+                    width: 100%;
+                    height: @splitter-split-bar-size;
+                }
+
+                &::after {
+                    width: @splitter-split-bar-draggable-size;
+                    height: @splitter-split-bar-size;
+                }
+            }
+
+            .@{splitter-prefix-cls}-bar-collapse-bar {
+                height: @font-size-sm;
+                width: @btn-height-sm;
+
+                &.@{splitter-prefix-cls}-bar-collapse-bar-start {
+                    top: auto;
+                    bottom: (@splitter-split-trigger-size / 2);
+                    transform: translateX(-50%);
+                }
+
+                &.@{splitter-prefix-cls}-bar-collapse-bar-end {
+                    top: (@splitter-split-trigger-size / 2);
+                    bottom: auto;
+                    transform: translateX(-50%);
+                }
+            }
+        }
+    }
+
+    .@{splitter-prefix-cls}-panel {
+        overflow: auto;
+        padding: 0 1px;
+        box-sizing: border-box;
+
+        &::-webkit-scrollbar {
+            width: 8px;
+            height: 8px;
+        }
+
+        &::-webkit-scrollbar-thumb {
+            background: @table-sticky-scroll-bar-bg;
+            border-radius: @table-sticky-scroll-bar-radius;
+        }
+
+        &.@{splitter-prefix-cls}-panel-hidden {
+            padding: 0;
+            overflow: hidden;
+        }
+
+        &:has(.@{splitter-prefix-cls}:only-child) {
+            overflow: hidden;
+        }
+    }
+
+    &.@{ant-prefix}-rtl.@{splitter-prefix-cls}-horizontal {
+        & > .@{splitter-prefix-cls}-bar {
+            .@{splitter-prefix-cls}-bar-collapse-previous {
+                right: 0;
+                left: unset;
+            }
+
+            .@{splitter-prefix-cls}-bar-collapse-next {
+                right: unset;
+                left: 0;
+            }
+        }
+    }
+
+    &.@{ant-prefix}-rtl.@{splitter-prefix-cls}-vertical {
+        & > .@{splitter-prefix-cls}-bar {
+            .@{splitter-prefix-cls}-bar-collapse-previous {
+                right: 50%;
+                left: unset;
+            }
+
+            .@{splitter-prefix-cls}-bar-collapse-next {
+                right: 50%;
+                left: unset;
+            }
+        }
+    }
+}

package/lib/statusTag/index.d.ts

@@ -0,0 +1,28 @@
+import React, { CSSProperties, HTMLAttributes, ReactNode } from 'react';
+import './style';
+export declare const PRESET_COLOR_TYPES: readonly ["blue", "yellow", "green", "gray", "red", "purple", "cyan", "pink"];
+export declare const STATUS_TAG_TYPES: readonly ["default", "outline", "fill"];
+export declare type PresetColorType = (typeof PRESET_COLOR_TYPES)[number] | (string & {});
+export declare type StatusTagType = (typeof STATUS_TAG_TYPES)[number];
+export interface IStatusTagProps extends HTMLAttributes<HTMLDivElement> {
+    /** 状态类型 */
+    type?: StatusTagType;
+    /** 是否圆角 */
+    rounded?: boolean;
+    /** 状态颜色（支持预设值/自定义十六进制/RGB） */
+    color?: PresetColorType;
+    /** 是否加载中 */
+    loading?: boolean;
+    /** 自定义图标 */
+    icon?: ReactNode;
+    /** 背景颜色（仅fill类型生效），未设置时使用color的0.15透明度 */
+    background?: string;
+    /** 类名 */
+    className?: string;
+    /** 子节点 */
+    children?: ReactNode;
+    /** 自定义样式 */
+    style?: CSSProperties;
+}
+declare const StatusTag: React.FC<IStatusTagProps>;
+export default StatusTag;