@sekiui/elements 0.1.3 → 0.1.4

package/dist/types/components/drawer/seki-drawer.d.ts

@@ -54,8 +54,12 @@ export declare class SekiDrawer {
      * event shape so a consumer can listen to one event name across every overlay.
      */
     sekiOpenChange: EventEmitter<boolean>;
+    /**
+     * Internal: notifies seki-drawer-content that `_drawerContext` changed. Not
+     * part of the public API; listen to `sekiOpenChange` instead.
+     */
+    drawerContextChange: EventEmitter<void>;
     componentWillLoad(): void;
-    componentDidLoad(): void;
     handleOpenPropChange(newValue: boolean): void;
     /**
      * Opens the drawer

package/dist/types/components/field-label/seki-field-label.d.ts

@@ -2,7 +2,8 @@ export declare class SekiFieldLabel {
     el: HTMLElement;
     /**
      * ID of the form control this label is for
-     * Sets the `for` attribute on the label element
+     * Resolved in the label's own root node (not this component's shadow root), so it
+     * reaches light-DOM controls. Falls back to the control nested in the label.
      */
     htmlFor?: string;
     /**
@@ -10,5 +11,12 @@ export declare class SekiFieldLabel {
      * Displays a required indicator (*) after the label text
      */
     required: boolean;
+    private binding?;
+    onForChange(): void;
+    /** Forward clicks to the labelled control (see utils/label-association.ts). */
+    onClick(event: MouseEvent): void;
+    connectedCallback(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
     render(): any;
 }

package/dist/types/components/label/seki-label.d.ts

@@ -10,8 +10,10 @@
 export declare class SekiLabel {
     el: HTMLElement;
     /**
-     * The ID of the form element this label is associated with.
-     * Maps to the `htmlFor` attribute on the inner `<label>` element.
+     * The ID of the form element this label is associated with. Resolved in the
+     * label's own root node (document or shadow root), not in this component's
+     * shadow root, so it reaches light-DOM controls. Without it, the first control
+     * nested inside the label is used.
      */
     for?: string;
     /**
@@ -24,5 +26,12 @@ export declare class SekiLabel {
      * @default false
      */
     disabled?: boolean;
+    private binding?;
+    onForChange(): void;
+    /** Forward clicks to the labelled control (see utils/label-association.ts). */
+    onClick(event: MouseEvent): void;
+    connectedCallback(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
     render(): any;
 }

package/dist/types/components/popover/seki-popover-content.d.ts

@@ -9,7 +9,11 @@ import type { PopoverSide, PopoverAlign } from './seki-popover';
 export declare class SekiPopoverContent {
     el: HTMLElement;
     private contentRef?;
-    private popoverEl?;
+    private popoverConsumer;
+    /**
+     * Re-read the parent's context. Runs once on connect (picking up a popover
+     * that is already open) and on every publish.
+     */
     private onPopoverOpenChange;
     /**
      * Override side from parent
@@ -34,8 +38,7 @@ export declare class SekiPopoverContent {
     };
     _actualSide: PopoverSide;
     private getContext;
-    componentWillRender(): void;
-    componentDidLoad(): void;
+    connectedCallback(): void;
     componentDidRender(): void;
     private updatePosition;
     disconnectedCallback(): void;

package/dist/types/components/popover/seki-popover.d.ts

@@ -57,10 +57,16 @@ export declare class SekiPopover {
      * Emitted when open state changes
      */
     sekiOpenChange: EventEmitter<boolean>;
+    /**
+     * Internal: notifies popover parts that `_popoverContext` changed. Not part
+     * of the public API; listen to `sekiOpenChange` instead.
+     */
+    popoverContextChange: EventEmitter<void>;
     private clickOutsideHandler?;
     private clickOutsideTimeout?;
     componentWillLoad(): void;
     openChanged(newValue: boolean): void;
+    placementChanged(): void;
     /**
      * Open the popover
      */
@@ -79,8 +85,8 @@ export declare class SekiPopover {
     private setupClickOutside;
     private removeClickOutside;
     private getContext;
+    private publish;
     componentDidLoad(): void;
-    componentDidUpdate(): void;
     disconnectedCallback(): void;
     render(): any;
 }

package/dist/types/components/select/seki-select.d.ts

@@ -74,6 +74,14 @@ export declare class SekiSelect {
     handleIsOpenChange(): void;
     handleInternalValueChange(): void;
     handleDisabledChange(): void;
+    /**
+     * The trigger's label comes from the registered options, so registering an
+     * option must notify the parts. Before #323 this was only a silent property
+     * write in componentDidRender, and a trigger that rendered before the
+     * selected option registered stayed on the placeholder.
+     */
+    handleRegisteredOptionsChange(): void;
+    private registrationPublishQueued;
     formResetCallback(): void;
     formDisabledCallback(disabled: boolean): void;
     formStateRestoreCallback(state: FormControlState): void;

package/dist/types/components/select-content/seki-select-content.d.ts

@@ -5,9 +5,10 @@ export declare class SekiSelectContent {
     el: HTMLElement;
     forceUpdate: number;
     private scrollContainerRef?;
-    componentDidLoad(): void;
+    private selectConsumer;
+    connectedCallback(): void;
     disconnectedCallback(): void;
-    private handleParentOpenChange;
+    private handleParentContextChange;
     /** Scroll to make an option visible */
     scrollToOption(optionId: string): Promise<void>;
     private getSelectContext;

package/dist/types/components/select-option/seki-select-option.d.ts

@@ -20,10 +20,16 @@ export declare class SekiSelectOption {
         value: string | number;
     }>;
     private get optionId();
-    private hasRegistered;
-    private contextSubscription;
-    componentDidLoad(): void;
+    /**
+     * The registerOption function this option last registered through. It is a
+     * stable per-select-instance function, so comparing it tells "already
+     * registered with this select" apart from "the select published its context
+     * for the first time" or "moved to a different select".
+     */
+    private registeredVia?;
+    private selectConsumer;
     connectedCallback(): void;
+    componentDidLoad(): void;
     disconnectedCallback(): void;
     /**
      * Refresh aria-selected/data-selected/data-focused directly on the

package/dist/types/components/select-trigger/seki-select-trigger.d.ts

@@ -6,11 +6,17 @@ export declare class SekiSelectTrigger {
     el: HTMLElement;
     forceUpdate: number;
     private buttonRef?;
-    private contextSubscription;
-    componentDidLoad(): void;
+    private selectConsumer;
+    connectedCallback(): void;
     disconnectedCallback(): void;
-    private handleParentOpenChange;
-    private handleParentValueChange;
+    /**
+     * Listeners follow the button element itself: the button only exists once a
+     * context is available (the first render may be the "Loading..." fallback
+     * when this trigger upgrades before its seki-select), so binding once in
+     * componentDidLoad could miss it entirely.
+     */
+    private setButtonRef;
+    private handleParentContextChange;
     private handleButtonClick;
     private handleButtonKeyDown;
     private getSelectContext;

package/dist/types/components/sheet/seki-sheet-content.d.ts

@@ -21,12 +21,16 @@ export declare class SekiSheetContent {
      * seki-sheet parent (e.g. mounted standalone).
      */
     _isOpen: boolean;
-    private sheetEl?;
+    private sheetConsumer;
     private handleCloseClick;
-    private onSheetOpenChange;
+    /**
+     * Re-read the parent's open state. Runs once on connect (picking up a sheet
+     * that is already open, e.g. `<seki-sheet open>`) and on every publish.
+     */
     private syncOpenState;
-    componentWillLoad(): void;
-    componentDidLoad(): void;
+    connectedCallback(): void;
     disconnectedCallback(): void;
+    /** Propagate the side attribute to the parent for CSS targeting. */
+    propagateSide(): void;
     render(): any;
 }

package/dist/types/components/sheet/seki-sheet.d.ts

@@ -45,8 +45,12 @@ export declare class SekiSheet {
      * event shape so a consumer can listen to one event name across every overlay.
      */
     sekiOpenChange: EventEmitter<boolean>;
+    /**
+     * Internal: notifies seki-sheet-content that `_sheetContext` changed. Not
+     * part of the public API; listen to `sekiOpenChange` instead.
+     */
+    sheetContextChange: EventEmitter<void>;
     componentWillLoad(): void;
-    componentDidLoad(): void;
     handleOpenPropChange(newValue: boolean): void;
     /**
      * Opens the sheet

package/dist/types/components.d.ts

@@ -18,7 +18,7 @@ import { CarouselContext } from "./components/carousel/seki-carousel";
 import { ChartData, ChartOptions, ChartType } from "./components/chart/chart-types";
 import { ChartLegendConfig } from "./components/chart-legend/seki-chart-legend";
 import { ComboboxChangeEventDetail, ComboboxCustomValueEventDetail, ComboboxEmptyReason, ComboboxItem, ComboboxMultiSelectDisplay, ComboboxSearchEventDetail, ComboboxValue } from "./utils/combobox";
-import { ColumnDef, ColumnReorderDetail, ColumnResizeDetail, ColumnsChangeDetail, FilterChangeDetail, FilterValue, PageChangeDetail, RowClickDetail, RowExpandDetail, SelectionChangeDetail, SortChangeDetail } from "./components/data-table/interfaces";
+import { ColumnDef, ColumnReorderDetail, ColumnResizeDetail, ColumnsChangeDetail, FetchDataCallback, FilterChangeDetail, FilterValue, PageChangeDetail, RenderExpandedRowCallback, RowClickDetail, RowExpandDetail, SelectionChangeDetail, SortChangeDetail } from "./components/data-table/interfaces";
 import { DatePickerMode, DateRange as DateRange1 } from "./components/date-picker/seki-date-picker";
 import { DrawerDirection } from "./components/drawer/seki-drawer-content";
 import { DropdownMenuAlign, DropdownMenuSide } from "./components/dropdown-menu/seki-dropdown-menu";
@@ -58,7 +58,7 @@ export { CarouselContext } from "./components/carousel/seki-carousel";
 export { ChartData, ChartOptions, ChartType } from "./components/chart/chart-types";
 export { ChartLegendConfig } from "./components/chart-legend/seki-chart-legend";
 export { ComboboxChangeEventDetail, ComboboxCustomValueEventDetail, ComboboxEmptyReason, ComboboxItem, ComboboxMultiSelectDisplay, ComboboxSearchEventDetail, ComboboxValue } from "./utils/combobox";
-export { ColumnDef, ColumnReorderDetail, ColumnResizeDetail, ColumnsChangeDetail, FilterChangeDetail, FilterValue, PageChangeDetail, RowClickDetail, RowExpandDetail, SelectionChangeDetail, SortChangeDetail } from "./components/data-table/interfaces";
+export { ColumnDef, ColumnReorderDetail, ColumnResizeDetail, ColumnsChangeDetail, FetchDataCallback, FilterChangeDetail, FilterValue, PageChangeDetail, RenderExpandedRowCallback, RowClickDetail, RowExpandDetail, SelectionChangeDetail, SortChangeDetail } from "./components/data-table/interfaces";
 export { DatePickerMode, DateRange as DateRange1 } from "./components/date-picker/seki-date-picker";
 export { DrawerDirection } from "./components/drawer/seki-drawer-content";
 export { DropdownMenuAlign, DropdownMenuSide } from "./components/dropdown-menu/seki-dropdown-menu";
@@ -1449,6 +1449,11 @@ export namespace Components {
           * @default false
          */
         "expandable": boolean;
+        /**
+          * Callback to fetch data. Set it as a JS property. Assigning or replacing it (re)loads the table. Must be a
+          * @Prop : in the lazy-loader build only decorated members are proxied from the host element to the instance.
+         */
+        "fetchData"?: FetchDataCallback;
         /**
           * Get current filter state
          */
@@ -1485,6 +1490,11 @@ export namespace Components {
           * Refresh data
          */
         "refresh": () => Promise<void>;
+        /**
+          * Callback to render expanded row content (must be a
+          * @Prop , see fetchData)
+         */
+        "renderExpandedRow"?: RenderExpandedRowCallback;
         /**
           * Fixed row height for virtualization
           * @default 48
@@ -2008,7 +2018,7 @@ export namespace Components {
     }
     interface SekiFieldLabel {
         /**
-          * ID of the form control this label is for Sets the `for` attribute on the label element
+          * ID of the form control this label is for Resolved in the label's own root node (not this component's shadow root), so it reaches light-DOM controls. Falls back to the control nested in the label.
          */
         "htmlFor"?: string;
         /**
@@ -2359,7 +2369,7 @@ export namespace Components {
          */
         "disabled"?: boolean;
         /**
-          * The ID of the form element this label is associated with. Maps to the `htmlFor` attribute on the inner `<label>` element.
+          * The ID of the form element this label is associated with. Resolved in the label's own root node (document or shadow root), not in this component's shadow root, so it reaches light-DOM controls. Without it, the first control nested inside the label is used.
          */
         "for"?: string;
         /**
@@ -4710,6 +4720,7 @@ declare global {
     };
     interface HTMLSekiAlertDialogElementEventMap {
         "sekiOpenChange": boolean;
+        "sekiContextChange": void;
     }
     /**
      * Alert Dialog root component for confirmation dialogs
@@ -5480,6 +5491,7 @@ declare global {
     };
     interface HTMLSekiCollapsibleElementEventMap {
         "sekiOpenChange": boolean;
+        "sekiContextChange": void;
     }
     interface HTMLSekiCollapsibleElement extends Components.SekiCollapsible, HTMLStencilElement {
         addEventListener<K extends keyof HTMLSekiCollapsibleElementEventMap>(type: K, listener: (this: HTMLSekiCollapsibleElement, ev: SekiCollapsibleCustomEvent<HTMLSekiCollapsibleElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
@@ -5576,6 +5588,7 @@ declare global {
     interface HTMLSekiCommandElementEventMap {
         "sekiValueChange": string;
         "sekiSelect": string;
+        "sekiContextChange": void;
     }
     /**
      * Command root component - command palette for navigation
@@ -5775,6 +5788,7 @@ declare global {
     };
     interface HTMLSekiDialogElementEventMap {
         "sekiOpenChange": boolean;
+        "sekiContextChange": void;
     }
     /**
      * Dialog root component for modal dialogs
@@ -5927,6 +5941,7 @@ declare global {
         "drawerClose": void;
         "drawerSnap": { point: number };
         "sekiOpenChange": boolean;
+        "sekiContextChange": void;
     }
     /**
      * seki-drawer: Mobile-friendly drawer component with swipe gestures
@@ -7093,6 +7108,7 @@ declare global {
     };
     interface HTMLSekiPopoverElementEventMap {
         "sekiOpenChange": boolean;
+        "sekiContextChange": void;
     }
     /**
      * Popover component - floating content triggered by click
@@ -7388,6 +7404,7 @@ declare global {
         "sheetOpen": void;
         "sheetClose": void;
         "sekiOpenChange": boolean;
+        "sekiContextChange": void;
     }
     /**
      * seki-sheet: Root sheet component (slide-out panel)
@@ -8350,6 +8367,10 @@ declare namespace LocalJSX {
           * @default false
          */
         "defaultOpen"?: boolean;
+        /**
+          * Internal: notifies alert dialog parts that `_alertDialogContext` changed. Not part of the public API; listen to `sekiOpenChange` instead.
+         */
+        "onSekiContextChange"?: (event: SekiAlertDialogCustomEvent<void>) => void;
         /**
           * Emitted when open state changes
          */
@@ -9308,6 +9329,10 @@ declare namespace LocalJSX {
           * @default false
          */
         "disabled"?: boolean;
+        /**
+          * Internal: notifies collapsible parts that `_collapsibleContext` changed. Not part of the public API; listen to `sekiOpenChange` instead.
+         */
+        "onSekiContextChange"?: (event: SekiCollapsibleCustomEvent<void>) => void;
         /**
           * Emitted when open state changes
          */
@@ -9476,6 +9501,10 @@ declare namespace LocalJSX {
           * @default true
          */
         "filter"?: boolean;
+        /**
+          * Internal: notifies command parts (input, items, groups, empty state) that `_commandContext` changed. Not part of the public API; listen to `sekiValueChange` instead.
+         */
+        "onSekiContextChange"?: (event: SekiCommandCustomEvent<void>) => void;
         /**
           * Emitted when an item is selected
          */
@@ -9641,6 +9670,11 @@ declare namespace LocalJSX {
           * @default false
          */
         "expandable"?: boolean;
+        /**
+          * Callback to fetch data. Set it as a JS property. Assigning or replacing it (re)loads the table. Must be a
+          * @Prop : in the lazy-loader build only decorated members are proxied from the host element to the instance.
+         */
+        "fetchData"?: FetchDataCallback;
         /**
           * Show loading state
           * @default false
@@ -9697,6 +9731,11 @@ declare namespace LocalJSX {
           * @default '[25, 50, 100]'
          */
         "pageSizeOptions"?: string | number[];
+        /**
+          * Callback to render expanded row content (must be a
+          * @Prop , see fetchData)
+         */
+        "renderExpandedRow"?: RenderExpandedRowCallback;
         /**
           * Fixed row height for virtualization
           * @default 48
@@ -9839,6 +9878,10 @@ declare namespace LocalJSX {
           * @default true
          */
         "modal"?: boolean;
+        /**
+          * Internal: notifies dialog parts (content, overlay, title, description) that `_dialogContext` changed. Not part of the public API; listen to `sekiOpenChange` instead.
+         */
+        "onSekiContextChange"?: (event: SekiDialogCustomEvent<void>) => void;
         /**
           * Emitted when open state changes
          */
@@ -9950,6 +9993,10 @@ declare namespace LocalJSX {
           * Emitted when the drawer snaps to a point
          */
         "onDrawerSnap"?: (event: SekiDrawerCustomEvent<{ point: number }>) => void;
+        /**
+          * Internal: notifies seki-drawer-content that `_drawerContext` changed. Not part of the public API; listen to `sekiOpenChange` instead.
+         */
+        "onSekiContextChange"?: (event: SekiDrawerCustomEvent<void>) => void;
         /**
           * Emitted whenever the open state changes. Matches the dialog/popover/collapsible event shape so a consumer can listen to one event name across every overlay.
          */
@@ -10225,7 +10272,7 @@ declare namespace LocalJSX {
     }
     interface SekiFieldLabel {
         /**
-          * ID of the form control this label is for Sets the `for` attribute on the label element
+          * ID of the form control this label is for Resolved in the label's own root node (not this component's shadow root), so it reaches light-DOM controls. Falls back to the control nested in the label.
          */
         "htmlFor"?: string;
         /**
@@ -10628,7 +10675,7 @@ declare namespace LocalJSX {
          */
         "disabled"?: boolean;
         /**
-          * The ID of the form element this label is associated with. Maps to the `htmlFor` attribute on the inner `<label>` element.
+          * The ID of the form element this label is associated with. Resolved in the label's own root node (document or shadow root), not in this component's shadow root, so it reaches light-DOM controls. Without it, the first control nested inside the label is used.
          */
         "for"?: string;
         /**
@@ -11424,6 +11471,10 @@ declare namespace LocalJSX {
           * @default false
          */
         "defaultOpen"?: boolean;
+        /**
+          * Internal: notifies popover parts that `_popoverContext` changed. Not part of the public API; listen to `sekiOpenChange` instead.
+         */
+        "onSekiContextChange"?: (event: SekiPopoverCustomEvent<void>) => void;
         /**
           * Emitted when open state changes
          */
@@ -11864,6 +11915,10 @@ declare namespace LocalJSX {
           * @default false
          */
         "defaultOpen"?: boolean;
+        /**
+          * Internal: notifies seki-sheet-content that `_sheetContext` changed. Not part of the public API; listen to `sekiOpenChange` instead.
+         */
+        "onSekiContextChange"?: (event: SekiSheetCustomEvent<void>) => void;
         /**
           * Emitted whenever the open state changes. Matches the dialog/popover/collapsible event shape so a consumer can listen to one event name across every overlay.
          */

package/dist/types/utils/context-bridge.d.ts

@@ -3,10 +3,25 @@
  *
  * Generalizes the "parent publishes state onto its host element + child
  * subscribes via closest()" pattern used by compound components (select,
- * toggle-group, combobox, ...). Each parent calls publishContext() from its
- * updateContextOnElement()-equivalent method; each child calls
- * subscribeToContextChange() once in componentDidLoad() and the returned
- * unsubscribe() in disconnectedCallback().
+ * toggle-group, combobox, dialog, popover, ...).
+ *
+ * Parent (provider) contract:
+ *   - call publishContext() from componentWillLoad(), so the context exists
+ *     before any child renders for the first time, and
+ *   - call it again on every state change, including changes that arrive as a
+ *     @Prop assignment (@Watch) rather than through a @Method or user input.
+ *
+ * Child (consumer) contract — use a ContextConsumer:
+ *   - call connect(this.el) from connectedCallback() (runs before the first
+ *     render, and again after the element is moved to a new parent), and
+ *   - call disconnect() from disconnectedCallback().
+ *   connect() invokes the callback once immediately, so a child that
+ *   upgrades after its parent already published still starts from the current
+ *   state; a child that upgrades before its parent (one-module-per-tag
+ *   loading, #314) hears the parent's first publish from componentWillLoad().
+ *
+ * subscribeToContextChange() is the older listener-only form (no immediate
+ * read, light-DOM closest() only); prefer ContextConsumer for new code.
  *
  * Extracted after the same bug (child freezes at mount-time state because
  * nothing told it the parent changed) was independently fixed three times
@@ -43,3 +58,52 @@ export declare function subscribeToContextChange(el: HTMLElement, parentSelector
     parent: HTMLElement | null;
     unsubscribe: () => void;
 };
+/**
+ * Nearest ancestor matching `selector`, continuing past shadow roots: when the
+ * element's own tree has no match, the search resumes from the shadow host.
+ * This lets a part rendered inside another component's shadow tree still find
+ * the provider that wraps that component.
+ */
+export declare function findContextProvider(el: Element, selector: string): HTMLElement | null;
+/**
+ * Child-side: tracks one provider (see findContextProvider) for a part.
+ *
+ *   private dialog = new ContextConsumer<DialogContext>('seki-dialog', '_dialogContext', () => this.sync());
+ *   connectedCallback() { this.dialog.connect(this.el); }
+ *   disconnectedCallback() { this.dialog.disconnect(); }
+ *
+ * connect() finds the provider, starts listening for its context-change
+ * notifications and calls `onChange` once right away, so the part starts from
+ * whatever is already published. `parent` and `context` are already set when
+ * that first call happens. Calling connect() from connectedCallback runs it
+ * before the first render and again after the part is moved to another
+ * provider.
+ *
+ * `onChange` gets no event payload by design (see SEKI_CONTEXT_CHANGE_EVENT):
+ * it reads the live `context`. Notifications bubbling up from a nested
+ * provider are ignored; only events dispatched by this part's own provider
+ * host (or retargeted to it from that host's shadow tree) count.
+ *
+ * Works whether or not the provider element has been upgraded yet: the
+ * listener sits on the element itself, so the provider's first
+ * publishContext() from componentWillLoad() reaches it.
+ */
+export declare class ContextConsumer<T> {
+    private readonly parentSelector;
+    private readonly propertyName;
+    private readonly onChange;
+    private provider;
+    constructor(parentSelector: string, propertyName: string, onChange: (context: T | null) => void);
+    /** The provider element found by the last connect(), or null. */
+    get parent(): HTMLElement | null;
+    /** The provider's current context, or null when there is none yet. */
+    get context(): T | null;
+    connect(host: HTMLElement): void;
+    disconnect(): void;
+    private handleEvent;
+}
+/**
+ * Read a context object a provider published with publishContext(). Returns
+ * null when there is no provider or it has not published yet.
+ */
+export declare function readContext<T>(parent: Element | null | undefined, propertyName: string): T | null;

package/dist/types/utils/label-association.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Label association for `seki-label` and `seki-field-label`.
+ *
+ * ## Why this exists
+ *
+ * Both labels render their text inside a shadow root. A native `<label for>`
+ * resolves its `for` id inside the tree the `<label>` lives in, so a `<label>`
+ * in our shadow root can never reach a control in the page's light DOM: clicks
+ * did nothing and the control had no accessible name (#329).
+ *
+ * The host element (`<seki-label>`) *does* live in the consumer's tree, so the
+ * wiring is done from the host in script, resolving the id against
+ * `host.getRootNode()` (the label's own root, which is where an author expects
+ * `for` to point, also when the label sits inside another component's shadow
+ * root together with its control).
+ *
+ * ## Behaviour
+ *
+ * - **Activation**: a click on the label forwards to the target the way a native
+ *   label would. Toggles (checkbox, switch, radio) are clicked, text-like
+ *   controls are focused. A click that originated on the control itself (the
+ *   wrapping form `<seki-label><seki-checkbox/> Text</seki-label>`) is ignored so
+ *   the control never toggles twice.
+ * - **Accessible name**: a shadow-DOM control hides its real focusable element
+ *   (`<button role="checkbox">`, `<input>`, ...) inside its own shadow root, and
+ *   an `aria-labelledby` id reference cannot cross a shadow boundary, so
+ *   pointing the host at the label would not name the inner element. SekiUI
+ *   controls all forward their `aria-label` attribute to that inner element, so
+ *   for them the label text is passed through as `aria-label`. For native
+ *   elements the reference does resolve, so we use `aria-labelledby` and the
+ *   name tracks the label's live content.
+ *   Anything the author set explicitly (`aria-label`, `aria-labelledby`) is
+ *   never overwritten; we only manage values we wrote ourselves, tracked with a
+ *   marker attribute so they can be updated and cleaned up.
+ *   `ElementInternals.ariaLabelledByElements` is deliberately not used: it is
+ *   unavailable in Firefox and older Safari, and cannot reach the inner element
+ *   of a shadow-DOM control either.
+ */
+export declare class LabelBinding {
+    private readonly host;
+    private readonly getFor;
+    private target;
+    private observer?;
+    constructor(host: HTMLElement, getFor: () => string | undefined);
+    /** Resolve the control this label is for, in the label's own root. */
+    resolveTarget(): HTMLElement | null;
+    /** Label text, without the text of a control nested inside the label. */
+    private labelText;
+    /** (Re)apply the accessible name. Call on load, `for` change and slot change. */
+    sync(): void;
+    /** Remove anything this binding wrote on the current target. */
+    release(): void;
+    /** Re-sync when the control is added after the label (async rendering). */
+    observe(): void;
+    disconnect(): void;
+    /** Forward a click on the label to its control, as a native label would. */
+    handleClick(event: Event): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sekiui/elements",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Modern, accessible Web Components with shadcn/ui-inspired design",
   "main": "dist/index.cjs.js",
   "module": "dist/index.js",

package/dist/cdn/p-DJMgrCw3.js

@@ -1,54 +0,0 @@
-/**
- * Context Bridge Utility
- *
- * Generalizes the "parent publishes state onto its host element + child
- * subscribes via closest()" pattern used by compound components (select,
- * toggle-group, combobox, ...). Each parent calls publishContext() from its
- * updateContextOnElement()-equivalent method; each child calls
- * subscribeToContextChange() once in componentDidLoad() and the returned
- * unsubscribe() in disconnectedCallback().
- *
- * Extracted after the same bug (child freezes at mount-time state because
- * nothing told it the parent changed) was independently fixed three times
- * for select (#244/#253), toggle-group (#255/#257), and combobox (#258/#259).
- */
-/**
- * One event name shared by every compound-component family. Stencil's
- * @Event() emits with { bubbles: true, composed: true } by default, so a
- * nested compound (e.g. a toggle-group rendered inside a select) can cause an
- * inner parent's event to bubble past an outer parent's own children. This is
- * harmless today only because subscribeToContextChange()'s callback takes no
- * payload and every handler re-reads its own closest() parent's live context
- * rather than trusting event.detail — do not add a payload to this event or
- * that bubbling becomes a real cross-family bug.
- */
-const SEKI_CONTEXT_CHANGE_EVENT = 'sekiContextChange';
-/**
- * Parent-side: publish a fresh context object onto the host element and
- * notify subscribed children. Must assign a plain property, not a class
- * accessor of the same name — in the dist-custom-elements build the class
- * IS the host element, so an accessor collision throws (#254).
- */
-function publishContext(el, propertyName, context, emitter) {
-    el[propertyName] = context;
-    emitter.emit();
-}
-/**
- * Child-side: find the nearest ancestor matching parentSelector and listen
- * for context-change notifications. onChange is called with no payload by
- * design — children re-read the live context property via closest() rather
- * than trusting a stale event.detail snapshot. No-ops safely (null parent,
- * no-op unsubscribe) if no matching parent is found.
- */
-function subscribeToContextChange(el, parentSelector, onChange) {
-    const parent = el.closest(parentSelector);
-    if (parent) {
-        parent.addEventListener(SEKI_CONTEXT_CHANGE_EVENT, onChange);
-    }
-    return {
-        parent,
-        unsubscribe: () => parent === null || parent === void 0 ? void 0 : parent.removeEventListener(SEKI_CONTEXT_CHANGE_EVENT, onChange),
-    };
-}
-
-export { publishContext as p, subscribeToContextChange as s };