@indielayer/ui 1.0.10 → 1.2.0

package/lib/components/table/TableHeader.vue.d.ts

@@ -1,32 +1,50 @@
-import type { PropType } from 'vue';
-export type Sort = 1 | -1 | undefined;
-export type Align = 'left' | 'center' | 'right' | 'justify' | undefined;
+import type { ExtractPublicPropTypes, PropType } from 'vue';
+declare const validators: {
+    sort: readonly [1, -1, undefined];
+    textAlign: readonly ["left", "center", "right", "justify"];
+};
+declare const tableHeaderProps: {
+    sort: {
+        type: PropType<1 | -1 | undefined>;
+        validator: (value: number) => boolean;
+    };
+    sortable: BooleanConstructor;
+    textAlign: {
+        type: PropType<"left" | "right" | "center" | "justify">;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    stickyHeader: BooleanConstructor;
+};
+export type TableHeaderSort = typeof validators.sort[number];
+export type TableHeaderAlign = typeof validators.textAlign[number];
+export type TableHeaderProps = ExtractPublicPropTypes<typeof tableHeaderProps>;
 declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
     sort: {
-        type: PropType<Sort>;
+        type: PropType<1 | -1 | undefined>;
         validator: (value: number) => boolean;
     };
     sortable: BooleanConstructor;
     textAlign: {
-        type: PropType<Align>;
+        type: PropType<"left" | "right" | "center" | "justify">;
         default: string;
         validator: (value: string) => boolean;
     };
     stickyHeader: BooleanConstructor;
 }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     sort: {
-        type: PropType<Sort>;
+        type: PropType<1 | -1 | undefined>;
         validator: (value: number) => boolean;
     };
     sortable: BooleanConstructor;
     textAlign: {
-        type: PropType<Align>;
+        type: PropType<"left" | "right" | "center" | "justify">;
         default: string;
         validator: (value: string) => boolean;
     };
     stickyHeader: BooleanConstructor;
 }>>, {
-    textAlign: Align;
+    textAlign: "left" | "right" | "center" | "justify";
     sortable: boolean;
     stickyHeader: boolean;
 }, {}>, {

package/lib/components/table/TableHeader.vue.js

@@ -0,0 +1,78 @@
+import { defineComponent as d, openBlock as t, createElementBlock as o, normalizeClass as u, renderSlot as i, Fragment as a, createCommentVNode as n, createElementVNode as s } from "vue";
+const c = {
+  key: 0,
+  class: "relative inline-block"
+}, p = {
+  key: 0,
+  class: "absolute stroke-2 w-3 h-3 ml-0.5 -right-3 top-0.5",
+  width: "24",
+  height: "24",
+  viewBox: "0 0 24 24",
+  stroke: "currentColor",
+  "stroke-linejoin": "round",
+  "stroke-linecap": "round",
+  fill: "none",
+  role: "presentation"
+}, y = /* @__PURE__ */ s("line", {
+  x1: "12",
+  y1: "5",
+  x2: "12",
+  y2: "19"
+}, null, -1), g = /* @__PURE__ */ s("polyline", { points: "19 12 12 19 5 12" }, null, -1), h = /* @__PURE__ */ s("line", {
+  x1: "12",
+  y1: "19",
+  x2: "12",
+  y2: "5"
+}, null, -1), f = /* @__PURE__ */ s("polyline", { points: "5 12 12 5 19 12" }, null, -1), l = {
+  sort: [1, -1, void 0],
+  textAlign: ["left", "center", "right", "justify"]
+}, k = {
+  sort: {
+    type: Number,
+    validator: (r) => l.sort.includes(r)
+  },
+  sortable: Boolean,
+  textAlign: {
+    type: String,
+    default: "left",
+    validator: (r) => l.textAlign.includes(r)
+  },
+  stickyHeader: Boolean
+}, m = { name: "XTableHeader", validators: l }, b = /* @__PURE__ */ d({
+  ...m,
+  props: k,
+  setup(r) {
+    return (e, v) => (t(), o("th", {
+      class: u(["py-2 font-semibold tracking-widest uppercase text-xs px-3", [
+        {
+          // sort
+          "cursor-pointer hover:text-gray-800 dark:hover:text-gray-300 transition-colors duration-150 ease-in-out": e.sortable,
+          // stickyHeader
+          "sticky top-0": e.stickyHeader,
+          // textAlign
+          "text-left": e.textAlign === "left",
+          "text-right": e.textAlign === "right",
+          "text-center": e.textAlign === "center",
+          "text-justify": e.textAlign === "justify"
+        }
+      ]])
+    }, [
+      e.sortable ? (t(), o("div", c, [
+        i(e.$slots, "default"),
+        e.sort && [1, -1].includes(e.sort) ? (t(), o("svg", p, [
+          e.sort === -1 ? (t(), o(a, { key: 0 }, [
+            y,
+            g
+          ], 64)) : n("", !0),
+          e.sort === 1 ? (t(), o(a, { key: 1 }, [
+            h,
+            f
+          ], 64)) : n("", !0)
+        ])) : n("", !0)
+      ])) : i(e.$slots, "default", { key: 1 })
+    ], 2));
+  }
+});
+export {
+  b as default
+};

package/lib/components/table/TableHeader.vue2.js

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

package/lib/components/table/TableRow.vue.js

@@ -0,0 +1,32 @@
+import { defineComponent as i, computed as a, openBlock as n, createElementBlock as s, normalizeClass as d, renderSlot as g } from "vue";
+const r = {
+  verticalAlign: ["baseline", "bottom", "middle", "text-bottom", "text-top", "top"]
+}, c = { name: "XTableRow", validators: r }, u = /* @__PURE__ */ i({
+  ...c,
+  props: {
+    pointer: Boolean,
+    striped: Boolean,
+    verticalAlign: {
+      type: String,
+      default: "top",
+      validator: (t) => r.verticalAlign.includes(t)
+    }
+  },
+  setup(t) {
+    const e = t, l = a(() => e.verticalAlign === "baseline" ? "align-baseline" : e.verticalAlign === "bottom" ? "align-bottom" : e.verticalAlign === "middle" ? "align-middle" : e.verticalAlign === "text-bottom" ? "align-text-bottom" : e.verticalAlign === "text-top" ? "align-text-top" : e.verticalAlign === "top" ? "align-top" : "");
+    return (o, p) => (n(), s("tr", {
+      class: d([
+        t.striped ? "odd:bg-gray-50 dark:odd:bg-gray-800" : "border-b border-gray-200 dark:border-gray-700",
+        {
+          "hover:bg-gray-50 dark:hover:bg-gray-700 cursor-pointer": t.pointer
+        },
+        l.value
+      ])
+    }, [
+      g(o.$slots, "default")
+    ], 2));
+  }
+});
+export {
+  u as default
+};

package/lib/components/table/TableRow.vue2.js

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

package/lib/components/table/index.d.ts

@@ -0,0 +1,9 @@
+export { default as XTable } from './Table.vue';
+export { default as XTableBody } from './TableBody';
+export { default as XTableCell } from './TableCell.vue';
+export { default as XTableHead } from './TableHead';
+export { default as XTableHeader } from './TableHeader.vue';
+export { default as XTableRow } from './TableRow.vue';
+export type { TableProps, TableHeader } from './Table.vue';
+export type { TableHeaderProps, TableHeaderAlign, TableHeaderSort } from './TableHeader.vue';
+export type { TableCellProps, TableCellTextAlign, TableCellVerticalAlign } from './TableCell.vue';

package/lib/components/tag/Tag.theme.d.ts

@@ -1,9 +1,10 @@
-import type { ThemeParams } from '../../composables/theme';
-declare const _default: {
-    classes: {
-        wrapper: ({ props, data }: ThemeParams) => string;
-        loadingWrapper: string;
-    };
-    styles: ({ colors, props, css }: ThemeParams) => Record<string, string>;
-};
-export default _default;
+import type { ThemeClasses, ThemeComponent } from '../../composables/theme';
+import type { TagProps } from './Tag.vue';
+type InternalClasses = 'wrapper' | 'loadingWrapper';
+interface InternalTheme extends ThemeComponent<TagProps, InternalClasses> {
+}
+export interface TagTheme extends Omit<InternalTheme, 'classes'> {
+    classes?: Partial<ThemeClasses<TagProps, InternalClasses>>;
+}
+declare const theme: InternalTheme;
+export default theme;

package/lib/components/tag/Tag.theme.js

@@ -0,0 +1,23 @@
+const a = {
+  classes: {
+    wrapper: ({ props: t, data: s }) => {
+      let e = "inline-flex items-center leading-none max-w-full";
+      return t.size === "xs" ? e += " px-2 py-1 text-xs" : t.size === "sm" ? e += " px-2 py-1 text-sm" : t.size === "lg" ? e += " px-4 py-3 text-lg" : t.size === "xl" ? e += " px-6 py-6 text-xl" : e += " px-3 py-2", e;
+    },
+    loadingWrapper: "absolute inset-0 flex items-center justify-center z-40 bg-gray-300 dark:bg-gray-600 rounded opacity-50"
+  },
+  styles: ({ colors: t, props: s, css: e }) => {
+    const l = t.getPalette(s.color);
+    return e.variables({
+      bg: l[100],
+      text: l[800],
+      border: l[800],
+      dark: {
+        text: s.outlined ? l[200] : l[800]
+      }
+    });
+  }
+}, i = a;
+export {
+  i as default
+};

package/lib/components/tag/Tag.vue.d.ts

@@ -1,3 +1,23 @@
+import { type ExtractPublicPropTypes } from 'vue';
+declare const tagProps: {
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    rounded: BooleanConstructor;
+    removable: BooleanConstructor;
+    outlined: BooleanConstructor;
+    color: {
+        readonly type: StringConstructor;
+        readonly default: string | undefined;
+    };
+    size: {
+        readonly type: import("vue").PropType<import("../../composables/common").Size>;
+        readonly default: "md";
+        readonly validator: (value: string) => boolean;
+    };
+};
+export type TagProps = ExtractPublicPropTypes<typeof tagProps>;
 declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
     tag: {
         type: StringConstructor;
@@ -35,12 +55,12 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
 }>> & {
     onRemove?: ((...args: any[]) => any) | undefined;
 }, {
-    size: import("../../composables/common").Size;
     color: string;
-    outlined: boolean;
-    removable: boolean;
+    size: import("../../composables/common").Size;
     tag: string;
+    outlined: boolean;
     rounded: boolean;
+    removable: boolean;
 }, {}>, {
     default?(_: {}): any;
 }>;

package/lib/components/tag/Tag.vue.js

@@ -0,0 +1,61 @@
+import { defineComponent as p, computed as f, openBlock as s, createBlock as g, resolveDynamicComponent as v, normalizeClass as y, unref as r, normalizeStyle as x, withCtx as z, createElementBlock as k, renderSlot as l, createVNode as b } from "vue";
+import { useColors as C } from "../../composables/colors.js";
+import { useCommon as a } from "../../composables/common.js";
+import { useTheme as B } from "../../composables/theme.js";
+import { closeIcon as h } from "../../common/icons.js";
+import S from "../icon/Icon.vue.js";
+import _ from "./Tag.theme.js";
+const $ = {
+  key: 0,
+  class: "max-w-full truncate"
+}, w = {
+  ...a.props(),
+  ...C.props("gray"),
+  tag: {
+    type: String,
+    default: "span"
+  },
+  rounded: Boolean,
+  removable: Boolean,
+  outlined: Boolean
+}, I = {
+  name: "XTag",
+  validators: {
+    ...a.validators()
+  }
+}, j = /* @__PURE__ */ p({
+  ...I,
+  props: w,
+  emits: ["remove"],
+  setup(n) {
+    const o = n, m = f(() => o.size === "xs" ? "xs" : o.size === "sm" ? "sm" : o.size === "lg" ? "md" : o.size === "xl" ? "lg" : "sm"), { styles: i, classes: u, className: d } = B("tag", _, o);
+    return (e, t) => (s(), g(v(e.tag), {
+      class: y([
+        "text-[color:var(--x-tag-text)] dark:text-[color:var(--x-tag-dark-text)] border-[color:var(--x-tag-border)",
+        [
+          r(d),
+          r(u).wrapper,
+          e.outlined ? "border" : "bg-[color:var(--x-tag-bg)]",
+          e.rounded ? "rounded-full" : "rounded"
+        ]
+      ]),
+      style: x(r(i))
+    }, {
+      default: z(() => [
+        e.removable ? (s(), k("span", $, [
+          l(e.$slots, "default"),
+          b(S, {
+            size: m.value,
+            icon: r(h),
+            class: "ml-1 cursor-pointer hover:text-gray-700 transition-colors duration-150",
+            onClick: t[0] || (t[0] = (c) => e.$emit("remove", c))
+          }, null, 8, ["size", "icon"])
+        ])) : l(e.$slots, "default", { key: 1 })
+      ]),
+      _: 3
+    }, 8, ["style", "class"]));
+  }
+});
+export {
+  j as default
+};

package/lib/components/tag/Tag.vue2.js

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

package/lib/components/tag/index.d.ts

@@ -0,0 +1,2 @@
+export { default as XTag } from './Tag.vue';
+export type { TagProps } from './Tag.vue';

package/lib/components/textarea/Textarea.theme.d.ts

@@ -1,10 +1,14 @@
-import type { ThemeParams } from '../../composables/theme';
-declare const _default: {
-    classes: {
-        wrapper: string;
-        label: ({ props }: ThemeParams) => string;
-        input: ({ props, data }: ThemeParams) => string[];
-    };
-    styles: ({ colors, props, css }: ThemeParams) => Record<string, string>;
+import type { Ref } from 'vue';
+import type { ThemeClasses, ThemeComponent } from '../../composables/theme';
+import type { TextareaProps } from './Textarea.vue';
+type InternalClasses = 'wrapper' | 'label' | 'input';
+type InternalExtraData = {
+    errorInternal: Ref<boolean>;
 };
-export default _default;
+interface InternalTheme extends ThemeComponent<TextareaProps, InternalClasses, InternalExtraData> {
+}
+export interface TextareaTheme extends Omit<InternalTheme, 'classes'> {
+    classes?: Partial<ThemeClasses<TextareaProps, InternalClasses, InternalExtraData>>;
+}
+declare const theme: InternalTheme;
+export default theme;

package/lib/components/textarea/Textarea.theme.js

@@ -0,0 +1,16 @@
+const s = {
+  classes: {
+    wrapper: "inline-block align-bottom text-left",
+    label: ({ props: e }) => {
+      const r = "font-medium text-gray-800 dark:text-gray-200 mb-1";
+      return e.size === "xs" ? r + " text-xs" : e.size === "sm" ? r + " text-sm" : e.size === "lg" ? r + " text-lg" : e.size === "xl" ? r + " text-xl" : r;
+    },
+    input: ({ props: e, data: r }) => {
+      const t = ["resize-none appearance-none block w-full placeholder-gray-400 dark:placeholder-gray-500 outline-transparent outline outline-2 outline-offset-[-1px] transition duration-150 ease-in-out border-gray-300 dark:border-gray-700 border shadow-sm rounded-md"];
+      return !r.errorInternal && !e.disabled && t.push("hover:border-gray-400 dark:hover:border-gray-500"), e.size === "xs" ? t.push("px-2 py-1 text-xs") : e.size === "sm" ? t.push("px-2 py-2 text-sm") : e.size === "lg" ? t.push("px-4 py-3 text-lg") : e.size === "xl" ? t.push("px-5 py-4 text-xl") : t.push("px-3 py-2"), t.push(e.disabled ? "bg-gray-100 dark:bg-gray-900 text-gray-500 cursor-not-allowed" : "bg-white dark:bg-gray-800 text-gray-700 dark:text-gray-200"), t;
+    }
+  }
+}, a = s;
+export {
+  a as default
+};

package/lib/components/textarea/Textarea.vue.d.ts

@@ -1,3 +1,45 @@
+import { type ExtractPublicPropTypes } from 'vue';
+declare const textareaProps: {
+    helper: StringConstructor;
+    label: StringConstructor;
+    dir: {
+        type: StringConstructor;
+        default: string;
+    };
+    rows: (StringConstructor | NumberConstructor)[];
+    max: (StringConstructor | NumberConstructor)[];
+    maxlength: (StringConstructor | NumberConstructor)[];
+    min: (StringConstructor | NumberConstructor)[];
+    minlength: (StringConstructor | NumberConstructor)[];
+    placeholder: StringConstructor;
+    adjustToText: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    preventEnter: BooleanConstructor;
+    block: BooleanConstructor;
+    modelValue: import("vue").PropType<string | number | boolean | object | any[] | undefined>;
+    name: StringConstructor;
+    readonly: BooleanConstructor;
+    required: BooleanConstructor;
+    validateOnInput: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    error: StringConstructor;
+    rules: {
+        readonly type: ArrayConstructor;
+        readonly default: () => never[];
+    };
+    disabled: BooleanConstructor;
+    loading: BooleanConstructor;
+    size: {
+        readonly type: import("vue").PropType<import("../../composables/common").Size>;
+        readonly default: "md";
+        readonly validator: (value: string) => boolean;
+    };
+};
+export type TextareaProps = ExtractPublicPropTypes<typeof textareaProps>;
 declare const _default: import("vue").DefineComponent<{
     helper: StringConstructor;
     label: StringConstructor;
@@ -5,11 +47,11 @@ declare const _default: import("vue").DefineComponent<{
         type: StringConstructor;
         default: string;
     };
-    rows: (NumberConstructor | StringConstructor)[];
-    max: (NumberConstructor | StringConstructor)[];
-    maxlength: (NumberConstructor | StringConstructor)[];
-    min: (NumberConstructor | StringConstructor)[];
-    minlength: (NumberConstructor | StringConstructor)[];
+    rows: (StringConstructor | NumberConstructor)[];
+    max: (StringConstructor | NumberConstructor)[];
+    maxlength: (StringConstructor | NumberConstructor)[];
+    min: (StringConstructor | NumberConstructor)[];
+    minlength: (StringConstructor | NumberConstructor)[];
     placeholder: StringConstructor;
     adjustToText: {
         type: BooleanConstructor;
@@ -41,7 +83,7 @@ declare const _default: import("vue").DefineComponent<{
     focus: () => void | undefined;
     blur: () => void | undefined;
     reset: () => void;
-    validate: (val: any) => boolean;
+    validate: (val?: any) => boolean;
     setError: (val: string) => void;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     helper: StringConstructor;
@@ -50,11 +92,11 @@ declare const _default: import("vue").DefineComponent<{
         type: StringConstructor;
         default: string;
     };
-    rows: (NumberConstructor | StringConstructor)[];
-    max: (NumberConstructor | StringConstructor)[];
-    maxlength: (NumberConstructor | StringConstructor)[];
-    min: (NumberConstructor | StringConstructor)[];
-    minlength: (NumberConstructor | StringConstructor)[];
+    rows: (StringConstructor | NumberConstructor)[];
+    max: (StringConstructor | NumberConstructor)[];
+    maxlength: (StringConstructor | NumberConstructor)[];
+    min: (StringConstructor | NumberConstructor)[];
+    minlength: (StringConstructor | NumberConstructor)[];
     placeholder: StringConstructor;
     adjustToText: {
         type: BooleanConstructor;
@@ -85,11 +127,11 @@ declare const _default: import("vue").DefineComponent<{
 }>> & {
     [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
 }, {
-    size: import("../../composables/common").Size;
-    required: boolean;
+    disabled: boolean;
     dir: string;
+    size: import("../../composables/common").Size;
     block: boolean;
-    disabled: boolean;
+    required: boolean;
     loading: boolean;
     readonly: boolean;
     validateOnInput: boolean;

package/lib/components/textarea/Textarea.vue.js

@@ -0,0 +1,110 @@
+import { defineComponent as V, ref as B, watch as P, openBlock as m, createElementBlock as u, normalizeStyle as K, unref as r, normalizeClass as p, toDisplayString as R, createCommentVNode as j, createElementVNode as D, mergeProps as H, toHandlers as L, withKeys as X, createVNode as F } from "vue";
+import { useResizeObserver as O, useEventListener as q } from "../../node_modules/.pnpm/@vueuse_core@10.2.0_vue@3.3.4/node_modules/@vueuse/core/index.js";
+import { useCSS as A } from "../../composables/css.js";
+import { useTheme as G } from "../../composables/theme.js";
+import { useCommon as d } from "../../composables/common.js";
+import { useColors as J } from "../../composables/colors.js";
+import { useInputtable as s } from "../../composables/inputtable.js";
+import { useInteractive as f } from "../../composables/interactive.js";
+import M from "../helpers/InputError.js";
+import Q from "./Textarea.theme.js";
+const U = ["textContent"], W = ["disabled", "max", "maxlength", "min", "dir", "rows", "minlength", "name", "placeholder", "readonly", "value", "onKeydown"], Y = {
+  ...d.props(),
+  ...f.props(),
+  ...s.props(),
+  helper: String,
+  label: String,
+  dir: {
+    type: String,
+    default: "ltr"
+  },
+  rows: [Number, String],
+  max: [Number, String],
+  maxlength: [Number, String],
+  min: [Number, String],
+  minlength: [Number, String],
+  placeholder: String,
+  adjustToText: {
+    type: Boolean,
+    default: !0
+  },
+  preventEnter: Boolean,
+  block: Boolean
+}, Z = {
+  name: "XTextarea",
+  validators: {
+    ...d.validators()
+  }
+}, ue = /* @__PURE__ */ V({
+  ...Z,
+  props: Y,
+  emits: s.emits(),
+  setup(c, { expose: h, emit: g }) {
+    const o = c, t = B(null);
+    O(t, n), typeof window < "u" && q(window, "resize", n), P([() => o.modelValue, () => o.size], () => {
+      setTimeout(n);
+    });
+    const b = A("textarea"), y = J().getPalette("primary"), v = b.get("border", y[400]);
+    function w() {
+      n();
+    }
+    function S(e) {
+      o.preventEnter && e.preventDefault(), e.stopPropagation();
+    }
+    function n() {
+      o.adjustToText && t.value && (t.value.style.height = "1px", t.value.style.height = 2 + t.value.scrollHeight + "px");
+    }
+    const { focus: i, blur: N } = f(t), {
+      errorInternal: l,
+      isInsideForm: x,
+      inputListeners: C,
+      reset: E,
+      validate: k,
+      setError: T
+    } = s(o, { focus: i, emit: g }), { styles: z, classes: a, className: I } = G("textarea", Q, o, { errorInternal: l });
+    return h({ focus: i, blur: N, reset: E, validate: k, setError: T }), (e, _) => (m(), u("label", {
+      style: K(r(z)),
+      class: p(["relative", [
+        r(I),
+        r(a).wrapper,
+        { "mb-3": r(x), "w-full": e.block }
+      ]])
+    }, [
+      e.label ? (m(), u("p", {
+        key: 0,
+        class: p(r(a).label),
+        textContent: R(e.label)
+      }, null, 10, U)) : j("", !0),
+      D("textarea", H({
+        ref_key: "elRef",
+        ref: t,
+        class: ["", [
+          r(a).input,
+          r(l) ? "border-red-500 dark:border-red-400 focus:outline-red-500" : "focus:outline-[color:var(--x-textarea-border)]"
+        ]],
+        style: r(v),
+        disabled: e.disabled,
+        max: e.max,
+        maxlength: e.maxlength,
+        min: e.min,
+        dir: e.dir,
+        rows: e.rows,
+        minlength: e.minlength,
+        name: e.name,
+        placeholder: e.placeholder,
+        readonly: e.readonly,
+        value: e.modelValue ? String(e.modelValue) : ""
+      }, L(r(C), !0), {
+        onKeydown: X(S, ["enter"]),
+        onInput: w
+      }), null, 16, W),
+      F(r(M), {
+        error: r(l),
+        helper: e.helper
+      }, null, 8, ["error", "helper"])
+    ], 6));
+  }
+});
+export {
+  ue as default
+};

package/lib/components/textarea/Textarea.vue2.js

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

package/lib/components/textarea/index.d.ts

@@ -0,0 +1,2 @@
+export { default as XTextarea } from './Textarea.vue';
+export type { TextareaProps } from './Textarea.vue';

package/lib/components/toggle/Toggle.theme.d.ts

@@ -1,11 +1,10 @@
-import type { ThemeParams } from '../../composables/theme';
-declare const _default: {
-    classes: {
-        wrapper: string;
-        label: ({ props }: ThemeParams) => string;
-        buttonWrapper: ({ props }: ThemeParams) => string;
-        button: ({ props }: ThemeParams) => string;
-    };
-    styles: ({ colors, props, css }: ThemeParams) => Record<string, string>;
-};
-export default _default;
+import type { ThemeClasses, ThemeComponent } from '../../composables/theme';
+import type { ToggleProps } from './Toggle.vue';
+type InternalClasses = 'wrapper' | 'label' | 'buttonWrapper' | 'button';
+interface InternalTheme extends ThemeComponent<ToggleProps, InternalClasses> {
+}
+export interface ToggleTheme extends Omit<InternalTheme, 'classes'> {
+    classes?: Partial<ThemeClasses<ToggleProps, InternalClasses>>;
+}
+declare const theme: InternalTheme;
+export default theme;