ayo/lion
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix: types base constructor same return type

Browse source
This commit is contained in:
Joren Broekema 2021-01-13 17:05:07 +01:00
parent 9f0691609f
commit 8fb7e7a193
61 changed files with 114 additions and 102 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
.changeset/four-roses-fetch.md Normal file
View file

@ -0,0 +1,21 @@
---
'@lion/calendar': patch
'@lion/checkbox-group': patch
'@lion/core': patch
'@lion/fieldset': patch
'@lion/form-core': patch
'@lion/input-date': patch
'@lion/input-datepicker': patch
'@lion/input-email': patch
'@lion/input-iban': patch
'@lion/listbox': patch
'@lion/localize': patch
'@lion/overlays': patch
'@lion/pagination': patch
'@lion/progress-indicator': patch
'@lion/radio-group': patch
'@lion/select-rich': patch
'@lion/switch': patch
---
Fix type issues where base constructors would not have the same return type. This allows us to remove a LOT of @ts-expect-errors/@ts-ignores across lion.

1
.eslintignore
View file

@ -2,3 +2,4 @@ node_modules
coverage/ coverage/
bundlesize/ bundlesize/
.history/ .history/
*.d.ts

1
packages/calendar/src/LionCalendar.js
View file

@ -25,7 +25,6 @@ import { isSameDate } from './utils/isSameDate.js';
/** /**
* @customElement lion-calendar * @customElement lion-calendar
*/ */
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/40110
export class LionCalendar extends LocalizeMixin(LitElement) { export class LionCalendar extends LocalizeMixin(LitElement) {
static get localizeNamespaces() { static get localizeNamespaces() {
return [ return [

1
packages/checkbox-group/src/LionCheckboxGroup.js
View file

@ -4,7 +4,6 @@ import { ChoiceGroupMixin, FormGroupMixin } from '@lion/form-core';
/** /**
* A wrapper around multiple checkboxes * A wrapper around multiple checkboxes
*/ */
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/40110
export class LionCheckboxGroup extends ChoiceGroupMixin(FormGroupMixin(LitElement)) { export class LionCheckboxGroup extends ChoiceGroupMixin(FormGroupMixin(LitElement)) {
constructor() { constructor() {
super(); super();

1
packages/core/types/DelegateMixinTypes.d.ts vendored
View file

@ -10,6 +10,7 @@ export type Delegations = {
}; };
export declare class DelegateHost { export declare class DelegateHost {
constructor(...args: any[]);
delegations: Delegations; delegations: Delegations;
protected _connectDelegateMixin(): void; protected _connectDelegateMixin(): void;

3
packages/core/types/DisabledMixinTypes.d.ts vendored
View file

@ -2,6 +2,7 @@ import { Constructor } from '@open-wc/dedupe-mixin';
import { LitElement } from '../index.js'; import { LitElement } from '../index.js';
export declare class DisabledHost { export declare class DisabledHost {
constructor(...args: any[]);
disabled: boolean; disabled: boolean;
/** /**
@ -20,6 +21,6 @@ export declare class DisabledHost {
export declare function DisabledMixinImplementation<T extends Constructor<LitElement>>( export declare function DisabledMixinImplementation<T extends Constructor<LitElement>>(
superclass: T, superclass: T,
): T & Constructor<DisabledHost>; ): T & Constructor<DisabledHost> & typeof DisabledHost;
export type DisabledMixin = typeof DisabledMixinImplementation; export type DisabledMixin = typeof DisabledMixinImplementation;

1
packages/core/types/DisabledWithTabIndexMixinTypes.d.ts vendored
View file

@ -2,6 +2,7 @@ import { Constructor } from '@open-wc/dedupe-mixin';
import { DisabledHost } from './DisabledMixinTypes'; import { DisabledHost } from './DisabledMixinTypes';
import { LitElement } from '../index.js'; import { LitElement } from '../index.js';
export declare class DisabledWithTabIndexHost { export declare class DisabledWithTabIndexHost {
constructor(...args: any[]);
tabIndex: number; tabIndex: number;
/** /**
* Makes request to make the element disabled and set the tabindex * Makes request to make the element disabled and set the tabindex

3
packages/core/types/SlotMixinTypes.d.ts vendored
View file

@ -7,6 +7,7 @@ export type SlotsMap = {
}; };
export declare class SlotHost { export declare class SlotHost {
constructor(...args: any[]);
/** /**
* Obtains all the slots to create * Obtains all the slots to create
*/ */
@ -50,6 +51,6 @@ export declare class SlotHost {
*/ */
export declare function SlotMixinImplementation<T extends Constructor<HTMLElement>>( export declare function SlotMixinImplementation<T extends Constructor<HTMLElement>>(
superclass: T, superclass: T,
): T & Constructor<SlotHost>; ): T & Constructor<SlotHost> & typeof SlotHost;
export type SlotMixin = typeof SlotMixinImplementation; export type SlotMixin = typeof SlotMixinImplementation;

1
packages/core/types/UpdateStylesMixinTypes.d.ts vendored
View file

@ -21,6 +21,7 @@ export declare class UpdateStylesHost {
* *
* @param {StylesMap} updateStyles * @param {StylesMap} updateStyles
*/ */
constructor(...args: any[]);
public updateStyles(updateStyles: StylesMap): void; public updateStyles(updateStyles: StylesMap): void;
} }

6
packages/fieldset/src/LionFieldset.js
View file

@ -19,13 +19,15 @@ import { FormGroupMixin } from '@lion/form-core';
* *
* @customElement lion-fieldset * @customElement lion-fieldset
*/ */
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/40110
export class LionFieldset extends FormGroupMixin(LitElement) { export class LionFieldset extends FormGroupMixin(LitElement) {
constructor() { constructor() {
super(); super();
/** @override FormRegistrarMixin */ /** @override FormRegistrarMixin */
this._isFormOrFieldset = true; this._isFormOrFieldset = true;
/** @override FormControlMixin */ /**
* @type {'child' | 'choice-group' | 'fieldset'}
* @override FormControlMixin
*/
this._repropagationRole = 'fieldset'; this._repropagationRole = 'fieldset';
} }
} }

9
packages/form-core/src/FormControlMixin.js
View file

@ -9,7 +9,6 @@ import { Unparseable } from './validate/Unparseable.js';
* @typedef {import('@lion/core').CSSResult} CSSResult * @typedef {import('@lion/core').CSSResult} CSSResult
* @typedef {import('@lion/core').nothing} nothing * @typedef {import('@lion/core').nothing} nothing
* @typedef {import('@lion/core/types/SlotMixinTypes').SlotsMap} SlotsMap * @typedef {import('@lion/core/types/SlotMixinTypes').SlotsMap} SlotsMap
* @typedef {import('../types/FormControlMixinTypes.js').FormControlHost} FormControlHost
* @typedef {import('../types/FormControlMixinTypes.js').FormControlMixin} FormControlMixin * @typedef {import('../types/FormControlMixinTypes.js').FormControlMixin} FormControlMixin
* @typedef {import('../types/FormControlMixinTypes.js').ModelValueEventDetails} ModelValueEventDetails * @typedef {import('../types/FormControlMixinTypes.js').ModelValueEventDetails} ModelValueEventDetails
*/ */
@ -522,15 +521,13 @@ const FormControlMixinImplementation = superclass =>
/** /**
* @param {?} modelValue * @param {?} modelValue
* @return {boolean} * @return {boolean}
*
* FIXME: Move to FormatMixin? Since there we have access to modelValue prop
*/ */
// @ts-expect-error // @ts-ignore FIXME: Move to FormatMixin? Since there we have access to modelValue prop
_isEmpty(modelValue = this.modelValue) { _isEmpty(modelValue = this.modelValue) {
let value = modelValue; let value = modelValue;
// @ts-expect-error // @ts-ignore
if (this.modelValue instanceof Unparseable) { if (this.modelValue instanceof Unparseable) {
// @ts-expect-error // @ts-ignore
value = this.modelValue.viewValue; value = this.modelValue.viewValue;
} }

5
packages/form-core/src/FormatMixin.js
View file

@ -304,15 +304,16 @@ const FormatMixinImplementation = superclass =>
*/ */
_onModelValueChanged(...args) { _onModelValueChanged(...args) {
this._calculateValues({ source: 'model' }); this._calculateValues({ source: 'model' });
// @ts-expect-error only passing this so a subclasser can use it, but we do not use it ourselves
this._dispatchModelValueChangedEvent(...args); this._dispatchModelValueChangedEvent(...args);
} }
/** /**
* @param {{ modelValue: unknown; }[]} args
* This is wrapped in a distinct method, so that parents can control when the changed event * This is wrapped in a distinct method, so that parents can control when the changed event
* is fired. For objects, a deep comparison might be needed. * is fired. For objects, a deep comparison might be needed.
*/ */
_dispatchModelValueChangedEvent() { // eslint-disable-next-line no-unused-vars
_dispatchModelValueChangedEvent(...args) {
/** @event model-value-changed */ /** @event model-value-changed */
this.dispatchEvent( this.dispatchEvent(
new CustomEvent('model-value-changed', { new CustomEvent('model-value-changed', {

2
packages/form-core/src/LionField.js
View file

@ -22,7 +22,7 @@ import { InteractionStateMixin } from './InteractionStateMixin.js'; // applies F
* *
* @customElement lion-field * @customElement lion-field
*/ */
// @ts-expect-error base constructors same return type // @ts-expect-error lit properties false positive
export class LionField extends FormControlMixin( export class LionField extends FormControlMixin(
InteractionStateMixin(FocusMixin(FormatMixin(ValidateMixin(SlotMixin(LitElement))))), InteractionStateMixin(FocusMixin(FormatMixin(ValidateMixin(SlotMixin(LitElement))))),
) { ) {

13
packages/form-core/src/choice-group/ChoiceInputMixin.js
View file

@ -244,12 +244,15 @@ const ChoiceInputMixinImplementation = superclass =>
* hasChanged is designed for async (updated) callback, also check for sync * hasChanged is designed for async (updated) callback, also check for sync
* (requestUpdateInternal) callback * (requestUpdateInternal) callback
* @param {{ modelValue:unknown }} newV * @param {{ modelValue:unknown }} newV
* @param {{ modelValue:unknown }} [oldV] * @param {{ modelValue:unknown }} [old]
*/ */
// @ts-expect-error _onModelValueChanged({ modelValue }, old) {
_onModelValueChanged({ modelValue }, { modelValue: old }) { let _old;
// @ts-expect-error if (old && old.modelValue) {
if (this.constructor._classProperties.get('modelValue').hasChanged(modelValue, old)) { _old = old.modelValue;
}
// @ts-expect-error lit private property
if (this.constructor._classProperties.get('modelValue').hasChanged(modelValue, _old)) {
super._onModelValueChanged({ modelValue }); super._onModelValueChanged({ modelValue });
} }
} }

2
packages/form-core/src/registration/FormRegistrarMixin.js
View file

@ -93,7 +93,7 @@ const FormRegistrarMixinImplementation = superclass =>
console.info('Error Node:', child); // eslint-disable-line no-console console.info('Error Node:', child); // eslint-disable-line no-console
throw new TypeError('You need to define a name'); throw new TypeError('You need to define a name');
} }
// @ts-expect-error // @ts-expect-error this._isFormOrFieldset true means we can assume `this.name` exists
if (name === this.name) { if (name === this.name) {
console.info('Error Node:', child); // eslint-disable-line no-console console.info('Error Node:', child); // eslint-disable-line no-console
throw new TypeError(`You can not have the same name "${name}" as your parent`); throw new TypeError(`You can not have the same name "${name}" as your parent`);

2
packages/form-core/src/utils/SyncUpdatableMixin.js
View file

@ -53,7 +53,7 @@ const SyncUpdatableMixinImplementation = superclass =>
* @param {*} oldValue * @param {*} oldValue
*/ */
static __syncUpdatableHasChanged(name, newValue, oldValue) { static __syncUpdatableHasChanged(name, newValue, oldValue) {
// @ts-expect-error FIXME: Typescript bug, superclass static method not availabe from static context // @ts-expect-error accessing private lit property
const properties = this._classProperties; const properties = this._classProperties;
if (properties.get(name) && properties.get(name).hasChanged) { if (properties.get(name) && properties.get(name).hasChanged) {
return properties.get(name).hasChanged(newValue, oldValue); return properties.get(name).hasChanged(newValue, oldValue);

10
packages/form-core/test-suites/FormRegistrationMixins.suite.js
View file

@ -10,7 +10,7 @@ import { FormRegistrarPortalMixin } from '../src/registration/FormRegistrarPorta
/** /**
* @typedef {Object} customConfig * @typedef {Object} customConfig
* @property {typeof HTMLElement | typeof import('@lion/core').UpdatingElement | typeof LitElement} [baseElement] * @property {typeof LitElement} [baseElement]
* @property {string} [customConfig.suffix] * @property {string} [customConfig.suffix]
* @property {string} [customConfig.parentTagString] * @property {string} [customConfig.parentTagString]
* @property {string} [customConfig.childTagString] * @property {string} [customConfig.childTagString]
@ -22,19 +22,16 @@ import { FormRegistrarPortalMixin } from '../src/registration/FormRegistrarPorta
*/ */
export const runRegistrationSuite = customConfig => { export const runRegistrationSuite = customConfig => {
const cfg = { const cfg = {
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/38535 // @ts-expect-error https://github.com/microsoft/TypeScript/issues/38535 fixed in later typescript version
baseElement: HTMLElement, baseElement: LitElement,
...customConfig, ...customConfig,
}; };
describe(`FormRegistrationMixins ${cfg.suffix}`, () => { describe(`FormRegistrationMixins ${cfg.suffix}`, () => {
// @ts-expect-error base constructors same return type & type cannot be assigned like this
class RegistrarClass extends FormRegistrarMixin(cfg.baseElement) {} class RegistrarClass extends FormRegistrarMixin(cfg.baseElement) {}
cfg.parentTagString = defineCE(RegistrarClass); cfg.parentTagString = defineCE(RegistrarClass);
// @ts-expect-error base constructors same return type & type cannot be assigned like this
class RegisteringClass extends FormRegisteringMixin(cfg.baseElement) {} class RegisteringClass extends FormRegisteringMixin(cfg.baseElement) {}
cfg.childTagString = defineCE(RegisteringClass); cfg.childTagString = defineCE(RegisteringClass);
// @ts-expect-error base constructors same return type & type cannot be assigned like this
class PortalClass extends FormRegistrarPortalMixin(cfg.baseElement) {} class PortalClass extends FormRegistrarPortalMixin(cfg.baseElement) {}
cfg.portalTagString = defineCE(PortalClass); cfg.portalTagString = defineCE(PortalClass);
@ -91,7 +88,6 @@ export const runRegistrationSuite = customConfig => {
}); });
it('works for components that have a delayed render', async () => { it('works for components that have a delayed render', async () => {
// @ts-expect-error base constructors same return type
class PerformUpdate extends FormRegistrarMixin(LitElement) { class PerformUpdate extends FormRegistrarMixin(LitElement) {
async performUpdate() { async performUpdate() {
await new Promise(resolve => setTimeout(() => resolve(), 10)); await new Promise(resolve => setTimeout(() => resolve(), 10));

2
packages/form-core/test-suites/FormatMixin.suite.js
View file

@ -9,7 +9,6 @@ import { Unparseable, Validator } from '../index.js';
* @typedef {ArrayConstructor | ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor | DateConstructor | 'iban' | 'email'} modelValueType * @typedef {ArrayConstructor | ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor | DateConstructor | 'iban' | 'email'} modelValueType
*/ */
// @ts-expect-error base constructor same return type
class FormatClass extends FormatMixin(LitElement) { class FormatClass extends FormatMixin(LitElement) {
get _inputNode() { get _inputNode() {
return /** @type {HTMLInputElement} */ (super._inputNode); // casts type return /** @type {HTMLInputElement} */ (super._inputNode); // casts type
@ -279,7 +278,6 @@ export function runFormatMixinSuite(customConfig) {
}); });
it('works if there is no underlying _inputNode', async () => { it('works if there is no underlying _inputNode', async () => {
// @ts-expect-error base constructor same return type
const tagNoInputString = defineCE(class extends FormatMixin(LitElement) {}); const tagNoInputString = defineCE(class extends FormatMixin(LitElement) {});
const tagNoInput = unsafeStatic(tagNoInputString); const tagNoInput = unsafeStatic(tagNoInputString);
expect(async () => { expect(async () => {

2
packages/form-core/test-suites/InteractionStateMixin.suite.js
View file

@ -24,7 +24,6 @@ export function runInteractionStateMixinSuite(customConfig) {
}; };
describe(`InteractionStateMixin`, async () => { describe(`InteractionStateMixin`, async () => {
// @ts-expect-error base constructors same return type
class IState extends InteractionStateMixin(ValidateMixin(LitElement)) { class IState extends InteractionStateMixin(ValidateMixin(LitElement)) {
connectedCallback() { connectedCallback() {
super.connectedCallback(); super.connectedCallback();
@ -244,7 +243,6 @@ export function runInteractionStateMixinSuite(customConfig) {
describe('SubClassers', () => { describe('SubClassers', () => {
it('can override the `_leaveEvent`', async () => { it('can override the `_leaveEvent`', async () => {
// @ts-expect-error base constructor same return type
class IStateCustomBlur extends InteractionStateMixin(LitElement) { class IStateCustomBlur extends InteractionStateMixin(LitElement) {
constructor() { constructor() {
super(); super();

12
packages/form-core/test-suites/ValidateMixin.suite.js
View file

@ -28,7 +28,6 @@ export function runValidateMixinSuite(customConfig) {
const lightDom = cfg.lightDom || ''; const lightDom = cfg.lightDom || '';
// @ts-expect-error base constructor same return type
class ValidateElement extends ValidateMixin(LitElement) { class ValidateElement extends ValidateMixin(LitElement) {
connectedCallback() { connectedCallback() {
super.connectedCallback(); super.connectedCallback();
@ -562,7 +561,6 @@ export function runValidateMixinSuite(customConfig) {
}; };
const withSuccessTagString = defineCE( const withSuccessTagString = defineCE(
// @ts-expect-error
class extends ValidateMixin(LitElement) { class extends ValidateMixin(LitElement) {
static get validationTypes() { static get validationTypes() {
return [...super.validationTypes, 'success']; return [...super.validationTypes, 'success'];
@ -677,7 +675,6 @@ export function runValidateMixinSuite(customConfig) {
}); });
it('calls "._isEmpty" when provided (useful for different modelValues)', async () => { it('calls "._isEmpty" when provided (useful for different modelValues)', async () => {
// @ts-expect-error base constructor same return type
class _isEmptyValidate extends ValidateMixin(LitElement) { class _isEmptyValidate extends ValidateMixin(LitElement) {
_isEmpty() { _isEmpty() {
// @ts-expect-error // @ts-expect-error
@ -729,7 +726,6 @@ export function runValidateMixinSuite(customConfig) {
describe('Default (preconfigured) Validators', () => { describe('Default (preconfigured) Validators', () => {
const preconfTagString = defineCE( const preconfTagString = defineCE(
// @ts-expect-error base constructor same return type
class extends ValidateMixin(LitElement) { class extends ValidateMixin(LitElement) {
constructor() { constructor() {
super(); super();
@ -752,7 +748,6 @@ export function runValidateMixinSuite(customConfig) {
it('can be altered by App Developers', async () => { it('can be altered by App Developers', async () => {
const altPreconfTagString = defineCE( const altPreconfTagString = defineCE(
// @ts-expect-error base constructor same return type
class extends ValidateMixin(LitElement) { class extends ValidateMixin(LitElement) {
constructor() { constructor() {
super(); super();
@ -918,7 +913,6 @@ export function runValidateMixinSuite(customConfig) {
describe('Extensibility: Custom Validator types', () => { describe('Extensibility: Custom Validator types', () => {
const customTypeTagString = defineCE( const customTypeTagString = defineCE(
// @ts-expect-error base constructor same return type
class extends ValidateMixin(LitElement) { class extends ValidateMixin(LitElement) {
static get validationTypes() { static get validationTypes() {
return [...super.validationTypes, 'x', 'y']; return [...super.validationTypes, 'x', 'y'];
@ -1026,7 +1020,6 @@ export function runValidateMixinSuite(customConfig) {
describe('Subclassers', () => { describe('Subclassers', () => {
describe('Adding new Validator types', () => { describe('Adding new Validator types', () => {
it('can add helpers for validation types', async () => { it('can add helpers for validation types', async () => {
// @ts-expect-error base constructor same return type
class ValidateHasX extends ValidateMixin(LitElement) { class ValidateHasX extends ValidateMixin(LitElement) {
static get validationTypes() { static get validationTypes() {
return [...super.validationTypes, 'x']; return [...super.validationTypes, 'x'];
@ -1074,7 +1067,6 @@ export function runValidateMixinSuite(customConfig) {
.concat(array2.filter(x => !array1.includes(x))); .concat(array2.filter(x => !array1.includes(x)));
} }
const elTagString = defineCE( const elTagString = defineCE(
// @ts-expect-error base constructor same return type
class extends ValidateMixin(LitElement) { class extends ValidateMixin(LitElement) {
static get validationTypes() { static get validationTypes() {
return [...super.validationTypes, 'x']; return [...super.validationTypes, 'x'];
@ -1123,7 +1115,7 @@ export function runValidateMixinSuite(customConfig) {
// TODO: add this test on FormControl layer // TODO: add this test on FormControl layer
it('reconsiders feedback visibility when interaction states changed', async () => { it('reconsiders feedback visibility when interaction states changed', async () => {
const elTagString = defineCE( const elTagString = defineCE(
// @ts-expect-error base constructor same return type // @ts-expect-error lit properties false positive, they get merged with parent properties by lit automatically
class extends ValidateMixin(LitElement) { class extends ValidateMixin(LitElement) {
static get properties() { static get properties() {
return { return {
@ -1168,7 +1160,7 @@ export function runValidateMixinSuite(customConfig) {
it('filters feedback visibility according interaction states', async () => { it('filters feedback visibility according interaction states', async () => {
const elTagString = defineCE( const elTagString = defineCE(
// @ts-expect-error base constructor same return type // @ts-expect-error lit properties false positive, they get merged with parent properties by lit automatically
class extends ValidateMixin(LitElement) { class extends ValidateMixin(LitElement) {
static get validationTypes() { static get validationTypes() {
return ['error', 'info']; return ['error', 'info'];

4
packages/form-core/test-suites/ValidateMixinFeedbackPart.suite.js
View file

@ -12,7 +12,6 @@ export function runValidateMixinFeedbackPart() {
localizeTearDown(); localizeTearDown();
}); });
// @ts-expect-error base constructor same return type
class ValidateElement extends ValidateMixin(LitElement) { class ValidateElement extends ValidateMixin(LitElement) {
connectedCallback() { connectedCallback() {
super.connectedCallback(); super.connectedCallback();
@ -80,7 +79,6 @@ export function runValidateMixinFeedbackPart() {
}); });
it('reflects .showsFeedbackFor as attribute joined with "," to be used as a style hook', async () => { it('reflects .showsFeedbackFor as attribute joined with "," to be used as a style hook', async () => {
// @ts-expect-error base constructors same return type
class ValidateElementCustomTypes extends ValidateMixin(LitElement) { class ValidateElementCustomTypes extends ValidateMixin(LitElement) {
static get validationTypes() { static get validationTypes() {
return [...super.validationTypes, 'x']; return [...super.validationTypes, 'x'];
@ -307,7 +305,6 @@ export function runValidateMixinFeedbackPart() {
}); });
it('shows success message after fixing an error', async () => { it('shows success message after fixing an error', async () => {
// @ts-expect-error base constructor same return type
class ValidateElementCustomTypes extends ValidateMixin(LitElement) { class ValidateElementCustomTypes extends ValidateMixin(LitElement) {
static get validationTypes() { static get validationTypes() {
return ['error', 'success']; return ['error', 'success'];
@ -362,7 +359,6 @@ export function runValidateMixinFeedbackPart() {
describe('Meta data', () => { describe('Meta data', () => {
it('".getMessage()" gets a reference to formControl, params, modelValue and type', async () => { it('".getMessage()" gets a reference to formControl, params, modelValue and type', async () => {
// @ts-expect-error base constructor same return type
class ValidateElementCustomTypes extends ValidateMixin(LitElement) { class ValidateElementCustomTypes extends ValidateMixin(LitElement) {
static get validationTypes() { static get validationTypes() {
return ['error', 'x']; return ['error', 'x'];

1
packages/form-core/test-suites/choice-group/ChoiceGroupMixin.suite.js
View file

@ -8,7 +8,6 @@ import { ChoiceInputMixin } from '../../src/choice-group/ChoiceInputMixin.js';
class ChoiceInput extends ChoiceInputMixin(LionInput) {} class ChoiceInput extends ChoiceInputMixin(LionInput) {}
customElements.define('choice-group-input', ChoiceInput); customElements.define('choice-group-input', ChoiceInput);
// @ts-expect-error
class ChoiceGroup extends ChoiceGroupMixin(FormGroupMixin(LitElement)) {} class ChoiceGroup extends ChoiceGroupMixin(FormGroupMixin(LitElement)) {}
customElements.define('choice-group', ChoiceGroup); customElements.define('choice-group', ChoiceGroup);

4
packages/form-core/test-suites/form-group/FormGroupMixin-input.suite.js
View file

@ -20,12 +20,14 @@ export function runFormGroupMixinInputSuite(cfg = {}) {
const childTagString = cfg.childTagString || defineCE(FormChild); const childTagString = cfg.childTagString || defineCE(FormChild);
// @ts-expect-error
const FormGroup = class extends FormGroupMixin(LitElement) { const FormGroup = class extends FormGroupMixin(LitElement) {
constructor() { constructor() {
super(); super();
/** @override from FormRegistrarMixin */ /** @override from FormRegistrarMixin */
this._isFormOrFieldset = true; this._isFormOrFieldset = true;
/**
* @type {'fieldset' | 'child' | 'choice-group'}
*/
this._repropagationRole = 'fieldset'; // configures FormControlMixin this._repropagationRole = 'fieldset'; // configures FormControlMixin
} }
}; };

37
packages/form-core/test-suites/form-group/FormGroupMixin.suite.js
View file

@ -29,7 +29,6 @@ export function runFormGroupMixinSuite(cfg = {}) {
const childTagString = cfg.childTagString || defineCE(FormChild); const childTagString = cfg.childTagString || defineCE(FormChild);
// @ts-expect-error base constructors same return type
class FormGroup extends FormGroupMixin(LitElement) { class FormGroup extends FormGroupMixin(LitElement) {
constructor() { constructor() {
super(); super();
@ -131,8 +130,9 @@ export function runFormGroupMixinSuite(cfg = {}) {
try { try {
// we test the api directly as errors thrown from a web component are in a // we test the api directly as errors thrown from a web component are in a
// different context and we can not catch them here => register fake elements // different context and we can not catch them here => register fake elements
// @ts-expect-error el.addFormElement(
el.addFormElement(/** @type {FormControlHost} */ ({})); /** @type {HTMLElement & import('../../types/FormControlMixinTypes').FormControlHost} */ ({}),
);
} catch (err) { } catch (err) {
error = err; error = err;
} }
@ -151,8 +151,11 @@ export function runFormGroupMixinSuite(cfg = {}) {
try { try {
// we test the api directly as errors thrown from a web component are in a // we test the api directly as errors thrown from a web component are in a
// different context and we can not catch them here => register fake elements // different context and we can not catch them here => register fake elements
// @ts-expect-error el.addFormElement(
el.addFormElement(/** @type {FormControlHost} */ ({ name: 'foo' })); /** @type {HTMLElement & import('../../types/FormControlMixinTypes').FormControlHost} */ ({
name: 'foo',
}),
);
} catch (err) { } catch (err) {
error = err; error = err;
} }
@ -171,10 +174,16 @@ export function runFormGroupMixinSuite(cfg = {}) {
try { try {
// we test the api directly as errors thrown from a web component are in a // we test the api directly as errors thrown from a web component are in a
// different context and we can not catch them here => register fake elements // different context and we can not catch them here => register fake elements
// @ts-expect-error el.addFormElement(
el.addFormElement(/** @type {FormControlHost} */ ({ name: 'fooBar' })); /** @type {HTMLElement & import('../../types/FormControlMixinTypes').FormControlHost} */ ({
// @ts-expect-error name: 'fooBar',
el.addFormElement(/** @type {FormControlHost} */ ({ name: 'fooBar' })); }),
);
el.addFormElement(
/** @type {HTMLElement & import('../../types/FormControlMixinTypes').FormControlHost} */ ({
name: 'fooBar',
}),
);
} catch (err) { } catch (err) {
error = err; error = err;
} }
@ -628,7 +637,7 @@ export function runFormGroupMixinSuite(cfg = {}) {
return 'Input1IsTen'; return 'Input1IsTen';
} }
// @ts-expect-error /** @param {?} value */
execute(value) { execute(value) {
const hasError = value.input1 !== 10; const hasError = value.input1 !== 10;
return hasError; return hasError;
@ -643,10 +652,8 @@ export function runFormGroupMixinSuite(cfg = {}) {
<${childTag} name="input2" .validators=${[new IsNumber()]}></${childTag}> <${childTag} name="input2" .validators=${[new IsNumber()]}></${childTag}>
</${tag}> </${tag}>
`)); `));
const inputs = el.querySelectorAll(childTagString); const inputs = /** @type {FormChild[]} */ (Array.from(el.querySelectorAll(childTagString)));
// @ts-expect-error
inputs[1].modelValue = 2; // make it dirty inputs[1].modelValue = 2; // make it dirty
// @ts-expect-error
inputs[1].focus(); inputs[1].focus();
outSideButton.focus(); outSideButton.focus();
@ -662,8 +669,8 @@ export function runFormGroupMixinSuite(cfg = {}) {
const fieldset = /** @type {FormGroup} */ (await fixture( const fieldset = /** @type {FormGroup} */ (await fixture(
html`<${tag}>${inputSlots}</${tag}>`, html`<${tag}>${inputSlots}</${tag}>`,
)); ));
// @ts-expect-error fieldset.formElements['hobbies[]'][0].serializer = /** @param {?} v */ v =>
fieldset.formElements['hobbies[]'][0].serializer = v => `${v.value}-serialized`; `${v.value}-serialized`;
fieldset.formElements['hobbies[]'][0].modelValue = { checked: false, value: 'Bar' }; fieldset.formElements['hobbies[]'][0].modelValue = { checked: false, value: 'Bar' };
fieldset.formElements['hobbies[]'][1].modelValue = { checked: false, value: 'rugby' }; fieldset.formElements['hobbies[]'][1].modelValue = { checked: false, value: 'rugby' };
fieldset.formElements['gender[]'][0].modelValue = { checked: false, value: 'male' }; fieldset.formElements['gender[]'][0].modelValue = { checked: false, value: 'male' };

1
packages/form-core/test/FocusMixin.test.js
View file

@ -3,7 +3,6 @@ import { defineCE, expect, fixture, html, oneEvent, unsafeStatic } from '@open-w
import { FocusMixin } from '../src/FocusMixin.js'; import { FocusMixin } from '../src/FocusMixin.js';
describe('FocusMixin', () => { describe('FocusMixin', () => {
// @ts-expect-error base constructors same return type
class Focusable extends FocusMixin(LitElement) { class Focusable extends FocusMixin(LitElement) {
render() { render() {
return html`<slot name="input"></slot>`; return html`<slot name="input"></slot>`;

2
packages/form-core/test/FormControlMixin.test.js
View file

@ -7,7 +7,6 @@ import { FormRegistrarMixin } from '../src/registration/FormRegistrarMixin.js';
describe('FormControlMixin', () => { describe('FormControlMixin', () => {
const inputSlot = '<input slot="input" />'; const inputSlot = '<input slot="input" />';
// @ts-expect-error base constructor same return type
class FormControlMixinClass extends FormControlMixin(LitElement) {} class FormControlMixinClass extends FormControlMixin(LitElement) {}
const tagString = defineCE(FormControlMixinClass); const tagString = defineCE(FormControlMixinClass);
@ -213,7 +212,6 @@ describe('FormControlMixin', () => {
}); });
describe('Model-value-changed event propagation', () => { describe('Model-value-changed event propagation', () => {
// @ts-expect-error base constructor same return type
const FormControlWithRegistrarMixinClass = class extends FormControlMixin( const FormControlWithRegistrarMixinClass = class extends FormControlMixin(
FormRegistrarMixin(LitElement), FormRegistrarMixin(LitElement),
) {}; ) {};

6
packages/form-core/test/FormRegistrationMixins.test.js
View file

@ -1,10 +1,10 @@
import { LitElement, UpdatingElement } from '@lion/core'; import { LitElement } from '@lion/core';
import { html } from '@open-wc/testing'; import { html } from '@open-wc/testing';
import { runRegistrationSuite } from '../test-suites/FormRegistrationMixins.suite.js'; import { runRegistrationSuite } from '../test-suites/FormRegistrationMixins.suite.js';
runRegistrationSuite({ runRegistrationSuite({
suffix: 'with UpdatingElement', suffix: 'with LitElement',
baseElement: UpdatingElement, baseElement: LitElement,
}); });
runRegistrationSuite({ runRegistrationSuite({

5
packages/form-core/test/utils/SyncUpdatableMixin.test.js
View file

@ -8,7 +8,6 @@ describe('SyncUpdatableMixin', () => {
it('initializes all properties', async () => { it('initializes all properties', async () => {
let hasCalledFirstUpdated = false; let hasCalledFirstUpdated = false;
let hasCalledUpdateSync = false; let hasCalledUpdateSync = false;
// @ts-expect-error base constructors same return type
class UpdatableImplementation extends SyncUpdatableMixin(LitElement) { class UpdatableImplementation extends SyncUpdatableMixin(LitElement) {
static get properties() { static get properties() {
return { return {
@ -65,7 +64,6 @@ describe('SyncUpdatableMixin', () => {
it('guarantees Member Order Independence', async () => { it('guarantees Member Order Independence', async () => {
let hasCalledRunPropertyEffect = false; let hasCalledRunPropertyEffect = false;
// @ts-expect-error base constructors same return type
class UpdatableImplementation extends SyncUpdatableMixin(LitElement) { class UpdatableImplementation extends SyncUpdatableMixin(LitElement) {
static get properties() { static get properties() {
return { return {
@ -136,7 +134,6 @@ describe('SyncUpdatableMixin', () => {
let propChangedCount = 0; let propChangedCount = 0;
let propUpdateSyncCount = 0; let propUpdateSyncCount = 0;
// @ts-expect-error the private override is on purpose
class UpdatableImplementation extends SyncUpdatableMixin(LitElement) { class UpdatableImplementation extends SyncUpdatableMixin(LitElement) {
static get properties() { static get properties() {
return { return {
@ -189,7 +186,6 @@ describe('SyncUpdatableMixin', () => {
describe('After firstUpdated', () => { describe('After firstUpdated', () => {
it('calls "updateSync" immediately when the observed property is changed (newValue !== oldValue)', async () => { it('calls "updateSync" immediately when the observed property is changed (newValue !== oldValue)', async () => {
// @ts-expect-error
class UpdatableImplementation extends SyncUpdatableMixin(LitElement) { class UpdatableImplementation extends SyncUpdatableMixin(LitElement) {
static get properties() { static get properties() {
return { return {
@ -245,7 +241,6 @@ describe('SyncUpdatableMixin', () => {
describe('Features', () => { describe('Features', () => {
// See: https://lit-element.polymer-project.org/guide/lifecycle#haschanged // See: https://lit-element.polymer-project.org/guide/lifecycle#haschanged
it('supports "hasChanged" from UpdatingElement', async () => { it('supports "hasChanged" from UpdatingElement', async () => {
// @ts-expect-error base constructors same return type
class UpdatableImplementation extends SyncUpdatableMixin(LitElement) { class UpdatableImplementation extends SyncUpdatableMixin(LitElement) {
static get properties() { static get properties() {
return { return {

2
packages/form-core/test/validate/Validator.test.js
View file

@ -134,7 +134,7 @@ describe('Validator', () => {
it('has access to FormControl', async () => { it('has access to FormControl', async () => {
const lightDom = ''; const lightDom = '';
// @ts-expect-error base constructors same return type // @ts-expect-error false positive for incompatible static get properties. Lit-element merges super properties already for you.
class ValidateElement extends ValidateMixin(LitElement) { class ValidateElement extends ValidateMixin(LitElement) {
static get properties() { static get properties() {
return { modelValue: String }; return { modelValue: String };

1
packages/form-core/types/FocusMixinTypes.d.ts vendored
View file

@ -3,6 +3,7 @@ import { LitElement } from '@lion/core';
import { FormControlHost } from './FormControlMixinTypes'; import { FormControlHost } from './FormControlMixinTypes';
export declare class FocusHost { export declare class FocusHost {
constructor(...args: any[]);
focused: boolean; focused: boolean;
connectedCallback(): void; connectedCallback(): void;

1
packages/form-core/types/FormControlMixinTypes.d.ts vendored
View file

@ -36,6 +36,7 @@ declare interface HTMLElementWithValue extends HTMLElement {
} }
export declare class FormControlHost { export declare class FormControlHost {
constructor(...args: any[]);
static get styles(): CSSResultArray; static get styles(): CSSResultArray;
static get properties(): { static get properties(): {
name: { name: {

1
packages/form-core/types/FormatMixinTypes.d.ts vendored
View file

@ -5,6 +5,7 @@ import { ValidateHost } from './validate/ValidateMixinTypes';
import { FormControlHost } from './FormControlMixinTypes'; import { FormControlHost } from './FormControlMixinTypes';
export declare class FormatHost { export declare class FormatHost {
constructor(...args: any[]);
formattedValue: string; formattedValue: string;
serializedValue: string; serializedValue: string;
formatOn: string; formatOn: string;

3
packages/form-core/types/InteractionStateMixinTypes.d.ts vendored
View file

@ -3,6 +3,7 @@ import { LitElement } from '@lion/core';
import { FormControlHost } from './FormControlMixinTypes'; import { FormControlHost } from './FormControlMixinTypes';
export declare class InteractionStateHost { export declare class InteractionStateHost {
constructor(...args: any[]);
prefilled: boolean; prefilled: boolean;
filled: boolean; filled: boolean;
touched: boolean; touched: boolean;
@ -26,7 +27,7 @@ export declare function InteractionStateImplementation<T extends Constructor<Lit
superclass: T, superclass: T,
): T & ): T &
Constructor<InteractionStateHost> & Constructor<InteractionStateHost> &
InteractionStateHost & typeof InteractionStateHost &
Constructor<FormControlHost> & Constructor<FormControlHost> &
typeof FormControlHost; typeof FormControlHost;

1
packages/form-core/types/NativeTextFieldMixinTypes.d.ts vendored
View file

@ -6,6 +6,7 @@ export declare class NativeTextField extends LionField {
} }
export declare class NativeTextFieldHost { export declare class NativeTextFieldHost {
constructor(...args: any[]);
get selectionStart(): number; get selectionStart(): number;
set selectionStart(value: number); set selectionStart(value: number);
get selectionEnd(): number; get selectionEnd(): number;

1
packages/form-core/types/choice-group/ChoiceGroupMixinTypes.d.ts vendored
View file

@ -5,6 +5,7 @@ import { FormRegistrarHost } from '../registration/FormRegistrarMixinTypes';
import { InteractionStateHost } from '../InteractionStateMixinTypes'; import { InteractionStateHost } from '../InteractionStateMixinTypes';
export declare class ChoiceGroupHost { export declare class ChoiceGroupHost {
constructor(...args: any[]);
multipleChoice: boolean; multipleChoice: boolean;
connectedCallback(): void; connectedCallback(): void;

1
packages/form-core/types/choice-group/ChoiceInputMixinTypes.d.ts vendored
View file

@ -15,6 +15,7 @@ export interface ChoiceInputSerializedValue {
} }
export declare class ChoiceInputHost { export declare class ChoiceInputHost {
constructor(...args: any[]);
modelValue: ChoiceInputModelValue; modelValue: ChoiceInputModelValue;
serializedValue: ChoiceInputSerializedValue; serializedValue: ChoiceInputSerializedValue;

3
packages/form-core/types/form-group/FormGroupMixinTypes.d.ts vendored
View file

@ -7,6 +7,7 @@ import { FormRegistrarHost } from '../registration/FormRegistrarMixinTypes';
import { ValidateHost } from '../validate/ValidateMixinTypes'; import { ValidateHost } from '../validate/ValidateMixinTypes';
export declare class FormGroupHost { export declare class FormGroupHost {
constructor(...args: any[]);
protected static _addDescriptionElementIdsToField(): void; protected static _addDescriptionElementIdsToField(): void;
_inputNode: HTMLElement; _inputNode: HTMLElement;
submitGroup(): void; submitGroup(): void;
@ -29,7 +30,7 @@ export declare function FormGroupImplementation<T extends Constructor<LitElement
superclass: T, superclass: T,
): T & ): T &
Constructor<FormGroupHost> & Constructor<FormGroupHost> &
FormGroupHost & typeof FormGroupHost &
Constructor<FormRegistrarHost> & Constructor<FormRegistrarHost> &
typeof FormRegistrarHost & typeof FormRegistrarHost &
Constructor<FormControlHost> & Constructor<FormControlHost> &

1
packages/form-core/types/registration/FormRegisteringMixinTypes.d.ts vendored
View file

@ -3,6 +3,7 @@ import { FormRegistrarHost } from './FormRegistrarMixinTypes';
import { LitElement } from '@lion/core'; import { LitElement } from '@lion/core';
export declare class FormRegisteringHost { export declare class FormRegisteringHost {
constructor(...args: any[]);
connectedCallback(): void; connectedCallback(): void;
disconnectedCallback(): void; disconnectedCallback(): void;
__parentFormGroup?: FormRegistrarHost; __parentFormGroup?: FormRegistrarHost;

1
packages/form-core/types/registration/FormRegistrarMixinTypes.d.ts vendored
View file

@ -9,6 +9,7 @@ export declare class ElementWithParentFormGroup {
} }
export declare class FormRegistrarHost { export declare class FormRegistrarHost {
constructor(...args: any[]);
_isFormOrFieldset: boolean; _isFormOrFieldset: boolean;
formElements: FormControlsCollection & { [x: string]: any }; formElements: FormControlsCollection & { [x: string]: any };
addFormElement( addFormElement(

1
packages/form-core/types/registration/FormRegistrarPortalMixinTypes.d.ts vendored
View file

@ -2,6 +2,7 @@ import { Constructor } from '@open-wc/dedupe-mixin';
import { LitElement } from '@lion/core'; import { LitElement } from '@lion/core';
export declare class FormRegistrarPortalHost { export declare class FormRegistrarPortalHost {
constructor(...args: any[]);
registrationTarget: HTMLElement; registrationTarget: HTMLElement;
__redispatchEventForFormRegistrarPortalMixin(ev: CustomEvent): void; __redispatchEventForFormRegistrarPortalMixin(ev: CustomEvent): void;
} }

1
packages/form-core/types/utils/SyncUpdatableMixinTypes.d.ts vendored
View file

@ -10,6 +10,7 @@ export declare interface SyncUpdatableNamespace {
} }
export declare class SyncUpdatableHost { export declare class SyncUpdatableHost {
constructor(...args: any[]);
static __syncUpdatableHasChanged(name: string, newValue: any, oldValue: any): boolean; static __syncUpdatableHasChanged(name: string, newValue: any, oldValue: any): boolean;
updateSync(name: string, oldValue: any): void; updateSync(name: string, oldValue: any): void;
__syncUpdatableInitialize(): void; __syncUpdatableInitialize(): void;

1
packages/form-core/types/validate/ValidateMixinTypes.d.ts vendored
View file

@ -19,6 +19,7 @@ type FeedbackMessage = {
}; };
export declare class ValidateHost { export declare class ValidateHost {
constructor(...args: any[]);
validators: Validator[]; validators: Validator[];
hasFeedbackFor: string[]; hasFeedbackFor: string[];
shouldShowFeedbackFor: string[]; shouldShowFeedbackFor: string[];

2
packages/input-date/src/LionInputDate.js
View file

@ -18,7 +18,7 @@ function isValidDate(date) {
* *
* @customElement lion-input-date * @customElement lion-input-date
*/ */
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/40110 // @ts-expect-error false positive for incompatible static get properties. Lit-element merges super properties already for you.
export class LionInputDate extends LocalizeMixin(LionInput) { export class LionInputDate extends LocalizeMixin(LionInput) {
static get properties() { static get properties() {
return { return {

1
packages/input-datepicker/src/LionCalendarOverlayFrame.js
View file

@ -1,7 +1,6 @@
import { css, html, LitElement } from '@lion/core'; import { css, html, LitElement } from '@lion/core';
import { LocalizeMixin } from '@lion/localize'; import { LocalizeMixin } from '@lion/localize';
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/40110
export class LionCalendarOverlayFrame extends LocalizeMixin(LitElement) { export class LionCalendarOverlayFrame extends LocalizeMixin(LitElement) {
static get styles() { static get styles() {
return [ return [

7
packages/input-datepicker/src/LionInputDatepicker.js
View file

@ -12,7 +12,7 @@ import { LionCalendarOverlayFrame } from './LionCalendarOverlayFrame.js';
/** /**
* @customElement lion-input-datepicker * @customElement lion-input-datepicker
*/ */
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/40110 // @ts-expect-error false positive for incompatible static get properties. Lit-element merges super properties already for you.
export class LionInputDatepicker extends ScopedElementsMixin( export class LionInputDatepicker extends ScopedElementsMixin(
ArrowMixin(OverlayMixin(LionInputDate)), ArrowMixin(OverlayMixin(LionInputDate)),
) { ) {
@ -199,9 +199,8 @@ export class LionInputDatepicker extends ScopedElementsMixin(
__toggleInvokerDisabled() { __toggleInvokerDisabled() {
if (this._invokerNode) { if (this._invokerNode) {
// @ts-expect-error even though disabled may not exist on the invoker node const invokerNode = /** @type {HTMLElement & {disabled: boolean}} */ (this._invokerNode);
// set it anyway, it doesn't harm, and is needed in case of invoker elements that do have disabled prop invokerNode.disabled = this.disabled || this.readOnly;
this._invokerNode.disabled = this.disabled || this.readOnly;
} }
} }

1
packages/input-email/src/LionInputEmail.js
View file

@ -7,7 +7,6 @@ import { LocalizeMixin } from '@lion/localize';
* *
* @customElement lion-input-email * @customElement lion-input-email
*/ */
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/40110
export class LionInputEmail extends LocalizeMixin(LionInput) { export class LionInputEmail extends LocalizeMixin(LionInput) {
constructor() { constructor() {
super(); super();

1
packages/input-iban/src/LionInputIban.js
View file

@ -8,7 +8,6 @@ import { IsIBAN } from './validators.js';
* `LionInputIban` is a class for an IBAN custom form element (`<lion-input-iban>`). * `LionInputIban` is a class for an IBAN custom form element (`<lion-input-iban>`).
* @customElement lion-input-iban * @customElement lion-input-iban
*/ */
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/40110
export class LionInputIban extends LocalizeMixin(LionInput) { export class LionInputIban extends LocalizeMixin(LionInput) {
constructor() { constructor() {
super(); super();

1
packages/listbox/src/LionListbox.js
View file

@ -8,7 +8,6 @@ import { ListboxMixin } from './ListboxMixin.js';
* LionListbox: implements the wai-aria listbox design pattern and integrates it as a Lion * LionListbox: implements the wai-aria listbox design pattern and integrates it as a Lion
* FormControl * FormControl
*/ */
// @ts-expect-error
export class LionListbox extends ListboxMixin( export class LionListbox extends ListboxMixin(
FocusMixin(InteractionStateMixin(ValidateMixin(LitElement))), FocusMixin(InteractionStateMixin(ValidateMixin(LitElement))),
) {} ) {}

1
packages/listbox/src/LionOption.js
View file

@ -13,7 +13,6 @@ import { css, DisabledMixin, html, LitElement } from '@lion/core';
* Element gets state supplied externally, reflects this to attributes, * Element gets state supplied externally, reflects this to attributes,
* enabling SubClassers to style based on those states * enabling SubClassers to style based on those states
*/ */
// @ts-expect-error
export class LionOption extends DisabledMixin(ChoiceInputMixin(FormRegisteringMixin(LitElement))) { export class LionOption extends DisabledMixin(ChoiceInputMixin(FormRegisteringMixin(LitElement))) {
static get properties() { static get properties() {
return { return {

1
packages/listbox/types/LionOption.d.ts vendored
View file

@ -1,5 +1,6 @@
import { ChoiceGroupHost } from '@lion/form-core/types/choice-group/ChoiceGroupMixinTypes'; import { ChoiceGroupHost } from '@lion/form-core/types/choice-group/ChoiceGroupMixinTypes';
export declare class LionOptionHost { export declare class LionOptionHost {
constructor(...args: any[]);
private __parentFormGroup: ChoiceGroupHost; private __parentFormGroup: ChoiceGroupHost;
} }

1
packages/listbox/types/ListboxMixinTypes.d.ts vendored
View file

@ -9,6 +9,7 @@ import { LionOptions } from '../src/LionOptions.js';
import { LionOption } from '../src/LionOption.js'; import { LionOption } from '../src/LionOption.js';
export declare class ListboxHost { export declare class ListboxHost {
constructor(...args: any[]);
/** /**
* When true, will synchronize activedescendant and selected element on * When true, will synchronize activedescendant and selected element on
* arrow key navigation. * arrow key navigation.

2
packages/localize/test/LocalizeMixin.test.js
View file

@ -71,7 +71,6 @@ describe('LocalizeMixin', () => {
'child-element': loc => fakeImport(`./child-element/${loc}.js`), 'child-element': loc => fakeImport(`./child-element/${loc}.js`),
}; };
// @ts-expect-error
class ParentElement extends LocalizeMixin(LitElement) { class ParentElement extends LocalizeMixin(LitElement) {
static get localizeNamespaces() { static get localizeNamespaces() {
return [parentElementNs, defaultNs, ...super.localizeNamespaces]; return [parentElementNs, defaultNs, ...super.localizeNamespaces];
@ -79,7 +78,6 @@ describe('LocalizeMixin', () => {
} }
const tagString = defineCE( const tagString = defineCE(
// @ts-expect-error
class ChildElement extends LocalizeMixin(ParentElement) { class ChildElement extends LocalizeMixin(ParentElement) {
static get localizeNamespaces() { static get localizeNamespaces() {
return [childElementNs, defaultNs, ...super.localizeNamespaces]; return [childElementNs, defaultNs, ...super.localizeNamespaces];

2
packages/localize/types/LocalizeMixinTypes.d.ts vendored
View file

@ -56,7 +56,7 @@ interface msgOptions {
} }
declare class LocalizeMixinHost { declare class LocalizeMixinHost {
// FIXME: return value type check doesn't seem to be `working! constructor(...args: any[]);
static get localizeNamespaces(): StringToFunctionMap[]; static get localizeNamespaces(): StringToFunctionMap[];
static get waitForLocalizeNamespaces(): boolean; static get waitForLocalizeNamespaces(): boolean;

8
packages/overlays/src/OverlayController.js
View file

@ -507,7 +507,7 @@ export class OverlayController extends EventTargetShim {
if (this.placementMode === 'local') { if (this.placementMode === 'local') {
// Lazily load Popper if not done yet // Lazily load Popper if not done yet
if (!OverlayController.popperModule) { if (!OverlayController.popperModule) {
// @ts-expect-error // @ts-expect-error FIXME: for some reason createPopper is missing here
OverlayController.popperModule = preloadPopper(); OverlayController.popperModule = preloadPopper();
} }
} }
@ -838,8 +838,8 @@ export class OverlayController extends EventTargetShim {
hideConfig.backdropNode.classList.remove( hideConfig.backdropNode.classList.remove(
`${this.placementMode}-overlays__backdrop--animation-in`, `${this.placementMode}-overlays__backdrop--animation-in`,
); );
/** @type {(ev:AnimationEvent) => void} */ /** @type {() => void} */
let afterFadeOut; let afterFadeOut = () => {};
hideConfig.backdropNode.classList.add( hideConfig.backdropNode.classList.add(
`${this.placementMode}-overlays__backdrop--animation-out`, `${this.placementMode}-overlays__backdrop--animation-out`,
); );
@ -857,7 +857,7 @@ export class OverlayController extends EventTargetShim {
resolve(undefined); resolve(undefined);
}; };
}); });
// @ts-expect-error
hideConfig.backdropNode.addEventListener('animationend', afterFadeOut); hideConfig.backdropNode.addEventListener('animationend', afterFadeOut);
} }
} }

1
packages/overlays/types/ArrowMixinTypes.d.ts vendored
View file

@ -5,6 +5,7 @@ import { Options as PopperOptions, State } from '@popperjs/core/lib/popper';
import { OverlayConfig } from '../types/OverlayConfig'; import { OverlayConfig } from '../types/OverlayConfig';
export declare class ArrowHost { export declare class ArrowHost {
constructor(...args: any[]);
static get properties(): { static get properties(): {
hasArrow: { hasArrow: {
type: BooleanConstructor; type: BooleanConstructor;

3
packages/overlays/types/OverlayMixinTypes.d.ts vendored
View file

@ -17,6 +17,7 @@ export interface DefineOverlayConfig {
} }
export declare class OverlayHost { export declare class OverlayHost {
constructor(...args: any[]);
public opened: Boolean; public opened: Boolean;
public get config(): OverlayConfig; public get config(): OverlayConfig;
@ -66,6 +67,6 @@ export declare class OverlayHost {
export declare function OverlayImplementation<T extends Constructor<LitElement>>( export declare function OverlayImplementation<T extends Constructor<LitElement>>(
superclass: T, superclass: T,
): T & Constructor<OverlayHost> & OverlayHost; ): T & Constructor<OverlayHost> & typeof OverlayHost;
export type OverlayMixin = typeof OverlayImplementation; export type OverlayMixin = typeof OverlayImplementation;

1
packages/pagination/src/LionPagination.js
View file

@ -10,7 +10,6 @@ import { LocalizeMixin } from '@lion/localize';
* *
* @customElement lion-pagination * @customElement lion-pagination
*/ */
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/40110
export class LionPagination extends LocalizeMixin(LitElement) { export class LionPagination extends LocalizeMixin(LitElement) {
static get styles() { static get styles() {
return [ return [

1
packages/progress-indicator/src/LionProgressIndicator.js
View file

@ -3,7 +3,6 @@
import { nothing, LitElement } from '@lion/core'; import { nothing, LitElement } from '@lion/core';
import { localize, LocalizeMixin } from '@lion/localize'; import { localize, LocalizeMixin } from '@lion/localize';
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/40110
export class LionProgressIndicator extends LocalizeMixin(LitElement) { export class LionProgressIndicator extends LocalizeMixin(LitElement) {
static get localizeNamespaces() { static get localizeNamespaces() {
return [ return [

1
packages/radio-group/src/LionRadioGroup.js
View file

@ -4,7 +4,6 @@ import { ChoiceGroupMixin, FormGroupMixin } from '@lion/form-core';
/** /**
* A wrapper around multiple radios. * A wrapper around multiple radios.
*/ */
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/40110
export class LionRadioGroup extends ChoiceGroupMixin(FormGroupMixin(LitElement)) { export class LionRadioGroup extends ChoiceGroupMixin(FormGroupMixin(LitElement)) {
connectedCallback() { connectedCallback() {
super.connectedCallback(); super.connectedCallback();

3
packages/select-rich/src/LionSelectRich.js
View file

@ -23,7 +23,7 @@ function detectInteractionMode() {
/** /**
* LionSelectRich: wraps the <lion-listbox> element * LionSelectRich: wraps the <lion-listbox> element
*/ */
// @ts-expect-error // @ts-expect-error false positive for incompatible static get properties. Lit-element merges super properties already for you.
export class LionSelectRich extends SlotMixin(ScopedElementsMixin(OverlayMixin(LionListbox))) { export class LionSelectRich extends SlotMixin(ScopedElementsMixin(OverlayMixin(LionListbox))) {
static get scopedElements() { static get scopedElements() {
return { return {
@ -88,7 +88,6 @@ export class LionSelectRich extends SlotMixin(ScopedElementsMixin(OverlayMixin(L
* @configure ListboxMixin * @configure ListboxMixin
* @protected * @protected
*/ */
// @ts-ignore
get _scrollTargetNode() { get _scrollTargetNode() {
// TODO: should this be defined here or in extension layer? // TODO: should this be defined here or in extension layer?
// @ts-expect-error we allow the _overlayContentNode to define its own _scrollTargetNode // @ts-expect-error we allow the _overlayContentNode to define its own _scrollTargetNode

1
packages/switch/src/LionSwitch.js
View file

@ -2,7 +2,6 @@ import { css, html, ScopedElementsMixin } from '@lion/core';
import { ChoiceInputMixin, LionField } from '@lion/form-core'; import { ChoiceInputMixin, LionField } from '@lion/form-core';
import { LionSwitchButton } from './LionSwitchButton.js'; import { LionSwitchButton } from './LionSwitchButton.js';
// @ts-expect-error https://github.com/microsoft/TypeScript/issues/40110
export class LionSwitch extends ScopedElementsMixin(ChoiceInputMixin(LionField)) { export class LionSwitch extends ScopedElementsMixin(ChoiceInputMixin(LionField)) {
static get styles() { static get styles() {
return [ return [