@sandlada/mdc 0.1.0-20250907.a

package/build/utils/behaviors/constraint-validation.d.ts

@@ -0,0 +1,134 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { LitElement } from 'lit';
+import { type FormAssociated } from '../form/form-associated';
+import { type WithElementInternals } from './element-internals';
+import type { MixinBase, MixinReturn } from './mixin';
+import { Validator } from './validators/validator';
+/**
+ * A form associated element that provides constraint validation APIs.
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/HTML/Constraint_validation
+ */
+export interface ConstraintValidation extends FormAssociated {
+    /**
+     * Returns a ValidityState object that represents the validity states of the
+     * element.
+     *
+     * https://developer.mozilla.org/en-US/docs/Web/API/ValidityState
+     */
+    readonly validity: ValidityState;
+    /**
+     * Returns a validation error message or an empty string if the element is
+     * valid.
+     *
+     * https://developer.mozilla.org/en-US/docs/Web/API/ElementInternals/validationMessage
+     */
+    readonly validationMessage: string;
+    /**
+     * Returns whether an element will successfully validate based on forms
+     * validation rules and constraints.
+     *
+     * Disabled and readonly elements will not validate.
+     *
+     * https://developer.mozilla.org/en-US/docs/Web/API/ElementInternals/willValidate
+     */
+    readonly willValidate: boolean;
+    /**
+     * Checks the element's constraint validation and returns true if the element
+     * is valid or false if not.
+     *
+     * If invalid, this method will dispatch an `invalid` event.
+     *
+     * https://developer.mozilla.org/en-US/docs/Web/API/ElementInternals/checkValidity
+     *
+     * @return true if the element is valid, or false if not.
+     */
+    checkValidity(): boolean;
+    /**
+     * Checks the element's constraint validation and returns true if the element
+     * is valid or false if not.
+     *
+     * If invalid, this method will dispatch a cancelable `invalid` event. If not
+     * canceled, a the current `validationMessage` will be reported to the user.
+     *
+     * https://developer.mozilla.org/en-US/docs/Web/API/ElementInternals/reportValidity
+     *
+     * @return true if the element is valid, or false if not.
+     */
+    reportValidity(): boolean;
+    /**
+     * Sets the element's constraint validation error message. When set to a
+     * non-empty string, `validity.customError` will be true and
+     * `validationMessage` will display the provided error.
+     *
+     * Use this method to customize error messages reported.
+     *
+     * https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/setCustomValidity
+     *
+     * @param error The error message to display, or an empty string.
+     */
+    setCustomValidity(error: string): void;
+    /**
+     * Creates and returns a `Validator` that is used to compute and cache
+     * validity for the element.
+     *
+     * A validator that caches validity is important since constraint validation
+     * must be computed synchronously and frequently in response to constraint
+     * validation property changes.
+     */
+    [createValidator](): Validator<unknown>;
+    /**
+     * Returns shadow DOM child that is used as the anchor for the platform
+     * `reportValidity()` popup. This is often the root element or the inner
+     * focus-delegated element.
+     */
+    [getValidityAnchor](): HTMLElement | null;
+}
+/**
+ * A symbol property used to create a constraint validation `Validator`.
+ * Required for all `mixinConstraintValidation()` elements.
+ */
+export declare const createValidator: unique symbol;
+/**
+ * A symbol property used to return an anchor for constraint validation popups.
+ * Required for all `mixinConstraintValidation()` elements.
+ */
+export declare const getValidityAnchor: unique symbol;
+/**
+ * Mixes in constraint validation APIs for an element.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/HTML/Constraint_validation
+ * for more details.
+ *
+ * Implementations must provide a validator to cache and compute its validity,
+ * along with a shadow root element to anchor validation popups to.
+ *
+ * @example
+ * ```ts
+ * const baseClass = mixinConstraintValidation(
+ *   mixinFormAssociated(mixinElementInternals(LitElement))
+ * );
+ *
+ * class MyCheckbox extends baseClass {
+ *   \@property({type: Boolean}) checked = false;
+ *   \@property({type: Boolean}) required = false;
+ *
+ *   [createValidator]() {
+ *     return new CheckboxValidator(() => this);
+ *   }
+ *
+ *   [getValidityAnchor]() {
+ *     return this.renderRoot.querySelector('.root');
+ *   }
+ * }
+ * ```
+ *
+ * @param base The class to mix functionality into.
+ * @return The provided class with `ConstraintValidation` mixed in.
+ */
+export declare function mixinConstraintValidation<T extends MixinBase<LitElement & FormAssociated & WithElementInternals>>(base: T): MixinReturn<T, ConstraintValidation>;
+//# sourceMappingURL=constraint-validation.d.ts.map

package/build/utils/behaviors/constraint-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraint-validation.d.ts","sourceRoot":"","sources":["../../../src/utils/behaviors/constraint-validation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAY,UAAU,EAAiD,MAAM,KAAK,CAAA;AACzF,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC7D,OAAO,EAAa,KAAK,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAC1E,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAElD;;;;GAIG;AACH,MAAM,WAAW,oBAAqB,SAAQ,cAAc;IACxD;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAA;IAEhC;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;IAElC;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;IAE9B;;;;;;;;;OASG;IACH,aAAa,IAAI,OAAO,CAAA;IAExB;;;;;;;;;;OAUG;IACH,cAAc,IAAI,OAAO,CAAA;IAEzB;;;;;;;;;;OAUG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IAEtC;;;;;;;OAOG;IACH,CAAC,eAAe,CAAC,IAAI,SAAS,CAAC,OAAO,CAAC,CAAA;IAEvC;;;;OAIG;IACH,CAAC,iBAAiB,CAAC,IAAI,WAAW,GAAG,IAAI,CAAA;CAC5C;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,eAA4B,CAAA;AAExD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,eAA8B,CAAA;AAO5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,yBAAyB,CACrC,CAAC,SAAS,SAAS,CAAC,UAAU,GAAG,cAAc,GAAG,oBAAoB,CAAC,EACzE,IAAI,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAyG/C"}

package/build/utils/behaviors/constraint-validation.js

@@ -0,0 +1,6 @@
+import"../../lit-element-Ho-VPzO1.js";import"../../tslib.es6-CmLYFWVC.js";import{internals as t}from"./element-internals.js";
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */const i=Symbol("createValidator"),e=Symbol("getValidityAnchor"),s=Symbol("privateValidator"),r=Symbol("privateSyncValidity"),a=Symbol("privateCustomValidationMessage");function l(l){var o;class d extends l{constructor(){super(...arguments),this[o]=""}get validity(){return this[r](),this[t].validity}get validationMessage(){return this[r](),this[t].validationMessage}get willValidate(){return this[r](),this[t].willValidate}checkValidity(){return this[r](),this[t].checkValidity()}reportValidity(){return this[r](),this[t].reportValidity()}setCustomValidity(t){this[a]=t,this[r]()}requestUpdate(t,i,e){super.requestUpdate(t,i,e),this[r]()}firstUpdated(t){super.firstUpdated(t),this[r]()}[(o=a,r)](){this[s]||(this[s]=this[i]());const{validity:r,validationMessage:l}=this[s].getValidity(),o=!!this[a],d=this[a]||l;this[t].setValidity({...r,customError:o},d,this[e]()??void 0)}[i](){throw new Error("Implement [createValidator]")}[e](){throw new Error("Implement [getValidityAnchor]")}}return d}export{i as createValidator,e as getValidityAnchor,l as mixinConstraintValidation};

package/build/utils/behaviors/element-internals.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { LitElement } from 'lit';
+import { type MixinBase, type MixinReturn } from './mixin';
+/**
+ * A unique symbol used for protected access to an instance's
+ * `ElementInternals`.
+ *
+ * @example
+ * ```ts
+ * class MyElement extends mixinElementInternals(LitElement) {
+ *   constructor() {
+ *     super();
+ *     this[internals].role = 'button';
+ *   }
+ * }
+ * ```
+ */
+export declare const internals: unique symbol;
+/**
+ * An instance with an `internals` symbol property for the component's
+ * `ElementInternals`.
+ *
+ * Use this when protected access is needed for an instance's `ElementInternals`
+ * from other files. A unique symbol is used to access the internals.
+ */
+export interface WithElementInternals {
+    /**
+     * An instance's `ElementInternals`.
+     */
+    [internals]: ElementInternals;
+}
+/**
+ * Mixes in an attached `ElementInternals` instance.
+ *
+ * This mixin is only needed when other shared code needs access to a
+ * component's `ElementInternals`, such as form-associated mixins.
+ *
+ * @param base The class to mix functionality into.
+ * @return The provided class with `WithElementInternals` mixed in.
+ */
+export declare function mixinElementInternals<T extends MixinBase<LitElement>>(base: T): MixinReturn<T, WithElementInternals>;
+//# sourceMappingURL=element-internals.d.ts.map

package/build/utils/behaviors/element-internals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-internals.d.ts","sourceRoot":"","sources":["../../../src/utils/behaviors/element-internals.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,KAAK,CAAA;AAChC,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,eAAsB,CAAA;AAE5C;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACjC;;OAEG;IACH,CAAC,SAAS,CAAC,EAAE,gBAAgB,CAAA;CAChC;AAKD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,SAAS,CAAC,UAAU,CAAC,EACjE,IAAI,EAAE,CAAC,GACR,WAAW,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAmBtC"}

package/build/utils/behaviors/element-internals.js

@@ -0,0 +1,6 @@
+import"../../lit-element-Ho-VPzO1.js";
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */const t=Symbol("internals"),e=Symbol("privateInternals");function n(n){return class extends n{get[t](){return this[e]||(this[e]=this.attachInternals()),this[e]}}}export{t as internals,n as mixinElementInternals};

package/build/utils/behaviors/mixin.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The base class for a mixin with an optional expected base class type.
+ *
+ * @template ExpectedBase Optional expected base class type, such as
+ *     `LitElement`.
+ *
+ * @example
+ * ```ts
+ * interface Foo {
+ *   isFoo: boolean;
+ * }
+ *
+ * function mixinFoo<T extends MixinBase>(base: T): MixinReturn<T, Foo> {
+ *   // Mixins must be `abstract`
+ *   abstract class FooImpl extends base implements Foo {
+ *     isFoo = true;
+ *   }
+ *
+ *   return FooImpl;
+ * }
+ * ```
+ */
+export type MixinBase<ExpectedBase = object> = abstract new (...args: any[]) => ExpectedBase;
+/**
+ * The return value of a mixin.
+ *
+ * @template MixinBase The generic that extends `MixinBase` used for the mixin's
+ *     base class argument.
+ * @template MixinClass Optional interface of fuctionality that was mixed in.
+ *     Omit if no additional APIs were added (such as purely overriding base
+ *     class functionality).
+ *
+ * @example
+ * ```ts
+ * interface Foo {
+ *   isFoo: boolean;
+ * }
+ *
+ * // Mixins must be `abstract`
+ * function mixinFoo<T extends MixinBase>(base: T): MixinReturn<T, Foo> {
+ *   abstract class FooImpl extends base implements Foo {
+ *     isFoo = true;
+ *   }
+ *
+ *   return FooImpl;
+ * }
+ * ```
+ */
+export type MixinReturn<MixinBase, MixinClass = object> = (abstract new (...args: any[]) => MixinClass) & MixinBase;
+//# sourceMappingURL=mixin.d.ts.map

package/build/utils/behaviors/mixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixin.d.ts","sourceRoot":"","sources":["../../../src/utils/behaviors/mixin.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,SAAS,CAAC,YAAY,GAAG,MAAM,IAAI,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,YAAY,CAAA;AAE5F;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,WAAW,CAAC,SAAS,EAAE,UAAU,GAAG,MAAM,IAAI,CAAC,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,UAAU,CAAC,GAAG,SAAS,CAAA"}

package/build/utils/behaviors/mixin.js

@@ -0,0 +1 @@
+

package/build/utils/behaviors/validators/checkbox-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 checkbox.
+ */
+export interface ICheckboxState {
+    /**
+     * Whether the checkbox is checked.
+     */
+    readonly checked: boolean;
+    /**
+     * Whether the checkbox is required.
+     */
+    readonly required: boolean;
+}
+/**
+ * A validator that provides constraint validation that emulates
+ * `<input type="checkbox">` validation.
+ */
+export declare class CheckboxValidator extends Validator<ICheckboxState> {
+    private checkboxControl?;
+    protected computeValidity(state: ICheckboxState): {
+        validity: ValidityState;
+        validationMessage: string;
+    };
+    protected equals(prev: ICheckboxState, next: ICheckboxState): boolean;
+    protected copy({ checked, required }: ICheckboxState): {
+        checked: boolean;
+        required: boolean;
+    };
+}
+//# sourceMappingURL=checkbox-validator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkbox-validator.d.ts","sourceRoot":"","sources":["../../../../src/utils/behaviors/validators/checkbox-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IAEzB;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAC7B;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,SAAS,CAAC,cAAc,CAAC;IAC5D,OAAO,CAAC,eAAe,CAAC,CAAkB;cAEvB,eAAe,CAAC,KAAK,EAAE,cAAc;;;;cAerC,MAAM,CAAC,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,cAAc;cAIjD,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,cAAc;;;;CAGhE"}

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-Ho-VPzO1.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};