vlite3 0.3.1 → 0.3.4

package/components/AvatarUploader/AvatarUploader.vue.d.ts

@@ -13,11 +13,11 @@ export interface Props {
     className?: string;
 }
 declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-    "update:modelValue": (value: string) => any;
+    "update:modelValue": (value: any) => any;
     change: (value: FilePickerValue) => any;
     error: (error: string) => any;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
-    "onUpdate:modelValue"?: (value: string) => any;
+    "onUpdate:modelValue"?: (value: any) => any;
     onChange?: (value: FilePickerValue) => any;
     onError?: (error: string) => any;
 }>, {

package/components/AvatarUploader/AvatarUploader.vue.js

@@ -1,8 +1,8 @@
-import { defineComponent as x, ref as w, computed as z, openBlock as n, createElementBlock as o, createElementVNode as b, normalizeClass as l, createVNode as d, withCtx as C, createCommentVNode as f, withModifiers as A } from "vue";
-import u from "../Icon.vue.js";
-import B from "../FilePicker/FilePicker.vue.js";
-import N from "../Avatar.vue.js";
-const E = { class: "inline-block" }, $ = ["onClick"], I = /* @__PURE__ */ x({
+import { defineComponent as x, ref as w, computed as z, openBlock as i, createElementBlock as r, createElementVNode as f, normalizeClass as o, createVNode as n, withCtx as C, createCommentVNode as g, withModifiers as A } from "vue";
+import c from "../Icon.vue.js";
+import U from "../FilePicker/FilePicker.vue.js";
+import V from "../Avatar.vue.js";
+const R = { class: "inline-block" }, j = ["onClick"], F = /* @__PURE__ */ x({
   name: "AvatarUploader",
   __name: "AvatarUploader",
   props: {
@@ -18,82 +18,99 @@ const E = { class: "inline-block" }, $ = ["onClick"], I = /* @__PURE__ */ x({
     className: {}
   },
   emits: ["update:modelValue", "change", "error"],
-  setup(e, { emit: g }) {
-    const v = e, t = g, i = w(null), s = z(() => i.value || v.modelValue), h = (a) => {
+  setup(e, { emit: v }) {
+    const l = e, t = v, d = w(null), m = z(() => {
+      if (d.value) return d.value;
+      if (typeof l.modelValue == "string") return l.modelValue;
+      if (l.modelValue && l.modelValue.base64) return l.modelValue.base64;
+      if (l.modelValue && l.modelValue.file instanceof File)
+        try {
+          return URL.createObjectURL(l.modelValue.file);
+        } catch {
+        }
+      return null;
+    }), h = (a) => {
       if (!a || Array.isArray(a)) {
-        Array.isArray(a) && a.length === 0 && c();
+        Array.isArray(a) && a.length === 0 && b();
         return;
       }
-      a.base64 && (i.value = a.base64, t("update:modelValue", a.base64)), t("change", a);
+      if (a.base64)
+        d.value = a.base64, t("update:modelValue", a.base64);
+      else if (a.file)
+        try {
+          d.value = URL.createObjectURL(a.file), t("update:modelValue", a);
+        } catch {
+        }
+      t("change", a);
     }, y = (a) => {
       t("error", a);
-    }, c = () => {
-      i.value = null, t("update:modelValue", null), t("change", null);
+    }, b = () => {
+      d.value = null, t("update:modelValue", null), t("change", null);
     };
-    return (a, m) => (n(), o("div", E, [
-      b("div", {
-        class: l(["relative inline-block group", e.rounded === "full" ? "rounded-full" : "rounded-md"])
+    return (a, u) => (i(), r("div", R, [
+      f("div", {
+        class: o(["relative inline-block group", e.rounded === "full" ? "rounded-full" : "rounded-md"])
       }, [
-        d(N, {
-          src: s.value || void 0,
+        n(V, {
+          src: m.value || void 0,
           fallback: e.fallback,
           alt: e.alt,
           size: e.size,
           rounded: e.rounded,
-          class: l(e.className)
+          class: o(e.className)
         }, null, 8, ["src", "fallback", "alt", "size", "rounded", "class"]),
-        d(B, {
+        n(U, {
           disabled: !e.editable || e.disabled || e.loading,
           "return-format": "base64",
           "file-types": ["image/jpeg", "image/png", "image/webp", "image/gif"],
           "max-size": e.maxSize,
           class: "absolute inset-0",
-          onChange: m[0] || (m[0] = (r) => h(r)),
+          onChange: u[0] || (u[0] = (s) => h(s)),
           onError: y
         }, {
-          trigger: C(({ trigger: r, isLoading: k }) => [
-            b("button", {
+          trigger: C(({ trigger: s, isLoading: k }) => [
+            f("button", {
               type: "button",
-              class: l(["absolute inset-0 cursor-pointer", { "cursor-default": !e.editable || e.disabled }]),
-              onClick: (j) => e.editable && !e.disabled ? r() : null
+              class: o(["absolute inset-0 cursor-pointer", { "cursor-default": !e.editable || e.disabled }]),
+              onClick: (B) => e.editable && !e.disabled ? s() : null
             }, [
-              e.loading || k ? (n(), o("div", {
+              e.loading || k ? (i(), r("div", {
                 key: 0,
-                class: l(["absolute inset-0 flex items-center justify-center bg-[#7878783b] text-white", e.rounded === "full" ? "rounded-full" : "rounded-md"])
+                class: o(["absolute inset-0 flex items-center justify-center bg-[#7878783b] text-white", e.rounded === "full" ? "rounded-full" : "rounded-md"])
               }, [
-                d(u, {
+                n(c, {
                   icon: "lucide:loader-2",
                   class: "animate-spin w-1/3 h-1/3"
                 })
-              ], 2)) : e.editable && !e.disabled ? (n(), o("div", {
+              ], 2)) : e.editable && !e.disabled ? (i(), r("div", {
                 key: 1,
-                class: l(["absolute inset-0 flex items-center justify-center bg-[#00000051] text-white opacity-0 group-hover:opacity-100 transition-opacity", e.rounded === "full" ? "rounded-full" : "rounded-md"])
+                class: o(["absolute inset-0 flex items-center justify-center bg-[#00000051] text-white opacity-0 group-hover:opacity-100 transition-opacity", e.rounded === "full" ? "rounded-full" : "rounded-md"])
               }, [
-                d(u, {
+                n(c, {
                   icon: "lucide:camera",
                   class: "w-1/3 h-1/3"
                 })
-              ], 2)) : f("", !0)
-            ], 10, $)
+              ], 2)) : g("", !0)
+            ], 10, j)
           ]),
           _: 1
         }, 8, ["disabled", "max-size"]),
-        s.value && e.editable && !e.disabled && !e.loading ? (n(), o("button", {
+        (m.value || e.modelValue) && e.editable && !e.disabled && !e.loading ? (i(), r("button", {
           key: 0,
           type: "button",
           class: "absolute -top-1 -right-1 z-10 p-1 bg-background border border-border rounded-full text-muted-foreground shadow-sm hover:text-destructive hover:border-destructive transition-all opacity-0 group-hover:opacity-100 scale-75 group-hover:scale-100",
-          onClick: A(c, ["stop"]),
+          onClick: A(b, ["stop"]),
           title: "Remove image"
         }, [
-          d(u, {
+          n(c, {
             icon: "lucide:x",
             class: "w-3 h-3"
           })
-        ])) : f("", !0)
+        ])) : g("", !0)
       ], 2)
     ]));
   }
 });
 export {
-  I as default
+  F as default
 };

package/components/DataList/DataList.vue.d.ts

@@ -0,0 +1,47 @@
+import { DataListProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        skeleton?(_: {
+            index: number;
+        }): any;
+        skelton?(_: {
+            index: number;
+        }): any;
+        empty?(_: {}): any;
+        item?(_: {
+            item: any;
+            data: any[];
+            index: number;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DataListProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:itemsPerPage": (limit: number) => any;
+    "page-change": (page: number) => any;
+}, string, import('vue').PublicProps, Readonly<DataListProps> & Readonly<{
+    "onUpdate:itemsPerPage"?: (limit: number) => any;
+    "onPage-change"?: (page: number) => any;
+}>, {
+    data: any[];
+    loading: boolean;
+    className: string;
+    paginationPosition: "start" | "center" | "end" | "between";
+    showItemsPerPage: boolean;
+    itemsPerPageOptions: number[];
+    emptyTitle: string;
+    emptyDescription: string;
+    emptyIcon: string;
+    showPagination: boolean;
+    itemProps: Record<string, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, 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/components/DataList/DataList.vue.js

@@ -0,0 +1,98 @@
+import { defineComponent as b, computed as r, openBlock as t, createElementBlock as n, normalizeClass as c, Fragment as u, renderList as f, renderSlot as l, createBlock as y, resolveDynamicComponent as P, createElementVNode as i, createVNode as h, toDisplayString as k, mergeProps as C, createCommentVNode as p, unref as N } from "vue";
+import B from "../Pagination/Pagination.vue.js";
+import $ from "../Icon.vue.js";
+const D = { class: "flex flex-col w-full" }, V = {
+  key: 1,
+  class: "h-48 rounded-lg bg-gray-200 animate-pulse w-full"
+}, j = {
+  key: 1,
+  class: "flex flex-col items-center justify-center p-12 text-center bg-gray-50 border border-gray-200 rounded-lg"
+}, E = { class: "flex h-12 w-12 items-center justify-center rounded-full bg-gray-100 mb-4" }, L = { class: "text-lg font-semibold text-gray-900" }, O = { class: "mt-2 text-sm text-gray-500" }, S = {
+  key: 3,
+  class: "mt-8"
+}, W = /* @__PURE__ */ b({
+  __name: "DataList",
+  props: {
+    data: { default: () => [] },
+    loading: { type: Boolean, default: !1 },
+    pageInfo: {},
+    className: { default: "grid grid-cols-1 sm:grid-cols-2 md:grid-cols-3 lg:grid-cols-4 gap-6" },
+    item: {},
+    skeleton: {},
+    skelton: {},
+    itemProps: { default: () => ({}) },
+    emptyTitle: { default: "No data found" },
+    emptyDescription: { default: "We could not find any items to display here." },
+    emptyIcon: { default: "lucide:inbox" },
+    showPagination: { type: Boolean, default: !0 },
+    paginationPosition: { default: "between" },
+    itemsPerPageOptions: { default: () => [10, 25, 50, 100] },
+    showItemsPerPage: { type: Boolean, default: !1 }
+  },
+  emits: ["page-change", "update:itemsPerPage"],
+  setup(e, { emit: v }) {
+    const d = e, m = v, w = (a) => {
+      m("page-change", a);
+    }, x = (a) => {
+      m("update:itemsPerPage", a);
+    }, I = r(() => d.pageInfo?.currentPage || 1), g = r(() => d.pageInfo?.totalPages || 1);
+    return (a, T) => (t(), n("div", D, [
+      e.loading ? (t(), n("div", {
+        key: 0,
+        class: c(e.className)
+      }, [
+        (t(), n(u, null, f(8, (s) => l(a.$slots, "skeleton", {
+          key: "skeleton-" + s,
+          index: s
+        }, () => [
+          l(a.$slots, "skelton", { index: s }, () => [
+            e.skeleton || e.skelton ? (t(), y(P(e.skeleton || e.skelton), { key: 0 })) : (t(), n("div", V))
+          ])
+        ])), 64))
+      ], 2)) : !e.data || e.data.length === 0 ? (t(), n("div", j, [
+        l(a.$slots, "empty", {}, () => [
+          i("div", E, [
+            h($, {
+              icon: e.emptyIcon,
+              class: "h-6 w-6 text-gray-500"
+            }, null, 8, ["icon"])
+          ]),
+          i("h3", L, k(e.emptyTitle), 1),
+          i("p", O, k(e.emptyDescription), 1)
+        ])
+      ])) : (t(), n("div", {
+        key: 2,
+        class: c(e.className)
+      }, [
+        (t(!0), n(u, null, f(e.data, (s, o) => l(a.$slots, "item", {
+          key: o,
+          item: s,
+          data: e.data,
+          index: o
+        }, () => [
+          e.item ? (t(), y(P(e.item), C({
+            key: 0,
+            item: s,
+            data: e.data,
+            index: o
+          }, { ref_for: !0 }, e.itemProps), null, 16, ["item", "data", "index"])) : p("", !0)
+        ])), 128))
+      ], 2)),
+      e.showPagination && e.pageInfo && g.value > 1 ? (t(), n("div", S, [
+        h(N(B), {
+          "current-page": I.value,
+          "total-pages": g.value,
+          alignment: e.paginationPosition,
+          "show-items-per-page": e.showItemsPerPage,
+          "items-per-page": e.pageInfo?.itemsPerPage,
+          "items-per-page-options": e.itemsPerPageOptions,
+          onChange: w,
+          "onUpdate:itemsPerPage": x
+        }, null, 8, ["current-page", "total-pages", "alignment", "show-items-per-page", "items-per-page", "items-per-page-options"])
+      ])) : p("", !0)
+    ]));
+  }
+});
+export {
+  W as default
+};

package/components/DataList/DataList.vue2.js

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

package/components/DataList/index.d.ts

@@ -0,0 +1,2 @@
+export { default as DataList } from './DataList.vue';
+export * from './types';

package/components/DataList/types.d.ts

@@ -0,0 +1,23 @@
+export interface DataListPageInfo {
+    currentPage: number;
+    totalPages: number;
+    totalItems?: number;
+    itemsPerPage?: number;
+}
+export interface DataListProps {
+    data?: any[];
+    loading?: boolean;
+    pageInfo?: DataListPageInfo;
+    className?: string;
+    item?: any;
+    skeleton?: any;
+    skelton?: any;
+    itemProps?: Record<string, any>;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    emptyIcon?: string;
+    showPagination?: boolean;
+    paginationPosition?: 'start' | 'center' | 'end' | 'between';
+    itemsPerPageOptions?: number[];
+    showItemsPerPage?: boolean;
+}

package/components/FilePicker/FilePicker.vue.d.ts

@@ -14,6 +14,7 @@ interface Props {
     loading?: boolean;
     disabled?: boolean;
     maxSize?: number;
+    maxFiles?: number;
     variant?: 'dropzone' | 'input';
     placeholder?: string;
     size?: InputSize;