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

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

@@ -1,4 +1,4 @@
-import type { SelectedAriaAttributes, FlyoutAriaAttribute, FlyoutBackdrop, FlyoutFooterBehavior, FlyoutPosition, Theme } from '../types';
+import type { SelectedAriaAttributes, FlyoutAriaAttribute, FlyoutBackdrop, FlyoutBackground, FlyoutFooterBehavior, FlyoutPosition } from '../types';
 type PFlyoutProps = {
     /**
      * Add ARIA attributes.
@@ -8,6 +8,10 @@ type PFlyoutProps = {
      * Defines the backdrop, 'blur' (should be used when the underlying content is not relevant for users) and 'shading' (should be used when the user still needs a visual connection to the underlying content).
      */
     backdrop?: FlyoutBackdrop;
+    /**
+     * Defines the background color
+     */
+    background?: FlyoutBackground;
     /**
      * If true, the flyout will not be closable via backdrop click.
      */
@@ -24,10 +28,6 @@ type PFlyoutProps = {
      * The position of the flyout
      */
     position?: FlyoutPosition;
-    /**
-     * Adapts the flyout color depending on the theme.
-     */
-    theme?: Theme;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {
@@ -40,6 +40,7 @@ declare const __VLS_base: import("vue").DefineComponent<PFlyoutProps, {}, {}, {}
 }>, {
     open: boolean;
     backdrop: FlyoutBackdrop;
+    background: FlyoutBackground;
     disableBackdropClick: boolean;
     footerBehavior: FlyoutFooterBehavior;
     position: FlyoutPosition;

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

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

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

@@ -1,4 +1,4 @@
-import type { HeadingAlign, HeadingColor, BreakpointCustomizable, HeadingSize, HeadingTag, Theme } from '../types';
+import type { HeadingAlign, HeadingColor, BreakpointCustomizable, HeadingSize, HeadingTag } from '../types';
 type PHeadingProps = {
     /**
      * Text alignment of the component.
@@ -20,10 +20,6 @@ type PHeadingProps = {
      * Sets a heading tag, so it fits correctly within the outline of the page.
      */
     tag?: HeadingTag;
-    /**
-     * 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/HeadingWrapper.vue.mjs

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

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

@@ -1,4 +1,4 @@
-import type { SelectedAriaAttributes, IconAriaAttribute, IconColor, IconName, IconSize, Theme } from '../types';
+import type { SelectedAriaAttributes, IconAriaAttribute, IconColor, IconName, IconSize } from '../types';
 type PIconProps = {
     /**
      * Add ARIA attributes.
@@ -8,11 +8,6 @@ type PIconProps = {
      * Basic color variations depending on theme property.
      */
     color?: IconColor;
-    /**
-     * Has no effect anymore (the component is now using the native `loading="lazy"` attribute by default)
-     * @deprecated since v3.0.0, will be removed with next major release
-     */
-    lazy?: boolean;
     /**
      * Specifies which icon to use.
      */
@@ -25,10 +20,6 @@ type PIconProps = {
      * Specifies a whole icon path which can be used for custom icons.
      */
     source?: string;
-    /**
-     * Adapts the color depending on the theme. Has no effect when "inherit" is set as color prop.
-     */
-    theme?: Theme;
 };
 declare const __VLS_export: import("vue").DefineComponent<PIconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PIconProps> & Readonly<{}>, {
     size: IconSize;

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

@@ -1,26 +1,22 @@
-import { defineComponent as m, ref as s, inject as f, onMounted as l, onUpdated as i, watch as u, createBlock as d, openBlock as h, resolveDynamicComponent as y, unref as _ } from "vue";
-import { usePrefix as C, themeInjectionKey as k, syncProperties as p } from "../../utils.mjs";
-const P = /* @__PURE__ */ m({
+import { defineComponent as p, ref as s, onMounted as a, onUpdated as c, 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__ */ p({
   __name: "IconWrapper",
   props: {
     aria: {},
     color: { default: "primary" },
-    lazy: { type: Boolean },
     name: { default: "arrow-right" },
     size: { default: "small" },
-    source: {},
-    theme: {}
+    source: {}
   },
-  setup(a) {
-    const c = C("p-icon"), e = a, o = s(), t = f(k), n = () => p(o, { ...e, theme: e.theme || t.value });
-    return l(n), i(n), u(t, (r) => {
-      p(o, { theme: e.theme || r });
-    }), (r, w) => (h(), d(y(_(c)), {
+  setup(n) {
+    const r = u("p-icon"), t = n, e = s(), o = () => d(e, t);
+    return a(o), c(o), (_, y) => (m(), f(i(l(r)), {
       ref_key: "pdsComponentRef",
-      ref: o
+      ref: e
     }, null, 512));
   }
 });
 export {
-  P as default
+  x as default
 };

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

@@ -1,4 +1,4 @@
-import type { InlineNotificationActionIcon, InlineNotificationHeadingTag, InlineNotificationState, Theme } from '../types';
+import type { InlineNotificationActionIcon, InlineNotificationHeadingTag, InlineNotificationState } from '../types';
 type PInlineNotificationProps = {
     /**
      * Action icon of the inline-notification.
@@ -28,18 +28,10 @@ type PInlineNotificationProps = {
      * Sets a heading tag, so it fits correctly within the outline of the page.
      */
     headingTag?: InlineNotificationHeadingTag;
-    /**
-     * @deprecated since v3.0.0, will be removed with next major release, use `dismissButton` instead. Defines if the inline-notification can be closed/removed by the user.
-     */
-    persistent?: boolean;
     /**
      * State of the inline-notification.
      */
     state?: InlineNotificationState;
-    /**
-     * Adapts the inline-notification color depending on the theme.
-     */
-    theme?: Theme;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {

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

@@ -1,6 +1,6 @@
-import { defineComponent as d, ref as m, inject as l, onMounted as u, onUpdated as h, watch as y, createBlock as _, openBlock as g, resolveDynamicComponent as B, unref as C, withCtx as w, renderSlot as R } from "vue";
-import { usePrefix as k, themeInjectionKey as v, syncProperties as s, addEventListenerToElementRef as r } from "../../utils.mjs";
-const P = /* @__PURE__ */ d({
+import { defineComponent as f, ref as p, onMounted as c, onUpdated as l, createBlock as m, openBlock as u, resolveDynamicComponent as _, unref as g, withCtx as h, renderSlot as y } from "vue";
+import { usePrefix as C, syncProperties as B, addEventListenerToElementRef as o } from "../../utils.mjs";
+const L = /* @__PURE__ */ f({
   __name: "InlineNotificationWrapper",
   props: {
     actionIcon: { default: "arrow-right" },
@@ -10,28 +10,24 @@ const P = /* @__PURE__ */ d({
     dismissButton: { type: Boolean, default: !0 },
     heading: { default: "" },
     headingTag: { default: "h5" },
-    persistent: { type: Boolean },
-    state: { default: "info" },
-    theme: {}
+    state: { default: "info" }
   },
   emits: ["action", "dismiss"],
-  setup(c, { emit: f }) {
-    const p = k("p-inline-notification"), t = c, e = m(), o = f, i = l(v), a = () => s(e, { ...t, theme: t.theme || i.value });
-    return u(() => {
-      a(), r(e, "action", o), r(e, "dismiss", o);
-    }), h(a), y(i, (n) => {
-      s(e, { theme: t.theme || n });
-    }), (n, x) => (g(), _(B(C(p)), {
+  setup(i, { emit: a }) {
+    const s = C("p-inline-notification"), r = i, e = p(), t = a, n = () => B(e, r);
+    return c(() => {
+      n(), o(e, "action", t), o(e, "dismiss", t);
+    }), l(n), (d, k) => (u(), m(_(g(s)), {
       ref_key: "pdsComponentRef",
       ref: e
     }, {
-      default: w(() => [
-        R(n.$slots, "default")
+      default: h(() => [
+        y(d.$slots, "default")
       ]),
       _: 3
     }, 512));
   }
 });
 export {
-  P as default
+  L as default
 };

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

@@ -1,4 +1,4 @@
-import type { BreakpointCustomizable, InputDateState, Theme } from '../types';
+import type { BreakpointCustomizable, InputDateState } from '../types';
 type PInputDateProps = {
     /**
      * Provides a hint to the browser about what type of data the field expects, which can assist with autofill features (e.g., auto-complete='bday' for a birthday).
@@ -64,10 +64,6 @@ type PInputDateProps = {
      * Defines the granularity of the date input. This value is given in days. The default is 1 (one day).
      */
     step?: number;
-    /**
-     * Controls the visual appearance of the component.
-     */
-    theme?: Theme;
     /**
      * The default date value for the input, in YYYY-MM-DD format (e.g., value='2025-07-02').
      */

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

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

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

@@ -1,4 +1,4 @@
-import type { BreakpointCustomizable, InputEmailState, Theme } from '../types';
+import type { BreakpointCustomizable, InputEmailState } from '../types';
 type PInputEmailProps = {
     /**
      * Provides a hint to the browser about what type of data the field expects, which can assist with autofill features (e.g., autocomplete='email').
@@ -76,10 +76,6 @@ type PInputEmailProps = {
      * Indicates the validation or overall status of the input component.
      */
     state?: InputEmailState;
-    /**
-     * Controls the visual appearance of the component.
-     */
-    theme?: Theme;
     /**
      * The default email address (or comma-separated list of addresses) for the input.
      */

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

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

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

@@ -0,0 +1,107 @@
+import type { BreakpointCustomizable, InputMonthState } from '../types';
+type PInputMonthProps = {
+    /**
+     * Provides a hint to the browser about what type of data the field expects, which can assist with autofill features.
+     */
+    autoComplete?: string;
+    /**
+     * A boolean value that, if present, renders the input field as a compact version.
+     */
+    compact?: boolean;
+    /**
+     * Supplementary text providing more context or explanation for the input.
+     */
+    description?: string;
+    /**
+     * A boolean value that, if present, makes the input field unusable and unclickable. The value will not be submitted with the form.
+     */
+    disabled?: boolean;
+    /**
+     * Specifies the id of the <form> element that the input belongs to (useful if the input is not a direct descendant of the form).
+     */
+    form?: string;
+    /**
+     * Controls the visibility of the label.
+     */
+    hideLabel?: BreakpointCustomizable<boolean>;
+    /**
+     * Text content for a user-facing label.
+     */
+    label?: string;
+    /**
+     * @experimental Shows a loading indicator.
+     */
+    loading?: boolean;
+    /**
+     * Specifies the latest month that can be selected. The value must be a month string in YYYY-MM format(e.g., max='2024-12').
+     */
+    max?: string;
+    /**
+     * Dynamic feedback text for validation or status.
+     */
+    message?: string;
+    /**
+     * Specifies the earliest month that can be selected. The value must be a month string in YYYY-MM format (e.g., min='2023-01').
+     */
+    min?: string;
+    /**
+     * The name of the input field, used when submitting the form data.
+     */
+    name: string;
+    /**
+     * A boolean value that, if present, makes the input field uneditable by the user, but its value will still be submitted with the form.
+     */
+    readOnly?: boolean;
+    /**
+     * A boolean value that, if present, indicates that the input field must be filled out before the form can be submitted.
+     */
+    required?: boolean;
+    /**
+     * Indicates the validation or overall status of the input component.
+     */
+    state?: InputMonthState;
+    /**
+     * Defines the stepping interval in months. For example, step="1" increments by 1 month, step="12" by 1 year. The default is 1 month.
+     */
+    step?: number;
+    /**
+     * The default month value for the input, in YYYY-MM format (e.g., value='2025-07').
+     */
+    value?: string;
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<PInputMonthProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    blur: (value: Event) => any;
+    change: (value: Event) => any;
+    input: (value: InputEvent) => any;
+    "update:value": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<PInputMonthProps> & Readonly<{
+    onBlur?: ((value: Event) => any) | undefined;
+    onChange?: ((value: Event) => any) | undefined;
+    onInput?: ((value: InputEvent) => any) | undefined;
+    "onUpdate:value"?: ((value: string) => any) | undefined;
+}>, {
+    step: number;
+    label: string;
+    compact: boolean;
+    description: string;
+    state: InputMonthState;
+    required: boolean;
+    disabled: boolean;
+    hideLabel: BreakpointCustomizable<boolean>;
+    loading: boolean;
+    value: string;
+    message: string;
+    readOnly: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,44 @@
+import { defineComponent as f, ref as r, onMounted as d, onUpdated as m, createBlock as i, openBlock as c, resolveDynamicComponent as y, unref as B, withCtx as b, renderSlot as h } from "vue";
+import { usePrefix as C, syncProperties as _, addEventListenerToElementRef as o } from "../../utils.mjs";
+const k = /* @__PURE__ */ f({
+  __name: "InputMonthWrapper",
+  props: {
+    autoComplete: {},
+    compact: { type: Boolean, default: !1 },
+    description: { default: "" },
+    disabled: { type: Boolean, default: !1 },
+    form: {},
+    hideLabel: { type: [Boolean, Object], default: !1 },
+    label: { default: "" },
+    loading: { type: Boolean, default: !1 },
+    max: {},
+    message: { default: "" },
+    min: {},
+    name: {},
+    readOnly: { type: Boolean, default: !1 },
+    required: { type: Boolean, default: !1 },
+    state: { default: "none" },
+    step: { default: 1 },
+    value: { default: "" }
+  },
+  emits: ["update:value", "blur", "change", "input"],
+  setup(l, { emit: p }) {
+    const s = C("p-input-month"), u = l, e = r(), t = p, n = () => _(e, u);
+    return d(() => {
+      n(), o(e, "blur", t), o(e, "change", t), o(e, "input", t, (a) => {
+        t("update:value", a.target.value);
+      });
+    }), m(n), (a, g) => (c(), i(y(B(s)), {
+      ref_key: "pdsComponentRef",
+      ref: e
+    }, {
+      default: b(() => [
+        h(a.$slots, "default")
+      ]),
+      _: 3
+    }, 512));
+  }
+});
+export {
+  k as default
+};

package/esm/lib/components/InputMonthWrapper.vue2.mjs

@@ -0,0 +1,4 @@
+import f from "./InputMonthWrapper.vue.mjs";
+export {
+  f as default
+};

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

@@ -1,4 +1,4 @@
-import type { BreakpointCustomizable, InputNumberState, Theme } from '../types';
+import type { BreakpointCustomizable, InputNumberState } from '../types';
 type PInputNumberProps = {
     /**
      * Provides a hint to the browser about what type of data the field expects, which can assist with autofill features (e.g., autocomplete='postal-code').
@@ -72,10 +72,6 @@ type PInputNumberProps = {
      * The granularity that the value must adhere to.
      */
     step?: number;
-    /**
-     * Controls the visual appearance of the component.
-     */
-    theme?: Theme;
     /**
      * The number input value.
      */

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

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