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

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

@@ -1,16 +1,15 @@
-import { defineComponent as r, ref as d, onMounted as p, onUpdated as s, createBlock as f, openBlock as u, resolveDynamicComponent as i, unref as c, withCtx as m, renderSlot as b } from "vue";
-import { usePrefix as y, syncProperties as B } from "../../utils.mjs";
-const k = /* @__PURE__ */ r({
+import { defineComponent as p, ref as s, onMounted as r, onUpdated as f, createBlock as d, openBlock as i, resolveDynamicComponent as u, unref as c, withCtx as m, renderSlot as y } from "vue";
+import { usePrefix as b, syncProperties as B } from "../../utils.mjs";
+const h = /* @__PURE__ */ p({
   __name: "ButtonTileWrapper",
   props: {
     align: { default: "bottom" },
     aria: {},
     aspectRatio: { default: "4/3" },
-    background: { default: "dark" },
     compact: { type: [Boolean, Object], default: !1 },
     description: {},
     disabled: { type: Boolean, default: !1 },
-    gradient: { type: Boolean, default: !0 },
+    gradient: { type: Boolean, default: !1 },
     icon: { default: "none" },
     iconSource: {},
     label: {},
@@ -20,18 +19,18 @@ const k = /* @__PURE__ */ r({
     weight: { default: "semi-bold" }
   },
   setup(o) {
-    const n = y("p-button-tile"), a = o, e = d(), t = () => B(e, a);
-    return p(t), s(t), (l, _) => (u(), f(i(c(n)), {
+    const n = b("p-button-tile"), a = o, e = s(), t = () => B(e, a);
+    return r(t), f(t), (l, _) => (i(), d(u(c(n)), {
       ref_key: "pdsComponentRef",
       ref: e
     }, {
       default: m(() => [
-        b(l.$slots, "default")
+        y(l.$slots, "default")
       ]),
       _: 3
     }, 512));
   }
 });
 export {
-  k as default
+  h as default
 };

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

@@ -1,4 +1,4 @@
-import type { SelectedAriaAttributes, ButtonAriaAttribute, BreakpointCustomizable, ButtonIcon, Theme, ButtonType, ButtonVariant } from '../types';
+import type { SelectedAriaAttributes, ButtonAriaAttribute, BreakpointCustomizable, ButtonIcon, ButtonType, ButtonVariant } from '../types';
 type PButtonProps = {
     /**
      * Add ARIA attributes.
@@ -36,10 +36,6 @@ type PButtonProps = {
      * The name of the button, submitted as a pair with the button's value as part of the form data, when that button is used to submit the form.
      */
     name?: string;
-    /**
-     * Adapts the button color depending on the theme.
-     */
-    theme?: Theme;
     /**
      * Specifies the type of the button.
      */

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

@@ -1,6 +1,6 @@
-import { defineComponent as f, ref as s, inject as c, onMounted as m, onUpdated as u, watch as d, createBlock as i, openBlock as h, resolveDynamicComponent as y, unref as b, withCtx as B, renderSlot as _ } from "vue";
-import { usePrefix as C, themeInjectionKey as j, syncProperties as r } from "../../utils.mjs";
-const x = /* @__PURE__ */ f({
+import { defineComponent as p, ref as l, onMounted as f, onUpdated as s, createBlock as c, openBlock as d, resolveDynamicComponent as u, unref as i, withCtx as m, renderSlot as y } from "vue";
+import { usePrefix as b, syncProperties as B } from "../../utils.mjs";
+const k = /* @__PURE__ */ p({
   __name: "ButtonWrapper",
   props: {
     aria: {},
@@ -12,26 +12,23 @@ const x = /* @__PURE__ */ f({
     iconSource: {},
     loading: { type: Boolean, default: !1 },
     name: {},
-    theme: {},
     type: { default: "submit" },
     value: {},
     variant: { default: "primary" }
   },
-  setup(p) {
-    const l = C("p-button"), e = p, t = s(), n = c(j), a = () => r(t, { ...e, theme: e.theme || n.value });
-    return m(a), u(a), d(n, (o) => {
-      r(t, { theme: e.theme || o });
-    }), (o, v) => (h(), i(y(b(l)), {
+  setup(t) {
+    const n = b("p-button"), a = t, e = l(), o = () => B(e, a);
+    return f(o), s(o), (r, _) => (d(), c(u(i(n)), {
       ref_key: "pdsComponentRef",
-      ref: t
+      ref: e
     }, {
-      default: B(() => [
-        _(o.$slots, "default")
+      default: m(() => [
+        y(r.$slots, "default")
       ]),
       _: 3
     }, 512));
   }
 });
 export {
-  x as default
+  k as default
 };

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

@@ -1,14 +1,9 @@
-import type { Theme } from '../types';
 type PCanvasProps = {
     sidebarEndOpen?: boolean;
     /**
      * Open the sidebar on the start side
      */
     sidebarStartOpen?: boolean;
-    /**
-     * Adapts the color depending on the theme.
-     */
-    theme?: Theme;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {

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

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

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

@@ -1,4 +1,4 @@
-import type { CarouselAlignControls, CarouselAlignHeader, SelectedAriaAttributes, CarouselAriaAttribute, BreakpointCustomizable, CarouselGradientColor, CarouselHeadingSize, CarouselInternationalization, CarouselSlidesPerPage, Theme, CarouselWidth } from '../types';
+import type { CarouselAlignControls, CarouselAlignHeader, SelectedAriaAttributes, CarouselAriaAttribute, CarouselHeadingSize, CarouselInternationalization, CarouselUpdateEventDetail, BreakpointCustomizable, CarouselSlidesPerPage, CarouselWidth } from '../types';
 type PCarouselProps = {
     /**
      * Defines which slide to be active (zero-based numbering).
@@ -20,18 +20,14 @@ type PCarouselProps = {
      * Defines the description used in the carousel.
      */
     description?: string;
-    /**
-     * @deprecated since v3.0.0, will be removed with next major release, use `pagination` instead. If true, the carousel will not show pagination bullets at the bottom.
-     */
-    disablePagination?: BreakpointCustomizable<boolean>;
     /**
      * Indicates whether focus should be set on the center slide. If true, the carousel loops by individual slide; otherwise, it loops by page.
      */
     focusOnCenterSlide?: boolean;
     /**
-     * Adapts the background gradient for the left and right edge.
+     * Fades the slides out.
      */
-    gradientColor?: CarouselGradientColor;
+    gradient?: boolean;
     /**
      * Defines the heading used in the carousel.
      */
@@ -60,10 +56,6 @@ type PCarouselProps = {
      * Sets the amount of slides visible at the same time. Can be set to `auto` if you want to define different widths per slide via CSS.
      */
     slidesPerPage?: BreakpointCustomizable<CarouselSlidesPerPage>;
-    /**
-     * Adapts the color when used on dark background.
-     */
-    theme?: Theme;
     /**
      * Determines whether to trim spaces before/after the carousel if `focusOnCenterSlide` option is true.
      */
@@ -72,34 +64,27 @@ type PCarouselProps = {
      * Defines the outer spacings between the carousel and the left and right screen sides.
      */
     width?: CarouselWidth;
-    /**
-     * Has no effect anymore
-     * @deprecated since v3.0.0, will be removed with next major release
-     */
-    wrapContent?: boolean;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<PCarouselProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    update: (value: import("../types").CarouselUpdateEvent) => any;
-    carouselChange: (value: import("../types").CarouselUpdateEvent) => any;
+    update: (value: CarouselUpdateEventDetail) => any;
 }, string, import("vue").PublicProps, Readonly<PCarouselProps> & Readonly<{
-    onUpdate?: ((value: import("../types").CarouselUpdateEvent) => any) | undefined;
-    onCarouselChange?: ((value: import("../types").CarouselUpdateEvent) => any) | undefined;
+    onUpdate?: ((value: CarouselUpdateEventDetail) => any) | undefined;
 }>, {
-    width: CarouselWidth;
+    gradient: boolean;
     activeSlideIndex: number;
     alignControls: CarouselAlignControls;
     alignHeader: CarouselAlignHeader;
     focusOnCenterSlide: boolean;
-    gradientColor: CarouselGradientColor;
     headingSize: CarouselHeadingSize;
     pagination: BreakpointCustomizable<boolean>;
     rewind: boolean;
     slidesPerPage: BreakpointCustomizable<CarouselSlidesPerPage>;
     trimSpace: boolean;
+    width: CarouselWidth;
 }, {}, {}, {}, 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/CarouselWrapper.vue.mjs

@@ -1,6 +1,6 @@
-import { defineComponent as u, ref as c, inject as f, onMounted as m, onUpdated as h, watch as g, createBlock as C, openBlock as y, resolveDynamicComponent as B, unref as _, withCtx as w, renderSlot as P } from "vue";
-import { usePrefix as b, themeInjectionKey as k, syncProperties as l, addEventListenerToElementRef as i } from "../../utils.mjs";
-const v = /* @__PURE__ */ u({
+import { defineComponent as d, ref as i, onMounted as p, onUpdated as f, createBlock as u, openBlock as c, resolveDynamicComponent as m, unref as g, withCtx as y, renderSlot as C } from "vue";
+import { usePrefix as B, syncProperties as _, addEventListenerToElementRef as h } from "../../utils.mjs";
+const S = /* @__PURE__ */ d({
   __name: "CarouselWrapper",
   props: {
     activeSlideIndex: { default: 0 },
@@ -8,39 +8,34 @@ const v = /* @__PURE__ */ u({
     alignHeader: { default: "start" },
     aria: {},
     description: {},
-    disablePagination: { type: [Boolean, Object] },
     focusOnCenterSlide: { type: Boolean, default: !1 },
-    gradientColor: { default: "none" },
+    gradient: { type: Boolean, default: !1 },
     heading: {},
     headingSize: { default: "x-large" },
     intl: {},
-    pagination: { type: [Boolean, Object], default: !0 },
-    rewind: { type: Boolean, default: !0 },
+    pagination: { type: [Boolean, Object], default: !1 },
+    rewind: { type: Boolean, default: !1 },
     skipLinkTarget: {},
     slidesPerPage: { default: 1 },
-    theme: {},
-    trimSpace: { type: Boolean, default: !0 },
-    width: { default: "basic" },
-    wrapContent: { type: Boolean }
+    trimSpace: { type: Boolean, default: !1 },
+    width: { default: "basic" }
   },
-  emits: ["carouselChange", "update"],
-  setup(s, { emit: d }) {
-    const p = b("p-carousel"), t = s, e = c(), o = d, a = f(k), r = () => l(e, { ...t, theme: t.theme || a.value });
-    return m(() => {
-      r(), i(e, "carouselChange", o), i(e, "update", o);
-    }), h(r), g(a, (n) => {
-      l(e, { theme: t.theme || n });
-    }), (n, x) => (y(), C(B(_(p)), {
+  emits: ["update"],
+  setup(a, { emit: n }) {
+    const o = B("p-carousel"), l = a, e = i(), r = n, t = () => _(e, l);
+    return p(() => {
+      t(), h(e, "update", r);
+    }), f(t), (s, k) => (c(), u(m(g(o)), {
       ref_key: "pdsComponentRef",
       ref: e
     }, {
-      default: w(() => [
-        P(n.$slots, "default")
+      default: y(() => [
+        C(s.$slots, "default")
       ]),
       _: 3
     }, 512));
   }
 });
 export {
-  v as default
+  S as default
 };

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

@@ -1,4 +1,4 @@
-import type { BreakpointCustomizable, CheckboxUpdateEventDetail, CheckboxState, Theme } from '../types';
+import type { BreakpointCustomizable, CheckboxState } from '../types';
 type PCheckboxProps = {
     /**
      * Reflects the checkbox current checked state and allows setting the initial checked state.
@@ -48,10 +48,6 @@ type PCheckboxProps = {
      * The validation state.
      */
     state?: CheckboxState;
-    /**
-     * Adapts the color depending on the theme.
-     */
-    theme?: Theme;
     /**
      * The checkbox value. When a form is submitted, only a checkbox which is currently checked is included in the submission.
      */
@@ -64,12 +60,10 @@ type __VLS_Slots = {} & {
 declare const __VLS_base: import("vue").DefineComponent<PCheckboxProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     blur: (value: Event) => any;
     change: (value: Event) => any;
-    update: (value: CheckboxUpdateEventDetail) => any;
     "update:checked": (value: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<PCheckboxProps> & Readonly<{
     onBlur?: ((value: Event) => any) | undefined;
     onChange?: ((value: Event) => any) | undefined;
-    onUpdate?: ((value: CheckboxUpdateEventDetail) => any) | undefined;
     "onUpdate:checked"?: ((value: boolean) => any) | undefined;
 }>, {
     label: string;

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

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

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

@@ -1,4 +1,4 @@
-import type { DisplayAlign, DisplayColor, BreakpointCustomizable, DisplaySize, DisplayTag, Theme } from '../types';
+import type { DisplayAlign, DisplayColor, BreakpointCustomizable, DisplaySize, DisplayTag } from '../types';
 type PDisplayProps = {
     /**
      * Text alignment of the component.
@@ -20,10 +20,6 @@ type PDisplayProps = {
      * Sets a heading tag, so it fits correctly within the outline of the page.
      */
     tag?: DisplayTag;
-    /**
-     * Adapts the text color depending on the theme. Has no effect when "inherit" is set as color prop.
-     */
-    theme?: Theme;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {

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

@@ -1,30 +1,27 @@
-import { defineComponent as l, ref as f, inject as m, onMounted as c, onUpdated as i, watch as d, createBlock as u, openBlock as h, resolveDynamicComponent as y, unref as _, withCtx as C, renderSlot as g } from "vue";
-import { usePrefix as k, themeInjectionKey as w, syncProperties as s } from "../../utils.mjs";
-const R = /* @__PURE__ */ l({
+import { defineComponent as s, ref as a, onMounted as l, onUpdated as f, createBlock as c, openBlock as d, resolveDynamicComponent as i, unref as m, withCtx as u, renderSlot as y } from "vue";
+import { usePrefix as _, syncProperties as C } from "../../utils.mjs";
+const B = /* @__PURE__ */ s({
   __name: "DisplayWrapper",
   props: {
     align: { default: "start" },
     color: { default: "primary" },
     ellipsis: { type: Boolean, default: !1 },
     size: { default: "large" },
-    tag: {},
-    theme: {}
+    tag: {}
   },
-  setup(a) {
-    const p = k("p-display"), e = a, t = f(), n = m(w), r = () => s(t, { ...e, theme: e.theme || n.value });
-    return c(r), i(r), d(n, (o) => {
-      s(t, { theme: e.theme || o });
-    }), (o, x) => (h(), u(y(_(p)), {
+  setup(t) {
+    const n = _("p-display"), r = t, e = a(), o = () => C(e, r);
+    return l(o), f(o), (p, g) => (d(), c(i(m(n)), {
       ref_key: "pdsComponentRef",
-      ref: t
+      ref: e
     }, {
-      default: C(() => [
-        g(o.$slots, "default")
+      default: u(() => [
+        y(p.$slots, "default")
       ]),
       _: 3
     }, 512));
   }
 });
 export {
-  R as default
+  B as default
 };

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

@@ -1,4 +1,4 @@
-import type { DividerColor, BreakpointCustomizable, DividerDirection, DividerOrientation, Theme } from '../types';
+import type { DividerColor, BreakpointCustomizable, DividerDirection } from '../types';
 type PDividerProps = {
     /**
      * Defines color depending on theme.
@@ -8,18 +8,10 @@ type PDividerProps = {
      * Defines direction.
      */
     direction?: BreakpointCustomizable<DividerDirection>;
-    /**
-     * @deprecated since v3.0.0, will be removed with next major release, use `direction` instead. Defines orientation.
-     */
-    orientation?: BreakpointCustomizable<DividerOrientation>;
-    /**
-     * Adapts color depending on theme.
-     */
-    theme?: Theme;
 };
 declare const __VLS_export: import("vue").DefineComponent<PDividerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PDividerProps> & Readonly<{}>, {
-    direction: BreakpointCustomizable<DividerDirection>;
     color: DividerColor;
+    direction: BreakpointCustomizable<DividerDirection>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1,23 +1,19 @@
-import { defineComponent as m, ref as i, inject as a, onMounted as f, onUpdated as d, watch as l, createBlock as u, openBlock as h, resolveDynamicComponent as _, unref as y } from "vue";
-import { usePrefix as C, themeInjectionKey as v, syncProperties as c } from "../../utils.mjs";
-const P = /* @__PURE__ */ m({
+import { defineComponent as p, ref as s, onMounted as c, onUpdated as a, createBlock as f, openBlock as i, resolveDynamicComponent as d, unref as m } from "vue";
+import { usePrefix as l, syncProperties as u } from "../../utils.mjs";
+const v = /* @__PURE__ */ p({
   __name: "DividerWrapper",
   props: {
-    color: { default: "contrast-low" },
-    direction: { default: "horizontal" },
-    orientation: {},
-    theme: {}
+    color: { default: "contrast-lower" },
+    direction: { default: "horizontal" }
   },
-  setup(p) {
-    const s = C("p-divider"), e = p, o = i(), t = a(v), n = () => c(o, { ...e, theme: e.theme || t.value });
-    return f(n), d(n), l(t, (r) => {
-      c(o, { theme: e.theme || r });
-    }), (r, k) => (h(), u(_(y(s)), {
+  setup(n) {
+    const r = l("p-divider"), t = n, e = s(), o = () => u(e, t);
+    return c(o), a(o), (_, C) => (i(), f(d(m(r)), {
       ref_key: "pdsComponentRef",
-      ref: o
+      ref: e
     }, null, 512));
   }
 });
 export {
-  P as default
+  v as default
 };

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

@@ -1,4 +1,4 @@
-import type { SelectedAriaAttributes, DrilldownAriaAttribute, Theme } from '../types';
+import type { SelectedAriaAttributes, DrilldownAriaAttribute } from '../types';
 type PDrilldownProps = {
     /**
      * Defines which drilldown-item to be visualized as opened.
@@ -12,10 +12,6 @@ type PDrilldownProps = {
      * If true, the drilldown is visualized as opened.
      */
     open?: boolean;
-    /**
-     * Adapts the drilldown color depending on the theme.
-     */
-    theme?: Theme;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {

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

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

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

@@ -1,4 +1,4 @@
-import type { SelectedAriaRole, FieldsetLabelSize, FieldsetState, Theme } from '../types';
+import type { SelectedAriaRole, FieldsetLabelSize, FieldsetState } from '../types';
 type PFieldsetProps = {
     /**
      * Add ARIA attributes.
@@ -24,10 +24,6 @@ type PFieldsetProps = {
      * The validation state.
      */
     state?: FieldsetState;
-    /**
-     * Adapts color depending on theme.
-     */
-    theme?: Theme;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {

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

@@ -1,6 +1,6 @@
-import { defineComponent as f, ref as l, inject as m, onMounted as d, onUpdated as c, watch as u, createBlock as i, openBlock as h, resolveDynamicComponent as _, unref as y, withCtx as C, renderSlot as b } from "vue";
-import { usePrefix as k, themeInjectionKey as w, syncProperties as a } from "../../utils.mjs";
-const R = /* @__PURE__ */ f({
+import { defineComponent as a, ref as p, onMounted as f, onUpdated as l, createBlock as d, openBlock as u, resolveDynamicComponent as m, unref as c, withCtx as i, renderSlot as _ } from "vue";
+import { usePrefix as C, syncProperties as y } from "../../utils.mjs";
+const B = /* @__PURE__ */ a({
   __name: "FieldsetWrapper",
   props: {
     aria: {},
@@ -8,24 +8,21 @@ const R = /* @__PURE__ */ f({
     labelSize: { default: "medium" },
     message: { default: "" },
     required: { type: Boolean, default: !1 },
-    state: { default: "none" },
-    theme: {}
+    state: { default: "none" }
   },
-  setup(s) {
-    const p = k("p-fieldset"), e = s, t = l(), n = m(w), r = () => a(t, { ...e, theme: e.theme || n.value });
-    return d(r), c(r), u(n, (o) => {
-      a(t, { theme: e.theme || o });
-    }), (o, x) => (h(), i(_(y(p)), {
+  setup(o) {
+    const n = C("p-fieldset"), r = o, e = p(), t = () => y(e, r);
+    return f(t), l(t), (s, b) => (u(), d(m(c(n)), {
       ref_key: "pdsComponentRef",
-      ref: t
+      ref: e
     }, {
-      default: C(() => [
-        b(o.$slots, "default")
+      default: i(() => [
+        _(s.$slots, "default")
       ]),
       _: 3
     }, 512));
   }
 });
 export {
-  R as default
+  B as default
 };