@porsche-design-system/components-vue 3.31.0 → 4.0.0-alpha.0

package/esm/lib/components/PinCodeWrapper.vue.mjs

@@ -1,6 +1,6 @@
-import { defineComponent as u, ref as m, inject as c, onMounted as i, onUpdated as h, watch as y, createBlock as b, openBlock as g, resolveDynamicComponent as v, unref as B, withCtx as C, renderSlot as _ } from "vue";
-import { usePrefix as P, themeInjectionKey as R, syncProperties as p, addEventListenerToElementRef as n } from "../../utils.mjs";
-const x = /* @__PURE__ */ u({
+import { defineComponent as p, ref as s, onMounted as u, onUpdated as c, createBlock as m, openBlock as i, resolveDynamicComponent as y, unref as b, withCtx as g, renderSlot as B } from "vue";
+import { usePrefix as C, syncProperties as _, addEventListenerToElementRef as n } from "../../utils.mjs";
+const k = /* @__PURE__ */ p({
   __name: "PinCodeWrapper",
   props: {
     compact: { type: Boolean, default: !1 },
@@ -15,30 +15,27 @@ const x = /* @__PURE__ */ u({
     name: {},
     required: { type: Boolean, default: !1 },
     state: { default: "none" },
-    theme: {},
     type: { default: "number" },
     value: { default: "" }
   },
-  emits: ["update:value", "blur", "change", "update"],
-  setup(f, { emit: r }) {
-    const s = P("p-pin-code"), o = f, e = m(), a = r, l = c(R), d = () => p(e, { ...o, theme: o.theme || l.value });
-    return i(() => {
-      d(), n(e, "blur", a), n(e, "change", a, (t) => {
-        a("update:value", t.target.value);
-      }), n(e, "update", a);
-    }), h(d), y(l, (t) => {
-      p(e, { theme: o.theme || t });
-    }), (t, j) => (g(), b(v(B(s)), {
+  emits: ["update:value", "blur", "change"],
+  setup(l, { emit: d }) {
+    const r = C("p-pin-code"), f = l, e = s(), t = d, o = () => _(e, f);
+    return u(() => {
+      o(), n(e, "blur", t), n(e, "change", t, (a) => {
+        t("update:value", a.target.value);
+      });
+    }), c(o), (a, h) => (i(), m(y(b(r)), {
       ref_key: "pdsComponentRef",
       ref: e
     }, {
-      default: C(() => [
-        _(t.$slots, "default")
+      default: g(() => [
+        B(a.$slots, "default")
       ]),
       _: 3
     }, 512));
   }
 });
 export {
-  x as default
+  k as default
 };

package/esm/lib/components/PopoverWrapper.vue.d.ts

@@ -1,4 +1,4 @@
-import type { SelectedAriaAttributes, PopoverAriaAttribute, PopoverDirection, Theme } from '../types';
+import type { SelectedAriaAttributes, PopoverAriaAttribute, PopoverDirection } from '../types';
 type PPopoverProps = {
     /**
      * Add ARIA attributes.
@@ -12,10 +12,6 @@ type PPopoverProps = {
      * Preferred direction in which popover should open, given there is enough space in viewport. Otherwise, it will be opened in the direction with most available space.
      */
     direction?: PopoverDirection;
-    /**
-     * Adapts the popover color depending on the theme.
-     */
-    theme?: Theme;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {

package/esm/lib/components/PopoverWrapper.vue.mjs

@@ -1,28 +1,25 @@
-import { defineComponent as m, ref as a, inject as f, onMounted as i, onUpdated as d, watch as u, createBlock as h, openBlock as l, resolveDynamicComponent as _, unref as C, withCtx as y, renderSlot as v } from "vue";
-import { usePrefix as P, themeInjectionKey as k, syncProperties as p } from "../../utils.mjs";
-const b = /* @__PURE__ */ m({
+import { defineComponent as s, ref as c, onMounted as a, onUpdated as f, createBlock as d, openBlock as i, resolveDynamicComponent as m, unref as u, withCtx as l, renderSlot as _ } from "vue";
+import { usePrefix as C, syncProperties as y } from "../../utils.mjs";
+const x = /* @__PURE__ */ s({
   __name: "PopoverWrapper",
   props: {
     aria: {},
     description: {},
-    direction: { default: "bottom" },
-    theme: {}
+    direction: { default: "bottom" }
   },
-  setup(s) {
-    const c = P("p-popover"), e = s, o = a(), n = f(k), r = () => p(o, { ...e, theme: e.theme || n.value });
-    return i(r), d(r), u(n, (t) => {
-      p(o, { theme: e.theme || t });
-    }), (t, w) => (l(), h(_(C(c)), {
+  setup(t) {
+    const n = C("p-popover"), r = t, e = c(), o = () => y(e, r);
+    return a(o), f(o), (p, P) => (i(), d(m(u(n)), {
       ref_key: "pdsComponentRef",
-      ref: o
+      ref: e
     }, {
-      default: y(() => [
-        v(t.$slots, "default")
+      default: l(() => [
+        _(p.$slots, "default")
       ]),
       _: 3
     }, 512));
   }
 });
 export {
-  b as default
+  x as default
 };

package/esm/lib/components/RadioGroupWrapper.vue.d.ts

@@ -1,4 +1,4 @@
-import type { BreakpointCustomizable, RadioGroupDirection, RadioGroupState, Theme } from '../types';
+import type { BreakpointCustomizable, RadioGroupDirection, RadioGroupState } from '../types';
 type PRadioGroupProps = {
     /**
      * A boolean value that, if present, renders the radio group as a compact version.
@@ -48,10 +48,6 @@ type PRadioGroupProps = {
      * Indicates the validation or overall status of the radio group component.
      */
     state?: RadioGroupState;
-    /**
-     * Controls the visual appearance of the component.
-     */
-    theme?: Theme;
     /**
      * The default value for the radio-group.
      */
@@ -75,8 +71,8 @@ declare const __VLS_base: import("vue").DefineComponent<PRadioGroupProps, {}, {}
     hideLabel: BreakpointCustomizable<boolean>;
     loading: boolean;
     value: string;
-    direction: BreakpointCustomizable<RadioGroupDirection>;
     message: string;
+    direction: BreakpointCustomizable<RadioGroupDirection>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/esm/lib/components/RadioGroupWrapper.vue.mjs

@@ -1,6 +1,6 @@
-import { defineComponent as u, ref as m, inject as c, onMounted as i, onUpdated as h, watch as y, createBlock as b, openBlock as g, resolveDynamicComponent as v, unref as B, withCtx as _, renderSlot as C } from "vue";
-import { usePrefix as R, themeInjectionKey as j, syncProperties as r, addEventListenerToElementRef as d } from "../../utils.mjs";
-const P = /* @__PURE__ */ u({
+import { defineComponent as s, ref as f, onMounted as u, onUpdated as c, createBlock as i, openBlock as m, resolveDynamicComponent as y, unref as b, withCtx as g, renderSlot as B } from "vue";
+import { usePrefix as _, syncProperties as v, addEventListenerToElementRef as n } from "../../utils.mjs";
+const k = /* @__PURE__ */ s({
   __name: "RadioGroupWrapper",
   props: {
     compact: { type: Boolean, default: !1 },
@@ -15,29 +15,26 @@ const P = /* @__PURE__ */ u({
     name: {},
     required: { type: Boolean, default: !1 },
     state: { default: "none" },
-    theme: {},
     value: { default: "" }
   },
   emits: ["update:value", "blur", "change"],
-  setup(s, { emit: f }) {
-    const p = R("p-radio-group"), o = s, e = m(), a = f, n = c(j), l = () => r(e, { ...o, theme: o.theme || n.value });
-    return i(() => {
-      l(), d(e, "blur", a), d(e, "change", a, (t) => {
-        a("update:value", t.target.value);
+  setup(l, { emit: r }) {
+    const d = _("p-radio-group"), p = l, e = f(), t = r, a = () => v(e, p);
+    return u(() => {
+      a(), n(e, "blur", t), n(e, "change", t, (o) => {
+        t("update:value", o.target.value);
       });
-    }), h(l), y(n, (t) => {
-      r(e, { theme: o.theme || t });
-    }), (t, k) => (g(), b(v(B(p)), {
+    }), c(a), (o, C) => (m(), i(y(b(d)), {
       ref_key: "pdsComponentRef",
       ref: e
     }, {
-      default: _(() => [
-        C(t.$slots, "default")
+      default: g(() => [
+        B(o.$slots, "default")
       ]),
       _: 3
     }, 512));
   }
 });
 export {
-  P as default
+  k as default
 };

package/esm/lib/components/ScrollerWrapper.vue.d.ts

@@ -1,4 +1,4 @@
-import type { ScrollerAlignScrollIndicator, SelectedAriaAttributes, ScrollerAriaAttribute, ScrollerGradientColor, ScrollerGradientColorScheme, ScrollerScrollIndicatorPosition, ScrollerScrollToPosition, Theme } from '../types';
+import type { ScrollerAlignScrollIndicator, SelectedAriaAttributes, ScrollerAriaAttribute, ScrollerScrollToPosition } from '../types';
 type PScrollerProps = {
     /**
      * Sets the vertical position of scroll indicator.
@@ -8,18 +8,6 @@ type PScrollerProps = {
      * Add ARIA role.
      */
     aria?: SelectedAriaAttributes<ScrollerAriaAttribute>;
-    /**
-     * @deprecated since v3.29.0, will be removed with next major release. Adapts the background gradient color of prev and next button.
-     */
-    gradientColor?: ScrollerGradientColor;
-    /**
-     * @deprecated since v3.0.0, will be removed with next major release. Adapts the background gradient color of prev and next button.
-     */
-    gradientColorScheme?: ScrollerGradientColorScheme;
-    /**
-     * @deprecated since v3.0.0, will be removed with next major release, use `alignScrollIndicator` instead. Sets the vertical position of scroll indicator
-     */
-    scrollIndicatorPosition?: ScrollerScrollIndicatorPosition;
     /**
      * Scrolls the scroll area to the left either smooth or immediately.
      */
@@ -28,10 +16,6 @@ type PScrollerProps = {
      * Specifies if scrollbar should be shown.
      */
     scrollbar?: boolean;
-    /**
-     * Adapts the color when used on dark background.
-     */
-    theme?: Theme;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {

package/esm/lib/components/ScrollerWrapper.vue.mjs

@@ -1,27 +1,21 @@
-import { defineComponent as a, ref as p, inject as i, onMounted as m, onUpdated as f, watch as d, createBlock as u, openBlock as h, resolveDynamicComponent as C, unref as _, withCtx as y, renderSlot as P } from "vue";
-import { usePrefix as g, themeInjectionKey as S, syncProperties as c } from "../../utils.mjs";
-const B = /* @__PURE__ */ a({
+import { defineComponent as l, ref as p, onMounted as a, onUpdated as c, createBlock as f, openBlock as d, resolveDynamicComponent as i, unref as m, withCtx as u, renderSlot as _ } from "vue";
+import { usePrefix as C, syncProperties as y } from "../../utils.mjs";
+const B = /* @__PURE__ */ l({
   __name: "ScrollerWrapper",
   props: {
     alignScrollIndicator: { default: "center" },
     aria: {},
-    gradientColor: {},
-    gradientColorScheme: {},
-    scrollIndicatorPosition: {},
     scrollToPosition: {},
-    scrollbar: { type: Boolean, default: !1 },
-    theme: {}
+    scrollbar: { type: Boolean, default: !1 }
   },
-  setup(l) {
-    const s = g("p-scroller"), e = l, o = p(), n = i(S), r = () => c(o, { ...e, theme: e.theme || n.value });
-    return m(r), f(r), d(n, (t) => {
-      c(o, { theme: e.theme || t });
-    }), (t, k) => (h(), u(C(_(s)), {
+  setup(r) {
+    const n = C("p-scroller"), t = r, e = p(), o = () => y(e, t);
+    return a(o), c(o), (s, P) => (d(), f(i(m(n)), {
       ref_key: "pdsComponentRef",
-      ref: o
+      ref: e
     }, {
-      default: y(() => [
-        P(t.$slots, "default")
+      default: u(() => [
+        _(s.$slots, "default")
       ]),
       _: 3
     }, 512));

package/esm/lib/components/SegmentedControlWrapper.vue.d.ts

@@ -1,9 +1,5 @@
-import type { SegmentedControlBackgroundColor, BreakpointCustomizable, SegmentedControlColumns, Theme } from '../types';
+import type { BreakpointCustomizable, SegmentedControlColumns, SegmentedControlState } from '../types';
 type PSegmentedControlProps = {
-    /**
-     * @deprecated since v3.0.0, will be removed with next major release. Background color variations
-     */
-    backgroundColor?: SegmentedControlBackgroundColor;
     /**
      * Sets the amount of columns.
      */
@@ -12,6 +8,10 @@ type PSegmentedControlProps = {
      * A boolean value that, if present, renders the segmented-control as a compact version.
      */
     compact?: boolean;
+    /**
+     * Supplementary text providing more context or explanation for the segmented-control.
+     */
+    description?: string;
     /**
      * Disables the segmented-control.
      */
@@ -20,14 +20,30 @@ type PSegmentedControlProps = {
      * The id of a form element the segmented-control should be associated with.
      */
     form?: string;
+    /**
+     * Controls the visibility of the label.
+     */
+    hideLabel?: BreakpointCustomizable<boolean>;
+    /**
+     * Text content for a user-facing label.
+     */
+    label?: string;
+    /**
+     * Dynamic feedback text for validation or status.
+     */
+    message?: string;
     /**
      * The name of the segmented-control.
      */
     name?: string;
     /**
-     * Adapts the segmented-control color depending on the theme.
+     * A boolean value that specifies a selection must be made from the group before the form can be submitted.
+     */
+    required?: boolean;
+    /**
+     * Indicates the validation or overall status of the component.
      */
-    theme?: Theme;
+    state?: SegmentedControlState;
     /**
      * Sets the initial value of the segmented-control.
      */
@@ -42,8 +58,14 @@ declare const __VLS_base: import("vue").DefineComponent<PSegmentedControlProps,
 }, string, import("vue").PublicProps, Readonly<PSegmentedControlProps> & Readonly<{
     [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
 }>, {
+    label: string;
     compact: boolean;
+    description: string;
+    state: SegmentedControlState;
+    required: boolean;
     disabled: boolean;
+    hideLabel: BreakpointCustomizable<boolean>;
+    message: string;
     columns: BreakpointCustomizable<SegmentedControlColumns>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/esm/lib/components/SegmentedControlWrapper.vue.mjs

@@ -1,37 +1,39 @@
-import { defineComponent as d, ref as u, inject as f, onMounted as i, onUpdated as h, watch as C, createBlock as g, openBlock as v, resolveDynamicComponent as y, unref as _, withCtx as b, renderSlot as k } from "vue";
-import { usePrefix as B, themeInjectionKey as R, syncProperties as s, addEventListenerToElementRef as n } from "../../utils.mjs";
-const j = /* @__PURE__ */ d({
+import { defineComponent as p, ref as f, onMounted as u, onUpdated as c, createBlock as m, openBlock as i, resolveDynamicComponent as y, unref as b, withCtx as g, renderSlot as C } from "vue";
+import { usePrefix as _, syncProperties as v, addEventListenerToElementRef as a } from "../../utils.mjs";
+const x = /* @__PURE__ */ p({
   __name: "SegmentedControlWrapper",
   props: {
-    backgroundColor: {},
     columns: { default: "auto" },
     compact: { type: Boolean, default: !1 },
+    description: { default: "" },
     disabled: { type: Boolean, default: !1 },
     form: {},
+    hideLabel: { type: [Boolean, Object], default: !1 },
+    label: { default: "" },
+    message: { default: "" },
     name: {},
-    theme: {},
+    required: { type: Boolean, default: !1 },
+    state: { default: "none" },
     value: {}
   },
-  emits: ["update:value", "blur", "change", "segmentedControlChange", "update"],
-  setup(l, { emit: p }) {
-    const c = B("p-segmented-control"), a = l, e = u(), t = p, r = f(R), m = () => s(e, { ...a, theme: a.theme || r.value });
-    return i(() => {
-      m(), n(e, "blur", t), n(e, "change", t, (o) => {
+  emits: ["update:value", "blur", "change"],
+  setup(l, { emit: r }) {
+    const s = _("p-segmented-control"), d = l, e = f(), t = r, n = () => v(e, d);
+    return u(() => {
+      n(), a(e, "blur", t), a(e, "change", t, (o) => {
         t("update:value", o.target.value);
-      }), n(e, "segmentedControlChange", t), n(e, "update", t);
-    }), h(m), C(r, (o) => {
-      s(e, { theme: a.theme || o });
-    }), (o, w) => (v(), g(y(_(c)), {
+      });
+    }), c(n), (o, B) => (i(), m(y(b(s)), {
       ref_key: "pdsComponentRef",
       ref: e
     }, {
-      default: b(() => [
-        k(o.$slots, "default")
+      default: g(() => [
+        C(o.$slots, "default")
       ]),
       _: 3
     }, 512));
   }
 });
 export {
-  j as default
+  x as default
 };

package/esm/lib/components/SelectWrapper.vue.d.ts

@@ -1,4 +1,4 @@
-import type { SelectDropdownDirection, BreakpointCustomizable, SelectState, Theme } from '../types';
+import type { SelectDropdownDirection, BreakpointCustomizable, SelectState } from '../types';
 type PSelectProps = {
     /**
      * Displays as compact version.
@@ -17,7 +17,7 @@ type PSelectProps = {
      */
     dropdownDirection?: SelectDropdownDirection;
     /**
-     * Shows an input in the dropdown allowing options to be filtered.
+     * Shows an input in the dropdown allowing options to be filtered. Will be ignored if the `filter` slot is used.
      */
     filter?: boolean;
     /**
@@ -48,10 +48,6 @@ type PSelectProps = {
      * The validation state.
      */
     state?: SelectState;
-    /**
-     * Adapts the select color depending on the theme.
-     */
-    theme?: Theme;
     /**
      * The selected value.
      */

package/esm/lib/components/SelectWrapper.vue.mjs

@@ -1,6 +1,6 @@
-import { defineComponent as u, ref as c, inject as m, onMounted as i, onUpdated as h, watch as y, createBlock as b, openBlock as v, resolveDynamicComponent as B, unref as _, withCtx as C, renderSlot as g } from "vue";
-import { usePrefix as w, themeInjectionKey as R, syncProperties as s, addEventListenerToElementRef as n } from "../../utils.mjs";
-const P = /* @__PURE__ */ u({
+import { defineComponent as p, ref as d, onMounted as u, onUpdated as c, createBlock as i, openBlock as m, resolveDynamicComponent as g, unref as y, withCtx as b, renderSlot as B } from "vue";
+import { usePrefix as _, syncProperties as v, addEventListenerToElementRef as a } from "../../utils.mjs";
+const w = /* @__PURE__ */ p({
   __name: "SelectWrapper",
   props: {
     compact: { type: Boolean, default: !1 },
@@ -15,29 +15,26 @@ const P = /* @__PURE__ */ u({
     name: {},
     required: { type: Boolean, default: !1 },
     state: { default: "none" },
-    theme: {},
     value: {}
   },
-  emits: ["update:value", "blur", "change", "update"],
-  setup(p, { emit: d }) {
-    const f = w("p-select"), a = p, e = c(), o = d, l = m(R), r = () => s(e, { ...a, theme: a.theme || l.value });
-    return i(() => {
-      r(), n(e, "blur", o), n(e, "change", o, (t) => {
-        o("update:value", t.target.value);
-      }), n(e, "update", o);
-    }), h(r), y(l, (t) => {
-      s(e, { theme: a.theme || t });
-    }), (t, j) => (v(), b(B(_(f)), {
+  emits: ["update:value", "blur", "change", "toggle"],
+  setup(l, { emit: r }) {
+    const s = _("p-select"), f = l, e = d(), t = r, n = () => v(e, f);
+    return u(() => {
+      n(), a(e, "blur", t), a(e, "change", t, (o) => {
+        t("update:value", o.target.value);
+      }), a(e, "toggle", t);
+    }), c(n), (o, C) => (m(), i(g(y(s)), {
       ref_key: "pdsComponentRef",
       ref: e
     }, {
-      default: C(() => [
-        g(t.$slots, "default")
+      default: b(() => [
+        B(o.$slots, "default")
       ]),
       _: 3
     }, 512));
   }
 });
 export {
-  P as default
+  w as default
 };

package/esm/lib/components/SheetWrapper.vue.d.ts

@@ -1,9 +1,13 @@
-import type { SelectedAriaAttributes, SheetAriaAttribute, Theme } from '../types';
+import type { SelectedAriaAttributes, SheetAriaAttribute, SheetBackground } from '../types';
 type PSheetProps = {
     /**
      * Add ARIA attributes.
      */
     aria?: SelectedAriaAttributes<SheetAriaAttribute>;
+    /**
+     * Defines the background color
+     */
+    background?: SheetBackground;
     /**
      * If true, the sheet will not be closable via backdrop click.
      */
@@ -16,10 +20,6 @@ type PSheetProps = {
      * If true, the sheet is open.
      */
     open: boolean;
-    /**
-     * Adapts the sheet color depending on the theme.
-     */
-    theme?: Theme;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {
@@ -32,6 +32,7 @@ declare const __VLS_base: import("vue").DefineComponent<PSheetProps, {}, {}, {},
 }>, {
     open: boolean;
     dismissButton: boolean;
+    background: SheetBackground;
     disableBackdropClick: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/esm/lib/components/SheetWrapper.vue.mjs

@@ -1,32 +1,30 @@
-import { defineComponent as l, ref as c, inject as f, onMounted as u, onUpdated as h, watch as y, createBlock as B, openBlock as C, resolveDynamicComponent as _, unref as E, withCtx as k, renderSlot as b } from "vue";
-import { usePrefix as R, themeInjectionKey as v, syncProperties as r, addEventListenerToElementRef as s } from "../../utils.mjs";
-const j = /* @__PURE__ */ l({
+import { defineComponent as p, ref as m, onMounted as l, onUpdated as f, createBlock as c, openBlock as u, resolveDynamicComponent as y, unref as B, withCtx as C, renderSlot as _ } from "vue";
+import { usePrefix as k, syncProperties as E, addEventListenerToElementRef as n } from "../../utils.mjs";
+const x = /* @__PURE__ */ p({
   __name: "SheetWrapper",
   props: {
     aria: {},
+    background: { default: "canvas" },
     disableBackdropClick: { type: Boolean, default: !1 },
     dismissButton: { type: Boolean, default: !0 },
-    open: { type: Boolean, default: !1 },
-    theme: {}
+    open: { type: Boolean, default: !1 }
   },
   emits: ["dismiss", "motionHiddenEnd", "motionVisibleEnd"],
-  setup(d, { emit: a }) {
-    const p = R("p-sheet"), t = d, e = c(), o = a, i = f(v), m = () => r(e, { ...t, theme: t.theme || i.value });
-    return u(() => {
-      m(), s(e, "dismiss", o), s(e, "motionHiddenEnd", o), s(e, "motionVisibleEnd", o);
-    }), h(m), y(i, (n) => {
-      r(e, { theme: t.theme || n });
-    }), (n, w) => (C(), B(_(E(p)), {
+  setup(s, { emit: i }) {
+    const d = k("p-sheet"), r = s, e = m(), o = i, t = () => E(e, r);
+    return l(() => {
+      t(), n(e, "dismiss", o), n(e, "motionHiddenEnd", o), n(e, "motionVisibleEnd", o);
+    }), f(t), (a, b) => (u(), c(y(B(d)), {
       ref_key: "pdsComponentRef",
       ref: e
     }, {
-      default: k(() => [
-        b(n.$slots, "default")
+      default: C(() => [
+        _(a.$slots, "default")
       ]),
       _: 3
     }, 512));
   }
 });
 export {
-  j as default
+  x as default
 };

package/esm/lib/components/SpinnerWrapper.vue.d.ts

@@ -1,4 +1,4 @@
-import type { SelectedAriaAttributes, SpinnerAriaAttribute, BreakpointCustomizable, SpinnerSize, Theme } from '../types';
+import type { SelectedAriaAttributes, SpinnerAriaAttribute, BreakpointCustomizable, SpinnerSize } from '../types';
 type PSpinnerProps = {
     /**
      * Add ARIA attributes.
@@ -8,10 +8,6 @@ type PSpinnerProps = {
      * Size of the spinner.
      */
     size?: BreakpointCustomizable<SpinnerSize>;
-    /**
-     * Adapts the spinner color depending on the theme.
-     */
-    theme?: Theme;
 };
 declare const __VLS_export: import("vue").DefineComponent<PSpinnerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PSpinnerProps> & Readonly<{}>, {
     size: BreakpointCustomizable<SpinnerSize>;

package/esm/lib/components/SpinnerWrapper.vue.mjs

@@ -1,22 +1,19 @@
-import { defineComponent as c, ref as a, inject as f, onMounted as i, onUpdated as l, watch as u, createBlock as h, openBlock as d, resolveDynamicComponent as _, unref as y } from "vue";
-import { usePrefix as C, themeInjectionKey as k, syncProperties as p } from "../../utils.mjs";
-const j = /* @__PURE__ */ c({
+import { defineComponent as t, ref as s, onMounted as c, onUpdated as a, createBlock as f, openBlock as m, resolveDynamicComponent as i, unref as l } from "vue";
+import { usePrefix as u, syncProperties as d } from "../../utils.mjs";
+const x = /* @__PURE__ */ t({
   __name: "SpinnerWrapper",
   props: {
     aria: {},
-    size: { default: "small" },
-    theme: {}
+    size: { default: "small" }
   },
-  setup(s) {
-    const m = C("p-spinner"), e = s, n = a(), t = f(k), o = () => p(n, { ...e, theme: e.theme || t.value });
-    return i(o), l(o), u(t, (r) => {
-      p(n, { theme: e.theme || r });
-    }), (r, x) => (d(), h(_(y(m)), {
+  setup(o) {
+    const r = u("p-spinner"), p = o, e = s(), n = () => d(e, p);
+    return c(n), a(n), (_, C) => (m(), f(i(l(r)), {
       ref_key: "pdsComponentRef",
-      ref: n
+      ref: e
     }, null, 512));
   }
 });
 export {
-  j as default
+  x as default
 };

package/esm/lib/components/StepperHorizontalWrapper.vue.d.ts

@@ -1,21 +1,15 @@
-import type { BreakpointCustomizable, StepperHorizontalSize, Theme } from '../types';
+import type { StepperHorizontalUpdateEventDetail, BreakpointCustomizable, StepperHorizontalSize } from '../types';
 type PStepperHorizontalProps = {
     size?: BreakpointCustomizable<StepperHorizontalSize>;
-    /**
-     * Adapts the tag color depending on the theme.
-     */
-    theme?: Theme;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<PStepperHorizontalProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    update: (value: import("../types").StepperHorizontalUpdateEvent) => any;
-    stepChange: (value: import("../types").StepperHorizontalUpdateEvent) => any;
+    update: (value: StepperHorizontalUpdateEventDetail) => any;
 }, string, import("vue").PublicProps, Readonly<PStepperHorizontalProps> & Readonly<{
-    onUpdate?: ((value: import("../types").StepperHorizontalUpdateEvent) => any) | undefined;
-    onStepChange?: ((value: import("../types").StepperHorizontalUpdateEvent) => any) | undefined;
+    onUpdate?: ((value: StepperHorizontalUpdateEventDetail) => any) | undefined;
 }>, {
     size: BreakpointCustomizable<StepperHorizontalSize>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;