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

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

@@ -0,0 +1,308 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collectRemovalActions = collectRemovalActions;
+exports.findRemovalAction = findRemovalAction;
+exports.removeSelectedRows = removeSelectedRows;
+exports.useArrayTableBatchRemove = useArrayTableBatchRemove;
+var _react = _interopRequireWildcard(require("react"));
+var _antd = require("antd");
+var _icons = require("@ant-design/icons");
+var _formilyReactive = require("@nokecy/formily-reactive");
+var _jsxRuntime = require("react/jsx-runtime");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(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; }
+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; } /** 标准删除控件在行内的字段路径与静态约束。@author nokecy */
+/** 收集标准删除入口，保留列级显隐约束，不把其他业务按钮当成删除。@author nokecy */
+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
+ */
+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
+ */
+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
+    };
+  });
+  (0, _formilyReactive.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 */
+function useArrayTableBatchRemove(field, sources, props, apiRef, getId) {
+  var _useState = (0, _react.useState)(0),
+    _useState2 = _slicedToArray(_useState, 2),
+    selectedCount = _useState2[0],
+    setSelectedCount = _useState2[1];
+  var _Modal$useModal = _antd.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.default.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 = (0, _react.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);
+  };
+  (0, _react.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__*/(0, _jsxRuntime.jsxs)(_jsxRuntime.Fragment, {
+      children: [contextHolder, enabled && /*#__PURE__*/(0, _jsxRuntime.jsxs)(_antd.Space, {
+        children: [selectedCount > 0 && /*#__PURE__*/(0, _jsxRuntime.jsxs)(_jsxRuntime.Fragment, {
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)("span", {
+            children: ["\u5DF2\u9009 ", selectedCount, " \u9879"]
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_antd.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__*/(0, _jsxRuntime.jsx)(_antd.Button, {
+          danger: true,
+          icon: /*#__PURE__*/(0, _jsxRuntime.jsx)(_icons.DeleteOutlined, {}),
+          disabled: !selectedCount,
+          onClick: confirmRemove,
+          children: "\u6279\u91CF\u5220\u9664"
+        })]
+      })]
+    })
+  };
+}

package/dist/cjs/array-table/cellEditorMarker.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+/** 格内控件的稳定标记值，键盘与浏览器测试按它定位，不依赖 antd 的内部类名。 */
+export type CellEditorKind = 'select' | 'date' | 'number' | 'text';
+/** 按 x-component 判定控件类别；开关、业务自定义组件等不在表内，不打标记（避免误导）。 */
+export declare const resolveCellEditorKind: (component: unknown) => CellEditorKind | undefined;
+/**
+ * 面板是否展开：下拉看 antd 的 open 类；日期面板挂在 body 下，只能「控件聚焦且存在可见面板」近似判断。
+ * 直接读 DOM 而不进 React 状态，避免每次开合让整格重渲。
+ */
+export declare const isCellEditorOpen: (root: Element, kind: CellEditorKind) => boolean;
+/**
+ * 给格内控件加 data-array-cell-editor / data-open 标记。display:contents 不产生盒子，不改变格内布局。
+ * 没有类别（不认识的组件）时原样返回子节点。@author nokecy
+ */
+export declare const CellEditorMarker: ({ kind, children }: {
+    kind?: CellEditorKind | undefined;
+    children: React.ReactNode;
+}) => React.JSX.Element;

package/dist/cjs/array-table/cellEditorMarker.js

@@ -0,0 +1,92 @@
+"use strict";
+
+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); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveCellEditorKind = exports.isCellEditorOpen = exports.CellEditorMarker = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _jsxRuntime = require("react/jsx-runtime");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(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; }
+/** 格内控件的稳定标记值，键盘与浏览器测试按它定位，不依赖 antd 的内部类名。 */
+
+var KIND_BY_COMPONENT = {
+  Select: 'select',
+  TreeSelect: 'select',
+  Cascader: 'select',
+  DatePicker: 'date',
+  'DatePicker.RangePicker': 'date',
+  TimePicker: 'date',
+  'TimePicker.RangePicker': 'date',
+  InputNumber: 'number',
+  NumberPicker: 'number',
+  Input: 'text',
+  'Input.TextArea': 'text',
+  Password: 'text'
+};
+
+/** 按 x-component 判定控件类别；开关、业务自定义组件等不在表内，不打标记（避免误导）。 */
+var resolveCellEditorKind = exports.resolveCellEditorKind = function resolveCellEditorKind(component) {
+  return typeof component === 'string' ? KIND_BY_COMPONENT[component] : undefined;
+};
+
+/**
+ * 面板是否展开：下拉看 antd 的 open 类；日期面板挂在 body 下，只能「控件聚焦且存在可见面板」近似判断。
+ * 直接读 DOM 而不进 React 状态，避免每次开合让整格重渲。
+ */
+var isCellEditorOpen = exports.isCellEditorOpen = function isCellEditorOpen(root, kind) {
+  if (kind === 'select') return !!root.querySelector('.ant-select-open');
+  if (kind === 'date') {
+    return !!root.querySelector('.ant-picker-focused') && !!document.querySelector('.ant-picker-dropdown:not(.ant-picker-dropdown-hidden)');
+  }
+  return false;
+};
+
+/**
+ * 给格内控件加 data-array-cell-editor / data-open 标记。display:contents 不产生盒子，不改变格内布局。
+ * 没有类别（不认识的组件）时原样返回子节点。@author nokecy
+ */
+var CellEditorMarker = exports.CellEditorMarker = function CellEditorMarker(_ref) {
+  var kind = _ref.kind,
+    children = _ref.children;
+  var ref = (0, _react.useRef)(null);
+  (0, _react.useEffect)(function () {
+    var root = ref.current;
+    if (!root || !kind || kind !== 'select' && kind !== 'date') return;
+    var sync = function sync() {
+      if (isCellEditorOpen(root, kind)) root.setAttribute('data-open', '1');else root.removeAttribute('data-open');
+    };
+    // 弹层开合发生在 antd 内部，类名变化与聚焦/点击/按键之后下一拍再读一次。
+    var later = function later() {
+      window.setTimeout(sync, 0);
+    };
+    var observer = new MutationObserver(sync);
+    observer.observe(root, {
+      subtree: true,
+      attributes: true,
+      attributeFilter: ['class']
+    });
+    var events = ['focusin', 'focusout', 'click', 'keyup'];
+    events.forEach(function (name) {
+      return root.addEventListener(name, later);
+    });
+    return function () {
+      observer.disconnect();
+      events.forEach(function (name) {
+        return root.removeEventListener(name, later);
+      });
+    };
+  }, [kind]);
+  if (!kind) return /*#__PURE__*/(0, _jsxRuntime.jsx)(_jsxRuntime.Fragment, {
+    children: children
+  });
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+    ref: ref,
+    "data-array-cell-editor": kind,
+    style: {
+      display: 'contents'
+    },
+    children: children
+  });
+};

package/dist/cjs/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/cjs/array-table/cellFocusScope.js

@@ -0,0 +1,152 @@
+"use strict";
+
+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); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CellFocusScope = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _cellInteractionLock = require("./cellInteractionLock");
+var _jsxRuntime = require("react/jsx-runtime");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(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; }
+/**
+ * 判断「焦点离开了这个单元格」的作用域,给懒挂载格「用完卸回纯文本」用。
+ *
+ * 用 React 合成的 onFocus/onBlur 判断焦点变化:合成事件会沿 React 树冒泡,穿过 portal。
+ * 下拉面板、日期面板、选择对话框这类渲染到 body 上的弹层,焦点进去时对本格仍是「格内」。
+ * 同时监听指针离开:点击到不可聚焦的文本格或页面空白不会触发 blur,需要按点击位置恢复展示态；
+ * portal 内的指针事件仍沿 React 树到达本作用域,不会被当作离开。
+ *
+ * 离开不立刻判定,而是推到下一个任务再看:焦点从输入框换到格内别的元素(或弹层)时,
+ * blur 之后紧跟着 focus,后者会作废这次判定。单纯 blur 时若 activeElement 仍在格内
+ * (如窗口切走),不算离开；指针明确点击到作用域外则按离开处理。
+ *
+ * 用 display: contents,不产生盒子,不改变单元格里原有的布局。
+ *
+ * @author nokecy
+ */
+
+var CellFocusScope = exports.CellFocusScope = function CellFocusScope(_ref) {
+  var onLeave = _ref.onLeave,
+    children = _ref.children;
+  var rootRef = (0, _react.useRef)(null);
+  var timerRef = (0, _react.useRef)(undefined);
+  var dateTimerRef = (0, _react.useRef)(undefined);
+  var acquireParentInteractionLock = (0, _react.useContext)(_cellInteractionLock.CellInteractionLockContext);
+  // 通过 React portal 渲染到 body 的弹层仍属于当前格；记录经过本作用域的指针事件，
+  // 避免日期/下拉弹层中的点击被 document 级离开检测误判。@author nokecy
+  var pointerEventsInScopeRef = (0, _react.useRef)(new WeakSet());
+  var focusWithinRef = (0, _react.useRef)(false);
+  var interactionLocksRef = (0, _react.useRef)(new Set());
+  // 每次焦点回到格内、或卸载时递增;进行中的异步判定拿它判断自己是否已过期
+  var generationRef = (0, _react.useRef)(0);
+  var onLeaveRef = (0, _react.useRef)(onLeave);
+  onLeaveRef.current = onLeave;
+  var cancel = (0, _react.useCallback)(function () {
+    generationRef.current += 1;
+    window.clearTimeout(timerRef.current);
+    window.clearTimeout(dateTimerRef.current);
+  }, []);
+  var scheduleLeave = (0, _react.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 = (0, _react.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);
+  };
+  (0, _react.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__*/(0, _jsxRuntime.jsx)(_cellInteractionLock.CellInteractionLockContext.Provider, {
+    value: acquireInteractionLock,
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+      ref: rootRef,
+      style: {
+        display: 'contents'
+      },
+      onFocusCapture: handleFocus,
+      onBlurCapture: handleBlur,
+      onClickCapture: handleClickCapture,
+      onPointerDownCapture: handlePointerDownCapture,
+      children: children
+    })
+  });
+};

package/dist/cjs/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/cjs/array-table/cellInteractionLock.js

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

package/dist/cjs/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;