@openreachtech/furo-vue 1.3.1

package/types/generated/components/organisms/FuroStepper/FuroStepperContext.d.ts

@@ -0,0 +1,266 @@
+/**
+ * Context class for FuroStepper organism.
+ *
+ * @extends {BaseFuroContext<null, Props, EmitEventName>}
+ */
+export default class FuroStepperContext extends BaseFuroContext<null, Props, "UPDATE_VALUE" | "STEP_CHANGE"> {
+    /**
+     * Factory method.
+     *
+     * @template {X extends typeof FuroStepperContext ? X : never} T, X
+     * @override
+     * @param {FuroStepperContextFactoryParams} params - Parameters of this factory method.
+     * @returns {InstanceType<T>} An instance of this class.
+     * @this {T}
+     */
+    static override create<T extends X extends typeof FuroStepperContext ? X : never, X>(this: T, { props, componentContext, refHash, }: FuroStepperContextFactoryParams): InstanceType<T>;
+    /**
+     * Build ref hash.
+     *
+     * @override
+     * @returns {FuroStepperContextParams['refHash']}
+     */
+    static override buildRefHash(): FuroStepperContextParams["refHash"];
+    /**
+     * Get emit event name.
+     *
+     * @override
+     * @returns {Readonly<{
+     *   STEP_CHANGE: 'step:change'
+     *   UPDATE_VALUE: 'update:value'
+     * }>}
+     */
+    static override get EMIT_EVENT_NAME(): Readonly<{
+        STEP_CHANGE: "step:change";
+        UPDATE_VALUE: "update:value";
+    }>;
+    /**
+     * Get emit options.
+     *
+     * @returns {{
+     *   'step:change': (payload: {
+     *     value: number
+     *   }) => void
+     *   'update:value': (value: number) => void
+     * }}
+     */
+    static get EMIT_EVENT_HASH(): {
+        "step:change": (payload: {
+            value: number;
+        }) => void;
+        "update:value": (value: number) => void;
+    };
+    /**
+     * Constructor.
+     *
+     * @param {FuroStepperContextParams} params - Parameters of this constructor.
+     */
+    constructor({ props, componentContext, refHash, }: FuroStepperContextParams);
+    refHash: {
+        activeValueRef: import("vue").Ref<number | null>;
+    };
+    /**
+     * get: Constructor of this class.
+     *
+     * @override
+     * @returns {typeof FuroStepperContext}
+     */
+    override get Ctor(): typeof FuroStepperContext;
+    /**
+     * Get internal active step ref (uncontrolled mode).
+     *
+     * @returns {import('vue').Ref<number | null>}
+     */
+    get activeValueRef(): import("vue").Ref<number | null>;
+    /**
+     * Normalized per-step entries for rendering. The `step` is the 1-based
+     * position consumed by the underlying primitive; `value` is the stable
+     * identifier used for slot names and keys.
+     *
+     * @returns {Array<StepEntry>}
+     */
+    get stepEntries(): Array<StepEntry>;
+    /**
+     * Total number of steps.
+     *
+     * @returns {number}
+     */
+    get stepCount(): number;
+    /**
+     * Whether the active step is controlled via `parcel.value`.
+     *
+     * @returns {boolean}
+     */
+    isControlled(): boolean;
+    /**
+     * Whether the whole stepper is disabled.
+     *
+     * @returns {boolean}
+     */
+    isDisabled(): boolean;
+    /**
+     * Whether the stepper lays out vertically.
+     *
+     * @returns {boolean}
+     */
+    isVertical(): boolean;
+    /**
+     * Whether steps must be completed in order (no forward jumps).
+     *
+     * @returns {boolean}
+     */
+    isLinear(): boolean;
+    /**
+     * Whether step panels render. When false, the component is an indicator
+     * strip only (e.g. the active value drives an external form region).
+     *
+     * @returns {boolean}
+     */
+    shouldShowPanels(): boolean;
+    /**
+     * Resolve the layout orientation.
+     *
+     * @returns {'horizontal' | 'vertical'}
+     */
+    extractOrientation(): "horizontal" | "vertical";
+    /**
+     * Resolve the step number of the first step, if any.
+     *
+     * @returns {number | null}
+     */
+    extractFirstStepValue(): number | null;
+    /**
+     * Resolve the active step number for the root host element.
+     * `parcel.value` takes precedence; otherwise the internal ref,
+     * falling back to the first step.
+     *
+     * @returns {number | null}
+     */
+    extractActiveValue(): number | null;
+    /**
+     * Extract attributes for the root host element.
+     * The `modelValue` key is only included when an active step exists, so the
+     * primitive stays uncontrolled when there are no steps.
+     *
+     * @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>;
+    /**
+     * Whether a given step is the active one.
+     *
+     * @param {{
+     *   step: number
+     * }} params
+     * @returns {boolean}
+     */
+    isActiveStep({ step, }: {
+        step: number;
+    }): boolean;
+    /**
+     * Whether a given step precedes the active one (visually completed).
+     *
+     * @param {{
+     *   step: number
+     * }} params
+     * @returns {boolean}
+     */
+    isCompletedStep({ step, }: {
+        step: number;
+    }): boolean;
+    /**
+     * Whether a separator renders after a given index.
+     *
+     * @param {{
+     *   index: number
+     * }} params
+     * @returns {boolean}
+     */
+    hasSeparatorAfter({ index, }: {
+        index: number;
+    }): boolean;
+    /**
+     * Handle active-step changes from the root host element.
+     *
+     * @param {{
+     *   value: number
+     * }} params
+     */
+    onStepChange({ value, }: {
+        value: number;
+    }): void;
+    /**
+     * Setup component context.
+     *
+     * @template {X extends FuroStepperContext ? X : never} T, X
+     * @override
+     * @returns {T} For method chaining.
+     * @this {T}
+     */
+    override setupComponent<T extends X extends FuroStepperContext ? X : never, X>(this: T): T;
+}
+export type FuroStepperContextParams = import("../../../contexts/BaseFuroContext.js").BaseFuroContextParams & {
+    props: Props;
+    componentContext: ComponentContext;
+    refHash: {
+        activeValueRef: import("vue").Ref<number | null>;
+    };
+};
+export type FuroStepperContextFactoryParams = Omit<FuroStepperContextParams, "refHash"> & {
+    refHash?: FuroStepperContextParams["refHash"];
+};
+export type EmitEventName = keyof typeof FuroStepperContext.EMIT_EVENT_NAME;
+export type Props = import("vue").HTMLAttributes & {
+    parcel?: FuroStepperParcel | null;
+};
+/**
+ * Closed-set Furo behavior for `<FuroStepper>`.
+ * JSON-serializable only. Not an open passthrough to the internal stepper primitive.
+ */
+export type FuroStepperParcel = {
+    steps?: Array<FuroStepperStep>;
+    value?: number | null;
+    orientation?: "horizontal" | "vertical";
+    linear?: boolean;
+    showPanels?: boolean;
+    disabled?: boolean;
+};
+export type FuroStepperStep = {
+    value: string | number;
+    title?: string;
+    description?: string;
+    slotName?: string;
+    disabled?: boolean;
+};
+export type StepEntry = {
+    step: number;
+    value: string | number;
+    title: string;
+    description: string | null;
+    disabled: boolean;
+    panelSlotName: string;
+    indicatorSlotName: string;
+    titleSlotName: string;
+};
+export type ComponentContext = import("vue").SetupContext<FuroStepperEmitHash, FuroStepperSlots>;
+export type FuroStepperEmitHash = typeof FuroStepperContext.EMIT_EVENT_HASH;
+export type FuroStepperSlots = import("vue").SlotsType<Record<string, {
+    value?: string | number;
+    step?: number;
+    completed?: boolean;
+}>>;
+export type FuroStepperSetup = (props: Props, componentContext: ComponentContext) => {
+    context: FuroStepperContext;
+};
+import BaseFuroContext from '../../../contexts/BaseFuroContext.js';