@mhmo91/schmancy 0.9.5 → 0.9.6

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

@@ -12,6 +12,7 @@ declare const SchmancyButton_base: CustomElementConstructor & import("@mixins/in
  * @slot - The default slot.
  * @slot prefix - The prefix slot.
  * @slot suffix - The suffix slot.
+ * @csspart base - The underlying native `<button>` (or `<a>` when `href` is set).
  */
 export declare class SchmancyButton extends SchmancyButton_base {
     protected static shadowRootOptions: {
@@ -22,6 +23,12 @@ export declare class SchmancyButton extends SchmancyButton_base {
         serializable?: boolean;
         slotAssignment?: SlotAssignmentMode;
     };
+    static formAssociated: boolean;
+    private internals;
+    constructor();
+    /** Associated form, when placed inside a <form>. */
+    get form(): HTMLFormElement | null;
+    formDisabledCallback(disabled: boolean): void;
     private nativeElement;
     private _ariaLabel;
     /**

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

@@ -4,7 +4,8 @@ declare const SchmnacyIconButton_base: CustomElementConstructor & import("@mixin
 /**
  * An icon button component.
  * @element schmancy-icon-button
- * @slot - The default slot.
+ * @slot - The default slot (usually an icon or glyph).
+ * @csspart base - The underlying native `<button>` (or `<a>` when `href` is set).
  */
 export declare class SchmnacyIconButton extends SchmnacyIconButton_base {
     protected static shadowRootOptions: {

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

@@ -20,6 +20,7 @@ declare class SchmancyCheckboxElement extends SchmancyCheckboxElement_base {
     };
     static formAssociated: boolean;
     internals: ElementInternals | undefined;
+    constructor();
     get form(): HTMLFormElement;
     /**
      * @attr {boolean} value - The value of the checkbox.
@@ -51,6 +52,11 @@ declare class SchmancyCheckboxElement extends SchmancyCheckboxElement_base {
      */
     label?: string;
     connectedCallback(): void;
+    updated(changed: Map<string, unknown>): void;
+    private _syncFormValue;
+    private _syncValidity;
+    checkValidity(): boolean;
+    reportValidity(): boolean;
     /**
      * @attr {xxs | xs | sm | md | lg } size - The size of the checkbox.
      * M3 aligned: 24dp (xxs) → 32dp (xs) → 40dp (sm) → 48dp (md) → 56dp (lg)

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

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

package/types/src/chips/filter-chip.d.ts

@@ -42,6 +42,9 @@ export declare class SchmancyFilterChip extends SchmancyFilterChip_base {
     internals: ElementInternals | undefined;
     get form(): HTMLFormElement;
     connectedCallback(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    formResetCallback(): void;
+    formDisabledCallback(disabled: boolean): void;
     private handleClick;
     private handleRemove;
     private handleKeyDown;

package/types/src/chips/input-chip.d.ts

@@ -60,6 +60,7 @@ export declare class SchmancyInputChip extends SchmancyInputChip_base {
     static formAssociated: boolean;
     internals: ElementInternals | undefined;
     get form(): HTMLFormElement;
+    protected updated(changed: Map<string, unknown>): void;
     connectedCallback(): void;
     private handleChipClick;
     private handleRemove;

package/types/src/date-range/date-range-helpers.d.ts

@@ -1,5 +1,4 @@
 import dayjs from 'dayjs';
-import { PresetUnit } from './date-range-presets';
 /**
  * Format a date range into a human-readable string
  */
@@ -14,14 +13,3 @@ export interface DateRangeType {
     isFullWeek: boolean;
 }
 export declare function detectDateRangeType(fromDate: dayjs.Dayjs, toDate: dayjs.Dayjs): DateRangeType;
-/**
- * Calculate the appropriate shift unit and amount for a date range
- */
-export declare function calculateShiftParams(fromDate: dayjs.Dayjs, toDate: dayjs.Dayjs, activePresetStep?: PresetUnit): {
-    unit: PresetUnit;
-    amount: number;
-};
-/**
- * Helper method to safely add/subtract quarter values
- */
-export declare function adjustQuarter(date: dayjs.Dayjs, amount: number, direction: 1 | -1): dayjs.Dayjs;

package/types/src/dialog/dialog.component.d.ts

@@ -76,6 +76,12 @@ export declare class SchmancyDialog extends SchmancyDialog_base {
      * Ref to the drag handle element for swipe gestures
      */
     private _dragHandleRef;
+    /**
+     * Stable per-instance id used for ARIA labelledby/describedby wiring
+     */
+    private readonly _a11yId;
+    private get _titleId();
+    private get _descId();
     /**
      * Return the dialog element for positioning/size measurement.
      * In content mode, returns the first slotted child (the actual component).

package/types/src/dropdown/dropdown-content.d.ts

@@ -3,7 +3,9 @@ declare const SchmancyDropdownContent_base: import("@mixins/index").Constructor<
  * Content container for the schmancy-dropdown component.
  *
  * @element schmancy-dropdown-content
- * @slot - Default slot for dropdown content
+ * @slot - Default slot for dropdown content.
+ * @csspart content - The inner wrapper element; style to override panel
+ *   backgrounds, shadows, padding, or borders without shadow-root piercing.
  */
 export declare class SchmancyDropdownContent extends SchmancyDropdownContent_base {
     /**

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

@@ -1,73 +1,22 @@
-import { LitElement } from 'lit';
-export interface FormElement extends HTMLElement {
-    name?: string;
-    value?: string;
-    disabled?: boolean;
-    type?: string;
-    defaultValue?: string;
-}
-export interface CheckableFormElement extends FormElement {
-    checked?: boolean;
-}
-export interface ValidatableFormElement extends FormElement {
-    reportValidity?: () => boolean;
-}
-export interface FormControlConfig {
-    tagName: string;
-    hasValue?: boolean;
-    hasChecked?: boolean;
-    canSubmit?: boolean;
-}
-declare const SchmancyFormV2_base: import("@mixins/index").Constructor<CustomElementConstructor> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+import SchmancyForm from './form';
+export type { FormElement, CheckableFormElement, ValidatableFormElement, FormControlConfig, FormEventMap, } from './form';
 /**
- * The form is a component used to collect user input from
- * interactive controls.
- *
- * @element sch-form
- *
- * @slot - Default slot for the form.
- *
- * @fires submit - Emitted when the form is submitted.
- * @fires reset - Emitted when the form is reset.
+ * @deprecated Use `<schmancy-form>` (`SchmancyForm`) from `./form`. The
+ * canonical form implementation now discovers fields via the `FormFieldMixin`
+ * brand + a small compat registry, which makes the `sch-form` tag redundant.
+ * This class remains as an alias so any existing `<sch-form>` markup or
+ * `SchmancyFormV2` imports continue to work, and will be removed in a future
+ * major.
  */
-export default class SchmancyFormV2 extends SchmancyFormV2_base {
-    private $disconnecting;
+export default class SchmancyFormV2 extends SchmancyForm {
     static readonly tagName = "sch-form";
-    private static formControlRegistry;
-    static registerFormControl(config: FormControlConfig): void;
-    private static hasValue;
-    private static hasChecked;
-    private static canSubmit;
-    protected static shadowRootOptions: {
-        mode: string;
-        delegatesFocus: boolean;
-        clonable?: boolean;
-        customElementRegistry?: CustomElementRegistry;
-        serializable?: boolean;
-        slotAssignment?: SlotAssignmentMode;
-    };
-    /** Specifies if form data validation should be skipped on submit.
-     * @attr novalidate
-     * @type {boolean}
-     * @public
+    /**
+     * @deprecated Use `SchmancyForm.registerControl()` instead.
      */
-    novalidate: boolean;
-    constructor();
-    disconnectedCallback(): void;
-    /** Submits the form. */
-    submit(): boolean;
-    /** Resets the form. */
-    reset(): void;
-    private getFormElements;
-    getFormData(): FormData;
-    /** Checks for validity of the form. */
-    reportValidity(): boolean;
-    private handleSubmitRequest;
-    protected render(): import("lit-html").TemplateResult<1>;
+    static registerFormControl: typeof SchmancyForm.registerControl;
 }
 declare global {
     interface HTMLElementTagNameMap {
         'sch-form': SchmancyFormV2;
     }
 }
-export {};

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

@@ -1,55 +1,73 @@
-import { LitElement } from 'lit';
-export interface FormEventMap {
-    submit: CustomEvent<FormData>;
-    reset: CustomEvent;
-}
-declare const SchmancyForm_base: import("@mixins/index").Constructor<CustomElementConstructor> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
 /**
- * The form is a component used to collect user input from
- * interactive controls.
+ * A thin ergonomic wrapper around a native `<form>` element. Its children are
+ * reparented into a `<form>` element in light DOM on connection, so:
  *
- * @element schmancy-form
+ * - Form-associated custom elements (FACE) resolve their `internals.form`
+ *   correctly via native DOM ancestry.
+ * - `new FormData(form)` collects values from every FACE + native control
+ *   without any manual walking.
+ * - `form.reset()` triggers `formResetCallback()` on every FACE.
+ * - `form.reportValidity()` runs native validation UI.
+ * - `<button type="submit">` and `<schmancy-button type="submit">` both
+ *   submit the form via the native submitter pipeline.
  *
- * @slot - Default slot for the form.
+ * This component exists only to translate the native `submit` / `reset`
+ * events into the Schmancy event shape (`detail: FormData`). All heavy
+ * lifting is the platform's.
  *
- * @fires submit - Emitted when the form is submitted.
- * @fires reset - Emitted when the form is reset.
+ * @element schmancy-form
+ * @fires submit - `CustomEvent<FormData>` emitted when the form is submitted.
+ * @fires reset - Emitted after the underlying form resets.
  */
-export default class SchmancyForm extends SchmancyForm_base {
-    private $disconnecting;
-    static readonly tagName = "schmancy-form";
-    protected static shadowRootOptions: {
-        mode: string;
-        delegatesFocus: boolean;
-        clonable?: boolean;
-        customElementRegistry?: CustomElementRegistry;
-        serializable?: boolean;
-        slotAssignment?: SlotAssignmentMode;
-    };
-    private _controlsWithChecked;
-    private _controlsWithValue;
-    private _controlsThatSubmit;
-    /** Specifies if form data validation should be skipped on submit.
-     * @attr novalidate
-     * @type {boolean}
-     * @public
+export default class SchmancyForm extends HTMLElement {
+    static readonly tagName: string;
+    private _form;
+    private _wrapped;
+    /** ElementInternals for `:state(invalid)` / `:state(submitting)` broadcasting. */
+    private readonly _internals;
+    /** Skip built-in constraint validation on submit. Mirrors `<form novalidate>`. */
+    get novalidate(): boolean;
+    set novalidate(value: boolean);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * On first connection, create the internal light-DOM `<form>` and move
+     * existing children into it. Re-entry is a no-op.
      */
-    novalidate: boolean;
-    constructor();
-    /** Submits the form. */
+    private ensureForm;
+    private _onSubmit;
+    private _onReset;
+    /** Programmatically submit via the native submitter pipeline. */
     submit(): boolean;
-    /** Resets the form. */
+    /** Programmatically reset via native `form.reset()`. */
     reset(): void;
-    private getFormElements;
-    getFormData(): FormData;
-    /** Checks for validity of the form. */
     reportValidity(): boolean;
-    private handleSubmitRequest;
-    protected render(): import("lit-html").TemplateResult<1>;
+    checkValidity(): boolean;
+    /** Snapshot of current form values. Equivalent to `new FormData(this.form)`. */
+    getFormData(): FormData;
+    /** The underlying `<form>` element (escape hatch for advanced integration). */
+    get form(): HTMLFormElement | null;
 }
 declare global {
     interface HTMLElementTagNameMap {
         'schmancy-form': SchmancyForm;
     }
 }
-export {};
+export interface FormElement extends HTMLElement {
+    name?: string;
+    value?: string;
+    disabled?: boolean;
+    type?: string;
+    defaultValue?: string;
+}
+export interface CheckableFormElement extends FormElement {
+    checked?: boolean;
+}
+export interface ValidatableFormElement extends FormElement {
+    reportValidity?: () => boolean;
+    checkValidity?: () => boolean;
+}
+export interface FormEventMap {
+    submit: CustomEvent<FormData>;
+    reset: CustomEvent;
+}

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

@@ -0,0 +1,4 @@
+import './form';
+import '../input/input';
+import '../button/button';
+import '../checkbox/checkbox';

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

@@ -1,2 +1,2 @@
-export * from './form-v2';
 export * from './form';
+export { default as SchmancyForm } from './form';

package/types/src/icons/icon.d.ts

@@ -18,6 +18,7 @@ declare const SchmancyIcon_base: import("@mixins/index").Constructor<CustomEleme
  * @cssprop --schmancy-icon-weight - Weight value for icon (100-700)
  * @cssprop --schmancy-icon-grade - Grade value for icon (-50-200)
  * @cssprop --schmancy-icon-opsz - Optical size (default: 24)
+ * @csspart icon - The inner `<span>` carrying the Material Symbols glyph.
  */
 export default class SchmancyIcon extends SchmancyIcon_base {
     private static fontsLoaded;

package/types/src/index.d.ts

@@ -67,3 +67,9 @@ export * from './typewriter';
 export * from './typography';
 export * from './utils';
 export * from './avatar';
+export * from './breadcrumb';
+export * from './kbd';
+export * from './skeleton';
+export * from './splash-screen';
+export * from './switch';
+export * from './visually-hidden';

package/types/src/kbd/index.d.ts

@@ -0,0 +1 @@
+export * from './kbd';

package/types/src/kbd/kbd.d.ts

@@ -0,0 +1,25 @@
+declare const SchmancyKbd_base: import("@mixins/index").Constructor<CustomElementConstructor> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+/**
+ * Renders a keyboard shortcut hint (e.g. `⌘ K`, `Ctrl+C`). Semantically a
+ * `<kbd>` element for screen readers; visually styled as a pressed key.
+ *
+ * Compose multiple instances for combinations:
+ * ```html
+ * <schmancy-kbd>⌘</schmancy-kbd> + <schmancy-kbd>K</schmancy-kbd>
+ * ```
+ *
+ * @element schmancy-kbd
+ * @slot - The key label (e.g. `⌘`, `Shift`, `K`).
+ * @attr size - 'sm' | 'md'. Default 'md'.
+ * @csspart base - The inner native `<kbd>` element.
+ */
+export declare class SchmancyKbd extends SchmancyKbd_base {
+    size: 'sm' | 'md';
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'schmancy-kbd': SchmancyKbd;
+    }
+}
+export {};

package/types/src/skeleton/index.d.ts

@@ -0,0 +1 @@
+export * from './skeleton';

package/types/src/skeleton/skeleton.d.ts

@@ -0,0 +1,27 @@
+declare const SchmancySkeleton_base: import("@mixins/index").Constructor<CustomElementConstructor> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+/**
+ * Placeholder shimmer surface shown while content loads. Renders a
+ * shape-configurable rectangle with a reduced-motion-aware shimmer.
+ *
+ * @element schmancy-skeleton
+ * @attr shape - 'rect' | 'circle' | 'text'. Default 'rect'.
+ * @attr width  - CSS length (e.g. `100%`, `12rem`).
+ * @attr height - CSS length; for `shape=text` defaults to 1em.
+ * @attr radius - CSS length for corner radius; ignored for `shape=circle`.
+ * @csspart surface - The shimmering surface element.
+ */
+export declare class SchmancySkeleton extends SchmancySkeleton_base {
+    shape: 'rect' | 'circle' | 'text';
+    width: string;
+    height: string;
+    radius: string;
+    connectedCallback(): void;
+    protected updated(): void;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'schmancy-skeleton': SchmancySkeleton;
+    }
+}
+export {};

package/types/src/splash-screen/index.d.ts

@@ -0,0 +1 @@
+export * from './splash-screen';

package/types/src/splash-screen/splash-screen.d.ts

@@ -0,0 +1,60 @@
+export type SchmancySplashScreenDoneEvent = CustomEvent<void>;
+declare const SchmancySplashScreen_base: CustomElementConstructor & import("../../mixins").Constructor<import("lit").LitElement> & import("../../mixins").Constructor<import("../../mixins").IBaseMixin>;
+/**
+ * Full-viewport splash overlay that dismisses once a minimum duration has
+ * elapsed and (optionally) an external `ready` signal has fired. The splash
+ * fades out while the underlying app content fades in.
+ *
+ * Bring-your-own visuals: the `splash` slot is empty by default so the
+ * component pulls in no dependencies. Provide a logo, spinner, or
+ * animation from the consumer side.
+ *
+ * @element schmancy-splash-screen
+ * @slot splash - Content rendered on the splash layer (logo, spinner, etc.).
+ * @slot - Default slot for the actual app content, revealed once dismissed.
+ * @fires schmancy-splash-done - `CustomEvent<void>` when the splash dismisses.
+ *
+ * @example
+ * ```html
+ * <schmancy-splash-screen min-duration="1200">
+ *   <my-logo slot="splash"></my-logo>
+ *   <my-app></my-app>
+ * </schmancy-splash-screen>
+ * ```
+ */
+export default class SchmancySplashScreen extends SchmancySplashScreen_base {
+    /**
+     * Minimum duration (ms) the splash layer stays visible. Prevents a flash
+     * when the app loads faster than expected.
+     */
+    minDuration: number;
+    /**
+     * When true, the splash dismisses on the `minDuration` timer alone.
+     * When false (default), it additionally waits for an external ready signal
+     * (a `ready` event on this element, or a call to `this.ready()`).
+     */
+    auto: boolean;
+    /**
+     * When true, the splash starts hidden. Use this for imperative control.
+     */
+    initiallyHidden: boolean;
+    private _visible;
+    connectedCallback(): void;
+    /**
+     * Imperative API: signal that the app is ready and dismiss the splash
+     * after the minimum duration has elapsed.
+     */
+    ready(): void;
+    /**
+     * Force the splash to show again (e.g. between route transitions).
+     */
+    show(): void;
+    private _dismiss;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'schmancy-splash-screen': SchmancySplashScreen;
+    }
+}
+export {};

package/types/src/switch/index.d.ts

@@ -0,0 +1 @@
+export * from './switch';

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

@@ -0,0 +1,54 @@
+import { LitElement } from 'lit';
+export type SchmancySwitchChangeEvent = CustomEvent<{
+    value: boolean;
+}>;
+declare const SchmancySwitch_base: import("@mixins/index").Constructor<CustomElementConstructor> & 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.
+ * @attr checked - Initial checked state (also reflected via `value`).
+ * @attr disabled - Disables interaction.
+ * @attr required - Requires the switch to be on for form validity.
+ * @attr name - Form field name for submission.
+ * @csspart track - The background track.
+ * @csspart thumb - The moving thumb.
+ */
+export declare class SchmancySwitch extends SchmancySwitch_base {
+    static formAssociated: boolean;
+    private internals;
+    checked: boolean;
+    disabled: boolean;
+    required: boolean;
+    name: string;
+    value: string;
+    label: string;
+    protected static shadowRootOptions: {
+        delegatesFocus: boolean;
+        clonable?: boolean;
+        customElementRegistry?: CustomElementRegistry;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    constructor();
+    get form(): HTMLFormElement | null;
+    protected updated(changed: Map<string, unknown>): void;
+    formResetCallback(): void;
+    formDisabledCallback(disabled: boolean): void;
+    checkValidity(): boolean;
+    reportValidity(): boolean;
+    private _toggle;
+    private _onKeydown;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'schmancy-switch': SchmancySwitch;
+    }
+}
+export {};

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

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

package/types/src/test-utils/a11y.d.ts

@@ -0,0 +1,11 @@
+import { type ElementContext, type RunOptions, type Result } from 'axe-core';
+/**
+ * Run axe-core on the given element (or document) and assert no violations.
+ * Throws a readable failure with a summary of violations so test output is
+ * immediately actionable.
+ *
+ * Keep the axe rule set minimal and appropriate for component tests — the
+ * defaults include many rules that only make sense at the page level (e.g.
+ * `region`, `landmark-one-main`). Override via `options.rules` when needed.
+ */
+export declare function expectNoA11yViolations(context?: ElementContext, options?: RunOptions): Promise<Result[]>;

package/types/src/textarea/textarea.d.ts

@@ -1,4 +1,4 @@
-import { LitElement } from 'lit';
+import { LitElement, type PropertyValues } from 'lit';
 declare const SchmancyTextarea_base: import("@mixins/index").Constructor<CustomElementConstructor> & 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.
@@ -24,6 +24,7 @@ export default class SchmancyTextarea extends SchmancyTextarea_base {
     static formAssociated: boolean;
     internals: ElementInternals | undefined;
     textareaRef: import("lit-html/directives/ref").Ref<HTMLTextAreaElement>;
+    private readonly _a11yId;
     /**
      * The label of the control.
      * @attr
@@ -141,6 +142,9 @@ export default class SchmancyTextarea extends SchmancyTextarea_base {
     hint: string | undefined;
     error: boolean;
     constructor();
+    protected willUpdate(changed: PropertyValues): void;
+    formResetCallback(): void;
+    formDisabledCallback(disabled: boolean): void;
     firstUpdated(): void;
     get form(): HTMLFormElement;
     /** Checks for validity of the control and shows the browser message if it's invalid. */

package/types/src/tooltip/index.d.ts

@@ -1,2 +1 @@
 export * from './tooltip.directive';
-export * from './tooltip';

package/types/src/tree/tree.d.ts

@@ -12,6 +12,11 @@ export declare class SchmancyTree extends SchmancyTree_base {
     toggler: HTMLSlotElement;
     defaultSlot: HTMLSlotElement;
     chevron: HTMLElement;
+    private readonly _a11yId;
+    private get _contentId();
+    /** ElementInternals — broadcasts `:state(open)` for consumer CSS. */
+    private readonly _internals;
+    updated(changed: Map<string, unknown>): void;
     firstUpdated(): void;
     render(): import("lit-html").TemplateResult<1>;
 }

package/types/src/visually-hidden/index.d.ts

@@ -0,0 +1 @@
+export * from './visually-hidden';

package/types/src/visually-hidden/visually-hidden.d.ts

@@ -0,0 +1,21 @@
+declare const SchmancyVisuallyHidden_base: import("@mixins/index").Constructor<CustomElementConstructor> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+/**
+ * Hides content visually while keeping it in the accessibility tree. Use for
+ * screen-reader-only labels, supplemental descriptions, and live-region text
+ * that sighted users don't need to see.
+ *
+ * Uses the WCAG-recommended clip pattern rather than `display: none` or
+ * `visibility: hidden` so assistive tech still reads the content.
+ *
+ * @element schmancy-visually-hidden
+ * @slot - Content hidden from sighted users but exposed to assistive tech.
+ */
+export declare class SchmancyVisuallyHidden extends SchmancyVisuallyHidden_base {
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'schmancy-visually-hidden': SchmancyVisuallyHidden;
+    }
+}
+export {};