@sentecacommerce-theme/lib 0.12.77 → 0.12.82

package/dist/esm/hooks/useCarousel/helpers/engine.js

@@ -21,188 +21,181 @@ import { Translate } from './translate';
 import { arrayKeys, groupArray } from './utils';
 import { Vector1D } from './vector1d';
 export function Engine(root, container, slides, options, events) {
-  // Options
-  var {
-    align,
-    axis: scrollAxis,
-    startIndex,
-    inViewThreshold,
-    loop,
-    speed,
-    dragFree,
-    slidesToScroll,
-    containScroll
-  } = options; // Measurements
-
-  var axis = Axis(scrollAxis);
-  var pxToPercent = PxToPercent(axis.measure(container));
-  var viewSize = pxToPercent.totalPercent;
-  var slideSizes = slides.map(axis.measure).map(pxToPercent.measure);
-  var groupedSizes = groupArray(slideSizes, slidesToScroll);
-  var snapSizes = groupedSizes.map(g => g.reduce((a, s) => a + s));
-  var snapIndexes = arrayKeys(snapSizes);
-  var contentSize = slideSizes.reduce((a, s) => a + s, 0);
-  var alignment = Alignment({
-    align,
-    viewSize
-  });
-  var scrollSnap = ScrollSnap({
-    snapSizes,
-    alignment,
-    loop
-  });
-  var defaultSnaps = snapIndexes.map(scrollSnap.measure);
-  var contain = ScrollContain({
-    alignment,
-    contentSize,
-    viewSize
-  });
-  var shouldContain = !loop && containScroll !== '';
-  var trimSnaps = containScroll === 'trimSnaps';
-  var containedSnaps = contain.measure(defaultSnaps, trimSnaps);
-  var scrollSnaps = shouldContain ? containedSnaps : defaultSnaps; // Index
-
-  var indexMax = Math.max(0, scrollSnaps.length - 1);
-  var indexSpan = Limit({
-    min: 0,
-    max: indexMax
-  });
-  var index = Counter({
-    limit: indexSpan,
-    start: startIndex,
-    loop
-  });
-  var indexPrevious = index.clone(); // ScrollLimit
-
-  var scrollLimit = ScrollLimit({
-    loop,
-    contentSize
-  });
-  var limit = scrollLimit.measure(scrollSnaps); // Draw
-
-  var update = () => {
-    engine.scrollBody.seek(target).update();
-    var settled = engine.scrollBody.settle(target);
-
-    if (!dragHandler.pointerDown()) {
-      if (!loop) engine.scrollBounds.constrain(target);
-
-      if (settled) {
-        engine.animation.stop();
-        events.emit('settle');
-      }
-    }
-
-    if (loop) {
-      var direction = engine.scrollBody.direction.get();
-      engine.scrollLooper.loop(loopVectors, direction);
-      engine.slideLooper.loop(slides);
-    }
-
-    if (!settled) events.emit('scroll');
-    engine.translate.to(engine.scrollBody.location);
-    engine.animation.proceed();
-  }; // Shared
-
-
-  var animation = Animation(update);
-  var startLocation = scrollSnaps[index.get()];
-  var location = Vector1D(startLocation);
-  var target = Vector1D(startLocation);
-  var loopVectors = [location, target];
-  var scrollBody = ScrollBody({
-    location,
-    speed,
-    mass: 1
-  });
-  var scrollTarget = ScrollTarget({
-    contentSize,
-    index,
-    limit,
-    loop,
-    scrollSnaps,
-    target
-  });
-  var scrollTo = ScrollTo({
-    animation,
-    events,
-    index,
-    indexPrevious,
-    scrollTarget,
-    target
-  }); // DragHandler
-
-  var dragHandler = DragHandler({
-    animation,
-    axis,
-    dragFree,
-    dragTracker: DragTracker({
-      axis,
-      pxToPercent
-    }),
-    element: root,
-    events,
-    index,
-    limit,
-    location,
-    loop,
-    scrollBody,
-    scrollTo,
-    scrollTarget,
-    target
-  }); // Slider
-
-  var engine = {
-    animation,
-    axis,
-    dragHandler,
-    pxToPercent,
-    index,
-    indexPrevious,
-    limit,
-    location,
-    options,
-    scrollBody,
-    scrollBounds: ScrollBounds({
-      animation,
-      limit,
-      location,
-      scrollBody
-    }),
-    scrollLooper: ScrollLooper({
-      contentSize,
-      limit,
-      location,
-      pxToPercent
-    }),
-    scrollProgress: ScrollProgress({
-      limit
-    }),
-    scrollSnaps,
-    scrollTarget,
-    scrollTo,
-    slideLooper: SlideLooper({
-      axis,
-      contentSize,
-      location,
-      scrollSnaps,
-      slideSizes,
-      viewSize
-    }),
-    slidesInView: SlidesInView({
-      contentSize,
-      inViewThreshold,
-      loop,
-      slideSizes,
-      viewSize
-    }),
-    snapIndexes,
-    target,
-    translate: Translate({
-      axis,
-      container
-    })
-  };
-  return engine;
+    // Options
+    var align = options.align, scrollAxis = options.axis, startIndex = options.startIndex, inViewThreshold = options.inViewThreshold, loop = options.loop, speed = options.speed, dragFree = options.dragFree, slidesToScroll = options.slidesToScroll, containScroll = options.containScroll;
+    // Measurements
+    var axis = Axis(scrollAxis);
+    var pxToPercent = PxToPercent(axis.measure(container));
+    var viewSize = pxToPercent.totalPercent;
+    var slideSizes = slides.map(axis.measure).map(pxToPercent.measure);
+    var groupedSizes = groupArray(slideSizes, slidesToScroll);
+    var snapSizes = groupedSizes.map(function(g) {
+        return g.reduce(function(a, s) {
+            return a + s;
+        });
+    });
+    var snapIndexes = arrayKeys(snapSizes);
+    var contentSize = slideSizes.reduce(function(a, s) {
+        return a + s;
+    }, 0);
+    var alignment = Alignment({
+        align: align,
+        viewSize: viewSize
+    });
+    var scrollSnap = ScrollSnap({
+        snapSizes: snapSizes,
+        alignment: alignment,
+        loop: loop
+    });
+    var defaultSnaps = snapIndexes.map(scrollSnap.measure);
+    var contain = ScrollContain({
+        alignment: alignment,
+        contentSize: contentSize,
+        viewSize: viewSize
+    });
+    var shouldContain = !loop && containScroll !== '';
+    var trimSnaps = containScroll === 'trimSnaps';
+    var containedSnaps = contain.measure(defaultSnaps, trimSnaps);
+    var scrollSnaps = shouldContain ? containedSnaps : defaultSnaps;
+    // Index
+    var indexMax = Math.max(0, scrollSnaps.length - 1);
+    var indexSpan = Limit({
+        min: 0,
+        max: indexMax
+    });
+    var index = Counter({
+        limit: indexSpan,
+        start: startIndex,
+        loop: loop
+    });
+    var indexPrevious = index.clone();
+    // ScrollLimit
+    var scrollLimit = ScrollLimit({
+        loop: loop,
+        contentSize: contentSize
+    });
+    var limit = scrollLimit.measure(scrollSnaps);
+    // Draw
+    var update = function() {
+        engine.scrollBody.seek(target).update();
+        var settled = engine.scrollBody.settle(target);
+        if (!dragHandler.pointerDown()) {
+            if (!loop) engine.scrollBounds.constrain(target);
+            if (settled) {
+                engine.animation.stop();
+                events.emit('settle');
+            }
+        }
+        if (loop) {
+            var direction = engine.scrollBody.direction.get();
+            engine.scrollLooper.loop(loopVectors, direction);
+            engine.slideLooper.loop(slides);
+        }
+        if (!settled) events.emit('scroll');
+        engine.translate.to(engine.scrollBody.location);
+        engine.animation.proceed();
+    };
+    // Shared
+    var animation = Animation(update);
+    var startLocation = scrollSnaps[index.get()];
+    var location = Vector1D(startLocation);
+    var target = Vector1D(startLocation);
+    var loopVectors = [
+        location,
+        target
+    ];
+    var scrollBody = ScrollBody({
+        location: location,
+        speed: speed,
+        mass: 1
+    });
+    var scrollTarget = ScrollTarget({
+        contentSize: contentSize,
+        index: index,
+        limit: limit,
+        loop: loop,
+        scrollSnaps: scrollSnaps,
+        target: target
+    });
+    var scrollTo = ScrollTo({
+        animation: animation,
+        events: events,
+        index: index,
+        indexPrevious: indexPrevious,
+        scrollTarget: scrollTarget,
+        target: target
+    });
+    // DragHandler
+    var dragHandler = DragHandler({
+        animation: animation,
+        axis: axis,
+        dragFree: dragFree,
+        dragTracker: DragTracker({
+            axis: axis,
+            pxToPercent: pxToPercent
+        }),
+        element: root,
+        events: events,
+        index: index,
+        limit: limit,
+        location: location,
+        loop: loop,
+        scrollBody: scrollBody,
+        scrollTo: scrollTo,
+        scrollTarget: scrollTarget,
+        target: target
+    });
+    // Slider
+    var engine = {
+        animation: animation,
+        axis: axis,
+        dragHandler: dragHandler,
+        pxToPercent: pxToPercent,
+        index: index,
+        indexPrevious: indexPrevious,
+        limit: limit,
+        location: location,
+        options: options,
+        scrollBody: scrollBody,
+        scrollBounds: ScrollBounds({
+            animation: animation,
+            limit: limit,
+            location: location,
+            scrollBody: scrollBody
+        }),
+        scrollLooper: ScrollLooper({
+            contentSize: contentSize,
+            limit: limit,
+            location: location,
+            pxToPercent: pxToPercent
+        }),
+        scrollProgress: ScrollProgress({
+            limit: limit
+        }),
+        scrollSnaps: scrollSnaps,
+        scrollTarget: scrollTarget,
+        scrollTo: scrollTo,
+        slideLooper: SlideLooper({
+            axis: axis,
+            contentSize: contentSize,
+            location: location,
+            scrollSnaps: scrollSnaps,
+            slideSizes: slideSizes,
+            viewSize: viewSize
+        }),
+        slidesInView: SlidesInView({
+            contentSize: contentSize,
+            inViewThreshold: inViewThreshold,
+            loop: loop,
+            slideSizes: slideSizes,
+            viewSize: viewSize
+        }),
+        snapIndexes: snapIndexes,
+        target: target,
+        translate: Translate({
+            axis: axis,
+            container: container
+        })
+    };
+    return engine;
 }
-//# sourceMappingURL=engine.js.map

package/dist/esm/hooks/useCarousel/helpers/eventEmitter.js

@@ -1,36 +1,37 @@
 export function EventEmitter() {
-  var listeners = {
-    destroy: [],
-    pointerDown: [],
-    pointerUp: [],
-    init: [],
-    reInit: [],
-    resize: [],
-    scroll: [],
-    select: [],
-    settle: []
-  };
-
-  function emit(evt) {
-    listeners[evt].forEach(e => e(evt));
+    var emit = function emit(evt) {
+        listeners[evt].forEach(function(e) {
+            return e(evt);
+        });
+        return self;
+    };
+    var on = function on(evt, cb) {
+        listeners[evt] = listeners[evt].concat([
+            cb
+        ]);
+        return self;
+    };
+    var off = function off(evt, cb) {
+        listeners[evt] = listeners[evt].filter(function(e) {
+            return e !== cb;
+        });
+        return self;
+    };
+    var listeners = {
+        destroy: [],
+        pointerDown: [],
+        pointerUp: [],
+        init: [],
+        reInit: [],
+        resize: [],
+        scroll: [],
+        select: [],
+        settle: []
+    };
+    var self = {
+        emit: emit,
+        off: off,
+        on: on
+    };
     return self;
-  }
-
-  function on(evt, cb) {
-    listeners[evt] = listeners[evt].concat([cb]);
-    return self;
-  }
-
-  function off(evt, cb) {
-    listeners[evt] = listeners[evt].filter(e => e !== cb);
-    return self;
-  }
-
-  var self = {
-    emit,
-    off,
-    on
-  };
-  return self;
 }
-//# sourceMappingURL=eventEmitter.js.map

package/dist/esm/hooks/useCarousel/helpers/eventStore.js

@@ -1,27 +1,22 @@
 export function EventStore() {
-  var listeners = [];
-
-  function add(node, type, handler, options) {
-    if (options === void 0) {
-      options = false;
-    }
-
-    node.addEventListener(type, handler, options);
-    listeners.push(() => {
-      return node.removeEventListener(type, handler, options);
-    });
+    var add = function add(node, type, handler) {
+        var options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+        node.addEventListener(type, handler, options);
+        listeners.push(function() {
+            return node.removeEventListener(type, handler, options);
+        });
+        return self;
+    };
+    var removeAll = function removeAll() {
+        listeners = listeners.filter(function(remove) {
+            return remove();
+        });
+        return self;
+    };
+    var listeners = [];
+    var self = {
+        add: add,
+        removeAll: removeAll
+    };
     return self;
-  }
-
-  function removeAll() {
-    listeners = listeners.filter(remove => remove());
-    return self;
-  }
-
-  var self = {
-    add,
-    removeAll
-  };
-  return self;
 }
-//# sourceMappingURL=eventStore.js.map

package/dist/esm/hooks/useCarousel/helpers/limit.js

@@ -1,64 +1,51 @@
 export function Limit(params) {
-  var {
-    min,
-    max
-  } = params;
-  var loopLimits = {
-    min: max,
-    max: min
-  };
-  var constrainLimits = {
-    min,
-    max
-  };
-  var length = Math.abs(min - max);
-
-  var reachedMin = n => n < min;
-
-  var reachedMax = n => n > max;
-
-  var reachedAny = n => reachedMin(n) || reachedMax(n);
-
-  var reachedWhich = n => {
-    if (reachedMin(n)) return 'min';
-    if (reachedMax(n)) return 'max';
-    return '';
-  };
-
-  var removeOffset = n => {
-    if (min === max) return n;
-
-    while (reachedMin(n)) {
-      n += length;
-    }
-
-    while (reachedMax(n)) {
-      n -= length;
-    }
-
-    return n;
-  };
-
-  var loop = n => {
-    var which = reachedWhich(n);
-    return which ? loopLimits[which] : n;
-  };
-
-  var constrain = n => {
-    var which = reachedWhich(n);
-    return which ? constrainLimits[which] : n;
-  };
-
-  return {
-    constrain,
-    length,
-    loop,
-    max,
-    min,
-    reachedAny,
-    reachedMax,
-    reachedMin,
-    removeOffset
-  };
+    var min = params.min, max = params.max;
+    var loopLimits = {
+        min: max,
+        max: min
+    };
+    var constrainLimits = {
+        min: min,
+        max: max
+    };
+    var length = Math.abs(min - max);
+    var reachedMin = function(n) {
+        return n < min;
+    };
+    var reachedMax = function(n) {
+        return n > max;
+    };
+    var reachedAny = function(n) {
+        return reachedMin(n) || reachedMax(n);
+    };
+    var reachedWhich = function(n) {
+        if (reachedMin(n)) return 'min';
+        if (reachedMax(n)) return 'max';
+        return '';
+    };
+    var removeOffset = function(n) {
+        if (min === max) return n;
+        while(reachedMin(n))n += length;
+        while(reachedMax(n))n -= length;
+        return n;
+    };
+    var loop = function(n) {
+        var which = reachedWhich(n);
+        return which ? loopLimits[which] : n;
+    };
+    var constrain = function(n) {
+        var which = reachedWhich(n);
+        return which ? constrainLimits[which] : n;
+    };
+    return {
+        constrain: constrain,
+        length: length,
+        loop: loop,
+        max: max,
+        min: min,
+        reachedAny: reachedAny,
+        reachedMax: reachedMax,
+        reachedMin: reachedMin,
+        removeOffset: removeOffset
+    };
 }
-//# sourceMappingURL=limit.js.map

package/dist/esm/hooks/useCarousel/helpers/options.js

@@ -1,17 +1,16 @@
 export var defaultOptions = {
-  align: 'center',
-  axis: 'x',
-  containScroll: '',
-  containerSelector: '*',
-  dragFree: false,
-  draggable: true,
-  draggableClass: 'is-draggable',
-  draggingClass: 'is-dragging',
-  inViewThreshold: 0,
-  loop: false,
-  selectedClass: 'is-selected',
-  slidesToScroll: 1,
-  speed: 10,
-  startIndex: 0
+    align: 'center',
+    axis: 'x',
+    containScroll: '',
+    containerSelector: '*',
+    dragFree: false,
+    draggable: true,
+    draggableClass: 'is-draggable',
+    draggingClass: 'is-dragging',
+    inViewThreshold: 0,
+    loop: false,
+    selectedClass: 'is-selected',
+    slidesToScroll: 1,
+    speed: 10,
+    startIndex: 0
 };
-//# sourceMappingURL=options.js.map

package/dist/esm/hooks/useCarousel/helpers/pxToPercent.js

@@ -1,11 +1,10 @@
 export function PxToPercent(viewInPx) {
-  var totalPercent = 100;
-
-  var measure = n => n / viewInPx * totalPercent;
-
-  return {
-    measure,
-    totalPercent
-  };
+    var totalPercent = 100;
+    var measure = function(n) {
+        return n / viewInPx * totalPercent;
+    };
+    return {
+        measure: measure,
+        totalPercent: totalPercent
+    };
 }
-//# sourceMappingURL=pxToPercent.js.map