umy-ui-table 1.2.4 → 1.2.6

package/packages/ux-grid/test/compatibility.cjs

@@ -0,0 +1,176 @@
+// Run: node packages/ux-grid/test/compatibility.cjs
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const vm = require('vm');
+const root = path.resolve(__dirname, '..');
+const source = file => fs.readFileSync(path.join(root, file), 'utf8');
+const registered = {};
+const existing = { renderTableEdit: () => 'custom' };
+registered.ElInput = existing;
+const loadRenderers = registry => vm.runInNewContext(source('src/element-renderer.js').replace(/^import .*;$/gm, ''), {
+  XEUtils: require('xe-utils'),
+  renderer: { get: name => registry[name], add: (name, config) => { registry[name] = config; } },
+  interceptor: {
+    callbacks: {},
+    get(name) { return this.callbacks[name] || []; },
+    add(name, callback) { (this.callbacks[name] || (this.callbacks[name] = [])).push(callback); }
+  }
+});
+loadRenderers(registered);
+const h = (tag, data, children) => ({ tag, data, children });
+let updates = 0;
+const params = { row: { value: 1 }, column: { field: 'value' }, $table: { updateStatus() { updates++; } } };
+const select = { name: 'ElSelect', optionProps: { value: 'id', label: 'text', disabled: 'locked' },
+  optionGroupProps: { label: 'title', options: 'items' },
+  optionGroups: [{ title: 'Group', items: [{ id: 1, text: 'One', locked: true }] }] };
+const edit = registered.ElSelect.renderTableEdit(h, select, params)[0];
+assert.equal(edit.children[0].tag, 'el-option-group');
+assert.equal(edit.children[0].children[0].data.props.disabled, true);
+edit.data.on.input(2);
+assert.equal(params.row.value, 2);
+assert.equal(updates, 0, 'Select input writes value without prematurely validating');
+edit.data.on.change(2);
+assert.equal(updates, 1);
+assert.strictEqual(registered.ElInput, existing, 'preserve user renderer');
+assert.equal(registered.ElButtons.renderTableDefault(h, { children: [{ content: 'Edit' }] }, params)[0].tag, 'ElButton');
+let checked;
+let filterUpdates = 0;
+const filterOption = { data: [1] };
+const filter = registered.ElSelect.renderTableFilter(h, { name: 'ElSelect', props: { multiple: true } }, {
+  column: { filters: [filterOption] }, $panel: { changeOption(event, value) { checked = value; filterUpdates++; } }
+})[0];
+filter.data.on.input([]);
+assert.equal(filterOption.data.length, 0);
+assert.equal(filterUpdates, 0, 'Select filter input only writes the pending value');
+filter.data.on.change([]);
+assert.equal(checked, false);
+assert.equal(filterUpdates, 1);
+
+// Validate the observable event contract in all three renderer contexts. Element
+// emits input before change/select; user handlers must still run exactly once.
+const eventRenderers = {};
+loadRenderers(eventRenderers);
+for (const name of ['ElInput', 'ElInputNumber', 'ElSelect', 'ElAutocomplete']) {
+  const statusEvent = name === 'ElAutocomplete' ? 'select'
+    : name === 'ElInput' || name === 'ElInputNumber' ? 'input' : 'change';
+  for (const context of ['edit', 'filter', 'form']) {
+    let count = 0;
+    const seen = [];
+    const events = Object.fromEntries(['input', 'change', 'select'].map(event => [event,
+      (received, value) => { assert.strictEqual(received, eventParams); seen.push([event, value]); }]));
+    const eventParams = {
+      row: { value: 1 }, column: { field: 'value', filters: [{ data: 1 }] },
+      data: { value: 1 }, field: 'value',
+      $table: { updateStatus() { count++; } },
+      $panel: { changeOption() { count++; } },
+      $form: { updateStatus() { count++; } }
+    };
+    const method = context === 'edit' ? 'renderTableEdit'
+      : context === 'filter' ? 'renderTableFilter' : 'renderFormItemContent';
+    const ons = eventRenderers[name][method](h, { name, events }, eventParams)[0].data.on;
+    ons.input(2);
+    assert.equal(context === 'edit' ? eventParams.row.value
+      : context === 'filter' ? eventParams.column.filters[0].data : eventParams.data.value, 2);
+    assert.equal(count, statusEvent === 'input' ? 1 : 0, `${name} ${context} input timing`);
+    ons.change(2);
+    assert.equal(count, statusEvent === 'select' ? 0 : 1, `${name} ${context} change timing`);
+    ons.select(2);
+    assert.equal(count, 1, `${name} ${context} updates once per interaction`);
+    assert.deepStrictEqual(seen, [['input', 2], ['change', 2], ['select', 2]]);
+  }
+}
+for (const [name, value] of [['ElSwitch', false], ['ElInputNumber', 0]]) {
+  const option = { data: null };
+  let enabled;
+  const ons = eventRenderers[name].renderTableFilter(h, { name }, {
+    column: { filters: [option] }, $panel: { changeOption(event, state) { enabled = state; } }
+  })[0].data.on;
+  ons.input(value);
+  if (ons.change) ons.change(value);
+  assert.strictEqual(option.data, value);
+  assert.equal(enabled, true, `${name} retains valid false/zero filters`);
+}
+params.row.value = '09:30';
+assert.equal(registered.ElTimeSelect.renderTableCell(h, { name: 'ElTimeSelect' }, params)[0], '09:30');
+params.row.value = ['20260905', '20260906'];
+params.column.editRender = { name: 'ElDatePicker', props: { valueFormat: 'yyyyMMdd', type: 'dates' } };
+assert.equal(registered.ElDatePicker.tableExportMethod(params), '2026-09-05, 2026-09-06');
+params.row.value = '20260905';
+params.column.filterRender = { props: { type: 'daterange', valueFormat: 'yyyyMMdd', format: 'dd/MM/yyyy' } };
+assert.equal(registered.ElDatePicker.tableFilterDefaultMethod(Object.assign({ option: { data: ['20260831', '20260906'] } }, params)), true);
+params.row.value = 1;
+const remote = { props: { remote: true }, options: [{ value: 1, label: 'One' }] };
+assert.equal(registered.ElSelect.renderTableCell(h, remote, params)[0], 'One');
+remote.options = [];
+assert.equal(registered.ElSelect.renderTableCell(h, remote, params)[0], 'One');
+const form = { data: { value: [] }, field: 'value', $form: { updateStatus() {} } };
+const group = registered.ElCheckbox.renderFormItemContent(h, {
+  name: 'ElCheckbox', options: [{ value: 1, label: 'One' }]
+}, form)[0];
+assert.equal(group.tag, 'ElCheckboxGroup');
+group.data.on.input([1]);
+assert.equal(form.data.value[0], 1);
+const cascader = { name: 'ElCascader', props: { options: [{ id: 1, text: 'Parent', nodes: [{ id: 2, text: 'Child' }, { id: 3, text: 'Other' }] }], props: { value: 'id', label: 'text', children: 'nodes', emitPath: false } } };
+params.row.value = 2;
+assert.equal(registered.ElCascader.renderTableCell(h, cascader, params)[0], 'Parent / Child');
+cascader.props.props.multiple = true;
+params.row.value = [2, 3];
+assert.equal(registered.ElCascader.renderTableCell(h, cascader, params)[0], 'Parent / Child, Parent / Other');
+cascader.props.props.emitPath = true;
+params.row.value = [[1, 2], [1, 3]];
+assert.equal(registered.ElCascader.renderTableCell(h, cascader, params)[0], 'Parent / Child, Parent / Other');
+cascader.props.showAllLevels = false;
+assert.equal(registered.ElCascader.renderTableCell(h, cascader, params)[0], 'Child, Other');
+
+const context = { Vue: {}, draggable: {}, ElPagination: {}, ElCheckbox: {}, ElButton: {}, VxeGrid: {}, uxGridMixin: {}, console };
+vm.runInNewContext(source('src/ux-grid.vue').split('<script type="text/babel">')[1].split('</script>')[0]
+  .replace(/^import .*;$/gm, '').replace('export default', 'component ='), context);
+const methods = context.component.methods;
+const column = (slot, children) => ({ componentOptions: {
+  Ctor: { options: { name: 'UxTableColumn' } }, propsData: { field: 'value' }, children
+}, data: { scopedSlots: slot ? { default: slot } : {} } });
+const state = Object.assign({ $slots: { default: [column(() => 'old')] } }, methods);
+state.syncSlotColumns();
+const first = state.slotColumns;
+state.syncSlotColumns();
+assert.strictEqual(state.slotColumns, first, 'self update must not reload columns');
+state.$slots.default = [column(() => 'new')];
+state.syncSlotColumns();
+assert.equal(state.slotColumns[0].slots.default(), 'new');
+assert.strictEqual(state.slotColumns, first, 'render-only update preserves column configuration identity');
+const text = { text: 'static content' };
+assert.strictEqual(state.vnodeToColumn(column(null, [text])).slots.default()[0], text);
+assert.equal(state.vnodeToColumn(column(null, [column()])).children.length, 1);
+const configured = [{ field: 'configured' }];
+state.columns = configured;
+state.$slots.default = [];
+state.syncSlotColumns();
+assert.strictEqual(context.component.computed.tableColumns.call(state), configured, 'explicit columns retain priority');
+for (const axis of ['X', 'Y']) {
+  const scroll = 'scroll' + axis;
+  const virtual = 'virtual' + axis + 'Config';
+  const evaluate = (legacy, modern, spanMethod) => {
+    const instance = { [scroll]: legacy, [virtual]: modern, spanMethod, $options: { propsData: { [scroll]: legacy, [virtual]: modern } } };
+    instance[scroll + 'Config'] = context.component.computed[scroll + 'Config'].call(instance);
+    return context.component.computed['computedVirtual' + axis + 'Config'].call(instance);
+  };
+  const legacy = { gt: 0, oSize: 8 };
+  const compatible = evaluate(legacy);
+  assert.equal(compatible.enabled, true, 'legacy ' + scroll + ' enables virtualization without explicit enabled');
+  assert.equal(compatible.gt, 0);
+  assert.equal(compatible.oSize, 8);
+  assert.equal(legacy.enabled, undefined, 'normalization does not mutate caller configuration');
+  assert.equal(evaluate({ gt: 0, enabled: undefined }).enabled, true);
+  assert.equal(evaluate({ enabled: false, gt: 0 }).enabled, false);
+  assert.equal(evaluate(legacy, null, () => null).enabled, false, 'spanMethod disables implicit virtual scroll');
+  assert.equal(evaluate({ enabled: true, gt: 0 }, null, () => null).enabled, true, 'explicit legacy enabled survives spanMethod');
+  assert.equal(evaluate({ enabled: false, gt: 0 }, null, () => null).enabled, false);
+  for (const enabled of [true, false, undefined]) {
+    const modern = { enabled, gt: 12, oSize: 6 };
+    assert.strictEqual(evaluate(legacy, modern, () => null), modern, 'new virtual config has unchanged priority');
+  }
+  const defaults = { enabled: true, gt: axis === 'Y' ? 100 : 24, oSize: 0 };
+  assert.equal(evaluate(defaults).gt, defaults.gt, 'modern default threshold preserved');
+}
+console.log('ux-grid compatibility regression checks passed');

package/packages/ux-grid/test/contracts.cjs

@@ -0,0 +1,281 @@
+// Wrapper contracts only: these assertions do not stand in for VXE integration.
+// Run: node packages/ux-grid/test/contracts.cjs
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const vm = require('vm');
+const Vue = require('vue');
+const root = path.resolve(__dirname, '..');
+const read = name => fs.readFileSync(path.join(root, name), 'utf8');
+const nodes = [];
+const document = {
+  createElement: () => ({ style: {} }),
+  body: {
+    appendChild(node) { nodes.push(node); node.parentNode = this; },
+    removeChild(node) { nodes.splice(nodes.indexOf(node), 1); node.parentNode = null; }
+  }
+};
+const context = { XEUtils: require('xe-utils'), isArrayFn: Array.isArray, console,
+  document, setTimeout, clearTimeout, Promise };
+vm.runInNewContext(read('src/dialog-draft.js').replace(/^import .*;$/gm, '').replace(/export function/g, 'function'), context);
+vm.runInNewContext(read('mixins/index.js').replace(/^import .*;$/gm, '').replace('export default', 'mixin ='), context);
+const methods = context.mixin.methods;
+const events = [];
+const state = Object.assign({ $listeners: {}, $refs: {}, $emit: (...args) => events.push(args),
+  $nextTick: () => Promise.resolve() }, methods);
+const tick = async () => { for (let i = 0; i < 8; i++) await Promise.resolve(); };
+
+async function run() {
+  // Real Vue listener bookkeeping: $off leaves empty arrays, $once removes itself.
+  const listenerVm = new Vue({ methods });
+  const selectedRows = [{ id: 1 }];
+  let reads = 0;
+  listenerVm.$refs.singleTable = {
+    getCheckboxRecords() { reads++; return selectedRows; },
+    setAllCheckboxRow() {}, clearCheckboxRow() {}, setCheckboxRow() {}, toggleCheckboxRow() {}
+  };
+  for (const [event, method] of [['select', 'plSelect'], ['select-all', 'selectAll'], ['selection-change', 'plSelect']]) {
+    let received;
+    const callback = value => { received = value; };
+    listenerVm.$on(event, callback);
+    listenerVm[method]({ row: selectedRows[0] });
+    assert.strictEqual(received, selectedRows);
+    listenerVm.$off(event, callback);
+    const before = reads;
+    listenerVm[method]({});
+    assert.equal(reads, before, '$off retains lazy selection reads');
+    received = null;
+    listenerVm.$once(event, callback);
+    listenerVm[method]({});
+    assert.strictEqual(received, selectedRows);
+    const afterOnce = reads;
+    listenerVm[method]({});
+    assert.equal(reads, afterOnce, '$once removal retains lazy reads');
+  }
+  let programEvents = 0;
+  listenerVm.$on('selection-change', () => programEvents++);
+  listenerVm.toggleAllSelection();
+  listenerVm.clearSelection();
+  listenerVm.newtoggleRowSelections([{ row: selectedRows[0], selected: true }]);
+  assert.equal(programEvents, 3);
+  listenerVm.$off();
+  const beforeProgram = reads;
+  listenerVm.toggleAllSelection(); listenerVm.clearSelection();
+  assert.equal(reads, beforeProgram);
+  listenerVm.$destroy();
+
+  const kernelContext = { Promise, VxeGrid: { methods: {} } };
+  vm.runInNewContext(read('src/grid-kernel.js').replace(/^import .*;$/gm, '').replace('export default', 'kernel ='), kernelContext);
+  const loadColumn = kernelContext.kernel.methods.loadColumn;
+  const active = {};
+  const marker = Promise.resolve('loaded');
+  const kernelArgs = [[], { extra: true }];
+  kernelContext.VxeGrid.methods.loadColumn = function (...values) {
+    assert.strictEqual(this, active);
+    assert.deepStrictEqual(values, kernelArgs);
+    return marker;
+  };
+  assert.strictEqual(loadColumn.apply(active, kernelArgs), marker);
+  const kernelFailure = new Error('kernel failure');
+  kernelContext.VxeGrid.methods.loadColumn = () => { throw kernelFailure; };
+  assert.throws(() => loadColumn.call(active), error => error === kernelFailure);
+  for (const flag of ['_isDestroyed', '_isBeingDestroyed']) {
+    assert.strictEqual(await loadColumn.call({ [flag]: true }), undefined);
+  }
+  const args = [{ row: 1 }, { column: 2 }, 'field'];
+  const token = Promise.resolve({ done: true });
+  // All simple public forwarding methods retain argument order and return type.
+  const forwarded = {
+    reloadData: 1, loadData: 1, reloadColumn: 1, loadColumn: 1, insertRow: 2,
+    reloadRow: 3, revertData: 1, updateFooter: 0, setFilter: 2, updateData: 0,
+    clearActived: 0, clearValidate: 0, getColumnByField: 1, getInsertRecords: 0,
+    getCheckboxRecords: 0, getTableColumn: 0, getColumnIndex: 1, getUpdateRecords: 0,
+    isUpdateByRow: 1, isCheckedByCheckboxRow: 1, isActiveByRow: 1, getTableData: 0,
+    getRowById: 1, toggleRowExpand: 1, setRowExpand: 2, setAllRowExpand: 1,
+    clearRowExpand: 0, setAllTreeExpand: 1, clearTreeExpand: 0, getTreeExpandRecords: 0,
+    toggleTreeExpand: 1, setTreeExpand: 2, isTreeExpandByRow: 1
+  };
+  for (const [name, count] of Object.entries(forwarded)) {
+    const kernelName = name === 'insertRow' ? 'insertAt' : name;
+    let received;
+    state.$refs.singleTable = { [kernelName](...values) { received = values; return token; } };
+    assert.strictEqual(state[name](...args.slice(0, count)), token, name + ' return');
+    assert.deepStrictEqual(received, args.slice(0, count), name + ' arguments');
+  }
+  const discarded = { setCurrentRow: 1, clearSort: 0, clearFilter: 1, sort: 2,
+    doLayout: 0, scrollToRow: 1, refreshColumn: 0, refreshScroll: 0,
+    setActiveRow: 1, setActiveCell: 2, updateStatus: 1, remove: 1, removeCheckboxRow: 0 };
+  for (const [name, count] of Object.entries(discarded)) {
+    let received;
+    state.$refs.singleTable = { [name === 'doLayout' ? 'recalculate' : name](...values) { received = values; return token; } };
+    assert.strictEqual(state[name](...args.slice(0, count)), undefined, name + ' return');
+    assert.deepStrictEqual(received, args.slice(0, count), name + ' arguments');
+    await tick();
+  }
+  let scrollArgs;
+  state.$refs.singleTable = { scrollTo(...values) { scrollArgs = values; return token; } };
+  assert.strictEqual(state.pagingScrollTopLeft(10, 20), undefined);
+  assert.deepStrictEqual(scrollArgs, [20, 10]);
+  const inserted = [];
+  state.$refs.singleTable = { getRecordset: () => ({ insertRecords: inserted, removeRecords: [{}] }) };
+  assert.strictEqual(state.getRecordset(), inserted);
+  assert.strictEqual(state.tableExample(), state.$refs.singleTable);
+  delete state.$refs.singleTable;
+  assert.strictEqual(state.tableExample(), undefined);
+  for (const name of ['validate', 'fullValidate']) {
+    for (const rows of [undefined, [], [{ value: 1 }]]) {
+      for (const fails of [false, true]) {
+        const result = { validation: fails ? 'error' : 'success' };
+        let received;
+        state.$refs.singleTable = { [name](...values) {
+          received = values;
+          return fails ? Promise.reject(result) : Promise.resolve(result);
+        } };
+        assert.strictEqual(await state[name](rows), result);
+        assert.deepStrictEqual(received, rows === undefined ? [] : [rows]);
+      }
+    }
+  }
+  const records = [{ selected: true }];
+  let scans = 0;
+  state.$refs.singleTable = { getCheckboxRecords() { scans++; return records; } };
+  for (const name of ['selectAll', 'plSelect']) {
+    state.$listeners = {};
+    state[name]({ records: () => { throw Error('must remain lazy without listeners'); } });
+    state.$listeners = { 'selection-change': true };
+    for (const value of [records, () => records, undefined]) {
+      state[name]({ records: value, row: args[0] });
+      assert.strictEqual(events.pop()[1], records);
+      events.pop();
+    }
+  }
+  assert.equal(scans, 2);
+  const operations = [];
+  state.$refs.singleTable = {
+    setCheckboxRow: (...values) => operations.push(['set', ...values]),
+    toggleCheckboxRow: row => operations.push(['toggle', row]),
+    setAllCheckboxRow: value => operations.push(['all', value]),
+    clearCheckboxRow: () => operations.push(['clear']),
+    getCheckboxRecords: () => records
+  };
+  state.$listeners = { 'selection-change': true };
+  const row = {};
+  assert.strictEqual(state.toggleRowSelection([{ row, selected: true }, { row, selected: false }, { row }]), undefined);
+  assert.deepStrictEqual(operations, [['set', row, true], ['set', row, false], ['toggle', row]]);
+  assert.strictEqual(events.pop()[1], records);
+  state.toggleAllSelection(); assert.deepStrictEqual(operations.pop(), ['all', true]);
+  assert.strictEqual(events.pop()[1], records);
+  state.clearSelection(); assert.deepStrictEqual(operations.pop(), ['clear']);
+  assert.strictEqual(events.pop()[1], records);
+  state.sortChange({ field: 'value', order: 'asc' });
+  assert.equal(events.pop()[1].prop, 'value');
+  state.sortChange({ property: 'old', field: 'new' });
+  assert.equal(events.pop()[1].prop, 'old');
+  for (const filters of [[], () => records]) {
+    state.filterChange({ field: 'value', filters });
+    const payload = events.pop()[1];
+    assert.equal(payload.property, 'value');
+    assert.strictEqual(payload.filters, typeof filters === 'function' ? records : filters);
+  }
+  const selected = { row: {}, column: {} };
+  const cell = {};
+  state.$listeners = { 'edit-currently-active': true };
+  state.$refs.singleTable = { recalculate: () => token, refreshColumn: () => token,
+    getSelectedCell: () => selected, getCellElement: () => cell };
+  events.length = 0;
+  state.doLayout(); state.refreshColumn(); state.dataRendered({});
+  await tick();
+  assert.equal(events.filter(event => event[0] === 'edit-currently-active').length, 1);
+  assert.strictEqual(events.find(event => event[0] === 'edit-currently-active')[1].cell, cell);
+  events.length = 0;
+  state.doLayout(); state.editCurrentlyActive(selected);
+  await tick();
+  assert.equal(events.length, 1, 'native selection suppresses pending refresh duplicate');
+  events.length = 0;
+  const emit = state.$emit;
+  state.$emit = (...args) => {
+    emit(...args);
+    if (args[0] === 'data-rendered') state.editCurrentlyActive(selected);
+  };
+  state.dataRendered({});
+  await tick();
+  assert.equal(events.filter(event => event[0] === 'edit-currently-active').length, 1,
+    'synchronous selection from consumer data-rendered handler is not emitted twice');
+  state.$emit = emit;
+  state.$refs.singleTable.getSelectedCell = () => null;
+  events.length = 0;
+  state.doLayout(); await tick();
+  assert.equal(events.length, 0, 'cleared selection is not resurrected');
+  const logged = [];
+  context.console = { error: (...values) => logged.push(values) };
+  const failure = new Error('layout failed');
+  state.$refs.singleTable.recalculate = () => Promise.reject(failure);
+  state.doLayout(); await tick();
+  assert.strictEqual(logged[0][1], failure, 'failed discarded Promise is reported without unhandled rejection');
+  context.console = console;
+
+  const keyless = [{ name: 'A', state: false }, { name: 'B', state: false }];
+  const initial = context.createDialogDraft(keyless);
+  initial.draft[0].state = true;
+  const merged = context.mergeDialogDraft(initial, [keyless[1], keyless[0]], initial.draft);
+  assert.equal(merged.value[1].state, true, 'keyless source object identity survives parent reorder');
+  for (const insertionIndex of [0, 1, 2]) {
+    const source = [{ name: 'A', state: false }, { name: 'B', state: false }];
+    const initial = context.createDialogDraft(source);
+    initial.draft[0].state = true;
+    const draft = initial.draft.slice().reverse();
+    const next = source.slice();
+    next.splice(insertionIndex, 0, { name: 'NEW', state: false });
+    const merged = context.mergeDialogDraft(initial, next, draft);
+    assert.equal(merged.value.map(item => item.name).join(','), 'B,A,NEW', 'keyless insertion preserves each item and draft order');
+    assert.equal(merged.value.find(item => item.name === 'A').state, true);
+    assert.equal(merged.value.find(item => item.name === 'NEW').state, false, 'new item cannot inherit another item draft');
+    const repeated = context.mergeDialogDraft(merged, next, merged.value);
+    assert.equal(repeated.value.map(item => item.name).join(','), 'B,A,NEW');
+    assert.equal(repeated.value.find(item => item.name === 'A').state, true);
+  }
+  const replaced = context.mergeDialogDraft(initial,
+    [{ name: 'Replacement A', state: false }, { name: 'Replacement B', state: false }], initial.draft);
+  assert.equal(replaced.value[0].state, true, 'fully replaced keyless objects retain positional fallback');
+
+  // Real Vue 2 watchers, with DOM creation isolated to a small owned-node fake.
+  const Grid = Vue.extend({ mixins: [context.mixin], data: () => ({ newDialogData: [], plDialogFals: false }) });
+  const grid = new Grid({ propsData: { dialogData: [
+    { field: 'a', name: 'A', state: false }, { field: 'b', name: 'B', state: true }
+  ] } });
+  grid.$refs.plDialog = { style: {} };
+  const unrelated = document.createElement('div'); document.body.appendChild(unrelated);
+  grid.plDialogOpens();
+  assert.equal(nodes.length, 2);
+  grid.plDialogOpens(); assert.equal(nodes.length, 2, 'opening twice does not leak backdrop');
+  grid.newDialogData[0].state = true;
+  grid.newDialogData.reverse();
+  grid.dialogData[0].name = 'Updated A';
+  grid.dialogData.push({ field: 'c', name: 'C', state: false });
+  await Vue.nextTick();
+  assert.deepStrictEqual(grid.newDialogData.map(item => item.field), ['b', 'a', 'c']);
+  assert.equal(grid.newDialogData[1].state, true);
+  assert.equal(grid.newDialogData[1].name, 'Updated A');
+  grid.dialogData.splice(1, 1);
+  await Vue.nextTick();
+  assert.deepStrictEqual(grid.newDialogData.map(item => item.field), ['a', 'c']);
+  let confirmed;
+  grid.$on('show-field', value => { confirmed = value; });
+  grid.dialogData[0].name = 'Same tick update';
+  grid.confirmField();
+  assert.equal(confirmed[0].name, 'Same tick update');
+  assert.equal(confirmed[0].state, true);
+  assert.equal(grid._dialogUnwatch, null);
+  assert.deepStrictEqual(nodes, [unrelated]);
+  const closedDraft = grid.newDialogData;
+  grid.dialogData[0].name = 'Closed update';
+  await Vue.nextTick();
+  assert.strictEqual(grid.newDialogData, closedDraft, 'no closed deep synchronization');
+  grid.plDialogOpens();
+  assert.equal(grid.newDialogData[0].name, 'Closed update');
+  grid.$destroy();
+  assert.equal(grid._dialogUnwatch, null);
+  assert.deepStrictEqual(nodes, [unrelated]);
+  console.log('ux-grid wrapper contracts passed (mock kernel; real Vue dialog watcher)');
+}
+run().catch(error => { console.error(error); process.exitCode = 1; });

package/packages/ux-grid/test/delivery-umd.cjs

@@ -0,0 +1,48 @@
+// Run after npm run lib. Exercise the actual script-tag UMD product, without
+// CommonJS/AMD globals or a bundler hiding missing browser runtime dependencies.
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const root = path.resolve(__dirname, '../../..');
+const dependencyRoot = process.env.UX_GRID_TEST_DEPENDENCIES || root;
+const { JSDOM, VirtualConsole } = require(require.resolve('jsdom', { paths: [dependencyRoot] }));
+const errors = [];
+const virtualConsole = new VirtualConsole();
+virtualConsole.on('jsdomError', error => errors.push(error));
+const dom = new JSDOM('<html><body><script src="/lib/index.js"></script></body></html>', {
+  url: 'http://localhost/', runScripts: 'outside-only', pretendToBeVisual: true, virtualConsole
+});
+const { window } = dom;
+let vm;
+(async () => {
+  window.eval(fs.readFileSync(require.resolve('vue/dist/vue.js'), 'utf8'));
+  window.Vue.config.productionTip = false;
+  window.Vue.config.devtools = false;
+  window.Vue.config.errorHandler = error => errors.push(error);
+  window.eval(fs.readFileSync(path.join(root, 'lib/index.js'), 'utf8'));
+  const product = window.UMYUI;
+  assert(product && product.UxGrid && product.UxTableColumn && product.interceptor);
+  assert.strictEqual(product.version, require(path.join(root, 'package.json')).version);
+  assert(window.Vue.options.components.UxGrid, 'script tag automatically installs UxGrid');
+  vm = new window.Vue({
+    render(h) { return h(product.UxGrid, { props: {
+      data: [{ name: 'umd-row' }], columns: [{ field: 'name' }], height: 240,
+      paginationShow: true, total: 42, layout: 'total'
+    } }); }
+  }).$mount();
+  window.document.body.appendChild(vm.$el);
+  await new Promise(resolve => setTimeout(resolve, 150));
+  assert(vm.$el.textContent.includes('umd-row'), 'UMD product mounts real VXE row');
+  window.eval(fs.readFileSync(path.join(root, 'lib/umd/locale/en.js'), 'utf8'));
+  assert(product.lang && product.lang.en, 'UMD locale script registers language');
+  product.locale(product.lang.en);
+  const forceTree = node => { node.$forceUpdate(); node.$children.forEach(forceTree); };
+  forceTree(vm);
+  await new Promise(resolve => setTimeout(resolve, 80));
+  assert(vm.$el.textContent.includes('Total 42'), 'UMD locale changes pagination labels');
+  assert.deepStrictEqual(errors, []);
+  console.log('delivery UMD: browser-global product, auto-install, real rows and locale script passed');
+})().catch(error => { console.error(error); process.exitCode = 1; }).finally(() => {
+  if (vm) vm.$destroy();
+  dom.window.close();
+});

package/packages/ux-grid/test/delivery.cjs

@@ -0,0 +1,103 @@
+// Run after common/component, lib:utils and lib:theme builds.
+// Resolves only declared runtime dependencies from the built entries, rejecting
+// accidental self aliases even when a developer's node_modules provides them.
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const Module = require('module');
+const root = path.resolve(__dirname, '../../..');
+const manifest = require(path.join(root, 'package.json'));
+const dependencies = Object.assign({}, manifest.dependencies, manifest.peerDependencies);
+const externalRoot = process.env.UX_GRID_TEST_DEPENDENCIES || root;
+const { JSDOM } = require(require.resolve('jsdom', { paths: [externalRoot] }));
+const dom = new JSDOM('<html><body><script></script></body></html>', { url: 'http://localhost/' });
+for (const key of ['window', 'document', 'Element', 'HTMLElement', 'HTMLTableElement', 'Node', 'MutationObserver', 'getComputedStyle', 'name', 'Image']) global[key] = dom.window[key];
+Object.defineProperty(global, 'navigator', { configurable: true, value: dom.window.navigator });
+global.requestAnimationFrame = callback => setTimeout(callback, 0);
+global.cancelAnimationFrame = clearTimeout;
+const Vue = require('vue');
+Vue.config.productionTip = false;
+Vue.config.devtools = false;
+const vueModule = require.cache[require.resolve('vue')];
+for (const location of [externalRoot, require.resolve('vxe-table')]) {
+  require.cache[require.resolve('vue', { paths: [location] })] = vueModule;
+}
+const originalLoad = Module._load;
+Module._load = function (request, parent, isMain) {
+  if (parent && parent.filename.startsWith(path.join(root, 'lib') + path.sep) && !request.startsWith('.') && !path.isAbsolute(request)) {
+    const name = request.startsWith('@') ? request.split('/').slice(0, 2).join('/') : request.split('/')[0];
+    assert(dependencies[name], 'Undeclared built runtime dependency: ' + request);
+  }
+  return originalLoad.apply(this, arguments);
+};
+const unwrap = value => value.default || value;
+const errors = [];
+Vue.config.errorHandler = error => errors.push(error);
+// The setup must not replace a consumer's language, dictionary or translator.
+const setupSource = fs.readFileSync(path.join(root, 'packages/ux-grid/src/setup.js'), 'utf8').replace(/^import .*;$/gm, '');
+for (const scenario of [
+  { language: '', dictionary: false, expected: ['register', 'language'] },
+  { language: '', dictionary: true, expected: ['language'] },
+  { language: 'en-US', dictionary: false, expected: [] },
+  { language: '', dictionary: false, custom: true, expected: [] }
+]) {
+  const calls = [];
+  require('vm').runInNewContext(setupSource, { zhCN: {}, VxeUI: {
+    getComponent: () => ({}),
+    getLanguage: () => scenario.language,
+    getConfig: () => ({ i18n: scenario.custom ? () => 'custom' : null }),
+    hasLanguage: () => scenario.dictionary,
+    setI18n: () => calls.push('register'), setLanguage: () => calls.push('language')
+  } });
+  assert.deepEqual(calls, scenario.expected);
+}
+const mounted = [];
+(async () => {
+  const common = require(path.join(root, manifest.main));
+  assert(common.UxGrid && common.UxTableColumn && common.interceptor);
+  const ui = require('vxe-table/lib/ui');
+  assert.strictEqual(common.interceptor, ui.interceptor);
+  assert.equal(ui.VxeUI.getLanguage(), 'zh-CN');
+  assert.notEqual(ui.getI18n('vxe.table.confirmFilter'), 'vxe.table.confirmFilter', 'Default VXE labels are translated');
+  Vue.use(common);
+  const standalone = unwrap(require(path.join(root, 'lib/ux-grid.js')));
+  Vue.use(standalone);
+  for (const Grid of [common.UxGrid, standalone]) {
+    const vm = new Vue({ render: h => h(Grid, { props: { data: [{ name: 'delivery-row' }], columns: [{ field: 'name' }], height: 240, paginationShow: true, total: 42, layout: 'total' } }) }).$mount();
+    mounted.push(vm);
+    document.body.appendChild(vm.$el);
+    await new Promise(resolve => setTimeout(resolve, 150));
+    assert(vm.$el.textContent.includes('delivery-row'), 'Built entry mounts and renders rows');
+  }
+  const locale = require(path.join(root, 'lib/locale'));
+  assert.equal(typeof locale.t, 'function');
+  assert.equal(typeof locale.use, 'function');
+  const forceTree = node => { node.$forceUpdate(); node.$children.forEach(forceTree); };
+  for (const [setLanguage, marker] of [[locale.use, 'SHARED_LOCALE'], [common.locale, 'COMMON_LOCALE']]) {
+    setLanguage({ el: { pagination: { total: marker + ' {total}' } } });
+    mounted.forEach(forceTree);
+    await new Promise(resolve => setTimeout(resolve, 80));
+    mounted.forEach(vm => assert(vm.$el.textContent.includes(marker + ' 42'), 'Public locale updates common and on-demand pagination'));
+  }
+  common.i18n(key => key === 'el.pagination.total' ? 'SHARED_TRANSLATOR' : key);
+  mounted.forEach(forceTree);
+  await new Promise(resolve => setTimeout(resolve, 80));
+  mounted.forEach(vm => assert(vm.$el.textContent.includes('SHARED_TRANSLATOR'), 'Custom translator is shared across bundles'));
+  require(path.join(root, 'lib/mixins/locale'));
+  require(path.join(root, 'lib/utils/util'));
+  for (const file of ['index.css', 'ux-grid.css']) {
+    const css = fs.readFileSync(path.join(root, 'lib/theme-chalk', file), 'utf8');
+    assert(css.includes('.vxe-grid') && css.includes('var(--vxe-'), 'Theme preserves VXE selectors and custom properties');
+    assert(!/\[class\*=(?:"vxe-icon-"|'vxe-icon-'|vxe-icon-)\](?!:not\()/g.test(css), 'Modern icon namespace must exclude legacy double-hyphen icons');
+    assert(css.includes('vxe-icon-spinner'), 'Official modern spinner glyph retained');
+  }
+  for (const file of fs.readdirSync(path.join(root, 'theme/fonts'))) {
+    assert(fs.readFileSync(path.join(root, 'theme/fonts', file)).equals(fs.readFileSync(path.join(root, 'lib/theme-chalk/fonts', file))), 'Font copied unchanged: ' + file);
+  }
+  assert.deepEqual(errors, []);
+  console.log('delivery: common/on-demand DOM, declared runtime dependencies, standalone locale, CSS and fonts passed');
+})().catch(error => { console.error(error); process.exitCode = 1; }).finally(() => {
+  Module._load = originalLoad;
+  mounted.forEach(vm => { vm.$destroy(); vm.$el.remove(); });
+  dom.window.close();
+});