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

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

@@ -1,4 +1,4 @@
-import type { BreakpointCustomizable, InputPasswordState, Theme } from '../types';
+import type { BreakpointCustomizable, InputPasswordState } from '../types';
 type PInputPasswordProps = {
     /**
      * Provides a hint to the browser about what type of data the field expects, which can assist with autofill features (e.g., autocomplete='current-password', autocomplete='new-password').
@@ -64,10 +64,6 @@ type PInputPasswordProps = {
      * Indicates the validation or overall status of the input component.
      */
     state?: InputPasswordState;
-    /**
-     * Controls the visual appearance of the component.
-     */
-    theme?: Theme;
     /**
      * Show or hide password toggle for `input type="password"`.
      */

package/esm/lib/components/InputPasswordWrapper.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 g, openBlock as B, resolveDynamicComponent as b, unref as v, withCtx as C, renderSlot as _ } from "vue";
-import { usePrefix as w, themeInjectionKey as x, syncProperties as s, addEventListenerToElementRef as n } from "../../utils.mjs";
-const j = /* @__PURE__ */ u({
+import { defineComponent as r, ref as f, onMounted as u, onUpdated as m, createBlock as c, openBlock as i, resolveDynamicComponent as y, unref as g, withCtx as B, renderSlot as h } from "vue";
+import { usePrefix as b, syncProperties as C, addEventListenerToElementRef as o } from "../../utils.mjs";
+const x = /* @__PURE__ */ r({
   __name: "InputPasswordWrapper",
   props: {
     autoComplete: {},
@@ -19,30 +19,27 @@ const j = /* @__PURE__ */ u({
     readOnly: { type: Boolean, default: !1 },
     required: { type: Boolean, default: !1 },
     state: { default: "none" },
-    theme: {},
     toggle: { type: Boolean, default: !1 },
     value: { default: "" }
   },
   emits: ["update:value", "blur", "change", "input"],
-  setup(d, { emit: f }) {
-    const r = w("p-input-password"), o = d, e = m(), a = f, l = c(x), p = () => s(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 s = b("p-input-password"), d = l, e = f(), t = p, n = () => C(e, d);
+    return u(() => {
+      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: o.theme || t });
-    }), (t, L) => (B(), g(b(v(r)), {
+    }), m(n), (a, _) => (i(), c(y(g(s)), {
       ref_key: "pdsComponentRef",
       ref: e
     }, {
-      default: C(() => [
-        _(t.$slots, "default")
+      default: B(() => [
+        h(a.$slots, "default")
       ]),
       _: 3
     }, 512));
   }
 });
 export {
-  j as default
+  x as default
 };

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

@@ -1,4 +1,4 @@
-import type { BreakpointCustomizable, InputSearchState, Theme } from '../types';
+import type { BreakpointCustomizable, InputSearchState } from '../types';
 type PInputSearchProps = {
     /**
      * Provides a hint to the browser about what type of data the field expects, which can assist with autofill features (e.g., autocomplete='on').
@@ -40,10 +40,18 @@ type PInputSearchProps = {
      * @experimental Shows a loading indicator.
      */
     loading?: boolean;
+    /**
+     * A non-negative integer specifying the maximum number of characters the user can enter into the input.
+     */
+    maxLength?: number;
     /**
      * Dynamic feedback text for validation or status.
      */
     message?: string;
+    /**
+     * A non-negative integer specifying the minimum number of characters required for the input's value to be considered valid.
+     */
+    minLength?: number;
     /**
      * The name of the input field, used when submitting the form data.
      */
@@ -64,10 +72,6 @@ type PInputSearchProps = {
      * Indicates the validation or overall status of the input component.
      */
     state?: InputSearchState;
-    /**
-     * Controls the visual appearance of the component.
-     */
-    theme?: Theme;
     /**
      * The search input value.
      */

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

@@ -1,6 +1,6 @@
-import { defineComponent as d, ref as c, inject as m, 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 R, themeInjectionKey as j, syncProperties as f, addEventListenerToElementRef as n } from "../../utils.mjs";
-const P = /* @__PURE__ */ d({
+import { defineComponent as d, ref as s, onMounted as u, onUpdated as c, createBlock as i, openBlock as m, resolveDynamicComponent as y, unref as h, withCtx as B, renderSlot as g } from "vue";
+import { usePrefix as b, syncProperties as C, addEventListenerToElementRef as o } from "../../utils.mjs";
+const L = /* @__PURE__ */ d({
   __name: "InputSearchWrapper",
   props: {
     autoComplete: {},
@@ -13,35 +13,34 @@ const P = /* @__PURE__ */ d({
     indicator: { type: Boolean, default: !1 },
     label: { default: "" },
     loading: { type: Boolean, default: !1 },
+    maxLength: {},
     message: { default: "" },
+    minLength: {},
     name: {},
     placeholder: { default: "" },
     readOnly: { type: Boolean, default: !1 },
     required: { type: Boolean, default: !1 },
     state: { default: "none" },
-    theme: {},
     value: { default: "" }
   },
   emits: ["update:value", "blur", "change", "input"],
-  setup(r, { emit: s }) {
-    const u = R("p-input-search"), o = r, e = c(), a = s, l = m(j), p = () => f(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 r = b("p-input-search"), f = l, e = s(), t = p, n = () => C(e, f);
+    return u(() => {
+      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) => {
-      f(e, { theme: o.theme || t });
-    }), (t, k) => (b(), B(v(C(u)), {
+    }), c(n), (a, _) => (m(), i(y(h(r)), {
       ref_key: "pdsComponentRef",
       ref: e
     }, {
-      default: _(() => [
-        g(t.$slots, "default")
+      default: B(() => [
+        g(a.$slots, "default")
       ]),
       _: 3
     }, 512));
   }
 });
 export {
-  P as default
+  L as default
 };

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

@@ -1,4 +1,4 @@
-import type { BreakpointCustomizable, InputTelState, Theme } from '../types';
+import type { BreakpointCustomizable, InputTelState } from '../types';
 type PInputTelProps = {
     /**
      * Provides a hint to the browser about what type of data the field expects, which can assist with autofill features (e.g., autocomplete='tel').
@@ -72,10 +72,6 @@ type PInputTelProps = {
      * Indicates the validation or overall status of the input component.
      */
     state?: InputTelState;
-    /**
-     * Controls the visual appearance of the component.
-     */
-    theme?: Theme;
     /**
      * The tel input value.
      */

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

@@ -1,6 +1,6 @@
-import { defineComponent as s, ref as m, inject as c, onMounted as i, 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 f, ref as u, onMounted as s, onUpdated as i, createBlock as c, openBlock as m, 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__ */ f({
   __name: "InputTelWrapper",
   props: {
     autoComplete: {},
@@ -21,29 +21,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(r, { emit: u }) {
-    const d = x("p-input-tel"), n = r, e = m(), a = u, l = c(L), p = () => f(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 r = b("p-input-tel"), d = l, e = u(), t = p, n = () => C(e, d);
+    return s(() => {
+      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) => {
-      f(e, { theme: n.theme || t });
-    }), (t, R) => (g(), B(b(v(d)), {
+    }), i(n), (a, _) => (m(), c(y(B(r)), {
       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/InputTextWrapper.vue.d.ts

@@ -1,4 +1,4 @@
-import type { BreakpointCustomizable, InputTextState, Theme } from '../types';
+import type { BreakpointCustomizable, InputTextState } from '../types';
 type PInputTextProps = {
     /**
      * Provides a hint to the browser about what type of data the field expects, which can assist with autofill features (e.g., autocomplete='name').
@@ -72,10 +72,6 @@ type PInputTextProps = {
      * Indicates the validation or overall status of the input component.
      */
     state?: InputTextState;
-    /**
-     * Controls the visual appearance of the component.
-     */
-    theme?: Theme;
     /**
      * The text input value.
      */

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

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

@@ -1,4 +1,4 @@
-import type { BreakpointCustomizable, InputTimeState, Theme } from '../types';
+import type { BreakpointCustomizable, InputTimeState } from '../types';
 type PInputTimeProps = {
     /**
      * Provides a hint to the browser about what type of data the field expects, which can assist with autofill features (e.g., auto-complete='on').
@@ -64,10 +64,6 @@ type PInputTimeProps = {
      * efines the granularity of the time input. The step value is given in seconds. The default is 60 (one minute). You can also specify smaller increments (e.g., step='1' for seconds, step='0.001' for milliseconds).
      */
     step?: number;
-    /**
-     * Controls the visual appearance of the component.
-     */
-    theme?: Theme;
     /**
      * The default time value for the input, in hh:mm or hh:mm:ss format (e.g., value='14:00').
      */

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

@@ -1,6 +1,6 @@
-import { defineComponent as d, ref as m, inject as i, onMounted as c, 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__ */ d({
+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 C } from "vue";
+import { usePrefix as _, syncProperties as g, addEventListenerToElementRef as o } from "../../utils.mjs";
+const k = /* @__PURE__ */ f({
   __name: "InputTimeWrapper",
   props: {
     autoComplete: {},
@@ -19,29 +19,26 @@ const P = /* @__PURE__ */ d({
     required: { type: Boolean, default: !1 },
     state: { default: "none" },
     step: { default: 60 },
-    theme: {},
     value: { default: "" }
   },
   emits: ["update:value", "blur", "change", "input"],
-  setup(u, { emit: f }) {
-    const r = x("p-input-time"), n = u, e = m(), a = f, l = i(R), p = () => s(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(l, { emit: p }) {
+    const s = _("p-input-time"), u = l, e = r(), t = p, n = () => g(e, u);
+    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) => {
-      s(e, { theme: n.theme || t });
-    }), (t, j) => (b(), B(v(C(r)), {
+    }), 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/InputUrlWrapper.vue.d.ts

@@ -1,4 +1,4 @@
-import type { BreakpointCustomizable, InputUrlState, Theme } from '../types';
+import type { BreakpointCustomizable, InputUrlState } from '../types';
 type PInputUrlProps = {
     /**
      * Provides a hint to the browser about what type of data the field expects, which can assist with autofill features (e.g., autocomplete='url').
@@ -72,10 +72,6 @@ type PInputUrlProps = {
      * Indicates the validation or overall status of the input component.
      */
     state?: InputUrlState;
-    /**
-     * Controls the visual appearance of the component.
-     */
-    theme?: Theme;
     /**
      * The url input value.
      */

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

@@ -1,6 +1,6 @@
-import { defineComponent as s, ref as m, inject as c, onMounted as i, 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 r, addEventListenerToElementRef as o } from "../../utils.mjs";
-const w = /* @__PURE__ */ s({
+import { defineComponent as d, ref as f, onMounted as s, onUpdated as i, createBlock as c, openBlock as m, 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: "InputUrlWrapper",
   props: {
     autoComplete: {},
@@ -21,29 +21,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: f }) {
-    const d = x("p-input-url"), n = u, e = m(), a = f, l = c(L), p = () => r(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 r = b("p-input-url"), u = l, e = f(), t = p, n = () => C(e, u);
+    return s(() => {
+      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) => {
-      r(e, { theme: n.theme || t });
-    }), (t, R) => (g(), B(b(v(d)), {
+    }), i(n), (a, _) => (m(), c(y(B(r)), {
       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/InputWeekWrapper.vue.d.ts

@@ -0,0 +1,107 @@
+import type { BreakpointCustomizable, InputWeekState } from '../types';
+type PInputWeekProps = {
+    /**
+     * 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 week that can be selected. The value must be a week string in YYYY-Www format (e.g., max='2024-W52').
+     */
+    max?: string;
+    /**
+     * Dynamic feedback text for validation or status.
+     */
+    message?: string;
+    /**
+     * Specifies the earliest week that can be selected. The value must be a week string in YYYY-Www format (e.g., min='2024-W01').
+     */
+    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?: InputWeekState;
+    /**
+     * Defines the stepping interval in weeks. For example, step="1" increments by 1 week. The default is 1 month.
+     */
+    step?: number;
+    /**
+     * The default week value for the input, in YYYY-Www format (e.g., value='2025-W27')
+     */
+    value?: string;
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<PInputWeekProps, {}, {}, {}, {}, 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<PInputWeekProps> & 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: InputWeekState;
+    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/InputWeekWrapper.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 C } from "vue";
+import { usePrefix as _, syncProperties as g, addEventListenerToElementRef as o } from "../../utils.mjs";
+const x = /* @__PURE__ */ f({
+  __name: "InputWeekWrapper",
+  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 = _("p-input-week"), u = l, e = r(), t = p, n = () => g(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, v) => (c(), i(y(B(s)), {
+      ref_key: "pdsComponentRef",
+      ref: e
+    }, {
+      default: b(() => [
+        C(a.$slots, "default")
+      ]),
+      _: 3
+    }, 512));
+  }
+});
+export {
+  x as default
+};

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

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

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

@@ -1,4 +1,4 @@
-import type { BreakpointCustomizable, LinkPureAlignLabel, SelectedAriaAttributes, LinkPureAriaAttribute, LinkPureIcon, LinkPureSize, LinkPureTarget, Theme, LinkPureWeight } from '../types';
+import type { BreakpointCustomizable, LinkPureAlignLabel, SelectedAriaAttributes, LinkPureAriaAttribute, LinkPureIcon, LinkPureSize, LinkPureTarget } from '../types';
 type PLinkPureProps = {
     /**
      * Display link in active state.
@@ -48,33 +48,23 @@ type PLinkPureProps = {
      * Target attribute where the link should be opened.
      */
     target?: LinkPureTarget;
-    /**
-     * Adapts the button color depending on the theme.
-     */
-    theme?: Theme;
     /**
      * Shows an underline under the label.
      */
     underline?: boolean;
-    /**
-     * The weight of the text (only has effect with visible label).
-     * @deprecated since v3.0.0, will be removed with next major release
-     */
-    weight?: LinkPureWeight;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<PLinkPureProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PLinkPureProps> & Readonly<{}>, {
-    weight: LinkPureWeight;
-    stretch: BreakpointCustomizable<boolean>;
     size: BreakpointCustomizable<LinkPureSize>;
     target: LinkPureTarget;
     hideLabel: BreakpointCustomizable<boolean>;
     icon: LinkPureIcon;
     active: boolean;
     alignLabel: BreakpointCustomizable<LinkPureAlignLabel>;
+    stretch: BreakpointCustomizable<boolean>;
     underline: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;