@fluentui/web-components 3.0.0-beta.3 → 3.0.0-beta.31

package/dist/esm/field/field.styles.js

@@ -0,0 +1,186 @@
+import { css } from '@microsoft/fast-element';
+import { borderRadiusMedium, colorNeutralForeground1, colorStrokeFocus2, fontFamilyBase, fontSizeBase200, fontSizeBase300, fontSizeBase400, fontWeightRegular, fontWeightSemibold, lineHeightBase200, lineHeightBase300, lineHeightBase400, spacingHorizontalM, spacingVerticalS, spacingVerticalXXS, strokeWidthThick, } from '../theme/design-tokens.js';
+import { display } from '../utils/display.js';
+import { ValidationFlags } from './field.options.js';
+/**
+ * Selector for the `disabled` state.
+ * @public
+ */
+const disabledState = css.partial `:is([state--disabled], :state(disabled))`;
+/**
+ * Selector for the `focus-visible` state.
+ * @public
+ */
+const focusVisibleState = css.partial `:is([state--focus-visible], :state(focus-visible))`;
+/**
+ * Selector for the `bad-input` state.
+ * @public
+ */
+const badInputState = css.partial `:is([state--${ValidationFlags.badInput}], :state(${ValidationFlags.badInput}))`;
+/**
+ * Selector for the `custom-error` state.
+ * @public
+ */
+const customErrorState = css.partial `:is([state--${ValidationFlags.customError}], :state(${ValidationFlags.customError}))`;
+/**
+ * Selector for the `pattern-mismatch` state.
+ * @public
+ */
+const patternMismatchState = css.partial `:is([state--${ValidationFlags.patternMismatch}], :state(${ValidationFlags.patternMismatch}))`;
+/**
+ * Selector for the `range-overflow` state.
+ * @public
+ */
+const rangeOverflowState = css.partial `:is([state--${ValidationFlags.rangeOverflow}], :state(${ValidationFlags.rangeOverflow}))`;
+/**
+ * Selector for the `range-underflow` state.
+ * @public
+ */
+const rangeUnderflowState = css.partial `:is([state--${ValidationFlags.rangeUnderflow}], :state(${ValidationFlags.rangeUnderflow}))`;
+/**
+ * Selector for the `step-mismatch` state.
+ * @public
+ */
+const stepMismatchState = css.partial `:is([state--${ValidationFlags.stepMismatch}], :state(${ValidationFlags.stepMismatch}))`;
+/**
+ * Selector for the `too-long` state.
+ * @public
+ */
+const tooLongState = css.partial `:is([state--${ValidationFlags.tooLong}], :state(${ValidationFlags.tooLong}))`;
+/**
+ * Selector for the `too-short` state.
+ * @public
+ */
+const tooShortState = css.partial `:is([state--${ValidationFlags.tooShort}], :state(${ValidationFlags.tooShort}))`;
+/**
+ * Selector for the `type-mismatch` state.
+ * @public
+ */
+const typeMismatchState = css.partial `:is([state--${ValidationFlags.typeMismatch}], :state(${ValidationFlags.typeMismatch}))`;
+/**
+ * Selector for the `valid` state.
+ * @public
+ */
+const validState = css.partial `:is([state-${ValidationFlags.valid}], :state(${ValidationFlags.valid}))`;
+/**
+ * Selector for the `value-missing` state.
+ * @public
+ */
+const valueMissingState = css.partial `:is([state--${ValidationFlags.valueMissing}], :state(${ValidationFlags.valueMissing}))`;
+/**
+ * The styles for the {@link Field} component.
+ *
+ * @public
+ */
+export const styles = css `
+  ${display('inline-grid')}
+
+  :host {
+    align-items: center;
+    cursor: pointer;
+    gap: 0 ${spacingHorizontalM};
+    justify-items: start;
+    padding: ${spacingVerticalS};
+  }
+
+  :has([slot='message']) {
+    color: ${colorNeutralForeground1};
+    row-gap: ${spacingVerticalS};
+  }
+
+  :not(::slotted([slot='label'])) {
+    gap: 0;
+  }
+
+  :host([label-position='before']) {
+    grid-template-areas: 'label input' 'label message';
+  }
+
+  :host([label-position='after']) {
+    gap: 0;
+    grid-template-areas: 'input label' 'message message';
+    grid-template-columns: auto 1fr;
+  }
+
+  :host([label-position='after']) ::slotted([slot='input']) {
+    margin-inline-end: ${spacingHorizontalM};
+  }
+
+  :host([label-position='above']) {
+    grid-template-areas: 'label' 'input' 'message';
+    row-gap: ${spacingVerticalXXS};
+  }
+
+  :host([label-position='below']) {
+    grid-template-areas: 'input' 'label' 'message';
+  }
+
+  ::slotted([slot='label']) {
+    cursor: pointer;
+    grid-area: label;
+  }
+
+  ::slotted([slot='input']) {
+    grid-area: input;
+  }
+
+  ::slotted([slot='message']) {
+    margin-block-start: ${spacingVerticalXXS};
+    grid-area: message;
+  }
+
+  :host(${focusVisibleState}:focus-within) {
+    border-radius: ${borderRadiusMedium};
+    outline: ${strokeWidthThick} solid ${colorStrokeFocus2};
+  }
+
+  ::slotted(label) {
+    display: inline-flex;
+    color: ${colorNeutralForeground1};
+    cursor: pointer;
+    font-family: ${fontFamilyBase};
+    font-size: ${fontSizeBase300};
+    font-weight: ${fontWeightRegular};
+    line-height: ${lineHeightBase300};
+    user-select: none;
+  }
+
+  :host([size='small']) ::slotted(label) {
+    font-size: ${fontSizeBase200};
+    line-height: ${lineHeightBase200};
+  }
+
+  :host([size='large']) ::slotted(label) {
+    font-size: ${fontSizeBase400};
+    line-height: ${lineHeightBase400};
+  }
+
+  :host([size='large']) ::slotted(label),
+  :host([weight='semibold']) ::slotted(label) {
+    font-weight: ${fontWeightSemibold};
+  }
+
+  :host(${disabledState}) ::slotted(label) {
+    color: ${colorNeutralForeground1};
+    cursor: default;
+  }
+
+  ::slotted([flag]) {
+    display: none;
+  }
+
+  :host(${badInputState}) ::slotted([flag='${ValidationFlags.badInput}']),
+  :host(${customErrorState}) ::slotted([flag='${ValidationFlags.customError}']),
+  :host(${patternMismatchState}) ::slotted([flag='${ValidationFlags.patternMismatch}']),
+  :host(${rangeOverflowState}) ::slotted([flag='${ValidationFlags.rangeOverflow}']),
+  :host(${rangeUnderflowState}) ::slotted([flag='${ValidationFlags.rangeUnderflow}']),
+  :host(${stepMismatchState}) ::slotted([flag='${ValidationFlags.stepMismatch}']),
+  :host(${tooLongState}) ::slotted([flag='${ValidationFlags.tooLong}']),
+  :host(${tooShortState}) ::slotted([flag='${ValidationFlags.tooShort}']),
+  :host(${typeMismatchState}) ::slotted([flag='${ValidationFlags.typeMismatch}']),
+  :host(${valueMissingState}) ::slotted([flag='${ValidationFlags.valueMissing}']),
+  :host(${validState}) ::slotted([flag='${ValidationFlags.valid}']) {
+    display: block;
+  }
+`;
+//# sourceMappingURL=field.styles.js.map

package/dist/esm/field/field.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.styles.js","sourceRoot":"","sources":["../../../src/field/field.styles.ts"],"names":[],"mappings":"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"}

package/dist/esm/field/field.template.js

@@ -0,0 +1,26 @@
+import { children, elements, html, slotted } from '@microsoft/fast-element';
+/**
+ * Template for the Field component
+ * @public
+ */
+export const template = html `
+  <template
+    @click="${(x, c) => x.clickHandler(c.event)}"
+    @change="${(x, c) => x.changeHandler(c.event)}"
+    @focusin="${(x, c) => x.focusinHandler(c.event)}"
+    @focusout="${(x, c) => x.focusoutHandler(c.event)}"
+    ${children({
+    property: 'slottedInputs',
+    attributes: true,
+    attributeFilter: ['disabled', 'required', 'readonly'],
+    subtree: true,
+    selector: '[slot="input"]',
+    filter: elements(),
+})}
+  >
+    <slot name="label" part="label"></slot>
+    <slot name="input" part="input"></slot>
+    <slot name="message" part="message" ${slotted({ property: 'messageSlot', filter: elements('[flag]') })}></slot>
+  </template>
+`;
+//# sourceMappingURL=field.template.js.map

package/dist/esm/field/field.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.template.js","sourceRoot":"","sources":["../../../src/field/field.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAuB,IAAI,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAGjG;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAwB,IAAI,CAAO;;cAE1C,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,KAAmB,CAAC;eAC9C,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,KAAmB,CAAC;gBAC/C,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,KAAmB,CAAC;iBAChD,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,KAAmB,CAAC;MAC7D,QAAQ,CAAC;IACT,QAAQ,EAAE,eAAe;IACzB,UAAU,EAAE,IAAI;IAChB,eAAe,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC;IACrD,OAAO,EAAE,IAAI;IACb,QAAQ,EAAE,gBAAgB;IAC1B,MAAM,EAAE,QAAQ,EAAE;CACnB,CAAC;;;;0CAIoC,OAAO,CAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;;CAEzG,CAAC"}

package/dist/esm/field/index.js

@@ -0,0 +1,6 @@
+export { Field } from './field.js';
+export { LabelPosition as FieldLabelPosition, ValidationFlags } from './field.options.js';
+export { definition as FieldDefinition } from './field.definition.js';
+export { styles as FieldStyles } from './field.styles.js';
+export { template as FieldTemplate } from './field.template.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/field/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/field/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,aAAa,IAAI,kBAAkB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1F,OAAO,EAAE,UAAU,IAAI,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,MAAM,IAAI,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,QAAQ,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/esm/form-associated/form-associated.js

@@ -0,0 +1,458 @@
+import { attr, booleanConverter, emptyArray, observable, Updates } from '@microsoft/fast-element';
+import { keyEnter } from '@microsoft/fast-web-utilities';
+const proxySlotName = 'form-associated-proxy';
+const ElementInternalsKey = 'ElementInternals';
+/**
+ * @alpha
+ */
+export const supportsElementInternals = ElementInternalsKey in window && 'setFormValue' in window[ElementInternalsKey].prototype;
+const InternalsMap = new WeakMap();
+/**
+ * Base function for providing Custom Element Form Association.
+ *
+ * @beta
+ */
+export function FormAssociated(BaseCtor) {
+    const C = class extends BaseCtor {
+        /**
+         * Must evaluate to true to enable elementInternals.
+         * Feature detects API support and resolve respectively
+         *
+         * @internal
+         */
+        static get formAssociated() {
+            return supportsElementInternals;
+        }
+        /**
+         * Returns the validity state of the element
+         *
+         * @beta
+         */
+        get validity() {
+            return this.elementInternals ? this.elementInternals.validity : this.proxy.validity;
+        }
+        /**
+         * Retrieve a reference to the associated form.
+         * Returns null if not associated to any form.
+         *
+         * @beta
+         */
+        get form() {
+            return this.elementInternals ? this.elementInternals.form : this.proxy.form;
+        }
+        /**
+         * Retrieve the localized validation message,
+         * or custom validation message if set.
+         *
+         * @beta
+         */
+        get validationMessage() {
+            return this.elementInternals ? this.elementInternals.validationMessage : this.proxy.validationMessage;
+        }
+        /**
+         * Whether the element will be validated when the
+         * form is submitted
+         */
+        get willValidate() {
+            return this.elementInternals ? this.elementInternals.willValidate : this.proxy.willValidate;
+        }
+        /**
+         * A reference to all associated label elements
+         */
+        get labels() {
+            if (this.elementInternals) {
+                return Object.freeze(Array.from(this.elementInternals.labels));
+            }
+            else if (this.proxy instanceof HTMLElement && this.proxy.ownerDocument && this.id) {
+                // Labels associated by wrapping the element: <label><custom-element></custom-element></label>
+                const parentLabels = this.proxy.labels;
+                // Labels associated using the `for` attribute
+                const forLabels = Array.from(this.proxy.getRootNode().querySelectorAll(`[for='${this.id}']`));
+                const labels = parentLabels ? forLabels.concat(Array.from(parentLabels)) : forLabels;
+                return Object.freeze(labels);
+            }
+            else {
+                return emptyArray;
+            }
+        }
+        /**
+         * Invoked when the `value` property changes
+         * @param previous - the previous value
+         * @param next - the new value
+         *
+         * @remarks
+         * If elements extending `FormAssociated` implement a `valueChanged` method
+         * They must be sure to invoke `super.valueChanged(previous, next)` to ensure
+         * proper functioning of `FormAssociated`
+         */
+        valueChanged(previous, next) {
+            this.dirtyValue = true;
+            if (this.proxy instanceof HTMLElement) {
+                this.proxy.value = this.value;
+            }
+            this.currentValue = this.value;
+            this.setFormValue(this.value);
+            this.validate();
+        }
+        currentValueChanged() {
+            this.value = this.currentValue;
+        }
+        /**
+         * Invoked when the `initialValue` property changes
+         *
+         * @param previous - the previous value
+         * @param next - the new value
+         *
+         * @remarks
+         * If elements extending `FormAssociated` implement a `initialValueChanged` method
+         * They must be sure to invoke `super.initialValueChanged(previous, next)` to ensure
+         * proper functioning of `FormAssociated`
+         */
+        initialValueChanged(previous, next) {
+            // If the value is clean and the component is connected to the DOM
+            // then set value equal to the attribute value.
+            if (!this.dirtyValue) {
+                this.value = this.initialValue;
+                this.dirtyValue = false;
+            }
+        }
+        /**
+         * Invoked when the `disabled` property changes
+         *
+         * @param previous - the previous value
+         * @param next - the new value
+         *
+         * @remarks
+         * If elements extending `FormAssociated` implement a `disabledChanged` method
+         * They must be sure to invoke `super.disabledChanged(previous, next)` to ensure
+         * proper functioning of `FormAssociated`
+         */
+        disabledChanged(previous, next) {
+            if (this.proxy instanceof HTMLElement) {
+                this.proxy.disabled = this.disabled;
+            }
+            Updates.enqueue(() => this.classList.toggle('disabled', this.disabled));
+        }
+        /**
+         * Invoked when the `name` property changes
+         *
+         * @param previous - the previous value
+         * @param next - the new value
+         *
+         * @remarks
+         * If elements extending `FormAssociated` implement a `nameChanged` method
+         * They must be sure to invoke `super.nameChanged(previous, next)` to ensure
+         * proper functioning of `FormAssociated`
+         */
+        nameChanged(previous, next) {
+            if (this.proxy instanceof HTMLElement) {
+                this.proxy.name = this.name;
+            }
+        }
+        /**
+         * Invoked when the `required` property changes
+         *
+         * @param previous - the previous value
+         * @param next - the new value
+         *
+         * @remarks
+         * If elements extending `FormAssociated` implement a `requiredChanged` method
+         * They must be sure to invoke `super.requiredChanged(previous, next)` to ensure
+         * proper functioning of `FormAssociated`
+         */
+        requiredChanged(prev, next) {
+            if (this.proxy instanceof HTMLElement) {
+                this.proxy.required = this.required;
+            }
+            Updates.enqueue(() => this.classList.toggle('required', this.required));
+            this.validate();
+        }
+        /**
+         * The element internals object. Will only exist
+         * in browsers supporting the attachInternals API
+         */
+        get elementInternals() {
+            if (!supportsElementInternals) {
+                return null;
+            }
+            let internals = InternalsMap.get(this);
+            if (!internals) {
+                internals = this.attachInternals();
+                InternalsMap.set(this, internals);
+            }
+            return internals;
+        }
+        constructor(...args) {
+            super(...args);
+            /**
+             * Track whether the value has been changed from the initial value
+             */
+            this.dirtyValue = false;
+            /**
+             * The initial value of the form. This value sets the `value` property
+             * only when the `value` property has not been explicitly set.
+             *
+             * @remarks
+             * HTML Attribute: value
+             */
+            this.initialValue = '';
+            /**
+             * Sets the element's disabled state. A disabled element will not be included during form submission.
+             *
+             * @remarks
+             * HTML Attribute: disabled
+             */
+            this.disabled = false;
+            /**
+             * These are events that are still fired by the proxy
+             * element based on user / programmatic interaction.
+             *
+             * The proxy implementation should be transparent to
+             * the app author, so block these events from emitting.
+             */
+            this.proxyEventsToBlock = ['change', 'click'];
+            this.proxyInitialized = false;
+            this.required = false;
+            this.initialValue = this.initialValue || '';
+            if (!this.elementInternals) {
+                // When elementInternals is not supported, formResetCallback is
+                // bound to an event listener, so ensure the handler's `this`
+                // context is correct.
+                this.formResetCallback = this.formResetCallback.bind(this);
+            }
+        }
+        /**
+         * @internal
+         */
+        connectedCallback() {
+            super.connectedCallback();
+            this.addEventListener('keypress', this._keypressHandler);
+            if (!this.value) {
+                this.value = this.initialValue;
+                this.dirtyValue = false;
+            }
+            if (!this.elementInternals) {
+                this.attachProxy();
+                if (this.form) {
+                    this.form.addEventListener('reset', this.formResetCallback);
+                }
+            }
+        }
+        /**
+         * @internal
+         */
+        disconnectedCallback() {
+            this.proxyEventsToBlock.forEach(name => this.proxy.removeEventListener(name, this.stopPropagation));
+            if (!this.elementInternals && this.form) {
+                this.form.removeEventListener('reset', this.formResetCallback);
+            }
+        }
+        /**
+         * Return the current validity of the element.
+         */
+        checkValidity() {
+            return this.elementInternals ? this.elementInternals.checkValidity() : this.proxy.checkValidity();
+        }
+        /**
+         * Return the current validity of the element.
+         * If false, fires an invalid event at the element.
+         */
+        reportValidity() {
+            return this.elementInternals ? this.elementInternals.reportValidity() : this.proxy.reportValidity();
+        }
+        /**
+         * Set the validity of the control. In cases when the elementInternals object is not
+         * available (and the proxy element is used to report validity), this function will
+         * do nothing unless a message is provided, at which point the setCustomValidity method
+         * of the proxy element will be invoked with the provided message.
+         * @param flags - Validity flags
+         * @param message - Optional message to supply
+         * @param anchor - Optional element used by UA to display an interactive validation UI
+         */
+        setValidity(flags, message, anchor) {
+            if (this.elementInternals) {
+                this.elementInternals.setValidity(flags, message, anchor);
+            }
+            else if (typeof message === 'string') {
+                this.proxy.setCustomValidity(message);
+            }
+        }
+        /**
+         * Invoked when a connected component's form or fieldset has its disabled
+         * state changed.
+         * @param disabled - the disabled value of the form / fieldset
+         */
+        formDisabledCallback(disabled) {
+            this.disabled = disabled;
+        }
+        formResetCallback() {
+            this.value = this.initialValue;
+            this.dirtyValue = false;
+        }
+        /**
+         * Attach the proxy element to the DOM
+         */
+        attachProxy() {
+            var _a;
+            if (!this.proxyInitialized) {
+                this.proxyInitialized = true;
+                this.proxy.style.display = 'none';
+                this.proxyEventsToBlock.forEach(name => this.proxy.addEventListener(name, this.stopPropagation));
+                // These are typically mapped to the proxy during
+                // property change callbacks, but during initialization
+                // on the initial call of the callback, the proxy is
+                // still undefined. We should find a better way to address this.
+                this.proxy.disabled = this.disabled;
+                this.proxy.required = this.required;
+                if (typeof this.name === 'string') {
+                    this.proxy.name = this.name;
+                }
+                if (typeof this.value === 'string') {
+                    this.proxy.value = this.value;
+                }
+                this.proxy.setAttribute('slot', proxySlotName);
+                this.proxySlot = document.createElement('slot');
+                this.proxySlot.setAttribute('name', proxySlotName);
+            }
+            (_a = this.shadowRoot) === null || _a === void 0 ? void 0 : _a.appendChild(this.proxySlot);
+            this.appendChild(this.proxy);
+        }
+        /**
+         * Detach the proxy element from the DOM
+         */
+        detachProxy() {
+            var _a;
+            this.removeChild(this.proxy);
+            (_a = this.shadowRoot) === null || _a === void 0 ? void 0 : _a.removeChild(this.proxySlot);
+        }
+        /** {@inheritDoc (FormAssociated:interface).validate} */
+        validate(anchor) {
+            if (this.proxy instanceof HTMLElement) {
+                this.setValidity(this.proxy.validity, this.proxy.validationMessage, anchor);
+            }
+        }
+        /**
+         * Associates the provided value (and optional state) with the parent form.
+         * @param value - The value to set
+         * @param state - The state object provided to during session restores and when autofilling.
+         */
+        setFormValue(value, state) {
+            if (this.elementInternals) {
+                this.elementInternals.setFormValue(value, state || value);
+            }
+        }
+        _keypressHandler(e) {
+            switch (e.key) {
+                case keyEnter:
+                    if (this.form instanceof HTMLFormElement) {
+                        // Implicit submission
+                        const defaultButton = this.form.querySelector('[type=submit]');
+                        defaultButton === null || defaultButton === void 0 ? void 0 : defaultButton.click();
+                    }
+                    break;
+            }
+        }
+        /**
+         * Used to stop propagation of proxy element events
+         * @param e - Event object
+         */
+        stopPropagation(e) {
+            e.stopPropagation();
+        }
+    };
+    attr({ mode: 'boolean' })(C.prototype, 'disabled');
+    attr({ mode: 'fromView', attribute: 'value' })(C.prototype, 'initialValue');
+    attr({ attribute: 'current-value' })(C.prototype, 'currentValue');
+    attr(C.prototype, 'name');
+    attr({ mode: 'boolean' })(C.prototype, 'required');
+    observable(C.prototype, 'value');
+    return C;
+}
+/**
+ * Creates a checkable form associated component.
+ * @beta
+ */
+export function CheckableFormAssociated(BaseCtor) {
+    class C extends FormAssociated(BaseCtor) {
+    }
+    class D extends C {
+        checkedAttributeChanged() {
+            this.defaultChecked = this.checkedAttribute;
+        }
+        /**
+         * @internal
+         */
+        defaultCheckedChanged() {
+            if (!this.dirtyChecked) {
+                // Setting this.checked will cause us to enter a dirty state,
+                // but if we are clean when defaultChecked is changed, we want to stay
+                // in a clean state, so reset this.dirtyChecked
+                this.checked = this.defaultChecked;
+                this.dirtyChecked = false;
+            }
+        }
+        checkedChanged(prev, next) {
+            if (!this.dirtyChecked) {
+                this.dirtyChecked = true;
+            }
+            this.currentChecked = this.checked;
+            this.updateForm();
+            if (this.proxy instanceof HTMLInputElement) {
+                this.proxy.checked = this.checked;
+            }
+            if (prev !== undefined) {
+                this.$emit('change');
+            }
+            this.validate();
+        }
+        currentCheckedChanged(prev, next) {
+            this.checked = this.currentChecked;
+        }
+        constructor(...args) {
+            super(args);
+            /**
+             * Tracks whether the "checked" property has been changed.
+             * This is necessary to provide consistent behavior with
+             * normal input checkboxes
+             */
+            this.dirtyChecked = false;
+            /**
+             * Provides the default checkedness of the input element
+             * Passed down to proxy
+             *
+             * @public
+             * @remarks
+             * HTML Attribute: checked
+             */
+            this.checkedAttribute = false;
+            /**
+             * The checked state of the control.
+             *
+             * @public
+             */
+            this.checked = false;
+            // Re-initialize dirtyChecked because initialization of other values
+            // causes it to become true
+            this.dirtyChecked = false;
+        }
+        updateForm() {
+            const value = this.checked ? this.value : null;
+            this.setFormValue(value, value);
+        }
+        connectedCallback() {
+            super.connectedCallback();
+            this.updateForm();
+        }
+        formResetCallback() {
+            super.formResetCallback();
+            this.checked = !!this.checkedAttribute;
+            this.dirtyChecked = false;
+        }
+    }
+    attr({ attribute: 'checked', mode: 'boolean' })(D.prototype, 'checkedAttribute');
+    attr({ attribute: 'current-checked', converter: booleanConverter })(D.prototype, 'currentChecked');
+    observable(D.prototype, 'defaultChecked');
+    observable(D.prototype, 'checked');
+    return D;
+}
+//# sourceMappingURL=form-associated.js.map