scb-wc 0.1.2 → 0.1.4

package/scb-test-components/scb-nav/scb-nav.d.ts

@@ -0,0 +1,50 @@
+import { LitElement, TemplateResult } from 'lit';
+export declare class ScbNav extends LitElement {
+    /** Aria-label för navigeringen (används om hosten saknar aria-label). */
+    label: string;
+    /** Matchar href-attributet på en item i slotten och markerar den som aktiv. */
+    activeHref: string;
+    /** Om nav:en ska uppdatera aktivt state när en item klickas. */
+    activateOnClick: boolean;
+    /** Om nav:en ska ligga kvar i toppen vid scroll (position: sticky). */
+    sticky: boolean;
+    /** Top-offset för sticky-läget (t.ex. "0px" eller "64px"). */
+    stickyTop: string;
+    /** Z-index för sticky-läget. */
+    stickyZIndex: number;
+    /** Bakgrund för sticky-läget. Kan vara en färg (#fff) eller en CSS-variabel (t.ex. var(--md-sys-color-surface) eller --md-sys-color-surface). */
+    stickyBackground: string;
+    /** Vertikalt avstånd till omgivande innehåll.
+     * spacing sätter både top och bottom om spacing-top / spacing-bottom inte är satta.
+     */
+    spacing: undefined;
+    spacingTop: undefined;
+    spacingBottom: undefined;
+    spacingLeft: undefined;
+    spacingRight: undefined;
+    private __autoAriaLabel;
+    /** Prefix för auto-genererade id:n för items i slotten. */
+    private __itemIdPrefix;
+    private __itemIdCounter;
+    static styles: import('lit').CSSResult;
+    private mapSpacingToken;
+    private __applySpacing;
+    private __syncStickyStyles;
+    connectedCallback(): void;
+    protected firstUpdated(): Promise<void>;
+    protected updated(changed: Map<string, unknown>): void;
+    private __syncAriaLabel;
+    /** Säkerställer att slottade items får samma utseende som Material-knappar (ripple och fokus-ring). */
+    private __decorateItems;
+    private __getSlottedItems;
+    private __getItemHref;
+    private __applyActiveHref;
+    private __onSlotChange;
+    private __onClick;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'scb-nav': ScbNav;
+    }
+}

package/scb-test-components/scb-notification-card/scb-notification-card.d.ts

@@ -0,0 +1,46 @@
+import { LitElement, PropertyValues } from 'lit';
+type NotificationVariant = 'success' | 'error' | 'warning' | 'info';
+type NotificationDirection = 'horizontal' | 'vertical';
+type NotificationSizing = 'stretch' | 'content-width' | 'content-height';
+type NotificationSize = 'small' | 'medium' | 'large';
+export declare class ScbNotificationCard extends LitElement {
+    #private;
+    variant: NotificationVariant;
+    direction: NotificationDirection;
+    size: NotificationSize;
+    title: string;
+    notificationCardTitle: string;
+    subtitle: string;
+    supportingText: string;
+    open: boolean;
+    linkText: string;
+    linkHref: string;
+    href: string;
+    showIcon: boolean;
+    showCloseButton: boolean;
+    sizing: NotificationSizing;
+    width: string;
+    maxWidth: string;
+    height: string;
+    maxHeight: string;
+    fullHeight: boolean;
+    fullWidth: boolean;
+    spacing: undefined;
+    spacingTop: undefined;
+    spacingBottom: undefined;
+    spacingLeft: undefined;
+    spacingRight: undefined;
+    static styles: import('lit').CSSResult[];
+    private _iconForVariant;
+    private _closeNotification;
+    private __resolveSpacingToken;
+    private __applySpacing;
+    protected updated(changed: PropertyValues): void;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'scb-notification-card': ScbNotificationCard;
+    }
+}
+export {};

package/scb-test-components/scb-options-menu/scb-options-menu-item.d.ts

@@ -0,0 +1,29 @@
+import { LitElement, TemplateResult } from 'lit';
+export declare class ScbOptionsMenuItem extends LitElement {
+    label: string;
+    hasSubMenu: boolean;
+    openLeft: boolean;
+    divider: boolean;
+    leadingIcon: string;
+    trailingIcon: string;
+    itemHref: string;
+    href: string;
+    static styles: import('lit').CSSResult;
+    private _subMenuChildObserver?;
+    private _subMenuAttrObserver?;
+    private _observedSubMenu;
+    private _syncSubMenuFlags;
+    private get _effectiveHref();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private handleClick;
+    /** Stänger submeny om fokus lämnar submenyn */
+    private _onBlur;
+    /** Tar bort open-submenu om ingen submeny är öppen när menyitem får fokus */
+    private _onFocus;
+    render(): TemplateResult;
+    _navigateToHref(e: Event): void;
+    _toggleSubMenu(): void;
+    /** Trigger click handler on Enter/Space for accessibility + pilnavigation */
+    private _onKeyDown;
+}

package/scb-test-components/scb-options-menu/scb-options-menu.d.ts

@@ -0,0 +1,35 @@
+import { LitElement, TemplateResult } from 'lit';
+export declare class ScbOptionsMenu extends LitElement {
+    open: boolean;
+    size: 'small' | 'medium' | 'large';
+    inSb: boolean;
+    spacing: undefined;
+    spacingTop: undefined;
+    spacingBottom: undefined;
+    spacingLeft: undefined;
+    spacingRight: undefined;
+    __lastTriggerEl: HTMLElement | null;
+    static styles: import('lit').CSSResult;
+    protected firstUpdated(): void;
+    render(): TemplateResult;
+    private __onViewportChange;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** Sätt endast state; side effects (overlay, fokus, events mm) hanteras i `updated()`. */
+    private __setOpen;
+    private __getActionFromEvent;
+    /** Returnerar true om klicket är i en scb-options-menu eller scb-options-sub-menu */
+    private isClickInScbMenu;
+    private __onDocumentClick;
+    private __onDocumentKeydown;
+    /** Reagera på ändrat `open` oavsett om det kom från triggers eller från kod (menu.open = …). */
+    protected updated(changed: Map<string, unknown>): void;
+    /** scroll lock, aria-uppdatering, fokusflytt och öppna/stäng-events. */
+    private __applyOpenSideEffects;
+    private __positionToTrigger;
+    private __restoreFocusToTrigger;
+    /** Sätt aria-expanded=true/false på alla kontroller som pekar på aktuell meny via id. */
+    private __updateTriggersExpanded;
+    private __applySpacing;
+    private __mapSpacingToken;
+}

package/scb-test-components/scb-options-menu/scb-options-sub-menu.d.ts

@@ -0,0 +1,11 @@
+import { LitElement, TemplateResult } from 'lit';
+export declare class ScbOptionsSubMenu extends LitElement {
+    open: boolean;
+    static styles: import('lit').CSSResult;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    _show: () => void;
+    _hide: (e?: Event) => void;
+    firstUpdated(): void;
+    render(): TemplateResult;
+}

package/scb-test-components/scb-overlay/scb-overlay.d.ts

@@ -0,0 +1,24 @@
+import { LitElement, nothing } from 'lit';
+export declare class ScbOverlay extends LitElement {
+    #private;
+    private static __instances;
+    private static __docListenerAttached;
+    private static __handleDocClick;
+    private static __ensureDocListener;
+    private static __maybeRemoveDocListener;
+    open: boolean;
+    variant: 'scrim' | 'solid';
+    isStatic: boolean;
+    ariaLabel: string;
+    __lastTriggerEl: HTMLElement | null;
+    static styles: import('lit').CSSResult;
+    render(): import('lit-html').TemplateResult<1> | typeof nothing;
+    connectedCallback(): void;
+    updated(changedProperties: Map<PropertyKey, unknown>): void;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'scb-overlay': ScbOverlay;
+    }
+}

package/scb-test-components/scb-pagination/scb-pagination.d.ts

@@ -0,0 +1,36 @@
+import { LitElement, PropertyValues } from 'lit';
+export declare class ScbPagination extends LitElement {
+    variant: 'icon-text' | 'icon';
+    page: number;
+    totalPages: number;
+    pagingHref: string;
+    baseUri: string;
+    paginationAriaLabel: string;
+    currentAriaLabel: string;
+    pagingNumberAriaLabel: string;
+    isNarrow: boolean;
+    spacing: undefined;
+    spacingTop: undefined;
+    spacingBottom: undefined;
+    spacingLeft: undefined;
+    spacingRight: undefined;
+    static styles: import('lit').CSSResult[];
+    private _emitPageChange;
+    private _getPagingHref;
+    private _handlePageSelection;
+    private _prevPage;
+    private _nextPage;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onResize;
+    private mapSpacingToken;
+    private __applySpacing;
+    protected firstUpdated(): void;
+    protected updated(changed: PropertyValues): void;
+    render(): import('lit-html').TemplateResult<1> | null;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'scb-pagination': ScbPagination;
+    }
+}

package/scb-test-components/scb-progress-indicator/scb-progress-indicator.d.ts

@@ -0,0 +1,28 @@
+import { LitElement, TemplateResult, PropertyValues } from 'lit';
+export declare class ScbProgressIndicator extends LitElement {
+    id: string;
+    type: 'circular' | 'linear';
+    progress: number;
+    isStatic: boolean;
+    spacing: undefined;
+    spacingTop: undefined;
+    spacingBottom: undefined;
+    spacingLeft: undefined;
+    spacingRight: undefined;
+    static styles: import('lit').CSSResult[];
+    private _isSyncingAria;
+    private _defaultAriaLabelApplied;
+    private _defaultAriaValueTextApplied;
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    connectedCallback(): void;
+    private clampProgress;
+    private applyDefaultAriaLabel;
+    private syncAria;
+    private mapSpacingToken;
+    private applySpacing;
+    private applyTypeLayout;
+    protected firstUpdated(_changed: PropertyValues): void;
+    protected updated(changed: PropertyValues): void;
+    render(): TemplateResult;
+}

package/scb-test-components/scb-progress-stepper/scb-progress-step.d.ts

@@ -0,0 +1,21 @@
+import { LitElement } from 'lit';
+/**
+ * En komponent som visar en progress stepper enligt SCB-standard.
+ * @slot - Innehåll för stegen
+ */
+export declare class ScbProgressStep extends LitElement {
+    width: string;
+    active: boolean;
+    disabled: boolean;
+    href: string;
+    label: string;
+    position: 'top' | 'bottom';
+    private _stepId;
+    static styles: import('lit').CSSResult;
+    updated(changedProps: Map<string, any>): void;
+    private _onClick;
+    firstUpdated(_changedProps: any): void;
+    _setupTooltipPositioning(): void;
+    _adjustTooltipPosition(): void;
+    render(): import('lit-html').TemplateResult<1>;
+}

package/scb-test-components/scb-progress-stepper/scb-progress-stepper.d.ts

@@ -0,0 +1,22 @@
+import { LitElement, PropertyValues } from 'lit';
+/**
+ * En komponent som visar en progress stepper enligt SCB-standard.
+ * @slot step-0 - Första steget
+ * @slot step-1 - Andra steget
+ * @slot step-n - Fler steg, indexbaserat
+ */
+export declare class ScbProgressStepper extends LitElement {
+    progressWidth: number;
+    height: 'normal' | 'high';
+    position: 'top' | 'bottom';
+    spacing: undefined;
+    spacingTop: undefined;
+    spacingBottom: undefined;
+    spacingLeft: undefined;
+    spacingRight: undefined;
+    static styles: import('lit').CSSResult;
+    private mapSpacingToken;
+    private applySpacing;
+    protected updated(_changedProperties: PropertyValues): void;
+    render(): import('lit-html').TemplateResult<1>;
+}

package/scb-test-components/scb-radio-button/scb-radio-button.d.ts

@@ -0,0 +1,26 @@
+import { LitElement, TemplateResult, PropertyValues } from 'lit';
+type ScbRadioSize = 'small' | 'medium' | 'large';
+export declare class ScbRadioButton extends LitElement {
+    #private;
+    disabled: boolean;
+    checked: boolean;
+    name: string;
+    value: string;
+    size: ScbRadioSize;
+    deselectable: boolean;
+    label: string;
+    supportingText: string;
+    ariaLabel: string;
+    private _radioId;
+    private _showOuterFocusRing;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onClick;
+    private _onRadioChange;
+    protected firstUpdated(): void;
+    protected updated(changed: PropertyValues): void;
+    private __syncInnerAria;
+    static styles: import('lit').CSSResult;
+    render(): TemplateResult;
+}
+export {};

package/scb-test-components/scb-radio-button/scb-radio-group.d.ts

@@ -0,0 +1,49 @@
+import { LitElement } from 'lit';
+type ScbRadioSize = 'small' | 'medium' | 'large';
+export declare class ScbRadioGroup extends LitElement {
+    #private;
+    static formAssociated: boolean;
+    name: string;
+    orientation: 'vertical' | 'horizontal';
+    disabled: boolean;
+    required: boolean;
+    deselectable: boolean;
+    size: ScbRadioSize;
+    ariaLabel: string | null;
+    /** Avstånd mellan radioknappar i gruppen ägs av CSS-variabeln --scb-radio-gap. */
+    /** Styr vertikalt avstånd till omgivande innehåll (samma modell som scb-checkbox-group). */
+    spacing: undefined;
+    spacingTop: undefined;
+    spacingBottom: undefined;
+    spacingLeft: undefined;
+    spacingRight: undefined;
+    /** Håller gruppens aktuella värde, speglar value på den radio-knapp som är vald. */
+    value: string;
+    private _internals;
+    private _form;
+    private _formResetHandler;
+    private _initialValue;
+    private _customValidationMessage;
+    constructor();
+    static styles: import('lit').CSSResult;
+    render(): import('lit-html').TemplateResult<1>;
+    firstUpdated(): void;
+    disconnectedCallback(): void;
+    updated(changed: Map<string, unknown>): void;
+    get form(): HTMLFormElement | null;
+    get validity(): ValidityState | undefined;
+    get validationMessage(): string;
+    get willValidate(): boolean;
+    get labels(): NodeList | undefined;
+    checkValidity(): boolean;
+    reportValidity(): boolean;
+    setCustomValidity(message: string): void;
+    formDisabledCallback(disabled: boolean): void;
+    private __syncFormValue;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'scb-radio-group': ScbRadioGroup;
+    }
+}
+export {};

package/scb-test-components/scb-scrollspy/scb-scrollspy.d.ts

@@ -0,0 +1,217 @@
+import { LitElement } from 'lit';
+/**
+  <scb-scrollspy>
+
+  Kopplar en navigationsyta (slot="nav" eller extern via nav-selector) till ett innehåll (slot="content").
+  När en sektion blir aktiv markeras motsvarande nav-element och rätt <scb-menu-item> får selected.
+
+  Förväntat markup-upplägg:
+    - Nav: <scb-menu-item item-href="#id">, <scb-nav-item href|data-href="#id">, vanliga <a href="#id"> eller <button data-href="#id">
+    - Innehåll: element med id som matchar hash:en
+
+  Extern nav-yta:
+    - Placera nav:en var du vill i layouten och koppla den med nav-selector.
+
+  Observern körs mot scrollcontainern om slot="content" är scrollbar. Annars används viewport.
+
+  Komponentens syfte är att vara ett beteende, inte en layout. :host använder display: contents.
+  För docs och plug-and-play-exempel kan layout="sidebar" användas för att skapa en fast tvåkolumnslayout
+  med scrollbart innehåll och nav-yta.
+*/
+export declare class ScbScrollspy extends LitElement {
+    static properties: {
+        navSelector: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        offsetTop: {
+            type: NumberConstructor;
+            attribute: string;
+        };
+        offsetBottom: {
+            type: NumberConstructor;
+            attribute: string;
+        };
+        updateHash: {
+            type: BooleanConstructor;
+            attribute: string;
+            converter: {
+                fromAttribute: (value: string | null) => boolean;
+                toAttribute: (value: boolean) => "" | null;
+            };
+        };
+        activeId: {
+            type: StringConstructor;
+            attribute: string;
+            reflect: boolean;
+        };
+        layout: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        sidebarNavWidth: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        sidebarHeight: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        stackHeight: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        sidebarNavTop: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        contentPadding: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        spacing: {
+            type: StringConstructor;
+            reflect: boolean;
+        };
+        spacingTop: {
+            type: StringConstructor;
+            attribute: string;
+            reflect: boolean;
+        };
+        spacingBottom: {
+            type: StringConstructor;
+            attribute: string;
+            reflect: boolean;
+        };
+        spacingLeft: {
+            type: StringConstructor;
+            attribute: string;
+            reflect: boolean;
+        };
+        spacingRight: {
+            type: StringConstructor;
+            attribute: string;
+            reflect: boolean;
+        };
+    };
+    /** CSS-selector för extern nav-yta. Om satt används den istället för slot="nav". */
+    navSelector: string;
+    /** Offset i px från toppen av scrollcontainern, exempelvis höjden på en sticky header. */
+    offsetTop: number;
+    /** Offset i px från botten av scrollcontainern. */
+    offsetBottom: number;
+    /** Om URL-hash ska uppdateras när aktiv sektion ändras. */
+    updateHash: boolean;
+    /** Senast aktivt id (utan #). */
+    activeId: string;
+    /** Layoutläge. Tomt värde innebär att komponenten inte skapar någon layout (display: contents). */
+    layout: '' | 'sidebar' | 'stack';
+    /** Bredd på nav-kolumnen när layout="sidebar" används. */
+    sidebarNavWidth: string;
+    /** Höjd på nav- och innehållspanelerna när layout="sidebar" används. */
+    sidebarHeight: string;
+    /** Maxhöjd på scrollcontainern när layout="stack" används. */
+    stackHeight: string;
+    /** Top-offset för nav-kolumnen när layout="sidebar" används (vid sticky-läge i wrappern). */
+    sidebarNavTop: string;
+    /** Inre padding för innehållet när layout="sidebar" eller layout="stack" används. */
+    contentPadding: string;
+    /** Vertikalt avstånd till omgivande innehåll. spacing sätter både top och bottom om spacing-top / spacing-bottom inte är satta. */
+    spacing: undefined;
+    /** Överkantens avstånd. Om satt går före spacing. */
+    spacingTop: undefined;
+    /** Nederkantens avstånd. Om satt går före spacing. */
+    spacingBottom: undefined;
+    /** Vänsterkantens avstånd. */
+    spacingLeft: undefined;
+    /** Högerkantens avstånd. */
+    spacingRight: undefined;
+    private __navEl;
+    private __contentEl;
+    private __contentShellEl;
+    private __links;
+    private __observer;
+    private __fallbackScrollRoot;
+    private __entries;
+    private __rafId;
+    private __scrollRafId;
+    private __hashAllowUpdates;
+    private __hashBaselineReady;
+    private __hashBaselinePos;
+    private __hashBaselineRafId;
+    private __hashScrollRoot;
+    private __hashSuspend;
+    private __hashInitialApplied;
+    private __onHashScrollBound;
+    private __scrollAnimSeq;
+    private __syncingActiveId;
+    private __slotsResolvedOnce;
+    private __motionMeasureEl;
+    private __focusableRafId;
+    private __autoOffsetTop;
+    private __autoOffsetRafId;
+    private __navResizeObserver;
+    private __onNavClickBound;
+    private __onScrollFallbackBound;
+    private __onResizeBound;
+    static styles: import('lit').CSSResult;
+    connectedCallback(): void;
+    protected firstUpdated(): void;
+    disconnectedCallback(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    private __mapSpacingToken;
+    private __applySpacing;
+    private __teardown;
+    private __cancelScrollAnimation;
+    private __cancelEnsureContentFocusable;
+    private __requestEnsureContentFocusable;
+    private __ensureScrollableContentFocusable;
+    private __ensureMotionMeasureEl;
+    private __disconnectObserver;
+    private __resolveInternals;
+    private __resolveSlots;
+    private __queryExternalNav;
+    private __getScrollContainerEl;
+    private __isOffsetTopExplicit;
+    private __getEffectiveOffsetTop;
+    private __cancelAutoOffsetMeasure;
+    private __disconnectAutoOffsetObserver;
+    private __requestAutoOffsetMeasure;
+    private __measureAutoOffset;
+    private __setAutoOffsetTop;
+    private __rebuildObserver;
+    private __enableFallbackScrollSpy;
+    private __getObserverRoot;
+    private __collectLinks;
+    private __getHref;
+    private __onIntersect;
+    private __requestActiveRecalc;
+    private __updateActiveFromEntries;
+    private __updateActiveFromRects;
+    private __applyActiveId;
+    private __applyExternalActiveId;
+    private __setActiveId;
+    private __applyActiveToNav;
+    private __expandAncestors;
+    private __scrollToTarget;
+    private __getScrollTopInContainer;
+    private __animateScroll;
+    private __getScrollDurationMs;
+    private __getScrollEasingFn;
+    private __resolveTimeMs;
+    private __resolveTimingFunction;
+    private __parseTimeToMs;
+    private __parseEasingFunction;
+    private __cubicBezier;
+    private __detachHashScrollRoot;
+    private __cancelHashBaseline;
+    private __attachHashScrollRoot;
+    private __scheduleHashBaseline;
+    private __getHashScrollPos;
+    private __onHashScroll;
+    private __jumpToTarget;
+    private __applyInitialHashIfAny;
+    private __onNavClick;
+    private __onSlotChange;
+    render(): import('lit-html').TemplateResult<1>;
+}