@raxium/vue-addons-swiper 0.1.1

package/dist/Swiper.js

@@ -0,0 +1,481 @@
+import { createElementBlock, createPropsRestProxy, createSlots, createVNode, defineComponent, mergeProps, openBlock, ref, renderSlot, shallowRef, unref, withCtx } from "vue";
+import { cn } from "@raxium/themes/utils";
+import { useForwardPropsEmits } from "@raxium/vue-addons-shared";
+import { Swiper } from "swiper/vue";
+import { useSwiperModule } from "./utils.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    inheritAttrs: false,
+    __name: "Swiper",
+    props: {
+        tag: {},
+        wrapperTag: {},
+        modules: {},
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        injectStyles: {},
+        injectStylesUrls: {},
+        init: {
+            type: Boolean
+        },
+        enabled: {
+            type: Boolean
+        },
+        updateOnWindowResize: {
+            type: Boolean
+        },
+        resizeObserver: {
+            type: Boolean
+        },
+        initialSlide: {},
+        direction: {
+            default: "horizontal"
+        },
+        oneWayMovement: {
+            type: Boolean
+        },
+        swiperElementNodeName: {},
+        speed: {},
+        setWrapperSize: {
+            type: Boolean
+        },
+        virtualTranslate: {
+            type: Boolean
+        },
+        width: {},
+        height: {},
+        autoHeight: {
+            type: Boolean
+        },
+        roundLengths: {
+            type: Boolean
+        },
+        nested: {
+            type: Boolean
+        },
+        createElements: {
+            type: Boolean
+        },
+        eventsPrefix: {},
+        focusableElements: {},
+        uniqueNavElements: {
+            type: Boolean
+        },
+        effect: {},
+        runCallbacksOnInit: {
+            type: Boolean
+        },
+        watchOverflow: {
+            type: Boolean
+        },
+        userAgent: {},
+        url: {},
+        on: {},
+        onAny: {
+            type: Function
+        },
+        cssMode: {
+            type: Boolean
+        },
+        spaceBetween: {},
+        slidesPerView: {},
+        maxBackfaceHiddenSlides: {},
+        slidesPerGroup: {},
+        slidesPerGroupSkip: {},
+        slidesPerGroupAuto: {
+            type: Boolean
+        },
+        centeredSlides: {
+            type: Boolean
+        },
+        centeredSlidesBounds: {
+            type: Boolean
+        },
+        slidesOffsetBefore: {},
+        slidesOffsetAfter: {},
+        normalizeSlideIndex: {
+            type: Boolean
+        },
+        centerInsufficientSlides: {
+            type: Boolean
+        },
+        snapToSlideEdge: {
+            type: Boolean
+        },
+        grabCursor: {
+            type: Boolean
+        },
+        touchEventsTarget: {},
+        touchRatio: {},
+        touchAngle: {},
+        simulateTouch: {
+            type: Boolean
+        },
+        shortSwipes: {
+            type: Boolean
+        },
+        longSwipes: {
+            type: Boolean
+        },
+        longSwipesRatio: {},
+        longSwipesMs: {},
+        followFinger: {
+            type: Boolean
+        },
+        allowTouchMove: {
+            type: Boolean
+        },
+        threshold: {},
+        touchStartPreventDefault: {
+            type: Boolean
+        },
+        touchStartForcePreventDefault: {
+            type: Boolean
+        },
+        touchMoveStopPropagation: {
+            type: Boolean
+        },
+        edgeSwipeDetection: {
+            type: [
+                Boolean,
+                String
+            ]
+        },
+        edgeSwipeThreshold: {},
+        touchReleaseOnEdges: {
+            type: Boolean
+        },
+        passiveListeners: {
+            type: Boolean
+        },
+        resistance: {
+            type: Boolean
+        },
+        resistanceRatio: {},
+        preventInteractionOnTransition: {
+            type: Boolean
+        },
+        allowSlidePrev: {
+            type: Boolean
+        },
+        allowSlideNext: {
+            type: Boolean
+        },
+        noSwiping: {
+            type: Boolean
+        },
+        noSwipingClass: {},
+        noSwipingSelector: {},
+        swipeHandler: {},
+        preventClicks: {
+            type: Boolean
+        },
+        preventClicksPropagation: {
+            type: Boolean
+        },
+        slideToClickedSlide: {
+            type: Boolean
+        },
+        watchSlidesProgress: {
+            type: Boolean
+        },
+        loop: {
+            type: Boolean
+        },
+        loopAddBlankSlides: {
+            type: Boolean
+        },
+        loopAdditionalSlides: {},
+        loopPreventsSliding: {
+            type: Boolean
+        },
+        rewind: {
+            type: Boolean
+        },
+        breakpoints: {},
+        breakpointsBase: {},
+        observer: {
+            type: Boolean
+        },
+        observeSlideChildren: {
+            type: Boolean
+        },
+        observeParents: {
+            type: Boolean
+        },
+        containerModifierClass: {},
+        slideClass: {},
+        slideActiveClass: {},
+        slideVisibleClass: {},
+        slideFullyVisibleClass: {},
+        slideBlankClass: {},
+        slideNextClass: {},
+        slidePrevClass: {},
+        wrapperClass: {},
+        lazyPreloaderClass: {},
+        lazyPreloadPrevNext: {},
+        a11y: {
+            type: [
+                Object,
+                Boolean
+            ]
+        },
+        autoplay: {
+            type: [
+                Object,
+                Boolean
+            ]
+        },
+        controller: {},
+        coverflowEffect: {},
+        cubeEffect: {},
+        fadeEffect: {},
+        flipEffect: {},
+        creativeEffect: {},
+        cardsEffect: {},
+        hashNavigation: {
+            type: [
+                Object,
+                Boolean
+            ]
+        },
+        history: {
+            type: [
+                Object,
+                Boolean
+            ]
+        },
+        keyboard: {
+            type: [
+                Object,
+                Boolean
+            ]
+        },
+        mousewheel: {
+            type: [
+                Object,
+                Boolean
+            ]
+        },
+        navigation: {
+            type: [
+                Object,
+                Boolean
+            ]
+        },
+        pagination: {
+            type: [
+                Object,
+                Boolean
+            ]
+        },
+        parallax: {
+            type: [
+                Object,
+                Boolean
+            ]
+        },
+        scrollbar: {
+            type: [
+                Object,
+                Boolean
+            ]
+        },
+        thumbs: {},
+        virtual: {
+            type: [
+                Object,
+                Boolean
+            ]
+        },
+        zoom: {
+            type: [
+                Object,
+                Boolean
+            ]
+        },
+        freeMode: {
+            type: [
+                Object,
+                Boolean
+            ]
+        },
+        grid: {},
+        _emitClasses: {
+            type: Boolean
+        }
+    },
+    emits: [
+        "swiper",
+        "init",
+        "beforeDestroy",
+        "slidesUpdated",
+        "slideChange",
+        "slideChangeTransitionStart",
+        "slideChangeTransitionEnd",
+        "slideNextTransitionStart",
+        "slideNextTransitionEnd",
+        "slidePrevTransitionStart",
+        "slidePrevTransitionEnd",
+        "transitionStart",
+        "transitionEnd",
+        "touchStart",
+        "touchMove",
+        "touchMoveOpposite",
+        "sliderMove",
+        "touchEnd",
+        "click",
+        "tap",
+        "doubleTap",
+        "progress",
+        "reachBeginning",
+        "reachEnd",
+        "toEdge",
+        "fromEdge",
+        "setTranslate",
+        "setTransition",
+        "resize",
+        "observerUpdate",
+        "beforeLoopFix",
+        "loopFix",
+        "breakpoint",
+        "_beforeBreakpoint",
+        "_containerClasses",
+        "_slideClass",
+        "_slideClasses",
+        "_swiper",
+        "_freeModeNoMomentumRelease",
+        "activeIndexChange",
+        "snapIndexChange",
+        "realIndexChange",
+        "afterInit",
+        "beforeInit",
+        "beforeResize",
+        "beforeSlideChangeStart",
+        "beforeTransitionStart",
+        "changeDirection",
+        "doubleClick",
+        "destroy",
+        "momentumBounce",
+        "orientationchange",
+        "slideResetTransitionStart",
+        "slideResetTransitionEnd",
+        "sliderFirstMove",
+        "slidesLengthChange",
+        "slidesGridLengthChange",
+        "snapGridLengthChange",
+        "update",
+        "lock",
+        "unlock"
+    ],
+    setup (__props, { expose: __expose, emit: __emit }) {
+        const props = createPropsRestProxy(__props, [
+            "class",
+            "direction"
+        ]);
+        const emits = __emit;
+        const forwarded = useForwardPropsEmits(props, emits);
+        const swiperInstance = shallowRef(null);
+        const swiperEl = ref();
+        const { hasModule } = useSwiperModule(swiperInstance);
+        function onSwiperInit(swiper) {
+            swiperEl.value = swiper.el;
+            swiperInstance.value = swiper;
+        }
+        function onFocusIn() {
+            if (hasModule("Keyboard")) swiperInstance.value?.keyboard.enable();
+        }
+        function onFocusOut() {
+            if (hasModule("Keyboard")) swiperInstance.value?.keyboard.disable();
+        }
+        function onKeyDown(event) {
+            if (hasModule("Keyboard")) return;
+            const prevKey = "vertical" === __props.direction ? "ArrowUp" : "ArrowLeft";
+            const nextKey = "vertical" === __props.direction ? "ArrowDown" : "ArrowRight";
+            if (event.key === prevKey) {
+                event.preventDefault();
+                swiperInstance.value?.slidePrev();
+                return;
+            }
+            if (event.key === nextKey) {
+                event.preventDefault();
+                swiperInstance.value?.slideNext();
+            }
+        }
+        __expose({
+            swiper: swiperInstance,
+            $el: swiperEl
+        });
+        return (_ctx, _cache)=>(openBlock(), createElementBlock("div", {
+                class: "swiper-region",
+                role: "region",
+                "aria-roledescription": "carousel",
+                tabindex: "0",
+                "data-scope": "swiper",
+                "data-part": "region",
+                onFocusin: onFocusIn,
+                onFocusout: onFocusOut,
+                onKeydown: onKeyDown
+            }, [
+                createVNode(unref(Swiper), mergeProps({
+                    ...unref(forwarded),
+                    ..._ctx.$attrs
+                }, {
+                    class: unref(cn)("rui-swiper", __props.class),
+                    direction: __props.direction,
+                    "data-scope": "swiper",
+                    "data-part": "root",
+                    onSwiper: onSwiperInit
+                }), createSlots({
+                    _: 2
+                }, [
+                    _ctx.$slots.default ? {
+                        name: "default",
+                        fn: withCtx(()=>[
+                                renderSlot(_ctx.$slots, "default")
+                            ]),
+                        key: "0"
+                    } : void 0,
+                    _ctx.$slots["container-start"] ? {
+                        name: "container-start",
+                        fn: withCtx(()=>[
+                                renderSlot(_ctx.$slots, "container-start")
+                            ]),
+                        key: "1"
+                    } : void 0,
+                    _ctx.$slots["container-end"] ? {
+                        name: "container-end",
+                        fn: withCtx(()=>[
+                                renderSlot(_ctx.$slots, "container-end")
+                            ]),
+                        key: "2"
+                    } : void 0,
+                    _ctx.$slots["wrapper-start"] ? {
+                        name: "wrapper-start",
+                        fn: withCtx(()=>[
+                                renderSlot(_ctx.$slots, "wrapper-start")
+                            ]),
+                        key: "3"
+                    } : void 0,
+                    _ctx.$slots["wrapper-end"] ? {
+                        name: "wrapper-end",
+                        fn: withCtx(()=>[
+                                renderSlot(_ctx.$slots, "wrapper-end")
+                            ]),
+                        key: "4"
+                    } : void 0
+                ]), 1040, [
+                    "class",
+                    "direction"
+                ])
+            ], 32));
+    }
+});
+const src_Swiper = _sfc_main;
+export default src_Swiper;

package/dist/Swiper.vue.d.ts

@@ -0,0 +1,183 @@
+import type { Swiper as SwiperInstance } from 'swiper/types';
+import type { SwiperProps, SwiperSlots } from '.';
+type __VLS_Slots = SwiperSlots;
+declare const __VLS_base: import("vue").DefineComponent<SwiperProps, {
+    swiper: import("vue").ShallowRef<SwiperInstance | null, SwiperInstance | null>;
+    $el: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    swiper: () => any;
+    progress: () => any;
+    update: () => any;
+    changeDirection: () => any;
+    init: () => any;
+    destroy: () => any;
+    setTranslate: () => any;
+    autoplay: () => any;
+    beforeDestroy: () => any;
+    slidesUpdated: () => any;
+    slideChange: () => any;
+    slideChangeTransitionStart: () => any;
+    slideChangeTransitionEnd: () => any;
+    slideNextTransitionStart: () => any;
+    slideNextTransitionEnd: () => any;
+    slidePrevTransitionStart: () => any;
+    slidePrevTransitionEnd: () => any;
+    transitionStart: () => any;
+    transitionEnd: () => any;
+    touchStart: () => any;
+    touchMove: () => any;
+    touchMoveOpposite: () => any;
+    sliderMove: () => any;
+    touchEnd: () => any;
+    click: () => any;
+    tap: () => any;
+    doubleTap: () => any;
+    reachBeginning: () => any;
+    reachEnd: () => any;
+    toEdge: () => any;
+    fromEdge: () => any;
+    setTransition: () => any;
+    resize: () => any;
+    observerUpdate: () => any;
+    beforeLoopFix: () => any;
+    loopFix: () => any;
+    breakpoint: () => any;
+    _beforeBreakpoint: () => any;
+    _containerClasses: () => any;
+    _slideClass: () => any;
+    _slideClasses: () => any;
+    _swiper: () => any;
+    _freeModeNoMomentumRelease: () => any;
+    activeIndexChange: () => any;
+    snapIndexChange: () => any;
+    realIndexChange: () => any;
+    afterInit: () => any;
+    beforeInit: () => any;
+    beforeResize: () => any;
+    beforeSlideChangeStart: () => any;
+    beforeTransitionStart: () => any;
+    doubleClick: () => any;
+    momentumBounce: () => any;
+    orientationchange: () => any;
+    slideResetTransitionStart: () => any;
+    slideResetTransitionEnd: () => any;
+    sliderFirstMove: () => any;
+    slidesLengthChange: () => any;
+    slidesGridLengthChange: () => any;
+    snapGridLengthChange: () => any;
+    lock: () => any;
+    unlock: () => any;
+    autoplayStart: () => any;
+    autoplayStop: () => any;
+    autoplayPause: () => any;
+    autoplayResume: () => any;
+    autoplayTimeLeft: () => any;
+    hashChange: () => any;
+    hashSet: () => any;
+    keyPress: () => any;
+    scroll: () => any;
+    navigationHide: () => any;
+    navigationShow: () => any;
+    navigationPrev: () => any;
+    navigationNext: () => any;
+    paginationRender: () => any;
+    paginationUpdate: () => any;
+    paginationHide: () => any;
+    paginationShow: () => any;
+    scrollbarDragStart: () => any;
+    scrollbarDragMove: () => any;
+    scrollbarDragEnd: () => any;
+    zoomChange: () => any;
+}, string, import("vue").PublicProps, Readonly<SwiperProps> & Readonly<{
+    onSwiper?: (() => any) | undefined;
+    onProgress?: (() => any) | undefined;
+    onUpdate?: (() => any) | undefined;
+    onChangeDirection?: (() => any) | undefined;
+    onInit?: (() => any) | undefined;
+    onDestroy?: (() => any) | undefined;
+    onSetTranslate?: (() => any) | undefined;
+    onAutoplay?: (() => any) | undefined;
+    onBeforeDestroy?: (() => any) | undefined;
+    onSlidesUpdated?: (() => any) | undefined;
+    onSlideChange?: (() => any) | undefined;
+    onSlideChangeTransitionStart?: (() => any) | undefined;
+    onSlideChangeTransitionEnd?: (() => any) | undefined;
+    onSlideNextTransitionStart?: (() => any) | undefined;
+    onSlideNextTransitionEnd?: (() => any) | undefined;
+    onSlidePrevTransitionStart?: (() => any) | undefined;
+    onSlidePrevTransitionEnd?: (() => any) | undefined;
+    onTransitionStart?: (() => any) | undefined;
+    onTransitionEnd?: (() => any) | undefined;
+    onTouchStart?: (() => any) | undefined;
+    onTouchMove?: (() => any) | undefined;
+    onTouchMoveOpposite?: (() => any) | undefined;
+    onSliderMove?: (() => any) | undefined;
+    onTouchEnd?: (() => any) | undefined;
+    onClick?: (() => any) | undefined;
+    onTap?: (() => any) | undefined;
+    onDoubleTap?: (() => any) | undefined;
+    onReachBeginning?: (() => any) | undefined;
+    onReachEnd?: (() => any) | undefined;
+    onToEdge?: (() => any) | undefined;
+    onFromEdge?: (() => any) | undefined;
+    onSetTransition?: (() => any) | undefined;
+    onResize?: (() => any) | undefined;
+    onObserverUpdate?: (() => any) | undefined;
+    onBeforeLoopFix?: (() => any) | undefined;
+    onLoopFix?: (() => any) | undefined;
+    onBreakpoint?: (() => any) | undefined;
+    on_beforeBreakpoint?: (() => any) | undefined;
+    on_containerClasses?: (() => any) | undefined;
+    on_slideClass?: (() => any) | undefined;
+    on_slideClasses?: (() => any) | undefined;
+    on_swiper?: (() => any) | undefined;
+    on_freeModeNoMomentumRelease?: (() => any) | undefined;
+    onActiveIndexChange?: (() => any) | undefined;
+    onSnapIndexChange?: (() => any) | undefined;
+    onRealIndexChange?: (() => any) | undefined;
+    onAfterInit?: (() => any) | undefined;
+    onBeforeInit?: (() => any) | undefined;
+    onBeforeResize?: (() => any) | undefined;
+    onBeforeSlideChangeStart?: (() => any) | undefined;
+    onBeforeTransitionStart?: (() => any) | undefined;
+    onDoubleClick?: (() => any) | undefined;
+    onMomentumBounce?: (() => any) | undefined;
+    onOrientationchange?: (() => any) | undefined;
+    onSlideResetTransitionStart?: (() => any) | undefined;
+    onSlideResetTransitionEnd?: (() => any) | undefined;
+    onSliderFirstMove?: (() => any) | undefined;
+    onSlidesLengthChange?: (() => any) | undefined;
+    onSlidesGridLengthChange?: (() => any) | undefined;
+    onSnapGridLengthChange?: (() => any) | undefined;
+    onLock?: (() => any) | undefined;
+    onUnlock?: (() => any) | undefined;
+    onAutoplayStart?: (() => any) | undefined;
+    onAutoplayStop?: (() => any) | undefined;
+    onAutoplayPause?: (() => any) | undefined;
+    onAutoplayResume?: (() => any) | undefined;
+    onAutoplayTimeLeft?: (() => any) | undefined;
+    onHashChange?: (() => any) | undefined;
+    onHashSet?: (() => any) | undefined;
+    onKeyPress?: (() => any) | undefined;
+    onScroll?: (() => any) | undefined;
+    onNavigationHide?: (() => any) | undefined;
+    onNavigationShow?: (() => any) | undefined;
+    onNavigationPrev?: (() => any) | undefined;
+    onNavigationNext?: (() => any) | undefined;
+    onPaginationRender?: (() => any) | undefined;
+    onPaginationUpdate?: (() => any) | undefined;
+    onPaginationHide?: (() => any) | undefined;
+    onPaginationShow?: (() => any) | undefined;
+    onScrollbarDragStart?: (() => any) | undefined;
+    onScrollbarDragMove?: (() => any) | undefined;
+    onScrollbarDragEnd?: (() => any) | undefined;
+    onZoomChange?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};