@energysage/es-ds-components 6.3.1 → 6.3.3

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

@@ -1,246 +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('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"
-}