@quidgest/ui 0.25.0 → 0.27.0

package/esm/components/QSteps/QStepsNav.vue.js

@@ -0,0 +1,42 @@
+import { QButton as e } from "../QButton/index.js";
+import { QIcon as t } from "../QIcon/index.js";
+import { createElementBlock as n, createVNode as r, defineComponent as i, guardReactiveProps as a, normalizeProps as o, openBlock as s, renderSlot as c, unref as l, withCtx as u } from "vue";
+//#region src/components/QSteps/QStepsNav.vue?vue&type=script&setup=true&lang.ts
+var d = { class: "q-steps__nav" }, f = /*@__PURE__*/ i({
+	__name: "QStepsNav",
+	props: {
+		prevSlotProps: {},
+		nextSlotProps: {},
+		icons: {}
+	},
+	setup(i) {
+		let f = i;
+		return (i, p) => (s(), n("div", d, [c(i.$slots, "prev", o(a(f.prevSlotProps)), () => [r(l(e), {
+			"data-testid": "steps-prev",
+			label: f.prevSlotProps.label,
+			disabled: f.prevSlotProps.disabled,
+			onClick: f.prevSlotProps.onClick
+		}, {
+			default: u(() => [r(l(t), o(a(f.icons.previous)), null, 16)]),
+			_: 1
+		}, 8, [
+			"label",
+			"disabled",
+			"onClick"
+		])]), c(i.$slots, "next", o(a(f.nextSlotProps)), () => [r(l(e), {
+			"data-testid": "steps-next",
+			label: f.nextSlotProps.label,
+			disabled: f.nextSlotProps.disabled,
+			onClick: f.nextSlotProps.onClick
+		}, {
+			append: u(() => [r(l(t), o(a(f.icons.next)), null, 16)]),
+			_: 1
+		}, 8, [
+			"label",
+			"disabled",
+			"onClick"
+		])])]));
+	}
+});
+//#endregion
+export { f as default };

package/esm/components/QSteps/QStepsNav2.vue.js

@@ -0,0 +1,5 @@
+import e from "./QStepsNav.vue.js";
+//#region src/components/QSteps/QStepsNav.vue
+var t = e;
+//#endregion
+export { t as default };

package/esm/components/QSteps/constants.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Default icons for {@link QSteps}'s navigation buttons and status badges.
+ */
+export declare const DEFAULT_ICONS: {
+    previous: {
+        icon: string;
+    };
+    next: {
+        icon: string;
+    };
+    completed: {
+        icon: string;
+    };
+    current: {
+        icon: string;
+    };
+};
+/**
+ * Default text overrides for {@link QSteps}.
+ */
+export declare const DEFAULT_TEXTS: {
+    previous: string;
+    next: string;
+    completed: string;
+    current: string;
+    required: string;
+};
+//# sourceMappingURL=constants.d.ts.map

package/esm/components/QSteps/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/components/QSteps/constants.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;CAaY,CAAA;AAEtC;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;CAMQ,CAAA"}

package/esm/components/QSteps/constants.js

@@ -0,0 +1,16 @@
+import { DEFAULT_TEXTS as e } from "../__internal__/QRequiredIndicator/constants.js";
+//#region src/components/QSteps/constants.ts
+var t = {
+	previous: { icon: "chevron-left-circle" },
+	next: { icon: "chevron-right-circle" },
+	completed: { icon: "check" },
+	current: { icon: "pencil" }
+}, n = {
+	...e,
+	previous: "Previous",
+	next: "Next",
+	completed: "Completed",
+	current: "Currently editing"
+};
+//#endregion
+export { t as DEFAULT_ICONS, n as DEFAULT_TEXTS };

package/esm/components/QSteps/index.d.ts

@@ -0,0 +1,228 @@
+declare const QSteps: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        modelValue?: string;
+    } & import('../..').QBaseComponentProps & {
+        steps: import('./types').QStep[];
+        direction?: import('./types').QStepsDirection;
+        variant?: import('./types').QStepsVariant;
+        disabled?: boolean;
+        linear?: boolean;
+        icons?: typeof import('./constants').DEFAULT_ICONS;
+        texts?: typeof import('./constants').DEFAULT_TEXTS;
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onFinish?: (() => any) | undefined;
+    }>, {
+        previous: () => void;
+        next: () => void;
+        isFirst: import('vue').ComputedRef<boolean>;
+        isLast: import('vue').ComputedRef<boolean>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:modelValue": (value: string) => any;
+        finish: () => any;
+    }, import('vue').PublicProps, {
+        variant: import('./types').QStepsVariant;
+        icons: typeof import('./constants').DEFAULT_ICONS;
+        texts: typeof import('./constants').DEFAULT_TEXTS;
+        linear: boolean;
+        direction: import('./types').QStepsDirection;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        overflowRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly id?: string | undefined;
+                readonly class?: string | unknown[] | undefined;
+                readonly direction?: import('..').QOverflowDirection | undefined;
+                readonly arrowPlacement?: import('..').QOverflowArrowPlacement | undefined;
+                readonly arrowVisibility?: import('..').QOverflowArrowVisibility | undefined;
+                readonly scrollMode?: import('..').QOverflowScrollMode | undefined;
+                readonly scrollStep?: number | undefined;
+                readonly remapWheel?: boolean | undefined;
+                readonly contentClass?: string | unknown[] | undefined;
+                readonly icons?: typeof import('../QOverflow/constants').DEFAULT_ICONS | undefined;
+                readonly texts?: import('..').QOverflowTexts | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                viewportRef: HTMLDivElement;
+                contentRef: HTMLDivElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('..').QOverflowProps> & Readonly<{}>, {
+                contentEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                scrollElementIntoView: (element: HTMLElement) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                icons: typeof import('../QOverflow/constants').DEFAULT_ICONS;
+                texts: import('..').QOverflowTexts;
+                direction: import('..').QOverflowDirection;
+                arrowPlacement: import('..').QOverflowArrowPlacement;
+                arrowVisibility: import('..').QOverflowArrowVisibility;
+                scrollMode: import('..').QOverflowScrollMode;
+                scrollStep: number;
+                remapWheel: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            icons: typeof import('../QOverflow/constants').DEFAULT_ICONS;
+            texts: import('..').QOverflowTexts;
+            direction: import('..').QOverflowDirection;
+            arrowPlacement: import('..').QOverflowArrowPlacement;
+            arrowVisibility: import('..').QOverflowArrowVisibility;
+            scrollMode: import('..').QOverflowScrollMode;
+            scrollStep: number;
+            remapWheel: boolean;
+        }> & Omit<Readonly<import('..').QOverflowProps> & Readonly<{}>, "contentEl" | "scrollElementIntoView" | ("icons" | "texts" | "direction" | "arrowPlacement" | "arrowVisibility" | "scrollMode" | "scrollStep" | "remapWheel")> & {
+            contentEl: HTMLElement | null;
+            scrollElementIntoView: (element: HTMLElement) => void;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                prev?(_: {
+                    disabled: boolean;
+                    onClick: () => void;
+                }): any;
+                default?(_: {}): any;
+                next?(_: {
+                    disabled: boolean;
+                    onClick: () => void;
+                }): any;
+            };
+        }) | null;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        modelValue?: string;
+    } & import('../..').QBaseComponentProps & {
+        steps: import('./types').QStep[];
+        direction?: import('./types').QStepsDirection;
+        variant?: import('./types').QStepsVariant;
+        disabled?: boolean;
+        linear?: boolean;
+        icons?: typeof import('./constants').DEFAULT_ICONS;
+        texts?: typeof import('./constants').DEFAULT_TEXTS;
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onFinish?: (() => any) | undefined;
+    }>, {
+        previous: () => void;
+        next: () => void;
+        isFirst: import('vue').ComputedRef<boolean>;
+        isLast: import('vue').ComputedRef<boolean>;
+    }, {}, {}, {}, {
+        variant: import('./types').QStepsVariant;
+        icons: typeof import('./constants').DEFAULT_ICONS;
+        texts: typeof import('./constants').DEFAULT_TEXTS;
+        linear: boolean;
+        direction: import('./types').QStepsDirection;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<{
+    modelValue?: string;
+} & import('../..').QBaseComponentProps & {
+    steps: import('./types').QStep[];
+    direction?: import('./types').QStepsDirection;
+    variant?: import('./types').QStepsVariant;
+    disabled?: boolean;
+    linear?: boolean;
+    icons?: typeof import('./constants').DEFAULT_ICONS;
+    texts?: typeof import('./constants').DEFAULT_TEXTS;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onFinish?: (() => any) | undefined;
+}>, {
+    previous: () => void;
+    next: () => void;
+    isFirst: import('vue').ComputedRef<boolean>;
+    isLast: import('vue').ComputedRef<boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    finish: () => any;
+}, string, {
+    variant: import('./types').QStepsVariant;
+    icons: typeof import('./constants').DEFAULT_ICONS;
+    texts: typeof import('./constants').DEFAULT_TEXTS;
+    linear: boolean;
+    direction: import('./types').QStepsDirection;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        icon?(_: {
+            step: import('./types').QStep;
+            index: number;
+        }): any;
+        icon?(_: {
+            step: import('./types').QStep;
+            index: number;
+        }): any;
+        icon?(_: {
+            step: import('./types').QStep;
+            index: number;
+        }): any;
+        default?(_: {}): any;
+        default?(_: {}): any;
+        prev?(_: {
+            disabled: boolean;
+            label: string;
+            isFirst: boolean;
+            isLast: boolean;
+            onClick: () => void;
+        }): any;
+        prev?(_: {
+            disabled: boolean;
+            label: string;
+            isFirst: boolean;
+            isLast: boolean;
+            onClick: () => void;
+        }): any;
+        next?(_: {
+            disabled: boolean;
+            label: string;
+            isFirst: boolean;
+            isLast: boolean;
+            onClick: () => void;
+        }): any;
+        next?(_: {
+            disabled: boolean;
+            label: string;
+            isFirst: boolean;
+            isLast: boolean;
+            onClick: () => void;
+        }): any;
+    };
+});
+export { QSteps };
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/esm/components/QSteps/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QSteps/index.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAO270B,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAPth1B,CAAA;AAGvC,OAAO,EAAE,MAAM,EAAE,CAAA;AAGjB,cAAc,SAAS,CAAA"}

package/esm/components/QSteps/index.js

@@ -0,0 +1,6 @@
+import { setupPropsProxy as e } from "../../utils/setupPropsProxy.js";
+import t from "./QSteps2.vue.js";
+//#region src/components/QSteps/index.ts
+var n = e(t);
+//#endregion
+export { n as QSteps };

package/esm/components/QSteps/types.d.ts

@@ -0,0 +1,190 @@
+import { QBaseComponentProps } from '../../types/component';
+import { QIconProps } from '../QIcon';
+import { DEFAULT_ICONS, DEFAULT_TEXTS } from './constants';
+/**
+ * Layout direction of the step list.
+ *
+ * - `horizontal` — steps in a row, content below
+ * - `vertical` — steps in a column, content under the active header
+ */
+export type QStepsDirection = 'horizontal' | 'vertical';
+/**
+ * Visual style of the step indicators.
+ *
+ * - `circle` — numbered or iconed nodes connected by a line
+ * - `dot` — plain dots connected by a line, no numbers or icons
+ * - `boxed` — filled rounded rectangles with gaps
+ * - `arrow` — interlocking chevron segments
+ */
+export type QStepsVariant = 'circle' | 'dot' | 'boxed' | 'arrow';
+/**
+ * Definition of a single step in {@link QSteps}.
+ */
+export type QStep = {
+    /**
+     * Identity used by `v-model` on `QSteps`.
+     *
+     * @category Identification
+     */
+    value: string;
+    /**
+     * The primary label shown on the step header.
+     *
+     * @category Content
+     */
+    title?: string;
+    /**
+     * Secondary line shown under the title.
+     *
+     * @category Content
+     */
+    caption?: string;
+    /**
+     * If true, shows a required asterisk next to the title.
+     *
+     * The asterisk is decorative (`aria-hidden`); {@link QRequiredIndicator}
+     * also exposes an accessible label via `.q-sr-only` when announced
+     * (from `texts.required`). `aria-required` is not set: it is not allowed on the header `button`.
+     *
+     * @category Presentation
+     */
+    required?: boolean;
+    /**
+     * If true, the step cannot be selected and is skipped by Next/Previous.
+     *
+     * @category State
+     */
+    disabled?: boolean;
+    /**
+     * If true, shows a completed badge on the indicator, taking precedence
+     * over the active step's "editing" badge when both apply. Not shown at
+     * all for `dot` — see {@link QStepBadgeState}.
+     *
+     * @category State
+     */
+    completed?: boolean;
+    /**
+     * Optional icon shown in the indicator instead of the step number.
+     *
+     * Overridden by the `#icon` slot when provided.
+     *
+     * @category Content
+     */
+    icon?: QIconProps;
+};
+/**
+ * Status badge shown on a step's indicator.
+ *
+ * - `completed` — `step.completed` is set, taking precedence over `active`
+ * - `active` — the current step is being edited (not shown for `dot`)
+ */
+export type QStepBadgeState = 'active' | 'completed';
+/**
+ * Slot props passed to the `prev` and `next` slots on {@link QSteps}.
+ */
+export type QStepsNavSlotProps = {
+    /**
+     * Whether the navigation button is disabled.
+     *
+     * @category State
+     */
+    disabled: boolean;
+    /**
+     * Resolved label for the navigation button.
+     *
+     * @category Content
+     */
+    label: string;
+    /**
+     * Whether the active step is the first enabled one.
+     *
+     * @category State
+     */
+    isFirst: boolean;
+    /**
+     * Whether the active step is the last enabled one.
+     *
+     * @category State
+     */
+    isLast: boolean;
+    /**
+     * Click handler that performs previous / next navigation, or emits
+     * `finish` when the active step is already the last one.
+     *
+     * @category Behavior
+     */
+    onClick: () => void;
+};
+/**
+ * Scoped slot props for the `icon` slot on {@link QSteps}.
+ */
+export type QStepsIconSlotProps = {
+    /**
+     * The step definition for this indicator.
+     *
+     * @category Content
+     */
+    step: QStep;
+    /**
+     * Zero-based index of the step in the `steps` array.
+     *
+     * @category Identification
+     */
+    index: number;
+};
+/**
+ * Props for the QSteps component.
+ *
+ * @extends QBaseComponentProps
+ */
+export type QStepsProps = QBaseComponentProps & {
+    /**
+     * Ordered list of step definitions.
+     *
+     * @category Content
+     */
+    steps: QStep[];
+    /**
+     * Orientation of the step list.
+     *
+     * @default 'horizontal'
+     * @category Presentation
+     */
+    direction?: QStepsDirection;
+    /**
+     * Visual style of the step indicators.
+     *
+     * @default 'circle'
+     * @category Presentation
+     */
+    variant?: QStepsVariant;
+    /**
+     * If true, disables all step headers and navigation.
+     *
+     * @category State
+     */
+    disabled?: boolean;
+    /**
+     * If true, header clicks cannot skip ahead of the furthest reached step.
+     *
+     * Next/Previous navigation still works.
+     *
+     * @default false
+     * @category Behavior
+     */
+    linear?: boolean;
+    /**
+     * Custom icons for the previous/next navigation buttons and the
+     * `completed`/`current` status badges.
+     *
+     * @category Configuration
+     */
+    icons?: typeof DEFAULT_ICONS;
+    /**
+     * Custom accessible strings.
+     *
+     * @category Configuration
+     */
+    texts?: typeof DEFAULT_TEXTS;
+};
+//# sourceMappingURL=types.d.ts.map

package/esm/components/QSteps/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/QSteps/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE/D;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG,UAAU,CAAA;AAEvD;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,KAAK,GAAG,OAAO,GAAG,OAAO,CAAA;AAEhE;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IACnB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAA;IAEb;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAEhB;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,UAAU,CAAA;CACjB,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,WAAW,CAAA;AAEpD;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAChC;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAA;IAEjB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAA;IAEb;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAA;IAEhB;;;;OAIG;IACH,MAAM,EAAE,OAAO,CAAA;IAEf;;;;;OAKG;IACH,OAAO,EAAE,MAAM,IAAI,CAAA;CACnB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG;IACjC;;;;OAIG;IACH,IAAI,EAAE,KAAK,CAAA;IAEX;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,mBAAmB,GAAG;IAC/C;;;;OAIG;IACH,KAAK,EAAE,KAAK,EAAE,CAAA;IAEd;;;;;OAKG;IACH,SAAS,CAAC,EAAE,eAAe,CAAA;IAE3B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,aAAa,CAAA;IAEvB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAEhB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,aAAa,CAAA;IAE5B;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,aAAa,CAAA;CAC5B,CAAA"}

package/esm/components/QSwitch/QSwitch.vue.js

@@ -1,5 +1,5 @@
-import { useColor as e } from "../../composables/useColor/index.js";
-import { useId as t } from "../../composables/useId/index.js";
+import { useId as e } from "../../composables/useId/index.js";
+import { useColor as t } from "../../composables/useColor/index.js";
 import { QLabel as n } from "../QLabel/index.js";
 import { Fragment as r, computed as i, createBlock as a, createCommentVNode as o, createElementBlock as s, createElementVNode as c, createTextVNode as l, defineComponent as u, mergeModels as d, mergeProps as f, normalizeClass as p, normalizeStyle as m, openBlock as h, toDisplayString as g, toRef as _, unref as v, useModel as y, useTemplateRef as b, vModelCheckbox as x, withDirectives as S, withModifiers as C } from "vue";
 //#region src/components/QSwitch/QSwitch.vue?vue&type=script&setup=true&lang.ts
@@ -40,7 +40,7 @@ var w = [
 			d.readonly && (e.preventDefault(), e.stopImmediatePropagation(), e.target.checked = !!O.value);
 		}, j = () => {
 			d.disabled || d.readonly || k.value?.click();
-		}, M = t(_(d, "id")), { style: N } = e(_(d, "checkedColor")), { style: P } = e(_(d, "uncheckedColor")), F = i(() => [
+		}, M = e(_(d, "id")), { style: N } = t(_(d, "checkedColor")), { style: P } = t(_(d, "uncheckedColor")), F = i(() => [
 			"q-switch",
 			d.size === "small" || d.size === "large" ? `q-switch--${d.size}` : void 0,
 			{

package/esm/components/QTabs/QTab.d.ts

@@ -1,5 +1,5 @@
 import { DEFAULT_TEXTS } from './constants';
-import { QTabProps } from './types';
+import { QTabProps } from '.';
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {

package/esm/components/QTabs/QTab.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QTab.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/QTab.vue"],"names":[],"mappings":"AA6CA;AAuNC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAW3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AA+JzC,iBAAS,cAAc;WAwHT,OAAO,IAA6B;;iCAdZ,GAAG;uBACb,GAAG;gCACM,GAAG;yBACV,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAmEisW,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;EAnDv1W;AAqBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA6B6sW,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;OArBt1W,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"QTab.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/QTab.vue"],"names":[],"mappings":"AA4CA;AAsNC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAW3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,GAAG,CAAA;AA+JnC,iBAAS,cAAc;WAsHT,OAAO,IAA6B;;iCAdZ,GAAG;uBACb,GAAG;gCACM,GAAG;yBACV,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAmEi2W,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;EAnDv/W;AAqBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA6B62W,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;OArBt/W,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/esm/components/QTabs/QTab.vue.js

@@ -1,8 +1,8 @@
 import { useGroupItem as e } from "../../composables/useGroup/index.js";
-import { DEFAULT_TEXTS as t } from "../__internal__/QRequiredIndicator/constants.js";
-import { QButton as n } from "../QButton/index.js";
-import { QRequiredIndicator as r } from "../__internal__/QRequiredIndicator/index.js";
-import { useId as i } from "../../composables/useId/index.js";
+import { useId as t } from "../../composables/useId/index.js";
+import { DEFAULT_TEXTS as n } from "../__internal__/QRequiredIndicator/constants.js";
+import { QButton as r } from "../QButton/index.js";
+import { QRequiredIndicator as i } from "../__internal__/QRequiredIndicator/index.js";
 import { TabsSymbol as a } from "./context.js";
 import { Fragment as o, Teleport as s, computed as c, createBlock as l, createCommentVNode as u, createElementBlock as d, createElementVNode as f, createVNode as p, defineComponent as m, inject as h, normalizeClass as g, onBeforeMount as _, onBeforeUnmount as v, openBlock as y, renderSlot as b, toDisplayString as x, toRef as S, unref as C, useTemplateRef as w, vShow as T, watch as E, withCtx as D, withDirectives as O } from "vue";
 //#region src/components/QTabs/QTab.vue?vue&type=script&setup=true&lang.ts
@@ -19,12 +19,12 @@ var k = { class: "q-tab__title" }, A = { class: "q-tab__title-text" }, j = [
 		required: { type: Boolean },
 		disabled: { type: Boolean },
 		value: {},
-		texts: { default: () => t }
+		texts: { default: () => n }
 	},
-	setup(t) {
-		let m = t, M = h(a, void 0);
+	setup(n) {
+		let m = n, M = h(a, void 0);
 		if (!M) throw Error("QTab: Failed to retrieve tabs context. Ensure the component is used within a QTabs context.");
-		let N = i(S(m, "value")), P = i(), F = i(), I = e(N);
+		let N = t(S(m, "value")), P = t(), F = t(), I = e(N);
 		if (!I) throw Error("QTab: Failed to retrieve group item. Ensure the component is used within a QTabs context.");
 		let L = w("tabBtn"), R = c(() => M.tabListEl.value), z = c(() => !!m.disabled), B = c(() => {
 			if (!z.value) return I.isActive.value ? 0 : -1;
@@ -76,7 +76,7 @@ var k = { class: "q-tab__title" }, A = { class: "q-tab__title-text" }, j = [
 		}), (e, t) => (y(), d(o, null, [R.value ? (y(), l(s, {
 			key: 0,
 			to: R.value
-		}, [p(C(n), {
+		}, [p(C(r), {
 			id: C(P),
 			ref: "tabBtn",
 			borderless: "",
@@ -87,7 +87,6 @@ var k = { class: "q-tab__title" }, A = { class: "q-tab__title-text" }, j = [
 			"data-value": C(N),
 			"aria-selected": C(I).isActive.value,
 			"aria-controls": C(F),
-			"aria-required": m.required || void 0,
 			tabindex: B.value,
 			onClick: W,
 			onKeydown: G
@@ -95,7 +94,7 @@ var k = { class: "q-tab__title" }, A = { class: "q-tab__title-text" }, j = [
 			default: D(() => [f("span", k, [
 				b(e.$slots, "title.prepend"),
 				b(e.$slots, "title", {}, () => [f("span", A, x(m.title), 1)]),
-				m.required ? (y(), l(C(r), {
+				m.required ? (y(), l(C(i), {
 					key: 0,
 					announce: "",
 					texts: m.texts
@@ -110,7 +109,6 @@ var k = { class: "q-tab__title" }, A = { class: "q-tab__title-text" }, j = [
 			"data-value",
 			"aria-selected",
 			"aria-controls",
-			"aria-required",
 			"tabindex"
 		])], 8, ["to"])) : u("v-if", !0), O(f("div", {
 			id: C(F),

package/esm/components/QTabs/QTabs.d.ts

@@ -1,4 +1,4 @@
-import { QTabsProps } from './types';
+import { QTabsProps } from '.';
 import { nextTick } from 'vue';
 type __VLS_Props = QTabsProps;
 type __VLS_PublicProps = {

package/esm/components/QTabs/QTabs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QTabs.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/QTabs.vue"],"names":[],"mappings":"AAyBA;AAycC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGzC,OAAO,EAEN,QAAQ,EASR,MAAM,KAAK,CAAA;AAGZ,KAAK,WAAW,GAAG,UAAU,CAAC;AAkZ/B,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAiET,OAAO,IAA6B;;yBAZrB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCA+D0e,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA9C/nB;AAcD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA+Bqf,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;kBArB9nB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"QTabs.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/QTabs.vue"],"names":[],"mappings":"AAyBA;AAocC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,GAAG,CAAA;AAGnC,OAAO,EAEN,QAAQ,EASR,MAAM,KAAK,CAAA;AAGZ,KAAK,WAAW,GAAG,UAAU,CAAC;AAyY/B,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAiET,OAAO,IAA6B;;yBAZrB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAgEynB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA/C9wB;AAeD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA+BooB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;kBArB7wB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}