@mhmo91/schmancy 0.9.28 → 0.10.2

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

@@ -1,26 +1,46 @@
+import { SchmancyElement } from '@mixins/index';
 import { type TemplateResult } from 'lit';
-import type { CloseReason, Content, OverlayLayout, ShowOptions } from './overlay.types';
-declare const SchmancyOverlay_base: CustomElementConstructor & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+import type { CloseReason, Content, OverlayLayout, OverlayTier, ShowOptions } from './overlay.types';
 /**
- * The single overlay element. Hosts a native `<dialog>` in its shadow
- * root for centered/sheet layouts; for anchored, we stay modeless by
- * using `<dialog>` with .show() (non-modal) + explicit positioning.
+ * The single overlay element. Custom `<div>` shell (not a native
+ * `<dialog>`) — one backdrop mechanism for all layouts, one focus-trap
+ * path, one animation orchestrator. The shell is always rendered; the
+ * backdrop only renders when modal. The surface is positioned per tier:
+ *
+ * - Modal layouts (centered / sheet) → backdrop + surface, focus-trapped,
+ *   library-managed z-index.
+ * - Anchored 'css-anchor' tier → surface as `popover="auto"` with
+ *   CSS Anchor Positioning; native top-layer + light-dismiss.
+ * - Anchored 'popover-fui' tier → surface as `popover="auto"` + Floating
+ *   UI position math; native top-layer + light-dismiss.
+ * - Anchored 'fui-only' tier → surface positioned by Floating UI;
+ *   manual click-outside + manual Esc.
  *
  * Public lifecycle: the service calls `open()` to mount content and
  * animate in, `close(reason)` to animate out and dismiss. The element
- * dispatches `overlay-close` when closed; the service listens and
- * resolves the caller's Observable.
+ * exposes `closed$` (Observable emitting reason + result once) and
+ * `tier` / `layout` / `modal` as properties for the stack entry.
  */
-export declare class SchmancyOverlay extends SchmancyOverlay_base {
+export declare class SchmancyOverlay extends SchmancyElement {
+    static styles: import("lit").CSSResult[];
     layout: OverlayLayout;
     dismissable: boolean;
     modal: boolean;
-    private _dialog;
+    tier: OverlayTier;
+    private _active;
+    private _backdrop?;
     private _surface;
     /** Close trigger for the service; emits the reason + detail payload. */
     private readonly _closed$;
     private _mounted;
     private _closing;
+    private _resolvedAnchor?;
+    private _rawAnchor?;
+    private _anchorOriginAnchor?;
+    private _positionerTeardown?;
+    private _lastFocusedElement;
+    private _inertedSiblings;
+    private _lastReResolveAt;
     /** Service subscribes to this to know when the overlay dismissed. */
     get closed$(): import('rxjs').Observable<{
         reason: CloseReason;
@@ -28,21 +48,25 @@ export declare class SchmancyOverlay extends SchmancyOverlay_base {
     }>;
     /**
      * Mount content and animate in. Called by the service after the
-     * element is attached to the DOM. Returns a promise that resolves
-     * when the entrance animation completes.
+     * element is attached to the DOM. Resolves when the entrance
+     * animation completes.
      */
     open(content: Content, options: ShowOptions): Promise<void>;
-    /** Play exit animations then close the native dialog. */
+    /** Play exit animations then dismiss. */
     close(reason: CloseReason, result?: unknown): Promise<void>;
+    protected render(): TemplateResult;
+    private onBackdropClick;
+    private setAnchorOriginVars;
+    private wireFocusTrap;
+    private releaseFocusTrap;
     private wireCloseTriggers;
-    private positionAnchored;
+    private wireResizeObserver;
+    private maybeReResolve;
     private playEnterAnimations;
     private playExitAnimations;
-    protected render(): TemplateResult;
 }
 declare global {
     interface HTMLElementTagNameMap {
         'schmancy-overlay': SchmancyOverlay;
     }
 }
-export {};

package/types/src/overlay/overlay.confirm-body.d.ts

@@ -1,5 +1,5 @@
+import { SchmancyElement } from '@mixins/index';
 import { type TemplateResult } from 'lit';
-declare const SchmancyOverlayPromptBody_base: CustomElementConstructor & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
 /**
  * Internal body component used by the `confirm()` / `prompt()` sugar.
  *
@@ -11,7 +11,8 @@ declare const SchmancyOverlayPromptBody_base: CustomElementConstructor & import(
  * that up as the primary return channel. For custom-styled confirms,
  * callers pass their own component to `show()`.
  */
-export declare class SchmancyOverlayPromptBody extends SchmancyOverlayPromptBody_base {
+export declare class SchmancyOverlayPromptBody extends SchmancyElement {
+    static styles: import("lit").CSSResult[];
     heading?: string;
     subtitle?: string;
     message?: string;
@@ -23,7 +24,7 @@ export declare class SchmancyOverlayPromptBody extends SchmancyOverlayPromptBody
     label?: string;
     defaultValue: string;
     placeholder?: string;
-    inputType: string;
+    inputType: 'text' | 'email' | 'password' | 'tel' | 'url' | 'number' | 'search' | 'date' | 'time' | 'datetime-local';
     pattern?: string;
     required: boolean;
     private _input?;
@@ -39,4 +40,3 @@ declare global {
         'schmancy-overlay-prompt-body': SchmancyOverlayPromptBody;
     }
 }
-export {};

package/types/src/overlay/overlay.gestures.d.ts

@@ -2,22 +2,33 @@ import { Observable } from 'rxjs';
 /**
  * Swipe-to-dismiss gesture for sheet-layout overlays.
  *
- * RxJS-native (rxjs skill principle 3: every async source is an Observable).
- * Returns an Observable that emits `'dismiss'` when the gesture passes the
- * distance/velocity threshold. Caller maps emissions to teardown.
+ * Pointer-event based — a single pipeline covers touch, mouse, pen, and
+ * any future pointer source. Without a visible drag handle, the gesture
+ * only starts within the top DRAG_START_TOP_PX band of the surface (a
+ * standard pull-to-dismiss convention). Escape + backdrop click cover
+ * the non-pointer dismiss paths via the component's modal-tier listeners.
  *
+ * RxJS-native (rxjs skill principle 3: every async source is an Observable).
  * Thresholds are policy constants, not magic numbers.
  */
-/** Distance beyond which the gesture dismisses, in px. */
+/** Distance (px) past which the gesture dismisses. */
 export declare const DISMISS_DISTANCE_PX = 80;
-/** Distance beyond which the gesture dismisses, as a fraction of sheet height. */
-export declare const DISMISS_DISTANCE_FRACTION = 0.3;
-/** Velocity beyond which the gesture dismisses, in px per ms. */
-export declare const DISMISS_VELOCITY_PX_PER_MS = 0.5;
-/** Drag only starts if touchstart is within this top-px band (unless a drag handle is used). */
+/** Distance as fraction of sheet height past which the gesture dismisses. */
+export declare const DISMISS_DISTANCE_FRACTION = 0.25;
+/** Velocity (px/ms) past which the gesture dismisses even short of distance. */
+export declare const DISMISS_VELOCITY_PX_PER_MS = 0.4;
+/** Drag only starts if pointerdown is within this top band (unless a drag handle is used). */
 export declare const DRAG_START_TOP_PX = 40;
-/** Snap-back spring duration when gesture doesn't pass threshold. */
+/** Snap-back animation duration when gesture doesn't pass threshold. */
 export declare const SNAP_BACK_MS = 300;
+/**
+ * Logarithmic rubber-band damping for upward (negative) drag past the
+ * top detent. Pulled from Vaul — `8 * (log(v + 1) - 2)` — diminishing
+ * returns that feel physical, unlike the linear × 0.2 this replaces.
+ *
+ * Applied only to upward motion; downward drag tracks 1:1.
+ */
+export declare function logDamp(delta: number): number;
 export interface SwipeInputs {
     /** The surface element to track gestures on. */
     surface: HTMLElement;
@@ -28,12 +39,10 @@ export interface SwipeInputs {
     until$: Observable<unknown>;
 }
 /**
- * Returns an Observable that emits exactly once when the user commits to
- * dismissing the sheet (threshold passed). The gesture is owned by the
- * caller — teardown fires on unsubscribe.
- *
- * During an in-progress drag, the surface's `transform` is updated
- * directly for 1:1 tracking. On release-but-not-dismissed, the surface
- * snaps back via a CSS transition.
+ * Emits exactly once when the user commits to dismissing the sheet
+ * (distance OR velocity threshold passed). Works for touch, mouse, and
+ * pen via the Pointer Events API. During an in-progress drag the
+ * surface's `transform` is updated directly for 1:1 tracking. On
+ * release-but-not-dismissed, the surface snaps back via a CSS transition.
  */
 export declare function swipeToDismiss$(inputs: SwipeInputs): Observable<'dismiss'>;

package/types/src/overlay/overlay.layout.d.ts

@@ -1,4 +1,4 @@
-import type { Anchor, OverlayLayout } from './overlay.types';
+import type { Anchor, OverlayLayout, VirtualAnchor } from './overlay.types';
 /**
  * Layout dispatch engine — pure function of (anchor, content, viewport).
  * No DOM access, no side effects — testable with synthetic inputs.
@@ -46,3 +46,29 @@ export declare function resolveLayout(inputs: LayoutInputs): OverlayLayout;
  * substitute synthetic inputs and the `resolveLayout` fn stays pure.
  */
 export declare function readViewport(): LayoutInputs['viewport'];
+/**
+ * Resolved reference the positioning strategies consume.
+ *
+ * `el` is populated when the anchor is an HTMLElement — the Popover API
+ * tier uses it directly via the `anchor=<id>` attribute, and Tier 1 / CSS
+ * Anchor Positioning sets `element.style.anchorName` on it.
+ *
+ * `virtual` is populated for point/rect/TouchEvent anchors — Floating UI
+ * accepts any object exposing `getBoundingClientRect()` as a virtual
+ * reference. The Popover API path cannot use virtual references, so a
+ * caller passing a point / DOMRect / event forces Tier 3 (or Tier 2 with
+ * Floating UI, not CSS Anchor Positioning).
+ */
+export interface ResolvedAnchor {
+    el?: HTMLElement;
+    virtual?: VirtualAnchor;
+}
+/**
+ * Normalise an `Anchor` input into the shape the positioning strategies
+ * accept. One function, one decision: element wins if present; otherwise
+ * synthesize a zero-size virtual reference at the anchor's point.
+ *
+ * Called by the overlay element during `open()` before dispatching to
+ * `pickPositioner(resolved)`.
+ */
+export declare function resolveAnchorRef(anchor: Anchor | undefined): ResolvedAnchor | undefined;

package/types/src/overlay/overlay.positioning.d.ts

@@ -0,0 +1,87 @@
+import { Observable } from 'rxjs';
+import { type ResolvedAnchor } from './overlay.layout';
+import type { OverlayPlacement, OverlayTier } from './overlay.types';
+/**
+ * Three-tier positioning ladder for anchored overlays. Public API of the
+ * overlay doesn't change based on the tier — the strategy is picked
+ * internally by feature-detection.
+ *
+ * Tier 1 — CSS Anchor Positioning (Popover + `anchor-name` / `position-anchor`)
+ *   Zero-JS position tracking. Chromium-only today.
+ *
+ * Tier 2 — Popover API + Floating UI
+ *   Native top-layer + light-dismiss + Esc from `popover="auto"`, Floating
+ *   UI middleware for the position math. Safari 17+, Chrome 114+, Firefox 125+.
+ *
+ * Tier 3 — Floating UI only
+ *   Fallback for browsers without the Popover API. Caller provides manual
+ *   backdrop + click-outside + Esc wiring.
+ */
+/**
+ * Feature-detection snapshot captured at module load. Frozen so consumers
+ * can safely destructure and compare.
+ */
+export declare const CAPS: Readonly<{
+    popover: boolean;
+    cssAnchor: boolean;
+}>;
+/**
+ * Pick the positioning tier for an anchor.
+ *
+ * CSS Anchor Positioning (Tier 1) requires a real element anchor — you
+ * can't point `anchor-name` at a DOMRect or a coord. A point/rect anchor
+ * forces Tier 2 (or Tier 3 if popover isn't supported).
+ */
+export declare function pickPositioner(anchor: ResolvedAnchor): OverlayTier;
+/**
+ * Set up CSS Anchor Positioning. Assigns a unique `anchor-name` to the
+ * anchor element and injects a stylesheet into the shadow root that
+ * positions the surface relative to it. No JS running per frame.
+ *
+ * Returns a cleanup function that removes the injected styles and the
+ * anchor-name from the anchor element.
+ */
+export declare function positionCSSAnchor(surface: HTMLElement, anchor: ResolvedAnchor, shadowRoot: ShadowRoot, opts?: {
+    id: string;
+    placement?: OverlayPlacement;
+}): () => void;
+/**
+ * Wire the Popover API lifecycle — the surface gets `popover="auto"` and
+ * `showPopover()` is called to promote it into the native top layer. No
+ * position math here; the caller pairs this with `positionFloatingUI` for
+ * the geometry, since Tier 2 is Popover-for-stacking + Floating UI-for-math.
+ *
+ * Returns a cleanup function that hides the popover and strips the attr.
+ */
+export declare function positionPopoverAPI(surface: HTMLElement): () => void;
+export interface FloatingUIOptions {
+    /** Preferred placement; Floating UI's `flip` middleware handles falls. */
+    placement?: OverlayPlacement;
+    /** Padding used by `shift` + `size` middleware. Defaults to
+     *  `ANCHOR_FIT_PADDING_PX` from overlay.layout. */
+    padding?: number;
+    /** Gap between anchor and surface. Default 8px. */
+    offsetPx?: number;
+    /** Whether `autoUpdate` should track element resizes. Default true. */
+    track?: boolean;
+}
+/**
+ * Floating UI-driven positioning. Returns a cold Observable — subscribe to
+ * start positioning, unsubscribe to stop tracking (teardown cancels the
+ * `autoUpdate` loop). The caller composes with `takeUntil(this.disconnecting)`:
+ *
+ *     positionFloatingUI(surface, anchor, opts)
+ *       .pipe(takeUntil(this.disconnecting))
+ *       .subscribe()
+ *
+ * Middleware (stack, in order):
+ *   offset(opts.offsetPx)
+ *   → flip({ fallbackPlacements: [...] })
+ *   → shift({ padding: opts.padding })
+ *   → size({ apply: clamp maxWidth AND maxHeight from availableWidth/Height })
+ *
+ * `flip` is chosen over `autoPlacement` because element-anchored overlays
+ * should respect the trigger's spatial context (menus shouldn't jump
+ * sides). Dialog uses `autoPlacement` because it's point-anchored.
+ */
+export declare function positionFloatingUI(surface: HTMLElement, anchor: ResolvedAnchor, opts?: FloatingUIOptions): Observable<void>;

package/types/src/overlay/overlay.stack.d.ts

@@ -10,8 +10,6 @@ export declare function pushEntry(entry: OverlayEntry): void;
 export declare function removeEntry(id: string): void;
 /** Clear the entire stack. Used by dismissAll(). */
 export declare function clearStack(): void;
-/** Top entry (LIFO). Undefined when stack is empty. */
-export declare function topEntry(): OverlayEntry | undefined;
 export declare function markModal(id: string, hostContainer: HTMLElement): void;
 export declare function unmarkModal(id: string): void;
 /**

package/types/src/overlay/overlay.types.d.ts

@@ -11,19 +11,39 @@ import type { THistoryStrategy } from '../area/router.types';
  * `show(el)`, `show('my-tag')`, `show(lazy(() => import('./x')))`.
  */
 export type Content = ComponentType | TemplateResult;
+/**
+ * Virtual reference object — same contract Floating UI and CSS Anchor
+ * Positioning accept. A caller who needs to anchor off something that
+ * isn't a real element (e.g. a computed region, a scroll-clipped shape)
+ * passes one of these. Must expose `getBoundingClientRect()` returning
+ * a DOMRect-shaped value.
+ */
+export interface VirtualAnchor {
+    getBoundingClientRect(): DOMRect;
+}
 /**
  * Anchor hint for positioning. When provided, the layout engine tries to
- * anchor the overlay near this point via Floating UI / CSS Anchor Positioning.
+ * anchor the overlay near this point via the Tier-1/2/3 positioning ladder
+ * (CSS Anchor Positioning → Popover API + Floating UI → Floating UI only).
  * Falls back to centered / sheet if the anchored position can't fit.
  *
- * `MouseEvent | TouchEvent` — idiomatic: pass the event that triggered the show.
- * `HTMLElement` — anchor to the element's bounding box (menus, tooltips).
- * `{ x, y }` — explicit coordinates (rare; for programmatic positioning).
+ * Forms accepted (typeof-discriminated at runtime):
+ * - `MouseEvent | TouchEvent` — pass the event that triggered the show (most idiomatic)
+ * - `HTMLElement` — anchor to the element's bounding box (menus, tooltips)
+ * - `DOMRect` — explicit rect (rare; useful when the anchoring surface is virtual)
+ * - `VirtualAnchor` — anything with `getBoundingClientRect()` (computed regions)
+ * - `{ x: number; y: number }` — explicit coordinates (last resort)
  */
-export type Anchor = MouseEvent | HTMLElement | {
+export type Anchor = MouseEvent | TouchEvent | HTMLElement | DOMRect | VirtualAnchor | {
     x: number;
     y: number;
 };
+/**
+ * Floating UI `Placement` subset the overlay exposes as a preferred
+ * placement hint. The full set of 12 placements is supported internally;
+ * this narrower list covers the practical cases a caller would name.
+ */
+export type OverlayPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
 /**
  * How the overlay should behave. All optional; the system handles every
  * layout decision itself.
@@ -55,6 +75,21 @@ export interface ShowOptions {
      *  - `'replace'` — replace current entry; back skips the overlay.
      *  - `'silent'` — no history; for tooltips / transient / ephemeral UI. */
     historyStrategy?: THistoryStrategy;
+    /** Preferred placement for anchored layouts. The positioning engine
+     *  (Floating UI `flip` middleware on Tier 2/3, CSS `position-try` on
+     *  Tier 1) will fall back when the preferred side doesn't fit.
+     *  Default is `'bottom-start'`. Ignored for centered / sheet layouts. */
+    preferredPlacement?: OverlayPlacement;
+    /** Render a tail arrow pointing from the surface to the anchor.
+     *  Default `false`. Only meaningful on anchored layouts. */
+    arrow?: boolean;
+    /** For anchored layouts: auto-track the anchor element's bounding rect
+     *  via `autoUpdate` (Floating UI tiers) or native `anchor-name` tracking
+     *  (CSS Anchor Positioning tier). Default `true` when an element anchor
+     *  is passed; `false` when a point / DOMRect / event anchor is passed
+     *  (those are inherently one-shot).
+     */
+    track?: boolean;
 }
 /**
  * Resolved layout. Pure output of the dispatch engine; callers never pick.
@@ -65,6 +100,18 @@ export interface ShowOptions {
  *                    swipe-to-dismiss, safe-area aware.
  */
 export type OverlayLayout = 'centered' | 'anchored' | 'sheet';
+/**
+ * Positioning tier an anchored overlay is using.
+ * - `'css-anchor'` — Tier 1: Popover API + CSS Anchor Positioning (Chromium).
+ *                    Lives in native top-layer; the library's z-index stack
+ *                    does not manage it.
+ * - `'popover-fui'` — Tier 2: Popover API + Floating UI. Native top-layer;
+ *                    z-index stack also skipped.
+ * - `'fui-only'` — Tier 3: Floating UI only, manual backdrop + click-outside.
+ *                    Uses the library's z-index stack.
+ * - `'modal'` — centered / sheet layout; custom shell, library z-index.
+ */
+export type OverlayTier = 'css-anchor' | 'popover-fui' | 'fui-only' | 'modal';
 /**
  * Read-only snapshot of an active overlay. Emitted as part of the
  * `openOverlays$` stream for stack introspection.
@@ -77,6 +124,13 @@ export interface OverlayEntry {
     readonly element: HTMLElement;
     /** Current layout, chosen by the dispatch engine. */
     readonly layout: OverlayLayout;
+    /** Whether this overlay traps focus + inerts siblings. Centered / sheet
+     *  default to modal; anchored defaults to non-modal (popover-like). */
+    readonly modal: boolean;
+    /** Which positioning tier is in use. Scroll lock + sibling-inert only
+     *  fire for `'modal'` and `'fui-only'` tiers — native top-layer tiers
+     *  (`'popover-fui'`, `'css-anchor'`) handle stacking via the platform. */
+    readonly tier: OverlayTier;
 }
 /**
  * Reason the overlay closed. Emitted on the internal close-event `detail`

package/types/src/page/page.d.ts

@@ -1,19 +1,23 @@
+import { SchmancyElement } from '@mixins/index';
 import '../layout/scroll/scroll';
-declare const SchmancyPage_base: CustomElementConstructor & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
 /**
- * Mobile-first page container — fills remaining viewport height, suppresses double-tap zoom / pull-to-refresh / rubber-banding. Lays children in a CSS grid whose row template is `rows`.
+ * Native mobile-like page container.
+ * Prevents double-tap zoom, pull-to-refresh, rubber-banding.
+ * Automatically fills remaining viewport height.
  *
  * @element schmancy-page
- * @summary The root of any app view — wraps header / main / footer children in a full-viewport grid. Use rows="auto_1fr_auto" to make the middle child scroll while header/footer stay pinned.
+ *
  * @example
- * <schmancy-page rows="auto_1fr_auto">
- *   <schmancy-nav-drawer-appbar>Title</schmancy-nav-drawer-appbar>
- *   <main>Scrollable content</main>
- *   <schmancy-navigation-bar></schmancy-navigation-bar>
- * </schmancy-page>
- * @platform div - Full-height CSS-grid container. Degrades to a plain div if the tag never registers — children still flow vertically but without the height fill and gesture suppression.
+ * html`
+ *   <schmancy-page rows="1fr_2fr_auto">
+ *     <header>App Bar</header>
+ *     <main>Scrollable content</main>
+ *     <footer>Navigation</footer>
+ *   </schmancy-page>
+ * `
  */
-export declare class SchmancyPage extends SchmancyPage_base {
+export declare class SchmancyPage extends SchmancyElement {
+    static styles: import("lit").CSSResult[];
     /** Custom grid-template-rows using underscores (e.g. "1fr_2fr_auto") */
     rows: string;
     showScrollbar: boolean;
@@ -31,4 +35,3 @@ declare global {
         'schmancy-page': SchmancyPage;
     }
 }
-export {};

package/types/src/{components/form-elements → payment-card-form}/payment-card-form.d.ts

@@ -1,6 +1,6 @@
+import { SchmancyElement } from '@mixins/index';
 import SchmancyForm from '@schmancy/form/form';
 import SchmancyInput from '@schmancy/input/input';
-declare const SchmancyPaymentCardForm_base: CustomElementConstructor & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
 /**
  * @element schmancy-payment-card-form
  * A mobile-friendly payment card form component that provides real-time validation
@@ -9,7 +9,7 @@ declare const SchmancyPaymentCardForm_base: CustomElementConstructor & import("@
  * @fires change - Fires when any field in the form changes
  * @slot - Default slot for any additional content
  */
-export declare class SchmancyPaymentCardForm extends SchmancyPaymentCardForm_base {
+export declare class SchmancyPaymentCardForm extends SchmancyElement {
     /**
      * The form data containing all payment card information
      */
@@ -83,4 +83,3 @@ declare global {
         'schmancy-payment-card-form': SchmancyPaymentCardForm;
     }
 }
-export {};

package/types/src/progress/progress.d.ts

@@ -1,5 +1,6 @@
-declare const SchmancyProgress_base: CustomElementConstructor & import("../../mixins").Constructor<import("lit").LitElement> & import("../../mixins").Constructor<import("../../mixins").IBaseMixin>;
-export default class SchmancyProgress extends SchmancyProgress_base {
+import { SchmancyElement } from '@mixins/index';
+export default class SchmancyProgress extends SchmancyElement {
+    static styles: import("lit").CSSResult[];
     value: number;
     max: number;
     indeterminate: boolean;
@@ -14,4 +15,3 @@ declare global {
         'schmancy-progress': SchmancyProgress;
     }
 }
-export {};

package/types/src/qr-scanner/qr-scanner.d.ts

@@ -1,5 +1,6 @@
-declare const SchmancyQRScanner_base: CustomElementConstructor & import("../../mixins").Constructor<import("lit").LitElement> & import("../../mixins").Constructor<import("../../mixins").IBaseMixin>;
-export declare class SchmancyQRScanner extends SchmancyQRScanner_base {
+import { SchmancyElement } from '@mixins/index';
+export declare class SchmancyQRScanner extends SchmancyElement {
+    static styles: import("lit").CSSResult[];
     continuous: boolean;
     private hasPermission;
     private error;
@@ -23,4 +24,3 @@ declare global {
         'schmancy-qr-scanner': SchmancyQRScanner;
     }
 }
-export {};

package/types/src/radio-group/radio-button.d.ts

@@ -1,16 +1,7 @@
-declare const RadioButton_base: import("@mixins/index").Constructor<import("@mixins/index").IFormFieldMixin> & 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>;
+import { SchmancyElement } from '@mixins/index';
+declare const RadioButton_base: import("@mixins/index").Constructor<import("@mixins/index").IFormFieldMixin> & typeof SchmancyElement;
 /**
- * Single radio button — always rendered as a child of `<schmancy-radio-group>`, never standalone.
- *
- * @element schmancy-radio-button
- * @summary Low-level primitive. Use schmancy-radio-group and pass `.options` for the common path; only instantiate schmancy-radio-button directly when you need per-button custom rendering.
- * @example
- * <schmancy-radio-group name="plan">
- *   <schmancy-radio-button value="free">Free</schmancy-radio-button>
- *   <schmancy-radio-button value="pro" checked>Pro</schmancy-radio-button>
- * </schmancy-radio-group>
- * @platform radio change - Schmancy-skinned `<input type="radio">` semantics. Degrades to native radio if the tag never registers.
- * @fires radio-button-click - Internal event consumed by the parent schmancy-radio-group; `detail.value` is the clicked button's value. Listen on schmancy-radio-group for the public `change` event instead of subscribing here.
+ * Radio button component for use within radio groups.
  *
  * @prop {string} name - Name attribute for grouping radio buttons
  * @prop {string} value - Value of this radio button

package/types/src/radio-group/radio-group.d.ts

@@ -1,3 +1,4 @@
+import { SchmancyElement } from '@mixins/index';
 export type SchmancyRadioGroupOption = {
     label: string;
     value: string;
@@ -5,26 +6,9 @@ export type SchmancyRadioGroupOption = {
 export type SchmancyRadioGroupChangeEvent = CustomEvent<{
     value: string;
 }>;
-declare const RadioGroup_base: import("@mixins/index").Constructor<import("@mixins/index").IFormFieldMixin> & 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>;
-/**
- * Radio-button group — single-select from a static list of mutually-exclusive options. Form-associated.
- *
- * @element schmancy-radio-group
- * @summary Use for 2–5 mutually-exclusive options where all should stay visible ("Shipping: standard / express / overnight"). Prefer schmancy-select when the list grows.
- * @example
- * <schmancy-radio-group
- *   name="shipping"
- *   label="Shipping"
- *   .options=${[
- *     { label: 'Standard (5 days)', value: 'standard' },
- *     { label: 'Express (2 days)', value: 'express' },
- *     { label: 'Overnight', value: 'overnight' },
- *   ]}
- * ></schmancy-radio-group>
- * @platform radiogroup change - Renders schmancy-radio-button children. Degrades to a fieldset with native `<input type="radio" name="…">` siblings if the tag never registers.
- * @fires change - `SchmancyRadioGroupChangeEvent` with the selected `value`.
- */
+declare const RadioGroup_base: import("@mixins/index").Constructor<import("@mixins/index").IFormFieldMixin> & typeof SchmancyElement;
 export declare class RadioGroup extends RadioGroup_base {
+    static styles: import("lit").CSSResult[];
     label: string;
     name: string;
     value: string;
@@ -35,7 +19,7 @@ export declare class RadioGroup extends RadioGroup_base {
     disconnectedCallback(): void;
     private handleSelection;
     private updateChildRadioButtons;
-    updated(changedProperties: Map<string, any>): void;
+    updated(changedProperties: Map<string, unknown>): void;
     render(): import("lit-html").TemplateResult<1>;
 }
 declare global {

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

@@ -1,13 +1,14 @@
+import { SchmancyElement } from '@mixins/index';
 export type SchmancyRangeChangeEvent = CustomEvent<{
     value: number;
 }>;
-declare const SchmancyRange_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>;
 /**
  * @element schmancy-range
  * Range input (numeric slider).
  * @fires change - Fires on value change with { value: number }
  */
-export declare class SchmancyRange extends SchmancyRange_base {
+export declare class SchmancyRange extends SchmancyElement {
+    static styles: import("lit").CSSResult[];
     min: number;
     max: number;
     step: number;
@@ -22,4 +23,3 @@ declare global {
         'schmancy-range': SchmancyRange;
     }
 }
-export {};

package/types/src/rxjs-utils/waitForElements.d.ts

@@ -4,7 +4,7 @@
  * @example waitForElements(['button', 'input']).subscribe(([button, input]) => button.click())
  * @returns
  */
-export default function waitForElements<T extends Array<T>>(
+export default function waitForElements(
 /**
  * @param selectors The selectors to use to find the elements
  * @type { string[] }

package/types/src/rxjs-utils/waitForElementsAll.d.ts

@@ -4,7 +4,7 @@
  * @example waitForElements(['button', 'input']).subscribe(([button, input]) => button.click())
  * @returns
  */
-export default function waitForElementsAll<T extends Array<T>>(
+export default function waitForElementsAll(
 /**
  * @param selectors The selectors to use to find the elements
  * @type { string[] }