@dtjoy/dt-design 1.0.1 → 1.0.2

package/esm/splitter/hooks/useResizable.d.ts

@@ -0,0 +1,10 @@
+import type { ShowCollapsibleIconMode } from '../SplitBar';
+import type { ItemType } from './useItems';
+export declare type ResizableInfo = {
+    resizable: boolean;
+    startCollapsible: boolean;
+    endCollapsible: boolean;
+    showStartCollapsibleIcon: ShowCollapsibleIconMode;
+    showEndCollapsibleIcon: ShowCollapsibleIconMode;
+};
+export default function useResizable(items: ItemType[], pxSizes: number[], isRTL: boolean): ResizableInfo[];

package/esm/splitter/hooks/useResizable.js

@@ -0,0 +1,73 @@
+import * as React from 'react';
+function getShowCollapsibleIcon(prev, next) {
+  if (prev.collapsible && next.collapsible) {
+    if (prev.showCollapsibleIcon === true || next.showCollapsibleIcon === true) {
+      return true;
+    }
+    if (prev.showCollapsibleIcon === 'auto' || next.showCollapsibleIcon === 'auto') {
+      return 'auto';
+    }
+    return false;
+  }
+  if (prev.collapsible) {
+    return prev.showCollapsibleIcon;
+  }
+  if (next.collapsible) {
+    return next.showCollapsibleIcon;
+  }
+  return false;
+}
+export default function useResizable(items, pxSizes, isRTL) {
+  return React.useMemo(function () {
+    var resizeInfos = [];
+    for (var i = 0; i < items.length - 1; i += 1) {
+      var prevItem = items[i];
+      var nextItem = items[i + 1];
+      var prevSize = pxSizes[i];
+      var nextSize = pxSizes[i + 1];
+      var _prevItem$resizable = prevItem.resizable,
+        prevResizable = _prevItem$resizable === void 0 ? true : _prevItem$resizable,
+        prevMin = prevItem.min,
+        prevCollapsible = prevItem.collapsible;
+      var _nextItem$resizable = nextItem.resizable,
+        nextResizable = _nextItem$resizable === void 0 ? true : _nextItem$resizable,
+        nextMin = nextItem.min,
+        nextCollapsible = nextItem.collapsible;
+      var mergedResizable =
+      // Both need to be resizable
+      prevResizable && nextResizable && (
+      // Prev is not collapsed and limit min size
+      prevSize !== 0 || !prevMin) && (
+      // Next is not collapsed and limit min size
+      nextSize !== 0 || !nextMin);
+      var prevEndCollapsible = !!prevCollapsible.end && prevSize > 0;
+      var nextStartExpandable = !!nextCollapsible.start && nextSize === 0 && prevSize > 0;
+      var startCollapsible = prevEndCollapsible || nextStartExpandable;
+      var nextStartCollapsible = !!nextCollapsible.start && nextSize > 0;
+      var prevEndExpandable = !!prevCollapsible.end && prevSize === 0 && nextSize > 0;
+      var endCollapsible = nextStartCollapsible || prevEndExpandable;
+      var showStartCollapsibleIcon = getShowCollapsibleIcon({
+        collapsible: prevEndCollapsible,
+        showCollapsibleIcon: prevCollapsible.showCollapsibleIcon
+      }, {
+        collapsible: nextStartExpandable,
+        showCollapsibleIcon: nextCollapsible.showCollapsibleIcon
+      });
+      var showEndCollapsibleIcon = getShowCollapsibleIcon({
+        collapsible: nextStartCollapsible,
+        showCollapsibleIcon: nextCollapsible.showCollapsibleIcon
+      }, {
+        collapsible: prevEndExpandable,
+        showCollapsibleIcon: prevCollapsible.showCollapsibleIcon
+      });
+      resizeInfos[i] = {
+        resizable: mergedResizable,
+        startCollapsible: !!(isRTL ? endCollapsible : startCollapsible),
+        endCollapsible: !!(isRTL ? startCollapsible : endCollapsible),
+        showStartCollapsibleIcon: isRTL ? showEndCollapsibleIcon : showStartCollapsibleIcon,
+        showEndCollapsibleIcon: isRTL ? showStartCollapsibleIcon : showEndCollapsibleIcon
+      };
+    }
+    return resizeInfos;
+  }, [pxSizes, items]);
+}

package/esm/splitter/hooks/useResize.d.ts

@@ -0,0 +1,6 @@
+import type { ItemType } from './useItems';
+import type { ResizableInfo } from './useResizable';
+/**
+ * Handle user drag resize logic.
+ */
+export default function useResize(items: ItemType[], resizableInfos: ResizableInfo[], percentSizes: number[], containerSize: number | undefined, updateSizes: (sizes: number[]) => void, isRTL: boolean): readonly [(index: number) => void, (index: number, offset: number) => number[], () => void, (index: number, type: 'start' | 'end') => number[], number | undefined];

package/esm/splitter/hooks/useResize.js

@@ -0,0 +1,158 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import * as React from 'react';
+import { getPtg } from "./useSizes";
+
+/**
+ * Handle user drag resize logic.
+ */
+export default function useResize(items, resizableInfos, percentSizes, containerSize, updateSizes, isRTL) {
+  var limitSizes = items.map(function (item) {
+    return [item.min, item.max];
+  });
+  var mergedContainerSize = containerSize || 0;
+  var ptg2px = function ptg2px(ptg) {
+    return ptg * mergedContainerSize;
+  };
+
+  // ======================== Resize ========================
+  function getLimitSize(str, defaultLimit) {
+    if (typeof str === 'string') {
+      return ptg2px(getPtg(str));
+    }
+    return str !== null && str !== void 0 ? str : defaultLimit;
+  }
+
+  // Real px sizes
+  var _React$useState = React.useState([]),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    cacheSizes = _React$useState2[0],
+    setCacheSizes = _React$useState2[1];
+  var 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.
+   */
+  var _React$useState3 = React.useState(null),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    movingIndex = _React$useState4[0],
+    setMovingIndex = _React$useState4[1];
+  var getPxSizes = function getPxSizes() {
+    return percentSizes.map(ptg2px);
+  };
+  var onOffsetStart = function onOffsetStart(index) {
+    setCacheSizes(getPxSizes());
+    setMovingIndex({
+      index: index,
+      confirmed: false
+    });
+  };
+  var onOffsetUpdate = function onOffsetUpdate(index, offset) {
+    var _ref, _confirmedIndex;
+    // First time trigger move index update is not sync in the state
+    var 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: index,
+          confirmed: true
+        });
+      } else {
+        for (var i = index; i >= 0; i -= 1) {
+          if (cacheSizes[i] > 0 && resizableInfos[i].resizable) {
+            confirmedIndex = i;
+            setMovingIndex({
+              index: i,
+              confirmed: true
+            });
+            break;
+          }
+        }
+      }
+    }
+    var mergedIndex = (_ref = (_confirmedIndex = confirmedIndex) !== null && _confirmedIndex !== void 0 ? _confirmedIndex : movingIndex === null || movingIndex === void 0 ? void 0 : movingIndex.index) !== null && _ref !== void 0 ? _ref : index;
+    var numSizes = _toConsumableArray(cacheSizes);
+    var nextIndex = mergedIndex + 1;
+
+    // Get boundary
+    var startMinSize = getLimitSize(limitSizes[mergedIndex][0], 0);
+    var endMinSize = getLimitSize(limitSizes[nextIndex][0], 0);
+    var startMaxSize = getLimitSize(limitSizes[mergedIndex][1], mergedContainerSize);
+    var endMaxSize = getLimitSize(limitSizes[nextIndex][1], mergedContainerSize);
+    var 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;
+  };
+  var onOffsetEnd = function onOffsetEnd() {
+    setMovingIndex(null);
+  };
+
+  // ======================= Collapse =======================
+  var onCollapse = function onCollapse(index, type) {
+    var currentSizes = getPxSizes();
+    var adjustedType = isRTL ? type === 'start' ? 'end' : 'start' : type;
+    var currentIndex = adjustedType === 'start' ? index : index + 1;
+    var targetIndex = adjustedType === 'start' ? index + 1 : index;
+    var currentSize = currentSizes[currentIndex];
+    var targetSize = currentSizes[targetIndex];
+    if (currentSize !== 0 && targetSize !== 0) {
+      // Collapse directly
+      currentSizes[currentIndex] = 0;
+      currentSizes[targetIndex] += currentSize;
+      cacheCollapsedSize.current[index] = currentSize;
+    } else {
+      var totalSize = currentSize + targetSize;
+      var currentSizeMin = getLimitSize(limitSizes[currentIndex][0], 0);
+      var currentSizeMax = getLimitSize(limitSizes[currentIndex][1], mergedContainerSize);
+      var targetSizeMin = getLimitSize(limitSizes[targetIndex][0], 0);
+      var targetSizeMax = getLimitSize(limitSizes[targetIndex][1], mergedContainerSize);
+      var limitStart = Math.max(currentSizeMin, totalSize - targetSizeMax);
+      var limitEnd = Math.min(currentSizeMax, totalSize - targetSizeMin);
+      var halfOffset = targetSizeMin || (limitEnd - limitStart) / 2;
+      var targetCacheCollapsedSize = cacheCollapsedSize.current[index];
+      var currentCacheCollapsedSize = totalSize - targetCacheCollapsedSize;
+      var 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 === null || movingIndex === void 0 ? void 0 : movingIndex.index];
+}

package/esm/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/esm/splitter/hooks/useSizes.js

@@ -0,0 +1,80 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import React from 'react';
+import { autoPtgSizes } from "./sizeUtil";
+export function getPtg(str) {
+  return Number(str.slice(0, -1)) / 100;
+}
+function isPtg(itemSize) {
+  return typeof itemSize === 'string' && itemSize.endsWith('%');
+}
+export default function useSizes(items, containerSize) {
+  var propSizes = items.map(function (item) {
+    return item.size;
+  });
+  var itemsCount = items.length;
+  var mergedContainerSize = containerSize || 0;
+  var ptg2px = function ptg2px(ptg) {
+    return ptg * mergedContainerSize;
+  };
+  var _React$useState = React.useState(function () {
+      return items.map(function (item) {
+        return item.defaultSize;
+      });
+    }),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    innerSizes = _React$useState2[0],
+    setInnerSizes = _React$useState2[1];
+  var sizes = React.useMemo(function () {
+    var mergedSizes = [];
+    for (var i = 0; i < itemsCount; i += 1) {
+      var _propSizes$i;
+      mergedSizes[i] = (_propSizes$i = propSizes[i]) !== null && _propSizes$i !== void 0 ? _propSizes$i : innerSizes[i];
+    }
+    return mergedSizes;
+  }, [itemsCount, innerSizes, propSizes]);
+  var postPercentMinSizes = React.useMemo(function () {
+    return items.map(function (item) {
+      if (isPtg(item.min)) {
+        return getPtg(item.min);
+      }
+      return (item.min || 0) / mergedContainerSize;
+    });
+  }, [items, mergedContainerSize]);
+  var postPercentMaxSizes = React.useMemo(function () {
+    return items.map(function (item) {
+      if (isPtg(item.max)) {
+        return getPtg(item.max);
+      }
+      return (item.max || mergedContainerSize) / mergedContainerSize;
+    });
+  }, [items, mergedContainerSize]);
+  var postPercentSizes = React.useMemo(function () {
+    var ptgList = [];
+    for (var i = 0; i < itemsCount; i += 1) {
+      var itemSize = sizes[i];
+      if (isPtg(itemSize)) {
+        ptgList[i] = getPtg(itemSize);
+      } else if (itemSize || itemSize === 0) {
+        var num = Number(itemSize);
+        if (!Number.isNaN(num)) {
+          ptgList[i] = num / mergedContainerSize;
+        }
+      } else {
+        ptgList[i] = undefined;
+      }
+    }
+    return autoPtgSizes(ptgList, postPercentMinSizes, postPercentMaxSizes);
+  }, [sizes, mergedContainerSize, postPercentMinSizes, postPercentMaxSizes]);
+  var postPxSizes = React.useMemo(function () {
+    return postPercentSizes.map(ptg2px);
+  }, [postPercentSizes, mergedContainerSize]);
+  var panelSizes = React.useMemo(function () {
+    return containerSize ? postPxSizes : sizes;
+  }, [postPxSizes, containerSize]);
+  return [panelSizes, postPxSizes, postPercentSizes, postPercentMinSizes, postPercentMaxSizes, setInnerSizes];
+}

package/esm/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/esm/splitter/index.js

@@ -0,0 +1,5 @@
+import Panel from "./Panel";
+import SplitterComp from "./Splitter";
+var Splitter = SplitterComp;
+Splitter.Panel = Panel;
+export default Splitter;

package/esm/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/esm/splitter/interface.js

@@ -0,0 +1 @@
+export {};

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

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

package/esm/splitter/style/index.js

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