vlite3 1.2.16 → 1.2.17

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 m = /* @__PURE__ */ r(o, [["__scopeId", "data-v-2d3c51df"]]);
 export {
-  f as default
+  m as default
 };

package/components/Carousel/Carousel.vue2.js

@@ -1,35 +1,43 @@
-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: 700 },
     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: 10 },
+    paginationHoverInitialTimeout: { default: 500 },
+    wheelOptions: { default: () => ({
+      threshold: 5,
+      velocityThreshold: 0.5,
+      pageScrollThreshold: 0.1,
+      debounceTime: 50
+    }) },
     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);
-    return n({
+  setup(n, { expose: r, emit: i }) {
+    const s = n, u = i, o = g(null);
+    return r({
       goToSlide: (e, t) => {
         o.value?.goToSlide(e, t);
       },
@@ -45,18 +53,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/FadeOverlay.vue.d.ts

@@ -0,0 +1,31 @@
+export interface FadeOverlayProps {
+    /** Which edge to fade toward */
+    direction?: 'top' | 'bottom' | 'left' | 'right';
+    /** How much of the container the overlay covers */
+    coverage?: string | number;
+    /** Where the transparent part of the gradient starts (0% = edge of overlay) */
+    fadeStart?: string | number;
+    /** Where the opaque/masked part of the gradient ends (100% = full coverage end) */
+    fadeEnd?: string | number;
+    /**
+     * Blur amount for a frosted-glass effect.
+     * true → 8px, a number → px, a string → used as-is (e.g. "12px")
+     */
+    blur?: boolean | string | number;
+    /** CSS mix-blend-mode */
+    blendMode?: 'normal' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 'hue' | 'saturation' | 'color' | 'luminosity';
+    /** Overall opacity of the overlay (0–1) */
+    opacity?: string | number;
+    /** CSS z-index */
+    zIndex?: string | number;
+    /** Solid/gradient color. Defaults to the page background color. */
+    color?: string;
+}
+declare const _default: import('vue').DefineComponent<FadeOverlayProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FadeOverlayProps> & Readonly<{}>, {
+    color: string;
+    direction: "top" | "bottom" | "left" | "right";
+    coverage: string | number;
+    fadeStart: string | number;
+    fadeEnd: string | number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/components/FadeOverlay.vue.js

@@ -0,0 +1,55 @@
+import { defineComponent as f, computed as i, openBlock as m, createElementBlock as g, normalizeStyle as v } from "vue";
+const $ = /* @__PURE__ */ f({
+  __name: "FadeOverlay",
+  props: {
+    direction: { default: "bottom" },
+    coverage: { default: "20%" },
+    fadeStart: { default: "0%" },
+    fadeEnd: { default: "100%" },
+    blur: { type: [Boolean, String, Number] },
+    blendMode: {},
+    opacity: {},
+    zIndex: {},
+    color: { default: "var(--color-background)" }
+  },
+  setup(c) {
+    const e = c, t = i(() => e.blur ? e.blur === !0 ? "8px" : typeof e.blur == "number" ? `${e.blur}px` : e.blur : ""), u = i(() => {
+      const o = typeof e.coverage == "number" ? `${e.coverage}%` : e.coverage, r = typeof e.fadeStart == "number" ? `${e.fadeStart}%` : e.fadeStart, n = typeof e.fadeEnd == "number" ? `${e.fadeEnd}%` : e.fadeEnd, a = {
+        top: "to top",
+        bottom: "to bottom",
+        left: "to left",
+        right: "to right"
+      }[e.direction] || "to bottom", b = e.direction === "top" || e.direction === "bottom" ? { left: 0, right: 0, height: o, [e.direction]: 0 } : { top: 0, bottom: 0, width: o, [e.direction]: 0 }, d = {
+        position: "absolute",
+        pointerEvents: "none",
+        opacity: e.opacity ?? 1,
+        zIndex: e.zIndex ?? 10,
+        ...e.blendMode ? { mixBlendMode: e.blendMode } : {},
+        ...b
+      };
+      if (t.value) {
+        const l = `linear-gradient(${a}, transparent ${r}, black ${n})`, p = e.color === "var(--color-background)" ? "color-mix(in srgb, var(--color-background) 60%, transparent)" : e.color;
+        return {
+          ...d,
+          background: p,
+          backdropFilter: `blur(${t.value})`,
+          WebkitBackdropFilter: `blur(${t.value})`,
+          maskImage: l,
+          WebkitMaskImage: l
+        };
+      }
+      const s = `linear-gradient(${a}, transparent ${r}, ${e.color} ${n})`;
+      return {
+        ...d,
+        background: s
+      };
+    });
+    return (o, r) => (m(), g("div", {
+      style: v(u.value),
+      "aria-hidden": "true"
+    }, null, 4));
+  }
+});
+export {
+  $ as default
+};

package/components/FadeOverlay.vue2.js

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

package/components/Workbook/WorkbookAddButton.vue.js

@@ -5,7 +5,7 @@ const _ = /* @__PURE__ */ l({
   __name: "WorkbookAddButton",
   emits: ["click"],
   setup(a, { emit: o }) {
-    const n = o, i = c(() => {
+    const r = o, n = c(() => {
       const t = u("vlite.workbook.addSheet");
       return t !== "vlite.workbook.addSheet" ? t : "Add New Sheet";
     });
@@ -13,10 +13,10 @@ const _ = /* @__PURE__ */ l({
       variant: "ghost",
       size: "md",
       icon: "lucide:plus",
-      title: i.value,
+      title: n.value,
       rounded: "none",
-      class: "h-full!",
-      onClick: e[0] || (e[0] = (r) => n("click", r))
+      class: "h-full! hover:bg-gray-250!",
+      onClick: e[0] || (e[0] = (i) => r("click", i))
     }, null, 8, ["title"]));
   }
 });

package/index.d.ts

@@ -77,6 +77,7 @@ export { default as CheckBox } from './components/CheckBox.vue';
 export { default as Textarea } from './components/Textarea.vue';
 export { default as Radio } from './components/Radio.vue';
 export { default as RadioGroup } from './components/RadioGroup.vue';
+export { default as FadeOverlay } from './components/FadeOverlay.vue';
 export { default as SidePanel } from './components/SidePanel.vue';
 export { default as DatePicker } from './components/DatePicker.vue';
 export { default as IconPicker } from './components/IconPicker.vue';