vlite3 1.2.16 → 1.3.1

package/components/Carousel/Carousel.vue.js

@@ -1,7 +1,7 @@
 import o from "./Carousel.vue2.js";
 /* empty css              */
 import r from "../../_virtual/_plugin-vue_export-helper.js";
-const f = /* @__PURE__ */ r(o, [["__scopeId", "data-v-e8fba320"]]);
+const p = /* @__PURE__ */ r(o, [["__scopeId", "data-v-4d544a95"]]);
 export {
-  f as default
+  p as default
 };

package/components/Carousel/Carousel.vue2.js

@@ -1,34 +1,44 @@
-import { defineComponent as g, shallowRef as f, openBlock as p, createElementBlock as m, createVNode as c, unref as v, mergeProps as P, createSlots as h, renderList as y, withCtx as S, renderSlot as x, normalizeProps as B, guardReactiveProps as N } from "vue";
-import _ from "vue-carousel-lite";
+import { defineComponent as f, shallowRef as g, openBlock as p, createElementBlock as c, createVNode as m, unref as h, mergeProps as v, createSlots as P, renderList as y, withCtx as S, renderSlot as B, normalizeProps as x, guardReactiveProps as T } from "vue";
+import w from "vue-carousel-lite";
 import "vue-carousel-lite/style.css";
-const w = { class: "carousel-wrapper" }, V = /* @__PURE__ */ g({
+const N = { class: "carousel-wrapper" }, V = /* @__PURE__ */ f({
   __name: "Carousel",
   props: {
     data: { default: () => [] },
-    pagination: { type: [String, Array, Boolean], default: "dots" },
-    paginationSize: { default: "sm" },
-    paginationPosition: { default: "bottom-center" },
-    paginationVisibility: {},
-    paginationHoverInitialTimeout: {},
-    paginationHoverEdgeThreshold: {},
-    direction: { default: "horizontal" },
-    autoPlay: { type: Boolean, default: !1 },
-    draggable: { type: Boolean, default: !1 },
-    autoPlayInterval: { default: 3e3 },
-    itemsToShow: { default: 1 },
     gap: { default: 0 },
-    speed: { default: 300 },
+    loop: { type: Boolean, default: !1 },
+    speed: { default: 850 },
     easing: { default: "ease" },
+    autoPlay: { type: Boolean, default: !1 },
+    draggable: { type: Boolean, default: !1 },
     mousewheel: { type: Boolean, default: !0 },
-    loop: { type: Boolean, default: !1 },
+    autoFocus: { type: Boolean, default: !1 },
+    autoPlayInterval: { default: 3e3 },
     currentItem: { default: 0 },
+    paginationBackground: { type: Boolean, default: !1 },
+    paginationSize: { default: "sm" },
+    itemsToShow: { default: 1 },
+    direction: { default: "horizontal" },
+    pagination: { type: [String, Boolean, Array], default: "dots" },
+    paginationPosition: { default: "bottom-center" },
+    paginationVisibility: { default: "always" },
+    paginationHoverEdgeThreshold: { default: 0.2 },
+    paginationHoverInitialTimeout: { default: 1e3 },
+    wheelOptions: { default: () => ({
+      threshold: 10,
+      velocityThreshold: 8,
+      pageScrollThreshold: 80,
+      debounceTime: 5,
+      preventDefault: !0,
+      stopPropagation: !0
+    }) },
     bufferSize: { default: 5 },
     maxDomElements: { default: 10 },
     updateKey: { default: void 0 }
   },
   emits: ["slide-change"],
   setup(r, { expose: n, emit: i }) {
-    const s = r, u = i, o = f(null);
+    const s = r, u = i, o = g(null);
     return n({
       goToSlide: (e, t) => {
         o.value?.goToSlide(e, t);
@@ -45,18 +55,18 @@ const w = { class: "carousel-wrapper" }, V = /* @__PURE__ */ g({
       goPrevPage: (e) => {
         o.value?.goPrevPage(e);
       }
-    }), (e, t) => (p(), m("div", w, [
-      c(v(_), P({
+    }), (e, t) => (p(), c("div", N, [
+      m(h(w), v({
         ref_key: "carouselRef",
         ref: o
       }, s, {
         style: { height: "100%", width: "100%" },
         onSlideChange: t[0] || (t[0] = (a) => u("slide-change", a))
-      }), h({ _: 2 }, [
+      }), P({ _: 2 }, [
         y(e.$slots, (a, l) => ({
           name: l,
           fn: S((d) => [
-            x(e.$slots, l, B(N(d || {})), void 0, !0)
+            B(e.$slots, l, x(T(d || {})), void 0, !0)
           ])
         }))
       ]), 1040)

package/components/Carousel/types.d.ts

@@ -1,24 +1,86 @@
+import { ComputedRef } from 'vue';
+export interface SlidesPerView {
+    [key: number]: number;
+}
+export type PaginationType = 'buttons' | 'dots' | 'lines' | 'fraction' | false;
+export type PaginationPosition = 'center' | 'bottom-center' | 'bottom-left' | 'bottom-right' | 'center-right' | 'bottom';
+export type PaginationVisibility = 'always' | 'hover';
+export interface WheelOptions {
+    threshold?: number;
+    velocityThreshold?: number;
+    pageScrollThreshold?: number;
+    debounceTime?: number;
+}
 export interface CarouselProps {
-    data?: any[];
-    pagination?: string | string[] | boolean;
-    paginationSize?: 'sm' | 'md' | 'lg';
-    paginationPosition?: string | string[];
-    paginationVisibility?: string | string[];
-    paginationHoverInitialTimeout?: number;
-    paginationHoverEdgeThreshold?: number;
-    direction?: 'horizontal' | 'vertical';
-    autoPlay?: boolean;
-    draggable?: boolean;
-    autoPlayInterval?: number;
-    itemsToShow?: number | Record<number, number>;
+    data: any[];
     gap?: number;
+    loop?: boolean;
     speed?: number;
     easing?: string;
+    autoPlay?: boolean;
+    draggable?: boolean;
     mousewheel?: boolean;
-    loop?: boolean;
+    autoFocus?: boolean;
+    autoPlayInterval?: number;
     currentItem?: number;
+    paginationBackground?: boolean;
+    paginationSize?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    itemsToShow?: number | SlidesPerView;
+    direction?: 'horizontal' | 'vertical';
+    pagination?: PaginationType | PaginationType[];
+    paginationPosition?: PaginationPosition | PaginationPosition[];
+    paginationVisibility?: PaginationVisibility | PaginationVisibility[];
+    paginationHoverEdgeThreshold?: number;
+    paginationHoverInitialTimeout?: number;
+    wheelOptions?: WheelOptions;
     bufferSize?: number;
     maxDomElements?: number;
     updateKey?: string | number;
-    [key: string]: any;
+}
+export interface CarouselState {
+    currentIndex: number;
+    isTransitioning: boolean;
+    isDragging: boolean;
+    isHovered: boolean;
+    isWheeling: boolean;
+}
+export interface CarouselMethods {
+    goNext: (smooth?: boolean) => void;
+    goPrev: (smooth?: boolean) => void;
+    goNextPage: (smooth?: boolean) => void;
+    goPrevPage: (smooth?: boolean) => void;
+    goToSlide: (index: number, smooth?: boolean) => void;
+}
+export interface CarouselExposedMethods extends CarouselMethods {
+    state: Readonly<CarouselState>;
+    canGoNext: ComputedRef<boolean>;
+    canGoPrev: ComputedRef<boolean>;
+}
+export interface DragState {
+    startX: number;
+    startY: number;
+    deltaX: number;
+    deltaY: number;
+    isDragging: boolean;
+    currentX: number;
+    currentY: number;
+    startTime: number;
+}
+export interface CarouselChangeEvent {
+    currentIndex: number;
+    previousIndex: number;
+    direction: 'next' | 'prev';
+}
+export interface CarouselDragEvent {
+    deltaX: number;
+    deltaY: number;
+    velocity: number;
+    direction: 'horizontal' | 'vertical';
+}
+export interface CarouselBreakpoint {
+    width: number;
+    settings: Partial<CarouselProps>;
+}
+export interface CarouselResponsive {
+    breakpoints: CarouselBreakpoint[];
 }

package/components/CategoryManager/CategoryManager.vue.d.ts

@@ -8,7 +8,13 @@ declare function __VLS_template(): {
     rootEl: HTMLDivElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<CategoryManagerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+declare const __VLS_component: import('vue').DefineComponent<CategoryManagerProps, {
+    expandedIds: import('vue').Ref<Set<string | number>>;
+    expandAll: () => void;
+    collapseAll: () => void;
+    expand: (...ids: (string | number)[]) => void;
+    collapse: (...ids: (string | number)[]) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     onDelete: (item: CategoryItem) => any;
     "update:modelValue": (val: CategoryItem[]) => any;
     onAdd: (item: CategoryItem) => any;
@@ -30,11 +36,13 @@ declare const __VLS_component: import('vue').DefineComponent<CategoryManagerProp
     }) => any;
 }>, {
     size: "sm" | "md" | "lg";
+    loading: boolean;
     readonly: boolean;
     modelValue: CategoryItem[];
     rawData: RawCategoryItem[];
     emptyTitle: string;
     emptyDescription: string;
+    defaultExpanded: (string | number)[];
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;