@openreachtech/furo-vue 1.3.1

package/types/generated/components/organisms/FuroTabs/FuroTabsContext.d.ts

@@ -0,0 +1,438 @@
+/**
+ * Context class for FuroTabs organism.
+ *
+ * @extends {BaseFuroContext<null, Props, EmitEventName>}
+ */
+export default class FuroTabsContext extends BaseFuroContext<null, Props, "UPDATE_VALUE" | "TAB_CHANGE"> {
+    /**
+     * Factory method.
+     *
+     * @template {X extends typeof FuroTabsContext ? X : never} T, X
+     * @override
+     * @param {FuroTabsContextFactoryParams} params - Parameters of this factory method.
+     * @returns {InstanceType<T>} An instance of this class.
+     * @this {T}
+     */
+    static override create<T extends X extends typeof FuroTabsContext ? X : never, X>(this: T, { props, componentContext, refHash, reactiveHash, }: FuroTabsContextFactoryParams): InstanceType<T>;
+    /**
+     * Build ref hash.
+     *
+     * @override
+     * @returns {FuroTabsContextParams['refHash']}
+     */
+    static override buildRefHash(): FuroTabsContextParams["refHash"];
+    /**
+     * Build reactive hash.
+     *
+     * @override
+     * @returns {FuroTabsContextParams['reactiveHash']}
+     */
+    static override buildReactiveHash(): FuroTabsContextParams["reactiveHash"];
+    /**
+     * Get emit event name.
+     *
+     * @override
+     * @returns {Readonly<{
+     *   TAB_CHANGE: 'tab:change'
+     *   UPDATE_VALUE: 'update:value'
+     * }>}
+     */
+    static override get EMIT_EVENT_NAME(): Readonly<{
+        TAB_CHANGE: "tab:change";
+        UPDATE_VALUE: "update:value";
+    }>;
+    /**
+     * Get emit options.
+     *
+     * @returns {{
+     *   'tab:change': (payload: {
+     *     value: string
+     *   }) => void
+     *   'update:value': (value: string) => void
+     * }}
+     */
+    static get EMIT_EVENT_HASH(): {
+        "tab:change": (payload: {
+            value: string;
+        }) => void;
+        "update:value": (value: string) => void;
+    };
+    /**
+     * get: ResizeObserverCtor
+     *
+     * @returns {typeof ResizeObserver | null}
+     */
+    static get ResizeObserverCtor(): typeof ResizeObserver | null;
+    /**
+     * Constructor.
+     *
+     * @param {FuroTabsContextParams} params - Parameters of this constructor.
+     */
+    constructor({ props, componentContext, refHash, reactiveHash, }: FuroTabsContextParams);
+    refHash: {
+        activeValueRef: import("vue").Ref<string | null>;
+        viewportElementRef: import("vue").Ref<HTMLElement | null>;
+        resizeObserverRef: import("vue").Ref<ResizeObserver | null>;
+    };
+    reactiveHash: {
+        scrollStateReactive: import("vue").Reactive<{
+            canScrollPrevious: boolean;
+            canScrollNext: boolean;
+        }>;
+    };
+    /**
+     * get: Constructor of this class.
+     *
+     * @override
+     * @returns {typeof FuroTabsContext}
+     */
+    override get Ctor(): typeof FuroTabsContext;
+    /**
+     * Get internal active value ref (uncontrolled mode).
+     *
+     * @returns {import('vue').Ref<string | null>}
+     */
+    get activeValueRef(): import("vue").Ref<string | null>;
+    /**
+     * Get the scrollable viewport element ref.
+     *
+     * @returns {import('vue').Ref<HTMLElement | null>}
+     */
+    get viewportElementRef(): import("vue").Ref<HTMLElement | null>;
+    /**
+     * get: resizeObserverRef
+     *
+     * @returns {import('vue').Ref<ResizeObserver | null>}
+     */
+    get resizeObserverRef(): import("vue").Ref<ResizeObserver | null>;
+    /**
+     * Get the scroll button state.
+     *
+     * @returns {import('vue').Reactive<{
+     *   canScrollPrevious: boolean
+     *   canScrollNext: boolean
+     * }>}
+     */
+    get scrollStateReactive(): import("vue").Reactive<{
+        canScrollPrevious: boolean;
+        canScrollNext: boolean;
+    }>;
+    /**
+     * Normalized per-tab entries for rendering.
+     *
+     * @returns {Array<TabEntry>}
+     */
+    get tabEntries(): Array<TabEntry>;
+    /**
+     * Whether the active tab is controlled via `parcel.value`.
+     *
+     * @returns {boolean}
+     */
+    isControlled(): boolean;
+    /**
+     * Whether the whole tab set is disabled.
+     *
+     * @returns {boolean}
+     */
+    isDisabled(): boolean;
+    /**
+     * Whether the tab set lays out vertically.
+     *
+     * @returns {boolean}
+     */
+    isVertical(): boolean;
+    /**
+     * Whether the underline `line` variant is active.
+     *
+     * @returns {boolean}
+     */
+    isLineVariant(): boolean;
+    /**
+     * Whether the segmented `solid` variant is active.
+     *
+     * @returns {boolean}
+     */
+    isSolidVariant(): boolean;
+    /**
+     * Whether the trigger row scrolls with navigation buttons.
+     *
+     * @returns {boolean}
+     */
+    isScrollable(): boolean;
+    /**
+     * Whether tab panels render. When false, the component is a navigation menu
+     * only (e.g. the active value drives an external `router-view`).
+     *
+     * @returns {boolean}
+     */
+    shouldShowPanels(): boolean;
+    /**
+     * Whether the animated active-tab indicator renders.
+     * The indicator is exclusive to the `line` variant; the `solid` variant marks
+     * the active tab with a static background instead.
+     *
+     * @returns {boolean}
+     */
+    shouldShowIndicator(): boolean;
+    /**
+     * Resolve the visual variant.
+     *
+     * @returns {'line' | 'solid'}
+     */
+    extractVariant(): "line" | "solid";
+    /**
+     * Resolve the layout orientation.
+     *
+     * @returns {'horizontal' | 'vertical'}
+     */
+    extractOrientation(): "horizontal" | "vertical";
+    /**
+     * Resolve the icon name for the scroll-toward-start button.
+     *
+     * @returns {string}
+     */
+    extractScrollPreviousIcon(): string;
+    /**
+     * Resolve the icon name for the scroll-toward-end button.
+     *
+     * @returns {string}
+     */
+    extractScrollNextIcon(): string;
+    /**
+     * Resolve the accessible name of the scroll-toward-start button.
+     *
+     * @returns {string}
+     */
+    extractScrollPreviousLabel(): string;
+    /**
+     * Resolve the accessible name of the scroll-toward-end button.
+     *
+     * @returns {string}
+     */
+    extractScrollNextLabel(): string;
+    /**
+     * Resolve the value of the first tab, if any.
+     *
+     * @returns {string | null}
+     */
+    extractFirstTabValue(): string | null;
+    /**
+     * Resolve the active tab value for the root host element.
+     * `parcel.value` takes precedence; otherwise the internal ref,
+     * falling back to the first tab.
+     *
+     * @returns {string | null}
+     */
+    extractActiveValue(): string | null;
+    /**
+     * Extract attributes for the root host element.
+     * The `model-value` key is only included when an active value exists, so the
+     * primitive (whose `model-value` is `string`, never `null`) stays uncontrolled
+     * when there is no active tab.
+     *
+     * @returns {Record<string, unknown>}
+     */
+    extractRootAttributes(): Record<string, unknown>;
+    /**
+     * Build the optional root attributes that are only included when present.
+     *
+     * @returns {Record<string, unknown>}
+     */
+    buildOptionalRootAttributes(): Record<string, unknown>;
+    /**
+     * Extract root class names.
+     *
+     * @returns {Record<string, boolean>}
+     */
+    extractRootClassNames(): Record<string, boolean>;
+    /**
+     * Build attributes of a single trigger. The component-owned attributes win:
+     * the bag loses every one of them before the tab's own values are applied.
+     *
+     * @param {{
+     *   entry: TabEntry
+     * }} params - Parameters.
+     * @returns {Record<string, *>} Attributes of the trigger.
+     */
+    buildTriggerAttributes({ entry, }: {
+        entry: TabEntry;
+    }): Record<string, any>;
+    /**
+     * Build class names of a single trigger.
+     *
+     * @param {{
+     *   entry: TabEntry
+     * }} params - Parameters.
+     * @returns {Array<string | null>} Class names of the trigger.
+     */
+    buildTriggerClassNames({ entry, }: {
+        entry: TabEntry;
+    }): Array<string | null>;
+    /**
+     * Whether a given tab is the active one.
+     *
+     * @param {{
+     *   value: string
+     * }} params
+     * @returns {boolean}
+     */
+    isActiveTab({ value, }: {
+        value: string;
+    }): boolean;
+    /**
+     * Handle active-tab changes from the root host element.
+     *
+     * @param {{
+     *   value: string
+     * }} params
+     */
+    onTabChange({ value, }: {
+        value: string;
+    }): void;
+    /**
+     * Setup component context.
+     *
+     * @template {X extends FuroTabsContext ? X : never} T, X
+     * @override
+     * @returns {T} For method chaining.
+     * @this {T}
+     */
+    override setupComponent<T extends X extends FuroTabsContext ? X : never, X>(this: T): T;
+    /**
+     * Observe the viewport size to recompute scroll button state.
+     */
+    setupScrollObservation(): void;
+    /**
+     * Create the observer that recomputes scroll button state on a size change.
+     *
+     * @returns {ResizeObserver | null}
+     */
+    createResizeObserver(): ResizeObserver | null;
+    /**
+     * Disconnect the viewport size observer.
+     */
+    teardownScrollObservation(): void;
+    /**
+     * Recompute whether the viewport can scroll in either direction.
+     */
+    onScroll(): void;
+    /**
+     * Extract the current scroll position, viewport size, and total size
+     * along the active axis.
+     *
+     * @returns {{
+     *   position: number
+     *   size: number
+     *   total: number
+     * }}
+     */
+    extractScrollMetrics(): {
+        position: number;
+        size: number;
+        total: number;
+    };
+    /**
+     * Update the scroll button enabled state from the viewport metrics.
+     */
+    updateScrollState(): void;
+    /**
+     * Scroll the viewport by a fraction of its size.
+     *
+     * @param {{
+     *   direction: number
+     * }} params - `-1` scrolls toward the start, `1` toward the end.
+     */
+    scrollByViewport({ direction, }: {
+        direction: number;
+    }): void;
+    /**
+     * Scroll the viewport toward the start.
+     */
+    onScrollPrevious(): void;
+    /**
+     * Scroll the viewport toward the end.
+     */
+    onScrollNext(): void;
+    /**
+     * Whether the viewport can scroll toward the start.
+     *
+     * @returns {boolean}
+     */
+    canScrollPrevious(): boolean;
+    /**
+     * Whether the viewport can scroll toward the end.
+     *
+     * @returns {boolean}
+     */
+    canScrollNext(): boolean;
+}
+export type FuroTabsContextParams = import("../../../contexts/BaseFuroContext.js").BaseFuroContextParams & {
+    props: Props;
+    componentContext: ComponentContext;
+    refHash: {
+        activeValueRef: import("vue").Ref<string | null>;
+        viewportElementRef: import("vue").Ref<HTMLElement | null>;
+        resizeObserverRef: import("vue").Ref<ResizeObserver | null>;
+    };
+    reactiveHash: {
+        scrollStateReactive: import("vue").Reactive<{
+            canScrollPrevious: boolean;
+            canScrollNext: boolean;
+        }>;
+    };
+};
+export type FuroTabsContextFactoryParams = Omit<FuroTabsContextParams, "refHash" | "reactiveHash"> & {
+    refHash?: FuroTabsContextParams["refHash"];
+    reactiveHash?: FuroTabsContextParams["reactiveHash"];
+};
+export type EmitEventName = keyof typeof FuroTabsContext.EMIT_EVENT_NAME;
+export type Props = import("vue").HTMLAttributes & {
+    parcel?: FuroTabsParcel | null;
+};
+/**
+ * Closed-set Furo behavior for `<FuroTabs>`.
+ * JSON-serializable only. Not an open passthrough to the internal tabs primitive.
+ */
+export type FuroTabsParcel = {
+    tabs?: Array<FuroTabsTab>;
+    value?: string | null;
+    orientation?: "horizontal" | "vertical";
+    variant?: "line" | "solid";
+    scrollable?: boolean;
+    showPanels?: boolean;
+    showIndicator?: boolean;
+    disabled?: boolean;
+    scrollPreviousLabel?: string;
+    scrollNextLabel?: string;
+};
+/**
+ * A single tab. `value` reaches the DOM inside the trigger and panel element ids,
+ * so pass a token that is valid in an id rather than raw server data.
+ */
+export type FuroTabsTab = {
+    value: string;
+    label: string;
+    slotName?: string;
+    disabled?: boolean;
+    attrs?: Record<string, string | number | boolean>;
+    class?: string;
+};
+export type TabEntry = {
+    value: string;
+    label: string;
+    disabled: boolean;
+    panelSlotName: string;
+    triggerSlotName: string;
+    attrs: Record<string, string | number | boolean> | null;
+    className: string | null;
+};
+export type ComponentContext = import("vue").SetupContext<FuroTabsEmitHash, FuroTabsSlots>;
+export type FuroTabsEmitHash = typeof FuroTabsContext.EMIT_EVENT_HASH;
+export type FuroTabsSlots = import("vue").SlotsType<Record<string, {
+    value: string;
+    label?: string;
+}>>;
+export type FuroTabsSetup = (props: Props, componentContext: ComponentContext) => {
+    context: FuroTabsContext;
+};
+import BaseFuroContext from '../../../contexts/BaseFuroContext.js';