@nokecy/qc-ui-components 0.0.0-stage → 2.0.0-beta.0

package/dist/esm/array-table/batchRemove.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import type { ArrayField } from '@nokecy/formily-core';
+import type { GridApi, IRowNode, SelectionChangedEvent } from 'ag-grid-community';
+import type { ArrayTableProps, ObservableColumnSource } from './interface';
+/** 标准删除控件在行内的字段路径与静态约束。@author nokecy */
+export type RemovalAction = {
+    path: string[];
+    schemas: any[];
+    column: ObservableColumnSource;
+};
+/** 收集标准删除入口，保留列级显隐约束，不把其他业务按钮当成删除。@author nokecy */
+export declare function collectRemovalActions(sources: ObservableColumnSource[]): RemovalAction[];
+/**
+ * 与行内删除共用字段的运行时权限；未挂载的普通行采用静态规则。
+ * 含动态权限且尚未求值的行保持不可删除，避免绕过业务禁用条件。@author nokecy
+ */
+export declare function findRemovalAction(field: ArrayField, index: number, actions: RemovalAction[]): RemovalAction | undefined;
+/**
+ * 把选择时的稳定行标识转换为当前表单索引；确认前全部复核，倒序删除保持数组地址正确。
+ * 返回 false 表示所选行已删除或变为不可删除，整个批次不执行。@author nokecy
+ */
+export declare function removeSelectedRows(field: ArrayField, ids: string[], actions: RemovalAction[], getId: (row: any) => string, onRemove?: (index: number) => void, event?: React.MouseEvent): boolean;
+/** 公共明细表格的勾选及批量删除，沿用业务行权限、行标识与删除通知。@author nokecy */
+export declare function useArrayTableBatchRemove(field: ArrayField, sources: ObservableColumnSource[], props: ArrayTableProps, apiRef: React.MutableRefObject<GridApi | undefined>, getId: (row: any) => string): {
+    rowSelection: "multiple" | "single" | import("ag-grid-community/dist/types/src/entities/gridOptions").SingleRowSelectionOptions<any, any> | import("ag-grid-community/dist/types/src/entities/gridOptions").MultiRowSelectionOptions<any, any> | {
+        isRowSelectable: (node: IRowNode) => boolean;
+        headerCheckbox?: boolean | undefined;
+        selectAll?: "filtered" | undefined;
+        mode: "singleRow" | "multiRow";
+        checkboxes: boolean;
+        enableClickSelection: boolean;
+    } | undefined;
+    selectionColumnDef: import("ag-grid-community").SelectionColumnDef | undefined;
+    onSelectionChanged: (event: SelectionChangedEvent) => void;
+    toolbar: React.JSX.Element;
+};

package/dist/esm/array-table/batchRemove.js

@@ -0,0 +1,301 @@
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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 _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; }
+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 _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+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; }
+import React, { useEffect, useMemo, useState } from 'react';
+import { Button, Modal, Space } from 'antd';
+import { DeleteOutlined } from '@ant-design/icons';
+import { batch } from '@nokecy/formily-reactive';
+
+/** 标准删除控件在行内的字段路径与静态约束。@author nokecy */
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment } from "react/jsx-runtime";
+/** 收集标准删除入口，保留列级显隐约束，不把其他业务按钮当成删除。@author nokecy */
+export function collectRemovalActions(sources) {
+  var actions = [];
+  var _iterator = _createForOfIteratorHelper(sources),
+    _step;
+  try {
+    var _loop = function _loop() {
+      var column = _step.value;
+      if (column.display && column.display !== 'visible') return 1; // continue
+      var visit = function visit(schema, path, ancestors) {
+        if (!schema) return;
+        var schemas = [].concat(_toConsumableArray(ancestors), [schema]);
+        if (typeof schema['x-component'] === 'string' && /^(?:ArrayTable|ArrayBase)\.Remove$/.test(schema['x-component'])) {
+          actions.push({
+            path: path,
+            schemas: schemas,
+            column: column
+          });
+          return;
+        }
+        Object.entries(schema.properties || {}).forEach(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+            key = _ref2[0],
+            child = _ref2[1];
+          return visit(child, [].concat(_toConsumableArray(path), [key]), schemas);
+        });
+      };
+      // 列本身不进入行地址；AgField 使用 onlyRenderProperties 挂载列内字段。
+      Object.entries(column.schema.properties || {}).forEach(function (_ref3) {
+        var _ref4 = _slicedToArray(_ref3, 2),
+          key = _ref4[0],
+          child = _ref4[1];
+        return visit(child, [key], []);
+      });
+    };
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      if (_loop()) continue;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return actions;
+}
+var permitsRemoval = function permitsRemoval(field) {
+  var _field$componentProps, _field$componentProps2;
+  return !field || field.display === 'visible' && field.pattern === 'editable' && !field.disabled && ((_field$componentProps = field.componentProps) === null || _field$componentProps === void 0 ? void 0 : _field$componentProps.disabled) !== true && ((_field$componentProps2 = field.componentProps) === null || _field$componentProps2 === void 0 ? void 0 : _field$componentProps2.readOnly) !== true;
+};
+
+/**
+ * 与行内删除共用字段的运行时权限；未挂载的普通行采用静态规则。
+ * 含动态权限且尚未求值的行保持不可删除，避免绕过业务禁用条件。@author nokecy
+ */
+export function findRemovalAction(field, index, actions) {
+  if (field.pattern !== 'editable' || field.disabled || !Array.isArray(field.value) || !field.value[index]) return;
+  return actions.find(function (action) {
+    if (!permitsRemoval(action.column.field)) return false;
+    if (action.column.schema['x-visible'] === false || action.column.schema['x-hidden'] === true) return false;
+    var _loop2 = function _loop2() {
+        var schema = action.schemas[depth];
+        var runtime = field.query(field.address.concat(index).concat(action.path.slice(0, depth + 1))).take();
+        if (runtime) {
+          if (!permitsRemoval(runtime)) return {
+            v: false
+          };
+        } else {
+          var _schema$xComponentP, _schema$xComponentP2;
+          if (schema['x-visible'] === false || schema['x-hidden'] === true || schema['x-display'] && schema['x-display'] !== 'visible' || schema['x-pattern'] && schema['x-pattern'] !== 'editable' || schema['x-disabled'] === true || schema['x-read-only'] === true || (_schema$xComponentP = schema['x-component-props']) !== null && _schema$xComponentP !== void 0 && _schema$xComponentP.disabled || (_schema$xComponentP2 = schema['x-component-props']) !== null && _schema$xComponentP2 !== void 0 && _schema$xComponentP2.readOnly || schema['x-reactions'] || ['x-visible', 'x-hidden', 'x-disabled', 'x-read-only'].some(function (key) {
+            return typeof schema[key] === 'string';
+          })) return {
+            v: false
+          };
+        }
+      },
+      _ret;
+    for (var depth = 0; depth < action.path.length; depth++) {
+      _ret = _loop2();
+      if (_ret) return _ret.v;
+    }
+    return true;
+  });
+}
+
+/**
+ * 把选择时的稳定行标识转换为当前表单索引；确认前全部复核，倒序删除保持数组地址正确。
+ * 返回 false 表示所选行已删除或变为不可删除，整个批次不执行。@author nokecy
+ */
+export function removeSelectedRows(field, ids, actions, getId, onRemove, event) {
+  var rows = Array.isArray(field.value) ? field.value : [];
+  var indices = new Map(rows.map(function (row, index) {
+    return [getId(row), index];
+  }));
+  var targets = Array.from(new Set(ids)).map(function (id) {
+    var _indices$get;
+    var index = (_indices$get = indices.get(id)) !== null && _indices$get !== void 0 ? _indices$get : -1;
+    return {
+      index: index,
+      action: index < 0 ? undefined : findRemovalAction(field, index, actions)
+    };
+  });
+  if (!targets.length || targets.some(function (target) {
+    return !target.action;
+  })) return false;
+  // 先固定已求值的回调，数组删除会让后续字段索引迁移。
+  var removals = targets.sort(function (a, b) {
+    return b.index - a.index;
+  }).map(function (_ref5) {
+    var _field$query$take$com, _field$query$take, _schemas$xComponent;
+    var index = _ref5.index,
+      action = _ref5.action;
+    return {
+      index: index,
+      onClick: (_field$query$take$com = (_field$query$take = field.query(field.address.concat(index).concat(action.path)).take()) === null || _field$query$take === void 0 || (_field$query$take = _field$query$take.componentProps) === null || _field$query$take === void 0 ? void 0 : _field$query$take.onClick) !== null && _field$query$take$com !== void 0 ? _field$query$take$com : (_schemas$xComponent = action.schemas[action.schemas.length - 1]['x-component-props']) === null || _schemas$xComponent === void 0 ? void 0 : _schemas$xComponent.onClick
+    };
+  });
+  batch(function () {
+    return removals.forEach(function (_ref6) {
+      var index = _ref6.index,
+        onClick = _ref6.onClick;
+      field.remove(index);
+      onRemove === null || onRemove === void 0 || onRemove(index);
+      if (typeof onClick === 'function') onClick(event);
+    });
+  });
+  return true;
+}
+
+/** 公共明细表格的勾选及批量删除，沿用业务行权限、行标识与删除通知。@author nokecy */
+export function useArrayTableBatchRemove(field, sources, props, apiRef, getId) {
+  var _useState = useState(0),
+    _useState2 = _slicedToArray(_useState, 2),
+    selectedCount = _useState2[0],
+    setSelectedCount = _useState2[1];
+  var _Modal$useModal = Modal.useModal(),
+    _Modal$useModal2 = _slicedToArray(_Modal$useModal, 2),
+    modal = _Modal$useModal2[0],
+    contextHolder = _Modal$useModal2[1];
+  var actions = collectRemovalActions(sources);
+  var enabled = props.batchRemove !== false && !props.disabled && field.pattern === 'editable' && !field.disabled && actions.length > 0;
+  var indices = new Map((field.value || []).map(function (row, index) {
+    return [getId(row), index];
+  }));
+  var removableIds = new Set(Array.from(indices).filter(function (_ref7) {
+    var _ref8 = _slicedToArray(_ref7, 2),
+      index = _ref8[1];
+    return !!findRemovalAction(field, index, actions);
+  }).map(function (_ref9) {
+    var _ref10 = _slicedToArray(_ref9, 1),
+      id = _ref10[0];
+    return id;
+  }));
+  var eligibilityKey = JSON.stringify(Array.from(removableIds));
+  var canRemove = function canRemove(node) {
+    if (node.rowPinned || !node.data) return false;
+    return removableIds.has(getId(node.data));
+  };
+  var businessSelectable = _typeof(props.rowSelection) === 'object' ? props.rowSelection.isRowSelectable : undefined;
+  var latest = React.useRef({
+    actions: actions,
+    enabled: enabled,
+    canRemove: canRemove,
+    onRemove: props.onRemove,
+    businessSelectable: businessSelectable
+  });
+  latest.current = {
+    actions: actions,
+    enabled: enabled,
+    canRemove: canRemove,
+    onRemove: props.onRemove,
+    businessSelectable: businessSelectable
+  };
+  var rowSelection = useMemo(function () {
+    var _configured$mode;
+    if (!enabled) return props.rowSelection;
+    var configured = _typeof(props.rowSelection) === 'object' ? props.rowSelection : undefined;
+    var businessSelectable = configured === null || configured === void 0 ? void 0 : configured.isRowSelectable;
+    var multiple = ((_configured$mode = configured === null || configured === void 0 ? void 0 : configured.mode) !== null && _configured$mode !== void 0 ? _configured$mode : props.rowSelection === 'single' ? 'singleRow' : 'multiRow') === 'multiRow';
+    return _objectSpread(_objectSpread(_objectSpread({
+      mode: multiple ? 'multiRow' : 'singleRow',
+      checkboxes: true,
+      enableClickSelection: false
+    }, multiple ? {
+      headerCheckbox: true,
+      selectAll: 'filtered'
+    } : {}), configured), {}, {
+      isRowSelectable: function isRowSelectable(node) {
+        return latest.current.canRemove(node) && (!businessSelectable || businessSelectable(node));
+      }
+    });
+  }, [enabled, props.rowSelection, eligibilityKey]);
+  var syncSelection = function syncSelection(api) {
+    return setSelectedCount(api.getSelectedNodes().filter(function (node) {
+      return latest.current.canRemove(node);
+    }).length);
+  };
+  useEffect(function () {
+    var api = apiRef.current;
+    if (api && !api.isDestroyed() && enabled) {
+      syncSelection(api);
+    }
+  }, [enabled, rowSelection]);
+  var confirmRemove = function confirmRemove(event) {
+    var api = apiRef.current;
+    if (!api || !latest.current.enabled) return;
+    var ids = api.getSelectedNodes().filter(function (node) {
+      return latest.current.canRemove(node);
+    }).map(function (node) {
+      return getId(node.data);
+    });
+    if (!ids.length) return;
+    modal.confirm({
+      title: '确认批量删除明细',
+      content: "\u5C06\u4ECE\u5F53\u524D\u8868\u5355\u79FB\u9664\u9009\u4E2D\u7684 ".concat(ids.length, " \u6761\u660E\u7EC6\uFF0C\u4FDD\u5B58\u540E\u4E0D\u53EF\u6062\u590D\u3002\u662F\u5426\u5220\u9664\uFF1F"),
+      okText: '删除',
+      okButtonProps: {
+        danger: true
+      },
+      onOk: function onOk() {
+        var current = latest.current;
+        if (api.isDestroyed()) return;
+        var stillSelectable = ids.every(function (id) {
+          var node = api.getRowNode(id);
+          return node && current.canRemove(node) && (!current.businessSelectable || current.businessSelectable(node));
+        });
+        if (!current.enabled || !stillSelectable || !removeSelectedRows(field, ids, current.actions, getId, current.onRemove, event)) {
+          modal.warning({
+            title: '明细已发生变化',
+            content: '部分明细已删除或不可删除，请重新选择后操作。'
+          });
+          return;
+        }
+        if (!api.isDestroyed()) api.deselectAll();
+        setSelectedCount(0);
+      }
+    });
+  };
+  return {
+    rowSelection: rowSelection,
+    selectionColumnDef: enabled ? _objectSpread({
+      pinned: 'left',
+      lockPosition: true,
+      width: 46,
+      resizable: false,
+      suppressHeaderMenuButton: true
+    }, props.selectionColumnDef) : props.selectionColumnDef,
+    onSelectionChanged: function onSelectionChanged(event) {
+      var _props$onSelectionCha;
+      syncSelection(event.api);
+      (_props$onSelectionCha = props.onSelectionChanged) === null || _props$onSelectionCha === void 0 || _props$onSelectionCha.call(props, event);
+    },
+    toolbar: /*#__PURE__*/_jsxs(_Fragment, {
+      children: [contextHolder, enabled && /*#__PURE__*/_jsxs(Space, {
+        children: [selectedCount > 0 && /*#__PURE__*/_jsxs(_Fragment, {
+          children: [/*#__PURE__*/_jsxs("span", {
+            children: ["\u5DF2\u9009 ", selectedCount, " \u9879"]
+          }), /*#__PURE__*/_jsx(Button, {
+            type: "link",
+            onClick: function onClick() {
+              var _apiRef$current;
+              return (_apiRef$current = apiRef.current) === null || _apiRef$current === void 0 ? void 0 : _apiRef$current.deselectAll();
+            },
+            children: "\u53D6\u6D88\u9009\u62E9"
+          })]
+        }), /*#__PURE__*/_jsx(Button, {
+          danger: true,
+          icon: /*#__PURE__*/_jsx(DeleteOutlined, {}),
+          disabled: !selectedCount,
+          onClick: confirmRemove,
+          children: "\u6279\u91CF\u5220\u9664"
+        })]
+      })]
+    })
+  };
+}

package/dist/esm/array-table/cellFocusScope.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+/**
+ * 判断「焦点离开了这个单元格」的作用域,给懒挂载格「用完卸回纯文本」用。
+ *
+ * 用 React 合成的 onFocus/onBlur 判断焦点变化:合成事件会沿 React 树冒泡,穿过 portal。
+ * 下拉面板、日期面板、选择对话框这类渲染到 body 上的弹层,焦点进去时对本格仍是「格内」。
+ * 同时监听指针离开:点击到不可聚焦的文本格或页面空白不会触发 blur,需要按点击位置恢复展示态；
+ * portal 内的指针事件仍沿 React 树到达本作用域,不会被当作离开。
+ *
+ * 离开不立刻判定,而是推到下一个任务再看:焦点从输入框换到格内别的元素(或弹层)时,
+ * blur 之后紧跟着 focus,后者会作废这次判定。单纯 blur 时若 activeElement 仍在格内
+ * (如窗口切走),不算离开；指针明确点击到作用域外则按离开处理。
+ *
+ * 用 display: contents,不产生盒子,不改变单元格里原有的布局。
+ *
+ * @author nokecy
+ */
+export type CellLeaveHandler = (isStale: () => boolean, hadFocus: boolean) => void;
+export declare const CellFocusScope: ({ onLeave, children }: {
+    onLeave: CellLeaveHandler;
+    children: React.ReactNode;
+}) => React.JSX.Element;

package/dist/esm/array-table/cellFocusScope.js

@@ -0,0 +1,143 @@
+import React, { useCallback, useContext, useEffect, useRef } from 'react';
+import { CellInteractionLockContext } from "./cellInteractionLock";
+
+/**
+ * 判断「焦点离开了这个单元格」的作用域,给懒挂载格「用完卸回纯文本」用。
+ *
+ * 用 React 合成的 onFocus/onBlur 判断焦点变化:合成事件会沿 React 树冒泡,穿过 portal。
+ * 下拉面板、日期面板、选择对话框这类渲染到 body 上的弹层,焦点进去时对本格仍是「格内」。
+ * 同时监听指针离开:点击到不可聚焦的文本格或页面空白不会触发 blur,需要按点击位置恢复展示态；
+ * portal 内的指针事件仍沿 React 树到达本作用域,不会被当作离开。
+ *
+ * 离开不立刻判定,而是推到下一个任务再看:焦点从输入框换到格内别的元素(或弹层)时,
+ * blur 之后紧跟着 focus,后者会作废这次判定。单纯 blur 时若 activeElement 仍在格内
+ * (如窗口切走),不算离开；指针明确点击到作用域外则按离开处理。
+ *
+ * 用 display: contents,不产生盒子,不改变单元格里原有的布局。
+ *
+ * @author nokecy
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+export var CellFocusScope = function CellFocusScope(_ref) {
+  var onLeave = _ref.onLeave,
+    children = _ref.children;
+  var rootRef = useRef(null);
+  var timerRef = useRef(undefined);
+  var dateTimerRef = useRef(undefined);
+  var acquireParentInteractionLock = useContext(CellInteractionLockContext);
+  // 通过 React portal 渲染到 body 的弹层仍属于当前格；记录经过本作用域的指针事件，
+  // 避免日期/下拉弹层中的点击被 document 级离开检测误判。@author nokecy
+  var pointerEventsInScopeRef = useRef(new WeakSet());
+  var focusWithinRef = useRef(false);
+  var interactionLocksRef = useRef(new Set());
+  // 每次焦点回到格内、或卸载时递增;进行中的异步判定拿它判断自己是否已过期
+  var generationRef = useRef(0);
+  var onLeaveRef = useRef(onLeave);
+  onLeaveRef.current = onLeave;
+  var cancel = useCallback(function () {
+    generationRef.current += 1;
+    window.clearTimeout(timerRef.current);
+    window.clearTimeout(dateTimerRef.current);
+  }, []);
+  var scheduleLeave = useCallback(function () {
+    var pointerLeftScope = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    var hadFocus = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : focusWithinRef.current;
+    var pointerEvent = arguments.length > 2 ? arguments[2] : undefined;
+    cancel();
+    var generation = generationRef.current;
+    timerRef.current = window.setTimeout(function () {
+      var _rootRef$current;
+      // 对话框仍打开时，按钮 loading、候选清空等引起的暂时失焦不结束整次选择交互。
+      // 结束条件由弹层自身关闭控制，避免连同弹窗一起卸成静默文本。@author nokecy
+      if (interactionLocksRef.current.size > 0) return;
+      // document 捕获先于 React portal 的捕获处理；到任务末再按完整的 React 作用域判定。
+      // 选择器弹层内的点击不结束当前格的编辑。@author nokecy
+      if (pointerEvent && pointerEventsInScopeRef.current.has(pointerEvent)) return;
+      // blur 后 activeElement 仍在本格通常是窗口切走或格内弹层切焦点，不算离开。
+      // 指针明确点到本格/其弹层之外时，即使目标不可聚焦导致 activeElement 没变，也应离开。
+      if (!pointerLeftScope && (_rootRef$current = rootRef.current) !== null && _rootRef$current !== void 0 && _rootRef$current.contains(document.activeElement)) return;
+      onLeaveRef.current(function () {
+        return generation !== generationRef.current;
+      }, hadFocus);
+    }, 0);
+  }, [cancel]);
+  var acquireInteractionLock = useCallback(function () {
+    var lock = Symbol('cell-popup');
+    interactionLocksRef.current.add(lock);
+    cancel();
+    // Editable 与懒挂载格可以嵌套；弹层同时占用所有父格，防止外层先卸掉选择器。@author nokecy
+    var releaseParent = acquireParentInteractionLock === null || acquireParentInteractionLock === void 0 ? void 0 : acquireParentInteractionLock();
+    return function () {
+      if (!interactionLocksRef.current.delete(lock)) return;
+      releaseParent === null || releaseParent === void 0 || releaseParent();
+      // 弹层关闭后恢复通常的校验与静默流程；不是永久屏蔽失焦。
+      // 卸载时 ref 已移除，不为已经销毁的单元格再排任务。@author nokecy
+      if (interactionLocksRef.current.size === 0 && rootRef.current) scheduleLeave(true, true);
+    };
+  }, [cancel, scheduleLeave, acquireParentInteractionLock]);
+  var handleFocus = function handleFocus() {
+    focusWithinRef.current = true;
+    cancel();
+  };
+  var handleBlur = function handleBlur() {
+    var hadFocus = focusWithinRef.current;
+    focusWithinRef.current = false;
+    scheduleLeave(false, hadFocus);
+  };
+  var handlePointerDownCapture = function handlePointerDownCapture(event) {
+    pointerEventsInScopeRef.current.add(event.nativeEvent);
+    // 再次点击原输入框不一定产生 focus，仍须作废此前离开时发起的异步校验。@author nokecy
+    cancel();
+  };
+  var handleClickCapture = function handleClickCapture(event) {
+    var target = event.target;
+    if (!(target instanceof Element)) return;
+    // DatePicker 选中日期后会关闭弹层，但通常把焦点留在输入框里，单靠 blur 无法恢复静默态。
+    // 只处理日期面板里的提交动作；范围日期选择第一端后面板仍开着，不会提前退出编辑。
+    // @author nokecy
+    var selected = target.closest('.ant-picker-dropdown .ant-picker-cell-inner, .ant-picker-dropdown .ant-picker-ok, .ant-picker-dropdown .ant-picker-today-btn, .ant-picker-dropdown .ant-picker-now-btn');
+    if (!selected) return;
+    var dropdown = selected.closest('.ant-picker-dropdown');
+    window.clearTimeout(dateTimerRef.current);
+    var generation = generationRef.current;
+    dateTimerRef.current = window.setTimeout(function () {
+      if (generation !== generationRef.current || !rootRef.current) return;
+      if (dropdown !== null && dropdown !== void 0 && dropdown.isConnected && !dropdown.classList.contains('ant-picker-dropdown-hidden')) return;
+      scheduleLeave(true, true);
+    }, 0);
+  };
+  useEffect(function () {
+    var handleDocumentPointerDown = function handleDocumentPointerDown(event) {
+      var root = rootRef.current;
+      if (!root) return;
+      var target = event.target;
+      // DOM 内点击以及 React portal 子树内点击都属于当前格的交互。
+      if (target instanceof Node && root.contains(target) || pointerEventsInScopeRef.current.has(event)) return;
+      // 新增行的必填空格也会预先挂载控件，但可能从未获得焦点；同样需要响应离开，
+      // 由 onLeave 根据 hadFocus 决定是否校验未触碰的空必填格。@author nokecy
+      scheduleLeave(true, focusWithinRef.current, event);
+    };
+
+    // 捕获阶段也能收到被表单控件阻止冒泡的点击，避免必须点工具栏才退出编辑。
+    // portal 的归属在延迟任务中确认。@author nokecy
+    document.addEventListener('pointerdown', handleDocumentPointerDown, true);
+    return function () {
+      document.removeEventListener('pointerdown', handleDocumentPointerDown, true);
+      cancel();
+    };
+  }, [cancel, scheduleLeave]);
+  return /*#__PURE__*/_jsx(CellInteractionLockContext.Provider, {
+    value: acquireInteractionLock,
+    children: /*#__PURE__*/_jsx("div", {
+      ref: rootRef,
+      style: {
+        display: 'contents'
+      },
+      onFocusCapture: handleFocus,
+      onBlurCapture: handleBlur,
+      onClickCapture: handleClickCapture,
+      onPointerDownCapture: handlePointerDownCapture,
+      children: children
+    })
+  });
+};

package/dist/esm/array-table/cellInteractionLock.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+/**
+ * 单元格弹层的交互占用。最后一个弹层关闭前，暂时失焦不能卸载单元格。
+ * 不在懒单元格中使用时无需任何额外处理。
+ * @author nokecy
+ */
+export declare const CellInteractionLockContext: import("react").Context<(() => () => void) | undefined>;
+/**
+ * 将弹层的打开状态绑定到所属单元格，支持嵌套弹层并在关闭或卸载时释放。
+ * 使用布局阶段同步占用，避免打开弹层的同一次交互产生的失焦任务先卸载控件。
+ * @author nokecy
+ */
+export declare const useCellInteractionLock: (open: boolean) => void;

package/dist/esm/array-table/cellInteractionLock.js

@@ -0,0 +1,21 @@
+import { createContext, useContext, useLayoutEffect } from 'react';
+
+/**
+ * 单元格弹层的交互占用。最后一个弹层关闭前，暂时失焦不能卸载单元格。
+ * 不在懒单元格中使用时无需任何额外处理。
+ * @author nokecy
+ */
+export var CellInteractionLockContext = /*#__PURE__*/createContext(undefined);
+
+/**
+ * 将弹层的打开状态绑定到所属单元格，支持嵌套弹层并在关闭或卸载时释放。
+ * 使用布局阶段同步占用，避免打开弹层的同一次交互产生的失焦任务先卸载控件。
+ * @author nokecy
+ */
+export var useCellInteractionLock = function useCellInteractionLock(open) {
+  var acquire = useContext(CellInteractionLockContext);
+  useLayoutEffect(function () {
+    if (open) return acquire === null || acquire === void 0 ? void 0 : acquire();
+    return undefined;
+  }, [acquire, open]);
+};

package/dist/esm/array-table/columnAlign.d.ts

@@ -0,0 +1,8 @@
+import type { ColDef } from 'ag-grid-community';
+/** 明细列对齐：沿用 antd Table 的 `align` 写法。@author nokecy */
+export type ColumnAlign = 'left' | 'center' | 'right';
+/**
+ * 按列上的 `align` 补单元格与列头的对齐类名；没写或写错时原样返回。
+ * 对齐样式见 theme.ts（单元格里正在编辑的输入框同样跟随列对齐）。
+ */
+export declare function withColumnAlign(column: ColDef, align: unknown): ColDef;

package/dist/esm/array-table/columnAlign.js

@@ -0,0 +1,35 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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 _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 _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 _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; }
+/** 明细列对齐：沿用 antd Table 的 `align` 写法。@author nokecy */
+
+var appendClass = function appendClass(original, extra) {
+  var merge = function merge(classes) {
+    return Array.from(new Set([].concat(_toConsumableArray(Array.isArray(classes) ? classes : classes ? [classes] : []), [extra])));
+  };
+  return typeof original === 'function' ? function (params) {
+    return merge(original(params));
+  } : merge(original);
+};
+
+/**
+ * 按列上的 `align` 补单元格与列头的对齐类名；没写或写错时原样返回。
+ * 对齐样式见 theme.ts（单元格里正在编辑的输入框同样跟随列对齐）。
+ */
+export function withColumnAlign(column, align) {
+  if (align !== 'left' && align !== 'center' && align !== 'right') return column;
+  return _objectSpread(_objectSpread({}, column), {}, {
+    cellClass: appendClass(column.cellClass, "qc-array-table-align-".concat(align))
+  }, align === 'right' ? {
+    headerClass: appendClass(column.headerClass, 'ag-right-aligned-header')
+  } : {});
+}

package/dist/esm/array-table/columnGroup.d.ts

@@ -0,0 +1,39 @@
+/**
+ * ArrayTable 分组表头(多级表头)。
+ *
+ * 背景:schema 里的每个 ArrayTable.Column 被抽成「扁平」列定义(buildArrayTableColumns),
+ * 内部一批逻辑(懒挂载列识别、列方案还原、首列拖拽等)都按扁平列取值,不能改。
+ * 所以分组只在「交给 AG-Grid 的那一份 columnDefs」上做:
+ *  1. buildArrayTableColumns 生成列定义时,用 markHeaderGroup 把列声明的 headerGroup 记下来;
+ *  2. index.tsx 把扁平列定义交给 groupColumnDefs,得到含列组的 columnDefs 传给 AgGridReact。
+ *
+ * 分组名记在模块内的 WeakMap 里,不往 colDef 上塞自定义字段——AG-Grid 会把未知属性当作错误告警。
+ *
+ * 只支持一级分组;分组名相同但不相邻的列各自成组。
+ *
+ * @author nokecy
+ */
+import type { ColDef, ColGroupDef } from 'ag-grid-community';
+/**
+ * 记下列定义所属的表头分组。
+ * headerGroup 不是非空字符串(没声明、空串、纯空白)时不做任何事,该列按无分组处理。
+ * 返回传入的 colDef 本身,方便链式使用。
+ */
+export declare const markHeaderGroup: <T extends object>(colDef: T, headerGroup: unknown) => T;
+/**
+ * 把扁平列定义按「相邻且 headerGroup 相同」合并成 AG-Grid 列组。
+ *
+ *  - 相邻同名的列 -> 一个 { headerName, groupId, children } 列组;
+ *  - 同名但被别的列隔开 -> 各自成组,groupId 各不相同;
+ *  - 没声明分组的列原样保留(同一个对象);
+ *  - 一个分组也没有时直接返回传入的数组本身,没用到分组的表格行为零变化。
+ *
+ * groupId 由分组名派生(同名第 N 次出现追加 _N),同样的输入永远得到同样的 id:
+ * columnDefs 因别的原因重建时,AG-Grid 靠 groupId 认出还是那个列组,列组状态不丢。
+ *
+ * 有意不设 marryChildren:设了以后,任何打破组内相邻的列顺序(用户旧的扁平列方案、
+ * 列设置面板里跨组拖动的实时预览)都会被 AG-Grid 整体丢弃并报 error #39;不设则顺序照常生效,
+ * 组被隔开时表头显示成多段。
+ * openByDefault:列组默认展开(只对配了 columnGroupShow 的可折叠列组有意义)。
+ */
+export declare const groupColumnDefs: (colDefs: ColDef[]) => (ColDef | ColGroupDef)[];