Vue kit: UiCheckbox for the Visual, voice, Data Library and welcome checkboxes

UiCheckbox is a label wrapping a native checkbox and its words; trailing
puts the box after them, as the Visual panel's rows have it. v-model shows
the value and emits the checked state, and change is emitted with its event;
without a modelValue the box is the browser's own, as the welcome card's
"Don't show this again" is. restore puts the box back to modelValue once a
change has rendered without the owner taking it, which is what the voice
panel's v-checked directive did for a refused preference. Attributes go to
the label; inputId and inputAttrs to the box.

checkbox.css holds the centred flex row, moved out of the two labels that
hold only a checkbox (first-run.css, library.css) and loaded before them.
Each box keeps its skin's size, margin and accent colour. checkboxes.test.mjs
fails if a view writes a checkbox by hand; Story Explore's filters are not
converted yet.

Co-authored-by: Manjunath Paparaju <[email protected]>
This commit is contained in:
Sameh KhamisandManjunath Paparaju committed 2026-11-19 01:05:12 -08:00
1 parent 52dd576769
commit 2d7b7be890
18 files changed
+385 -41

No files matched your search

+162
View File
@@ -0,0 +1,162 @@
import { after, before, test } from 'node:test';
import assert from 'node:assert/strict';
import { installVueDom } from '../../testSupport/vueDom.mjs';
let mount;
let nextTick;
let UiCheckbox;
let uninstall;
before(async () => {
uninstall = installVueDom();
({ mount } = await import('@vue/test-utils'));
({ nextTick } = await import('vue'));
UiCheckbox = (await import('./UiCheckbox.vue')).default;
});
after(() => uninstall());
/** A checkbox whose v-model writes back into its props, as a parent's would. */
function bound(props = {}, attrs = {}) {
const wrapper = mount(UiCheckbox, {
attachTo: document.body,
props: {
modelValue: false,
...props,
'onUpdate:modelValue': (value) => wrapper.setProps({ modelValue: value }),
},
attrs,
slots: { default: '<span class="words">Scope</span>' },
});
return wrapper;
}
/** Tick the box as a person does: flip it, then the change event. */
async function tick(input) {
input.element.checked = !input.element.checked;
await input.trigger('change');
}
test('a checkbox is a label wrapping a native box, then its words', () => {
const wrapper = bound();
const root = wrapper.get('label');
assert.ok(root.classes().includes('ui-checkbox'));
const input = wrapper.get('input');
assert.equal(input.attributes('type'), 'checkbox');
assert.ok(input.classes().includes('ui-checkbox__input'));
assert.equal(input.attributes('id'), undefined);
const elements = [...root.element.children];
assert.deepEqual(
elements.map((el) => el.tagName),
['INPUT', 'SPAN'],
);
wrapper.unmount();
});
test('trailing puts the box after its words', () => {
const wrapper = bound({ trailing: true });
assert.deepEqual(
[...wrapper.get('label').element.children].map((el) => el.tagName),
['SPAN', 'INPUT'],
);
wrapper.unmount();
});
test('attributes and classes go to the label; inputId and inputAttrs to the box', () => {
const wrapper = bound(
{
inputId: 'scope-toggle',
inputAttrs: { 'aria-describedby': 'note', 'data-hook': '' },
},
{ class: 'pp-scope-toggle', title: 'Scope', id: 'scope-row' },
);
const root = wrapper.get('label');
assert.ok(root.classes().includes('pp-scope-toggle'));
assert.equal(root.attributes('title'), 'Scope');
assert.equal(root.attributes('id'), 'scope-row');
const input = wrapper.get('input');
assert.equal(input.attributes('id'), 'scope-toggle');
assert.equal(input.attributes('aria-describedby'), 'note');
assert.equal(input.attributes('data-hook'), '');
assert.equal(input.attributes('title'), undefined);
assert.ok(!input.classes().includes('pp-scope-toggle'));
wrapper.unmount();
});
test('v-model shows the value and reports each change', async () => {
const wrapper = bound({ modelValue: true });
const input = wrapper.get('input');
assert.equal(input.element.checked, true);
await tick(input);
assert.deepEqual(wrapper.emitted('update:modelValue').at(-1), [false]);
assert.equal(wrapper.emitted('change').at(-1)[0].target, input.element);
assert.equal(input.element.checked, false);
await tick(input);
assert.deepEqual(wrapper.emitted('update:modelValue').at(-1), [true]);
// A parent that resets its value resets the box.
await wrapper.setProps({ modelValue: false });
assert.equal(input.element.checked, false);
wrapper.unmount();
});
test('without restore a change the owner ignores stays ticked, as :checked did', async () => {
const wrapper = mount(UiCheckbox, { props: { modelValue: false } });
const input = wrapper.get('input');
await tick(input);
await nextTick();
assert.deepEqual(wrapper.emitted('update:modelValue'), [[true]]);
assert.equal(input.element.checked, true);
wrapper.unmount();
});
test('restore puts a refused change back and keeps an accepted one', async () => {
// Refused: the owner keeps its value.
const refused = mount(UiCheckbox, {
props: { modelValue: true, restore: true },
});
const box = refused.get('input');
await tick(box);
assert.deepEqual(refused.emitted('update:modelValue'), [[false]]);
await nextTick();
assert.equal(box.element.checked, true);
refused.unmount();
// Accepted: the owner takes the change before the box is checked again.
const accepted = bound({ modelValue: true, restore: true });
const input = accepted.get('input');
await tick(input);
await nextTick();
assert.equal(input.element.checked, false);
assert.equal(accepted.props('modelValue'), false);
accepted.unmount();
});
test('without a modelValue the box is the browser’s own', async () => {
const wrapper = mount(UiCheckbox, {
props: { inputAttrs: { 'data-first-run-suppress': '' } },
});
const input = wrapper.get('input');
assert.equal(input.element.checked, false);
await tick(input);
assert.equal(input.element.checked, true);
assert.equal(wrapper.emitted('change').length, 1);
// Rendering again leaves what was ticked alone.
await wrapper.setProps({ inputId: 'suppress' });
assert.equal(input.attributes('id'), 'suppress');
assert.equal(input.element.checked, true);
wrapper.unmount();
});
test('a change listener sees the box as the event’s current target', async () => {
let seen = null;
const wrapper = mount(UiCheckbox, {
attrs: {
onChange: (event) => {
seen = event.currentTarget;
},
},
});
const input = wrapper.get('input');
await tick(input);
assert.equal(seen, input.element);
// The label itself does not hear the box's change a second time.
assert.equal(wrapper.emitted('change').length, 1);
wrapper.unmount();
});