@sandlada/mdc 0.1.0-nightly.14072025

package/build/utils/behaviors/validators/checkbox-validator.js

@@ -0,0 +1,6 @@
+import{Validator as e}from"./validator.js";
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */class c extends e{computeValidity(e){return this.checkboxControl||(this.checkboxControl=document.createElement("input"),this.checkboxControl.type="checkbox"),this.checkboxControl.checked=e.checked,this.checkboxControl.required=e.required,{validity:this.checkboxControl.validity,validationMessage:this.checkboxControl.validationMessage}}equals(e,c){return e.checked===c.checked&&e.required===c.required}copy({checked:e,required:c}){return{checked:e,required:c}}}export{c as CheckboxValidator};

package/build/utils/behaviors/validators/radio-validator.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Validator } from './validator.js';
+/**
+ * Constraint validation properties for a radio.
+ */
+export interface RadioState {
+    /**
+     * Whether the radio is checked.
+     */
+    readonly checked: boolean;
+    /**
+     * Whether the radio is required.
+     */
+    readonly required: boolean;
+}
+/**
+ * Radio constraint validation properties for a single radio and its siblings.
+ */
+export type RadioGroupState = readonly [RadioState, ...RadioState[]];
+/**
+ * A validator that provides constraint validation that emulates
+ * `<input type="radio">` validation.
+ */
+export declare class RadioValidator extends Validator<RadioGroupState> {
+    private radioElement?;
+    protected computeValidity(states: RadioGroupState): {
+        validity: {
+            valueMissing: boolean;
+        };
+        validationMessage: string;
+    };
+    protected equals(prevGroup: RadioGroupState, nextGroup: RadioGroupState): boolean;
+    protected copy(states: RadioGroupState): RadioGroupState;
+}
+//# sourceMappingURL=radio-validator.d.ts.map

package/build/utils/behaviors/validators/radio-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-validator.d.ts","sourceRoot":"","sources":["../../../../src/utils/behaviors/validators/radio-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,SAAS,CAAC,UAAU,EAAE,GAAG,UAAU,EAAE,CAAC,CAAC;AAErE;;;GAGG;AACH,qBAAa,cAAe,SAAQ,SAAS,CAAC,eAAe,CAAC;IAC5D,OAAO,CAAC,YAAY,CAAC,CAAmB;cAErB,eAAe,CAAC,MAAM,EAAE,eAAe;;;;;;cAmCvC,MAAM,CACvB,SAAS,EAAE,eAAe,EAC1B,SAAS,EAAE,eAAe;cAiBT,IAAI,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe;CAQlE"}

package/build/utils/behaviors/validators/radio-validator.js

@@ -0,0 +1,6 @@
+import{Validator as e}from"./validator.js";
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */class t extends e{computeValidity(e){this.radioElement||(this.radioElement=document.createElement("input"),this.radioElement.type="radio",this.radioElement.name="group");let t=!1,r=!1;for(const{checked:i,required:d}of e)d&&(t=!0),i&&(r=!0);return this.radioElement.checked=r,this.radioElement.required=t,{validity:{valueMissing:t&&!r},validationMessage:this.radioElement.validationMessage}}equals(e,t){if(e.length!==t.length)return!1;for(let r=0;r<e.length;r++){const i=e[r],d=t[r];if(i.checked!==d.checked||i.required!==d.required)return!1}return!0}copy(e){return e.map(({checked:e,required:t})=>({checked:e,required:t}))}}export{t as RadioValidator};

package/build/utils/behaviors/validators/select-validator.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Validator } from './validator.js';
+/**
+ * Constraint validation properties for a select dropdown.
+ */
+export interface SelectState {
+    /**
+     * The current selected value.
+     */
+    readonly value: string;
+    /**
+     * Whether the select is required.
+     */
+    readonly required: boolean;
+}
+/**
+ * A validator that provides constraint validation that emulates `<select>`
+ * validation.
+ */
+export declare class SelectValidator extends Validator<SelectState> {
+    private selectControl?;
+    protected computeValidity(state: SelectState): {
+        validity: ValidityState;
+        validationMessage: string;
+    };
+    protected equals(prev: SelectState, next: SelectState): boolean;
+    protected copy({ value, required }: SelectState): {
+        value: string;
+        required: boolean;
+    };
+}
+//# sourceMappingURL=select-validator.d.ts.map

package/build/utils/behaviors/validators/select-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-validator.d.ts","sourceRoot":"","sources":["../../../../src/utils/behaviors/validators/select-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,SAAS,CAAC,WAAW,CAAC;IACzD,OAAO,CAAC,aAAa,CAAC,CAAoB;cAEvB,eAAe,CAAC,KAAK,EAAE,WAAW;;;;cAgBlC,MAAM,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW;cAI3C,IAAI,CAAC,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAE,WAAW;;;;CAGvD"}

package/build/utils/behaviors/validators/select-validator.js

@@ -0,0 +1,6 @@
+import{B as e,x as t}from"../../../lit-element-Bf8D1KRw.js";import{Validator as l}from"./validator.js";
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */class r extends l{computeValidity(l){return this.selectControl||(this.selectControl=document.createElement("select")),e(t`<option value="${l.value}"></option>`,this.selectControl),this.selectControl.value=l.value,this.selectControl.required=l.required,{validity:this.selectControl.validity,validationMessage:this.selectControl.validationMessage}}equals(e,t){return e.value===t.value&&e.required===t.required}copy({value:e,required:t}){return{value:e,required:t}}}export{r as SelectValidator};

package/build/utils/behaviors/validators/text-field-validator.d.ts

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Validator } from './validator.js';
+/**
+ * Constraint validation for a text field.
+ */
+export interface TextFieldState {
+    /**
+     * The input or textarea state to validate.
+     */
+    state: InputState | TextAreaState;
+    /**
+     * The `<input>` or `<textarea>` that is rendered on the page.
+     *
+     * `minlength` and `maxlength` validation do not apply until a user has
+     * interacted with the control and the element is internally marked as dirty.
+     * This is a spec quirk, the two properties behave differently from other
+     * constraint validation.
+     *
+     * This means we need an actual rendered element instead of a virtual one,
+     * since the virtual element will never be marked as dirty.
+     *
+     * This can be `null` if the element has not yet rendered, and the validator
+     * will fall back to virtual elements for other constraint validation
+     * properties, which do apply even if the control is not dirty.
+     */
+    renderedControl: HTMLInputElement | HTMLTextAreaElement | null;
+}
+/**
+ * Constraint validation properties for an `<input>`.
+ */
+export interface InputState extends SharedInputAndTextAreaState {
+    /**
+     * The `<input>` type.
+     *
+     * Not all constraint validation properties apply to every type. See
+     * https://developer.mozilla.org/en-US/docs/Web/HTML/Constraint_validation#validation-related_attributes
+     * for which properties will apply to which types.
+     */
+    readonly type: string;
+    /**
+     * The regex pattern a value must match.
+     */
+    readonly pattern: string;
+    /**
+     * The minimum value.
+     */
+    readonly min: string;
+    /**
+     * The maximum value.
+     */
+    readonly max: string;
+    /**
+     * The step interval of the value.
+     */
+    readonly step: string;
+}
+/**
+ * Constraint validation properties for a `<textarea>`.
+ */
+export interface TextAreaState extends SharedInputAndTextAreaState {
+    /**
+     * The type, must be "textarea" to inform the validator to use `<textarea>`
+     * instead of `<input>`.
+     */
+    readonly type: 'textarea';
+}
+/**
+ * Constraint validation properties shared between an `<input>` and
+ * `<textarea>`.
+ */
+interface SharedInputAndTextAreaState {
+    /**
+     * The current value.
+     */
+    readonly value: string;
+    /**
+     * Whether the textarea is required.
+     */
+    readonly required: boolean;
+    /**
+     * The minimum length of the value.
+     */
+    readonly minLength: number;
+    /**
+     * The maximum length of the value.
+     */
+    readonly maxLength: number;
+}
+/**
+ * A validator that provides constraint validation that emulates `<input>` and
+ * `<textarea>` validation.
+ */
+export declare class TextFieldValidator extends Validator<TextFieldState> {
+    private inputControl?;
+    private textAreaControl?;
+    protected computeValidity({ state, renderedControl }: TextFieldState): {
+        validity: ValidityState;
+        validationMessage: string;
+    };
+    protected equals({ state: prev }: TextFieldState, { state: next }: TextFieldState): boolean;
+    protected copy({ state }: TextFieldState): TextFieldState;
+    private copyInput;
+    private copyTextArea;
+    private copySharedState;
+}
+export {};
+//# sourceMappingURL=text-field-validator.d.ts.map

package/build/utils/behaviors/validators/text-field-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-field-validator.d.ts","sourceRoot":"","sources":["../../../../src/utils/behaviors/validators/text-field-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,KAAK,EAAE,UAAU,GAAG,aAAa,CAAC;IAElC;;;;;;;;;;;;;;OAcG;IACH,eAAe,EAAE,gBAAgB,GAAG,mBAAmB,GAAG,IAAI,CAAC;CAChE;AAED;;GAEG;AACH,MAAM,WAAW,UAAW,SAAQ,2BAA2B;IAC7D;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,aAAc,SAAQ,2BAA2B;IAChE;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC3B;AAED;;;GAGG;AACH,UAAU,2BAA2B;IACnC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAE3B;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,SAAS,CAAC,cAAc,CAAC;IAC/D,OAAO,CAAC,YAAY,CAAC,CAAmB;IACxC,OAAO,CAAC,eAAe,CAAC,CAAsB;cAE3B,eAAe,CAAC,EAAC,KAAK,EAAE,eAAe,EAAC,EAAE,cAAc;;;;cA+FxD,MAAM,CACvB,EAAC,KAAK,EAAE,IAAI,EAAC,EAAE,cAAc,EAC7B,EAAC,KAAK,EAAE,IAAI,EAAC,EAAE,cAAc;cAyBZ,IAAI,CAAC,EAAC,KAAK,EAAC,EAAE,cAAc,GAAG,cAAc;IAWhE,OAAO,CAAC,SAAS;IAYjB,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,eAAe;CAQxB"}

package/build/utils/behaviors/validators/text-field-validator.js

@@ -0,0 +1,6 @@
+import{Validator as t}from"./validator.js";
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */class e extends t{computeValidity({state:t,renderedControl:e}){let r=e;n(t)&&!r?(r=this.inputControl||document.createElement("input"),this.inputControl=r):r||(r=this.textAreaControl||document.createElement("textarea"),this.textAreaControl=r);const a=n(t)?r:null;if(a&&(a.type=t.type),r.value!==t.value&&(r.value=t.value),r.required=t.required,a){const e=t;e.pattern?a.pattern=e.pattern:a.removeAttribute("pattern"),e.min?a.min=e.min:a.removeAttribute("min"),e.max?a.max=e.max:a.removeAttribute("max"),e.step?a.step=e.step:a.removeAttribute("step")}return(t.minLength??-1)>-1?r.setAttribute("minlength",String(t.minLength)):r.removeAttribute("minlength"),(t.maxLength??-1)>-1?r.setAttribute("maxlength",String(t.maxLength)):r.removeAttribute("maxlength"),{validity:r.validity,validationMessage:r.validationMessage}}equals({state:t},{state:e}){const r=t.type===e.type&&t.value===e.value&&t.required===e.required&&t.minLength===e.minLength&&t.maxLength===e.maxLength;return n(t)&&n(e)?r&&t.pattern===e.pattern&&t.min===e.min&&t.max===e.max&&t.step===e.step:r}copy({state:t}){return{state:n(t)?this.copyInput(t):this.copyTextArea(t),renderedControl:null}}copyInput(t){const{type:e,pattern:n,min:r,max:a,step:i}=t;return{...this.copySharedState(t),type:e,pattern:n,min:r,max:a,step:i}}copyTextArea(t){return{...this.copySharedState(t),type:t.type}}copySharedState({value:t,required:e,minLength:n,maxLength:r}){return{value:t,required:e,minLength:n,maxLength:r}}}function n(t){return"textarea"!==t.type}export{e as TextFieldValidator};

package/build/utils/behaviors/validators/validator.d.ts

@@ -0,0 +1,97 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A class that computes and caches `ValidityStateFlags` for a component with
+ * a given `State` interface.
+ *
+ * Cached performance before computing validity is important since constraint
+ * validation must be checked frequently and synchronously when properties
+ * change.
+ *
+ * @template State The expected interface of properties relevant to constraint
+ *     validation.
+ */
+export declare abstract class Validator<State> {
+    /**
+     * The previous state, used to determine if state changed and validation needs
+     * to be re-computed.
+     */
+    private prevState?;
+    /**
+     * The current validity state and message. This is cached and returns if
+     * constraint validation state does not change.
+     */
+    private currentValidity;
+    private readonly getCurrentState;
+    /**
+     * Creates a new validator.
+     *
+     * @param getCurrentState A callback that returns the current state of
+     *     constraint validation-related properties.
+     */
+    constructor(getCurrentState: () => State);
+    /**
+     * Returns the current `ValidityStateFlags` and validation message for the
+     * validator.
+     *
+     * If the constraint validation state has not changed, this will return a
+     * cached result. This is important since `getValidity()` can be called
+     * frequently in response to synchronous property changes.
+     *
+     * @return The current validity and validation message.
+     */
+    getValidity(): IValidityAndMessage;
+    /**
+     * Computes the `ValidityStateFlags` and validation message for a given set
+     * of constraint validation properties.
+     *
+     * Implementations can use platform elements like `<input>` and `<select>` to
+     * sync state and compute validation along with i18n'd messages. This function
+     * may be expensive, and is only called when state changes.
+     *
+     * @param state The new state of constraint validation properties.
+     * @return An object containing a `validity` property with
+     *     `ValidityStateFlags` and a `validationMessage` property.
+     */
+    protected abstract computeValidity(state: State): IValidityAndMessage;
+    /**
+     * Checks if two states are equal. This is used to check against cached state
+     * to see if validity needs to be re-computed.
+     *
+     * @param prev The previous state.
+     * @param next The next state.
+     * @return True if the states are equal, or false if not.
+     */
+    protected abstract equals(prev: State, next: State): boolean;
+    /**
+     * Creates a copy of a state. This is used to cache state and check if it
+     * changes.
+     *
+     * Note: do NOT spread the {...state} to copy it. The actual state object is
+     * a web component, and trying to spread its getter/setter properties won't
+     * work.
+     *
+     * @param state The state to copy.
+     * @return A copy of the state.
+     */
+    protected abstract copy(state: State): State;
+}
+/**
+ * An object containing `ValidityStateFlags` and a corresponding validation
+ * message.
+ */
+export interface IValidityAndMessage {
+    /**
+     * Validity flags.
+     */
+    validity: ValidityStateFlags;
+    /**
+     * The validation message for the associated flags. It may not be an empty
+     * string if any of the validity flags are `true`.
+     */
+    validationMessage: string;
+}
+//# sourceMappingURL=validator.d.ts.map

package/build/utils/behaviors/validators/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../../src/utils/behaviors/validators/validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;GAUG;AACH,8BAAsB,SAAS,CAAC,KAAK;IACjC;;;OAGG;IACH,OAAO,CAAC,SAAS,CAAC,CAAO;IAEzB;;;OAGG;IACH,OAAO,CAAC,eAAe,CAGrB;IAEF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAa;IAE7C;;;;;OAKG;gBACS,eAAe,EAAE,MAAM,KAAK;IAIxC;;;;;;;;;OASG;IACH,WAAW,IAAI,mBAAmB;IA+BlC;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,QAAQ,CAAC,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,mBAAmB;IAErE;;;;;;;OAOG;IACH,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;IAE5D;;;;;;;;;;OAUG;IACH,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;CAC/C;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAChC;;OAEG;IACH,QAAQ,EAAE,kBAAkB,CAAA;IAE5B;;;OAGG;IACH,iBAAiB,EAAE,MAAM,CAAA;CAC5B"}

package/build/utils/behaviors/validators/validator.js

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class t{constructor(t){this.currentValidity={validity:{},validationMessage:""},this.getCurrentState=t}getValidity(){const t=this.getCurrentState();if(!(!this.prevState||!this.equals(this.prevState,t)))return this.currentValidity;const{validity:i,validationMessage:e}=this.computeValidity(t);return this.prevState=this.copy(t),this.currentValidity={validationMessage:e,validity:{badInput:i.badInput,customError:i.customError,patternMismatch:i.patternMismatch,rangeOverflow:i.rangeOverflow,rangeUnderflow:i.rangeUnderflow,stepMismatch:i.stepMismatch,tooLong:i.tooLong,tooShort:i.tooShort,typeMismatch:i.typeMismatch,valueMissing:i.valueMissing}},this.currentValidity}}export{t as Validator};

package/build/utils/controller/attachable-controller.d.ts

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * @link
+ * https://github.com/material-components/material-web/blob/main/internal/controller/attachable-controller.ts
+ */
+import { type ReactiveController, type ReactiveControllerHost } from 'lit';
+/**
+ * An element that can be attached to an associated controlling element.
+ */
+export interface IAttachable {
+    /**
+     * Reflects the value of the `for` attribute, which is the ID of the element's
+     * associated control.
+     *
+     * Use this when the elements's associated control is not its parent.
+     *
+     * To manually control an element, set its `for` attribute to `""`.
+     *
+     * @example
+     * ```html
+     * <div class="container">
+     *   <md-attachable for="interactive"></md-attachable>
+     *   <button id="interactive">Action</button>
+     * </div>
+     * ```
+     *
+     * @example
+     * ```html
+     * <button class="manually-controlled">
+     *   <md-attachable for=""></md-attachable>
+     * </button>
+     * ```
+     */
+    htmlFor: string | null;
+    /**
+     * Gets or sets the element that controls the visibility of the attachable
+     * element. It is one of:
+     *
+     * - The control referenced by the `for` attribute.
+     * - The control provided to `element.attach(control)`
+     * - The element's parent.
+     * - `null` if the element is not controlled.
+     */
+    control: HTMLElement | null;
+    /**
+     * Attaches the element to an interactive control.
+     *
+     * @param control The element that controls the attachable element.
+     */
+    attach(control: HTMLElement): void;
+    /**
+     * Detaches the element from its current control.
+     */
+    detach(): void;
+}
+/**
+ * A key to retrieve an `IAttachable` element's `AttachableController` from a
+ * global `MutationObserver`.
+ */
+declare const ATTACHABLE_CONTROLLER: unique symbol;
+/**
+ * The host of an `AttachableController`. The controller will add itself to
+ * the host so it can be retrieved in a global `MutationObserver`.
+ */
+export interface IAttachableControllerHost extends ReactiveControllerHost, HTMLElement {
+    [ATTACHABLE_CONTROLLER]?: AttachableController;
+}
+/**
+ * A controller that provides an implementation for `IAttachable` elements.
+ *
+ * @example
+ * ```ts
+ * class MyElement extends LitElement implements IAttachable {
+ *   get control() { return this.attachableController.control; }
+ *
+ *   private readonly attachableController = new AttachableController(
+ *     this,
+ *     (previousControl, newControl) => {
+ *       previousControl?.removeEventListener('click', this.handleClick);
+ *       newControl?.addEventListener('click', this.handleClick);
+ *     }
+ *   );
+ *
+ *   // Implement remaining `IAttachable` properties/methods that call the
+ *   // controller's properties/methods.
+ * }
+ * ```
+ */
+export declare class AttachableController implements ReactiveController, IAttachable {
+    private readonly host;
+    private readonly onControlChange;
+    get htmlFor(): string | null;
+    set htmlFor(htmlFor: string | null);
+    get control(): HTMLElement | null;
+    set control(control: HTMLElement | null);
+    private currentControl;
+    /**
+     * Creates a new controller for an `IAttachable` element.
+     *
+     * @param host The `IAttachable` element.
+     * @param onControlChange A callback with two parameters for the previous and
+     *     next control. An `IAttachable` element may perform setup or teardown
+     *     logic whenever the control changes.
+     */
+    constructor(host: IAttachableControllerHost, onControlChange: (prev: HTMLElement | null, next: HTMLElement | null) => void);
+    attach(control: HTMLElement): void;
+    detach(): void;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    private setCurrentControl;
+}
+export {};
+//# sourceMappingURL=attachable-controller.d.ts.map

package/build/utils/controller/attachable-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachable-controller.d.ts","sourceRoot":"","sources":["../../../src/utils/controller/attachable-controller.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAY,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAErF;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvB;;;;;;;;OAQG;IACH,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IAE5B;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IAEnC;;OAEG;IACH,MAAM,IAAI,IAAI,CAAC;CAClB;AAED;;;GAGG;AACH,QAAA,MAAM,qBAAqB,eAAiC,CAAC;AAE7D;;;GAGG;AACH,MAAM,WAAW,yBAA0B,SAAQ,sBAAsB,EAAE,WAAW;IAClF,CAAC,qBAAqB,CAAC,CAAC,EAAE,oBAAoB,CAAC;CAClD;AAqBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,oBAAqB,YAAW,kBAAkB,EAAE,WAAW;IACxE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA2B;IAChD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAGvB;IAET,IAAW,OAAO,IAIU,MAAM,GAAG,IAAI,CAFxC;IAED,IAAW,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,EAMxC;IAED,IAAW,OAAO,IAaU,WAAW,GAAG,IAAI,CAD7C;IACD,IAAW,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,EAM7C;IAED,OAAO,CAAC,cAAc,CAA4B;IAElD;;;;;;;OAOG;gBAEC,IAAI,EAAE,yBAAyB,EAC/B,eAAe,EAAE,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI;IAU1E,MAAM,CAAC,OAAO,EAAE,WAAW;IAW3B,MAAM;IAON,aAAa;IAIb,gBAAgB;IAIvB,OAAO,CAAC,iBAAiB;CAI5B"}

package/build/utils/controller/attachable-controller.js

@@ -0,0 +1,9 @@
+import"../../lit-element-Bf8D1KRw.js";
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * @link
+ * https://github.com/material-components/material-web/blob/main/internal/controller/attachable-controller.ts
+ */const t=Symbol("attachableController");let o;o=new MutationObserver(o=>{for(const r of o)r.target[t]?.hostConnected()});class r{get htmlFor(){return this.host.getAttribute("for")}set htmlFor(t){null===t?this.host.removeAttribute("for"):this.host.setAttribute("for",t)}get control(){return this.host.hasAttribute("for")?this.htmlFor&&this.host.isConnected?this.host.getRootNode().querySelector(`#${this.htmlFor}`):null:this.currentControl||this.host.parentElement}set control(t){t?this.attach(t):this.detach()}constructor(r,e){this.currentControl=null,this.host=r,this.onControlChange=e,r.addController(this),r[t]=this,o?.observe(r,{attributeFilter:["for"]})}attach(t){t!==this.currentControl&&(this.setCurrentControl(t),this.host.removeAttribute("for"))}detach(){this.setCurrentControl(null),this.host.setAttribute("for","")}hostConnected(){this.setCurrentControl(this.control)}hostDisconnected(){this.setCurrentControl(null)}setCurrentControl(t){this.onControlChange(this.currentControl,t),this.currentControl=t}}export{r as AttachableController};

package/build/utils/controller/form-submitter.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ReactiveElement } from 'lit';
+import { type WithElementInternals } from '../behaviors/element-internals';
+/**
+ * A string indicating the form submission behavior of the element.
+ *
+ * - submit: The element submits the form. This is the default value if the
+ * attribute is not specified, or if it is dynamically changed to an empty or
+ * invalid value.
+ * - reset: The element resets the form.
+ * - button: The element does nothing.
+ */
+export type FormSubmitterType = 'button' | 'submit' | 'reset';
+/**
+ * An element that can submit or reset a `<form>`, similar to
+ * `<button type="submit">`.
+ */
+export interface FormSubmitter extends ReactiveElement, WithElementInternals {
+    /**
+     * A string indicating the form submission behavior of the element.
+     *
+     * - submit: The element submits the form. This is the default value if the
+     * attribute is not specified, or if it is dynamically changed to an empty or
+     * invalid value.
+     * - reset: The element resets the form.
+     * - button: The element does nothing.
+     */
+    type: FormSubmitterType;
+    /**
+     * The HTML name to use in form submission. When combined with a `value`, the
+     * submitting button's name/value will be added to the form.
+     *
+     * Names must reflect to a `name` attribute for form integration.
+     */
+    name: string;
+    /**
+     * The value of the button. When combined with a `name`, the submitting
+     * button's name/value will be added to the form.
+     */
+    value: string;
+}
+type FormSubmitterConstructor = (new () => FormSubmitter) | (abstract new () => FormSubmitter);
+/**
+ * Sets up an element's constructor to enable form submission. The element
+ * instance should be form associated and have a `type` property.
+ *
+ * A click listener is added to each element instance. If the click is not
+ * default prevented, it will submit the element's form, if any.
+ *
+ * @example
+ * ```ts
+ * class MyElement extends mixinElementInternals(LitElement) {
+ *   static {
+ *     setupFormSubmitter(MyElement);
+ *   }
+ *
+ *   static formAssociated = true;
+ *
+ *   type: FormSubmitterType = 'submit';
+ * }
+ * ```
+ *
+ * @param ctor The form submitter element's constructor.
+ */
+export declare function setupFormSubmitter(ctor: FormSubmitterConstructor): void;
+export {};
+//# sourceMappingURL=form-submitter.d.ts.map

package/build/utils/controller/form-submitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-submitter.d.ts","sourceRoot":"","sources":["../../../src/utils/controller/form-submitter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAY,eAAe,EAAE,MAAM,KAAK,CAAA;AAC/C,OAAO,EAAE,KAAK,oBAAoB,EAAa,MAAM,gCAAgC,CAAA;AAErF;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAA;AAE7D;;;GAGG;AACH,MAAM,WAAW,aAAc,SAAQ,eAAe,EAAE,oBAAoB;IACxE;;;;;;;;OAQG;IACH,IAAI,EAAE,iBAAiB,CAAA;IAEvB;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAA;IAEZ;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAA;CAChB;AAED,KAAK,wBAAwB,GACvB,CAAC,UAAU,aAAa,CAAC,GACzB,CAAC,QAAQ,WAAW,aAAa,CAAC,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,wBAAwB,QAgDhE"}

package/build/utils/controller/form-submitter.js

@@ -0,0 +1,6 @@
+import"../../lit-element-Bf8D1KRw.js";import{internals as e}from"../behaviors/element-internals.js";
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */function t(t){t.addInitializer(t=>{const r=t;r.addEventListener("click",async t=>{const{type:n,[e]:i}=r,{form:s}=i;s&&"button"!==n&&(await new Promise(e=>{setTimeout(e)}),t.defaultPrevented||("reset"!==n?(s.addEventListener("submit",e=>{Object.defineProperty(e,"submitter",{configurable:!0,enumerable:!0,get:()=>r})},{capture:!0,once:!0}),i.setFormValue(r.value),s.requestSubmit()):s.reset()))})})}export{t as setupFormSubmitter};

package/build/utils/event/dispatch-hook.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Add a hook for an event that is called after the event is dispatched and
+ * propagates to other event listeners.
+ *
+ * This is useful for behaviors that need to check if an event is canceled.
+ *
+ * The callback is invoked synchronously, which allows for better integration
+ * with synchronous platform APIs (like `<form>` or `<label>` clicking).
+ *
+ * Note: `setupDispatchHooks()` must be called on the element before adding any
+ * other event listeners. Call it in the constructor of an element or
+ * controller.
+ *
+ * @example
+ * ```ts
+ * class MyControl extends LitElement {
+ *   constructor() {
+ *     super();
+ *     setupDispatchHooks(this, 'click');
+ *     this.addEventListener('click', event => {
+ *       afterDispatch(event, () => {
+ *         if (event.defaultPrevented) {
+ *           return
+ *         }
+ *
+ *         // ... perform logic
+ *       });
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * class MyController implements ReactiveController {
+ *   constructor(host: ReactiveElement) {
+ *     // setupDispatchHooks() may be called multiple times for the same
+ *     // element and events, making it safe for multiple controllers to use it.
+ *     setupDispatchHooks(host, 'click');
+ *     host.addEventListener('click', event => {
+ *       afterDispatch(event, () => {
+ *         if (event.defaultPrevented) {
+ *           return;
+ *         }
+ *
+ *         // ... perform logic
+ *       });
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @param event The event to add a hook to.
+ * @param callback A hook that is called after the event finishes dispatching.
+ */
+export declare function afterDispatch(event: Event, callback: () => void): void;
+/**
+ * Sets up an element to add dispatch hooks to given event types. This must be
+ * called before adding any event listeners that need to use dispatch hooks
+ * like `afterDispatch()`.
+ *
+ * This function is safe to call multiple times with the same element or event
+ * types. Call it in the constructor of elements, mixins, and controllers to
+ * ensure it is set up before external listeners.
+ *
+ * @example
+ * ```ts
+ * class MyControl extends LitElement {
+ *   constructor() {
+ *     super();
+ *     setupDispatchHooks(this, 'click');
+ *     this.addEventListener('click', this.listenerUsingAfterDispatch);
+ *   }
+ * }
+ * ```
+ *
+ * @param element The element to set up event dispatch hooks for.
+ * @param eventTypes The event types to add dispatch hooks to.
+ */
+export declare function setupDispatchHooks(element: Element, ...eventTypes: [string, ...string[]]): void;
+//# sourceMappingURL=dispatch-hook.d.ts.map

package/build/utils/event/dispatch-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-hook.d.ts","sourceRoot":"","sources":["../../../src/utils/event/dispatch-hook.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAcH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,IAAI,QAO/D;AASD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,GAAG,UAAU,EAAE,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,QA6DrC"}

package/build/utils/event/dispatch-hook.js

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const t=Symbol("dispatchHooks");function e(e,n){const o=e[t];if(!o)throw new Error(`'${e.type}' event needs setupDispatchHooks().`);o.addEventListener("after",n)}const n=new WeakMap;function o(e,...o){let s=n.get(e);s||(s=new Set,n.set(e,s));for(const n of o){if(s.has(n))continue;let o=!1;e.addEventListener(n,n=>{if(o)return;n.stopImmediatePropagation();const s=Reflect.construct(n.constructor,[n.type,n]),c=new EventTarget;s[t]=c,o=!0;const r=e.dispatchEvent(s);o=!1,r||n.preventDefault(),c.dispatchEvent(new Event("after"))},{capture:!0}),s.add(n)}}export{e as afterDispatch,o as setupDispatchHooks};