@aceshooting/lyra-ui 4.2.0 → 5.0.0

package/dist/components/spinner/spinner.class.js

@@ -1,43 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { html } from 'lit';
-import { property } from 'lit/decorators.js';
-import { LyraElement } from '../../internal/lyra-element.js';
-import { styles } from './spinner.styles.js';
-/**
- * `<lr-spinner>` — an indeterminate busy indicator.
- *
- * @customElement lr-spinner
- * @slot - Optional visible label.
- * @csspart base - The wrapper.
- * @csspart spinner - The animated indicator.
- * @csspart label - The accessible/visible label wrapper.
- */
-export class LyraSpinner extends LyraElement {
-    constructor() {
-        super(...arguments);
-        this.labelPlacement = 'none';
-        /** Accessible name for the busy status, forwarded from a host `aria-label`. When unset, the
-         *  localized "Loading…" default provides the name. */
-        this.accessibleLabel = null;
-    }
-    static { this.styles = [LyraElement.styles, styles]; }
-    render() {
-        const label = this.accessibleLabel || this.localize('loading');
-        return html `<span part="base" role="status" aria-label=${label}>
-      <span part="spinner" aria-hidden="true"></span>
-      <span part="label" ?hidden=${this.labelPlacement === 'none'}><slot></slot></span>
-    </span>`;
-    }
-}
-__decorate([
-    property({ attribute: 'label-placement', reflect: true })
-], LyraSpinner.prototype, "labelPlacement", void 0);
-__decorate([
-    property({ attribute: 'aria-label' })
-], LyraSpinner.prototype, "accessibleLabel", void 0);
-//# sourceMappingURL=spinner.class.js.map

package/dist/components/spinner/spinner.class.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"spinner.class.js","sourceRoot":"","sources":["../../../src/components/spinner/spinner.class.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,IAAI,EAAuB,MAAM,KAAK,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAI7C;;;;;;;;GAQG;AACH,MAAM,OAAO,WAAY,SAAQ,WAAW;IAA5C;;QAE6D,mBAAc,GAA0B,MAAM,CAAC;QAC1G;8DACsD;QACf,oBAAe,GAAkB,IAAI,CAAC;IAQ/E,CAAC;aAZQ,WAAM,GAAG,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,AAA/B,CAAgC;IAK7C,MAAM;QACJ,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAA,8CAA8C,KAAK;;mCAE/B,IAAI,CAAC,cAAc,KAAK,MAAM;YACrD,CAAC;IACX,CAAC;CACF;AAX4D;IAA1D,QAAQ,CAAC,EAAE,SAAS,EAAE,iBAAiB,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;mDAAgD;AAGnE;IAAtC,QAAQ,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC;oDAAuC"}

package/dist/components/spinner/spinner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"spinner.d.ts","sourceRoot":"","sources":["../../../src/components/spinner/spinner.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/components/spinner/spinner.js

@@ -1,5 +0,0 @@
-export * from './spinner.class.js';
-import { LyraSpinner } from './spinner.class.js';
-import { defineElement } from '../../internal/prefix.js';
-defineElement('spinner', LyraSpinner);
-//# sourceMappingURL=spinner.js.map

package/dist/components/spinner/spinner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"spinner.js","sourceRoot":"","sources":["../../../src/components/spinner/spinner.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,aAAa,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC"}

package/dist/components/spinner/spinner.styles.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"spinner.styles.d.ts","sourceRoot":"","sources":["../../../src/components/spinner/spinner.styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,yBAkBlB,CAAC"}

package/dist/components/spinner/spinner.styles.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"spinner.styles.js","sourceRoot":"","sources":["../../../src/components/spinner/spinner.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE1B,MAAM,CAAC,MAAM,MAAM,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;CAkBxB,CAAC"}

package/dist/components/split/split.class.d.ts

@@ -1,308 +0,0 @@
-import { type TemplateResult, type PropertyValues } from 'lit';
-import { LyraElement } from '../../internal/lyra-element.js';
-/** A fixed-pixel-range constraint for one panel; index-aligned with `sizes`/
- *  `panelConstraints`. Either bound may be omitted to leave that side
- *  unconstrained (falls back to the component's percent-based `min`). */
-export interface PanelConstraint {
-    minPx?: number;
-    maxPx?: number;
-}
-export type SplitConstraintIssueReason = 'minimum-total' | 'maximum-total' | 'minimum-exceeds-maximum';
-export interface SplitConstraintIssueDetail {
-    reason: SplitConstraintIssueReason;
-    panelCount: number;
-    minimumTotal: number;
-    maximumTotal: number | null;
-    containerSize: number;
-}
-/** Which pane (if any) participates in responsive collapse (see `collapse`). */
-export type SplitCollapseMode = 'start' | 'end' | 'none';
-/** The collapsing pane's current responsive state — `'wide'` is the normal
- *  drag-resizable percent layout (identical to `collapse="none"`); `'rail'`
- *  clamps it to `railWidth`; `'floating'` lifts it out of the flex flow as an
- *  overlay above the other pane. */
-export type SplitCollapseState = 'wide' | 'rail' | 'floating';
-/** What can be *assigned* to `collapseState` -- `'auto'` is a write-only
- *  sentinel; see the `collapseState` accessor doc. */
-export type SplitCollapseStateInput = SplitCollapseState | 'auto';
-export interface SplitCollapseChangeDetail {
-    state: SplitCollapseState;
-}
-export interface SplitResizeDetail {
-    sizes: number[];
-}
-export interface LyraSplitEventMap {
-    'lr-resize': CustomEvent<SplitResizeDetail>;
-    'lr-split-collapse-change': CustomEvent<SplitCollapseChangeDetail>;
-    'lr-split-constraints-invalid': CustomEvent<SplitConstraintIssueDetail>;
-}
-/**
- * `<lr-split>` — resizable panels for dashboard layouts. Direct light-DOM
- * children are the panels; a divider is auto-inserted between each pair.
- *
- * Optionally, one pane can opt in to responsive collapse via `collapse`
- * (`"start"`/`"end"`, default `"none"` — no behavior change when unset): as
- * the split's own container narrows past `railBreakpoint` that pane clamps
- * to a fixed `railWidth`, and past the narrower `floatBreakpoint` it instead
- * becomes an absolutely-positioned overlay "floating card" above the other
- * pane. This component only handles the width-collapse mechanics and
- * signals the current state — via the `collapseState`-derived
- * `data-collapse-state` attribute (set on both the host and the collapsing
- * panel itself) and the `lr-split-collapse-change` event — it renders no
- * icon-only/collapsed UI of its own; slotted content is expected to adapt to
- * its own clamped width (e.g. via its own container query).
- *
- * `collapseState` is a public accessor with force/auto semantics mirroring
- * `<lr-app-rail>`'s `mode`: it's normally derived automatically from the
- * measured container width (via a `ResizeObserver` on `[part="base"]`)
- * whenever it crosses `railBreakpoint`/`floatBreakpoint`, but assigning it a
- * concrete `'wide'`/`'rail'`/`'floating'` value pins it there and stops that
- * automatic tracking — useful for a consumer-driven toggle (e.g. a button
- * that forces `'floating'` regardless of width). Assigning the write-only
- * `'auto'` sentinel releases the pin and immediately re-derives the state
- * from the current measured width, resuming automatic tracking. `'auto'` is
- * never a value this getter returns.
- *
- * The `'floating'` state is a hidden-by-default drawer, gated by `open`
- * (mirrors `<lr-app-rail>`'s mobile overlay): while `collapseState` is
- * `'floating'` and `open` is `false` (the default), the collapsing panel
- * renders nothing — `hidden`, out of the accessibility tree, not just
- * visually hidden — instead of the always-visible overlay card this state
- * rendered before `open` existed. Setting `open = true` reveals it as a
- * focus-trapped floating panel with a `[part="backdrop"]` scrim; Escape or a
- * backdrop click set `open` back to `false`. `open` is preserved (not reset)
- * while `collapseState` isn't `'floating'`, but no drawer chrome renders
- * until it is again — except that leaving `'floating'` while `open` is
- * `true` (a breakpoint crossing back to `'wide'`/`'rail'`, or a forced
- * reassignment) also closes it, the same way `<lr-app-rail>` closes its
- * mobile overlay when leaving `'mobile'` while open.
- *
- * @customElement lr-split
- * @event lr-resize - `detail: { sizes }`, fired on every drag step/release
- *   and every keyboard step.
- * @event lr-split-collapse-change - `detail: { state }` (`SplitCollapseChangeDetail`),
- *   fired whenever the responsive `collapseState` actually transitions between
- *   `'wide'`/`'rail'`/`'floating'` — whether from a breakpoint crossing or an
- *   explicit `collapseState` assignment. Only relevant when `collapse` isn't
- *   `"none"`; never fires otherwise. Not fired for a redundant reassignment
- *   to the state already in effect.
- * @event lr-split-constraints-invalid - `detail: SplitConstraintIssueDetail`,
- *   fired once when the configured panel minimums/maximums cannot describe a
- *   layout that fits the track. The splitter rejects that infeasible set for
- *   interaction and falls back to a normalized percent minimum.
- * @slot - Panels to arrange side by side (or stacked, when `orientation="vertical"`); each direct child becomes one resizable panel.
- * @csspart base - The flex layout wrapper (`position: relative`, so the `'floating'` collapse state can anchor to it).
- * @csspart divider - Each divider between two panels; carries `aria-disabled="true"` and is drag/keyboard-inert while its adjacent panel is collapsed (`'rail'`/`'floating'`).
- * @csspart backdrop - The `'floating'` drawer's scrim. Only rendered while `collapseState === 'floating'` and `open`.
- */
-export declare class LyraSplit extends LyraElement<LyraSplitEventMap> {
-    static styles: import("lit").CSSResultGroup[];
-    static properties: {
-        collapseState: {
-            reflect: boolean;
-            attribute: string;
-            noAccessor: boolean;
-        };
-    };
-    sizes: number[];
-    min: number;
-    orientation: 'horizontal' | 'vertical';
-    storageKey?: string;
-    /** Optional fixed-pixel min/max per panel, index-aligned with `sizes`. A
-     *  `null`/missing entry leaves that panel purely percent-based (the
-     *  existing `min`-only behavior). `sizes`, the `lr-resize` payload, and
-     *  localStorage persistence stay percent-based regardless — only the
-     *  effective clamp bounds change for a constrained panel. */
-    panelConstraints: (PanelConstraint | null)[];
-    /** Opts a pane in to responsive collapse: `'start'` is the first light-DOM
-     *  panel (index 0), `'end'` is the last. Both are LOGICAL positions, same
-     *  as CSS `inset-inline-start`/`-end` — see the `collapsingIndex` getter
-     *  for why that already resolves to the same physical index under RTL for
-     *  this component (panels are never re-`order`ed for RTL, only the drag
-     *  delta sign mirrors). Default `'none'`: none of the collapse behavior
-     *  below applies, and rendering/behavior is identical to before this
-     *  property existed. */
-    collapse: SplitCollapseMode;
-    /** Fixed CSS length the collapsing pane clamps to in the `'rail'` state. */
-    railWidth: string;
-    /** Container width (px, measured on `[part="base"]`) below which the
-     *  collapsing pane switches from its normal percent width to the fixed
-     *  `railWidth` (`'rail'` state). Must stay above `floatBreakpoint`. */
-    railBreakpoint: number;
-    /** Container width (px) below which the collapsing pane instead becomes an
-     *  absolutely-positioned overlay above the other pane (`'floating'` state). */
-    floatBreakpoint: number;
-    /** Whether the `'floating'` collapse state's drawer is shown. Only
-     *  meaningful while `collapseState` is `'floating'` — the value is
-     *  preserved (not reset) while another state is active, but no drawer
-     *  chrome renders until `collapseState` is `'floating'` again. Defaults to
-     *  `false`: the collapsing pane renders nothing while floating until a
-     *  consumer opts in by setting this (or it's forced open programmatically)
-     *  — see the class doc. */
-    open: boolean;
-    /** Overrides the auto-inserted divider's `aria-label` — receives the divider's 0-based index
-     *  and the total panel count (`lr-split` supports N panels, so a single fixed string can't
-     *  express every divider's label; a function can). Unset (the default) keeps today's exact
-     *  localized `Resize divider between panel {a} and panel {b}` template (see `this.localize()`). */
-    dividerLabel?: (index: number, panelCount: number) => string;
-    private panelCount;
-    private _collapseState;
-    private _forced;
-    private overlayActive;
-    private justOpened;
-    private releaseScrollLock?;
-    private overlayHandle?;
-    private drags;
-    private stylizedPanels;
-    private constraintIssueKey;
-    private baseEl?;
-    private collapseResizeObserver?;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    protected firstUpdated(): void;
-    /** Both branches here derive one reactive property from another with no
-     *  DOM measurement involved, so they belong in `willUpdate()` rather than
-     *  `updated()`: setting a reactive property from `updated()`/
-     *  `firstUpdated()` schedules a *second* update on top of the one that
-     *  just finished, which Lit's dev-mode console flags ("scheduled an
-     *  update ... after an update completed"). Both of these were real and
-     *  reproducible in normal usage, not just test artifacts --
-     *  `ensureSizes()` on any direct `sizes` assignment whose length doesn't
-     *  match `panelCount` (e.g. a consumer correcting a stale layout), and the
-     *  `collapseState` reset on every `collapse` -> `'none'` transition. The
-     *  `collapse !== 'none'` re-arm path in `syncCollapseObserver()` still
-     *  needs a freshly measured container width and stays in `updated()` --
-     *  see `armCollapseObserver()`'s own doc comment for why *that* one is the
-     *  documented exception instead (mirrors virtual-list.ts's
-     *  `attachContainerListeners()`). */
-    protected willUpdate(changed: PropertyValues): void;
-    /**
-     * The collapsing pane's current responsive state. Always one of the three
-     * real states — never `'auto'` — reflecting either the live measured
-     * width or, once forced, whatever was last assigned. See the class doc for
-     * the full force/auto contract (mirrors `<lr-app-rail>`'s `mode`).
-     */
-    get collapseState(): SplitCollapseState;
-    set collapseState(next: SplitCollapseStateInput);
-    /** The container width (px) `[part="base"]` is measured at right now --
-     *  used to re-derive `collapseState` immediately when a forced value is
-     *  released back to `'auto'`, outside of the `ResizeObserver`'s own
-     *  (async, entry-driven) callback. Mirrors the synchronous initial read
-     *  `armCollapseObserver()` already does when it (re-)arms. */
-    private currentMeasuredWidth;
-    /** Resets `collapseState` back to its `'wide'` default and releases any
-     *  force, bypassing the public accessor's pin/event-emit side effects --
-     *  used only for the `collapse -> 'none'` housekeeping reset in
-     *  `willUpdate()`, which is purely internal bookkeeping (the feature is
-     *  off entirely), not a state transition a consumer forced or observed. */
-    private resetCollapseState;
-    /** Applies an actual `collapseState` transition (no-op if `next` matches
-     *  the current value): updates the field, triggers Lit's reflect/re-render
-     *  via `requestUpdate`, and fires `lr-split-collapse-change`. Shared by
-     *  both the `ResizeObserver`-driven measurement path (`updateCollapseState`)
-     *  and the accessor's forced-value assignment, so the two never duplicate
-     *  this logic. Leaving `'floating'` while `open` is still `true` also
-     *  closes the drawer -- mirrors `<lr-app-rail>` closing its mobile
-     *  overlay when `mode` leaves `'mobile'` while open. */
-    private applyCollapseStateChange;
-    private get storageFullKey();
-    private loadPersisted;
-    private persist;
-    private ensureSizes;
-    private onSlotChange;
-    /** The container extent (px) along the resize axis, read live so a
-     *  container resize between calls is always picked up — same live read
-     *  `onPointerMove` already does via `drag.base.clientWidth/clientHeight`. */
-    private getContainerSize;
-    /** The physical panel index `collapse: 'start' | 'end'` resolves to, or
-     *  `-1` when collapse is off (`'none'`) or there are fewer than 2 panels
-     *  to collapse one of. Panels are laid out via ascending inline `order`
-     *  (see `updated()`) and that ordering is never re-swapped for RTL — only
-     *  the drag/keyboard *delta sign* mirrors for RTL, exactly like
-     *  `onPointerMove`/`onDividerKeyDown` — so panel index 0 already renders
-     *  at the logical inline-start edge under both LTR and RTL (confirmed by
-     *  the pointer-drag RTL test elsewhere in this file: panel 0 renders on
-     *  the visual *right*, i.e. the RTL inline-start side). `'start'` therefore
-     *  always resolves to index 0 and `'end'` to `panelCount - 1`, regardless
-     *  of `isRtl(this)` — consulting it here would swap collapse onto the
-     *  panel that visually sits at the *other* logical edge, which would be a
-     *  bug against this component's own RTL rendering, not a fix for one.
-     */
-    private get collapsingIndex();
-    /** Whether a pane is actually collapsed (rail or floating) right now —
-     *  `false` whenever `collapse === 'none'`, since `collapseState` then
-     *  never leaves its `'wide'` default. */
-    private get collapseActive();
-    /** Dragging/keyboard-resizing is disabled on the one divider immediately
-     *  adjacent to the currently-collapsed pane (its other side has nothing
-     *  meaningful to resize against while the pane is rail/floating-width). */
-    private isDividerDisabled;
-    /** Classifies a measured container width into the collapsing pane's
-     *  responsive state and, only on an actual transition, applies it (via the
-     *  same `applyCollapseStateChange()` the accessor's forced-value path
-     *  uses). Gated behind `_forced` so a pinned `collapseState` is never
-     *  silently overwritten by a subsequent resize — this is also what the
-     *  accessor's `'auto'` release calls (with the current measured width) to
-     *  re-derive the state without duplicating the width-vs-breakpoint logic. */
-    private updateCollapseState;
-    /** Creates (idempotently) and (re-)observes `[part="base"]` with the
-     *  collapse-state `ResizeObserver` — a no-op until `baseEl` exists (see
-     *  `firstUpdated()`/`connectedCallback()`). The observer's first callback
-     *  supplies the initial layout measurement; keeping the read there avoids
-     *  mutating reactive state from `firstUpdated()`/`updated()`, which would
-     *  create a redundant lifecycle update and a Lit warning. */
-    private armCollapseObserver;
-    /** Reacts to a live `collapse` property change (as opposed to the
-     *  connect/first-render arming above): turns the observer on/off. The
-     *  `collapseState` reset for the `'none'` case lives in `willUpdate()`
-     *  instead (see its doc comment) so no stale rail/floating styling
-     *  survives switching collapse off, without the extra render pass a
-     *  property set here would cost. */
-    private syncCollapseObserver;
-    /** `min` normalized to a finite, non-negative percent floor before it reaches
-     *  `normalizedDefaultMin()`/`resolveConstraintBounds()`'s clamp math or `loadPersisted()`'s
-     *  validity check -- an invalid attribute value would otherwise poison every panel's percent
-     *  bounds with `NaN` or a negative floor. */
-    private get safeMin();
-    /** `floatBreakpoint` normalized to a finite, non-negative px width before `updateCollapseState()`'s
-     *  breakpoint comparison. */
-    private get safeFloatBreakpoint();
-    /** `railBreakpoint` normalized the same way, then cross-referenced against the already-sanitized
-     *  float breakpoint -- the class doc requires it stay above `floatBreakpoint`, and an
-     *  inverted/invalid pair would otherwise let `updateCollapseState()` skip the `'rail'` state
-     *  entirely. */
-    private get safeRailBreakpoint();
-    /** The safe fallback for a shared percent minimum. A value above the
-     *  available share is still useful as a consumer intent, but it cannot be
-     *  honored for every panel at once, so reduce it proportionally. */
-    private normalizedDefaultMin;
-    /** Resolves all panel bounds together so aggregate feasibility is checked
-     *  before an individual divider is asked to clamp a pair. An invalid set is
-     *  rejected as a whole: interaction uses the safe shared minimum instead of
-     *  exposing a divider whose minimum is greater than its maximum. */
-    private resolveConstraintBounds;
-    private percentBounds;
-    private clampPair;
-    private applyDelta;
-    /** The collapsing pane's light-DOM element itself — the `'floating'`
-     *  drawer's focus-trap/backdrop target. There's no separate shadow-DOM
-     *  panel to trap focus within (unlike `<lr-app-rail>`'s `[part="panel"]`):
-     *  the slotted panel *is* the floating drawer, just repositioned via
-     *  inline styles in `updated()`. */
-    private get floatingPanelEl();
-    private activateFloatingOverlay;
-    private deactivateFloatingOverlay;
-    private onBackdropClick;
-    private onPointerDown;
-    private onPointerMove;
-    private onPointerUp;
-    private onDividerKeyDown;
-    protected updated(changed: PropertyValues): void;
-    render(): TemplateResult;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'lr-split': LyraSplit;
-    }
-}
-//# sourceMappingURL=split.class.d.ts.map

package/dist/components/split/split.class.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"split.class.d.ts","sourceRoot":"","sources":["../../../src/components/split/split.class.ts"],"names":[],"mappings":"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"}