@energysage/es-ds-components 6.3.2 → 6.3.3

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [6.3.3](https://github.com/EnergySage/es-ds/compare/es-ds-components-v6.3.2...es-ds-components-v6.3.3) (2026-10-19)
+
+
+### Bug Fixes
+
+* exclude tests from package to prevent downstream type errors ([#1798](https://github.com/EnergySage/es-ds/issues/1798)) ([07723a3](https://github.com/EnergySage/es-ds/commit/07723a36cefd46a8eacbc2c63413a753702aa34c))
+
 ## [6.3.2](https://github.com/EnergySage/es-ds/compare/es-ds-components-v6.3.1...es-ds-components-v6.3.2) (2026-10-14)
 
 

package/nuxt.config.ts

@@ -109,6 +109,7 @@ export default defineNuxtConfig({
             },
         },
     },
+    // Applies to all consuming apps too, since layer config merges into theirs
     typescript: {
         typeCheck: true,
     },

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@energysage/es-ds-components",
-    "version": "6.3.2",
+    "version": "6.3.3",
     "private": false,
     "type": "module",
     "description": "An EnergySage Vue component library",
@@ -18,6 +18,13 @@
         "url": "https://github.com/EnergySage/es-ds/issues"
     },
     "main": "./nuxt.config.ts",
+    "files": [
+        "app",
+        "nuxt.config.ts",
+        "CHANGELOG.md",
+        "README.md",
+        "!**/*.test.ts"
+    ],
     "scripts": {
         "test": "vitest run",
         "lint:eslint": "eslint .",

package/.prettierignore

@@ -1,2 +0,0 @@
-# Managed by release-please
-CHANGELOG.md

package/.prettierrc.json

@@ -1,10 +0,0 @@
-{
-    "printWidth": 119,
-    "useTabs": false,
-    "singleQuote": true,
-    "trailingComma": "all",
-    "bracketSpacing": true,
-    "bracketSameLine": true,
-    "singleAttributePerLine": true,
-    "tabWidth": 4
-}

package/app/composables/autocomplete-announcer.test.ts

@@ -1,70 +0,0 @@
-// @vitest-environment happy-dom
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { App } from 'vue';
-import { createApp, nextTick, ref } from 'vue';
-import { useEsAutocompleteAnnouncer } from './autocomplete-announcer';
-
-/** run the composable inside a real component so watchers are scoped */
-function withSetup<T>(composable: () => T): { app: App; result: T } {
-    let result!: T;
-    const app = createApp({
-        setup() {
-            result = composable();
-            return () => null;
-        },
-    });
-    app.mount(document.createElement('div'));
-    return { app, result };
-}
-
-function makeAnnouncer(initial = '') {
-    const source = ref(initial);
-    const { app, result: announced } = withSetup(() => useEsAutocompleteAnnouncer(() => source.value));
-    return { announced, app, source };
-}
-
-describe('useEsAutocompleteAnnouncer', () => {
-    beforeEach(() => vi.useFakeTimers());
-    afterEach(() => vi.useRealTimers());
-
-    it('holds the text back until the listbox has stopped changing', async () => {
-        const { announced, source } = makeAnnouncer();
-        source.value = '34 Prospect St';
-        await nextTick();
-        expect(announced.value).toBe('');
-        vi.advanceTimersByTime(250);
-        expect(announced.value).toBe('34 Prospect St');
-    });
-
-    it('speaks only the last of several texts arriving together', async () => {
-        const { announced, source } = makeAnnouncer();
-        source.value = '34 Prospect St';
-        await nextTick();
-        vi.advanceTimersByTime(100);
-        source.value = '355 Cedar Ct';
-        await nextTick();
-        vi.advanceTimersByTime(100);
-        expect(announced.value).toBe('');
-        vi.advanceTimersByTime(150);
-        expect(announced.value).toBe('355 Cedar Ct');
-    });
-
-    it('empties at once, having nothing to wait behind', async () => {
-        const { announced, source } = makeAnnouncer();
-        source.value = '34 Prospect St';
-        await nextTick();
-        vi.advanceTimersByTime(250);
-        source.value = '';
-        await nextTick();
-        expect(announced.value).toBe('');
-    });
-
-    it('drops a text still waiting when the component goes away', async () => {
-        const { announced, app, source } = makeAnnouncer();
-        source.value = '34 Prospect St';
-        await nextTick();
-        app.unmount();
-        vi.advanceTimersByTime(250);
-        expect(announced.value).toBe('');
-    });
-});

package/app/composables/autocomplete-combobox.test.ts

@@ -1,523 +0,0 @@
-// @vitest-environment happy-dom
-import { describe, expect, it, vi } from 'vitest';
-import type { App } from 'vue';
-import { createApp, nextTick, ref } from 'vue';
-import type { EsAutocompleteSuggestion } from '../types';
-import { useEsAutocompleteCombobox } from './autocomplete-combobox';
-
-/** run the composable inside a real component so watchers are scoped */
-function withSetup<T>(composable: () => T): { app: App; result: T } {
-    let result!: T;
-    const app = createApp({
-        setup() {
-            result = composable();
-            return () => null;
-        },
-    });
-    app.mount(document.createElement('div'));
-    return { app, result };
-}
-
-function makeCombobox(
-    initialSuggestions: EsAutocompleteSuggestion[] = [{ id: 'a', text: 'solar batteries' }],
-    { autoSelect = false, selectOnBlur = false } = {},
-) {
-    const inputEl = document.createElement('input');
-    document.body.append(inputEl);
-    const model = ref('solar');
-    const suggestions = ref(initialSuggestions);
-    const suggestionsPending = ref(false);
-    const close = vi.fn();
-    const emitSelect = vi.fn();
-    const { result: combobox } = withSetup(() =>
-        useEsAutocompleteCombobox({
-            autoSelect: () => autoSelect,
-            selectOnBlur: () => selectOnBlur,
-            close,
-            emitSelect,
-            idPrefix: 'test',
-            inputEl: ref(inputEl),
-            model,
-            suggestions: () => suggestions.value,
-            suggestionsPending: () => suggestionsPending.value,
-        }),
-    );
-    return { close, combobox, emitSelect, inputEl, model, suggestions, suggestionsPending };
-}
-
-function keydown(key: string, init: { isComposing?: boolean } = {}) {
-    const event = new KeyboardEvent('keydown', { cancelable: true, key });
-    if (init.isComposing) {
-        Object.defineProperty(event, 'isComposing', { value: true });
-    }
-    return event;
-}
-
-const THREE = [
-    { id: 'a', text: 'apple' },
-    { id: 'b', text: 'apricot' },
-    { id: 'c', text: 'avocado' },
-];
-
-describe('useEsAutocompleteCombobox arrow navigation and mirroring', () => {
-    it('cycles down through every suggestion, back to the input, and around again', () => {
-        const { combobox, model } = makeCombobox(THREE);
-        model.value = 'a';
-        const down = () => combobox.onKeydown(keydown('ArrowDown'));
-        down();
-        expect(combobox.displayValue.value).toBe('apple');
-        expect(combobox.activeDescendant.value).toBe('test-option-0');
-        down();
-        down();
-        expect(combobox.displayValue.value).toBe('avocado');
-        // past the last suggestion: back to the input showing the typed text
-        down();
-        expect(combobox.displayValue.value).toBe('a');
-        expect(combobox.activeDescendant.value).toBeUndefined();
-        down();
-        expect(combobox.displayValue.value).toBe('apple');
-    });
-
-    it('cycles up from the input to the last suggestion and back', () => {
-        const { combobox, model } = makeCombobox(THREE);
-        model.value = 'a';
-        const up = () => combobox.onKeydown(keydown('ArrowUp'));
-        up();
-        expect(combobox.displayValue.value).toBe('avocado');
-        up();
-        up();
-        expect(combobox.displayValue.value).toBe('apple');
-        up();
-        expect(combobox.displayValue.value).toBe('a');
-    });
-
-    it('mirrors only keyboard highlights: hovering never changes the field', () => {
-        const { combobox, model } = makeCombobox(THREE);
-        model.value = 'a';
-        combobox.onOptionPointermove(1);
-        expect(combobox.displayValue.value).toBe('a');
-        expect(combobox.activeDescendant.value).toBe('test-option-1');
-        expect(combobox.keyboardNav.value).toBe(false);
-    });
-
-    it("holds the arrows' highlight while the pointer passes over the list", () => {
-        const { combobox, model } = makeCombobox(THREE);
-        model.value = 'a';
-        combobox.onKeydown(keydown('ArrowDown'));
-        expect(combobox.displayValue.value).toBe('apple');
-        // a panel opens under a resting cursor, so this is a twitch, not a choice
-        combobox.onOptionPointermove(2);
-        expect(combobox.selectedIndex.value).toBe(0);
-        expect(combobox.activeDescendant.value).toBe('test-option-0');
-        expect(combobox.displayValue.value).toBe('apple');
-    });
-
-    it('arrows are a no-op while there is nothing displayed', () => {
-        const { combobox } = makeCombobox([]);
-        combobox.onKeydown(keydown('ArrowDown'));
-        expect(combobox.activeDescendant.value).toBeUndefined();
-    });
-
-    it('prevents the caret-moving default on arrows', () => {
-        const { combobox } = makeCombobox(THREE);
-        const event = keydown('ArrowDown');
-        combobox.onKeydown(event);
-        expect(event.defaultPrevented).toBe(true);
-    });
-
-    it('a changed suggestion list drops the highlight and restores the typed text', async () => {
-        const { combobox, model, suggestions } = makeCombobox(THREE);
-        model.value = 'a';
-        combobox.onKeydown(keydown('ArrowDown'));
-        expect(combobox.displayValue.value).toBe('apple');
-        suggestions.value = [{ id: 'z', text: 'banana' }];
-        await nextTick();
-        expect(combobox.displayValue.value).toBe('a');
-        expect(combobox.activeDescendant.value).toBeUndefined();
-    });
-
-    it('typing ends navigation and takes the edited field value as the model', () => {
-        const { combobox, inputEl, model } = makeCombobox(THREE);
-        model.value = 'a';
-        combobox.onKeydown(keydown('ArrowDown'));
-        // the user edits the mirrored suggestion, as on Google
-        inputEl.value = 'applex';
-        inputEl.dispatchEvent(new Event('input'));
-        combobox.onInput({ target: inputEl } as unknown as Event);
-        expect(model.value).toBe('applex');
-        expect(combobox.displayValue.value).toBe('applex');
-        expect(combobox.activeDescendant.value).toBeUndefined();
-    });
-});
-
-describe('useEsAutocompleteCombobox Enter semantics', () => {
-    it('closes and leaves the key to the page when nothing is highlighted', () => {
-        const { close, combobox, emitSelect } = makeCombobox();
-        const event = keydown('Enter');
-        combobox.onKeydown(event);
-        expect(emitSelect).not.toHaveBeenCalled();
-        expect(close).toHaveBeenCalled();
-        // a surrounding <form> submits implicitly, as from any other field
-        expect(event.defaultPrevented).toBe(false);
-    });
-
-    it('selects a keyboard-highlighted suggestion instead of submitting a form', () => {
-        const { close, combobox, emitSelect, model } = makeCombobox();
-        combobox.onKeydown(keydown('ArrowDown'));
-        const event = keydown('Enter');
-        combobox.onKeydown(event);
-        expect(emitSelect).toHaveBeenCalledWith({ id: 'a', text: 'solar batteries' });
-        expect(event.defaultPrevented).toBe(true);
-        expect(model.value).toBe('solar batteries');
-        // a shell that renders the final text mid-close takes it from this argument
-        expect(close).toHaveBeenCalledWith('solar batteries');
-    });
-
-    it('selects a pointer-highlighted suggestion', () => {
-        const { combobox, emitSelect } = makeCombobox();
-        combobox.onOptionPointermove(0);
-        combobox.onKeydown(keydown('Enter'));
-        expect(emitSelect).toHaveBeenCalled();
-    });
-
-    it('ignores the Enter that commits an IME composition', () => {
-        const { close, combobox, emitSelect } = makeCombobox();
-        combobox.onKeydown(keydown('Enter', { isComposing: true }));
-        expect(emitSelect).not.toHaveBeenCalled();
-        expect(close).not.toHaveBeenCalled();
-    });
-
-    it('selects nothing after a list change reset the highlight', async () => {
-        const { combobox, emitSelect, suggestions } = makeCombobox(THREE);
-        combobox.onKeydown(keydown('ArrowDown'));
-        suggestions.value = [{ id: 'z', text: 'banana' }];
-        await nextTick();
-        const event = keydown('Enter');
-        combobox.onKeydown(event);
-        expect(emitSelect).not.toHaveBeenCalled();
-        expect(event.defaultPrevented).toBe(false);
-    });
-});
-
-describe('useEsAutocompleteCombobox selection, clearing, and focus retention', () => {
-    it('onOptionClick writes the model, closes with the text, and emits the suggestion', () => {
-        const { close, combobox, emitSelect, model } = makeCombobox(THREE);
-        combobox.onOptionClick(1);
-        expect(model.value).toBe('apricot');
-        expect(close).toHaveBeenCalledWith('apricot');
-        expect(emitSelect).toHaveBeenCalledWith({ id: 'b', text: 'apricot' });
-    });
-
-    it('onClear empties the model and refocuses the input', () => {
-        const { combobox, inputEl, model } = makeCombobox();
-        combobox.onClear();
-        expect(model.value).toBe('');
-        expect(document.activeElement).toBe(inputEl);
-    });
-
-    it('list mousedown keeps focus in the input, except on interactive slot content', () => {
-        const { combobox } = makeCombobox();
-        const row = document.createElement('div');
-        const plain = new MouseEvent('mousedown', { cancelable: true });
-        Object.defineProperty(plain, 'target', { value: row });
-        combobox.onListMousedown(plain);
-        expect(plain.defaultPrevented).toBe(true);
-
-        const button = document.createElement('button');
-        row.append(button);
-        const interactive = new MouseEvent('mousedown', { cancelable: true });
-        Object.defineProperty(interactive, 'target', { value: button });
-        combobox.onListMousedown(interactive);
-        expect(interactive.defaultPrevented).toBe(false);
-    });
-});
-
-describe('useEsAutocompleteCombobox arrow-driven blur window', () => {
-    it('claims the blur a screen reader makes in answer to an arrow press', () => {
-        const { combobox } = makeCombobox(THREE);
-        combobox.onKeydown(keydown('ArrowDown'));
-        expect(combobox.consumeRewriteBlur()).toBe(true);
-    });
-
-    it('claims it once, so a later blur reads as the user leaving the field', () => {
-        const { combobox } = makeCombobox(THREE);
-        combobox.onKeydown(keydown('ArrowDown'));
-        expect(combobox.consumeRewriteBlur()).toBe(true);
-        expect(combobox.consumeRewriteBlur()).toBe(false);
-    });
-
-    it('claims nothing once the window has passed, or without an arrow press', () => {
-        const { combobox } = makeCombobox(THREE);
-        expect(combobox.consumeRewriteBlur()).toBe(false);
-        combobox.onKeydown(keydown('ArrowDown'));
-        vi.spyOn(performance, 'now').mockReturnValue(performance.now() + 1_000);
-        expect(combobox.consumeRewriteBlur()).toBe(false);
-        vi.restoreAllMocks();
-    });
-});
-
-describe('useEsAutocompleteCombobox automatic selection', () => {
-    it('selects the first suggestion as the list arrives', () => {
-        const { combobox, model } = makeCombobox(THREE, { autoSelect: true });
-        model.value = 'a';
-        expect(combobox.selectedIndex.value).toBe(0);
-    });
-
-    it('leaves aria-activedescendant to the user, so a screen reader cursor stays in the field', () => {
-        const { combobox, model } = makeCombobox(THREE, { autoSelect: true });
-        model.value = 'a';
-        expect(combobox.activeDescendant.value).toBeUndefined();
-        combobox.onKeydown(keydown('ArrowDown'));
-        expect(combobox.activeDescendant.value).toBe('test-option-1');
-    });
-
-    it('selects nothing in the default mode', () => {
-        const { combobox, model } = makeCombobox(THREE);
-        model.value = 'a';
-        expect(combobox.selectedIndex.value).toBe(-1);
-        expect(combobox.activeDescendant.value).toBeUndefined();
-    });
-
-    it('completes the typed text inline when the suggestion continues it', () => {
-        const { combobox, model } = makeCombobox(THREE, { autoSelect: true });
-        model.value = 'ap';
-        expect(combobox.displayValue.value).toBe('apple');
-    });
-
-    it('adds only the untyped remainder, leaving the typed characters alone', () => {
-        const { combobox, model } = makeCombobox([{ id: 'p', text: 'Pagination' }], { autoSelect: true });
-        model.value = 'p';
-        expect(combobox.displayValue.value).toBe('pagination');
-        model.value = 'pAg';
-        expect(combobox.displayValue.value).toBe('pAgination');
-    });
-
-    it("takes the suggestion's own text as the value once it is chosen", () => {
-        const { combobox, model } = makeCombobox([{ id: 'p', text: 'Pagination' }], {
-            autoSelect: true,
-            selectOnBlur: true,
-        });
-        model.value = 'p';
-        expect(combobox.commitAutoSelection()).toBe(true);
-        expect(model.value).toBe('Pagination');
-    });
-
-    it('selects without completing when the suggestion matches some other way', () => {
-        const { combobox, model } = makeCombobox([{ id: 'a', text: '12 Maple Ave' }], { autoSelect: true });
-        model.value = 'maple';
-        expect(combobox.selectedIndex.value).toBe(0);
-        expect(combobox.displayValue.value).toBe('maple');
-    });
-
-    it('leaves a deletion alone rather than putting the character back', () => {
-        const { combobox, inputEl, model } = makeCombobox(THREE, { autoSelect: true });
-        model.value = 'ap';
-        expect(combobox.displayValue.value).toBe('apple');
-        inputEl.value = 'a';
-        combobox.onInput({ inputType: 'deleteContentBackward', target: inputEl } as unknown as Event);
-        expect(combobox.displayValue.value).toBe('a');
-    });
-
-    it('keeps the completion remainder selected as the typed text grows', async () => {
-        const { combobox, inputEl, model } = makeCombobox(THREE, { autoSelect: true });
-        inputEl.focus();
-        model.value = 'ap';
-        // the value the shell renders from displayValue, which the selection follows
-        inputEl.value = combobox.displayValue.value;
-        await nextTick();
-        expect([inputEl.selectionStart, inputEl.selectionEnd]).toEqual([2, 5]);
-        // typing over the remainder leaves the same suggestion completing the
-        // longer text, so the remainder has to be selected again
-        model.value = 'app';
-        inputEl.value = combobox.displayValue.value;
-        await nextTick();
-        expect([inputEl.selectionStart, inputEl.selectionEnd]).toEqual([3, 5]);
-    });
-
-    it('claims a rewrite for the completion it writes, never for the typing over it', async () => {
-        const { combobox, inputEl, model } = makeCombobox(THREE, { autoSelect: true });
-        inputEl.focus();
-        model.value = 'ap';
-        inputEl.value = combobox.displayValue.value;
-        await nextTick();
-        expect(combobox.consumeRewriteBlur()).toBe(true);
-        model.value = 'app';
-        inputEl.value = combobox.displayValue.value;
-        await nextTick();
-        expect(combobox.consumeRewriteBlur()).toBe(false);
-    });
-
-    it('names the selected suggestion for the shell to announce', () => {
-        const { combobox } = makeCombobox(THREE, { autoSelect: true });
-        expect(combobox.autoSelectedText.value).toBe('apple');
-        const { combobox: off } = makeCombobox(THREE);
-        expect(off.autoSelectedText.value).toBe('');
-    });
-
-    it('keeps the completion while the pointer passes over the list', () => {
-        const { combobox, model } = makeCombobox(THREE, { autoSelect: true });
-        model.value = 'ap';
-        expect(combobox.displayValue.value).toBe('apple');
-        combobox.onOptionPointermove(2);
-        // the pointer highlights what it is over, and the field keeps its proposal
-        expect(combobox.selectedIndex.value).toBe(2);
-        expect(combobox.displayValue.value).toBe('apple');
-    });
-
-    it('restores the completion, still selected, when the arrows come back to the input', async () => {
-        const { combobox, inputEl, model } = makeCombobox(THREE, { autoSelect: true });
-        inputEl.focus();
-        model.value = 'ap';
-        const down = () => combobox.onKeydown(keydown('ArrowDown'));
-        down();
-        expect(combobox.displayValue.value).toBe('apricot');
-        down();
-        down();
-        expect(combobox.selectedIndex.value).toBe(0);
-        expect(combobox.displayValue.value).toBe('apple');
-        inputEl.value = combobox.displayValue.value;
-        // three ticks: the completion's own flush, then the two the caret-to-end
-        // move would have taken had the arrows still claimed the field
-        await nextTick();
-        await nextTick();
-        await nextTick();
-        expect([inputEl.selectionStart, inputEl.selectionEnd]).toEqual([2, 5]);
-    });
-
-    it("holds the arrows' highlight while the pointer passes over the list", () => {
-        const { combobox, model } = makeCombobox(THREE, { autoSelect: true });
-        model.value = 'ap';
-        combobox.onKeydown(keydown('ArrowDown'));
-        expect(combobox.selectedIndex.value).toBe(1);
-        combobox.onOptionPointermove(2);
-        expect(combobox.selectedIndex.value).toBe(1);
-        expect(combobox.displayValue.value).toBe('apricot');
-    });
-
-    it('Enter chooses the automatically selected suggestion', () => {
-        const { combobox, emitSelect, model } = makeCombobox(THREE, { autoSelect: true });
-        model.value = 'a';
-        const event = keydown('Enter');
-        combobox.onKeydown(event);
-        expect(event.defaultPrevented).toBe(true);
-        expect(emitSelect).toHaveBeenCalledWith(THREE[0]);
-    });
-
-    it('arrows carry on from the automatic selection rather than restarting', () => {
-        const { combobox, model } = makeCombobox(THREE, { autoSelect: true });
-        model.value = 'a';
-        combobox.onKeydown(keydown('ArrowDown'));
-        expect(combobox.displayValue.value).toBe('apricot');
-    });
-
-    it('commits the selection on the way out', () => {
-        const { combobox, emitSelect, model } = makeCombobox(THREE, { autoSelect: true, selectOnBlur: true });
-        model.value = 'a';
-        expect(combobox.commitAutoSelection()).toBe(true);
-        expect(emitSelect).toHaveBeenCalledWith(THREE[0]);
-        expect(model.value).toBe('apple');
-    });
-
-    it('commits the suggestion the arrows moved to, not the one it started on', () => {
-        const { combobox, emitSelect, model } = makeCombobox(THREE, { autoSelect: true, selectOnBlur: true });
-        model.value = 'a';
-        combobox.onKeydown(keydown('ArrowDown'));
-        combobox.onKeydown(keydown('ArrowDown'));
-        expect(combobox.commitAutoSelection()).toBe(true);
-        expect(emitSelect).toHaveBeenCalledWith(THREE[2]);
-        expect(model.value).toBe('avocado');
-    });
-
-    it('commits the held suggestion when a pointer merely rests over another', () => {
-        const { combobox, emitSelect, model } = makeCombobox(THREE, { autoSelect: true, selectOnBlur: true });
-        model.value = 'a';
-        combobox.onOptionPointermove(2);
-        expect(combobox.commitAutoSelection()).toBe(true);
-        expect(emitSelect).toHaveBeenCalledWith(THREE[0]);
-    });
-
-    it('commits nothing in the default mode, whatever the arrows reached', () => {
-        const { combobox, emitSelect, model } = makeCombobox(THREE);
-        model.value = 'a';
-        combobox.onKeydown(keydown('ArrowDown'));
-        expect(combobox.commitAutoSelection()).toBe(false);
-        expect(emitSelect).not.toHaveBeenCalled();
-    });
-
-    it('commits nothing on the way out unless the field is asked to take a value', () => {
-        const { combobox, emitSelect, model } = makeCombobox(THREE, { autoSelect: true });
-        model.value = 'a';
-        // the suggestion is still active, and still what Enter would choose
-        expect(combobox.selectedIndex.value).toBe(0);
-        expect(combobox.displayValue.value).toBe('apple');
-        expect(combobox.commitAutoSelection()).toBe(false);
-        expect(emitSelect).not.toHaveBeenCalled();
-        combobox.onKeydown(keydown('Enter'));
-        expect(emitSelect).toHaveBeenCalledWith(THREE[0]);
-    });
-
-    it('commits nothing with no list displayed, or in the default mode', () => {
-        const { combobox: empty } = makeCombobox([], { autoSelect: true, selectOnBlur: true });
-        expect(empty.commitAutoSelection()).toBe(false);
-        const { combobox, emitSelect } = makeCombobox(THREE);
-        expect(combobox.commitAutoSelection()).toBe(false);
-        expect(emitSelect).not.toHaveBeenCalled();
-    });
-});
-
-describe('useEsAutocompleteCombobox automatic selection from a list answering an earlier query', () => {
-    const BEACON = [
-        { id: 'c', text: '1 Beacon Street, Cambridge, MA, USA' },
-        { id: 'b', text: '1 Beacon Street, Boston, MA, USA' },
-    ];
-
-    it('takes nothing on Enter or on the way out once the typing has moved past the list', () => {
-        const { close, combobox, emitSelect, model, suggestionsPending } = makeCombobox(BEACON, {
-            autoSelect: true,
-            selectOnBlur: true,
-        });
-        model.value = '02108';
-        suggestionsPending.value = true;
-        expect(combobox.selectedIndex.value).toBe(-1);
-        expect(combobox.autoSelectedText.value).toBe('');
-        expect(combobox.commitAutoSelection()).toBe(false);
-        const event = keydown('Enter');
-        combobox.onKeydown(event);
-        expect(event.defaultPrevented).toBe(false);
-        expect(close).toHaveBeenCalled();
-        expect(emitSelect).not.toHaveBeenCalled();
-        expect(model.value).toBe('02108');
-    });
-
-    it('keeps holding the first suggestion while it still continues the typed text', () => {
-        const { combobox, emitSelect, model, suggestionsPending } = makeCombobox(BEACON, {
-            autoSelect: true,
-            selectOnBlur: true,
-        });
-        model.value = '1 Beacon Street, Ca';
-        suggestionsPending.value = true;
-        // the field shows exactly what leaving it would take
-        expect(combobox.displayValue.value).toBe('1 Beacon Street, Cambridge, MA, USA');
-        expect(combobox.commitAutoSelection()).toBe(true);
-        expect(emitSelect).toHaveBeenCalledWith(BEACON[0]);
-    });
-
-    it('selects again once the app answers the typed query', () => {
-        const { combobox, model, suggestionsPending } = makeCombobox(BEACON, { autoSelect: true });
-        model.value = '1 Beacon St Bos';
-        suggestionsPending.value = true;
-        expect(combobox.selectedIndex.value).toBe(-1);
-        suggestionsPending.value = false;
-        expect(combobox.selectedIndex.value).toBe(0);
-    });
-
-    it('still lets the user choose from the list explicitly', () => {
-        const { combobox, emitSelect, model, suggestionsPending } = makeCombobox(BEACON, { autoSelect: true });
-        model.value = '1 Beacon St Bos';
-        suggestionsPending.value = true;
-        combobox.onKeydown(keydown('ArrowDown'));
-        combobox.onKeydown(keydown('ArrowDown'));
-        combobox.onKeydown(keydown('Enter'));
-        expect(emitSelect).toHaveBeenCalledWith(BEACON[1]);
-    });
-});

package/app/composables/autocomplete-search.test.ts

@@ -1,312 +0,0 @@
-// @vitest-environment happy-dom
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { App } from 'vue';
-import { createApp, nextTick, ref } from 'vue';
-import type { EsAutocompleteSuggestion } from '../types';
-import { useEsAutocompleteSearch } from './autocomplete-search';
-
-const DELAY = 300;
-
-const apps: App[] = [];
-beforeEach(() => {
-    vi.useFakeTimers();
-});
-afterEach(() => {
-    apps.forEach((app) => app.unmount());
-    apps.length = 0;
-    vi.useRealTimers();
-});
-
-/** run a composable inside a real component so lifecycle hooks work */
-function withSetup<T>(composable: () => T): { app: App; result: T } {
-    let result!: T;
-    const app = createApp({
-        setup() {
-            result = composable();
-            return () => null;
-        },
-    });
-    app.mount(document.createElement('div'));
-    apps.push(app);
-    return { app, result };
-}
-
-function makeSearch(overrides: { minChars?: number } = {}) {
-    const model = ref('');
-    const suggestions = ref<EsAutocompleteSuggestion[]>([]);
-    const emitComplete = vi.fn();
-    const emitSelect = vi.fn();
-    const { app, result: search } = withSetup(() =>
-        useEsAutocompleteSearch({
-            delay: () => DELAY,
-            emitComplete,
-            emitSelect,
-            minChars: () => overrides.minChars ?? 1,
-            model,
-            noResultsText: () => 'No results found',
-            promptText: () => 'Type for suggestions',
-            suggestions: () => suggestions.value,
-        }),
-    );
-    /** type a value and let the model watcher run */
-    async function type(value: string) {
-        model.value = value;
-        await nextTick();
-    }
-    return { app, emitComplete, emitSelect, model, search, suggestions, type };
-}
-
-describe('useEsAutocompleteSearch complete debouncing', () => {
-    it('emits complete once per typing pause, with the trimmed query', async () => {
-        const { emitComplete, type } = makeSearch();
-        await type('s');
-        vi.advanceTimersByTime(DELAY - 50);
-        await type('so');
-        await type(' solar ');
-        vi.advanceTimersByTime(DELAY);
-        expect(emitComplete).toHaveBeenCalledTimes(1);
-        expect(emitComplete).toHaveBeenCalledWith('solar');
-    });
-
-    it('does not emit below minChars', async () => {
-        const { emitComplete, type } = makeSearch({ minChars: 3 });
-        await type('so');
-        vi.advanceTimersByTime(DELAY * 2);
-        expect(emitComplete).not.toHaveBeenCalled();
-    });
-
-    it('does not re-fetch when selection copies the suggestion text into the input', async () => {
-        const { emitComplete, search, type } = makeSearch();
-        // selection is terminal: Reka sets the model to the chosen text afterward
-        search.onSelect({ id: 'a', text: 'solar batteries' });
-        await type('solar batteries');
-        vi.advanceTimersByTime(DELAY * 2);
-        expect(emitComplete).not.toHaveBeenCalled();
-
-        // ...but the suppression is one-shot: typing again fetches normally
-        await type('solar batteries plus');
-        vi.advanceTimersByTime(DELAY);
-        expect(emitComplete).toHaveBeenCalledWith('solar batteries plus');
-    });
-
-    it('unmount cancels a pending complete', async () => {
-        const { app, emitComplete, type } = makeSearch();
-        await type('solar');
-        app.unmount();
-        vi.advanceTimersByTime(DELAY * 2);
-        expect(emitComplete).not.toHaveBeenCalled();
-    });
-});
-
-describe('useEsAutocompleteSearch panel message and suggestion gating', () => {
-    it('walks prompt → results → no-results → prompt-while-pending correctly', async () => {
-        const { search, suggestions, type } = makeSearch();
-        // nothing searched yet
-        expect(search.panelMessage.value).toBe('Type for suggestions');
-
-        // results arrive: no message
-        await type('solar');
-        suggestions.value = [{ id: 'a', text: 'solar batteries' }];
-        await nextTick();
-        expect(search.panelMessage.value).toBe('');
-
-        // a search came back empty: no-results
-        await type('solarx');
-        suggestions.value = [];
-        await nextTick();
-        expect(search.panelMessage.value).toBe('No results found');
-
-        // the query changed again, so a new search is pending: prompt, not the
-        // previous query's stale no-results
-        await type('solarxy');
-        expect(search.panelMessage.value).toBe('Type for suggestions');
-    });
-
-    it('exposes the no-results announcement exactly when a search came back empty', async () => {
-        const { search, suggestions, type } = makeSearch();
-        // nothing searched yet: nothing to announce
-        expect(search.noResultsAnnouncement.value).toBe('');
-
-        await type('solar');
-        suggestions.value = [{ id: 'a', text: 'solar batteries' }];
-        await nextTick();
-        expect(search.noResultsAnnouncement.value).toBe('');
-
-        // a search that came back empty announces the no-results message
-        await type('solarx');
-        suggestions.value = [];
-        await nextTick();
-        expect(search.noResultsAnnouncement.value).toBe('No results found');
-
-        // a pending search announces nothing: the prompt is guidance, not a
-        // state change
-        await type('solarxy');
-        expect(search.noResultsAnnouncement.value).toBe('');
-    });
-
-    it('holds back the stale list after a selection until the app answers again', async () => {
-        const { search, suggestions, type } = makeSearch();
-        await type('12');
-        suggestions.value = [
-            { id: 'a', text: '12 Maple Ave, Cambridge, MA 02138' },
-            { id: 'b', text: '123 Main St, Boston, MA 02108' },
-        ];
-        await nextTick();
-        expect(search.effectiveSuggestions.value).toHaveLength(2);
-
-        // selection fills the input with the full text; the app's list matched
-        // "12", not that text, so a refocused panel shows the prompt instead
-        search.onSelect({ id: 'b', text: '123 Main St, Boston, MA 02108' });
-        await type('123 Main St, Boston, MA 02108');
-        expect(search.effectiveSuggestions.value).toHaveLength(0);
-        expect(search.panelMessage.value).toBe('Type for suggestions');
-
-        // editing fetches again, and the app's answer clears the staleness
-        await type('123 Main St B');
-        vi.advanceTimersByTime(DELAY);
-        suggestions.value = [{ id: 'b', text: '123 Main St, Boston, MA 02108' }];
-        await nextTick();
-        expect(search.effectiveSuggestions.value).toHaveLength(1);
-        expect(search.panelMessage.value).toBe('');
-    });
-
-    it('fills again after a selection even when the app answers with the same array', async () => {
-        // an app that memoises per query hands back the identical array, so the
-        // suggestions watcher never fires and only the edit can end the staleness
-        const CACHED = [{ id: 'a', text: 'apple' }];
-        const model = ref('');
-        const search = withSetup(() =>
-            useEsAutocompleteSearch({
-                delay: () => DELAY,
-                emitComplete: () => undefined,
-                emitSelect: () => undefined,
-                minChars: () => 1,
-                model,
-                noResultsText: () => 'No results found',
-                promptText: () => 'Type for suggestions',
-                suggestions: () => CACHED,
-            }),
-        ).result;
-
-        model.value = 'app';
-        await nextTick();
-        expect(search.effectiveSuggestions.value).toHaveLength(1);
-
-        search.onSelect(CACHED[0]!);
-        model.value = 'apple';
-        await nextTick();
-        expect(search.effectiveSuggestions.value).toHaveLength(0);
-
-        // searching again returns the very same array the app cached
-        model.value = 'app';
-        await nextTick();
-        expect(search.effectiveSuggestions.value).toHaveLength(1);
-    });
-
-    it('shows suggestions an app refreshes in its own select handler', async () => {
-        const { search, suggestions, type } = makeSearch();
-        await type('12');
-        suggestions.value = [{ id: 'a', text: '12 Maple Ave, Cambridge, MA 02138' }];
-        await nextTick();
-
-        // the app's select handler runs inside the select emit, before the
-        // model picks up the chosen text
-        search.onSelect({ id: 'a', text: '12 Maple Ave, Cambridge, MA 02138' });
-        suggestions.value = [{ id: 'b', text: '12 Maple Ave rear unit, Cambridge, MA 02138' }];
-        await type('12 Maple Ave, Cambridge, MA 02138');
-        expect(search.effectiveSuggestions.value).toHaveLength(1);
-    });
-
-    it('shows the prompt, not no-results, when the app clears its list on select', async () => {
-        const { search, suggestions, type } = makeSearch();
-        await type('12');
-        suggestions.value = [{ id: 'a', text: '12 Maple Ave, Cambridge, MA 02138' }];
-        await nextTick();
-
-        search.onSelect({ id: 'a', text: '12 Maple Ave, Cambridge, MA 02138' });
-        suggestions.value = [];
-        await type('12 Maple Ave, Cambridge, MA 02138');
-        expect(search.effectiveSuggestions.value).toHaveLength(0);
-        expect(search.panelMessage.value).toBe('Type for suggestions');
-    });
-
-    it('marks the list pending from an edit until the app answers the typed query', async () => {
-        const { search, suggestions, type } = makeSearch();
-        await type('1 Beacon St');
-        expect(search.suggestionsPending.value).toBe(true);
-        vi.advanceTimersByTime(DELAY);
-        suggestions.value = [{ id: 'a', text: '1 Beacon Street, Cambridge, MA, USA' }];
-        await nextTick();
-        expect(search.suggestionsPending.value).toBe(false);
-
-        // typing past the answered query leaves the list on screen, but pending
-        await type('1 Beacon St Melrose');
-        expect(search.effectiveSuggestions.value).toHaveLength(1);
-        expect(search.suggestionsPending.value).toBe(true);
-
-        // whitespace the trimmed query ignores leaves it answered
-        await type('1 Beacon St ');
-        expect(search.suggestionsPending.value).toBe(false);
-    });
-
-    it('keeps a list pending when it answers a search the typing has already moved past', async () => {
-        const { emitComplete, search, suggestions, type } = makeSearch();
-        await type('1 Beacon');
-        vi.advanceTimersByTime(DELAY);
-        // the answer to "1 Beacon" lands while "1 Beacon St" is still debouncing
-        await type('1 Beacon St');
-        suggestions.value = [{ id: 'a', text: '1 Beacon Street, Cambridge, MA, USA' }];
-        await nextTick();
-        expect(search.suggestionsPending.value).toBe(true);
-
-        vi.advanceTimersByTime(DELAY);
-        expect(emitComplete).toHaveBeenLastCalledWith('1 Beacon St');
-        suggestions.value = [{ id: 'b', text: '1 Beacon Street, Boston, MA, USA' }];
-        await nextTick();
-        expect(search.suggestionsPending.value).toBe(false);
-    });
-
-    it('credits an app that answers synchronously inside its complete handler', async () => {
-        const model = ref('');
-        const suggestions = ref<EsAutocompleteSuggestion[]>([]);
-        const search = withSetup(() =>
-            useEsAutocompleteSearch({
-                delay: () => DELAY,
-                emitComplete: (query) => {
-                    suggestions.value = [{ id: query, text: `${query} batteries` }];
-                },
-                emitSelect: () => undefined,
-                minChars: () => 1,
-                model,
-                noResultsText: () => 'No results found',
-                promptText: () => 'Type for suggestions',
-                suggestions: () => suggestions.value,
-            }),
-        ).result;
-        model.value = 'solar';
-        await nextTick();
-        vi.advanceTimersByTime(DELAY);
-        await nextTick();
-        expect(search.suggestionsPending.value).toBe(false);
-    });
-
-    it('is never pending below minChars, where no list shows', async () => {
-        const { search, type } = makeSearch({ minChars: 3 });
-        await type('so');
-        expect(search.suggestionsPending.value).toBe(false);
-    });
-
-    it('gates suggestions below minChars with a referentially stable empty list', async () => {
-        const { search, suggestions, type } = makeSearch({ minChars: 3 });
-        suggestions.value = [{ id: 'a', text: 'solar batteries' }];
-        await type('so');
-        const first = search.effectiveSuggestions.value;
-        expect(first).toHaveLength(0);
-        await type('s');
-        // same reference: downstream watchers must not re-fire per keystroke
-        expect(search.effectiveSuggestions.value).toBe(first);
-
-        await type('sol');
-        expect(search.effectiveSuggestions.value).toHaveLength(1);
-    });
-});

package/app/composables/autocomplete-visible-rows.test.ts

@@ -1,209 +0,0 @@
-// @vitest-environment happy-dom
-import { afterEach, describe, expect, it } from 'vitest';
-import type { App } from 'vue';
-import { createApp, nextTick, ref } from 'vue';
-import type { EsAutocompleteSuggestion } from '../types';
-import { useEsAutocompleteVisibleRows } from './autocomplete-visible-rows';
-
-// NOTE: happy-dom has no real layout, so element geometry (offsetHeight,
-// clientHeight) is mocked per element. These tests cover the counting/limit
-// LOGIC — whole rows per available height, the min-1 floor, and which height
-// constraint wins. Whether real browser layout produces that geometry is
-// covered by the planned Playwright specs (plan §8a).
-
-const apps: App[] = [];
-afterEach(() => {
-    apps.forEach((app) => app.unmount());
-    apps.length = 0;
-    document.body.innerHTML = '';
-});
-
-/** run a composable inside a real component so lifecycle hooks work */
-function withSetup<T>(composable: () => T): T {
-    let result!: T;
-    const app = createApp({
-        setup() {
-            result = composable();
-            return () => null;
-        },
-    });
-    app.mount(document.createElement('div'));
-    apps.push(app);
-    return result;
-}
-
-function suggestionList(count: number): EsAutocompleteSuggestion[] {
-    return Array.from({ length: count }, (_, index) => ({ id: `s${index}`, text: `suggestion ${index}` }));
-}
-
-function makeContainer(
-    rows: { count: number; height: number },
-    size: { clientHeight?: number; maxHeight?: number },
-    extras: { messageOnly?: boolean } = {},
-) {
-    const container = document.createElement('div');
-    // happy-dom only resolves computed styles (the max-height limit) for
-    // elements attached to the document
-    document.body.append(container);
-    if (size.maxHeight !== undefined) {
-        container.style.maxHeight = `${size.maxHeight}px`;
-    }
-    Object.defineProperty(container, 'clientHeight', {
-        configurable: true,
-        get: () => size.clientHeight ?? 0,
-    });
-    if (extras.messageOnly) {
-        container.append(document.createElement('div'));
-        return container;
-    }
-    // rows share one uniform height, matching the es-autocomplete-item styles
-    for (let index = 0; index < rows.count; index += 1) {
-        const el = document.createElement('div');
-        el.dataset.esAutocompleteItem = '';
-        Object.defineProperty(el, 'offsetHeight', { configurable: true, value: rows.height });
-        container.append(el);
-    }
-    return container;
-}
-
-describe('useEsAutocompleteVisibleRows', () => {
-    it('renders the number of whole rows that fit the height limit', async () => {
-        const contentEl = ref<HTMLElement | null>(makeContainer({ count: 7, height: 30 }, { maxHeight: 100 }));
-        const suggestions = ref(suggestionList(7));
-        const fit = withSetup(() => useEsAutocompleteVisibleRows(contentEl, suggestions, 10));
-        await fit.remeasure();
-        // floor(100 / 30) = 3 whole rows; the fourth would be partially shown
-        expect(fit.visibleSuggestions.value).toHaveLength(3);
-        expect(fit.measured.value).toBe(true);
-    });
-
-    it('never trims below one row, even when none fully fits', async () => {
-        const contentEl = ref<HTMLElement | null>(makeContainer({ count: 1, height: 200 }, { maxHeight: 100 }));
-        const suggestions = ref(suggestionList(5));
-        const fit = withSetup(() => useEsAutocompleteVisibleRows(contentEl, suggestions, 10));
-        await fit.remeasure();
-        expect(fit.visibleSuggestions.value).toHaveLength(1);
-    });
-
-    it('a message-only panel (prompt/no-results, no rows) is measured and untrimmed', async () => {
-        const contentEl = ref<HTMLElement | null>(
-            makeContainer({ count: 0, height: 0 }, { maxHeight: 100 }, { messageOnly: true }),
-        );
-        const suggestions = ref<EsAutocompleteSuggestion[]>([]);
-        const fit = withSetup(() => useEsAutocompleteVisibleRows(contentEl, suggestions, 10));
-        await fit.remeasure();
-        expect(fit.measured.value).toBe(true);
-    });
-
-    it('prefers the resolved max-height over the content-sized clientHeight', async () => {
-        // clientHeight is content-limited (40) but max-height allows 100: the count
-        // must come from what COULD fit, or a grown viewport never refills
-        const contentEl = ref<HTMLElement | null>(
-            makeContainer({ count: 5, height: 30 }, { clientHeight: 40, maxHeight: 100 }),
-        );
-        const suggestions = ref(suggestionList(5));
-        const fit = withSetup(() => useEsAutocompleteVisibleRows(contentEl, suggestions, 10));
-        await fit.remeasure();
-        expect(fit.visibleSuggestions.value).toHaveLength(3);
-    });
-
-    it('falls back to clientHeight when there is no max-height (the mobile takeover list)', async () => {
-        const contentEl = ref<HTMLElement | null>(makeContainer({ count: 5, height: 30 }, { clientHeight: 70 }));
-        const suggestions = ref(suggestionList(5));
-        const fit = withSetup(() => useEsAutocompleteVisibleRows(contentEl, suggestions, 10));
-        await fit.remeasure();
-        expect(fit.visibleSuggestions.value).toHaveLength(2);
-    });
-
-    it('re-measures when the suggestions change', async () => {
-        const container = makeContainer({ count: 7, height: 30 }, { maxHeight: 100 });
-        const contentEl = ref<HTMLElement | null>(container);
-        const suggestions = ref(suggestionList(7));
-        const fit = withSetup(() => useEsAutocompleteVisibleRows(contentEl, suggestions, 10));
-        await fit.remeasure();
-        expect(fit.visibleSuggestions.value).toHaveLength(3);
-
-        container.style.maxHeight = '70px';
-        suggestions.value = suggestionList(7);
-        await nextTick(); // the watcher fires
-        await nextTick(); // remeasure's internal tick
-        expect(fit.visibleSuggestions.value).toHaveLength(2);
-    });
-
-    it('adds and removes whole rows on scroll as the available height changes', async () => {
-        const container = makeContainer({ count: 2, height: 30 }, { maxHeight: 70 });
-        const contentEl = ref<HTMLElement | null>(container);
-        const suggestions = ref(suggestionList(7));
-        const fit = withSetup(() => useEsAutocompleteVisibleRows(contentEl, suggestions, 10));
-        await fit.remeasure();
-        expect(fit.visibleSuggestions.value).toHaveLength(2);
-
-        // scrolling moved the anchor and the popper granted more height: the
-        // count grows from the row height alone, without extra rows pre-rendered
-        container.style.maxHeight = '130px';
-        window.dispatchEvent(new Event('scroll'));
-        await new Promise((resolve) => requestAnimationFrame(resolve)); // the handler's deferred frame
-        await nextTick(); // remeasure's internal tick
-        await nextTick();
-        expect(fit.visibleSuggestions.value).toHaveLength(4);
-    });
-
-    it('ignores viewport events while inactive: a closed, still-mounted panel never re-measures on scroll', async () => {
-        const container = makeContainer({ count: 2, height: 30 }, { maxHeight: 70 });
-        const contentEl = ref<HTMLElement | null>(container);
-        const suggestions = ref(suggestionList(7));
-        const active = ref(true);
-        const fit = withSetup(() =>
-            useEsAutocompleteVisibleRows(contentEl, suggestions, 10, { active: () => active.value }),
-        );
-        await fit.remeasure();
-        expect(fit.visibleSuggestions.value).toHaveLength(2);
-
-        active.value = false;
-        container.style.maxHeight = '130px';
-        window.dispatchEvent(new Event('scroll'));
-        await new Promise((resolve) => requestAnimationFrame(resolve));
-        await nextTick();
-        await nextTick();
-        expect(fit.visibleSuggestions.value).toHaveLength(2);
-
-        // reactivating restores the viewport tracking
-        active.value = true;
-        window.dispatchEvent(new Event('scroll'));
-        await new Promise((resolve) => requestAnimationFrame(resolve));
-        await nextTick();
-        await nextTick();
-        expect(fit.visibleSuggestions.value).toHaveLength(4);
-    });
-
-    it('beforeMeasure runs in the same pass, so a limit it writes drives that count', async () => {
-        const container = makeContainer({ count: 7, height: 30 }, {});
-        const contentEl = ref<HTMLElement | null>(container);
-        const suggestions = ref(suggestionList(7));
-        // the caller positions the container and writes its max-height (the
-        // desktop shell's positionPanel) right before each measurement
-        const fit = withSetup(() =>
-            useEsAutocompleteVisibleRows(contentEl, suggestions, 10, {
-                beforeMeasure: () => {
-                    container.style.maxHeight = '70px';
-                },
-            }),
-        );
-        await fit.remeasure();
-        expect(fit.visibleSuggestions.value).toHaveLength(2);
-    });
-
-    it('is unmeasured (list hidden) until a container exists', async () => {
-        const contentEl = ref<HTMLElement | null>(null);
-        const suggestions = ref(suggestionList(3));
-        const fit = withSetup(() => useEsAutocompleteVisibleRows(contentEl, suggestions, 10));
-        expect(fit.measured.value).toBe(false);
-
-        contentEl.value = makeContainer({ count: 3, height: 30 }, { maxHeight: 100 });
-        await nextTick(); // the watcher fires
-        await new Promise((resolve) => requestAnimationFrame(resolve)); // the measure's deferred frame
-        await nextTick(); // remeasure's internal tick
-        expect(fit.measured.value).toBe(true);
-        expect(fit.visibleSuggestions.value).toHaveLength(3);
-    });
-});

package/app/utils/autocomplete.test.ts

@@ -1,103 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { EsAutocompleteTextSegment } from '../types';
-import { splitEsAutocompleteText, splitEsAutocompleteTextLines } from './autocomplete';
-
-// matched (typed) portions render regular; predictive portions render bold
-const regular = (text: string): EsAutocompleteTextSegment => ({ predictive: false, text });
-const bold = (text: string): EsAutocompleteTextSegment => ({ predictive: true, text });
-
-/** segments must always reconstruct the input exactly — no lost or duplicated characters */
-function expectReconstructs(text: string, segments: EsAutocompleteTextSegment[]) {
-    expect(segments.map((segment) => segment.text).join('')).toBe(text);
-}
-
-describe('splitEsAutocompleteText', () => {
-    it('bolds the predictive remainder of a prefix match', () => {
-        expect(splitEsAutocompleteText('solar batteries', 'solar')).toEqual([regular('solar'), bold(' batteries')]);
-    });
-
-    it('matches case-insensitively', () => {
-        expect(splitEsAutocompleteText('Solar Batteries', 'SOLAR')).toEqual([regular('Solar'), bold(' Batteries')]);
-    });
-
-    it('matches tokens in any order, at every word start', () => {
-        expect(splitEsAutocompleteText('123 Main St, Boston, MA', 'boston main')).toEqual([
-            bold('123 '),
-            regular('Main'),
-            bold(' St, '),
-            regular('Boston'),
-            bold(', MA'),
-        ]);
-    });
-
-    it('prefers word starts: "st" matches "St" but not the middle of "Boston"', () => {
-        expect(splitEsAutocompleteText('Boston St', 'st')).toEqual([bold('Boston '), regular('St')]);
-    });
-
-    it('falls back to mid-word matching when a token never matches at a word start', () => {
-        expect(splitEsAutocompleteText('123 Main St', '3')).toEqual([bold('12'), regular('3'), bold(' Main St')]);
-    });
-
-    it('renders everything regular when nothing matches, and for a blank query', () => {
-        expect(splitEsAutocompleteText('solar panels', 'xyz')).toEqual([regular('solar panels')]);
-        expect(splitEsAutocompleteText('solar panels', '  ')).toEqual([regular('solar panels')]);
-    });
-
-    it('merges overlapping token matches', () => {
-        expect(splitEsAutocompleteText('solar panels', 'solar sol')).toEqual([regular('solar'), bold(' panels')]);
-    });
-
-    it('never mis-slices when lowercasing changes string length (e.g. İ)', () => {
-        const text = 'İzmir solar';
-        const segments = splitEsAutocompleteText(text, 'solar');
-        expectReconstructs(text, segments);
-        expect(segments).toContainEqual(regular('solar'));
-    });
-
-    it('always reconstructs the input text exactly', () => {
-        const cases: Array<[string, string]> = [
-            ['solar batteries', 'solar'],
-            ['123 Main St', 'main 123 st'],
-            ['heat pump water heater', 'heat'],
-            ['no match here', 'zzz'],
-            ['', 'anything'],
-        ];
-        for (const [text, query] of cases) {
-            expectReconstructs(text, splitEsAutocompleteText(text, query));
-        }
-    });
-});
-
-describe('splitEsAutocompleteTextLines', () => {
-    const addressLines = ['1200 Beacon St', 'Brookline, MA 02446'];
-
-    it('highlights tokens on the lines they match', () => {
-        expect(splitEsAutocompleteTextLines(['123 Main St', 'Boston, MA 02108'], 'boston main')).toEqual([
-            [bold('123 '), regular('Main'), bold(' St')],
-            [regular('Boston'), bold(', MA 02108')],
-        ]);
-    });
-
-    it('bolds a whole line without its own match when another line matched (bolding mode)', () => {
-        expect(splitEsAutocompleteTextLines(addressLines, 'beacon')).toEqual([
-            [bold('1200 '), regular('Beacon'), bold(' St')],
-            [bold('Brookline, MA 02446')],
-        ]);
-    });
-
-    it('renders every line regular when no line matches', () => {
-        expect(splitEsAutocompleteTextLines(addressLines, 'zzz')).toEqual([
-            [regular('1200 Beacon St')],
-            [regular('Brookline, MA 02446')],
-        ]);
-    });
-
-    it('decides the word-start fallback across all lines together', () => {
-        // "st" has a word-start match on line 1, so it must NOT fall back to
-        // mid-word matching inside "Brookline" on line 2
-        expect(splitEsAutocompleteTextLines(addressLines, 'beacon st')).toEqual([
-            [bold('1200 '), regular('Beacon'), bold(' '), regular('St')],
-            [bold('Brookline, MA 02446')],
-        ]);
-    });
-});

package/eslint.config.mjs

@@ -1,37 +0,0 @@
-import withNuxt from '../es-ds-docs/.nuxt/eslint.config.mjs';
-
-export default withNuxt()
-    .override('nuxt/vue/rules', {
-        rules: {
-            'vue/component-name-in-template-casing': [
-                'error',
-                'kebab-case',
-                {
-                    registeredComponentsOnly: false,
-                    ignores: [],
-                },
-            ],
-            'vue/block-order': [
-                'error',
-                {
-                    order: [['script[setup]', 'script:not([setup])'], 'template', 'style'],
-                },
-            ],
-            'vue/block-lang': [
-                'error',
-                {
-                    script: {
-                        lang: 'ts',
-                    },
-                },
-            ],
-            'vue/html-self-closing': 'off',
-        },
-    })
-    .override('nuxt/typescript/rules', {
-        rules: {
-            '@typescript-eslint/no-explicit-any': 'off',
-            '@typescript-eslint/no-unsafe-function-type': 'off',
-            '@typescript-eslint/ban-ts-comment': 'off',
-        },
-    });

package/tsconfig.json

@@ -1,4 +0,0 @@
-{
-    // https://nuxt.com/docs/guide/concepts/typescript
-    "extends": "../es-ds-docs/.nuxt/tsconfig.json"
-}