@zat-design/sisyphus-react 4.5.10-beta.1 → 4.5.10-beta.2

package/es/ProEditTable/utils/transform.js

@@ -1,40 +1,35 @@
-import { transforms } from '@zat-design/utils';
-const {
-  transformDate
-} = transforms;
-const getDefaultFormat = picker => {
+import { transforms } from "@zat-design/utils";
+const { transformDate } = transforms;
+const getDefaultFormat = (picker) => {
   switch (picker) {
-    case 'week':
-      return 'YYYY-ww';
-    // ISO week，避免 locale 相关的 'wo' 格式解析问题
-    case 'month':
-      return 'YYYY-MM';
-    case 'quarter':
-      return 'YYYY-[Q]Q';
-    case 'year':
-      return 'YYYY';
+    case "week":
+      return "YYYY-ww";
+    case "month":
+      return "YYYY-MM";
+    case "quarter":
+      return "YYYY-[Q]Q";
+    case "year":
+      return "YYYY";
     default:
-      return 'YYYY-MM-DD';
+      return "YYYY-MM-DD";
   }
 };
-export default {
-  RangePicker: () => transformDate({
-    type: 'RangePicker',
-    keys: ['form', 'to']
-  }),
-  DatePicker: fieldProps => {
-    const format = fieldProps?.format ?? getDefaultFormat(fieldProps?.picker);
-    const baseTransform = transformDate({
-      type: 'DatePicker',
-      format
-    });
+var transform_default = {
+  RangePicker: () => transformDate({ type: "RangePicker", keys: ["form", "to"] }),
+  DatePicker: (fieldProps) => {
+    const format = (fieldProps == null ? void 0 : fieldProps.format) ?? getDefaultFormat(fieldProps == null ? void 0 : fieldProps.picker);
+    const baseTransform = transformDate({ type: "DatePicker", format });
     return {
       ...baseTransform,
       normalize: (value, prevValue, allValues) => {
-        // DatePicker 已输出格式化字符串时直接透传
-        if (typeof value === 'string') return value;
-        return baseTransform.normalize?.(value, prevValue, allValues);
+        var _a;
+        if (typeof value === "string")
+          return value;
+        return (_a = baseTransform.normalize) == null ? void 0 : _a.call(baseTransform, value, prevValue, allValues);
       }
     };
   }
-};
+};
+export {
+  transform_default as default
+};

package/es/ProEditTable/utils/useEditTableError.js

@@ -1,5 +1,5 @@
-import _debounce from "lodash/debounce";
-import { useState, useEffect } from 'react';
+import { useState, useEffect } from "react";
+import debounce from "lodash/debounce";
 const useEditTableError = ({
   containerNode,
   className,
@@ -7,54 +7,43 @@ const useEditTableError = ({
 }) => {
   const [errorLength, setErrorLength] = useState(0);
   useEffect(() => {
-    // 如果 isEnabled 为 false 或容器节点不存在，直接跳过监听
-    if (!isEnabled || !containerNode || !containerNode?.querySelector) {
-      return; // 如果未启用监听或容器节点不存在，直接返回
+    var _a;
+    if (!isEnabled || !containerNode || !(containerNode == null ? void 0 : containerNode.querySelector)) {
+      return;
     }
-
-    // 防抖处理：将 setErrorLength 函数进行防抖
-    const debouncedSetErrorLength = _debounce(errorCount => {
-      setErrorLength(errorCount); // 更新错误数量
-    }, 300); // 300ms 后更新状态
-
-    const observer = new MutationObserver(mutations => {
-      mutations.forEach(mutation => {
-        // 只处理节点的 class 属性变化
-        if (mutation.type === 'attributes' && mutation.attributeName === 'class') {
+    const debouncedSetErrorLength = debounce((errorCount) => {
+      setErrorLength(errorCount);
+    }, 300);
+    const observer = new MutationObserver((mutations) => {
+      mutations.forEach((mutation) => {
+        var _a2;
+        if (mutation.type === "attributes" && mutation.attributeName === "class") {
           const target = mutation.target;
-
-          // 检查目标节点是否包含指定的类
           if (target.classList.contains(className)) {
-            // 查找所有包含 className 的节点
-            const errorNodes = containerNode?.children[0]?.querySelectorAll(`.${className}`);
-
-            // 过滤这些节点，只保留那些类名完全为 `ant-form-item-explain-error` 的节点
-            const validErrorNodes = Array.from(errorNodes).filter(node => node.classList.length === 1 && node.classList.contains('ant-form-item-explain-error'));
+            const errorNodes = (_a2 = containerNode == null ? void 0 : containerNode.children[0]) == null ? void 0 : _a2.querySelectorAll(`.${className}`);
+            const validErrorNodes = Array.from(errorNodes).filter(
+              (node) => node.classList.length === 1 && node.classList.contains("ant-form-item-explain-error")
+            );
             if (errorLength === 0) {
               debouncedSetErrorLength(0);
             }
             if (errorLength === validErrorNodes.length) {
               return;
             }
-            // 使用防抖后的方法更新错误数量
             debouncedSetErrorLength(validErrorNodes.length);
           }
         }
-
-        // 监听子节点的添加或删除
-        if (mutation.type === 'childList') {
-          // 检查删除的节点是否包含指定的类名
-          mutation.removedNodes.forEach(removedNode => {
-            if (removedNode instanceof HTMLElement && removedNode.classList.contains('ant-table-row')) {
-              // 更新错误数量
-              const errorNodes = containerNode?.children[0]?.querySelectorAll(`.${className}`);
+        if (mutation.type === "childList") {
+          mutation.removedNodes.forEach((removedNode) => {
+            var _a3;
+            if (removedNode instanceof HTMLElement && removedNode.classList.contains("ant-table-row")) {
+              const errorNodes = (_a3 = containerNode == null ? void 0 : containerNode.children[0]) == null ? void 0 : _a3.querySelectorAll(`.${className}`);
               if (errorLength === 0) {
                 debouncedSetErrorLength(0);
               }
               if (errorLength === errorNodes.length) {
                 return;
               }
-              // 使用防抖后的方法更新错误数量
               debouncedSetErrorLength(errorNodes.length);
             }
           });
@@ -66,26 +55,24 @@ const useEditTableError = ({
       // 监听属性的变化
       subtree: true,
       // 监听子节点的变化
-      attributeFilter: ['class'],
+      attributeFilter: ["class"],
       // 只监听 class 属性变化
       childList: true
     };
-
-    // 启动 MutationObserver
-    const targetNode = containerNode?.children[0]?.querySelector('tbody');
+    const targetNode = (_a = containerNode == null ? void 0 : containerNode.children[0]) == null ? void 0 : _a.querySelector("tbody");
     if (targetNode instanceof HTMLElement) {
       observer.observe(targetNode, config);
     } else {
-      console.error('warning: tbody element not found or invalid');
+      console.error("warning: tbody element not found or invalid");
     }
-
-    // 清理 MutationObserver 和防抖定时器
     return () => {
       observer.disconnect();
-      debouncedSetErrorLength.cancel(); // 取消防抖定时器
+      debouncedSetErrorLength.cancel();
     };
-  }, [containerNode, className, isEnabled]); // 当 isEnabled 改变时会重新启动或取消监听
-
+  }, [containerNode, className, isEnabled]);
   return [errorLength];
 };
-export default useEditTableError;
+var useEditTableError_default = useEditTableError;
+export {
+  useEditTableError_default as default
+};

package/es/ProEditTable/utils/useShouldUpdateForTable.js

@@ -1,39 +1,29 @@
-import _debounce from "lodash/debounce";
-import _isEqualWith from "lodash/isEqualWith";
-import _isFunction from "lodash/isFunction";
-import { useRef, useState, useEffect } from 'react';
+import { useRef, useState, useEffect } from "react";
+import isFunction from "lodash/isFunction";
+import isEqualWith from "lodash/isEqualWith";
+import debounce from "lodash/debounce";
 import { customEqualForFunction } from "../../utils";
 import { isRecordShallowEqual } from "./tools";
-const useShouldUpdateForTable = props => {
-  const {
-    rowParams,
-    column,
-    shouldUpdateDebounce
-  } = props;
-
-  // refs 存储当前值
-  const isEditableRef = useRef(undefined);
-  const requiredRef = useRef(undefined);
-  const rulesRef = useRef(undefined);
-  const fieldPropsRef = useRef(undefined);
-  const desensitizationRef = useRef(undefined);
-  const valueTypeRef = useRef(undefined);
-  const componentRef = useRef(undefined);
+const useShouldUpdateForTable = (props) => {
+  var _a, _b;
+  const { rowParams, column, shouldUpdateDebounce } = props;
+  const isEditableRef = useRef(void 0);
+  const requiredRef = useRef(void 0);
+  const rulesRef = useRef(void 0);
+  const fieldPropsRef = useRef(void 0);
+  const desensitizationRef = useRef(void 0);
+  const valueTypeRef = useRef(void 0);
+  const componentRef = useRef(void 0);
   const componentResolvedRef = useRef(false);
-  const resolvedRowSnapshotRef = useRef(undefined);
+  const resolvedRowSnapshotRef = useRef(void 0);
   const [, reRender] = useState({});
   const debouncedUpdateRef = useRef(null);
   const pendingParamsRef = useRef(null);
   const isInitializedRef = useRef(false);
-
-  // 统一处理所有动态属性的更新
   const processUpdate = (params, forceFieldPropsUpdate = false) => {
     let hasChange = false;
-    // 新格式：params = [values, { form, index, namePath }]
     const [values, reactiveParams] = params;
-
-    // isEditable 处理
-    if (_isFunction(column.isEditable)) {
+    if (isFunction(column.isEditable)) {
       const newIsEditable = column.isEditable(values, reactiveParams);
       if (isEditableRef.current !== newIsEditable) {
         isEditableRef.current = newIsEditable;
@@ -42,9 +32,7 @@ const useShouldUpdateForTable = props => {
     } else {
       isEditableRef.current = column.isEditable;
     }
-
-    // required 处理
-    if (_isFunction(column.required)) {
+    if (isFunction(column.required)) {
       const newRequired = column.required(values, reactiveParams);
       if (requiredRef.current !== newRequired) {
         requiredRef.current = newRequired;
@@ -53,42 +41,34 @@ const useShouldUpdateForTable = props => {
     } else {
       requiredRef.current = column.required;
     }
-
-    // rules 处理
-    if (_isFunction(column.rules)) {
+    if (isFunction(column.rules)) {
       const newRules = column.rules(values, reactiveParams);
-      if (!_isEqualWith(rulesRef.current, newRules, customEqualForFunction)) {
+      if (!isEqualWith(rulesRef.current, newRules, customEqualForFunction)) {
         rulesRef.current = newRules;
         hasChange = true;
       }
     } else {
       rulesRef.current = column.rules;
     }
-
-    // fieldProps 处理
-    if (_isFunction(column.fieldProps)) {
+    if (isFunction(column.fieldProps)) {
       const newFieldProps = column.fieldProps(values, reactiveParams);
-      if (forceFieldPropsUpdate || !_isEqualWith(fieldPropsRef.current, newFieldProps, customEqualForFunction)) {
+      if (forceFieldPropsUpdate || !isEqualWith(fieldPropsRef.current, newFieldProps, customEqualForFunction)) {
         fieldPropsRef.current = newFieldProps;
         hasChange = true;
       }
     } else {
       fieldPropsRef.current = column.fieldProps;
     }
-
-    // desensitization 处理
-    if (_isFunction(column.desensitization)) {
+    if (isFunction(column.desensitization)) {
       const newDesensitization = column.desensitization(values, reactiveParams);
-      if (!_isEqualWith(desensitizationRef.current, newDesensitization)) {
+      if (!isEqualWith(desensitizationRef.current, newDesensitization)) {
         desensitizationRef.current = newDesensitization;
         hasChange = true;
       }
     } else {
       desensitizationRef.current = column.desensitization;
     }
-
-    // valueType 处理（保持旧格式，因为 valueType 可能还在使用旧格式）
-    if (_isFunction(column.valueType)) {
+    if (isFunction(column.valueType)) {
       const newValueType = column.valueType(...params);
       if (valueTypeRef.current !== newValueType) {
         valueTypeRef.current = newValueType;
@@ -97,33 +77,26 @@ const useShouldUpdateForTable = props => {
     } else {
       valueTypeRef.current = column.valueType;
     }
-
-    // component 处理（注意：component 是 editRender 的别名）
     const componentOrEditRender = column.component || column.editRender;
-    if (_isFunction(componentOrEditRender)) {
+    if (isFunction(componentOrEditRender)) {
       const newComponent = componentOrEditRender(values, reactiveParams);
       componentResolvedRef.current = true;
-      // 对于 ReactNode 类型的返回值，使用深度比较
-      if (!_isEqualWith(componentRef.current, newComponent, customEqualForFunction)) {
+      if (!isEqualWith(componentRef.current, newComponent, customEqualForFunction)) {
         componentRef.current = newComponent;
         hasChange = true;
       }
     } else {
       componentRef.current = componentOrEditRender;
     }
-    resolvedRowSnapshotRef.current = values && typeof values === 'object' ? {
-      ...values
-    } : values;
+    resolvedRowSnapshotRef.current = values && typeof values === "object" ? { ...values } : values;
     if (hasChange) {
       reRender({});
     }
   };
-
-  // 创建防抖函数（统一处理所有动态属性）
   useEffect(() => {
     const componentOrEditRender = column.component || column.editRender;
-    if (shouldUpdateDebounce > 0 && (_isFunction(column.isEditable) || _isFunction(column.required) || _isFunction(column.rules) || _isFunction(column.fieldProps) || _isFunction(column.desensitization) || _isFunction(column.valueType) || _isFunction(componentOrEditRender))) {
-      debouncedUpdateRef.current = _debounce(() => {
+    if (shouldUpdateDebounce > 0 && (isFunction(column.isEditable) || isFunction(column.required) || isFunction(column.rules) || isFunction(column.fieldProps) || isFunction(column.desensitization) || isFunction(column.valueType) || isFunction(componentOrEditRender))) {
+      debouncedUpdateRef.current = debounce(() => {
         if (pendingParamsRef.current) {
           processUpdate(pendingParamsRef.current);
           pendingParamsRef.current = null;
@@ -131,37 +104,31 @@ const useShouldUpdateForTable = props => {
       }, shouldUpdateDebounce);
     }
     return () => {
-      debouncedUpdateRef.current?.cancel();
+      var _a2;
+      (_a2 = debouncedUpdateRef.current) == null ? void 0 : _a2.cancel();
     };
   }, [shouldUpdateDebounce, column]);
-
-  // 统一的属性处理逻辑
-  // 使用 ref 存储上一次的 rowParams，避免引用变化导致的重复调用
   const prevRowParamsRef = useRef(null);
-  const currentFieldPropsFactory = _isFunction(column.fieldProps) ? column.fieldProps : undefined;
+  const currentFieldPropsFactory = isFunction(column.fieldProps) ? column.fieldProps : void 0;
   const prevFieldPropsFactoryRef = useRef(currentFieldPropsFactory);
   const fieldPropsFactoryChanged = prevFieldPropsFactoryRef.current !== currentFieldPropsFactory;
   prevFieldPropsFactoryRef.current = currentFieldPropsFactory;
-
-  // 上一次保存的是浅快照，可同时覆盖引用稳定和 onFieldChange 原地修改两种路径。
   const prevRowParams = prevRowParamsRef.current;
-  const rowDataUnchanged = isInitializedRef.current && isRecordShallowEqual(prevRowParams?.[0], rowParams[0]) && prevRowParams?.[1]?.index === rowParams[1]?.index;
-  const shouldProcess = !isInitializedRef.current || fieldPropsFactoryChanged || !rowDataUnchanged && !_isEqualWith(prevRowParams, rowParams, customEqualForFunction);
+  const rowDataUnchanged = isInitializedRef.current && isRecordShallowEqual(prevRowParams == null ? void 0 : prevRowParams[0], rowParams[0]) && ((_a = prevRowParams == null ? void 0 : prevRowParams[1]) == null ? void 0 : _a.index) === ((_b = rowParams[1]) == null ? void 0 : _b.index);
+  const shouldProcess = !isInitializedRef.current || fieldPropsFactoryChanged || !rowDataUnchanged && !isEqualWith(prevRowParams, rowParams, customEqualForFunction);
   if (shouldProcess) {
     const currentRowData = rowParams[0];
-    prevRowParamsRef.current = [currentRowData && typeof currentRowData === 'object' ? {
-      ...currentRowData
-    } : currentRowData, rowParams[1]];
+    prevRowParamsRef.current = [
+      currentRowData && typeof currentRowData === "object" ? { ...currentRowData } : currentRowData,
+      rowParams[1]
+    ];
     isInitializedRef.current = true;
     if (fieldPropsFactoryChanged) {
-      // 外部依赖变化会生成新的 fieldProps 函数，需要立即替换旧闭包缓存
       processUpdate(rowParams, true);
     } else if (shouldUpdateDebounce > 0 && debouncedUpdateRef.current) {
-      // 使用防抖延迟更新
       pendingParamsRef.current = rowParams;
       debouncedUpdateRef.current();
     } else {
-      // 立即更新（shouldUpdateDebounce = 0 或无防抖函数）
       processUpdate(rowParams);
     }
   }
@@ -177,4 +144,7 @@ const useShouldUpdateForTable = props => {
     rowSnapshot: resolvedRowSnapshotRef.current
   };
 };
-export default useShouldUpdateForTable;
+var useShouldUpdateForTable_default = useShouldUpdateForTable;
+export {
+  useShouldUpdateForTable_default as default
+};