@mhmo91/schmancy 0.10.15 → 0.10.17

package/types/src/button/button.d.ts

@@ -26,10 +26,19 @@ export declare class SchmancyButton extends SchmancyElement {
     };
     static formAssociated: boolean;
     private internals;
+    /**
+     * When this button is `type="submit"` and lives inside a <schmancy-form>,
+     * the observer mirrors the form's `aria-busy` attribute onto this button
+     * while a submit is in flight. Stays focusable; disabled buttons drop from
+     * the tab order and are unreachable to AT (WCAG 2.2 AA).
+     */
+    private _formBusyObserver?;
     constructor();
     /** Associated form, when placed inside a <form>. */
     get form(): HTMLFormElement | null;
     formDisabledCallback(disabled: boolean): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
     private nativeElement;
     private _ariaLabel;
     /**

package/types/src/button/button.test.d.ts

@@ -0,0 +1,3 @@
+import './button';
+import '../form/form';
+import '../form/fields/input/input';

package/types/src/{autocomplete → form/fields/autocomplete}/autocomplete.d.ts

@@ -1,10 +1,10 @@
-import { SchmancyElement } from '@mixins/index';
 import { InputSize, SchmancyInput } from '@schmancy/input';
-import '../chips/input-chip';
+import '../../../chips/input-chip';
 export type SchmancyAutocompleteChangeEvent = CustomEvent<{
     value: string | string[];
     values?: string[];
 }>;
+declare const SchmancyAutocomplete_base: import("@mixins/index").Constructor<import("@mixins/index").IFormFieldMixin> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
 /**
  * Autocomplete input component with filtering and multi-select support.
  *
@@ -16,20 +16,12 @@ export type SchmancyAutocompleteChangeEvent = CustomEvent<{
  * @prop {string} value - Selected value (single select mode)
  * @prop {string[]} values - Selected values (multi-select mode)
  */
-export default class SchmancyAutocomplete extends SchmancyElement {
-    static styles: import("lit").CSSResult[];
-    static formAssociated: boolean;
-    internals: ElementInternals | undefined;
-    constructor();
-    get form(): HTMLFormElement | null;
-    formResetCallback(): void;
-    formDisabledCallback(disabled: boolean): void;
+export default class SchmancyAutocomplete extends SchmancyAutocomplete_base {
+    /** Override mixin's resetForm with autocomplete-specific subject reset. */
+    resetForm(): void;
     _valueSet: boolean;
     _valuesSet: boolean;
-    required: boolean;
     placeholder: string;
-    label: string;
-    name: string;
     maxHeight: string;
     multi: boolean;
     description: string;
@@ -37,8 +29,6 @@ export default class SchmancyAutocomplete extends SchmancyElement {
     autocomplete: string;
     debounceMs: number;
     similarityThreshold: number;
-    error: boolean;
-    validationMessage: string;
     private readonly _a11yId;
     get values(): string[];
     set values(vals: string[]);
@@ -82,3 +72,4 @@ declare global {
         'schmancy-autocomplete': SchmancyAutocomplete;
     }
 }
+export {};

package/types/src/form/fields/checkbox/checkbox.d.ts

@@ -0,0 +1,47 @@
+import '@material/web/checkbox/checkbox.js';
+import { LitElement, type PropertyValues } from 'lit';
+export type schmancyCheckBoxChangeEvent = CustomEvent<{
+    value: boolean;
+}>;
+declare const SchmancyCheckboxElement_base: import("@mixins/index").Constructor<import("@mixins/index").IFormFieldMixin> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+/**
+ * @element schmancy-checkbox
+ * @slot - The label for the checkbox.
+ * @fires change - Event fired when the checkbox value changes.
+ */
+declare class SchmancyCheckboxElement extends SchmancyCheckboxElement_base {
+    protected static shadowRootOptions: {
+        delegatesFocus: boolean;
+        clonable?: boolean;
+        customElementRegistry?: CustomElementRegistry;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    /**
+     * Boolean checked state. Test contract: `cb.value = true` flips the state.
+     * The FormData *string* is read from `true-value` attribute (or `'on'`
+     * default) — kept separate from `value` to keep the boolean-state ergonomic.
+     */
+    value: boolean;
+    /** Alias for `value` for read-side ergonomics. */
+    get checked(): boolean;
+    set checked(val: boolean);
+    /**
+     * M3-aligned sizes: 24dp (xxs) → 32dp (xs) → 40dp (sm) → 48dp (md) → 56dp (lg).
+     */
+    size: 'xxs' | 'xs' | 'sm' | 'md' | 'lg';
+    private get _trueValue();
+    willUpdate(changed: PropertyValues): void;
+    /** Checkbox validity is `checked === true` when required. */
+    checkValidity(): boolean;
+    /** Emit only when checked. */
+    toFormEntries(): Array<[string, FormDataEntryValue]>;
+    render(): import("lit-html").TemplateResult<1>;
+}
+export { SchmancyCheckboxElement as SchmancyCheckbox };
+declare global {
+    interface HTMLElementTagNameMap {
+        'schmancy-checkbox': SchmancyCheckboxElement;
+    }
+}

package/types/src/{date-range → form/fields/date-range}/date-range.d.ts

@@ -1,17 +1,17 @@
-import { SchmancyElement } from '@mixins/index';
 import { PropertyValues } from 'lit';
 import './date-range-dialog';
 export type SchmancyDateRangeChangeEvent = CustomEvent<{
     dateFrom: string;
     dateTo: string;
 }>;
+declare const SchmancyDateRange_base: import("@mixins/index").Constructor<import("@mixins/index").IFormFieldMixin> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
 /**
  * A date range selector that supports presets and manual date input.
  *
  * @element schmancy-date-range
  * @fires change - Fired when the date range changes with dateFrom and dateTo values
  */
-export declare class SchmancyDateRange extends SchmancyElement {
+export declare class SchmancyDateRange extends SchmancyDateRange_base {
     type: 'date' | 'datetime-local';
     dateFrom: {
         label: string;
@@ -29,8 +29,6 @@ export declare class SchmancyDateRange extends SchmancyElement {
         dateTo: string;
     }>;
     format?: string;
-    disabled: boolean;
-    required: boolean;
     placeholder: string;
     clearable: boolean;
     step?: 'day' | 'week' | 'month' | 'year' | number;
@@ -47,6 +45,25 @@ export declare class SchmancyDateRange extends SchmancyElement {
     connectedCallback(): void;
     private setupEventHandlers;
     updated(changedProps: PropertyValues): void;
+    willUpdate(changed: PropertyValues): void;
+    /**
+     * Date-range validity is `both dates non-empty` when required.
+     * (Order/range constraints are out of scope here — they belong to a
+     * domain-specific schema layer.)
+     */
+    checkValidity(): boolean;
+    /**
+     * Override — emit `${name}From` and `${name}To` flat-suffix entries (the
+     * plan's chosen multi-entry encoding; native to JS consumers without
+     * server-side bracket parsing).
+     */
+    toFormEntries(): Array<[string, FormDataEntryValue]>;
+    /** `dirty` tracks the underlying date strings, not the wide-union value. */
+    private _dateFromDefault;
+    private _dateToDefault;
+    firstUpdated(changed: PropertyValues): void;
+    get dirty(): boolean;
+    resetForm(): void;
     private initPresetRanges;
     private getDateFormat;
     /**
@@ -85,3 +102,4 @@ export declare class SchmancyDateRange extends SchmancyElement {
     private announceToScreenReader;
     render(): import("lit-html").TemplateResult<1>;
 }
+export {};

package/types/src/form/fields/date-range/date-range.test.d.ts

@@ -0,0 +1 @@
+import './date-range';

package/types/src/form/fields/index.d.ts

@@ -0,0 +1,9 @@
+export * from './autocomplete';
+export * from './checkbox';
+export * from './date-range';
+export * from './input';
+export * from './radio-group';
+export * from './range';
+export * from './select';
+export * from './switch';
+export * from './textarea';

package/types/src/{input → form/fields/input}/input.d.ts

@@ -1,4 +1,4 @@
-import { LitElement, PropertyValueMap } from 'lit';
+import { LitElement } from 'lit';
 declare global {
     interface HTMLElementTagNameMap {
         'schmancy-input': SchmancyInput;
@@ -88,14 +88,6 @@ export default class SchmancyInput extends SchmancyInput_base {
      * - 'lg': Large size (56px)
      */
     size: InputSize;
-    /**
-     * Controls when validation should show.
-     * - 'always' - Always show validation
-     * - 'touched' - Only show after field has been focused and then blurred
-     * - 'dirty' - Only show after value has changed
-     * - 'submitted' - Only show after form submission
-     */
-    validateOn: 'always' | 'touched' | 'dirty' | 'submitted';
     /**
      * For datalist support
      */
@@ -106,16 +98,6 @@ export default class SchmancyInput extends SchmancyInput_base {
      * For integration with browser's autofill support
      */
     private isAutofilled;
-    /**
-     * Track user interaction state for validation
-     */
-    private touched;
-    private dirty;
-    private submitted;
-    /**
-     * Store the default value for reset behavior
-     */
-    private defaultValue;
     protected static shadowRootOptions: {
         delegatesFocus: boolean;
         clonable?: boolean;
@@ -124,51 +106,44 @@ export default class SchmancyInput extends SchmancyInput_base {
         serializable?: boolean;
         slotAssignment?: SlotAssignmentMode;
     };
-    private formResetObserver?;
     /**
      * If user did not provide an ID, auto-generate one so <label for="...">
      * and various aria-* attributes can reference it.
      */
-    protected willUpdate(changedProps: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
-    protected updated(changedProps: Map<string, unknown>): void;
-    /**
-     * Connect to the closest form element and set up form integration
-     */
+    protected willUpdate(changedProps: Map<PropertyKey, unknown>): void;
     connectedCallback(): void;
-    /**
-     * Set up form integration with ElementInternals
-     */
-    private setupFormIntegration;
     /**
      * Set up external label association for native HTML label support
      */
     private setupExternalLabelAssociation;
-    disconnectedCallback(): void;
     /**
-     * Reset the input to its default state
+     * Check validity. Folds in the inner native input's structured
+     * `ValidityState` flags (`typeMismatch`, `patternMismatch`, `tooShort`,
+     * `tooLong`, `rangeUnderflow`, `rangeOverflow`, `stepMismatch`, `badInput`)
+     * via `internals.setValidity` so consumers can target specific flags via
+     * `field.validity.<flag>` and `:state(value-missing|type-mismatch|…)`.
+     *
+     * The visual `error` flag is still gated by the mixin's `_shouldShowError()`.
      */
-    private resetToDefault;
     /**
-     * Determines if validation errors should be shown based on current state
-     * and validation strategy
+     * Re-run checkValidity AFTER render so the native inner input's `.value`
+     * binding has propagated. The mixin's willUpdate fires checkValidity too
+     * early — at that point native.validity still reflects the previous value.
      */
-    private shouldShowValidation;
+    protected updated(changedProps: Map<PropertyKey, unknown>): void;
     /**
-     * Validate input based on required, pattern, etc.
-     * This mimics native validation behavior
-     */
-    private validateInput;
-    /**
-     * Check validity without showing validation UI
+     * Pick the first matching `errorMessages` override for the failing flags.
+     * Order matches the natural priority of validity flags (valueMissing
+     * before more specific ones — empty trumps malformed).
      */
+    private _firstMatchingErrorMessage;
     checkValidity(): boolean;
     /**
-     * Show validation UI and check validity
+     * Show validation UI and check validity.
+     * Marks the field as submitted so the mixin's gate flips to "always show."
      */
     reportValidity(): boolean;
-    /**
-     * Set a custom validation error message
-     */
+    /** Set a custom validation error on both the inner input and the mixin. */
     setCustomValidity(message: string): void;
     firstUpdated(): void;
     /**

package/types/src/form/fields/input/input.test.d.ts

@@ -0,0 +1 @@
+import './input';

package/types/src/{radio-group → form/fields/radio-group}/radio-button.d.ts

@@ -1,5 +1,5 @@
 import { SchmancyElement } from '@mixins/index';
-declare const RadioButton_base: import("@mixins/index").Constructor<import("@mixins/index").IFormFieldMixin> & typeof SchmancyElement;
+declare const RadioButton_base: import("@mixins/index").Constructor<import("@mixins/formField.mixin").IFormFieldMixin> & typeof SchmancyElement;
 /**
  * Radio button component for use within radio groups.
  *

package/types/src/{radio-group → form/fields/radio-group}/radio-group.d.ts

@@ -6,7 +6,7 @@ export type SchmancyRadioGroupOption = {
 export type SchmancyRadioGroupChangeEvent = CustomEvent<{
     value: string;
 }>;
-declare const RadioGroup_base: import("@mixins/index").Constructor<import("@mixins/index").IFormFieldMixin> & typeof SchmancyElement;
+declare const RadioGroup_base: import("@mixins/index").Constructor<import("@mixins/formField.mixin").IFormFieldMixin> & typeof SchmancyElement;
 export declare class RadioGroup extends RadioGroup_base {
     static styles: import("lit").CSSResult[];
     label: string;

package/types/src/form/fields/range/range.d.ts

@@ -0,0 +1,28 @@
+import { type PropertyValues } from 'lit';
+export type SchmancyRangeChangeEvent = CustomEvent<{
+    value: number;
+}>;
+declare const SchmancyRange_base: import("@mixins/index").Constructor<import("@mixins/index").IFormFieldMixin> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+/**
+ * @element schmancy-range
+ * Range input (numeric slider).
+ * @fires change - Fires on value change with `{ value: number }`.
+ */
+export declare class SchmancyRange extends SchmancyRange_base {
+    min: number;
+    max: number;
+    step: number;
+    /** Numeric value — narrowed override of the mixin's wide value union. */
+    value: number;
+    private get progress();
+    willUpdate(changed: PropertyValues): void;
+    /** FormData contributes the value as a string (native range input convention). */
+    toFormEntries(): Array<[string, FormDataEntryValue]>;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'schmancy-range': SchmancyRange;
+    }
+}
+export {};

package/types/src/form/fields/range/range.test.d.ts

@@ -0,0 +1 @@
+import './range';

package/types/src/{select → form/fields/select}/select.d.ts

@@ -1,8 +1,8 @@
-import { SchmancyElement } from '@mixins/index';
 import { PropertyValues, TemplateResult } from 'lit';
 export type SchmancySelectChangeEvent = CustomEvent<{
     value: string | string[];
 }>;
+declare const SchmancySelect_base: import("@mixins/index").Constructor<import("@mixins/index").IFormFieldMixin> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
 /**
  * Select dropdown component with single and multi-select support.
  *
@@ -14,28 +14,19 @@ export type SchmancySelectChangeEvent = CustomEvent<{
  * @prop {string} value - Selected value (single select mode)
  * @prop {string[]} values - Selected values (multi-select mode)
  */
-export declare class SchmancySelect extends SchmancyElement {
+export declare class SchmancySelect extends SchmancySelect_base {
     static styles: import("lit").CSSResult[];
-    static formAssociated: boolean;
-    private internals?;
-    name: string | undefined;
-    required: boolean;
-    disabled: boolean;
     placeholder: string;
     get value(): string | string[];
     set value(val: string | string[]);
     get values(): string[];
     set values(vals: string[]);
     multi: boolean;
-    label: string;
-    hint: string;
-    validateOn: 'always' | 'touched' | 'dirty' | 'submitted';
     size: 'xxs' | 'xs' | 'sm' | 'md' | 'lg';
     private isOpen;
     private valueLabel;
     private isValid;
-    validationMessage: string;
-    private defaultValue;
+    private selectDefaultValue;
     private ul;
     private inputRef;
     private options;
@@ -44,24 +35,18 @@ export declare class SchmancySelect extends SchmancyElement {
     private _selectedValue$;
     private _selectedValues$;
     private _optionSelect$;
+    /**
+     * Tracks whether the user has actively interacted (clicked/typed/keyed
+     * inside the dropdown). Distinct from the mixin's `touched` (which fires on
+     * blur). Used to gate dropdown-positioning side-effects on user-driven
+     * actions versus programmatic state changes.
+     */
     _userInteracted: boolean;
-    private _touched;
-    private _dirty;
-    private _submitted;
     private _focusedOptionId;
-    private formSubmitHandler;
-    private formResetHandler;
-    constructor();
-    get form(): HTMLFormElement;
     connectedCallback(): void;
     disconnectedCallback(): void;
     firstUpdated(): void;
     updated(changedProps: PropertyValues): void;
-    /**
-     * Determines if validation errors should be shown based on current state
-     * and validation strategy
-     */
-    private shouldShowValidation;
     private syncSelection;
     private setupOptionsAccessibility;
     private positionDropdown;
@@ -74,7 +59,20 @@ export declare class SchmancySelect extends SchmancyElement {
     private _fireChangeEvent;
     checkValidity(): boolean;
     reportValidity(): boolean;
+    /**
+     * Multi-value-aware `toFormEntries`. Single-select emits one `[name,value]`;
+     * multi-select emits N entries with the same name (canonical FormData shape
+     * for repeated fields).
+     */
+    toFormEntries(): Array<[string, FormDataEntryValue]>;
     setCustomValidity(message: string): void;
+    /**
+     * Reset to the snapshot captured at connect time. Mixin's `resetForm`
+     * handles touched/submitted/error/validationMessage; the override layers on
+     * select-specific cleanup (value subjects, label, validity).
+     */
+    resetForm(): void;
+    /** Back-compat alias for callers that used the previous public API. */
     reset(): void;
     render(): TemplateResult;
 }
@@ -83,3 +81,4 @@ declare global {
         'schmancy-select': SchmancySelect;
     }
 }
+export {};

package/types/src/form/fields/switch/switch.d.ts

@@ -0,0 +1,57 @@
+import { LitElement, type PropertyValues } from 'lit';
+export type SchmancySwitchChangeEvent = CustomEvent<{
+    value: boolean;
+}>;
+declare const SchmancySwitch_base: import("@mixins/index").Constructor<import("@mixins/index").IFormFieldMixin> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+/**
+ * Binary on/off control. Form-associated, keyboard-accessible, semantically a
+ * switch (ARIA role="switch"). Distinct from `schmancy-checkbox`: a switch
+ * represents an immediate state change, a checkbox represents a selection in
+ * a form to be submitted.
+ *
+ * @element schmancy-switch
+ * @fires change - `CustomEvent<{ value: boolean }>` when the state changes.
+ * @csspart track - The background track.
+ * @csspart thumb - The moving thumb.
+ */
+export declare class SchmancySwitch extends SchmancySwitch_base {
+    protected static shadowRootOptions: {
+        delegatesFocus: boolean;
+        clonable?: boolean;
+        customElementRegistry?: CustomElementRegistry;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    /**
+     * The string written to FormData when the switch is on. Native
+     * `<input type=checkbox value="...">` semantics. Defaults to `'on'` to
+     * match HTML checkbox conventions.
+     */
+    value: string;
+    /** Boolean on/off state. Native `<input type=checkbox>.checked` semantics. */
+    checked: boolean;
+    /** Snapshot of `checked` at first render — drives the `dirty` override. */
+    private _checkedDefault;
+    firstUpdated(changed: PropertyValues): void;
+    /**
+     * Override the mixin's value-vs-default `dirty` getter — for switch the
+     * meaningful state is `checked`, not the FormData string.
+     */
+    get dirty(): boolean;
+    willUpdate(changed: PropertyValues): void;
+    /** Override — switch validity is `checked === true` when required. */
+    checkValidity(): boolean;
+    /** Override — emit only when the switch is on. */
+    toFormEntries(): Array<[string, FormDataEntryValue]>;
+    resetForm(): void;
+    private _toggle;
+    private _onKeydown;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'schmancy-switch': SchmancySwitch;
+    }
+}
+export {};

package/types/src/{textarea → form/fields/textarea}/textarea.d.ts

@@ -1,5 +1,5 @@
-import { type PropertyValues } from 'lit';
-import { SchmancyElement } from '@mixins/index';
+import { LitElement, type PropertyValues } from 'lit';
+declare const SchmancyTextarea_base: import("@mixins/index").Constructor<import("@mixins/index").IFormFieldMixin> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
 /**
  * Textarea component with auto-resize and form integration.
  *
@@ -12,8 +12,7 @@ import { SchmancyElement } from '@mixins/index';
  * @prop {number} rows - Number of visible text rows
  * @prop {number} maxlength - Maximum character length
  */
-export default class SchmancyTextarea extends SchmancyElement {
-    static styles: import("lit").CSSResult[];
+export default class SchmancyTextarea extends SchmancyTextarea_base {
     protected static shadowRootOptions: {
         delegatesFocus: boolean;
         clonable?: boolean;
@@ -22,26 +21,8 @@ export default class SchmancyTextarea extends SchmancyElement {
         serializable?: boolean;
         slotAssignment?: SlotAssignmentMode;
     };
-    static formAssociated: boolean;
-    internals: ElementInternals | undefined;
     textareaRef: import("lit-html/directives/ref").Ref<HTMLTextAreaElement>;
     private readonly _a11yId;
-    /**
-     * The label of the control.
-     * @attr
-     * @type {string} label
-     * @default ''
-     * @public
-     */
-    label: string;
-    /**
-     * The name of the control.
-     * @attr name
-     * @type {string} name
-     * @default 'name_' + Date.now()
-     * @public
-     */
-    name: string;
     /**
      * The placeholder of the control.
      * @attr placeholder
@@ -51,11 +32,9 @@ export default class SchmancyTextarea extends SchmancyElement {
      */
     placeholder: string;
     /**
-     * The value of the control.
+     * The value of the control. Narrowed from the mixin's wide union to the
+     * textarea-specific `string` type.
      * @attr {string} value - The value of the control.
-     * @type {string}
-     * @default ''
-     * @public
      */
     value: string;
     /**
@@ -125,27 +104,15 @@ export default class SchmancyTextarea extends SchmancyElement {
      * @public
      */
     dirname: string | undefined;
-    required: boolean;
-    disabled: boolean;
-    readonly: boolean;
     spellcheck: boolean;
     align: 'left' | 'center' | 'right';
     /**
      * The autofocus attribute of the control.
-     * @attr
-     * @type {boolean}
-     * @default false
-     * @public
      */
     autofocus: boolean;
     tabIndex: number;
     textareaElement: HTMLTextAreaElement;
-    hint: string | undefined;
-    error: boolean;
-    constructor();
-    protected willUpdate(changed: PropertyValues): void;
-    formResetCallback(): void;
-    formDisabledCallback(disabled: boolean): void;
+    willUpdate(changed: PropertyValues): void;
     firstUpdated(): void;
     get form(): HTMLFormElement;
     /** Checks for validity of the control and shows the browser message if it's invalid. */

package/types/src/form/fields/textarea/textarea.test.d.ts

@@ -0,0 +1 @@
+import './textarea';

package/types/src/form/form-state.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Form-level submit state — consumed by `<schmancy-form>` and any descendant
+ * (e.g. `<schmancy-button type="submit">` to drive its loading/aria-busy).
+ *
+ * `<schmancy-form>` wraps its render output in `<schmancy-context
+ * .provides=${[formSubmitState]}>` so each instance gets an isolated copy
+ * via the schmancy state library's resolveContextual mechanism. Reads of
+ * `formSubmitState.value` and writes via `formSubmitState.set(...)` inside
+ * the form's subtree resolve to the per-form copy automatically — no
+ * `@lit/context` plumbing in user code.
+ */
+export type FormError = {
+    message: string;
+    code?: string;
+};
+export type FormSubmitState = {
+    status: 'idle' | 'submitting' | 'success' | 'error';
+    error: FormError | null;
+    /** Increments on every submit attempt — RHF parity. */
+    submitCount: number;
+};
+export declare const formSubmitState: import("../state").SyncState<`${string}/${string}`, FormSubmitState, "memory"> & import("../state").ObjectAPI<FormSubmitState>;