@mhmo91/schmancy 0.10.36 → 0.10.38

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

@@ -19,8 +19,8 @@ declare const SchmancyAutocomplete_base: import("@mixins/index").Constructor<imp
 export default class SchmancyAutocomplete extends SchmancyAutocomplete_base {
     /** Override mixin's resetForm with autocomplete-specific subject reset. */
     resetForm(): void;
-    _valueSet: boolean;
-    _valuesSet: boolean;
+    valueSet: boolean;
+    valuesSet: boolean;
     placeholder: string;
     maxHeight: string;
     multi: boolean;
@@ -29,43 +29,43 @@ export default class SchmancyAutocomplete extends SchmancyAutocomplete_base {
     autocomplete: string;
     debounceMs: number;
     similarityThreshold: number;
-    private readonly _a11yId;
+    private readonly a11yId;
     get values(): string[];
     set values(vals: string[]);
     get value(): string;
     set value(val: string);
-    private _open;
-    private _inputValue;
-    private _visibleOptionsCount;
-    private _hasResults;
-    _listbox: HTMLUListElement;
-    _input: SchmancyInput;
-    private _options;
-    private _inputElementRef;
-    private _selectedValue$;
-    private _selectedValues$;
-    private _inputValue$;
+    private open;
+    private inputValue;
+    private visibleOptionsCount;
+    private hasResults;
+    listbox: HTMLUListElement;
+    input: SchmancyInput;
+    private options;
+    private inputElementRef;
+    private selectedValue$;
+    private selectedValues$;
+    private inputValue$;
     connectedCallback(): void;
-    private _setupAutocompleteLogic;
-    private _setupOptionHandlers;
-    private _updateOptionSelection;
-    private _filterOptions;
-    private _openDropdown;
-    private _selectOption;
-    private _setupDocumentClickHandler;
-    private _updateInputDisplay;
-    private _getSelectedLabels;
-    private _announceToScreenReader;
-    private _fireChangeEvent;
+    private setupAutocompleteLogic;
+    private setupOptionHandlers;
+    private updateOptionSelection;
+    private filterOptions;
+    private openDropdown;
+    private selectOption;
+    private setupDocumentClickHandler;
+    private updateInputDisplay;
+    private getSelectedLabels;
+    private announceToScreenReader;
+    private fireChangeEvent;
     checkValidity(): boolean;
     reportValidity(): boolean;
     firstUpdated(): void;
     private handleChipRemove;
-    private _getChipLabel;
-    private _focusTextInput;
+    private getChipLabel;
+    private focusTextInput;
     render(): import("lit-html").TemplateResult<1>;
-    private _handleAutoSelectOnBlur;
-    private _handleKeyDown;
+    private handleAutoSelectOnBlur;
+    private handleKeyDown;
 }
 declare global {
     interface HTMLElementTagNameMap {

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

@@ -31,7 +31,7 @@ declare class SchmancyCheckboxElement extends SchmancyCheckboxElement_base {
      * M3-aligned sizes: 24dp (xxs) → 32dp (xs) → 40dp (sm) → 48dp (md) → 56dp (lg).
      */
     size: 'xxs' | 'xs' | 'sm' | 'md' | 'lg';
-    private get _trueValue();
+    private get trueValue();
     willUpdate(changed: PropertyValues): void;
     /** Checkbox validity is `checked === true` when required. */
     checkValidity(): boolean;

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

@@ -24,7 +24,7 @@ export default class SchmancyChips extends SchmancyChips_base {
     private updateChipStates;
     change(e: CustomEvent<SchmancyChipChangeEvent>): Promise<void>;
     resetForm(): void;
-    protected firstUpdated(_changedProperties: PropertyValues): void;
+    protected firstUpdated(changedProperties: PropertyValues): void;
     protected render(): unknown;
 }
 declare global {

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

@@ -16,11 +16,10 @@ import { SchmancyElement } from '@mixins/index';
  * ```
  */
 export declare class SchmancyFilterChip extends SchmancyElement {
+    #private;
     static styles: import("lit").CSSResult[];
     /** Unique identifier for this filter chip */
     value: string;
-    /** Whether the filter chip is selected (active filter) */
-    private _selected;
     get selected(): boolean;
     set selected(value: boolean);
     /** Whether to show a remove button */

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

@@ -45,7 +45,7 @@ declare const SchmancyInput_base: import("@mixins/index").Constructor<import("@m
  */
 export default class SchmancyInput extends SchmancyInput_base {
     /** Auto-incrementing counter for generating unique IDs */
-    static _idCounter: number;
+    static idCounter: number;
     /** Override value to be string only for input element */
     value: string;
     /**
@@ -123,7 +123,7 @@ export default class SchmancyInput extends SchmancyInput_base {
      * 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()`.
+     * The visual `error` flag is still gated by the mixin's `shouldShowError()`.
      */
     /**
      * Re-run checkValidity AFTER render so the native inner input's `.value`
@@ -136,7 +136,7 @@ export default class SchmancyInput extends SchmancyInput_base {
      * Order matches the natural priority of validity flags (valueMissing
      * before more specific ones — empty trumps malformed).
      */
-    private _firstMatchingErrorMessage;
+    private firstMatchingErrorMessage;
     checkValidity(): boolean;
     /**
      * Show validation UI and check validity.

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

@@ -13,7 +13,7 @@ export declare class RadioButton extends SchmancyElement {
     disabled: boolean;
     name: string;
     connectedCallback(): void;
-    private _handleClick;
+    private handleClick;
     render(): import("lit-html").TemplateResult<1>;
 }
 declare global {

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

@@ -11,7 +11,7 @@ export declare class RadioGroup extends RadioGroup_base {
     required: boolean;
     connectedCallback(): void;
     updated(changed: Map<string, unknown>): void;
-    private _syncChildren;
+    private syncChildren;
     render(): import("lit-html").TemplateResult<1>;
 }
 declare global {

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

@@ -31,18 +31,18 @@ export declare class SchmancySelect extends SchmancySelect_base {
     private inputRef;
     private options;
     private cleanupPositioner?;
-    private _options$;
-    private _selectedValue$;
-    private _selectedValues$;
-    private _optionSelect$;
+    private options$;
+    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 _focusedOptionId;
+    userInteracted: boolean;
+    private focusedOptionId;
     connectedCallback(): void;
     disconnectedCallback(): void;
     firstUpdated(): void;
@@ -54,9 +54,9 @@ export declare class SchmancySelect extends SchmancySelect_base {
     private focusOption;
     private openDropdown;
     private closeDropdown;
-    private _setupReactivePipelines;
+    private setupReactivePipelines;
     private handleOptionSelect;
-    private _fireChangeEvent;
+    private fireChangeEvent;
     checkValidity(): boolean;
     reportValidity(): boolean;
     /**

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

@@ -32,7 +32,7 @@ export declare class SchmancySwitch extends SchmancySwitch_base {
     /** Boolean on/off state. Native `<input type=checkbox>.checked` semantics. */
     checked: boolean;
     /** Snapshot of `checked` at first render — drives the `dirty` override. */
-    private _checkedDefault;
+    private checkedDefault;
     firstUpdated(changed: PropertyValues): void;
     /**
      * Override the mixin's value-vs-default `dirty` getter — for switch the
@@ -45,8 +45,8 @@ export declare class SchmancySwitch extends SchmancySwitch_base {
     /** Override — emit only when the switch is on. */
     toFormEntries(): Array<[string, FormDataEntryValue]>;
     resetForm(): void;
-    private _toggle;
-    private _onKeydown;
+    private toggle;
+    private onKeydown;
     render(): import("lit-html").TemplateResult<1>;
 }
 declare global {

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

@@ -22,7 +22,7 @@ export default class SchmancyTextarea extends SchmancyTextarea_base {
         slotAssignment?: SlotAssignmentMode;
     };
     textareaRef: import("lit-html/directives/ref").Ref<HTMLTextAreaElement>;
-    private readonly _a11yId;
+    private readonly a11yId;
     /**
      * The placeholder of the control.
      * @attr placeholder

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

@@ -24,16 +24,16 @@ export declare class SchmancyFormSummary extends SchmancyElement {
      * Render bumper — incremented to force a re-render when the form's state
      * changes (the actual content is computed from the DOM in render()).
      */
-    private _bump;
-    private _form;
-    private _formObserver?;
+    private bump;
+    private form;
+    private formObserver?;
     connectedCallback(): void;
     disconnectedCallback(): void;
-    private _readFormStatus;
-    private _readFormMessage;
-    private _readInvalidFields;
+    private readFormStatus;
+    private readFormMessage;
+    private readInvalidFields;
     render(): import("lit-html").TemplateResult<1> | typeof nothing;
-    private _jumpToField;
+    private jumpToField;
 }
 declare global {
     interface HTMLElementTagNameMap {

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

@@ -43,24 +43,24 @@ export default class SchmancyForm<TSchema extends ParseSchema | undefined = unde
     schema?: TSchema;
     /** Skip built-in browser constraint validation. Mirrors `<form novalidate>`. */
     novalidate: boolean;
-    private _fields;
-    private _submitting;
+    private fields;
+    private submitting;
     /**
      * Local mirror of the submit-state status — drives the inline live region
      * synchronously. Independent of the schmancy-state library's resolution
      * chain (which has known cross-await fallback semantics) so the AT-facing
      * announcement is always correct for this form instance.
      */
-    private _liveStatus;
-    private _liveError;
-    private _internals;
+    private liveStatus;
+    private liveError;
+    private internals;
     connectedCallback(): void;
-    private _maybeRequestSubmit;
+    private maybeRequestSubmit;
     /** Active fields — drops stale refs from disconnected nodes. */
-    private get _activeFields();
-    private _onSubmit;
-    private _onReset;
-    private _broadcastStatus;
+    private get activeFields();
+    private onSubmit;
+    private onReset;
+    private broadcastStatus;
     /**
      * Server-side error mapping (RHF `setError(name, ...)`-equivalent).
      * Sets `setCustomValidity(message)` on the matching field and ensures the
@@ -76,7 +76,7 @@ export default class SchmancyForm<TSchema extends ParseSchema | undefined = unde
      * Clear the `submitted` flag on every registered field without resetting
      * their values. Wizard pattern: stepping back from a later step should not
      * leave the earlier step's fields in aggressive "show all errors" mode
-     * (which `submitted = true` triggers via the `_shouldShowError()` gate).
+     * (which `submitted = true` triggers via the `shouldShowError()` gate).
      *
      * Pristine fields with `validateOn: 'dirty'` go quiet again. Fields the
      * user actually dirtied keep showing their errors (correct UX — those are

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

@@ -20,8 +20,8 @@ declare global {
  */
 export default class SchmancyIcon extends SchmancyElement {
     static styles: import("lit").CSSResult[];
-    private _name;
-    private _observer?;
+    private name;
+    private observer?;
     connectedCallback(): void;
     disconnectedCallback(): void;
     protected render(): unknown;

package/types/src/iframe/iframe.d.ts

@@ -23,9 +23,9 @@ export default class SchmancyIframe extends SchmancyElement {
     sandbox: string;
     /** Minimum height in pixels */
     minHeight: number;
-    private _height;
-    private _srcdoc;
-    private _iframeRef;
+    private height;
+    private srcdoc;
+    private iframeRef;
     protected willUpdate(changed: PropertyValues): void;
     protected updated(changed: PropertyValues): void;
     private buildSrcdoc;

package/types/src/lightbox/flip-directive.d.ts

@@ -21,9 +21,9 @@ declare class FlipDirective extends AsyncDirective {
     private element?;
     private hasAnimated;
     constructor(partInfo: PartInfo);
-    render(_options?: FlipOptions): symbol;
+    render(options?: FlipOptions): symbol;
     update(part: ElementPart, [options]: [FlipOptions?]): symbol;
     private animateIn;
 }
-export declare const flip: (_options?: FlipOptions) => import("lit-html/directive").DirectiveResult<typeof FlipDirective>;
+export declare const flip: (options?: FlipOptions) => import("lit-html/directive").DirectiveResult<typeof FlipDirective>;
 export {};

package/types/src/lightbox/lightbox.directive.d.ts

@@ -16,7 +16,7 @@ declare class LightboxDirective extends AsyncDirective {
     private overlay?;
     private clickPosition?;
     constructor(partInfo: PartInfo);
-    render(_options?: LightboxOptions): symbol;
+    render(options?: LightboxOptions): symbol;
     update(part: ElementPart, [options]: [LightboxOptions?]): symbol;
     private open;
     private close;
@@ -26,5 +26,5 @@ declare class LightboxDirective extends AsyncDirective {
     private renderLightbox;
     disconnected(): void;
 }
-export declare const lightbox: (_options?: LightboxOptions) => import("lit-html/directive.js").DirectiveResult<typeof LightboxDirective>;
+export declare const lightbox: (options?: LightboxOptions) => import("lit-html/directive.js").DirectiveResult<typeof LightboxDirective>;
 export {};

package/types/src/nav-drawer/navbar.d.ts

@@ -6,7 +6,7 @@ export declare class SchmancyNavigationDrawerSidebar extends SchmancyElement {
     overlay: HTMLElement;
     nav: HTMLElement;
     width: string;
-    private _initialized;
+    private initialized;
     /**
      * firstUpdated()
      * Set initial styles based on the current mode and consumed state.

package/types/src/navigation-rail/navigation-rail.d.ts

@@ -59,6 +59,7 @@ export type LabelVisibility = 'all' | 'selected' | 'none';
  * </schmancy-navigation-rail>
  */
 export declare class SchmancyNavigationRail extends SchmancyElement {
+    #private;
     private activeIndex$;
     /**
      * The currently active item index
@@ -71,7 +72,6 @@ export declare class SchmancyNavigationRail extends SchmancyElement {
      */
     get activeValue(): string;
     set activeValue(value: string);
-    private _activeValue;
     /**
      * When to show labels for navigation items
      * 'all' - Always show labels for all items
@@ -108,7 +108,7 @@ export declare class SchmancyNavigationRail extends SchmancyElement {
      * Forwarded verbatim to the inner `<nav>` element.
      * When empty, the nav falls back to the M3 default: `flex flex-col gap-3`.
      */
-    private _hostLayoutClasses;
+    private hostLayoutClasses;
     private allElements;
     private get navigationItems();
     connectedCallback(): void;

package/types/src/notification/notification.d.ts

@@ -5,6 +5,7 @@ export type NotificationType = 'info' | 'success' | 'warning' | 'error';
  * @fires close - When notification is closed
  */
 export default class SchmancyNotification extends SchmancyElement {
+    #private;
     static styles: import("lit").CSSResult[];
     title: string;
     message: string;
@@ -18,10 +19,10 @@ export default class SchmancyNotification extends SchmancyElement {
         x: number;
         y: number;
     };
-    private _visible;
-    private _progress;
-    private _hovered;
-    private _closing;
+    private visible;
+    private progress;
+    private hovered;
+    private closing;
     private paused$;
     private startTime;
     private pausedAt;
@@ -30,11 +31,10 @@ export default class SchmancyNotification extends SchmancyElement {
     private animateIn;
     private setupAutoClose;
     private setupProgressUpdates;
-    private _playSound;
-    private _handleMouseEnter;
-    private _handleMouseLeave;
+    private handleMouseEnter;
+    private handleMouseLeave;
     close(): Promise<void>;
-    private _getTypeLabel;
+    private getTypeLabel;
     render(): import("lit-html").TemplateResult<1>;
 }
 declare global {

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

@@ -22,27 +22,27 @@ import type { CloseReason, Content, OverlayLayout, OverlayTier, ShowOptions } fr
  * `tier` / `layout` / `modal` as properties for the stack entry.
  */
 export declare class SchmancyOverlay extends SchmancyElement {
+    #private;
     static styles: import("lit").CSSResult[];
     layout: OverlayLayout;
     dismissable: boolean;
     modal: boolean;
     tier: OverlayTier;
-    private _active;
-    private _full;
-    private _backdrop?;
-    private _surface;
-    private _shell?;
-    /** 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;
+    private active;
+    private full;
+    private backdrop?;
+    private surface;
+    private shell?;
+    private mounted;
+    private closing;
+    private resolvedAnchor?;
+    private rawAnchor?;
+    private anchorOriginAnchor?;
+    private positionerTeardown?;
+    private factoryEffectDispose?;
+    private lastFocusedElement;
+    private inertedSiblings;
+    private lastReResolveAt;
     /** Service subscribes to this to know when the overlay dismissed. */
     get closed$(): import('rxjs').Observable<{
         reason: CloseReason;

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

@@ -31,7 +31,7 @@ export declare class SchmancyOverlayPromptBody extends SchmancyElement {
     inputType: 'text' | 'email' | 'password' | 'tel' | 'url' | 'number' | 'search' | 'date' | 'time' | 'datetime-local';
     pattern?: string;
     required: boolean;
-    private _schmancyInput?;
+    private schmancyInput?;
     firstUpdated(): void;
     private dismiss;
     private handleCancel;

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

@@ -2,8 +2,10 @@ import type { TemplateResult } from 'lit';
 import type { Observable } from 'rxjs';
 import type { ComponentType, THistoryStrategy } from '../area/router.types';
 /**
- * Sync factory that returns a TemplateResult. Called at mount time so closed-over
- * variables are evaluated lazily — no snapshot staleness.
+ * Sync factory returning a TemplateResult. Invoked at mount and re-invoked
+ * whenever a signal read inside it changes — the factory's reactivity matches
+ * a component's render(). Prefer it over the eager html`` form whenever the
+ * template reads reactive state.
  */
 export type TemplateFactory = () => TemplateResult;
 /**

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

@@ -39,7 +39,7 @@ export default class SchmancySplashScreen extends SchmancyElement {
      * When true, the splash starts hidden. Use this for imperative control.
      */
     initiallyHidden: boolean;
-    private _visible;
+    private visible;
     connectedCallback(): void;
     /**
      * Imperative API: signal that the app is ready and dismiss the splash
@@ -50,7 +50,7 @@ export default class SchmancySplashScreen extends SchmancyElement {
      * Force the splash to show again (e.g. between route transitions).
      */
     show(): void;
-    private _dismiss;
+    private dismiss;
     render(): import("lit-html").TemplateResult<1>;
 }
 declare global {

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

@@ -88,7 +88,7 @@ export interface BaseAPI<NS extends string, T, S extends StorageBackend> {
      *  current value. Exposed on the type so a state can be passed to
      *  `<schmancy-context provides={[…]}>` without casts. Not for end-user
      *  code — the leading underscore signals "internal API". */
-    _isolatedInstance(): {
+    isolatedInstance(): {
         destroy(): void;
     } & Record<string | symbol, unknown>;
 }

package/types/src/state/schmancy-context.d.ts

@@ -9,7 +9,7 @@ export interface StateTemplate {
      *  per-context copy seeded with the current value, sharing nothing with the
      *  global instance. The returned object exposes `destroy()` so the context
      *  element can flush + close on disconnect. */
-    _isolatedInstance(): {
+    isolatedInstance(): {
         destroy(): void;
     } & Record<string | symbol, unknown>;
 }
@@ -19,8 +19,8 @@ export declare class SchmancyContext extends SchmancyElement {
      *  they continue to behave as module-scoped globals; descendants of this
      *  element see a per-element isolated copy. */
     provides: readonly StateTemplate[];
-    private _scoped;
-    private _publishEventTargetAsHost;
+    private scoped;
+    private publishEventTargetAsHost;
     connectedCallback(): void;
     disconnectedCallback(): void;
     render(): import("lit-html").TemplateResult<1>;

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

@@ -1,3 +1,3 @@
 export * from './schmancy-step';
-export * from './schmancy-steps-container';
+export * from './schmancy-steps';
 export * from './steps.context';

package/types/src/steps/schmancy-step.d.ts

@@ -7,14 +7,9 @@ export declare class SchmancyStep extends SchmancyElement {
      * "current", or "upcoming".
      */
     position: number;
-    title: string;
+    label: string;
     description: string;
     completed: boolean;
-    /**
-     * NEW: Lock API to disable users from going back.
-     * When set to true, clicking on a previous (completed) step is ignored.
-     */
-    lockBack: boolean;
     /**
      * Consume the shared StepsController from context.
      */
@@ -23,28 +18,18 @@ export declare class SchmancyStep extends SchmancyElement {
      * Local reactive copy of the container's current step number.
      */
     private currentStep;
-    /**
-     * Keep a reference to our subscription so we can unsubscribe cleanly.
-     */
-    private subscription?;
+    private hasContent;
+    private assignedNodes;
     connectedCallback(): void;
     firstUpdated(): void;
-    disconnectedCallback(): void;
-    /**
-     * Update the host element's flex properties based on active state
-     */
+    private onSlotChange;
     private updateFlexProperties;
-    /**
-     * Compute visual status for styling purposes. Note that if a step is explicitly
-     * marked as completed, it always appears as complete even if it's active.
-     */
     get status(): 'complete' | 'current' | 'upcoming';
-    /**
-     * Click handler to allow navigation between completed (or active) steps.
-     * With lockBack enabled, clicking on a previous step is ignored.
-     */
-    private _onStepClick;
+    private onStepClick;
+    private onStepKeydown;
     render(): import("lit-html").TemplateResult<1>;
+    private renderContentRow;
+    private renderRailRow;
 }
 declare global {
     interface HTMLElementTagNameMap {

package/types/src/steps/{schmancy-steps-container.d.ts → schmancy-steps.d.ts}

@@ -8,27 +8,26 @@ import { StepsController } from './steps.context';
 export type SchmancyStepsChangeEvent = CustomEvent<{
     value: number;
 }>;
-export declare class SchmancyStepsContainer extends SchmancyElement {
+export declare class SchmancySteps extends SchmancyElement {
     static styles: import("lit").CSSResult[];
     private controller;
     stepsController: StepsController;
-    set currentStep(value: number);
-    get currentStep(): number;
+    set value(v: number);
+    get value(): number;
     /**
-     * Gap between steps. Maps to Tailwind gap classes.
-     * @default 4
+     * Block back-navigation for the whole stepper.
      */
-    gap: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12 | 16 | 20 | 24;
+    set lockBack(v: boolean);
+    get lockBack(): boolean;
     connectedCallback(): void;
     /**
-     * Handle change events - stop propagation of bubbled events from children.
-     * This prevents form inputs inside steps from triggering the parent's @change handler.
+     * Handle change events — stop propagation of bubbled events from children.
      */
     private handleChange;
     render(): import("lit-html").TemplateResult<1>;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'schmancy-steps-container': SchmancyStepsContainer;
+        'schmancy-steps': SchmancySteps;
     }
 }