@dv.net/ui-kit 1.0.0

package/dist/components/UiTable/UiTable.vue.d.ts

@@ -0,0 +1,64 @@
+import { UiPaginationMeta } from '../UiPagination/types.ts';
+import { UiTableProps, UiTableSortObject } from './types.ts';
+declare const _default: <Selected, Expanded, Data>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:disabled"?: ((value: Selected[]) => any) | undefined;
+        readonly "onUpdate:selected"?: ((value: Selected[]) => any) | undefined;
+        readonly "onUpdate:expanded"?: ((value: Expanded[]) => any) | undefined;
+        readonly "onUpdate:sort"?: ((value: UiTableSortObject) => any) | undefined;
+        readonly onSortChange?: ((value: UiTableSortObject) => any) | undefined;
+        readonly onRowClick?: ((row: Data) => any) | undefined;
+        readonly onChangePagination?: ((value: UiPaginationMeta) => any) | undefined;
+        readonly onIndeterminateChange?: ((value: boolean) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:disabled" | "onUpdate:selected" | "onUpdate:expanded" | "onUpdate:sort" | "onSortChange" | "onRowClick" | "onChangePagination" | "onIndeterminateChange"> & ({
+        disabled?: Selected[];
+        selected?: Selected[];
+        expanded?: Expanded[];
+        sort?: UiTableSortObject;
+    } & UiTableProps<Data>) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Partial<Record<`header-cell-${string}`, (_: {
+        title: string | undefined;
+        header: import('./types.ts').UiTableHeader<Data>;
+    }) => any>> & Partial<Record<`header-cell-${string}-prepend`, (_: {}) => any>> & Partial<Record<`header-cell-${string}-append`, (_: {}) => any>> & Partial<Record<number, (_: {
+        key: number;
+        summary: number | "N/A";
+    }) => any>> & Partial<Record<`body-cell-${string}`, (_: {
+        row: Data;
+        index: number;
+    }) => any>> & Partial<Record<number, (_: {
+        key: number;
+        summary: number | "N/A";
+    }) => any>> & {
+        header?(_: {
+            headers: import('./types.ts').UiTableHeader<Data>[];
+        }): any;
+        'header-cell'?(_: {
+            title: string | undefined;
+            header: import('./types.ts').UiTableHeader<Data>;
+        }): any;
+        body?(_: {
+            row: Data;
+            headers: import('./types.ts').UiTableHeader<Data>[];
+            index: number;
+        }): any;
+        'body-cell'?(_: {
+            row: Data;
+            header: import('./types.ts').UiTableHeader<Data>;
+            index: number;
+        }): any;
+        expande?(_: {
+            row: Data;
+            index: number;
+        }): any;
+        footer?(_: {}): any;
+    };
+    emit: (((evt: "sortChange", value: UiTableSortObject) => void) & ((evt: "rowClick", row: Data) => void) & ((evt: "changePagination", value: UiPaginationMeta) => void) & ((evt: "indeterminateChange", value: boolean) => void)) & (((evt: "update:disabled", value: Selected[]) => void) & ((evt: "update:selected", value: Selected[]) => void) & ((evt: "update:expanded", value: Expanded[]) => void) & ((evt: "update:sort", value: UiTableSortObject) => void));
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/UiTable/components/TableSort.js

@@ -0,0 +1,5 @@
+import { _ as m } from "../../../chunks/TableSort.vue_vue_type_script_setup_true_lang-DOlNv552.js";
+import "../../../chunks/style-CD0jFgS4.js";
+export {
+  m as default
+};

package/dist/components/UiTable/components/TableSort.vue.d.ts

@@ -0,0 +1,27 @@
+import { UiTableSortOrder } from '../types.ts';
+type __VLS_PublicProps = {
+    modelValue?: UiTableSortOrder;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    sort: (...args: any[]) => void;
+    "update:modelValue": (value: UiTableSortOrder) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSort?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: UiTableSortOrder) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/UiTable/components/TableSummary.js

@@ -0,0 +1,4 @@
+import { _ as f } from "../../../chunks/TableSummary.vue_vue_type_script_setup_true_lang-9VfVgUTT.js";
+export {
+  f as default
+};

package/dist/components/UiTable/components/TableSummary.vue.d.ts

@@ -0,0 +1,26 @@
+import { PreparedData, UiTableHeader } from '../types.ts';
+declare const _default: <Data>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & {
+        emptyValue: string | boolean;
+        loading?: boolean;
+        headers: UiTableHeader<Data>[];
+        preparedData: PreparedData<Data>[];
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Partial<Record<`summary-cell-${string}`, (_: {
+        summary: string | number;
+    }) => any>> & {
+        'summary-cell'?(_: {
+            index: number;
+            header: UiTableHeader<Data>;
+        }): any;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/UiTable/composables/useExpande.d.ts

@@ -0,0 +1,6 @@
+import { ComputedRef, Ref } from 'vue';
+import { PreparedData } from '../types.ts';
+export declare function useExpande<T>(data: ComputedRef<PreparedData<T>[]>, expandeModel: Ref<unknown[]>, expandeKey: string | undefined): {
+    expandeRow: (id: string, value: boolean) => void;
+    expandeObj: Ref<{}, {}>;
+};

package/dist/components/UiTable/composables/useExpande.js

@@ -0,0 +1,21 @@
+import { ref as s } from "vue";
+function c(n, u, i) {
+  const v = s({});
+  function e(r, f) {
+    if (i) {
+      const t = n.value.find((l) => l.id === r)?.row;
+      t && (u.value.includes(t[i]) ? u.value = u.value.filter((l) => l !== t[i]) : u.value = [...u.value, t[i]]);
+    } else
+      v.value[r] = f, o();
+  }
+  function o() {
+    u.value = n.value.reduce((r, f) => v.value[f.id] ? [...r, f.row] : r, []);
+  }
+  return {
+    expandeRow: e,
+    expandeObj: v
+  };
+}
+export {
+  c as useExpande
+};

package/dist/components/UiTable/composables/useSelected.d.ts

@@ -0,0 +1,9 @@
+import { ComputedRef, Ref } from 'vue';
+import { PreparedData } from '../types.ts';
+export declare function useSelected<T>(data: ComputedRef<PreparedData<T>[]>, selectedModel: Ref<unknown[]>, selectedKey: string | undefined): {
+    isAllSelected: ComputedRef<boolean>;
+    isIndeterminate: ComputedRef<boolean>;
+    selectRow: (id: string, value: boolean) => void;
+    selectAll: (value: boolean) => void;
+    selectedObject: Ref<{}, {}>;
+};

package/dist/components/UiTable/composables/useSelected.js

@@ -0,0 +1,30 @@
+import { ref as g, computed as t } from "vue";
+function S(n, v, r) {
+  const i = g({}), a = t(() => r ? v.value.length === n.value.length : n.value.every((u) => !!i.value[u.id])), m = t(() => r ? v.value.length > 0 && !a.value : n.value.some((u) => !!i.value[u.id]) && n.value.some((u) => !i.value[u.id]));
+  function p(u, l) {
+    if (r) {
+      const e = n.value.find((f) => f.id === u)?.row;
+      e && (v.value.includes(e[r]) ? v.value = v.value.filter((f) => f !== e[r]) : v.value = [...v.value, e[r]]);
+    } else
+      i.value[u] = l, o();
+  }
+  function w(u) {
+    r ? a.value ? v.value = [] : v.value = n.value.map((l) => l.row[r]) : (u ? i.value = n.value.reduce((l, e) => ({
+      ...l,
+      [e.id]: !0
+    }), {}) : i.value = {}, o());
+  }
+  function o() {
+    v.value = n.value.reduce((u, l) => i.value[l.id] ? [...u, l.row] : u, []);
+  }
+  return {
+    isAllSelected: a,
+    isIndeterminate: m,
+    selectRow: p,
+    selectAll: w,
+    selectedObject: i
+  };
+}
+export {
+  S as useSelected
+};

package/dist/components/UiTable/composables/useSort.d.ts

@@ -0,0 +1,9 @@
+import { ComputedRef, Ref } from 'vue';
+import { PreparedData, UiTableHeader, UiTableSortObject } from '../types';
+export declare function useSort<T>(preparedData: ComputedRef<PreparedData<T>[]>, sortObject: Ref<UiTableSortObject>, emptyValue: string | boolean, headers: UiTableHeader<T>[]): {
+    isCustomSortMode: Ref<boolean, boolean>;
+    sortedData: ComputedRef<PreparedData<T>[]>;
+    sortObject: Ref<UiTableSortObject, UiTableSortObject>;
+    isSorting: Ref<boolean, boolean>;
+    sort: ({ name, order }: UiTableSortObject, isCustomSort: boolean) => void;
+};

package/dist/components/UiTable/composables/useSort.js

@@ -0,0 +1,34 @@
+import { ref as d, computed as h } from "vue";
+import { getValueByHeaderName as N } from "../helpers/getValueByHeaderName.js";
+function x(i, e, m, g) {
+  const u = d(!1), S = d(!1), b = h(() => {
+    if (e.value.order && !u.value) {
+      const t = e.value.name && g.find((r) => r.name === e.value.name)?.isNumberSort;
+      return i.value.toSorted((r, a) => {
+        const o = N(r.row, e.value.name ?? "", m), n = N(a.row, e.value.name ?? "", m), s = typeof o == "string" && typeof n == "string", F = typeof o == "number" && typeof n == "number", T = typeof o == "boolean" && typeof n == "boolean", f = e.value.order === "asc";
+        function l(c, p) {
+          const v = t && s ? parseFloat(c) : c, y = t && s ? parseFloat(p) : p;
+          return v < y ? f ? -1 : 1 : v > y ? f ? 1 : -1 : 0;
+        }
+        return s || F ? l(o, n) : T ? l(Number(o), Number(n)) : 0;
+      });
+    }
+    return i.value;
+  });
+  function V({ name: t, order: r }, a) {
+    e.value = {
+      name: t,
+      order: r
+    }, u.value = a;
+  }
+  return {
+    isCustomSortMode: u,
+    sortedData: b,
+    sortObject: e,
+    isSorting: S,
+    sort: V
+  };
+}
+export {
+  x as useSort
+};

package/dist/components/UiTable/helpers/getValueByHeaderName.d.ts

@@ -0,0 +1 @@
+export declare function getValueByHeaderName<T>(obj: T, path: string, emptyValue: string | boolean): T;

package/dist/components/UiTable/helpers/getValueByHeaderName.js

@@ -0,0 +1,6 @@
+function s(t, i, r) {
+  return i.split(".").reduce((e, n) => e !== null && typeof e == "object" && n in e ? e[n] ?? (r === !1 ? String(e[n]) : r) : r, t);
+}
+export {
+  s as getValueByHeaderName
+};

package/dist/components/UiTable/types.d.ts

@@ -0,0 +1,58 @@
+export type UiTableSortOrder = "asc" | "desc" | null;
+export type UiTableColumnAlign = "left" | "center" | "right";
+export type SummaryPosition = "top" | "bottom";
+export interface UItableMeta {
+    page: number;
+    perPage: number;
+    total?: number;
+    nextPageExists?: boolean;
+}
+export interface SummarySlotData {
+    key: number;
+    summary: number | "N/A";
+}
+export interface UiTableSortObject {
+    name: string | null;
+    order: UiTableSortOrder;
+}
+export type PreparedData<Data> = {
+    id: string;
+    row: Data;
+};
+export interface UiTableHeader<T = unknown> {
+    align?: UiTableColumnAlign;
+    label?: string;
+    format?: (row: T) => unknown;
+    sort?: () => number;
+    summary?: (summary: number | string) => unknown;
+    width?: string;
+    name?: string;
+    sortable?: boolean | "custom";
+    selection?: boolean;
+    expande?: boolean | ((row: T) => boolean);
+    isShow?: boolean;
+    sortName?: string;
+    columnClass?: (row: T, headerName?: string) => string;
+    isNumberSort?: boolean;
+    colspan?: number;
+}
+export interface UiTableProps<T> {
+    data: T[];
+    headers: UiTableHeader<T>[];
+    rowClass?: (row: T) => string;
+    tableLayout?: "auto" | "fixed";
+    loading?: boolean;
+    selectedKey?: string;
+    expandeKey?: string;
+    disabledKey?: string;
+    rowKey?: string;
+    keyPerPagPagination?: string;
+    skeletonRows?: number;
+    showSummary?: boolean;
+    meta?: UItableMeta | null;
+    emptyValue?: boolean | string;
+    highlightRow?: "odd" | "even";
+    isShowPerPageSelect?: boolean;
+    summaryPosition?: SummaryPosition;
+    isShowAlwaysPagination?: boolean;
+}

package/dist/components/UiTable/types.js

@@ -0,0 +1 @@
+

package/dist/components/UiTabs/UiTabs.js

@@ -0,0 +1,5 @@
+import { _ as m } from "../../chunks/UiTabs.vue_vue_type_script_setup_true_lang-Cl2uvELZ.js";
+/* empty css                                                           */
+export {
+  m as default
+};

package/dist/components/UiTabs/UiTabs.vue.d.ts

@@ -0,0 +1,32 @@
+import { UiTabsProps } from './types';
+type __VLS_Props = UiTabsProps;
+type __VLS_PublicProps = {
+    modelValue?: string;
+    'modelModifiers'?: Partial<Record<number, true>>;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+    "update:modelValue": (value: string) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onChange?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: import('./types').UiTabsSize;
+    mode: import('./types').UiTabsMode;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/UiTabs/constants.d.ts

@@ -0,0 +1 @@
+export declare const TABS_PROVIDE_VALUE: unique symbol;

package/dist/components/UiTabs/constants.js

@@ -0,0 +1,4 @@
+const o = Symbol();
+export {
+  o as TABS_PROVIDE_VALUE
+};

package/dist/components/UiTabs/types.d.ts

@@ -0,0 +1,17 @@
+import { Ref } from 'vue';
+export type UiTabsSize = "md" | "lg";
+export type UiTabsMode = "outline" | "light" | "dark" | "clear";
+export interface UiTabsProps {
+    modelValue: string;
+    size?: UiTabsSize;
+    mode?: UiTabsMode;
+    router?: boolean;
+    isShort?: boolean;
+}
+export interface UiTabsProvideData {
+    modelValue: Ref<string | number>;
+    size?: UiTabsSize;
+    mode?: UiTabsMode;
+    router: boolean;
+    change: (tab: string | number) => void;
+}

package/dist/components/UiTabs/types.js

@@ -0,0 +1 @@
+

package/dist/components/UiTabsItem/UiTabsItem.js

@@ -0,0 +1,5 @@
+import { _ as m } from "../../chunks/UiTabsItem.vue_vue_type_script_setup_true_lang-XvsBaqkr.js";
+/* empty css                                                               */
+export {
+  m as default
+};

package/dist/components/UiTabsItem/UiTabsItem.vue.d.ts

@@ -0,0 +1,18 @@
+import { UiTabsItemProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<UiTabsItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UiTabsItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/UiTabsItem/types.d.ts

@@ -0,0 +1,4 @@
+export interface UiTabsItemProps {
+    value: string | number;
+    badge?: string | number;
+}

package/dist/components/UiTabsItem/types.js

@@ -0,0 +1 @@
+

package/dist/components/UiTag/UiTag.js

@@ -0,0 +1,22 @@
+import { defineComponent as t, createElementBlock as o, openBlock as a, normalizeClass as s, createElementVNode as n, toDisplayString as r } from "vue";
+/* empty css                                                                          */
+import { _ as i } from "../../chunks/_plugin-vue_export-helper-CHgC5LLL.js";
+const p = { class: "ui-tag__text" }, l = /* @__PURE__ */ t({
+  __name: "UiTag",
+  props: {
+    size: { default: "md" },
+    mode: { default: "neutral" },
+    text: { default: "" },
+    pointer: { type: Boolean, default: !1 }
+  },
+  setup(d) {
+    return (e, m) => (a(), o("div", {
+      class: s(["ui-tag", [e.size, e.mode, { pointer: e.pointer }]])
+    }, [
+      n("span", p, r(e.text), 1)
+    ], 2));
+  }
+}), u = /* @__PURE__ */ i(l, [["__scopeId", "data-v-5862d48a"]]);
+export {
+  u as default
+};

package/dist/components/UiTag/UiTag.vue.d.ts

@@ -0,0 +1,8 @@
+import { UiTagProps } from './types.ts';
+declare const _default: import('vue').DefineComponent<UiTagProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UiTagProps> & Readonly<{}>, {
+    size: import('./types.ts').UiTagSize;
+    text: string;
+    mode: import('./types.ts').UiTagMode;
+    pointer: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/UiTag/types.d.ts

@@ -0,0 +1,8 @@
+export type UiTagSize = "sm" | "md" | "lg";
+export type UiTagMode = "positive" | "warning" | "negative" | "accent" | "neutral";
+export interface UiTagProps {
+    size?: UiTagSize;
+    mode?: UiTagMode;
+    text?: string;
+    pointer?: boolean;
+}

package/dist/components/UiTag/types.js

@@ -0,0 +1 @@
+

package/dist/components/UiTextarea/UiTextarea.js

@@ -0,0 +1,5 @@
+import { _ as m } from "../../chunks/UiTextarea.vue_vue_type_script_setup_true_lang-DfTIMM0c.js";
+/* empty css                                                               */
+export {
+  m as default
+};

package/dist/components/UiTextarea/UiTextarea.vue.d.ts

@@ -0,0 +1,51 @@
+import { UiTextareaProps } from './type.ts';
+type __VLS_Props = UiTextareaProps;
+type __VLS_PublicProps = {
+    modelValue?: string | null;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        prepend?(_: {}): any;
+        append?(_: {}): any;
+        placeholder?(_: {}): any;
+    };
+    refs: {
+        textareaRef: HTMLTextAreaElement;
+    };
+    rootEl: HTMLLabelElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    focus: () => any;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    input: (...args: any[]) => void;
+    change: (...args: any[]) => void;
+    focus: (...args: any[]) => void;
+    blur: (...args: any[]) => void;
+    "update:modelValue": (value: string | null) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onInput?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | null) => any) | undefined;
+    onChange?: ((...args: any[]) => any) | undefined;
+    onFocus?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: import('./type.ts').UiTextareaSize;
+    placeholder: string;
+    label: string;
+    filled: boolean;
+    disabled: boolean;
+    copy: boolean;
+    error: boolean;
+    rows: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    textareaRef: HTMLTextAreaElement;
+}, HTMLLabelElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/UiTextarea/type.d.ts

@@ -0,0 +1,16 @@
+export type UiTextareaSize = "md" | "lg" | "auto";
+export interface UiTextareaProps {
+    maxLength?: string;
+    isDisabled?: boolean;
+    placeholder?: string;
+    label?: string;
+    size?: UiTextareaSize;
+    filled?: boolean;
+    error?: boolean;
+    disabled?: boolean;
+    isEmptyValueNull?: boolean;
+    copy?: boolean;
+    id?: string;
+    readonly?: boolean;
+    rows?: number;
+}

package/dist/components/UiTextarea/type.js

@@ -0,0 +1 @@
+

package/dist/components/UiTooltip/UiTooltip.js

@@ -0,0 +1,5 @@
+import { _ as m } from "../../chunks/UiTooltip.vue_vue_type_script_setup_true_lang-D_zaCBDd.js";
+import "../../chunks/style-CD0jFgS4.js";
+export {
+  m as default
+};

package/dist/components/UiTooltip/UiTooltip.vue.d.ts

@@ -0,0 +1,51 @@
+import { UiTooltipProps } from './types';
+type __VLS_Props = UiTooltipProps;
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        title?(_: {}): any;
+        text?(_: {}): any;
+        append?(_: {}): any;
+    };
+    refs: {
+        triggerRefer: HTMLDivElement;
+        contentRefer: HTMLDivElement;
+        arrowRefer: SVGSVGElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+    click: (args_0: void) => any;
+    close: (args_0: void) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onClick?: ((args_0?: void | undefined) => any) | undefined;
+    onClose?: ((args_0?: void | undefined) => any) | undefined;
+}>, {
+    title: string;
+    text: string;
+    disabled: boolean;
+    popperClass: string;
+    position: import('./types').UiPlacementType;
+    showEvent: import('./types').UiTooltipShowEvent;
+    timeout: number;
+    teleport: string | boolean;
+    tabindex: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    triggerRefer: HTMLDivElement;
+    contentRefer: HTMLDivElement;
+    arrowRefer: SVGSVGElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/UiTooltip/types.d.ts

@@ -0,0 +1,14 @@
+export type UiTooltipShowEvent = "click" | "hover";
+export type UiPlacementType = 'top' | 'top-start' | 'top-end' | 'right' | 'right-start' | 'right-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end';
+export interface UiTooltipProps {
+    position?: UiPlacementType;
+    title?: string;
+    text?: string;
+    showEvent?: UiTooltipShowEvent;
+    disabled?: boolean;
+    popperClass?: string;
+    timeout?: number;
+    teleport?: string | boolean;
+    isShowIconClose?: boolean;
+    tabindex?: number;
+}

package/dist/components/UiTooltip/types.js

@@ -0,0 +1 @@
+

package/dist/composables/useBreakpoints.d.ts

@@ -0,0 +1,5 @@
+export declare function useBreakpoints(): {
+    isTablet: import('vue').Ref<boolean, boolean>;
+    isMobile: import('vue').Ref<boolean, boolean>;
+    isDesktop: import('vue').Ref<boolean, boolean>;
+};