@v-c/slick 0.0.1

package/dist/default-props.js

@@ -0,0 +1,57 @@
+import { createVNode } from "vue";
+var default_props_default = {
+	accessibility: true,
+	adaptiveHeight: false,
+	afterChange: null,
+	appendDots: (dots) => createVNode("ul", { "style": { display: "block" } }, [dots]),
+	arrows: true,
+	autoplay: false,
+	autoplaySpeed: 3e3,
+	beforeChange: null,
+	centerMode: false,
+	centerPadding: "50px",
+	className: "",
+	cssEase: "ease",
+	customPaging: (i) => createVNode("button", null, [i + 1]),
+	dots: false,
+	dotsClass: "slick-dots",
+	draggable: true,
+	easing: "linear",
+	edgeFriction: .35,
+	fade: false,
+	focusOnSelect: false,
+	infinite: true,
+	initialSlide: 0,
+	lazyLoad: null,
+	nextArrow: null,
+	onEdge: null,
+	onInit: null,
+	onLazyLoadError: null,
+	onReInit: null,
+	pauseOnDotsHover: false,
+	pauseOnFocus: false,
+	pauseOnHover: true,
+	prevArrow: null,
+	responsive: null,
+	rows: 1,
+	rtl: false,
+	slide: "div",
+	slidesPerRow: 1,
+	slidesToScroll: 1,
+	slidesToShow: 1,
+	speed: 500,
+	swipe: true,
+	swipeEvent: null,
+	swipeToSlide: false,
+	touchMove: true,
+	touchThreshold: 5,
+	useCSS: true,
+	useTransform: true,
+	variableWidth: false,
+	vertical: false,
+	verticalSwiping: false,
+	waitForAnimate: true,
+	asNavFor: null,
+	unslick: false
+};
+export { default_props_default as default };

package/dist/index.cjs

@@ -0,0 +1,7 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_Slider = require("./Slider.cjs");
+var src_default = require_Slider.default;
+exports.default = src_default;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { InnerSliderRef, SlickProps, SlickRef } from './interface';
+import { default as Slider } from './Slider';
+export type { InnerSliderRef, SlickProps, SlickRef };
+export default Slider;

package/dist/index.js

@@ -0,0 +1,3 @@
+import Slider_default from "./Slider.js";
+var src_default = Slider_default;
+export { src_default as default };

package/dist/initial-state.cjs

@@ -0,0 +1,36 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+var initialState = {
+	animating: false,
+	autoplaying: null,
+	currentDirection: 0,
+	currentLeft: null,
+	currentSlide: 0,
+	direction: 1,
+	dragging: false,
+	edgeDragged: false,
+	initialized: false,
+	lazyLoadedList: [],
+	listHeight: null,
+	listWidth: null,
+	scrolling: false,
+	slideCount: 0,
+	slideHeight: null,
+	slideWidth: null,
+	swipeLeft: null,
+	swiped: false,
+	swiping: false,
+	touchObject: {
+		startX: 0,
+		startY: 0,
+		curX: 0,
+		curY: 0
+	},
+	trackStyle: {},
+	trackWidth: 0,
+	targetSlide: 0
+};
+var initial_state_default = initialState;
+exports.default = initial_state_default;

package/dist/initial-state.d.ts

@@ -0,0 +1,3 @@
+import { InnerSliderState } from './interface';
+declare const initialState: InnerSliderState;
+export default initialState;

package/dist/initial-state.js

@@ -0,0 +1,31 @@
+var initial_state_default = {
+	animating: false,
+	autoplaying: null,
+	currentDirection: 0,
+	currentLeft: null,
+	currentSlide: 0,
+	direction: 1,
+	dragging: false,
+	edgeDragged: false,
+	initialized: false,
+	lazyLoadedList: [],
+	listHeight: null,
+	listWidth: null,
+	scrolling: false,
+	slideCount: 0,
+	slideHeight: null,
+	slideWidth: null,
+	swipeLeft: null,
+	swiped: false,
+	swiping: false,
+	touchObject: {
+		startX: 0,
+		startY: 0,
+		curX: 0,
+		curY: 0
+	},
+	trackStyle: {},
+	trackWidth: 0,
+	targetSlide: 0
+};
+export { initial_state_default as default };

package/dist/interface.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });

package/dist/interface.d.ts

@@ -0,0 +1,146 @@
+import { CSSProperties, Ref, VNodeChild } from 'vue';
+export type LazyLoadType = 'ondemand' | 'progressive' | boolean | null;
+export interface SlickProps {
+    accessibility?: boolean;
+    adaptiveHeight?: boolean;
+    afterChange?: ((currentSlide: number) => void) | null;
+    appendDots?: (dots: VNodeChild[]) => VNodeChild;
+    arrows?: boolean;
+    autoplay?: boolean;
+    autoplaySpeed?: number;
+    beforeChange?: ((currentSlide: number, nextSlide: number) => void) | null;
+    centerMode?: boolean;
+    centerPadding?: string;
+    className?: string;
+    cssEase?: string;
+    customPaging?: (index: number) => VNodeChild;
+    dots?: boolean;
+    dotsClass?: string;
+    draggable?: boolean;
+    easing?: string;
+    edgeFriction?: number;
+    fade?: boolean;
+    focusOnSelect?: boolean;
+    infinite?: boolean;
+    initialSlide?: number;
+    lazyLoad?: LazyLoadType;
+    nextArrow?: VNodeChild;
+    onEdge?: ((direction: string) => void) | null;
+    onInit?: (() => void) | null;
+    onLazyLoad?: ((slidesToLoad: number[]) => void) | null;
+    onLazyLoadError?: (() => void) | null;
+    onReInit?: (() => void) | null;
+    onSwipe?: ((direction: string) => void) | null;
+    pauseOnDotsHover?: boolean;
+    pauseOnFocus?: boolean;
+    pauseOnHover?: boolean;
+    prevArrow?: VNodeChild;
+    responsive?: ResponsiveSetting[] | null;
+    rows?: number;
+    rtl?: boolean;
+    slide?: string;
+    slidesPerRow?: number;
+    slidesToScroll?: number;
+    slidesToShow?: number;
+    speed?: number;
+    swipe?: boolean;
+    swipeEvent?: ((direction: string) => void) | null;
+    swipeToSlide?: boolean;
+    touchMove?: boolean;
+    touchThreshold?: number;
+    useCSS?: boolean;
+    useTransform?: boolean;
+    variableWidth?: boolean;
+    vertical?: boolean;
+    verticalSwiping?: boolean;
+    waitForAnimate?: boolean;
+    asNavFor?: SlickRef | InnerSliderRef | null;
+    unslick?: boolean;
+    style?: CSSProperties;
+}
+export type SlickSettings = Omit<SlickProps, 'responsive'>;
+export interface ResponsiveSetting {
+    breakpoint: number;
+    settings: 'unslick' | SlickSettings;
+}
+export type AutoPlayType = 'update' | 'leave' | 'blur' | 'play' | 'playing';
+export type PauseType = 'paused' | 'hovered' | 'focused';
+export interface SlickRef {
+    slickPrev: () => void;
+    slickNext: () => void;
+    slickGoTo: (slide: number, dontAnimate?: boolean) => void;
+    slickPause: () => void;
+    slickPlay: () => void;
+    innerSlider?: InnerSliderRef | Ref<InnerSliderRef | null> | null;
+}
+export interface InnerSliderState {
+    animating: boolean;
+    autoplaying: 'playing' | 'paused' | 'hovered' | 'focused' | null;
+    currentDirection: number;
+    currentLeft: number | null;
+    currentSlide: number;
+    direction: number;
+    dragging: boolean;
+    edgeDragged: boolean;
+    initialized: boolean;
+    lazyLoadedList: number[];
+    listHeight: number | null;
+    listWidth: number | null;
+    scrolling: boolean;
+    slideCount: number;
+    slideHeight: number | null;
+    slideWidth: number | string | null;
+    swipeLeft: number | null;
+    swiped: boolean;
+    swiping: boolean;
+    touchObject: {
+        startX: number;
+        startY: number;
+        curX: number;
+        curY: number;
+        swipeLength?: number;
+    };
+    trackStyle: Record<string, any>;
+    trackWidth: number;
+    targetSlide: number;
+}
+export interface InnerSliderRef {
+    slickPrev: () => void;
+    slickNext: () => void;
+    slickGoTo: (slide: number, dontAnimate?: boolean) => void;
+    autoPlay: (playType: AutoPlayType) => void;
+    pause: (pauseType: PauseType) => void;
+    play: () => void;
+    slideHandler: (index: number, dontAnimate?: boolean) => void;
+    changeSlide: (options: any, dontAnimate?: boolean) => void;
+}
+export interface TrackProps {
+    children: VNodeChild[];
+    currentSlide: number;
+    targetSlide: number;
+    slideCount: number;
+    slidesToShow: number;
+    slidesToScroll: number;
+    slideWidth?: number | string | null;
+    slideHeight?: number | null;
+    listHeight?: number | null;
+    fade?: boolean;
+    cssEase?: string;
+    speed?: number;
+    infinite?: boolean;
+    centerMode?: boolean;
+    focusOnSelect?: (options: any) => void;
+    lazyLoad?: LazyLoadType;
+    lazyLoadedList: number[];
+    rtl?: boolean;
+    vertical?: boolean;
+    variableWidth?: boolean;
+    unslick?: boolean;
+    centerPadding?: string;
+    trackStyle?: CSSProperties;
+    useCSS?: boolean;
+    onMouseEnter?: (e: MouseEvent) => void;
+    onMouseOver?: (e: MouseEvent) => void;
+    onMouseLeave?: (e: MouseEvent) => void;
+    nodeRef?: Ref<HTMLDivElement | null>;
+}