umy-ui-table 1.2.4 → 1.2.6

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

@@ -0,0 +1,132 @@
+// DOM semantics only: jsdom does not measure layout or scrolling performance.
+// UX_GRID_TEST_DEPENDENCIES=/path/to/consumer node packages/ux-grid/test/integration.cjs
+const assert = require('assert');
+const dependencyRoot = process.env.UX_GRID_TEST_DEPENDENCIES || process.cwd();
+const external = name => require(require.resolve(name, { paths: [dependencyRoot] }));
+const { JSDOM } = external('jsdom');
+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');
+// Match a consumer bundler's Vue singleton across linked workspaces.
+const vueModule = require.cache[require.resolve('vue')];
+for (const root of [dependencyRoot, require.resolve('vxe-table')]) {
+  require.cache[require.resolve('vue', { paths: [root] })] = vueModule;
+}
+Vue.config.productionTip = false;
+Vue.config.devtools = false;
+Vue.use(external('element-ui'));
+const unwrap = value => value.default || value;
+const Grid = unwrap(require('../../../lib/ux-grid.js'));
+const Column = unwrap(require('../../../lib/ux-table-column.js'));
+const errors = [];
+Vue.config.errorHandler = error => errors.push(error);
+const delay = () => new Promise(resolve => setTimeout(resolve, 80));
+let vm;
+let selection;
+(async () => {
+  vm = new Vue({
+    data: () => ({ prefix: 'old', extra: false, named: 'alpha', explicitColumns: null, rows: [{ id: 1, name: 'One', number: 2 }] }),
+    render(h) {
+      const prefix = this.prefix;
+      return h(Grid, { ref: 'grid', scopedSlots: { [this.named]: () => h('span', 'named-' + this.named) }, on: { 'selection-change': value => { selection = value; } }, props: { columns: this.explicitColumns, data: this.rows, height: 300, editConfig: { trigger: 'click', mode: 'cell' } } }, [
+        h(Column, { key: 'name', props: { field: 'name', title: 'Name', sortable: true, editRender: { name: 'ElInput' } }, scopedSlots: { default: () => h('span', prefix) } }),
+        h(Column, { key: 'number', props: { field: 'number', title: 'Number', formatter: ({ cellValue }) => prefix + cellValue } }),
+        this.extra ? h(Column, { key: 'id', props: { field: 'id', title: 'ID', slots: { default: this.named } } }) : null
+      ]);
+    }
+  }).$mount();
+  document.body.appendChild(vm.$el);
+  await delay();
+  const grid = vm.$refs.grid.$refs.singleTable;
+  const before = grid.getColumnByField('name');
+  before.resizeWidth = 177;
+  await grid.sort('name', 'asc');
+  await grid.updateData(); // Exercise a cache-hit render before changing formatter.
+  await delay();
+  const originalUpdateData = grid.updateData;
+  let fullDataUpdates = 0;
+  grid.updateData = function (...args) { fullDataUpdates++; return originalUpdateData.apply(this, args); };
+  vm.prefix = 'new';
+  await delay();
+  assert(grid.getColumnByField('name') === before, 'slot update must preserve actual ColumnInfo identity');
+  assert.equal(before.resizeWidth, 177);
+  assert.equal(before.order, 'asc');
+  assert(vm.$el.textContent.includes('new2'), 'formatter updated in real DOM');
+  assert(vm.$el.textContent.includes('new'), 'slot updated in real DOM');
+  await grid.setEditCell(vm.rows[0], 'name');
+  const editing = grid.getEditCell();
+  assert(editing && editing.column === before, 'real edit cell activated');
+  assert(vm.$el.querySelector('.el-input__inner'), 'real Element input mounted in edit cell');
+  vm.prefix = 'latest';
+  await delay();
+  assert(grid.getEditCell().column === before, 'callback update preserves active edit column');
+  assert(vm.$el.textContent.includes('latest2'), 'repeated formatter updates invalidate cache');
+  assert.equal(fullDataUpdates, 0, 'render-only updates do not reprocess full table data');
+  grid.updateData = originalUpdateData;
+  await grid.clearEdit();
+  const wrapper = vm.$refs.grid;
+  let filterEvent;
+  wrapper.$on('filter-change', payload => { filterEvent = payload; });
+  const filters = [{ field: 'name', values: ['One'] }];
+  grid.$emit('filter-change', { column: before, field: 'name', filters: () => filters });
+  assert.deepStrictEqual(filterEvent.filters, [], 'only actual visible filterable columns appear in compatibility payload');
+  assert.equal(filterEvent.property, 'name');
+  grid.$emit('checkbox-change', { row: vm.rows[0], records: () => [vm.rows[0]] });
+  assert.strictEqual(selection[0], vm.rows[0]);
+  vm.extra = true;
+  await delay();
+  assert(grid.getColumnByField('id'), 'structural addition loads a real column');
+  vm.explicitColumns = [{ field: 'id', slots: { default: 'alpha' } }];
+  await delay();
+  assert(vm.$el.textContent.includes('named-alpha'), 'named scoped slot forwarded');
+  vm.named = 'beta';
+  vm.explicitColumns = [{ field: 'id', slots: { default: 'beta' } }];
+  await delay();
+  assert(grid.$scopedSlots.beta && !grid.$scopedSlots.alpha, 'dynamic scoped slot names forwarded and removed');
+  assert(vm.$el.textContent.includes('named-beta'), 'replacement named slot renders');
+  await wrapper.loadData([{ id: 2, name: 'Loaded', number: 3 }]);
+  assert.equal(grid.getTableData().fullData[0].name, 'Loaded');
+  // Pure instance listeners must work without parent v-on listeners.
+  for (let round = 0; round < 3; round++) {
+    const race = new Vue({
+      data: () => ({ cols: [{ field: 'id' }], rows: [{ id: 1 }] }),
+      render(h) { return h(Grid, { ref: 'grid', props: { columns: this.cols, data: this.rows, height: 200 } }); }
+    }).$mount();
+    document.body.appendChild(race.$el);
+    await delay();
+    const raceWrapper = race.$refs.grid;
+    const raceGrid = raceWrapper.$refs.singleTable;
+    for (const [event, kernelEvent] of [['selection-change', 'checkbox-change'], ['select', 'checkbox-change'], ['select-all', 'checkbox-all']]) {
+      let count = 0;
+      let reads = 0;
+      raceWrapper.$once(event, records => { assert.strictEqual(records[0], race.rows[0]); count++; });
+      const params = { row: race.rows[0], records: () => { reads++; return race.rows; } };
+      raceGrid.$emit(kernelEvent, params);
+      raceGrid.$emit(kernelEvent, params);
+      assert.equal(count, 1);
+      assert.equal(reads, 1, 'once listener removal stops reading records');
+    }
+    let cancelledCalls = 0;
+    const originalLoad = raceGrid.loadColumn;
+    raceGrid.loadColumn = function (...args) {
+      if (this._isDestroyed || this._isBeingDestroyed) cancelledCalls++;
+      return originalLoad.apply(this, args);
+    };
+    race.cols = [{ field: 'id' }, { field: 'name' }];
+    // The columns watcher runs first and schedules another nextTick callback;
+    // destroy before that second callback dereferences the table instance.
+    await Vue.nextTick(() => race.$destroy());
+    await delay();
+    assert(cancelledCalls > 0, 'real watcher callback reached destroyed guard');
+    if (race.$el.parentNode) race.$el.parentNode.removeChild(race.$el);
+  }
+  assert.deepStrictEqual(errors, []);
+  console.log('ux-grid real Vue/VXE/Element DOM integration passed');
+})().catch(error => { console.error(error.stack); process.exitCode = 1; }).finally(() => {
+  if (vm) vm.$destroy();
+  dom.window.close();
+  setImmediate(() => process.exit(process.exitCode || 0));
+});

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

@@ -0,0 +1,335 @@
+// Core public wrapper contracts against actual OLD and NEW kernels in isolated
+// Vue/jsdom processes. No mocked kernel methods; no layout/performance claims.
+const assert = require('assert');
+const path = require('path');
+const root = process.env.UX_GRID_TEST_DEPENDENCIES;
+if (!root) throw Error('Set UX_GRID_TEST_DEPENDENCIES to an installed legacy consumer');
+const mode = process.argv[2];
+if (!mode) {
+  const results = {};
+  const traces = {};
+  for (const name of ['old', 'new']) {
+    const child = require('child_process').spawnSync(process.execPath, [__filename, name], { env: process.env, encoding: 'utf8' });
+    assert.strictEqual(child.status, 0, name + '\n' + child.stdout + child.stderr);
+    const line = child.stdout.split('\n').find(value => value.startsWith('RESULT '));
+    assert(line, name + ' completed all assertions');
+    results[name] = JSON.parse(line.slice(7));
+    const timingLine = child.stdout.split('\n').find(value => value.startsWith('TIMING '));
+    assert(timingLine, name + ' emits timing evidence');
+    traces[name] = JSON.parse(timingLine.slice(7));
+    console.log(name + ' ' + timingLine);
+  }
+  assert.deepStrictEqual(results.new, results.old, 'public observable results match legacy');
+  for (const [label, current] of Object.entries(traces.new)) {
+    const previous = traces.old[label];
+    assert(previous, label + ' legacy observation exists');
+    if (['loadColumn', 'reloadColumn'].includes(label)) {
+      assert.equal(previous.returnType, 'undefined'); assert.equal(current.returnType, 'Promise');
+    } else assert.equal(current.returnType, previous.returnType, label + ' return contract');
+    for (const trace of [current.sequence, previous.sequence]) {
+      assert(trace.indexOf('before-call') < trace.indexOf('returned'));
+      if (trace.includes('resolved')) assert(trace.indexOf('returned') < trace.indexOf('resolved'));
+      if (trace.includes('edit-actived')) {
+        assert.equal(trace.filter(item => item === 'edit-actived').length, 1);
+        assert(trace.indexOf('returned') < trace.indexOf('edit-actived'));
+      }
+      if (label === 'clearActived') {
+        assert.equal(trace.filter(item => item === 'edit-closed').length, 1);
+        assert(trace.indexOf('edit-closed') < trace.indexOf('returned'));
+      }
+    }
+    // Faster nextTick completion is allowed; semantic event order is not.
+    assert.deepStrictEqual(current.sequence.filter(item => item !== 'nextTick' && item !== 'resolved'), previous.sequence.filter(item => item !== 'nextTick' && item !== 'resolved'), label + ' event order');
+  }
+  console.log('real old/new kernel wrapper contracts passed:', JSON.stringify(results.new));
+  process.exit(0);
+}
+const external = name => require(require.resolve(name, { paths: [root] }));
+require('babel-polyfill');
+const { JSDOM } = external('jsdom');
+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 = cb => setTimeout(cb, 0);
+global.cancelAnimationFrame = clearTimeout;
+const Vue = require('vue');
+for (const location of [root, require.resolve('vxe-table'), require.resolve('vxe-pc-ui')]) require.cache[require.resolve('vue', { paths: [location] })] = require.cache[require.resolve('vue')];
+Vue.config.productionTip = false;
+Vue.config.devtools = false;
+const errors = [];
+Vue.config.errorHandler = error => errors.push(error.stack || String(error));
+Vue.use(external('element-ui'));
+let Grid;
+if (mode === 'old') {
+  const old = external('umy-table/lib/umy-table.common.js');
+  Vue.use(old.default || old);
+  Grid = Vue.options.components.UxGrid;
+} else {
+  const current = require('../../../lib/ux-grid.js');
+  Grid = current.default || current;
+}
+const settle = () => new Promise(resolve => setTimeout(resolve, 60));
+function promiseResult(value, label) {
+  assert(value && typeof value.then === 'function', label + ' returns Promise');
+  return value;
+}
+const observations = {};
+let summaryCalls = 0;
+let summaryParams;
+let summaryLabel = 'Initial summary';
+let statusValidations = 0;
+let spanParams;
+const spanResult = { rowspan: 1, colspan: 1 };
+let vm;
+(async () => {
+  vm = new Vue({ render(h) { return h(Grid, { ref: 'grid', props: {
+    height: 300, data: [], keepSource: true, rowId: 'id',
+    showSummary: true,
+    spanMethod(params) { spanParams = params; return spanResult; },
+    summaryMethod(params) {
+      summaryCalls++;
+      summaryParams = params;
+      return [[summaryLabel, '', '', '']];
+    },
+    treeConfig: { children: 'children' }, editConfig: { mode: 'cell', trigger: 'click' },
+    mouseConfig: { selected: true },
+    rules: { name: [{ required: true, message: 'Name required' }, { trigger: 'change', validator() { statusValidations++; return Promise.resolve(); } }] },
+    columns: [{ type: 'checkbox' }, { type: 'expand' }, { field: 'id', sortable: true }, { field: 'name', treeNode: true, editRender: { name: 'ElInput' } }]
+  } }); } }).$mount();
+  document.body.appendChild(vm.$el);
+  await settle();
+  const wrapper = vm.$refs.grid;
+  const kernel = wrapper.tableExample();
+  const rows = [{ id: 1, name: 'One', children: [{ id: 11, name: 'Child' }] }, { id: 2, name: 'Two' }];
+  for (const method of ['loadData', 'reloadData']) {
+    const result = wrapper[method](rows);
+    assert(result && typeof result.then === 'function', method + ' returns Promise');
+    await result;
+    assert.strictEqual(wrapper.getTableData().fullData[0], rows[0]);
+  }
+  observations.data = wrapper.getTableData().fullData.map(row => row.id);
+  assert.strictEqual(wrapper.getRowById(1), rows[0]);
+  assert(!wrapper.getRowById('missing-row'));
+  assert(!wrapper.getColumnByField('missing-field'));
+  assert(spanParams && rows.includes(spanParams.row), 'real body renderer invokes spanMethod with original row');
+  assert.strictEqual(wrapper.getTableColumn().fullColumn[spanParams.columnIndex], spanParams.column);
+  assert.strictEqual(wrapper.arraySpanMethod(spanParams), spanResult, 'wrapper preserves callback result identity');
+  for (const method of ['loadColumn', 'reloadColumn']) {
+    const result = wrapper[method]([{ type: 'checkbox' }, { type: 'expand' }, { field: 'id', sortable: true }, { field: 'name', filters: [], treeNode: true, editRender: { name: 'ElInput' } }]);
+    console.log(method + ' return: ' + (result && typeof result.then === 'function' ? 'Promise' : String(result)));
+    if (mode === 'new') assert(result && typeof result.then === 'function');
+    else assert.strictEqual(result, undefined);
+    await result;
+    await settle();
+    assert(wrapper.getColumnByField('name'));
+  }
+  observations.columns = wrapper.getTableColumn().fullColumn.length;
+  const previousSummaryCalls = summaryCalls;
+  summaryLabel = 'Updated summary';
+  await promiseResult(wrapper.updateFooter(), 'updateFooter');
+  await Vue.nextTick();
+  assert(summaryCalls > previousSummaryCalls, 'updateFooter invokes actual summaryMethod');
+  assert.strictEqual(summaryParams.data[0], rows[0]);
+  assert.strictEqual(summaryParams.columns[3], wrapper.getColumnByField('name'));
+  assert(vm.$el.querySelector('tfoot').textContent.includes('Updated summary'), 'updated summary renders in real footer DOM');
+  observations.summary = true;
+  assert.strictEqual(wrapper.setCurrentRow(rows[1]), undefined);
+  await settle();
+  assert.strictEqual(kernel.getCurrentRecord(), rows[1]);
+  observations.current = kernel.getCurrentRecord().id;
+  assert.strictEqual(wrapper.toggleRowSelection([{ row: rows[0], selected: true }]), undefined);
+  await settle();
+  assert.strictEqual(wrapper.getCheckboxRecords()[0], rows[0]);
+  assert.equal(wrapper.isCheckedByCheckboxRow(rows[0]), true);
+  assert.strictEqual(wrapper.toggleAllSelection(true), undefined);
+  await settle();
+  observations.checked = wrapper.getCheckboxRecords().map(row => row.id).sort();
+  assert.strictEqual(wrapper.clearSelection(), undefined);
+  await settle();
+  assert.equal(wrapper.getCheckboxRecords().length, 0);
+  assert.equal(wrapper.isCheckedByCheckboxRow(rows[0]), false);
+  await promiseResult(wrapper.setRowExpand(rows[1], true), 'setRowExpand');
+  assert(kernel.isExpandByRow(rows[1]));
+  await promiseResult(wrapper.clearRowExpand(), 'clearRowExpand');
+  assert(!kernel.isExpandByRow(rows[1]));
+  await promiseResult(wrapper.setTreeExpand(rows[0], true), 'setTreeExpand');
+  assert(wrapper.isTreeExpandByRow(rows[0]));
+  assert.strictEqual(wrapper.getTreeExpandRecords()[0], rows[0]);
+  await promiseResult(wrapper.clearTreeExpand(), 'clearTreeExpand');
+  assert(!wrapper.isTreeExpandByRow(rows[0]));
+  observations.expand = true;
+  assert.strictEqual(wrapper.sort('id', 'desc'), undefined);
+  await settle();
+  assert.equal(wrapper.getColumnByField('id').order, 'desc');
+  assert.equal(wrapper.getTableData().visibleData[0].id, 2, 'sort changes actual row order');
+  assert.strictEqual(wrapper.clearSort(), undefined);
+  await settle();
+  assert(!wrapper.getColumnByField('id').order);
+  await promiseResult(wrapper.setFilter(wrapper.getColumnByField('name'), [{ label: 'One', value: 'One', checked: true }]), 'setFilter');
+  assert.equal(wrapper.getColumnByField('name').filters[0].value, 'One');
+  assert.strictEqual(wrapper.clearFilter('name'), undefined);
+  await settle();
+  assert(!wrapper.getColumnByField('name').filters[0].checked);
+  observations.sortFilter = true;
+  rows[0].name = 'Changed';
+  assert(wrapper.isUpdateByRow(rows[0], 'name'));
+  assert(wrapper.getUpdateRecords().includes(rows[0]));
+  await promiseResult(wrapper.revertData(rows[0]), 'revertData');
+  assert.equal(rows[0].name, 'One');
+  assert(!wrapper.isUpdateByRow(rows[0]));
+  observations.revert = rows[0].name;
+  const replacement = { id: 2, name: 'Reloaded two' };
+  const reloadedRow = wrapper.reloadRow(rows[1], replacement);
+  assert(reloadedRow && typeof reloadedRow.then === 'function');
+  await reloadedRow;
+  assert.equal(rows[1].name, 'Reloaded two');
+  assert(!wrapper.isUpdateByRow(rows[1]), 'reloadRow resets source baseline');
+  const updated = wrapper.updateData();
+  assert(updated && typeof updated.then === 'function');
+  await updated;
+  assert.equal(wrapper.getTableData().fullData[1].name, 'Reloaded two');
+  // Flat data avoids kernel-specific tree insertion configuration.
+  await wrapper.reloadData([{ id: 3, name: 'Three' }]);
+  const insertion = wrapper.insertRow({ id: 4, name: 'Four' }, -1);
+  assert(insertion && typeof insertion.then === 'function');
+  const inserted = await insertion;
+  assert.equal(inserted.row.id, 4);
+  assert(Array.isArray(wrapper.getRecordset()), 'legacy wrapper exposes only insertRecords');
+  assert.strictEqual(wrapper.getRecordset()[0], inserted.row);
+  assert.strictEqual(wrapper.remove(inserted.row), undefined);
+  await settle();
+  assert.equal(wrapper.getInsertRecords().length, 0);
+  observations.insertRemove = true;
+  const validRows = [{ id: 5, name: 'Valid' }];
+  await wrapper.reloadData(validRows);
+  for (const method of ['validate', 'fullValidate']) {
+    for (const args of [[], [[]], [validRows]]) {
+      const pending = wrapper[method](...args);
+      assert(pending && typeof pending.then === 'function');
+      const result = await pending;
+      assert(!result || !Object.keys(result).length, method + ' valid returns no errors');
+    }
+    validRows[0].name = '';
+    for (const [label, args] of [['default', []], ['empty', [[]]], ['explicit', [validRows]]]) {
+      const result = await wrapper[method](...args);
+      const hasErrors = !!(result && result.name && result.name.length);
+      observations[method + ':' + label] = hasErrors;
+      if (label !== 'empty') assert(hasErrors, method + ' resolves validation errors, does not reject');
+      else assert.strictEqual(hasErrors, false, method + ' empty row array excludes all rows');
+      if (hasErrors) {
+        assert.strictEqual(result.name[0].row, validRows[0]);
+        assert.equal(result.name[0].rule.message, 'Name required');
+      }
+    }
+    validRows[0].name = 'Valid';
+  }
+  observations.validation = true;
+  const trace = [];
+  const phases = {};
+  for (const name of ['selection-change', 'select', 'select-all', 'edit-actived', 'edit-closed', 'current-change']) {
+    wrapper.$on(name, () => trace.push(name));
+  }
+  async function measure(label, method, args, expectedReturn, check) {
+    trace.length = 0; trace.push('before-call');
+    const result = wrapper[method](...args);
+    const returnType = result && typeof result.then === 'function' ? 'Promise' : typeof result;
+    assert.equal(returnType, expectedReturn, label + ' return');
+    trace.push('returned');
+    const completion = returnType === 'Promise' ? result.then(() => {
+      trace.push('resolved');
+      if (check) check();
+    }) : null;
+    await Vue.nextTick(); trace.push('nextTick');
+    if (completion) await completion;
+    await settle(); trace.push('settled');
+    if (check && !completion) check();
+    phases[label] = { returnType, sequence: trace.slice() };
+  }
+  const activeRow = validRows[0];
+  await wrapper.clearActived();
+  await measure('setActiveCell', 'setActiveCell', [activeRow, 'name'], 'undefined', () => assert(wrapper.isActiveByRow(activeRow)));
+  assert(trace.includes('edit-actived'));
+  const validationsBefore = statusValidations;
+  await measure('updateStatus', 'updateStatus', [{ row: activeRow, column: wrapper.getColumnByField('name') }], 'undefined', () => assert(statusValidations > validationsBefore, 'updateStatus invokes configured change validator'));
+  await measure('clearActived', 'clearActived', [], 'Promise', () => assert(!wrapper.isActiveByRow(activeRow)));
+  assert(trace.includes('edit-closed'));
+  await measure('setActiveRow', 'setActiveRow', [activeRow], 'undefined', () => assert(wrapper.isActiveByRow(activeRow)));
+  await wrapper.clearActived();
+  activeRow.name = '';
+  await wrapper.fullValidate([activeRow]); await settle();
+  assert(vm.$el.querySelector('td.col--valid-error'), 'real validation marks invalid cell');
+  await measure('clearValidate', 'clearValidate', [], 'Promise', () => assert(!vm.$el.querySelector('td.col--valid-error'), 'clearValidate clears actual error DOM at resolution'));
+  activeRow.name = 'Valid'; await wrapper.clearActived();
+  for (const [method, args] of [
+    ['toggleRowSelection', [[{ row: activeRow, selected: true }]]],
+    ['newtoggleRowSelections', [[{ row: activeRow }]]],
+    ['toggleAllSelection', []], ['clearSelection', []]
+  ]) {
+    await measure(method, method, args, 'undefined');
+    assert.equal(trace.filter(name => name === 'selection-change').length, 1);
+    assert(trace.indexOf('selection-change') < trace.indexOf('returned'));
+    assert(!trace.includes('select') && !trace.includes('select-all'));
+  }
+  await measure('setCurrentRow', 'setCurrentRow', [activeRow], 'undefined', () => assert.strictEqual(kernel.getCurrentRecord(), activeRow));
+  assert(!trace.includes('current-change'));
+  await measure('setCurrentRow:clear', 'setCurrentRow', [], 'undefined', () => assert(!kernel.getCurrentRecord()));
+  assert(!trace.includes('current-change'));
+  await measure('reloadData', 'reloadData', [rows], 'Promise', () => assert.strictEqual(wrapper.getTableData().fullData[0], rows[0]));
+  for (const [method, args, expanded] of [
+    ['toggleRowExpand', [rows[1]], true], ['toggleRowExpand', [rows[1]], false],
+    ['setAllRowExpand', [true], true], ['setAllRowExpand', [false], false]
+  ]) await measure(method + ':' + expanded, method, args, 'Promise', () => assert.equal(kernel.isExpandByRow(rows[1]), expanded));
+  for (const [method, args, expanded] of [
+    ['toggleTreeExpand', [rows[0]], true], ['toggleTreeExpand', [rows[0]], false],
+    ['setAllTreeExpand', [true], true], ['setAllTreeExpand', [false], false]
+  ]) await measure(method + ':' + expanded, method, args, 'Promise', () => assert.equal(wrapper.isTreeExpandByRow(rows[0]), expanded));
+  for (const method of ['doLayout', 'refreshColumn', 'refreshScroll', 'pagingScrollTopLeft']) {
+    await measure(method, method, [], 'undefined');
+  }
+  await measure('scrollToRow', 'scrollToRow', [rows[1]], 'undefined');
+  assert.equal(wrapper.getColumnIndex(wrapper.getColumnByField('name')), 3);
+  const selectedEvents = [];
+  wrapper.$on('edit-currently-active', payload => selectedEvents.push(payload));
+  await kernel.setSelectCell(rows[0], 'id'); await settle();
+  for (const method of ['doLayout', 'refreshColumn']) {
+    selectedEvents.length = 0;
+    assert.strictEqual(wrapper[method](), undefined);
+    await settle();
+    assert(selectedEvents.length, method + ' refreshes selected-cell event');
+    if (mode === 'new') assert.equal(selectedEvents.length, 1, 'no duplicate selected refresh');
+    selectedEvents.forEach(payload => {
+      assert.strictEqual(payload.row, rows[0]);
+      assert.strictEqual(payload.column, wrapper.getColumnByField('id'));
+      assert(payload.cell instanceof HTMLElement);
+    });
+  }
+  if (mode === 'new') {
+    selectedEvents.length = 0;
+    let rendered = 0;
+    wrapper.$once('data-rendered', () => {
+      rendered++;
+      kernel.setSelectCell(rows[0], 'id');
+    });
+    await wrapper.loadData(rows); await settle();
+    assert.equal(rendered, 1, 'real loadData emits data-rendered');
+    assert.equal(selectedEvents.length, 1, 'real selected event suppresses pending rendered refresh duplicate');
+    assert.strictEqual(selectedEvents[0].row, rows[0]);
+    assert.strictEqual(selectedEvents[0].column, wrapper.getColumnByField('id'));
+    assert(selectedEvents[0].cell instanceof HTMLElement);
+  }
+  for (const method of ['loadColumn', 'reloadColumn']) {
+    const field = method + 'Unique';
+    await measure(method, method, [[{ field }]], mode === 'new' ? 'Promise' : 'undefined', () => {
+      assert.equal(wrapper.getTableColumn().fullColumn.length, 1);
+      assert(wrapper.getColumnByField(field));
+      assert(!wrapper.getColumnByField('name'));
+    });
+  }
+  console.log('TIMING ' + JSON.stringify(phases));
+  assert.deepStrictEqual(errors, []);
+  console.log('RESULT ' + JSON.stringify(observations));
+})().catch(error => { console.error(error.stack); process.exitCode = 1; }).finally(() => {
+  if (vm) vm.$destroy();
+  dom.window.close();
+  setImmediate(() => process.exit(process.exitCode || 0));
+});