Vue kit: UiSearchField for the Context and Layer Finder searches

UiSearchField is the search glyph, a search input with v-model and, with
clearLabel, a UiCloseButton shown while text is typed that clears and
refocuses. tag is div or label; attributes go to the frame, and inputId,
inputClass, autocomplete and spellcheck to the input. Escape stops at the
input and is emitted with its event; focus() focuses the input.

search-field.css holds the declarations both skins had in common (the
frame's flex row, the input's min-width, border and background), moved out
of context-dock.css and layer-finder.css and loaded before them. The
browser's cancel button stays each skin's own.

Co-authored-by: Manjunath Paparaju <[email protected]>
This commit is contained in:
Sameh KhamisandManjunath Paparaju committed 2026-11-19 00:42:51 -08:00
1 parent 1711b4b456
commit 52dd576769
12 files changed
+303 -23

No files matched your search

+136
View File
@@ -0,0 +1,136 @@
import { after, before, test } from 'node:test';
import assert from 'node:assert/strict';
import { installVueDom } from '../../testSupport/vueDom.mjs';
let mount;
let UiSearchField;
let uninstall;
before(async () => {
uninstall = installVueDom();
({ mount } = await import('@vue/test-utils'));
UiSearchField = (await import('./UiSearchField.vue')).default;
});
after(() => uninstall());
/** A field whose v-model writes back into its props, as a parent's would. */
function bound(props = {}, attrs = {}) {
const wrapper = mount(UiSearchField, {
attachTo: document.body,
props: {
label: 'Search layers',
modelValue: '',
...props,
'onUpdate:modelValue': (value) => wrapper.setProps({ modelValue: value }),
},
attrs,
});
return wrapper;
}
test('a search field is the search glyph and a search input named by its label', () => {
const wrapper = bound({ placeholder: 'Search layers…' });
const root = wrapper.get('div');
assert.ok(root.classes().includes('ui-search-field'));
const icon = wrapper.get('span');
assert.equal(icon.text(), 'search');
assert.ok(icon.classes().includes('material-symbols-outlined'));
assert.equal(icon.attributes('aria-hidden'), 'true');
const input = wrapper.get('input');
assert.equal(input.attributes('type'), 'search');
assert.ok(input.classes().includes('ui-search-field__input'));
assert.equal(input.attributes('aria-label'), 'Search layers');
assert.equal(input.attributes('placeholder'), 'Search layers…');
for (const name of ['id', 'autocomplete', 'spellcheck'])
assert.equal(input.attributes(name), undefined, name);
assert.equal(wrapper.find('button').exists(), false);
wrapper.unmount();
});
test('v-model shows the text and updates it as typed', async () => {
const wrapper = bound({ modelValue: 'radar' });
const input = wrapper.get('input');
assert.equal(input.element.value, 'radar');
await input.setValue('rain');
assert.deepEqual(wrapper.emitted('update:modelValue').at(-1), ['rain']);
assert.equal(wrapper.props('modelValue'), 'rain');
// A parent that empties its value, as closing a search does, empties the input.
await wrapper.setProps({ modelValue: '' });
assert.equal(input.element.value, '');
wrapper.unmount();
});
test('the clear button shows only while text is typed, clears and refocuses', async () => {
const wrapper = bound({
clearLabel: 'Clear search',
clearClass: 'context-search__clear',
});
assert.equal(wrapper.find('button').exists(), false);
await wrapper.setProps({ modelValue: 'rain' });
const clear = wrapper.get('button');
assert.equal(clear.attributes('aria-label'), 'Clear search');
assert.equal(clear.attributes('title'), 'Clear search');
assert.ok(clear.classes().includes('context-search__clear'));
assert.ok(clear.classes().includes('ui-close-button'));
assert.equal(clear.get('span').text(), 'close');
await clear.trigger('click');
assert.deepEqual(wrapper.emitted('update:modelValue').at(-1), ['']);
assert.equal(document.activeElement, wrapper.get('input').element);
assert.equal(wrapper.find('button').exists(), false);
wrapper.unmount();
});
test('Escape is emitted with its event and stops at the input', async () => {
const wrapper = bound();
let bubbled = 0;
const onKey = () => bubbled++;
wrapper.element.addEventListener('keydown', onKey);
await wrapper.get('input').trigger('keydown', { key: 'Escape' });
const escapes = wrapper.emitted('escape');
assert.equal(escapes.length, 1);
assert.ok(escapes[0][0] instanceof Event);
assert.equal(escapes[0][0].defaultPrevented, false);
assert.equal(bubbled, 0);
await wrapper.get('input').trigger('keydown', { key: 'a' });
assert.equal(wrapper.emitted('escape').length, 1);
assert.equal(bubbled, 1);
wrapper.unmount();
});
test('tag="label" frames the input in a label', () => {
const wrapper = bound({ tag: 'label' });
assert.equal(wrapper.element.tagName, 'LABEL');
assert.ok(wrapper.element.contains(wrapper.get('input').element));
wrapper.unmount();
});
test('attributes and classes pass through to the frame; the input takes its own', () => {
const wrapper = bound(
{
inputId: 'layer-finder-input',
inputClass: 'context-search__input',
autocomplete: 'off',
spellcheck: 'false',
},
{ class: 'context-search', role: 'search', 'data-x': '1' },
);
const root = wrapper.get('div');
assert.ok(root.classes().includes('context-search'));
assert.ok(root.classes().includes('ui-search-field'));
assert.equal(root.attributes('role'), 'search');
assert.equal(root.attributes('data-x'), '1');
const input = wrapper.get('input');
assert.equal(input.attributes('id'), 'layer-finder-input');
assert.ok(input.classes().includes('context-search__input'));
assert.ok(input.classes().includes('ui-search-field__input'));
assert.equal(input.attributes('autocomplete'), 'off');
assert.equal(input.attributes('spellcheck'), 'false');
assert.equal(input.attributes('role'), undefined);
wrapper.unmount();
});
test('focus() focuses the input', () => {
const wrapper = bound();
wrapper.vm.focus();
assert.equal(document.activeElement, wrapper.get('input').element);
wrapper.unmount();
});
+81
View File
@@ -0,0 +1,81 @@
<script setup>
import { computed, ref } from 'vue';
import UiCloseButton from './UiCloseButton.vue';
// Core's search field: the Material `search` glyph, then an
// `<input type="search">` bound with v-model, and, when `clearLabel` is set,
// a UiCloseButton (the `close` symbol, its label as its tip) shown while
// text is typed, which empties the field and focuses the input again. `tag`
// is the frame: a `div` (give it role="search") or a `label`, which names
// the input by wrapping it. Attributes and classes pass through to the frame,
// so each site keeps its feature class; the input takes `inputId`,
// `inputClass`, `autocomplete` and `spellcheck`, and the clear button
// `clearClass`. Escape, pressed in the input, stops there and is emitted
// with its event, so a caller that also prevents the browser's own Escape
// does so. `focus()` focuses the input. The kit classes `ui-search-field`
// and `ui-search-field__input` (search-field.css) are the frame's flex row
// and the bare input; the browser's own cancel button is left as it is.
const props = defineProps({
modelValue: { type: String, default: '' },
/** The input's accessible name (aria-label). */
label: { type: String, required: true },
placeholder: { type: String, default: undefined },
tag: {
type: String,
default: 'div',
validator: (value) => ['div', 'label'].includes(value),
},
inputId: { type: String, default: undefined },
inputClass: { type: String, default: undefined },
autocomplete: { type: String, default: undefined },
spellcheck: { type: String, default: undefined },
/** The clear button's accessible name and tip; none without it. */
clearLabel: { type: String, default: undefined },
clearClass: { type: String, default: undefined },
});
const emit = defineEmits(['update:modelValue', 'escape']);
const input = ref(null);
// The input keeps Vue's native v-model, as both fields had.
const text = computed({
get: () => props.modelValue,
set: (value) => emit('update:modelValue', value),
});
function focus() {
input.value?.focus();
}
function clear() {
emit('update:modelValue', '');
focus();
}
defineExpose({ focus });
</script>
<template>
<component :is="props.tag" class="ui-search-field">
<span class="material-symbols-outlined" aria-hidden="true">search</span>
<input
:id="props.inputId"
ref="input"
v-model="text"
type="search"
class="ui-search-field__input"
:class="props.inputClass"
:placeholder="props.placeholder"
:aria-label="props.label"
:autocomplete="props.autocomplete"
:spellcheck="props.spellcheck"
@keydown.esc.stop="emit('escape', $event)"
/>
<UiCloseButton
v-if="props.clearLabel && props.modelValue"
:class="props.clearClass"
glyph="icon"
:label="props.clearLabel"
:title="props.clearLabel"
@click="clear"
/>
</component>
</template>
+43
View File
@@ -149,6 +149,45 @@ test('UiCloseButton wears the bare glyph look the guide’s close shares', () =>
assert.match(rule.body, declaration);
});
test('UiSearchField owns the row and bare input both search skins drew', () => {
const frame = ruleWith('.ui-search-field');
assert.deepEqual(frame.selectors, ['.ui-search-field']);
assert.match(frame.body, /display:\s*flex;/);
assert.match(frame.body, /align-items:\s*center;/);
const input = ruleWith('.ui-search-field__input');
assert.deepEqual(input.selectors, ['.ui-search-field__input']);
for (const declaration of [
/min-width:\s*0;/,
/background:\s*none;/,
/border:\s*0;/,
])
assert.match(input.body, declaration);
// The browser's cancel button is each skin's own: Context hides it, the
// Layer Finder keeps it.
assert.ok(
!all.some((rule) =>
rule.selectors.some((s) =>
s.startsWith('.ui-search-field__input::-webkit-search-cancel-button'),
),
),
);
// Each declaration lives once, in the kit's rule.
for (const [selector, kit] of [
['.context-search', frame],
['.layer-finder__field', frame],
['.context-search__input', input],
['.layer-finder__field input', input],
]) {
const feature = ruleWith(selector);
for (const property of kit.body.match(/[\w-]+(?=:)/g))
assert.doesNotMatch(
feature.body,
new RegExp(`(^|[\\s;])${property}:`),
`${selector} leaves ${property} to the kit`,
);
}
});
test('the kit’s skins load before the feature stylesheets that restyle them', () => {
const at = (selector) => css.indexOf(selector);
for (const [kit, feature] of [
@@ -166,6 +205,10 @@ test('the kit’s skins load before the feature stylesheets that restyle them',
['.ui-close-button,', '.context-search__clear {'],
['.ui-close-button,', '.key-setup-close {'],
['.ui-close-button,', '.gev-guide-close {'],
['.ui-search-field {', '.context-search {'],
['.ui-search-field {', '.layer-finder__field {'],
['.ui-search-field__input {', '.context-search__input {'],
['.ui-search-field__input {', '.layer-finder__field input {'],
]) {
assert.ok(
at(kit) >= 0 && at(feature) > at(kit),