@sandlada/mdc 0.1.0-20250907.a

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-Ho-VPzO1.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-Ho-VPzO1.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/controller/selection-controller.d.ts

@@ -0,0 +1,24 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+export type TSelectableElement = HTMLElement & {
+    checked: boolean;
+    disabled?: boolean;
+};
+export type TSelectionController = {};
+export declare class SelectionController implements TSelectionController, ReactiveController {
+    private readonly host;
+    private root;
+    multiple: boolean;
+    constructor(host: TSelectableElement & ReactiveControllerHost, options?: Partial<{
+        multiple: boolean;
+    }>);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    get controls(): Array<TSelectableElement>;
+    private updateTabIndices;
+    readonly handleCheckedChange: () => void;
+    readonly handleFocus: () => void;
+    readonly handleKeyDown: (e: KeyboardEvent) => void;
+    readonly focus: (control: TSelectableElement) => void;
+    readonly select: (control: TSelectableElement) => void;
+}
+//# sourceMappingURL=selection-controller.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selection-controller.d.ts","sourceRoot":"","sources":["../../../src/utils/controller/selection-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,KAAK,CAAA;AAErE,MAAM,MAAM,kBAAkB,GAAG,WAAW,GAAG;IAC3C,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG,EAElC,CAAA;AAED,qBAAa,mBAAoB,YAAW,oBAAoB,EAAE,kBAAkB;IAEhF,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA6C;IAClE,OAAO,CAAC,IAAI,CAAqC;IAE1C,QAAQ,EAAE,OAAO,CAAQ;gBAG5B,IAAI,EAAE,kBAAkB,GAAG,sBAAsB,EACjD,OAAO,CAAC,EAAE,OAAO,CAAC;QACd,QAAQ,EAAE,OAAO,CAAA;KACpB,CAAC;IAYN,aAAa,IAAI,IAAI;IAkBd,gBAAgB;IAYvB,IAAW,QAAQ,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAK/C;IAED,OAAO,CAAC,gBAAgB;IAoBxB,SAAgB,mBAAmB,aASlC;IAED,SAAgB,WAAW,aAE1B;IAED,SAAgB,aAAa,GAAI,GAAG,aAAa,UAwChD;IAED,SAAgB,KAAK,GAAI,SAAS,kBAAkB,UAEnD;IAED,SAAgB,MAAM,GAAI,SAAS,kBAAkB,UASpD;CAEJ"}

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

@@ -0,0 +1 @@
+class t{constructor(t,e){if(this.root=null,this.multiple=!1,this.handleCheckedChange=()=>{if(this.host.checked&&!this.multiple)for(const t of this.controls)t!==this.host&&(t.checked=!1)},this.handleFocus=()=>{this.updateTabIndices()},this.handleKeyDown=t=>{const{key:e}=t,s={isArrowKey:e.startsWith("Arrow"),isHomeEnd:"Home"===e||"End"===e,isActivationKey:" "===e,isVertical:"ArrowDown"===e||"ArrowUp"===e,isForward:"ArrowDown"===e||"ArrowRight"===e};if(!Object.values(s).includes(!0))return;const o=this.controls.filter(t=>!t?.disabled);if(t.preventDefault(),s.isActivationKey)return this.host.checked=!this.host.checked,void this.handleCheckedChange();const i=o.indexOf(this.host);let h=i;s.isArrowKey?h=s.isForward?(i+1)%o.length:(i-1+o.length)%o.length:s.isHomeEnd&&(h="Home"===e?0:o.length-1);const n=o[h];n&&(this.focus(n),this.select(n),this.updateTabIndices())},this.focus=t=>{t.focus()},this.select=t=>{this.multiple||t.checked||(t.checked=!0,this.handleCheckedChange())},this.host=t,e)for(const[t,s]of Object.entries(e))this[t]=s}hostConnected(){this.root=this.host.getRootNode(),this.host.addEventListener("keydown",this.handleKeyDown),this.host.addEventListener("focus",this.handleFocus),this.host.checked&&this.handleCheckedChange(),requestAnimationFrame(()=>{this.updateTabIndices()})}hostDisconnected(){this.host.removeEventListener("keydown",this.handleKeyDown),this.host.removeEventListener("focus",this.handleFocus),this.root=null,requestAnimationFrame(()=>{this.updateTabIndices()})}get controls(){const t=this.host.getAttribute("name");if(!t||!this.root||!this.host.isConnected)return[this.host];const e=this.root.querySelectorAll(`[name="${t}"]`);return Array.from(e)}updateTabIndices(){const t=this.controls,e=t.find(t=>t.checked),s=this.root?.activeElement,o=t.includes(s)?s:e??t.find(t=>!t?.disabled);for(const e of t)e.tabIndex=e===o?0:-1}}export{t as SelectionController};

package/build/utils/controller/single-selection-controller.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2025 Kai-Orion & Sandlada
+ * SPDX-License-Identifier: MIT
+ */
+import { type ReactiveController } from 'lit';
+export interface ISingleSelectionElement extends HTMLElement {
+    checked: boolean;
+}
+export interface ISingleSelectionController {
+    controls: [ISingleSelectionElement, ...Array<ISingleSelectionElement>];
+    handleCheckedChange: () => void;
+}
+/**
+ * @deprecated
+ * Because the "single selection" operation logic of SingleSelectionController
+ * has limitations, please use SelectionController instead.
+ */
+export declare class SingleSelectionController implements ReactiveController, ISingleSelectionController {
+    get controls(): [ISingleSelectionElement, ...Array<ISingleSelectionElement>];
+    private focused;
+    private root;
+    private readonly host;
+    constructor(host: ISingleSelectionElement);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /**
+     * Should be called whenever the host's `checked` property changes
+     * synchronously.
+     */
+    handleCheckedChange(): void;
+    private readonly handleFocusIn;
+    private readonly handleFocusOut;
+    private uncheckSiblings;
+    /**
+     * Updates the `tabindex` of the host and its siblings.
+     */
+    private updateTabIndices;
+    /**
+     * Handles arrow key events from the host. Using the arrow keys will
+     * select and check the next or previous sibling with the host's
+     * `name` attribute.
+     */
+    private readonly handleKeyDown;
+}
+//# sourceMappingURL=single-selection-controller.d.ts.map

package/build/utils/controller/single-selection-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-selection-controller.d.ts","sourceRoot":"","sources":["../../../src/utils/controller/single-selection-controller.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,KAAK,CAAA;AAG7C,MAAM,WAAW,uBAAwB,SAAQ,WAAW;IACxD,OAAO,EAAE,OAAO,CAAA;CACnB;AAED,MAAM,WAAW,0BAA0B;IACvC,QAAQ,EAAE,CAAC,uBAAuB,EAAE,GAAG,KAAK,CAAC,uBAAuB,CAAC,CAAC,CAAA;IACtE,mBAAmB,EAAE,MAAM,IAAI,CAAA;CAClC;AAED;;;;GAIG;AACH,qBAAa,yBAA0B,YAAW,kBAAkB,EAAE,0BAA0B;IAE5F,IAAW,QAAQ,IAAI,CAAC,uBAAuB,EAAE,GAAG,KAAK,CAAC,uBAAuB,CAAC,CAAC,CAOlF;IAED,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,IAAI,CAA0B;IACtC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAyB;gBAElC,IAAI,EAAE,uBAAuB;IAIlC,aAAa;IAeb,gBAAgB;IASvB;;;OAGG;IACI,mBAAmB;IAS1B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAG7B;IAED,OAAO,CAAC,QAAQ,CAAC,cAAc,CAG9B;IAED,OAAO,CAAC,eAAe;IAQvB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAwBxB;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAqE7B;CACJ"}

package/build/utils/controller/single-selection-controller.js

@@ -0,0 +1,6 @@
+import"../../lit-element-Ho-VPzO1.js";
+/**
+ * @license
+ * Copyright 2025 Kai-Orion & Sandlada
+ * SPDX-License-Identifier: MIT
+ */class t{get controls(){const t=this.host.getAttribute("name");return t&&this.root&&this.host.isConnected?Array.from(this.root.querySelectorAll(`[name="${t}"]`)):[this.host]}constructor(t){this.focused=!1,this.root=null,this.handleFocusIn=()=>{this.focused=!0,this.updateTabIndices()},this.handleFocusOut=()=>{this.focused=!1,this.updateTabIndices()},this.handleKeyDown=t=>{const e="ArrowDown"===t.key,s="ArrowUp"===t.key,o="ArrowLeft"===t.key,h="ArrowRight"===t.key;if(!(o||h||e||s))return;const n=this.controls;if(!n.length)return;t.preventDefault();const i="rtl"===getComputedStyle(this.host).direction?o||e:h||e,c=n.indexOf(this.host);let d=i?c+1:c-1;for(;d!==c;){d>=n.length?d=0:d<0&&(d=n.length-1);const t=n[d];if(!t.hasAttribute("disabled")){for(const e of n)e!==t&&(e.tabIndex=-1,e.blur());t.checked=!0,t.tabIndex=0,t.focus();break}i?d++:d--}},this.host=t}hostConnected(){this.root=this.host.getRootNode(),this.host.addEventListener("keydown",this.handleKeyDown),this.host.addEventListener("focusin",this.handleFocusIn),this.host.addEventListener("focusout",this.handleFocusOut),this.host.checked&&this.uncheckSiblings(),this.updateTabIndices()}hostDisconnected(){this.host.removeEventListener("keydown",this.handleKeyDown),this.host.removeEventListener("focusin",this.handleFocusIn),this.host.removeEventListener("focusout",this.handleFocusOut),this.updateTabIndices(),this.root=null}handleCheckedChange(){this.host.checked&&(this.uncheckSiblings(),this.updateTabIndices())}uncheckSiblings(){for(const t of this.controls)t!==this.host&&(t.checked=!1)}updateTabIndices(){const t=this.controls,e=t.find(t=>t.checked);if(e||this.focused){const s=e||this.host;s.tabIndex=0;for(const e of t)e!==s&&(e.tabIndex=-1);return}for(const e of t)e.tabIndex=0}}export{t as SingleSelectionController};

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};

package/build/utils/event/form-label-activation.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Dispatches a click event to the given element that triggers a native action,
+ * but is not composed and therefore is not seen outside the element.
+ *
+ * This is useful for responding to an external click event on the host element
+ * that should trigger an internal action like a button click.
+ *
+ * Note, a helper is provided because setting this up correctly is a bit tricky.
+ * In particular, calling `click` on an element creates a composed event, which
+ * is not desirable, and a manually dispatched event must specifically be a
+ * `MouseEvent` to trigger a native action.
+ *
+ * @example
+ * hostClickListener = (event: MouseEvent) {
+ *   if (isActivationClick(event)) {
+ *     this.dispatchActivationClick(this.buttonElement);
+ *   }
+ * }
+ *
+ */
+export declare function dispatchActivationClick(element: HTMLElement): MouseEvent;
+/**
+ * Returns true if the click event should trigger an activation behavior. The
+ * behavior is defined by the element and is whatever it should do when
+ * clicked.
+ *
+ * Typically when an element needs to handle a click, the click is generated
+ * from within the element and an event listener within the element implements
+ * the needed behavior; however, it's possible to fire a click directly
+ * at the element that the element should handle. This method helps
+ * distinguish these "external" clicks.
+ *
+ * An "external" click can be triggered in a number of ways: via a click
+ * on an associated label for a form  associated element, calling
+ * `element.click()`, or calling
+ * `element.dispatchEvent(new MouseEvent('click', ...))`.
+ *
+ * Also works around Firefox issue
+ * https://bugzilla.mozilla.org/show_bug.cgi?id=1804576 by squelching
+ * events for a microtask after called.
+ *
+ * @example
+ * hostClickListener = (event: MouseEvent) {
+ *   if (isActivationClick(event)) {
+ *     this.dispatchActivationClick(this.buttonElement);
+ *   }
+ * }
+ *
+ */
+export declare function isActivationClick(event: Event): boolean;
+//# sourceMappingURL=form-label-activation.d.ts.map

package/build/utils/event/form-label-activation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-label-activation.d.ts","sourceRoot":"","sources":["../../../src/utils/event/form-label-activation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,WAAW,cAI3D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,WAgB7C"}

package/build/utils/event/form-label-activation.js

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function t(t){const e=new MouseEvent("click",{bubbles:!0});return t.dispatchEvent(e),e}function e(t){return t.currentTarget===t.target&&(t.composedPath()[0]===t.target&&(!t.target.disabled&&!function(t){const e=n;e&&(t.preventDefault(),t.stopImmediatePropagation());return async function(){n=!0,await null,n=!1}(),e}(t)))}let n=!1;export{t as dispatchActivationClick,e as isActivationClick};

package/build/utils/event/redispatch-event.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Re-dispatches an event from the provided element.
+ *
+ * This function is useful for forwarding non-composed events, such as `change`
+ * events.
+ *
+ * @example
+ * class MyInput extends LitElement {
+ *   render() {
+ *     return html`<input @change=${this.redispatchEvent}>`;
+ *   }
+ *
+ *   protected redispatchEvent(event: Event) {
+ *     redispatchEvent(this, event);
+ *   }
+ * }
+ *
+ * @param element The element to dispatch the event from.
+ * @param event The event to re-dispatch.
+ * @return Whether or not the event was dispatched (if cancelable).
+ */
+export declare function redispatchEvent(element: Element, event: Event): boolean;
+//# sourceMappingURL=redispatch-event.d.ts.map

package/build/utils/event/redispatch-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redispatch-event.d.ts","sourceRoot":"","sources":["../../../src/utils/event/redispatch-event.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,WAkB7D"}

package/build/utils/event/redispatch-event.js

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function t(t,o){!o.bubbles||t.shadowRoot&&!o.composed||o.stopPropagation();const e=new o.constructor(o.type,o),n=!t.dispatchEvent(e);return n&&o.preventDefault(),n}export{t as redispatchEvent};