@crowdstrike/glide-core 0.13.0 → 0.14.0

package/dist/input.test.focus.js

@@ -1,58 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions */
-import './input.js';
-import { expect, fixture, html } from '@open-wc/testing';
-import GlideCoreInput from './input.js';
-GlideCoreInput.shadowRootOptions.mode = 'open';
-it('focuses the input when `focus()` is called', async () => {
-    const component = await fixture(html `<glide-core-input required></glide-core-input>`);
-    component.focus();
-    const inputElement = component.shadowRoot?.querySelector('input');
-    expect(component.shadowRoot?.activeElement).to.equal(inputElement);
-});
-it('focuses the input after submit when required and no value', async () => {
-    const form = document.createElement('form');
-    const component = await fixture(html `<glide-core-input required></glide-core-input>`, {
-        parentNode: form,
-    });
-    form.requestSubmit();
-    const inputElement = component.shadowRoot?.querySelector('input');
-    expect(component.shadowRoot?.activeElement).to.be.equal(inputElement);
-});
-it('blurs the input and reports validity if `blur` is called', async () => {
-    const component = await fixture(html `<glide-core-input required></glide-core-input>`);
-    component.focus();
-    const inputElement = component.shadowRoot?.querySelector('input');
-    expect(component.shadowRoot?.activeElement).to.equal(inputElement);
-    component.blur();
-    await component.updateComplete;
-    expect(component.shadowRoot?.activeElement).to.equal(null);
-    expect(component.validity.valid).to.be.false;
-    expect(component.shadowRoot?.querySelector('glide-core-private-label')?.error)
-        .to.be.true;
-});
-it('focuses the input after `reportValidity` is called when required and no value', async () => {
-    const form = document.createElement('form');
-    const component = await fixture(html `<glide-core-input required></glide-core-input>`, {
-        parentNode: form,
-    });
-    component.reportValidity();
-    const inputElement = component.shadowRoot?.querySelector('input');
-    expect(component.shadowRoot?.activeElement).to.equal(inputElement);
-});
-it('focuses the input after `requestSubmit` is called when required and no value', async () => {
-    const form = document.createElement('form');
-    const component = await fixture(html `<glide-core-input required></glide-core-input>`, {
-        parentNode: form,
-    });
-    form.requestSubmit();
-    const inputElement = component.shadowRoot?.querySelector('input');
-    expect(component.shadowRoot?.activeElement === inputElement).to.be.true;
-});
-it('does not focus the input after `checkValidity` is called', async () => {
-    const form = document.createElement('form');
-    const component = await fixture(html `<glide-core-input required></glide-core-input>`, {
-        parentNode: form,
-    });
-    component.checkValidity();
-    expect(component.shadowRoot?.activeElement === null).to.be.true;
-});

package/dist/input.test.form.d.ts

@@ -1 +0,0 @@
-import './input.js';

package/dist/input.test.form.js

@@ -1,74 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions */
-import './input.js';
-import { expect, fixture, html } from '@open-wc/testing';
-import { sendKeys } from '@web/test-runner-commands';
-import GlideCoreInput from './input.js';
-import sinon from 'sinon';
-it('can be reset to initial value', async () => {
-    const form = document.createElement('form');
-    const component = await fixture(html `<glide-core-input value="value"></glide-core-input>`, {
-        parentNode: form,
-    });
-    component.value = '';
-    form.reset();
-    expect(component.value).to.equal('value');
-});
-it('can be reset if there was no initial value', async () => {
-    const form = document.createElement('form');
-    const component = await fixture(html `<glide-core-input></glide-core-input>`, {
-        parentNode: form,
-    });
-    component.value = 'value';
-    form.reset();
-    expect(component.value).to.equal('');
-});
-it('has `formData` value when it has a value', async () => {
-    const form = document.createElement('form');
-    await fixture(html `<glide-core-input name="name" value="value"></glide-core-input>`, {
-        parentNode: form,
-    });
-    const formData = new FormData(form);
-    expect(formData.get('name')).to.be.equal('value');
-});
-it('has no `formData` value when no value', async () => {
-    const form = document.createElement('form');
-    await fixture(html `<glide-core-input name="name"></glide-core-input>`, {
-        parentNode: form,
-    });
-    const formData = new FormData(form);
-    expect(formData.get('name')).to.be.null;
-});
-it('has no `formData` value when it has a value but disabled', async () => {
-    const form = document.createElement('form');
-    await fixture(html `<glide-core-input
-      name="name"
-      value="value"
-      disabled
-    ></glide-core-input>`, {
-        parentNode: form,
-    });
-    const formData = new FormData(form);
-    expect(formData.get('name')).to.be.null;
-});
-it('has no `formData` value when it has a value but without a `name`', async () => {
-    const form = document.createElement('form');
-    await fixture(html `<glide-core-input value="value"></glide-core-input>`, {
-        parentNode: form,
-    });
-    const formData = new FormData(form);
-    expect(formData.get('name')).to.be.null;
-});
-it('submits its form on Enter', async () => {
-    const form = document.createElement('form');
-    const component = await fixture(html `<glide-core-input value="value"></glide-core-input>`, {
-        parentNode: form,
-    });
-    const spy = sinon.spy();
-    form.addEventListener('submit', (event) => {
-        event.preventDefault();
-        spy();
-    });
-    component.focus();
-    await sendKeys({ press: 'Enter' });
-    expect(spy.callCount).to.equal(1);
-});

package/dist/input.test.validity.d.ts

@@ -1 +0,0 @@
-import './input.js';

package/dist/input.test.validity.js

@@ -1,258 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions */
-import './input.js';
-import { elementUpdated, expect, fixture, html } from '@open-wc/testing';
-import { sendKeys } from '@web/test-runner-commands';
-import GlideCoreInput from './input.js';
-GlideCoreInput.shadowRootOptions.mode = 'open';
-it('is valid if empty but not required', async () => {
-    const component = await fixture(html `<glide-core-input></glide-core-input>`);
-    expect(component.validity?.valid).to.be.true;
-    expect(component.validity?.valueMissing).to.be.false;
-    expect(component.checkValidity()).to.be.true;
-    expect(component.reportValidity()).to.be.true;
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('false');
-});
-it('is valid after being filled in when empty and required', async () => {
-    const component = await fixture(html `<glide-core-input required></glide-core-input>`);
-    component.focus();
-    await sendKeys({ type: 'value' });
-    expect(component.validity?.valid).to.be.true;
-    expect(component.validity?.valueMissing).to.be.false;
-    expect(component.checkValidity()).to.be.true;
-    expect(component.reportValidity()).to.be.true;
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('false');
-});
-it('is invalid if no value and required', async () => {
-    const component = await fixture(html `<glide-core-input required></glide-core-input>`);
-    expect(component.validity?.valid).to.be.false;
-    expect(component.validity?.valueMissing).to.be.true;
-    expect(component.willValidate).to.be.true;
-    expect(component.checkValidity()).to.be.false;
-    expect(component.reportValidity()).to.be.false;
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('true');
-});
-it('is invalid after value is cleared when required', async () => {
-    const component = await fixture(html `<glide-core-input
-      clearable
-      value="value"
-      required
-    ></glide-core-input>`);
-    const clearButton = component.shadowRoot?.querySelector('[data-test="clear-button"]');
-    clearButton?.click();
-    await component.updateComplete;
-    expect(component.validity?.valid).to.be.false;
-    expect(component.validity?.valueMissing).to.be.true;
-    expect(component.checkValidity()).to.be.false;
-    expect(component.reportValidity()).to.be.false;
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('true');
-});
-it('is valid if no value and required but disabled', async () => {
-    const component = await fixture(html `<glide-core-input disabled required></glide-core-input>`);
-    expect(component.validity?.valid).to.be.true;
-    expect(component.validity?.valueMissing).to.be.false;
-    expect(component.checkValidity()).to.be.true;
-    expect(component.reportValidity()).to.be.true;
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('false');
-});
-it('updates validity when `required` and `value` is changed programmatically', async () => {
-    const component = await fixture(html `<glide-core-input label="Label" required></glide-core-input>`);
-    expect(component.validity?.valid).to.be.false;
-    expect(component.validity?.valueMissing).to.be.true;
-    expect(component.checkValidity()).to.be.false;
-    expect(component.reportValidity()).to.be.false;
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('true');
-    component.value = 'text';
-    await elementUpdated(component);
-    expect(component.validity?.valid).to.be.true;
-    expect(component.validity?.valueMissing).to.be.false;
-    expect(component.checkValidity()).to.be.true;
-    expect(component.reportValidity()).to.be.true;
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('false');
-    // Resetting the value to empty to ensure it goes
-    // back to an invalid state
-    component.value = '';
-    await elementUpdated(component);
-    expect(component.validity?.valid).to.be.false;
-    expect(component.validity?.valueMissing).to.be.true;
-    expect(component.checkValidity()).to.be.false;
-    expect(component.reportValidity()).to.be.false;
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('true');
-});
-it('is invalid when `value` is empty and `required` is set to `true` programmatically', async () => {
-    const component = await fixture(html `<glide-core-input label="Label"></glide-core-input>`);
-    expect(component.validity?.valid).to.be.true;
-    expect(component.validity?.valueMissing).to.be.false;
-    expect(component.checkValidity()).to.be.true;
-    expect(component.reportValidity()).to.be.true;
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('false');
-    component.required = true;
-    await elementUpdated(component);
-    expect(component.validity?.valid).to.be.false;
-    expect(component.validity?.valueMissing).to.be.true;
-    expect(component.checkValidity()).to.be.false;
-    expect(component.reportValidity()).to.be.false;
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('true');
-});
-it('is valid when `value` is empty and `required` is updated to `false` programmatically', async () => {
-    const component = await fixture(html `<glide-core-input label="Label" required></glide-core-input>`);
-    expect(component.validity?.valid).to.be.false;
-    expect(component.validity?.valueMissing).to.be.true;
-    expect(component.checkValidity()).to.be.false;
-    expect(component.reportValidity()).to.be.false;
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('true');
-    component.required = false;
-    await elementUpdated(component);
-    expect(component.validity?.valid).to.be.true;
-    expect(component.validity?.valueMissing).to.be.false;
-    expect(component.checkValidity()).to.be.true;
-    expect(component.reportValidity()).to.be.true;
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('false');
-});
-it('is valid when the `value` attribute matches `pattern`', async () => {
-    const component = await fixture(html `<glide-core-input
-      label="Label"
-      pattern="[a-z]{4,8}"
-      value="value"
-    ></glide-core-input>`);
-    expect(component.validity?.valid).to.be.true;
-    expect(component.validity?.patternMismatch).to.be.false;
-    expect(component.checkValidity()).to.be.true;
-    expect(component.reportValidity()).to.be.true;
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('false');
-});
-it('is valid when `value` matches `pattern` after being set programmatically', async () => {
-    const component = await fixture(html `<glide-core-input
-      label="Label"
-      pattern="[a-z]{4,8}"
-    ></glide-core-input>`);
-    component.value = 'value';
-    await elementUpdated(component);
-    expect(component.validity?.valid).to.be.true;
-    expect(component.validity?.patternMismatch).to.be.false;
-    expect(component.checkValidity()).to.be.true;
-    expect(component.reportValidity()).to.be.true;
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('false');
-});
-it('is invalid when `value` does not match `pattern`', async () => {
-    const component = await fixture(html `<glide-core-input
-      label="Label"
-      pattern="[a-z]{4,8}"
-      value="1234"
-    ></glide-core-input>`);
-    expect(component.validity?.valid).to.be.false;
-    expect(component.validity?.patternMismatch).to.be.true;
-    expect(component.checkValidity()).to.be.false;
-    expect(component.reportValidity()).to.be.false;
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('true');
-});
-it('is invalid when a programmatically set `value` does not match `pattern`', async () => {
-    const component = await fixture(html `<glide-core-input
-      label="Label"
-      pattern="[a-z]{4,8}"
-    ></glide-core-input>`);
-    component.value = 'val';
-    expect(component.validity?.valid).to.be.false;
-    expect(component.validity?.patternMismatch).to.be.true;
-    expect(component.checkValidity()).to.be.false;
-    expect(component.reportValidity()).to.be.false;
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('true');
-});
-it('is invalid when `required` and `value` does not match `pattern`', async () => {
-    const component = await fixture(html `<glide-core-input
-      label="Label"
-      pattern="[a-z]{4,8}"
-      required
-    ></glide-core-input>`);
-    expect(component.validity?.valid).to.be.false;
-    expect(component.validity?.patternMismatch).to.be.true;
-    expect(component.validity?.valueMissing).to.be.true;
-});
-it('is valid when `pattern` is programmatically removed', async () => {
-    const component = await fixture(html `<glide-core-input
-      label="Label"
-      pattern="[a-z]{4,8}"
-    ></glide-core-input>`);
-    component.pattern = undefined;
-    await elementUpdated(component);
-    expect(component.validity?.valid).to.be.true;
-    expect(component.validity?.patternMismatch).to.be.false;
-    expect(component.checkValidity()).to.be.true;
-    expect(component.reportValidity()).to.be.true;
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('false');
-});
-it('sets the validity message with `setCustomValidity()`', async () => {
-    const component = await fixture(html `<glide-core-input label="Label"></glide-core-input>`);
-    component.setCustomValidity('validity message');
-    expect(component.validity?.valid).to.be.false;
-    expect(component.validity?.customError).to.be.true;
-    expect(component.checkValidity()).to.be.false;
-    await elementUpdated(component);
-    // Like native, the validity message shouldn't display until `reportValidity()` is called.
-    expect(component.shadowRoot?.querySelector('[data-test="validity-message"]')
-        ?.textContent).to.be.undefined;
-    expect(component.reportValidity()).to.be.false;
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('true');
-    expect(component.shadowRoot?.querySelector('[data-test="validity-message"]')
-        ?.textContent).to.equal('validity message');
-});
-it('removes a validity message with an empty argument to `setCustomValidity()`', async () => {
-    const component = await fixture(html `<glide-core-input label="Label"></glide-core-input>`);
-    component.setCustomValidity('validity message');
-    component.reportValidity();
-    await elementUpdated(component);
-    component.setCustomValidity('');
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('[data-test="validity-message"]')
-        ?.textContent).to.be.undefined;
-});
-it('is invalid when `setValidity()` is called', async () => {
-    const component = await fixture(html `<glide-core-input label="Label"></glide-core-input>`);
-    component.setValidity({ customError: true }, 'validity message');
-    expect(component.validity.valid).to.be.false;
-    await elementUpdated(component);
-    // Like native, the validity message shouldn't display until `reportValidity()` is called.
-    expect(component.shadowRoot?.querySelector('[data-test="validity-message"]')
-        ?.textContent).to.be.undefined;
-    expect(component.validity?.customError).to.be.true;
-    component.reportValidity();
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('input')?.getAttribute('aria-invalid')).to.equal('true');
-    expect(component.shadowRoot?.querySelector('[data-test="validity-message"]')
-        ?.textContent).to.equal('validity message');
-});
-it('is valid when `setValidity()` is called', async () => {
-    const component = await fixture(html `<glide-core-input label="Label"></glide-core-input>`);
-    component.setValidity({ customError: true }, 'validity message');
-    component.setValidity({});
-    await elementUpdated(component);
-    expect(component.validity.valid).to.be.true;
-    expect(component.validity.customError).to.be.false;
-    expect(component.reportValidity()).to.be.true;
-    await elementUpdated(component);
-    expect(component.shadowRoot?.querySelector('[data-test="validity-message"]')
-        ?.textContent).to.be.undefined;
-});
-it('retains existing validity state when `setCustomValidity()` is called', async () => {
-    const component = await fixture(html `<glide-core-input
-      label="Label"
-      pattern="[a-z]{4,8}"
-      required
-    ></glide-core-input>`);
-    component.setCustomValidity('validity message');
-    expect(component.validity?.valid).to.be.false;
-    expect(component.validity?.customError).to.be.true;
-    expect(component.validity?.patternMismatch).to.be.true;
-    expect(component.validity?.valueMissing).to.be.true;
-});

package/dist/label.test.basics.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/label.test.basics.js

@@ -1,136 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions */
-import { ArgumentError } from 'ow';
-import { expect, fixture, html, waitUntil } from '@open-wc/testing';
-import GlideCoreLabel from './label.js';
-import sinon from 'sinon';
-GlideCoreLabel.shadowRootOptions.mode = 'open';
-it('registers', async () => {
-    expect(window.customElements.get('glide-core-private-label')).to.equal(GlideCoreLabel);
-});
-it('has defaults', async () => {
-    const component = await fixture(html `<glide-core-private-label>
-      <label for="input">Label</label>
-      <input id="input" slot="control" />
-    </glide-core-private-label>`);
-    expect(component.getAttribute('error')).to.equal(null);
-    expect(component.error).to.be.false;
-    expect(component.getAttribute('hide')).to.equal(null);
-    expect(component.hide).to.be.false;
-    expect(component.getAttribute('orientation')).to.equal('horizontal');
-    expect(component.orientation).to.equal('horizontal');
-    expect(component.hasAttribute('required')).to.be.false;
-    expect(component.required).to.be.false;
-});
-it('is accessible', async () => {
-    const component = await fixture(html `<glide-core-private-label>
-      <label for="input">Label</label>
-      <input id="input" slot="control" />
-      <div slot="tooltip">Tooltip</div>
-      <div slot="description">Description</div>
-    </glide-core-private-label>`);
-    await expect(component).to.be.accessible();
-});
-it('can have a label', async () => {
-    const component = await fixture(html `<glide-core-private-label>
-      <label for="input">Label</label>
-      <input id="input" slot="control" />
-    </glide-core-private-label>`);
-    const assignedElements = component.shadowRoot
-        ?.querySelector('slot:not([name])')
-        ?.assignedElements();
-    expect(assignedElements?.at(0)?.textContent).to.equal('Label');
-});
-it('can have a description', async () => {
-    const component = await fixture(html `<glide-core-private-label>
-      <label for="input">Label</label>
-      <input id="input" slot="control" />
-      <div slot="description">Description</div>
-    </glide-core-private-label>`);
-    const assignedElements = component.shadowRoot
-        ?.querySelector('slot[name="description"]')
-        ?.assignedElements();
-    expect(assignedElements?.at(0)?.textContent).to.equal('Description');
-});
-it('can have a tooltip', async () => {
-    const component = await fixture(html `<glide-core-private-label>
-      <label for="input">Label</label>
-      <input id="input" slot="control" />
-      <div slot="tooltip">Tooltip</div>
-    </glide-core-private-label>`);
-    const assignedElements = component.shadowRoot
-        ?.querySelector('slot[name="tooltip"]')
-        ?.assignedElements();
-    expect(assignedElements?.at(0)?.textContent).to.equal('Tooltip');
-});
-it('can be required', async () => {
-    const component = await fixture(html `<glide-core-private-label required>
-      <label for="input">Label</label>
-      <input id="input" slot="control" />
-    </glide-core-private-label>`);
-    expect(component.hasAttribute('required')).to.be.true;
-    expect(component.required).to.be.true;
-    const label = component.shadowRoot?.querySelector('[data-test="label"]');
-    expect(label?.textContent?.includes('*')).to.be.true;
-});
-it('can have an `error`', async () => {
-    const component = await fixture(html `<glide-core-private-label ?error=${true}>
-      <label for="input">Label</label>
-      <input id="input" slot="control" />
-    </glide-core-private-label>`);
-    expect(component.hasAttribute('error')).to.be.true;
-    expect(component.error).to.be.true;
-});
-it('places the tooltip on the bottom when horizontal', async () => {
-    const component = await fixture(html `<glide-core-private-label>
-      <label for="input">Label</label>
-      <input id="input" slot="control" />
-      <div slot="tooltip">Tooltip</div>
-    </glide-core-private-label>`);
-    expect(component.shadowRoot
-        ?.querySelector('glide-core-tooltip')
-        ?.getAttribute('placement')).to.equal('bottom');
-});
-it('places the tooltip on the right when vertical', async () => {
-    const component = await fixture(html `<glide-core-private-label orientation="vertical">
-      <label for="input">Label</label>
-      <input id="input" slot="control" />
-      <div slot="tooltip">Tooltip</div>
-    </glide-core-private-label>`);
-    expect(component.shadowRoot
-        ?.querySelector('glide-core-tooltip')
-        ?.getAttribute('placement')).to.equal('right');
-});
-it('throws if it does not have a default slot', async () => {
-    const spy = sinon.spy();
-    try {
-        await fixture(html `<glide-core-private-label
-        ><input slot="control"
-      /></glide-core-private-label>`);
-    }
-    catch (error) {
-        if (error instanceof ArgumentError) {
-            spy();
-        }
-    }
-    expect(spy.callCount).to.equal(1);
-});
-it('throws if it does not have a "control" slot', async () => {
-    const spy = sinon.spy();
-    const stub = sinon.stub(console, 'error');
-    try {
-        await fixture(html `<glide-core-private-label>
-        <label>Label</label>
-      </glide-core-private-label>`);
-    }
-    catch (error) {
-        if (error instanceof ArgumentError) {
-            spy();
-        }
-    }
-    expect(spy.callCount).to.equal(1);
-    // It's not clear to me why the error logged by Ow shows up in the console
-    // here and not in the above test or elsewhere. A bug in Web Test Runner?
-    // Something I don't understand about Lit's lifecycle?
-    await waitUntil(() => stub.called);
-    stub.restore();
-});

package/dist/menu.button.test.basics.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/menu.button.test.basics.js

@@ -1,43 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions */
-import { expect, fixture, html } from '@open-wc/testing';
-import GlideCoreMenuButton from './menu.button.js';
-GlideCoreMenuButton.shadowRootOptions.mode = 'open';
-it('registers', async () => {
-    expect(window.customElements.get('glide-core-menu-button')).to.equal(GlideCoreMenuButton);
-});
-it('has defaults', async () => {
-    // Required attributes are supplied and not asserted below. The idea is that
-    // this test shouldn't fail to typecheck if these templates are eventually
-    // typechecked, which means supplying required attributes up front.
-    const component = await fixture(html `<glide-core-menu-button label="Label"></glide-core-menu-button>`);
-    // Not reflected. So no attribute assertions are necessary.
-    expect(component.privateActive).to.be.false;
-});
-it('can have a label', async () => {
-    const component = await fixture(html `<glide-core-menu-button label="Label"></glide-core-menu-button>`);
-    expect(component.shadowRoot?.textContent?.trim()).to.equal('Label');
-});
-it('can have an icon', async () => {
-    const component = await fixture(html `<glide-core-menu-button label="Label">
-      <svg
-        slot="icon"
-        width="16"
-        height="16"
-        fill="none"
-        viewBox="0 0 24 24"
-        stroke-width="1.5"
-        stroke="currentColor"
-      >
-        <path
-          stroke-linecap="round"
-          stroke-linejoin="round"
-          d="m16.862 4.487 1.687-1.688a1.875 1.875 0 1 1 2.652 2.652L10.582 16.07a4.5 4.5 0 0 1-1.897 1.13L6 18l.8-2.685a4.5 4.5 0 0 1 1.13-1.897l8.932-8.931Zm0 0L19.5 7.125M18 14v4.75A2.25 2.25 0 0 1 15.75 21H5.25A2.25 2.25 0 0 1 3 18.75V8.25A2.25 2.25 0 0 1 5.25 6H10"
-        />
-      </svg>
-    </glide-core-menu-button>`);
-    const icon = component?.shadowRoot
-        ?.querySelector('slot[name="icon"]')
-        ?.assignedElements()
-        .at(0);
-    expect(icon instanceof Element).to.be.true;
-});

package/dist/menu.link.test.basics.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/menu.link.test.basics.js

@@ -1,47 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions */
-import { expect, fixture, html } from '@open-wc/testing';
-import GlideCoreMenuLink from './menu.link.js';
-GlideCoreMenuLink.shadowRootOptions.mode = 'open';
-it('registers', async () => {
-    expect(window.customElements.get('glide-core-menu-link')).to.equal(GlideCoreMenuLink);
-});
-it('has defaults', async () => {
-    // Required attributes are supplied and not asserted below. The idea is that
-    // this test shouldn't fail to typecheck if these templates are eventually
-    // typechecked, which means supplying required attributes up front.
-    const component = await fixture(html `<glide-core-menu-link label="Label" url="/"></glide-core-menu-link>`);
-    // Not reflected. So no attribute assertions are necessary.
-    expect(component.privateActive).to.be.false;
-});
-it('can have a label', async () => {
-    const component = await fixture(html `<glide-core-menu-link label="Label" url="/"></glide-core-menu-link>`);
-    expect(component.shadowRoot?.textContent?.trim()).to.equal('Label');
-});
-it('can have a URL', async () => {
-    const component = await fixture(html `<glide-core-menu-link label="Label" url="/"></glide-core-menu-link>`);
-    expect(component.url).to.equal('/');
-});
-it('can have an icon', async () => {
-    const component = await fixture(html `<glide-core-menu-link label="Label">
-      <svg
-        slot="icon"
-        width="16"
-        height="16"
-        fill="none"
-        viewBox="0 0 24 24"
-        stroke-width="1.5"
-        stroke="currentColor"
-      >
-        <path
-          stroke-linecap="round"
-          stroke-linejoin="round"
-          d="m16.862 4.487 1.687-1.688a1.875 1.875 0 1 1 2.652 2.652L10.582 16.07a4.5 4.5 0 0 1-1.897 1.13L6 18l.8-2.685a4.5 4.5 0 0 1 1.13-1.897l8.932-8.931Zm0 0L19.5 7.125M18 14v4.75A2.25 2.25 0 0 1 15.75 21H5.25A2.25 2.25 0 0 1 3 18.75V8.25A2.25 2.25 0 0 1 5.25 6H10"
-        />
-      </svg>
-    </glide-core-menu-link>`);
-    const icon = component?.shadowRoot
-        ?.querySelector('slot[name="icon"]')
-        ?.assignedElements()
-        .at(0);
-    expect(icon instanceof Element).to.be.true;
-});

package/dist/menu.options.test.basics.d.ts

@@ -1,2 +0,0 @@
-import './menu.button.js';
-import './menu.link.js';