1739 lines
68 KiB
JavaScript
1739 lines
68 KiB
JavaScript
import { LitElement } from 'lit';
|
|
import { repeat } from 'lit/directives/repeat.js';
|
|
import { Required } from '@lion/ui/form-core.js';
|
|
import { LionOptions } from '@lion/ui/listbox.js';
|
|
import '@lion/ui/define/lion-listbox.js';
|
|
import '@lion/ui/define/lion-option.js';
|
|
import {
|
|
aTimeout,
|
|
defineCE,
|
|
expect,
|
|
fixture as _fixture,
|
|
html,
|
|
nextFrame,
|
|
unsafeStatic,
|
|
} from '@open-wc/testing';
|
|
import { sendKeys } from '@web/test-runner-commands';
|
|
import sinon from 'sinon';
|
|
import { getListboxMembers } from '../../../exports/listbox-test-helpers.js';
|
|
import { browserDetection } from '../../core/src/browserDetection.js';
|
|
|
|
/**
|
|
* @typedef {import('../src/LionListbox.js').LionListbox} LionListbox
|
|
* @typedef {import('../src/LionOption.js').LionOption} LionOption
|
|
* @typedef {import('../../select-rich/src/LionSelectInvoker.js').LionSelectInvoker} LionSelectInvoker
|
|
* @typedef {import('lit').TemplateResult} TemplateResult
|
|
*/
|
|
|
|
const fixture = /** @type {(arg: TemplateResult) => Promise<LionListbox>} */ (_fixture);
|
|
|
|
/**
|
|
* @param {HTMLElement} el
|
|
* @param {string} key
|
|
* @param {string} code
|
|
*/
|
|
function mimicKeyPress(el, key, code = '') {
|
|
el.dispatchEvent(new KeyboardEvent('keydown', { key, code }));
|
|
el.dispatchEvent(new KeyboardEvent('keyup', { key, code }));
|
|
}
|
|
|
|
/**
|
|
* @param { {tagString?:string, optionTagString?:string} } [customConfig]
|
|
*/
|
|
export function runListboxMixinSuite(customConfig = {}) {
|
|
const cfg = {
|
|
tagString: 'lion-listbox',
|
|
optionTagString: 'lion-option',
|
|
...customConfig,
|
|
};
|
|
|
|
const tag = unsafeStatic(cfg.tagString);
|
|
const optionTag = unsafeStatic(cfg.optionTagString);
|
|
|
|
describe('ListboxMixin', () => {
|
|
// TODO: See if it is possible to get functionality from ChoiceGroup and/or Field suite(s)
|
|
describe('FormControl (Field / ChoiceGroup) functionality', () => {
|
|
it('has a single modelValue representing the currently checked option', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} name="foo">
|
|
<${optionTag} .choiceValue=${'10'} checked>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${'20'}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
expect(el.modelValue).to.equal('10');
|
|
});
|
|
|
|
it('should dispatch model-value-changed 1 time on first paint', async () => {
|
|
const spy = sinon.spy();
|
|
await fixture(html`
|
|
<${tag} @model-value-changed="${spy}">
|
|
<${optionTag} .choiceValue="${'10'}">Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue="${'20'}">Item 2</${optionTag}>
|
|
<${optionTag} .choiceValue="${'30'}">Item 3</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
expect(spy.callCount).to.equal(1);
|
|
});
|
|
|
|
it('should dispatch model-value-changed 1 time on interaction', async () => {
|
|
const spy = sinon.spy();
|
|
const el = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag} .choiceValue="${'10'}">Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue="${'20'}">Item 2</${optionTag}>
|
|
<${optionTag} .choiceValue="${'30'}">Item 3</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
|
|
el.addEventListener('model-value-changed', spy);
|
|
el.formElements[1].checked = true;
|
|
expect(spy.callCount).to.equal(1);
|
|
|
|
spy.resetHistory();
|
|
|
|
el.formElements[2].checked = true;
|
|
expect(spy.callCount).to.equal(1);
|
|
});
|
|
|
|
it('should not dispatch model-value-changed on reappend checked child', async () => {
|
|
const spy = sinon.spy();
|
|
const el = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag} .choiceValue="${'10'}">Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue="${'20'}">Item 2</${optionTag}>
|
|
<${optionTag} .choiceValue="${'30'}">Item 3</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
|
|
el.addEventListener('model-value-changed', spy);
|
|
el.formElements[1].checked = true;
|
|
expect(spy.callCount).to.equal(1);
|
|
|
|
el.appendChild(el.formElements[1]);
|
|
expect(spy.callCount).to.equal(1);
|
|
});
|
|
|
|
it('automatically sets the name attribute of child checkboxes to its own name', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} name="foo">
|
|
<${optionTag} .choiceValue=${10} checked>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
|
|
expect(el.formElements[0].name).to.equal('foo');
|
|
expect(el.formElements[1].name).to.equal('foo');
|
|
|
|
const validChild = await fixture(
|
|
html` <${optionTag} .choiceValue=${30}>Item 3</${optionTag}> `,
|
|
);
|
|
el.appendChild(validChild);
|
|
|
|
expect(el.formElements[2].name).to.equal('foo');
|
|
});
|
|
|
|
it('throws if a child element without a modelValue like { value: "foo", checked: false } tries to register', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} name="foo">
|
|
<${optionTag} .choiceValue=${10} checked>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const invalidChild = await fixture(
|
|
html` <${optionTag} .modelValue=${'Lara'}></${optionTag}> `,
|
|
);
|
|
|
|
expect(() => {
|
|
el.addFormElement(invalidChild);
|
|
}).to.throw(
|
|
`The ${cfg.tagString} name="foo" does not allow to register lion-option with .modelValue="Lara" - The modelValue should represent an Object { value: "foo", checked: false }`,
|
|
);
|
|
});
|
|
|
|
it('can set initial modelValue on creation', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} name="gender" .modelValue=${'other'}>
|
|
<${optionTag} .choiceValue=${'male'}></${optionTag}>
|
|
<${optionTag} .choiceValue=${'female'}></${optionTag}>
|
|
<${optionTag} .choiceValue=${'other'}></${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
|
|
expect(el.modelValue).to.equal('other');
|
|
expect(el.formElements[2].checked).to.be.true;
|
|
});
|
|
|
|
it('requests update for modelValue when checkedIndex changes', async () => {
|
|
const el = /** @type {LionListbox} */ await fixture(html`
|
|
<${tag} name="gender" .modelValue=${'other'}>
|
|
<${optionTag} .choiceValue=${'male'}></${optionTag}>
|
|
<${optionTag} .choiceValue=${'female'}></${optionTag}>
|
|
<${optionTag} .choiceValue=${'other'}></${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
expect(el.checkedIndex).to.equal(2);
|
|
const requestSpy = sinon.spy(el, 'requestUpdate');
|
|
const updatedSpy = sinon.spy(el, 'updated');
|
|
el.setCheckedIndex(1);
|
|
await el.updateComplete;
|
|
expect(requestSpy).to.have.been.calledWith('modelValue', 'other');
|
|
expect(updatedSpy).to.have.been.calledWith(
|
|
sinon.match.map.contains(new Map([['modelValue', 'other']])),
|
|
);
|
|
});
|
|
|
|
it('requests update for modelValue after click', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} name="gender" .modelValue=${'other'}>
|
|
<${optionTag} .choiceValue=${'male'}></${optionTag}>
|
|
<${optionTag} .choiceValue=${'female'}></${optionTag}>
|
|
<${optionTag} .choiceValue=${'other'}></${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
expect(el.checkedIndex).to.equal(2);
|
|
const requestSpy = sinon.spy(el, 'requestUpdate');
|
|
const updatedSpy = sinon.spy(el, 'updated');
|
|
el.formElements[0].click();
|
|
await el.updateComplete;
|
|
expect(requestSpy).to.have.been.calledWith('modelValue', 'other');
|
|
expect(updatedSpy).to.have.been.calledWith(
|
|
sinon.match.map.contains(new Map([['modelValue', 'other']])),
|
|
);
|
|
});
|
|
|
|
it('requests update for modelValue when checkedIndex changes for multiple choice', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} name="gender" multiple-choice .modelValue=${['other']}>
|
|
<${optionTag} .choiceValue=${'male'}></${optionTag}>
|
|
<${optionTag} .choiceValue=${'female'}></${optionTag}>
|
|
<${optionTag} .choiceValue=${'other'}></${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
expect(el.checkedIndex).to.eql([2]);
|
|
const requestSpy = sinon.spy(el, 'requestUpdate');
|
|
const updatedSpy = sinon.spy(el, 'updated');
|
|
el.setCheckedIndex(1);
|
|
await el.updateComplete;
|
|
expect(requestSpy).to.have.been.calledWith(
|
|
'modelValue',
|
|
sinon.match.array.deepEquals(['other']),
|
|
);
|
|
expect(updatedSpy).to.have.been.calledOnce;
|
|
// reference values vs real values suck :( had to do it like this, sinon matchers did not match because 'other' is inside an array so it's not a "real" match
|
|
expect([...updatedSpy.args[0][0].entries()]).to.deep.include(['modelValue', ['other']]);
|
|
});
|
|
|
|
it('requests update for modelValue after click for multiple choice', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} name="gender" multiple-choice .modelValue=${['other']}>
|
|
<${optionTag} .choiceValue=${'male'}></${optionTag}>
|
|
<${optionTag} .choiceValue=${'female'}></${optionTag}>
|
|
<${optionTag} .choiceValue=${'other'}></${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
expect(el.checkedIndex).to.eql([2]);
|
|
const requestSpy = sinon.spy(el, 'requestUpdate');
|
|
const updatedSpy = sinon.spy(el, 'updated');
|
|
el.formElements[0].click();
|
|
await el.updateComplete;
|
|
expect(requestSpy).to.have.been.calledWith(
|
|
'modelValue',
|
|
sinon.match.array.deepEquals(['other']),
|
|
);
|
|
expect(updatedSpy).to.have.been.calledOnce;
|
|
// reference values vs real values suck :( had to do it like this, sinon matchers did not match because 'other' is inside an array so it's not a "real" match
|
|
expect([...updatedSpy.args[0][0].entries()]).to.deep.include(['modelValue', ['other']]);
|
|
});
|
|
|
|
it(`has a fieldName based on the label`, async () => {
|
|
const el1 = await fixture(html`
|
|
<${tag} label="foo"></${tag}>
|
|
`);
|
|
const { _labelNode: _labelNode1 } = getListboxMembers(el1);
|
|
expect(el1.fieldName).to.equal(_labelNode1.textContent);
|
|
|
|
const el2 = await fixture(html`
|
|
<${tag}>
|
|
<label slot="label">bar</label>
|
|
</${tag}>
|
|
`);
|
|
const { _labelNode: _labelNode2 } = getListboxMembers(el2);
|
|
expect(el2.fieldName).to.equal(_labelNode2.textContent);
|
|
});
|
|
|
|
it(`has a fieldName based on the name if no label exists`, async () => {
|
|
const el = await fixture(html`
|
|
<${tag} name="foo"></${tag}>
|
|
`);
|
|
expect(el.fieldName).to.equal(el.name);
|
|
});
|
|
|
|
it(`can override fieldName`, async () => {
|
|
const el = await fixture(html`
|
|
<${tag} label="foo" .fieldName="${'bar'}"></${tag}>
|
|
`);
|
|
// @ts-ignore [allow-protected] in test
|
|
expect(el.__fieldName).to.equal(el.fieldName);
|
|
});
|
|
|
|
it('supports validation', async () => {
|
|
const el = await fixture(html`
|
|
<${tag}
|
|
id="color"
|
|
name="color"
|
|
label="Favorite color"
|
|
.validators="${[new Required()]}"
|
|
>
|
|
<${optionTag} .choiceValue=${null}>select a color</${optionTag}>
|
|
<${optionTag} .choiceValue=${'red'}>Red</${optionTag}>
|
|
<${optionTag} .choiceValue=${'hotpink'} disabled>Hotpink</${optionTag}>
|
|
<${optionTag} .choiceValue=${'teal'}>Teal</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
|
|
expect(el.hasFeedbackFor.includes('error')).to.be.true;
|
|
expect(el.showsFeedbackFor.includes('error')).to.be.false;
|
|
|
|
// test submitted prop explicitly, since we dont extend field, we add the prop manually
|
|
el.submitted = true;
|
|
await el.updateComplete;
|
|
expect(el.showsFeedbackFor.includes('error')).to.be.true;
|
|
|
|
el.formElements[1].checked = true;
|
|
await el.updateComplete;
|
|
expect(el.hasFeedbackFor.includes('error')).to.be.false;
|
|
expect(el.showsFeedbackFor.includes('error')).to.be.false;
|
|
|
|
el.formElements[0].checked = true;
|
|
await el.updateComplete;
|
|
expect(el.hasFeedbackFor.includes('error')).to.be.true;
|
|
expect(el.showsFeedbackFor.includes('error')).to.be.true;
|
|
});
|
|
});
|
|
|
|
describe('Selection', () => {
|
|
it('supports changing the selection through serializedValue setter', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} id="color" name="color" label="Favorite color" has-no-default-selected>
|
|
<${optionTag} .choiceValue=${'red'}>Red</${optionTag}>
|
|
<${optionTag} .choiceValue=${'hotpink'}>Hotpink</${optionTag}>
|
|
<${optionTag} .choiceValue=${'teal'}>Teal</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
|
|
expect(el.checkedIndex).to.equal(-1);
|
|
expect(el.serializedValue).to.equal('');
|
|
|
|
el.serializedValue = 'hotpink';
|
|
|
|
expect(el.checkedIndex).to.equal(1);
|
|
expect(el.serializedValue).to.equal('hotpink');
|
|
});
|
|
|
|
it('scrolls active element into view when necessary, takes into account sticky/fixed elements', async () => {
|
|
const el = await fixture(html`
|
|
<div id="scrolling-element" style="position: relative; overflow-y: scroll; height: 570px;">
|
|
<div style="position: sticky; top: 0px; width: 100%; height: 100px; background-color: purple; z-index: 1;">Header 1</div>
|
|
<div style="position: relative">
|
|
<div style="position: sticky; top: 100px; width: 100%; height: 50px; background-color: beige; z-index: 1;">Header 2</div>
|
|
<${tag} id="color" name="color" has-no-default-selected>
|
|
<${optionTag} style="height: 50px; scroll-margin-top: 150px;" .choiceValue=${'red'}>Red</${optionTag}>
|
|
<${optionTag} style="height: 50px; scroll-margin-top: 150px;" .choiceValue=${'hotpink'}>Hotpink</${optionTag}>
|
|
<${optionTag} style="height: 50px; scroll-margin-top: 150px;" .choiceValue=${'teal'}>Teal</${optionTag}>
|
|
<${optionTag} style="height: 50px; scroll-margin-top: 150px;" .choiceValue=${'1'}>1</${optionTag}>
|
|
<${optionTag} style="height: 50px; scroll-margin-top: 150px;" .choiceValue=${'2'}>2</${optionTag}>
|
|
<${optionTag} style="height: 50px; scroll-margin-top: 150px;" .choiceValue=${'3'}>3</${optionTag}>
|
|
<${optionTag} style="height: 50px; scroll-margin-top: 150px;" .choiceValue=${'4'}>4</${optionTag}>
|
|
<${optionTag} style="height: 50px; scroll-margin-top: 150px;" .choiceValue=${'5'}>5</${optionTag}>
|
|
<${optionTag} style="height: 50px; scroll-margin-top: 150px;" .choiceValue=${'5'}>6</${optionTag}>
|
|
<${optionTag} style="height: 50px; scroll-margin-top: 150px;" .choiceValue=${'6'}>7</${optionTag}>
|
|
</${tag}>
|
|
</div>
|
|
</div>
|
|
`);
|
|
const listboxEl = /** @type {LionListbox} */ (el.querySelector('#color'));
|
|
|
|
// Skip test if listbox cannot receive focus, e.g. in combobox
|
|
// Skip test if the listbox is controlled by overlay system,
|
|
// since these overlays "overlay" any fixed/sticky items, meaning
|
|
// the active item will not be hidden by them.
|
|
// @ts-ignore allow protected members in tests
|
|
if (listboxEl._listboxReceivesNoFocus || listboxEl._overlayCtrl) {
|
|
return;
|
|
}
|
|
|
|
Object.defineProperty(listboxEl, '_scrollTargetNode', {
|
|
get: () => el,
|
|
});
|
|
|
|
const thirdOption = /** @type {LionOption} */ (listboxEl.formElements[2]);
|
|
const lastOption = /** @type {LionOption} */ (
|
|
listboxEl.formElements[listboxEl.formElements.length - 1]
|
|
);
|
|
await listboxEl.updateComplete;
|
|
await nextFrame();
|
|
|
|
// Scroll to last option and wait for browser scroll animation (works)
|
|
lastOption.active = true;
|
|
await aTimeout(1000);
|
|
|
|
thirdOption.active = true;
|
|
await aTimeout(1000);
|
|
|
|
// top should be offset 2x40px (sticky header elems) instead of 0px
|
|
if (browserDetection.isChrome || browserDetection.isChromium) {
|
|
// TODO: find out why this is different in recent Chromium
|
|
expect(el.scrollTop).to.equal(160);
|
|
} else {
|
|
expect(el.scrollTop).to.equal(116);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('Accessibility', () => {
|
|
it('[axe]: is accessible when opened', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} label="age" opened>
|
|
<${optionTag} .choiceValue=${10}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
await el.updateComplete;
|
|
await el.updateComplete; // need 2 awaits as overlay.show is an async function
|
|
// for more info about why we need the ignoreRules, see: https://lion-web.netlify.app/fundamentals/systems/overlays/rationale/#considerations
|
|
await expect(el).to.be.accessible({ ignoredRules: ['aria-allowed-role'] });
|
|
});
|
|
|
|
// NB: regular listbox is always 'opened', but needed for combobox and select-rich
|
|
it('[axe]: is accessible when closed', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} label="age">
|
|
<${optionTag} .choiceValue=${10}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
// for more info about why we need the ignoreRules, see: https://lion-web.netlify.app/fundamentals/systems/overlays/rationale/#considerations
|
|
await expect(el).to.be.accessible({ ignoredRules: ['aria-allowed-role'] });
|
|
});
|
|
|
|
it('does not have a tabindex', async () => {
|
|
const el = await fixture(html`<${tag}></${tag}>`);
|
|
expect(el.hasAttribute('tabindex')).to.be.false;
|
|
});
|
|
|
|
it('creates unique ids for all children', async () => {
|
|
const el = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag} .choiceValue=${10}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20} selected>Item 2</${optionTag}>
|
|
<${optionTag} .choiceValue=${30} id="predefined">Item 3</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
expect(el.querySelectorAll(cfg.optionTagString)[0].id).to.exist;
|
|
expect(el.querySelectorAll(cfg.optionTagString)[1].id).to.exist;
|
|
expect(el.querySelectorAll(cfg.optionTagString)[2].id).to.equal('predefined');
|
|
});
|
|
|
|
it('has a reference to the active option', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} opened has-no-default-selected autocomplete="none" show-all-on-empty>
|
|
<${optionTag} .choiceValue=${'10'} id="first">Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${'20'} id="second">Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const { _activeDescendantOwnerNode } = getListboxMembers(el);
|
|
|
|
expect(_activeDescendantOwnerNode.getAttribute('aria-activedescendant')).to.be.null;
|
|
await el.updateComplete;
|
|
|
|
// Normalize
|
|
el.activeIndex = 0;
|
|
await el.updateComplete;
|
|
expect(_activeDescendantOwnerNode.getAttribute('aria-activedescendant')).to.equal('first');
|
|
mimicKeyPress(_activeDescendantOwnerNode, 'ArrowDown');
|
|
await el.updateComplete;
|
|
expect(_activeDescendantOwnerNode.getAttribute('aria-activedescendant')).to.equal('second');
|
|
});
|
|
|
|
it('puts "aria-setsize" on all options to indicate the total amount of options', async () => {
|
|
const el = /** @type {LionListbox} */ (
|
|
await fixture(html`
|
|
<${tag} autocomplete="none" show-all-on-empty>
|
|
<${optionTag} .choiceValue=${10}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
<${optionTag} .choiceValue=${30}>Item 3</${optionTag}>
|
|
</${tag}>
|
|
`)
|
|
);
|
|
el.formElements.forEach(optionEl => {
|
|
expect(optionEl.getAttribute('aria-setsize')).to.equal('3');
|
|
});
|
|
});
|
|
|
|
it('puts "aria-posinset" on all options to indicate their position in the listbox', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} autocomplete="none" show-all-on-empty>
|
|
<${optionTag} .choiceValue=${10}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
<${optionTag} .choiceValue=${30}>Item 3</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
el.formElements.forEach((oEl, i) => {
|
|
expect(oEl.getAttribute('aria-posinset')).to.equal(`${i + 1}`);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Values', () => {
|
|
// TODO: ChoiceGroup suite?
|
|
it('registers options', async () => {
|
|
const el = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag} .choiceValue=${10}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
expect(el.formElements.length).to.equal(2);
|
|
expect(el.formElements).to.eql([
|
|
el.querySelectorAll('lion-option')[0],
|
|
el.querySelectorAll('lion-option')[1],
|
|
]);
|
|
});
|
|
|
|
it('allows null choiceValue', async () => {
|
|
const el = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag} checked .choiceValue=${null}>Please select value</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
|
|
// @ts-ignore feature detect LionCombobox
|
|
if (el._comboboxNode) {
|
|
// note that the modelValue can only be supplied as string if we have a textbox
|
|
// (parsers not supported atm)
|
|
expect(el.modelValue).to.equal('');
|
|
return;
|
|
}
|
|
expect(el.modelValue).to.be.null;
|
|
});
|
|
|
|
it('should reset selected value to initial value', async () => {
|
|
const el = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag} .choiceValue=${'10'}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${'20'} checked>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
expect(el.modelValue).to.equal('20');
|
|
el.setCheckedIndex(0);
|
|
expect(el.modelValue).to.equal('10');
|
|
el.reset();
|
|
expect(el.modelValue).to.equal('20');
|
|
});
|
|
|
|
it('should reset selected value to "Please select account" with has-no-default-selected attribute', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} has-no-default-selected>
|
|
<${optionTag} .choiceValue=${'10'}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${'20'}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
el.setCheckedIndex(1);
|
|
expect(el.modelValue).to.equal('20');
|
|
el.reset();
|
|
expect(el.modelValue).to.equal('');
|
|
});
|
|
|
|
it('should reset selected value to initial values when multiple-choice', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} multiple-choice has-no-default-selected>
|
|
<${optionTag} .choiceValue=${'10'}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${'20'} checked>Item 2</${optionTag}>
|
|
<${optionTag} .choiceValue=${'30'} checked>Item 3</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
el.setCheckedIndex(0);
|
|
expect(el.modelValue).to.deep.equal(['10', '20', '30']);
|
|
el.reset();
|
|
expect(el.modelValue).to.deep.equal(['20', '30']);
|
|
});
|
|
|
|
it('has an activeIndex', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} has-no-default-selected autocomplete="list">
|
|
<${optionTag} .choiceValue=${10}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const options = el.formElements;
|
|
|
|
expect(el.activeIndex).to.equal(-1);
|
|
options[1].active = true;
|
|
expect(options[0].active).to.be.false;
|
|
expect(el.activeIndex).to.equal(1);
|
|
});
|
|
|
|
it('should reset activeIndex value', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} has-no-default-selected>
|
|
<${optionTag} .choiceValue=${'10'}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${'20'}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const options = el.formElements;
|
|
|
|
expect(el.activeIndex).to.equal(-1);
|
|
options[1].active = true;
|
|
expect(el.activeIndex).to.equal(1);
|
|
el.reset();
|
|
expect(el.activeIndex).to.equal(-1);
|
|
});
|
|
});
|
|
|
|
describe('Interactions', () => {
|
|
describe('Keyboard navigation', () => {
|
|
describe('Rotate Keyboard Navigation', () => {
|
|
it('stops navigation by default at end of option list', async () => {
|
|
const el = /** @type {LionListbox} */ (
|
|
await fixture(html`
|
|
<${tag} opened name="foo" .rotateKeyboardNavigation="${false}">
|
|
<${optionTag} .choiceValue="${'Artichoke'}">Artichoke</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Bla'}">Bla</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Chard'}">Chard</${optionTag}>
|
|
</${tag}>
|
|
`)
|
|
);
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
// Normalize
|
|
el.activeIndex = 0;
|
|
const options = el.formElements;
|
|
|
|
mimicKeyPress(_listboxNode, 'ArrowUp');
|
|
|
|
expect(options[0].active).to.be.true;
|
|
expect(options[1].active).to.be.false;
|
|
expect(options[2].active).to.be.false;
|
|
el.activeIndex = 2;
|
|
mimicKeyPress(_listboxNode, 'ArrowDown');
|
|
|
|
expect(options[0].active).to.be.false;
|
|
expect(options[1].active).to.be.false;
|
|
expect(options[2].active).to.be.true;
|
|
});
|
|
|
|
it('when "rotate-navigation" provided, selects first option after navigated to next from last and vice versa', async () => {
|
|
const el = /** @type {LionListbox} */ (
|
|
await fixture(html`
|
|
<${tag} opened name="foo" rotate-keyboard-navigation autocomplete="inline">
|
|
<${optionTag} checked .choiceValue="${'Artichoke'}">Artichoke</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Bla'}">Bla</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Chard'}">Chard</${optionTag}>
|
|
</${tag}>
|
|
`)
|
|
);
|
|
const { _inputNode } = getListboxMembers(el);
|
|
|
|
_inputNode.dispatchEvent(new Event('focusin', { bubbles: true, composed: true }));
|
|
await el.updateComplete;
|
|
// Normalize
|
|
el.activeIndex = 0;
|
|
expect(el.activeIndex).to.equal(0);
|
|
|
|
// el._inputNode.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowUp' }));
|
|
mimicKeyPress(_inputNode, 'ArrowUp');
|
|
|
|
await el.updateComplete;
|
|
expect(el.activeIndex).to.equal(2);
|
|
|
|
// el._inputNode.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown' }));
|
|
mimicKeyPress(_inputNode, 'ArrowDown');
|
|
|
|
expect(el.activeIndex).to.equal(0);
|
|
// Extra check: regular navigation
|
|
// el._inputNode.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown' }));
|
|
mimicKeyPress(_inputNode, 'ArrowDown');
|
|
|
|
expect(el.activeIndex).to.equal(1);
|
|
});
|
|
});
|
|
|
|
describe('Enter', () => {
|
|
it('[Enter] selects active option', async () => {
|
|
const el = /** @type {LionListbox} */ (
|
|
await fixture(html`
|
|
<${tag} opened name="foo" autocomplete="none" show-all-on-empty>
|
|
<${optionTag} .choiceValue="${'Artichoke'}">Artichoke</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Bla'}">Bla</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Chard'}">Chard</${optionTag}>
|
|
</${tag}>
|
|
`)
|
|
);
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
// Normalize suite
|
|
el.activeIndex = 0;
|
|
const options = el.formElements;
|
|
el.checkedIndex = 0;
|
|
mimicKeyPress(_listboxNode, 'ArrowDown');
|
|
mimicKeyPress(_listboxNode, 'Enter');
|
|
expect(options[1].checked).to.be.true;
|
|
});
|
|
|
|
it('submits form on [Enter] when inputNode is an instance of HTMLInputNode', async () => {
|
|
const submitSpy = sinon.spy(e => e.preventDefault());
|
|
const el = /** @type {HTMLFormElement} */ (
|
|
await _fixture(html`
|
|
<form @submit=${submitSpy}>
|
|
<${tag} name="foo">
|
|
<${optionTag} .choiceValue="${'Artichoke'}">Artichoke</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Bla'}">Bla</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Chard'}">Chard</${optionTag}>
|
|
</${tag}>
|
|
<button type="submit">submit</button>
|
|
</form>
|
|
`)
|
|
);
|
|
const listbox = /** @type {LionListbox} */ (el.querySelector('[name="foo"]'));
|
|
const { _inputNode } = getListboxMembers(listbox);
|
|
if (!(_inputNode instanceof HTMLInputElement)) {
|
|
return;
|
|
}
|
|
await listbox.updateComplete;
|
|
// @ts-ignore allow protected members in tests
|
|
|
|
_inputNode.focus();
|
|
await sendKeys({
|
|
press: 'Enter',
|
|
});
|
|
expect(submitSpy.callCount).to.equal(1);
|
|
});
|
|
});
|
|
|
|
describe('Space', () => {
|
|
it('selects active option when "_listboxReceivesNoFocus" is true', async () => {
|
|
// When listbox is not focusable (in case of a combobox), the user should be allowed
|
|
// to enter a space in the focusable element (textbox)
|
|
const el = /** @type {LionListbox} */ (
|
|
await fixture(html`
|
|
<${tag} opened name="foo" ._listboxReceivesNoFocus="${false}" autocomplete="none" show-all-on-empty>
|
|
<${optionTag} .choiceValue="${'Artichoke'}">Artichoke</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Bla'}">Bla</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Chard'}">Chard</${optionTag}>
|
|
</${tag}>
|
|
`)
|
|
);
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
// Normalize suite
|
|
el.activeIndex = 0;
|
|
const options = el.formElements;
|
|
el.checkedIndex = 0;
|
|
mimicKeyPress(_listboxNode, 'ArrowDown');
|
|
mimicKeyPress(_listboxNode, ' ');
|
|
|
|
expect(options[1].checked).to.be.true;
|
|
el.checkedIndex = 0;
|
|
// @ts-ignore allow protected member access in test
|
|
el._listboxReceivesNoFocus = true;
|
|
mimicKeyPress(_listboxNode, 'ArrowDown');
|
|
mimicKeyPress(_listboxNode, ' ');
|
|
|
|
expect(options[1].checked).to.be.false;
|
|
});
|
|
});
|
|
// TODO: add key combinations like shift+home/ctrl+A etc etc.
|
|
|
|
describe('Typeahead', () => {
|
|
it('activates a value with single [character] key', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} opened id="color" name="color" label="Favorite color">
|
|
<${optionTag} .choiceValue=${'red'}>Red</${optionTag}>
|
|
<${optionTag} .choiceValue=${'teal'}>Teal</${optionTag}>
|
|
<${optionTag} .choiceValue=${'turquoise'}>Turquoise</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
// @ts-expect-error [allow-protected-in-tests]
|
|
if (el._noTypeAhead) {
|
|
return;
|
|
}
|
|
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
// Normalize start values between listbox, select and combobox and test interaction below
|
|
el.activeIndex = 0;
|
|
|
|
mimicKeyPress(_listboxNode, 't', 'KeyT');
|
|
// await aTimeout(0);
|
|
expect(el.activeIndex).to.equal(1);
|
|
});
|
|
|
|
it('activates a value with multiple [character] keys', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} opened id="color" name="color" label="Favorite color">
|
|
<${optionTag} .choiceValue=${'red'}>Red</${optionTag}>
|
|
<${optionTag} .choiceValue=${'teal'}>Teal</${optionTag}>
|
|
<${optionTag} .choiceValue=${'turquoise'}>Turquoise</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
// @ts-expect-error [allow-protected-in-tests]
|
|
if (el._noTypeAhead) {
|
|
return;
|
|
}
|
|
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
// Normalize start values between listbox, select and combobox and test interaction below
|
|
el.activeIndex = 0;
|
|
|
|
mimicKeyPress(_listboxNode, 't', 'KeyT');
|
|
expect(el.activeIndex).to.equal(1);
|
|
|
|
mimicKeyPress(_listboxNode, 'u', 'KeyU');
|
|
expect(el.activeIndex).to.equal(2);
|
|
});
|
|
|
|
it('selects a value with [character] keys and selectionFollowsFocus', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} opened id="color" name="color" label="Favorite color" selection-follows-focus>
|
|
<${optionTag} .choiceValue=${'red'}>Red</${optionTag}>
|
|
<${optionTag} .choiceValue=${'teal'}>Teal</${optionTag}>
|
|
<${optionTag} .choiceValue=${'turquoise'}>Turquoise</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
// @ts-expect-error [allow-protected-in-tests]
|
|
if (el._noTypeAhead) {
|
|
return;
|
|
}
|
|
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
// Normalize start values between listbox, select and combobox and test interaction below
|
|
el.checkedIndex = 0;
|
|
|
|
mimicKeyPress(_listboxNode, 't', 'KeyT');
|
|
expect(el.checkedIndex).to.equal(1);
|
|
|
|
mimicKeyPress(_listboxNode, 'u', 'KeyU');
|
|
expect(el.checkedIndex).to.equal(2);
|
|
});
|
|
|
|
it('clears typedChars after _typeAheadTimeout', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} opened id="color" name="color" label="Favorite color">
|
|
<${optionTag} .choiceValue=${'red'}>Red</${optionTag}>
|
|
<${optionTag} .choiceValue=${'teal'}>Teal</${optionTag}>
|
|
<${optionTag} .choiceValue=${'turquoise'}>turquoise</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
// @ts-expect-error [allow-protected-in-tests]
|
|
if (el._noTypeAhead) {
|
|
return;
|
|
}
|
|
|
|
const clock = sinon.useFakeTimers();
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
mimicKeyPress(_listboxNode, 't', 'KeyT');
|
|
// @ts-ignore [allow-private] in test
|
|
expect(el.__typedChars).to.deep.equal(['t']);
|
|
|
|
mimicKeyPress(_listboxNode, 'u', 'KeyU');
|
|
// @ts-ignore [allow-private] in test
|
|
expect(el.__typedChars).to.deep.equal(['t', 'u']);
|
|
|
|
clock.tick(1000);
|
|
// @ts-ignore [allow-private] in test
|
|
expect(el.__typedChars).to.deep.equal([]);
|
|
|
|
clock.restore();
|
|
});
|
|
|
|
it('clears scheduled timeouts', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} opened id="color" name="color" label="Favorite color">
|
|
<${optionTag} .choiceValue=${'red'}>Red</${optionTag}>
|
|
<${optionTag} .choiceValue=${'teal'}>Teal</${optionTag}>
|
|
<${optionTag} .choiceValue=${'turquoise'}>Turquoise</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
// @ts-expect-error [allow-protected-in-tests]
|
|
if (el._noTypeAhead) {
|
|
return;
|
|
}
|
|
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
// Normalize start values between listbox, select and combobox and test interaction below
|
|
el.activeIndex = 0;
|
|
mimicKeyPress(_listboxNode, 't', 'KeyT');
|
|
// @ts-expect-error [allow-private-in-tests]
|
|
const pendingClear = el.__pendingTypeAheadTimeout;
|
|
const clearTimeoutSpy = sinon.spy(window, 'clearTimeout');
|
|
mimicKeyPress(_listboxNode, 'u', 'KeyU');
|
|
expect(clearTimeoutSpy.args[0][0]).to.equal(pendingClear);
|
|
});
|
|
});
|
|
|
|
it('navigates to first and last option with [Home] and [End] keys', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} opened>
|
|
<${optionTag} .choiceValue=${'10'}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${'20'}>Item 2</${optionTag}>
|
|
<${optionTag} .choiceValue=${'30'} checked>Item 3</${optionTag}>
|
|
<${optionTag} .choiceValue=${'40'}>Item 4</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
// @ts-ignore allow protected members in tests
|
|
if (el._listboxReceivesNoFocus) {
|
|
return;
|
|
}
|
|
|
|
el.activeIndex = 2;
|
|
mimicKeyPress(_listboxNode, 'Home');
|
|
expect(el.activeIndex).to.equal(0);
|
|
mimicKeyPress(_listboxNode, 'End');
|
|
expect(el.activeIndex).to.equal(3);
|
|
});
|
|
|
|
it('navigates through open lists with [ArrowDown] [ArrowUp] keys activates the option', async () => {
|
|
const el = /** @type {LionListbox} */ (
|
|
await fixture(html`
|
|
<${tag} opened has-no-default-selected autocomplete="none" show-all-on-empty>
|
|
<${optionTag} .choiceValue=${'Item 1'}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${'Item 2'}>Item 2</${optionTag}>
|
|
<${optionTag} .choiceValue=${'Item 3'}>Item 3</${optionTag}>
|
|
</${tag}>
|
|
`)
|
|
);
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
// Normalize across listbox/select-rich/combobox
|
|
el.activeIndex = 0;
|
|
// selectionFollowsFocus will be true by default on combobox (running this suite),
|
|
// but should still be able to work with selectionFollowsFocus=false
|
|
el.selectionFollowsFocus = false;
|
|
expect(el.activeIndex).to.equal(0);
|
|
expect(el.checkedIndex).to.equal(-1);
|
|
mimicKeyPress(_listboxNode, 'ArrowDown');
|
|
expect(el.activeIndex).to.equal(1);
|
|
expect(el.checkedIndex).to.equal(-1);
|
|
mimicKeyPress(_listboxNode, 'ArrowUp');
|
|
|
|
expect(el.activeIndex).to.equal(0);
|
|
expect(el.checkedIndex).to.equal(-1);
|
|
});
|
|
});
|
|
|
|
describe('Orientation', () => {
|
|
it('has a default value of "vertical"', async () => {
|
|
const el = /** @type {LionListbox} */ (
|
|
await fixture(html`
|
|
<${tag} opened name="foo" autocomplete="none" show-all-on-empty>
|
|
<${optionTag} .choiceValue="${'Artichoke'}">Artichoke</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Chard'}">Chard</${optionTag}>
|
|
</${tag}>
|
|
`)
|
|
);
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
expect(el.orientation).to.equal('vertical');
|
|
const options = el.formElements;
|
|
// Normalize for suite tests
|
|
el.activeIndex = 0;
|
|
|
|
await el.updateComplete;
|
|
expect(options[0].active).to.be.true;
|
|
expect(options[1].active).to.be.false;
|
|
|
|
mimicKeyPress(_listboxNode, 'ArrowDown');
|
|
expect(options[0].active).to.be.false;
|
|
expect(options[1].active).to.be.true;
|
|
|
|
mimicKeyPress(_listboxNode, 'ArrowUp');
|
|
|
|
expect(options[0].active).to.be.true;
|
|
expect(options[1].active).to.be.false;
|
|
|
|
// No response to horizontal arrows...
|
|
mimicKeyPress(_listboxNode, 'ArrowRight');
|
|
|
|
expect(options[0].active).to.be.true;
|
|
expect(options[1].active).to.be.false;
|
|
|
|
el.activeIndex = 1;
|
|
mimicKeyPress(_listboxNode, 'ArrowLeft');
|
|
|
|
expect(options[0].active).to.be.false;
|
|
expect(options[1].active).to.be.true;
|
|
});
|
|
|
|
it('uses [ArrowLeft] and [ArrowRight] keys when "horizontal"', async () => {
|
|
const el = /** @type {LionListbox} */ (
|
|
await fixture(html`
|
|
<${tag} ._listboxReceivesNoFocus="${false}" opened name="foo" orientation="horizontal" autocomplete="none" show-all-on-empty>
|
|
<${optionTag} .choiceValue="${'Artichoke'}">Artichoke</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Chard'}">Chard</${optionTag}>
|
|
</${tag}>
|
|
`)
|
|
);
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
expect(el.orientation).to.equal('horizontal');
|
|
|
|
// Normalize for suite tests
|
|
el.activeIndex = 0;
|
|
await el.updateComplete;
|
|
|
|
mimicKeyPress(_listboxNode, 'ArrowRight');
|
|
expect(el.activeIndex).to.equal(1);
|
|
|
|
mimicKeyPress(_listboxNode, 'ArrowLeft');
|
|
expect(el.activeIndex).to.equal(0);
|
|
|
|
// No response to vertical arrows...
|
|
mimicKeyPress(_listboxNode, 'ArrowDown');
|
|
expect(el.activeIndex).to.equal(0);
|
|
|
|
el.activeIndex = 1;
|
|
mimicKeyPress(_listboxNode, 'ArrowUp');
|
|
expect(el.activeIndex).to.equal(1);
|
|
|
|
// @ts-ignore allow protected member access in test
|
|
el._listboxReceivesNoFocus = true;
|
|
mimicKeyPress(_listboxNode, 'ArrowLeft');
|
|
expect(el.activeIndex).to.equal(1);
|
|
|
|
mimicKeyPress(_listboxNode, 'ArrowRight');
|
|
expect(el.activeIndex).to.equal(1);
|
|
});
|
|
|
|
describe('Accessibility', () => {
|
|
it('adds aria-orientation attribute to listbox node', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} name="foo" orientation="horizontal">
|
|
<${optionTag} checked .choiceValue="${'Artichoke'}">Artichoke</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Chard'}">Chard</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
expect(_listboxNode.getAttribute('aria-orientation')).to.equal('horizontal');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Multiple Choice', () => {
|
|
it('does not uncheck siblings', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} name="foo" multiple-choice>
|
|
<${optionTag} .choiceValue="${'Artichoke'}">Artichoke</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Chard'}">Chard</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Chicory'}">Chicory</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Victoria Plum'}">Victoria Plum</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const options = el.formElements;
|
|
options[0].checked = true;
|
|
options[1].checked = true;
|
|
expect(options[0].checked).to.equal(true);
|
|
expect(el.modelValue).to.eql(['Artichoke', 'Chard']);
|
|
});
|
|
|
|
it('works via different interaction mechanisms (click, enter, spaces)', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} name="foo" multiple-choice>
|
|
<${optionTag} .choiceValue="${'Artichoke'}">Artichoke</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Chard'}">Chard</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Chicory'}">Chicory</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Victoria Plum'}">Victoria Plum</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
const options = el.formElements;
|
|
|
|
// @ts-ignore feature detection select-rich
|
|
if (el.navigateWithinInvoker !== undefined) {
|
|
// Note we don't have multipleChoice in the select-rich yet.
|
|
// TODO: implement in future when requested
|
|
return;
|
|
}
|
|
|
|
// click
|
|
options[0].click();
|
|
options[1].click();
|
|
expect(options[0].checked).to.equal(true);
|
|
expect(el.modelValue).to.eql(['Artichoke', 'Chard']);
|
|
// also deselect
|
|
options[1].click();
|
|
expect(options[0].checked).to.equal(true);
|
|
expect(el.modelValue).to.eql(['Artichoke']);
|
|
|
|
// Reset
|
|
// @ts-ignore allow protected members in tests
|
|
el._uncheckChildren();
|
|
|
|
// Enter
|
|
el.activeIndex = 0;
|
|
mimicKeyPress(_listboxNode, 'Enter');
|
|
el.activeIndex = 1;
|
|
mimicKeyPress(_listboxNode, 'Enter');
|
|
expect(options[0].checked).to.equal(true);
|
|
expect(el.modelValue).to.eql(['Artichoke', 'Chard']);
|
|
// also deselect
|
|
mimicKeyPress(_listboxNode, 'Enter');
|
|
expect(options[0].checked).to.equal(true);
|
|
expect(el.modelValue).to.eql(['Artichoke']);
|
|
|
|
// @ts-ignore allow protected
|
|
if (el._listboxReceivesNoFocus) {
|
|
return; // if suite is run for combobox, we don't respond to [Space]
|
|
}
|
|
|
|
// Reset
|
|
// @ts-ignore allow protected members in tests
|
|
el._uncheckChildren();
|
|
|
|
// Space
|
|
el.activeIndex = 0;
|
|
mimicKeyPress(_listboxNode, ' ');
|
|
|
|
el.activeIndex = 1;
|
|
mimicKeyPress(_listboxNode, ' ');
|
|
|
|
expect(options[0].checked).to.equal(true);
|
|
expect(el.modelValue).to.eql(['Artichoke', 'Chard']);
|
|
// also deselect
|
|
mimicKeyPress(_listboxNode, ' ');
|
|
|
|
expect(options[0].checked).to.equal(true);
|
|
expect(el.modelValue).to.eql(['Artichoke']);
|
|
});
|
|
|
|
describe('Accessibility', () => {
|
|
it('adds aria-multiselectable="true" to listbox node', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} name="foo" multiple-choice>
|
|
<${optionTag} .choiceValue="${'Artichoke'}">Artichoke</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Chard'}">Chard</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
expect(_listboxNode.getAttribute('aria-multiselectable')).to.equal('true');
|
|
});
|
|
|
|
it('does not allow "selectionFollowsFocus"', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} name="foo" multiple-choice>
|
|
<${optionTag} checked .choiceValue="${'Artichoke'}">Artichoke</${optionTag}>
|
|
<${optionTag} .choiceValue="${'Chard'}">Chard</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const { _listboxNode, _inputNode } = getListboxMembers(el);
|
|
|
|
_inputNode.focus();
|
|
_listboxNode.dispatchEvent(new KeyboardEvent('keyup', { key: 'ArrowDown' }));
|
|
expect(_listboxNode.getAttribute('aria-multiselectable')).to.equal('true');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Selection Follows Focus', () => {
|
|
it('navigates through list with [ArrowDown] [ArrowUp] keys: activates and checks the option', async () => {
|
|
/**
|
|
* @param {LionOption[]} options
|
|
* @param {number} selectedIndex
|
|
*/
|
|
function expectOnlyGivenOneOptionToBeChecked(options, selectedIndex) {
|
|
options.forEach((option, i) => {
|
|
if (i === selectedIndex) {
|
|
expect(option.checked).to.be.true;
|
|
} else {
|
|
expect(option.checked).to.be.false;
|
|
}
|
|
});
|
|
}
|
|
const el = /** @type {LionListbox} */ (
|
|
await fixture(html`
|
|
<${tag} opened selection-follows-focus autocomplete="none" show-all-on-empty>
|
|
<${optionTag} .choiceValue=${10}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
<${optionTag} .choiceValue=${30}>Item 3</${optionTag}>
|
|
</${tag}>
|
|
`)
|
|
);
|
|
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
const options = el.formElements;
|
|
// Normalize start values between listbox, select and combobox and test interaction below
|
|
el.activeIndex = 0;
|
|
el.checkedIndex = 0;
|
|
expect(el.activeIndex).to.equal(0);
|
|
expect(el.checkedIndex).to.equal(0);
|
|
expectOnlyGivenOneOptionToBeChecked(options, 0);
|
|
mimicKeyPress(_listboxNode, 'ArrowDown');
|
|
expect(el.activeIndex).to.equal(1);
|
|
expect(el.checkedIndex).to.equal(1);
|
|
expectOnlyGivenOneOptionToBeChecked(options, 1);
|
|
mimicKeyPress(_listboxNode, 'ArrowUp');
|
|
|
|
expect(el.activeIndex).to.equal(0);
|
|
expect(el.checkedIndex).to.equal(0);
|
|
expectOnlyGivenOneOptionToBeChecked(options, 0);
|
|
});
|
|
|
|
it('navigates through list with [ArrowLeft] [ArrowRight] keys when horizontal: activates and checks the option', async () => {
|
|
/**
|
|
* @param {LionOption[]} options
|
|
* @param {number} selectedIndex
|
|
*/
|
|
function expectOnlyGivenOneOptionToBeChecked(options, selectedIndex) {
|
|
options.forEach((option, i) => {
|
|
if (i === selectedIndex) {
|
|
expect(option.checked).to.be.true;
|
|
} else {
|
|
expect(option.checked).to.be.false;
|
|
}
|
|
});
|
|
}
|
|
const el = /** @type {LionListbox} */ (
|
|
await fixture(html`
|
|
<${tag} ._listboxReceivesNoFocus="${false}" opened selection-follows-focus orientation="horizontal" autocomplete="none" show-all-on-empty>
|
|
<${optionTag} .choiceValue=${10}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
<${optionTag} .choiceValue=${30}>Item 3</${optionTag}>
|
|
</${tag}>
|
|
`)
|
|
);
|
|
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
const options = el.formElements;
|
|
// Normalize start values between listbox, slect and combobox and test interaction below
|
|
el.activeIndex = 0;
|
|
el.checkedIndex = 0;
|
|
expect(el.activeIndex).to.equal(0);
|
|
expect(el.checkedIndex).to.equal(0);
|
|
expectOnlyGivenOneOptionToBeChecked(options, 0);
|
|
mimicKeyPress(_listboxNode, 'ArrowRight');
|
|
|
|
expect(el.activeIndex).to.equal(1);
|
|
expect(el.checkedIndex).to.equal(1);
|
|
expectOnlyGivenOneOptionToBeChecked(options, 1);
|
|
mimicKeyPress(_listboxNode, 'ArrowLeft');
|
|
|
|
expect(el.activeIndex).to.equal(0);
|
|
expect(el.checkedIndex).to.equal(0);
|
|
expectOnlyGivenOneOptionToBeChecked(options, 0);
|
|
});
|
|
it('checks first and last option with [Home] and [End] keys', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} opened selection-follows-focus>
|
|
<${optionTag} .choiceValue=${'10'}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${'20'}>Item 2</${optionTag}>
|
|
<${optionTag} .choiceValue=${'30'} checked>Item 3</${optionTag}>
|
|
<${optionTag} .choiceValue=${'40'}>Item 4</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
// @ts-ignore allow protected
|
|
if (el._listboxReceivesNoFocus) {
|
|
return;
|
|
}
|
|
|
|
expect(el.modelValue).to.equal('30');
|
|
mimicKeyPress(_listboxNode, 'Home');
|
|
expect(el.modelValue).to.equal('10');
|
|
mimicKeyPress(_listboxNode, 'End');
|
|
expect(el.modelValue).to.equal('40');
|
|
});
|
|
});
|
|
|
|
describe('Disabled Host', () => {
|
|
it('cannot be navigated with keyboard if disabled', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} disabled>
|
|
<${optionTag} .choiceValue=${'10'}>Item 1</${optionTag}>
|
|
<${optionTag} checked .choiceValue=${'20'}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
await el.updateComplete;
|
|
const { checkedIndex } = el;
|
|
mimicKeyPress(_listboxNode, 'ArrowDown');
|
|
expect(el.checkedIndex).to.equal(checkedIndex);
|
|
});
|
|
|
|
it('sync its disabled state to all options', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} opened>
|
|
<${optionTag} .choiceValue=${10} disabled>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const options = el.formElements;
|
|
el.disabled = true;
|
|
await el.updateComplete;
|
|
expect(options[0].disabled).to.be.true;
|
|
expect(options[1].disabled).to.be.true;
|
|
|
|
el.disabled = false;
|
|
await el.updateComplete;
|
|
expect(options[0].disabled).to.be.true;
|
|
expect(options[1].disabled).to.be.false;
|
|
});
|
|
|
|
it('can be enabled (incl. its options) even if it starts as disabled', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} disabled>
|
|
<${optionTag} .choiceValue=${10} disabled>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const options = el.formElements;
|
|
expect(options[0].disabled).to.be.true;
|
|
expect(options[1].disabled).to.be.true;
|
|
|
|
el.disabled = false;
|
|
await el.updateComplete;
|
|
expect(options[0].disabled).to.be.true;
|
|
expect(options[1].disabled).to.be.false;
|
|
});
|
|
});
|
|
|
|
describe('Disabled Options', () => {
|
|
it('does not skip disabled options but prevents checking them', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} opened autocomplete="inline" .selectionFollowsFocus="${false}">
|
|
<${optionTag} .choiceValue=${'Item 1'} checked>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${'Item 2'} disabled>Item 2</${optionTag}>
|
|
<${optionTag} .choiceValue=${'Item 3'}>Item 3</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
// Normalize activeIndex across multiple implementers of ListboxMixinSuite
|
|
el.activeIndex = 0;
|
|
|
|
mimicKeyPress(_listboxNode, 'ArrowDown');
|
|
expect(el.activeIndex).to.equal(1);
|
|
|
|
expect(el.checkedIndex).to.equal(0);
|
|
mimicKeyPress(_listboxNode, 'Enter');
|
|
// Checked index stays where it was
|
|
expect(el.checkedIndex).to.equal(0);
|
|
});
|
|
it('does not check disabled options when selection-follow-focus is enabled', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} opened autocomplete="inline" .selectionFollowsFocus="${true}">
|
|
<${optionTag} .choiceValue=${'Item 1'} checked>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${'Item 2'} disabled>Item 2</${optionTag}>
|
|
<${optionTag} .choiceValue=${'Item 3'}>Item 3</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
// Normalize activeIndex across multiple implementers of ListboxMixinSuite
|
|
el.activeIndex = 0;
|
|
|
|
mimicKeyPress(_listboxNode, 'ArrowDown');
|
|
expect(el.activeIndex).to.equal(1);
|
|
expect(el.checkedIndex).to.equal(-1);
|
|
|
|
mimicKeyPress(_listboxNode, 'ArrowDown');
|
|
expect(el.activeIndex).to.equal(2);
|
|
expect(el.checkedIndex).to.equal(2);
|
|
});
|
|
});
|
|
|
|
describe('Programmatic interaction', () => {
|
|
it('can set active state', async () => {
|
|
const el = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag} .choiceValue=${10}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20} id="myId">Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const { _activeDescendantOwnerNode } = getListboxMembers(el);
|
|
|
|
const opt = el.formElements[1];
|
|
opt.active = true;
|
|
expect(_activeDescendantOwnerNode.getAttribute('aria-activedescendant')).to.equal('myId');
|
|
});
|
|
|
|
it('can set checked state', async () => {
|
|
const el = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag} .choiceValue=${10}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const option = el.formElements[1];
|
|
option.checked = true;
|
|
expect(el.modelValue).to.equal(20);
|
|
});
|
|
|
|
it('does not allow to set checkedIndex or activeIndex to be out of bound', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} has-no-default-selected autocomplete="list">
|
|
<${optionTag} .choiceValue=${10}>Item 1</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
expect(() => {
|
|
el.activeIndex = -1;
|
|
el.activeIndex = 1;
|
|
el.checkedIndex = -1;
|
|
el.checkedIndex = 1;
|
|
}).to.not.throw();
|
|
expect(el.checkedIndex).to.equal(-1);
|
|
expect(el.activeIndex).to.equal(-1);
|
|
});
|
|
|
|
it('unsets checked on other options when option becomes checked', async () => {
|
|
const el = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag} .choiceValue=${10}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const options = el.formElements;
|
|
options[0].checked = true;
|
|
expect(options[0].checked).to.be.true;
|
|
expect(options[1].checked).to.be.false;
|
|
options[1].checked = true;
|
|
expect(options[0].checked).to.be.false;
|
|
expect(options[1].checked).to.be.true;
|
|
});
|
|
|
|
it('unsets active on other options when option becomes active', async () => {
|
|
const el = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag} active .choiceValue=${10}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const options = el.formElements;
|
|
expect(options[0].active).to.be.true;
|
|
options[1].active = true;
|
|
expect(options[0].active).to.be.false;
|
|
});
|
|
});
|
|
|
|
// TODO: ChoiceGroup suite?
|
|
describe('Interaction states', () => {
|
|
it('becomes dirty if value changed once', async () => {
|
|
const el = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag} .choiceValue=${10}>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
|
|
expect(el.dirty).to.be.false;
|
|
el.modelValue = 20;
|
|
expect(el.dirty).to.be.true;
|
|
});
|
|
|
|
it('is prefilled if there is a value on init', async () => {
|
|
const el = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag} checked .choiceValue=${'10'}>Item 1</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
expect(el.prefilled).to.be.true;
|
|
|
|
const elEmpty = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag} .choiceValue=${null}>Please select a value</${optionTag}>
|
|
<${optionTag} .choiceValue=${'10'}>Item 1</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
expect(elEmpty.prefilled).to.be.false;
|
|
});
|
|
});
|
|
|
|
// TODO: ChoiceGroup suite?
|
|
describe('Validation', () => {
|
|
it('can be required', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} .validators=${[new Required()]}>
|
|
<${optionTag} .choiceValue=${null}>Please select a value</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
|
|
expect(el.hasFeedbackFor).to.include('error');
|
|
expect(el.validationStates).to.have.a.property('error');
|
|
expect(el.validationStates.error).to.have.a.property('Required');
|
|
|
|
el.modelValue = 20;
|
|
expect(el.hasFeedbackFor).not.to.include('error');
|
|
expect(el.validationStates).to.have.a.property('error');
|
|
expect(el.validationStates.error).not.to.have.a.property('Required');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Complex Data', () => {
|
|
it('works for complex array data', async () => {
|
|
const objs = [
|
|
{ type: 'mastercard', label: 'Master Card', amount: 12000, active: true },
|
|
{ type: 'visacard', label: 'Visa Card', amount: 0, active: false },
|
|
];
|
|
const el = await fixture(html`
|
|
<${tag} label="Favorite color" name="color">
|
|
${objs.map(
|
|
obj => html`
|
|
<${optionTag} .modelValue=${{ value: obj, checked: false }}
|
|
>${obj.label}</${optionTag}
|
|
>
|
|
`,
|
|
)}
|
|
</${tag}>
|
|
`);
|
|
el.setCheckedIndex(0);
|
|
expect(el.modelValue).to.deep.equal({
|
|
type: 'mastercard',
|
|
label: 'Master Card',
|
|
amount: 12000,
|
|
active: true,
|
|
});
|
|
|
|
el.setCheckedIndex(1);
|
|
expect(el.modelValue).to.deep.equal({
|
|
type: 'visacard',
|
|
label: 'Visa Card',
|
|
amount: 0,
|
|
active: false,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Instantiation methods', () => {
|
|
it('can be instantiated via "document.createElement"', async () => {
|
|
let properlyInstantiated = false;
|
|
|
|
try {
|
|
const el = document.createElement(cfg.tagString);
|
|
const optionsEl = document.createElement('lion-options');
|
|
optionsEl.slot = 'input';
|
|
const optionEl = document.createElement(cfg.optionTagString);
|
|
optionsEl.appendChild(optionEl);
|
|
el.appendChild(optionsEl);
|
|
properlyInstantiated = true;
|
|
} catch (e) {
|
|
throw Error(/** @type {Error} */ (e).message);
|
|
}
|
|
|
|
expect(properlyInstantiated).to.be.true;
|
|
});
|
|
|
|
it('can be instantiated without options', async () => {
|
|
const el = await fixture(html`
|
|
<${tag} name="foo">
|
|
<${optionTag} .choiceValue=${10} checked>Item 1</${optionTag}>
|
|
<${optionTag} .choiceValue=${20}>Item 2</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
expect(_listboxNode).to.exist;
|
|
expect(_listboxNode).to.be.instanceOf(LionOptions);
|
|
expect(el.querySelector('[role=listbox]')).to.equal(_listboxNode);
|
|
|
|
expect(el.formElements.length).to.equal(2);
|
|
expect(_listboxNode.children.length).to.equal(2);
|
|
expect(_listboxNode.children[0].tagName).to.equal(cfg.optionTagString.toUpperCase());
|
|
});
|
|
});
|
|
|
|
describe('Href Options', () => {
|
|
it('allows anchors to be clicked when a [href] attribute is present', async () => {
|
|
const el = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag}>Google</${optionTag}>
|
|
<${optionTag} .href=${'https://duckduckgo.com'}>DuckDuck Go</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
el.activeIndex = 1;
|
|
|
|
// Allow options that behave like anchors (think of Google Search) to trigger the anchor behavior
|
|
const activeOption = el.formElements[1];
|
|
const clickSpy = sinon.spy(activeOption, 'click');
|
|
mimicKeyPress(_listboxNode, 'Enter');
|
|
|
|
expect(clickSpy).to.have.been.calledOnce;
|
|
});
|
|
|
|
it('does not allow anchors to be clicked when a [href] attribute is not present', async () => {
|
|
const el = await fixture(html`
|
|
<${tag}>
|
|
<${optionTag}>Google</${optionTag}>
|
|
<${optionTag} .href=${'https://duckduckgo.com'}>DuckDuck Go</${optionTag}>
|
|
</${tag}>
|
|
`);
|
|
|
|
const { _listboxNode } = getListboxMembers(el);
|
|
|
|
el.activeIndex = 0;
|
|
|
|
const activeOption = el.formElements[0];
|
|
const clickSpy = sinon.spy(activeOption, 'click');
|
|
|
|
mimicKeyPress(_listboxNode, 'Enter');
|
|
|
|
expect(clickSpy).to.not.have.been.called;
|
|
});
|
|
});
|
|
|
|
describe('Dynamically adding options', () => {
|
|
class MyEl extends LitElement {
|
|
constructor() {
|
|
super();
|
|
/** @type {string[]} */
|
|
this.options = ['option 1', 'option 2'];
|
|
}
|
|
|
|
clearOptions() {
|
|
/** @type {string[]} */
|
|
this.options = [];
|
|
this.requestUpdate();
|
|
}
|
|
|
|
addOption() {
|
|
this.options.push(`option ${this.options.length + 1}`);
|
|
this.requestUpdate();
|
|
}
|
|
|
|
get withMap() {
|
|
return /** @type {LionListbox} */ (this.shadowRoot?.querySelector('#withMap'));
|
|
}
|
|
|
|
get withRepeat() {
|
|
return /** @type {LionListbox} */ (this.shadowRoot?.querySelector('#withRepeat'));
|
|
}
|
|
|
|
get registrationComplete() {
|
|
return Promise.all([
|
|
this.withMap.registrationComplete,
|
|
this.withRepeat.registrationComplete,
|
|
]);
|
|
}
|
|
|
|
render() {
|
|
return html`
|
|
<${tag} id="withMap">
|
|
${this.options.map(
|
|
option => html` <lion-option .choiceValue="${option}">${option}</lion-option> `,
|
|
)}
|
|
</${tag}>
|
|
<${tag} id="withRepeat">
|
|
${repeat(
|
|
this.options,
|
|
(/** @type {string} */ option) => option,
|
|
(/** @type {string} */ option) =>
|
|
html` <lion-option .choiceValue="${option}">${option}</lion-option> `,
|
|
)}
|
|
</${tag}>
|
|
`;
|
|
}
|
|
}
|
|
const tagName = defineCE(MyEl);
|
|
const wrappingTag = unsafeStatic(tagName);
|
|
|
|
it('works with array map and repeat directive', async () => {
|
|
const choiceVals = (/** @type {LionListbox} */ elm) =>
|
|
elm.formElements.map(fel => fel.choiceValue);
|
|
const insideListboxNode = (/** @type {LionListbox} */ elm) =>
|
|
// @ts-ignore [allow-protected] in test
|
|
elm.formElements.filter(fel => elm._listboxNode.contains(fel)).length ===
|
|
elm.formElements.length;
|
|
|
|
const el = /** @type {MyEl} */ (await _fixture(html`<${wrappingTag}></${wrappingTag}>`));
|
|
|
|
expect(choiceVals(el.withMap)).to.eql(el.options);
|
|
expect(el.withMap.formElements.length).to.equal(2);
|
|
expect(insideListboxNode(el.withMap)).to.be.true;
|
|
expect(choiceVals(el.withRepeat)).to.eql(el.options);
|
|
expect(el.withRepeat.formElements.length).to.equal(2);
|
|
expect(insideListboxNode(el.withRepeat)).to.be.true;
|
|
|
|
el.addOption();
|
|
await el.updateComplete;
|
|
expect(choiceVals(el.withMap)).to.eql(el.options);
|
|
expect(el.withMap.formElements.length).to.equal(3);
|
|
expect(insideListboxNode(el.withMap)).to.be.true;
|
|
expect(choiceVals(el.withRepeat)).to.eql(el.options);
|
|
expect(el.withRepeat.formElements.length).to.equal(3);
|
|
expect(insideListboxNode(el.withRepeat)).to.be.true;
|
|
|
|
el.clearOptions();
|
|
await el.updateComplete;
|
|
expect(choiceVals(el.withMap)).to.eql(el.options);
|
|
expect(el.withMap.formElements.length).to.equal(0);
|
|
expect(insideListboxNode(el.withMap)).to.be.true;
|
|
expect(choiceVals(el.withRepeat)).to.eql(el.options);
|
|
expect(el.withRepeat.formElements.length).to.equal(0);
|
|
expect(insideListboxNode(el.withRepeat)).to.be.true;
|
|
});
|
|
});
|
|
|
|
describe('Subclassers', () => {
|
|
class MyEl extends LitElement {
|
|
constructor() {
|
|
super();
|
|
/** @type {string[]} */
|
|
this.options = ['option 1', 'option 2'];
|
|
}
|
|
|
|
clearOptions() {
|
|
/** @type {string[]} */
|
|
this.options = [];
|
|
this.requestUpdate();
|
|
}
|
|
|
|
addOption() {
|
|
this.options.push(`option ${this.options.length + 1}`);
|
|
this.requestUpdate();
|
|
}
|
|
|
|
get listbox() {
|
|
return /** @type {LionListbox} */ (this.shadowRoot?.querySelector('#listbox'));
|
|
}
|
|
|
|
render() {
|
|
return html`
|
|
<${tag} id="listbox">
|
|
${this.options.map(
|
|
option => html` <lion-option .choiceValue="${option}">${option}</lion-option> `,
|
|
)}
|
|
</${tag}>
|
|
`;
|
|
}
|
|
}
|
|
const tagName = defineCE(MyEl);
|
|
const wrappingTag = unsafeStatic(tagName);
|
|
|
|
it('calls "_onListboxContentChanged" after externally changing options', async () => {
|
|
const el = /** @type {MyEl} */ (await _fixture(html`<${wrappingTag}></${wrappingTag}>`));
|
|
await el.listbox.registrationComplete;
|
|
// @ts-ignore [allow-protected] in test
|
|
const spy = sinon.spy(el.listbox, '_onListboxContentChanged');
|
|
el.addOption();
|
|
await el.updateComplete;
|
|
expect(spy).to.have.been.calledOnce;
|
|
el.clearOptions();
|
|
await el.updateComplete;
|
|
expect(spy).to.have.been.calledTwice;
|
|
});
|
|
});
|
|
});
|
|
}
|