会员权益

uni_modules/zebra-swiper/libs/update/index.js

@@ -0,0 +1,20 @@
+import updateSize from './updateSize.js';
+import updateSlides from './updateSlides.js';
+import updateAutoHeight from './updateAutoHeight.js';
+import updateSlidesOffset from './updateSlidesOffset.js';
+import updateSlidesProgress from './updateSlidesProgress.js';
+import updateProgress from './updateProgress.js';
+import updateSlidesClasses from './updateSlidesClasses.js';
+import updateActiveIndex from './updateActiveIndex.js';
+import updateClickedSlide from './updateClickedSlide.js';
+export default {
+	updateSize,
+	updateSlides,
+	updateAutoHeight,
+	updateSlidesOffset,
+	updateSlidesProgress,
+	updateProgress,
+	updateSlidesClasses,
+	updateActiveIndex,
+	updateClickedSlide
+};

uni_modules/zebra-swiper/libs/update/updateActiveIndex.js

@@ -0,0 +1,102 @@
+export default function updateActiveIndex(newActiveIndex) {
+	const swiper = this;
+	const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
+	const {
+		slidesGrid,
+		snapGrid,
+		params,
+		activeIndex: previousIndex,
+		realIndex: previousRealIndex,
+		snapIndex: previousSnapIndex
+	} = swiper;
+	let activeIndex = newActiveIndex;
+	let snapIndex;
+
+	if (typeof activeIndex === 'undefined') {
+		for (let i = 0; i < slidesGrid.length; i += 1) {
+			if (typeof slidesGrid[i + 1] !== 'undefined') {
+				if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) /
+					2) {
+					activeIndex = i;
+				} else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
+					activeIndex = i + 1;
+				}
+			} else if (translate >= slidesGrid[i]) {
+				activeIndex = i;
+			}
+		} // Normalize slideIndex
+
+
+		if (params.normalizeSlideIndex) {
+			if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
+		}
+
+	}
+
+	if (snapGrid.indexOf(translate) >= 0) {
+		snapIndex = snapGrid.indexOf(translate);
+	} else {
+		const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
+		snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
+	}
+
+	if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
+
+
+
+	if (swiper.loopedSlides) {
+		swiper.slides.filter((item) => item.index >= swiper.loopedSlides && item.index < swiper.slides.length - swiper
+			.loopedSlides).forEach((item, index) => {
+			item.dataSwiperSlideIndex = item.index - swiper.loopedSlides;
+		})
+		swiper.slides.filter((item) => item.index < swiper.loopedSlides).forEach((item, index) => {
+			if (swiper.slides[swiper.slides.length - swiper.loopedSlides * 3 + index]) {
+				item.dataSwiperSlideIndex = swiper.slides[swiper.slides.length - swiper.loopedSlides * 3 +
+						index]
+					.index;
+			}
+		})
+		swiper.slides.filter((item) => item.index >= swiper.slides.length - swiper
+			.loopedSlides).forEach((item, index) => {
+			item.dataSwiperSlideIndex = swiper.slides[index].index;
+		})
+	}
+
+
+	if (activeIndex === previousIndex) {
+		if (snapIndex !== previousSnapIndex) {
+			swiper.snapIndex = snapIndex;
+			swiper.emit('snapIndexChange');
+		}
+
+		return;
+	} // Get real index
+
+	let realIndex;
+	if (swiper.virtual && params.virtual.enabled) {
+		realIndex = activeIndex;
+	} else {
+		if (swiper.slides[activeIndex].dataSwiperSlideIndex == undefined || swiper.slides[activeIndex]
+			.dataSwiperSlideIndex == null) {
+			realIndex = activeIndex;
+		} else {
+			realIndex = swiper.slides[activeIndex].dataSwiperSlideIndex;
+		}
+	}
+	Object.assign(swiper, {
+		snapIndex,
+		realIndex,
+		previousIndex,
+		activeIndex
+	});
+	swiper.emit('activeIndexChange');
+	swiper.emit('snapIndexChange');
+
+	if (previousRealIndex !== realIndex) {
+		swiper.emit('realIndexChange');
+	}
+
+	if (swiper.initialized || swiper.params.runCallbacksOnInit) {
+		swiper.emit('slideChange', activeIndex);
+	}
+}

uni_modules/zebra-swiper/libs/update/updateAutoHeight.js

@@ -0,0 +1,53 @@
+export default async function updateAutoHeight(speed) {
+	const swiper = this;
+	const activeSlides = [];
+	const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
+	let newHeight = 0;
+	let i;
+
+	if (typeof speed === 'number') {
+		swiper.setTransition(speed);
+	} else if (speed === true) {
+		swiper.setTransition(swiper.params.speed);
+	}
+
+	const getSlideByIndex = index => {
+		if (isVirtual) {
+			return swiper.slides.filter(el => parseInt(el.getAttribute('data-swiper-slide-index'), 10) ===
+				index)[
+				0];
+		}
+
+		return swiper.slides[index];
+	}; // Find slides currently in view
+
+	if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
+		if (swiper.params.centeredSlides) {
+			swiper.visibleSlides.each(slide => {
+				activeSlides.push(slide);
+			});
+		} else {
+			for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
+				const index = swiper.activeIndex + i;
+				if (index > swiper.slides.length && !isVirtual) break;
+				activeSlides.push(getSlideByIndex(index));
+			}
+		}
+	} else {
+		activeSlides.push(getSlideByIndex(swiper.activeIndex));
+	} // Find new height from highest slide in view
+
+
+	for (i = 0; i < activeSlides.length; i += 1) {
+		if (typeof activeSlides[i] !== 'undefined') {
+			const size = await activeSlides[i].getSize();
+			const height = size.height;
+			newHeight = height > newHeight ? height : newHeight;
+		}
+	} // Update Height
+
+
+	if (newHeight || newHeight === 0) swiper.$wrapperEl.css({
+		height: `${newHeight?newHeight:''}px`
+	});
+}

uni_modules/zebra-swiper/libs/update/updateClickedSlide.js

@@ -0,0 +1,35 @@
+export default function updateClickedSlide(e) {
+	const swiper = this;
+	const params = swiper.params;
+	const slide = swiper.slides[e];
+	let slideFound = false;
+	let slideIndex;
+
+	if (slide) {
+		for (let i = 0; i < swiper.slides.length; i += 1) {
+			if (swiper.slides[i] === slide) {
+				slideFound = true;
+				slideIndex = i;
+				break;
+			}
+		}
+	}
+
+	if (slide && slideFound) {
+		swiper.clickedSlide = slide;
+
+		if (swiper.virtual && swiper.params.virtual.enabled) {
+			swiper.clickedIndex = parseInt($(slide).attr('data-swiper-slide-index'), 10);
+		} else {
+			swiper.clickedIndex = slideIndex;
+		}
+	} else {
+		swiper.clickedSlide = undefined;
+		swiper.clickedIndex = undefined;
+		return;
+	}
+
+	if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
+		swiper.slideToClickedSlide();
+	}
+}

uni_modules/zebra-swiper/libs/update/updateProgress.js

@@ -0,0 +1,50 @@
+export default function updateProgress(translate) {
+  const swiper = this;
+
+  if (typeof translate === 'undefined') {
+    const multiplier = swiper.rtlTranslate ? -1 : 1; // eslint-disable-next-line
+
+    translate = swiper && swiper.translate && swiper.translate * multiplier || 0;
+  }
+
+  const params = swiper.params;
+  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
+  let {
+    progress,
+    isBeginning,
+    isEnd
+  } = swiper;
+  const wasBeginning = isBeginning;
+  const wasEnd = isEnd;
+
+  if (translatesDiff === 0) {
+    progress = 0;
+    isBeginning = true;
+    isEnd = true;
+  } else {
+    progress = (translate - swiper.minTranslate()) / translatesDiff;
+    isBeginning = progress <= 0;
+    isEnd = progress >= 1;
+  }
+
+  Object.assign(swiper, {
+    progress,
+    isBeginning,
+    isEnd
+  });
+  if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);
+
+  if (isBeginning && !wasBeginning) {
+    swiper.emit('reachBeginning toEdge');
+  }
+
+  if (isEnd && !wasEnd) {
+    swiper.emit('reachEnd toEdge');
+  }
+
+  if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
+    swiper.emit('fromEdge');
+  }
+
+  swiper.emit('progress', progress);
+}

uni_modules/zebra-swiper/libs/update/updateSize.js

@@ -0,0 +1,28 @@
+export default function updateSize() {
+	const swiper = this;
+	let width;
+	let height;
+	const el = swiper.el;
+	if (typeof swiper.params.width !== 'undefined' && swiper.params.width !== null) {
+		width = swiper.params.width;
+	} else {
+		width = el.width;
+	}
+
+	if (typeof swiper.params.height !== 'undefined' && swiper.params.height !== null) {
+		height = swiper.params.height;
+	} else {
+		height = el.height;
+	}
+
+	if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
+		return;
+	} // Subtract paddings
+	if (Number.isNaN(width)) width = 0;
+	if (Number.isNaN(height)) height = 0;
+	Object.assign(swiper, {
+		width,
+		height,
+		size: swiper.isHorizontal() ? width : height
+	});
+}

uni_modules/zebra-swiper/libs/update/updateSlides.js

@@ -0,0 +1,311 @@
+import {
+	setCSSProperty
+} from '../../shared/utils.js';
+export default function updateSlides() {
+	const swiper = this;
+
+	function getDirectionLabel(property) {
+		if (swiper.isHorizontal()) {
+			return property;
+		} // prettier-ignore
+
+
+		return {
+			'width': 'height',
+			'margin-top': 'margin-left',
+			'margin-bottom ': 'margin-right',
+			'margin-left': 'margin-top',
+			'margin-right': 'margin-bottom',
+			'padding-left': 'padding-top',
+			'padding-right': 'padding-bottom',
+			'marginRight': 'marginBottom'
+		} [property];
+	}
+
+	function getDirectionPropertyValue(node, label) {
+		return parseFloat(node[getDirectionLabel(label)] || 0);
+	}
+
+	function getComputedStyle(native) {
+		return native.itemStyle;
+	}
+	const params = swiper.params;
+	const {
+		$wrapperEl,
+		size: swiperSize,
+		rtlTranslate: rtl,
+		wrongRTL
+	} = swiper;
+	const isVirtual = swiper.virtual && params.virtual.enabled;
+	const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
+	// const slides = $wrapperEl.children(`.${swiper.params.slideClass}`);
+	const slides = swiper.slides;
+	const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
+	let snapGrid = [];
+	const slidesGrid = [];
+	const slidesSizesGrid = [];
+	let offsetBefore = params.slidesOffsetBefore;
+
+	if (typeof offsetBefore === 'function') {
+		offsetBefore = params.slidesOffsetBefore.call(swiper);
+	}
+
+	let offsetAfter = params.slidesOffsetAfter;
+
+	if (typeof offsetAfter === 'function') {
+		offsetAfter = params.slidesOffsetAfter.call(swiper);
+	}
+
+	const previousSnapGridLength = swiper.snapGrid.length;
+	const previousSlidesGridLength = swiper.slidesGrid.length;
+	let spaceBetween = params.spaceBetween;
+	let slidePosition = -offsetBefore;
+	let prevSlideSize = 0;
+	let index = 0;
+
+	if (typeof swiperSize === 'undefined') {
+		return;
+	}
+
+	if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
+		spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiperSize;
+	}
+
+	swiper.virtualSize = -spaceBetween; // reset margins
+
+	if (params.centeredSlides && params.cssMode) {
+		setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-before', '');
+		setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-after', '');
+	}
+
+	const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
+
+	if (gridEnabled) {
+		swiper.grid.initSlides(slidesLength);
+	}
+
+
+	let slideSize;
+	const shouldResetSlideSize = params.slidesPerView === 'auto' && params.breakpoints && Object.keys(params
+		.breakpoints).filter(key => {
+		return typeof params.breakpoints[key].slidesPerView !== 'undefined';
+	}).length > 0;
+	Array(...Array(slidesLength)).forEach(async (item, i) => {
+		slideSize = 0;
+		const slide = slides[i];
+
+		if (gridEnabled) {
+			swiper.grid.updateSlide(i, slide, slidesLength, getDirectionLabel);
+		}
+		if (params.slidesPerView === 'auto') {
+			if (shouldResetSlideSize) {
+				slides[i].style[getDirectionLabel('width')] = ``;
+			}
+
+			const slideStyles = getComputedStyle(slide);
+			const currentTransform = slide.itemStyle.transform;
+			const currentWebKitTransform = slide.itemStyle.webkitTransform;
+
+			if (currentTransform) {
+				slide.itemStyle.transform = 'none';
+			}
+
+			if (currentWebKitTransform) {
+				slide.itemStyle.webkitTransform = 'none';
+			}
+
+			if (params.roundLengths) {
+				slideSize = swiper.isHorizontal() ? slide.outerWidth(true) : slide.outerHeight(true);
+			} else {
+				const width = swiper.isHorizontal() ? slide.width : slide.height;
+				const paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');
+				const paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');
+				const marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');
+				const marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');
+				const boxSizing = slideStyles['box-sizing'];
+
+				if (boxSizing && boxSizing === 'border-box') {
+					slideSize = width + marginLeft + marginRight;
+				} else {
+					// slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight;
+					slideSize = width;
+				}
+			}
+
+			if (currentTransform) {
+				slide.itemStyle.transform = currentTransform;
+			}
+
+			if (currentWebKitTransform) {
+				slide.itemStyle.webkitTransform = currentWebKitTransform;
+			}
+
+			if (params.roundLengths) slideSize = Math.floor(slideSize);
+		} else {
+			slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
+			if (params.roundLengths) slideSize = Math.floor(slideSize);
+			slides[i] && slides[i].css({
+				[getDirectionLabel('width')]: `${slideSize}px`
+			})
+		}
+
+		if (slides[i]) {
+			slides[i].swiperSlideSize = slideSize;
+		}
+
+		if (params.autoHeight) {
+			slides[i] && slides[i].css({
+				height: 'auto'
+			})
+		}
+
+		slidesSizesGrid.push(slideSize);
+
+		if (params.centeredSlides) {
+			slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
+			if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 -
+				spaceBetween;
+			if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
+			if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;
+			if (params.roundLengths) slidePosition = Math.floor(slidePosition);
+			if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
+			slidesGrid.push(slidePosition);
+		} else {
+			if (params.roundLengths) slidePosition = Math.floor(slidePosition);
+			if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params
+				.slidesPerGroup === 0)
+				snapGrid.push(slidePosition);
+			slidesGrid.push(slidePosition);
+			slidePosition = slidePosition + slideSize + spaceBetween;
+		}
+		swiper.virtualSize += slideSize + spaceBetween;
+		prevSlideSize = slideSize;
+		index += 1;
+	})
+	swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
+
+	if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
+		$wrapperEl.css({
+			width: `${swiper.virtualSize + params.spaceBetween}px`
+		});
+	}
+
+	if (params.setWrapperSize) {
+		$wrapperEl.css({
+			[getDirectionLabel('width')]: `${swiper.virtualSize + params.spaceBetween}px`
+		});
+	}
+
+	if (gridEnabled) {
+		swiper.grid.updateWrapperSize(slideSize, snapGrid, getDirectionLabel);
+	} // Remove last grid elements depending on width
+
+
+	if (!params.centeredSlides) {
+		const newSlidesGrid = [];
+
+		for (let i = 0; i < snapGrid.length; i += 1) {
+			let slidesGridItem = snapGrid[i];
+			if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
+
+			if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
+				newSlidesGrid.push(slidesGridItem);
+			}
+		}
+		snapGrid = newSlidesGrid;
+
+		if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
+			snapGrid.push(swiper.virtualSize - swiperSize);
+		}
+	}
+
+	if (snapGrid.length === 0) snapGrid = [0];
+
+	if (params.spaceBetween !== 0) {
+		// #ifdef MP-BAIDU
+		const key = swiper.isHorizontal() && rtl ? 'marginLeft' : getDirectionLabel('marginRight');
+		// #endif
+		// #ifndef MP-BAIDU
+		const key = swiper.isHorizontal() && rtl ? 'margin-left' : getDirectionLabel('margin-right');
+		// #endif
+		slides.filter((_, slideIndex) => {
+			if (!params.cssMode) return true;
+
+			if (slideIndex === slides.length - 1) {
+				return false;
+			}
+
+			return true;
+		}).forEach((item) => {
+			item.css({
+				[key]: `${spaceBetween}px`
+			})
+		});
+	}
+	if (params.centeredSlides && params.centeredSlidesBounds) {
+		let allSlidesSize = 0;
+		slidesSizesGrid.forEach(slideSizeValue => {
+			allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
+		});
+		allSlidesSize -= params.spaceBetween;
+		const maxSnap = allSlidesSize - swiperSize;
+		snapGrid = snapGrid.map(snap => {
+			if (snap < 0) return -offsetBefore;
+			if (snap > maxSnap) return maxSnap + offsetAfter;
+			return snap;
+		});
+	}
+
+	if (params.centerInsufficientSlides) {
+		let allSlidesSize = 0;
+		slidesSizesGrid.forEach(slideSizeValue => {
+			allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
+		});
+		allSlidesSize -= params.spaceBetween;
+
+		if (allSlidesSize < swiperSize) {
+			const allSlidesOffset = (swiperSize - allSlidesSize) / 2;
+			snapGrid.forEach((snap, snapIndex) => {
+				snapGrid[snapIndex] = snap - allSlidesOffset;
+			});
+			slidesGrid.forEach((snap, snapIndex) => {
+				slidesGrid[snapIndex] = snap + allSlidesOffset;
+			});
+		}
+	}
+	Object.assign(swiper, {
+		slides,
+		snapGrid,
+		slidesGrid,
+		slidesSizesGrid
+	});
+
+	if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
+		setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-before', `${-snapGrid[0]}px`);
+		setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-after',
+			`${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);
+		const addToSnapGrid = -swiper.snapGrid[0];
+		const addToSlidesGrid = -swiper.slidesGrid[0];
+		swiper.snapGrid = swiper.snapGrid.map(v => v + addToSnapGrid);
+		swiper.slidesGrid = swiper.slidesGrid.map(v => v + addToSlidesGrid);
+	}
+
+	if (slidesLength !== previousSlidesLength) {
+		swiper.emit('slidesLengthChange');
+	}
+
+	if (snapGrid.length !== previousSnapGridLength) {
+		if (swiper.params.watchOverflow) swiper.checkOverflow();
+		swiper.emit('snapGridLengthChange');
+	}
+
+	if (slidesGrid.length !== previousSlidesGridLength) {
+		swiper.emit('slidesGridLengthChange');
+	}
+
+	if (params.watchSlidesProgress) {
+		swiper.updateSlidesOffset();
+	}
+
+	return slides;
+}

uni_modules/zebra-swiper/libs/update/updateSlidesClasses.js

@@ -0,0 +1,119 @@
+export default function updateSlidesClasses() {
+	const swiper = this;
+	const {
+		slides,
+		params,
+		$wrapperEl,
+		activeIndex,
+		realIndex
+	} = swiper;
+	if (!slides.length || !$wrapperEl) return;
+	const isVirtual = swiper.virtual && params.virtual.enabled;
+	for (var i = 0; i < slides.length; i++) {
+		slides[i].removeClass(
+			`${params.slideActiveClass} ${params.slideNextClass} ${params.slidePrevClass} ${params.slideDuplicateActiveClass} ${params.slideDuplicateNextClass} ${params.slideDuplicatePrevClass}`
+		);
+	}
+
+	let activeSlide;
+
+	if (isVirtual) {
+		// activeSlide = swiper.$wrapperEl.find(`.${params.slideClass}[data-swiper-slide-index="${activeIndex}"]`);
+		activeSlide = slides[slides.findIndex((item) => {
+			return item.dataSwiperSlideIndex == activeIndex
+		})];
+	} else {
+		activeSlide = slides[activeIndex];
+	} // Active classes
+
+	if (!activeSlide) return
+	activeSlide.addClass(params.slideActiveClass);
+
+	if (params.loop) {
+		if (activeSlide.hasClass(params.slideDuplicateClass)) {
+			// $wrapperEl.children[realIndex].addClass(params.slideDuplicateActiveClass);
+			let index = slides.findIndex((item) => {
+				return !item.hasClass(params.slideDuplicateClass) && item.dataSwiperSlideIndex == realIndex
+			})
+			slides[index] && slides[index].addClass(params.slideDuplicateActiveClass);
+		} else {
+			// $wrapperEl.children[realIndex].addClass(params.slideDuplicateActiveClass);
+			let index = slides.findIndex((item) => {
+				return item.hasClass(params.slideDuplicateClass) && item.dataSwiperSlideIndex == realIndex
+			})
+			slides[index] && slides[index].addClass(params.slideDuplicateActiveClass);
+		}
+	} // Next Slide
+
+
+	let nextSlide = activeSlide.nextAll(`.${params.slideClass}`)[0];
+	if (nextSlide) {
+		nextSlide.addClass(params.slideNextClass);
+	} else {
+		if (params.loop && !nextSlide) {
+			nextSlide = slides[0];
+			nextSlide.addClass(params.slideNextClass);
+		} // Prev Slide
+	}
+
+
+
+	let prevSlide = activeSlide.prevAll(`.${params.slideClass}`)[0];
+	if (prevSlide) {
+		prevSlide.addClass(params.slidePrevClass);
+	} else {
+		if (params.loop && !prevSlide) {
+			prevSlide = slides[slides.length - 1];
+			prevSlide.addClass(params.slidePrevClass);
+		}
+	}
+
+
+	if (params.loop) {
+		// Duplicate to all looped slides
+		if (nextSlide.hasClass(params.slideDuplicateClass)) {
+			// $wrapperEl.children(
+			// 	nextSlide.dataSwiperSlideIndex
+			// ).addClass(params.slideDuplicateNextClass);
+
+			let index = slides.findIndex((item) => {
+				return !item.hasClass(params.slideDuplicateClass) && item.dataSwiperSlideIndex == nextSlide
+					.dataSwiperSlideIndex
+			})
+			slides[index] && slides[index].addClass(params.slideDuplicateNextClass);
+
+
+		} else {
+			// $wrapperEl.children(
+			// 	nextSlide.dataSwiperSlideIndex
+			// ).addClass(params.slideDuplicateNextClass);
+
+			let index = slides.findIndex((item) => {
+				return item.hasClass(params.slideDuplicateClass) && item.dataSwiperSlideIndex == nextSlide
+					.dataSwiperSlideIndex
+			})
+			slides[index] && slides[index].addClass(params.slideDuplicateNextClass);
+		}
+		if (prevSlide.hasClass(params.slideDuplicateClass)) {
+			// $wrapperEl.children(
+			// 	prevSlide.dataSwiperSlideIndex
+			// ).addClass(params.slideDuplicatePrevClass);
+			let index = slides.findIndex((item) => {
+				return !item.hasClass(params.slideDuplicateClass) && item.dataSwiperSlideIndex == prevSlide
+					.dataSwiperSlideIndex
+			})
+			slides[index] && slides[index].addClass(params.slideDuplicatePrevClass);
+		} else {
+			// $wrapperEl.children(
+			// 	prevSlide.dataSwiperSlideIndex
+			// ).addClass(params.slideDuplicatePrevClass);
+			let index = slides.findIndex((item) => {
+				return item.hasClass(params.slideDuplicateClass) && item.dataSwiperSlideIndex == prevSlide
+					.dataSwiperSlideIndex
+			})
+			slides[index] && slides[index].addClass(params.slideDuplicatePrevClass);
+		}
+	}
+
+	swiper.emitSlidesClasses();
+}

uni_modules/zebra-swiper/libs/update/updateSlidesOffset.js

@@ -0,0 +1,11 @@
+export default async function updateSlidesOffset() {
+	const swiper = this;
+	const slides = swiper.slides;
+
+	for (let i = 0; i < slides.length; i += 1) {
+		let offset = (slides[i].swiperSlideSize + swiper.params.spaceBetween) * slides[i].index;
+		slides[i].swiperSlideOffset = swiper.isHorizontal() ? offset :
+			offset;
+	}
+
+}

uni_modules/zebra-swiper/libs/update/updateSlidesProgress.js

@@ -0,0 +1,45 @@
+export default function updateSlidesProgress(translate = this && this.translate || 0) {
+	const swiper = this;
+	const params = swiper.params;
+	const {
+		slides,
+		rtlTranslate: rtl,
+		snapGrid
+	} = swiper;
+	if (slides.length === 0) return;
+	if (typeof slides[0].swiperSlideOffset === 'undefined' || typeof slides[slides.length - 1].swiperSlideOffset ===
+		'undefined') swiper
+		.updateSlidesOffset();
+	let offsetCenter = -translate;
+	if (rtl) offsetCenter = translate; // Visible Slides
+
+	swiper.visibleSlidesIndexes = [];
+	swiper.visibleSlides = [];
+	
+	// slides.forEach((item)=>)
+
+	for (let i = 0; i < slides.length; i += 1) {
+		const slide = slides[i];
+		let slideOffset = slide.swiperSlideOffset;
+		if (params.cssMode && params.centeredSlides) {
+			slideOffset -= slides[0].swiperSlideOffset;
+		}
+
+		const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (
+			slide.swiperSlideSize + params.spaceBetween);
+		const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() :
+			0) - slideOffset) / (slide.swiperSlideSize + params.spaceBetween);
+		const slideBefore = -(offsetCenter - slideOffset);
+		const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
+		const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper
+			.size || slideBefore <= 0 && slideAfter >= swiper.size;
+		if (isVisible) {
+			swiper.visibleSlides.push(slide);
+			swiper.visibleSlidesIndexes.push(i);
+			slides[i].addClass(params.slideVisibleClass);
+		}
+
+		slide.progress = rtl ? -slideProgress : slideProgress;
+		slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
+	}
+}