@sentecacommerce-theme/lib 0.12.67 → 0.13.5-alpha.1

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

@@ -2,81 +2,67 @@ import { Direction } from './direction';
 import { map, roundToDecimals } from './utils';
 import { Vector1D } from './vector1d';
 export function ScrollBody(params) {
-  var {
-    location,
-    speed,
-    mass
-  } = params;
-  var roundToTwoDecimals = roundToDecimals(2);
-  var velocity = Vector1D(0);
-  var acceleration = Vector1D(0);
-  var attraction = Vector1D(0);
-  var direction = Direction(0);
-  var state = {
-    speed,
-    mass
-  };
-
-  function update() {
-    velocity.add(acceleration);
-    location.add(velocity);
-    acceleration.multiply(0);
-  }
-
-  function applyForce(v) {
-    v.divide(state.mass);
-    acceleration.add(v);
-  }
-
-  function seek(v) {
-    attraction.set(v).subtract(location);
-    var magnitude = attraction.get();
-    var m = map(magnitude, 0, 100, 0, state.speed);
-    direction.set(attraction);
-    attraction.normalize().multiply(m).subtract(velocity);
-    applyForce(attraction);
+    var update = function update() {
+        velocity.add(acceleration);
+        location.add(velocity);
+        acceleration.multiply(0);
+    };
+    var applyForce = function applyForce(v) {
+        v.divide(state.mass);
+        acceleration.add(v);
+    };
+    var seek = function seek(v) {
+        attraction.set(v).subtract(location);
+        var magnitude = attraction.get();
+        var m = map(magnitude, 0, 100, 0, state.speed);
+        direction.set(attraction);
+        attraction.normalize().multiply(m).subtract(velocity);
+        applyForce(attraction);
+        return self;
+    };
+    var settle = function settle(v) {
+        var diff = v.get() - location.get();
+        var diffRounded = roundToTwoDecimals(diff);
+        var hasSettled = !diffRounded;
+        if (hasSettled) location.set(v);
+        return hasSettled;
+    };
+    var useSpeed = function useSpeed(n) {
+        state.speed = n;
+        return self;
+    };
+    var useDefaultSpeed = function useDefaultSpeed() {
+        useSpeed(speed);
+        return self;
+    };
+    var useMass = function useMass(n) {
+        state.mass = n;
+        return self;
+    };
+    var useDefaultMass = function useDefaultMass() {
+        useMass(mass);
+        return self;
+    };
+    var location = params.location, speed = params.speed, mass = params.mass;
+    var roundToTwoDecimals = roundToDecimals(2);
+    var velocity = Vector1D(0);
+    var acceleration = Vector1D(0);
+    var attraction = Vector1D(0);
+    var direction = Direction(0);
+    var state = {
+        speed: speed,
+        mass: mass
+    };
+    var self = {
+        direction: direction,
+        location: location,
+        seek: seek,
+        settle: settle,
+        update: update,
+        useDefaultMass: useDefaultMass,
+        useDefaultSpeed: useDefaultSpeed,
+        useMass: useMass,
+        useSpeed: useSpeed
+    };
     return self;
-  }
-
-  function settle(v) {
-    var diff = v.get() - location.get();
-    var diffRounded = roundToTwoDecimals(diff);
-    var hasSettled = !diffRounded;
-    if (hasSettled) location.set(v);
-    return hasSettled;
-  }
-
-  function useSpeed(n) {
-    state.speed = n;
-    return self;
-  }
-
-  function useDefaultSpeed() {
-    useSpeed(speed);
-    return self;
-  }
-
-  function useMass(n) {
-    state.mass = n;
-    return self;
-  }
-
-  function useDefaultMass() {
-    useMass(mass);
-    return self;
-  }
-
-  var self = {
-    direction,
-    location,
-    seek,
-    settle,
-    update,
-    useDefaultMass,
-    useDefaultSpeed,
-    useMass,
-    useSpeed
-  };
-  return self;
 }
-//# sourceMappingURL=scrollBody.js.map

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

@@ -1,45 +1,30 @@
 export function ScrollBounds(params) {
-  var {
-    limit,
-    location,
-    scrollBody,
-    animation
-  } = params;
-  var {
-    min,
-    max,
-    reachedMin,
-    reachedMax
-  } = limit;
-  var tolerance = 50;
-  var disabled = false;
-  var timeout = 0;
-
-  function shouldConstrain(v) {
-    if (disabled || timeout) return false;
-    if (reachedMin(location.get())) return v.get() !== min;
-    if (reachedMax(location.get())) return v.get() !== max;
-    return false;
-  }
-
-  function constrain(v) {
-    if (!shouldConstrain(v)) return;
-    timeout = window.setTimeout(() => {
-      var constraint = limit.constrain(v.get());
-      v.set(constraint);
-      scrollBody.useSpeed(10).useMass(3);
-      animation.start();
-      timeout = 0;
-    }, tolerance);
-  }
-
-  function toggleActive(active) {
-    disabled = !active;
-  }
-
-  return {
-    constrain,
-    toggleActive
-  };
+    var shouldConstrain = function shouldConstrain(v) {
+        if (disabled || timeout) return false;
+        if (reachedMin(location.get())) return v.get() !== min;
+        if (reachedMax(location.get())) return v.get() !== max;
+        return false;
+    };
+    var constrain = function constrain(v) {
+        if (!shouldConstrain(v)) return;
+        timeout = window.setTimeout(function() {
+            var constraint = limit.constrain(v.get());
+            v.set(constraint);
+            scrollBody.useSpeed(10).useMass(3);
+            animation.start();
+            timeout = 0;
+        }, tolerance);
+    };
+    var toggleActive = function toggleActive(active) {
+        disabled = !active;
+    };
+    var limit = params.limit, location = params.location, scrollBody = params.scrollBody, animation = params.animation;
+    var min = limit.min, max = limit.max, reachedMin = limit.reachedMin, reachedMax = limit.reachedMax;
+    var tolerance = 50;
+    var disabled = false;
+    var timeout = 0;
+    return {
+        constrain: constrain,
+        toggleActive: toggleActive
+    };
 }
-//# sourceMappingURL=scrollBounds.js.map

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

@@ -1,41 +1,32 @@
 import { Limit } from './limit';
 export function ScrollContain(params) {
-  var {
-    alignment,
-    contentSize,
-    viewSize
-  } = params;
-  var scrollBounds = Limit({
-    min: -contentSize + viewSize,
-    max: 0
-  });
-  var alignedWithinView = [alignment.measure(contentSize)];
-  var contentExceedsView = contentSize > viewSize;
-
-  var findDuplicates = scrollSnaps => {
-    var startSnap = scrollSnaps[0];
-    var endSnap = scrollSnaps[scrollSnaps.length - 1];
-    var min = scrollSnaps.lastIndexOf(startSnap) + 1;
-    var max = scrollSnaps.indexOf(endSnap);
-    return Limit({
-      min,
-      max
+    var alignment = params.alignment, contentSize = params.contentSize, viewSize = params.viewSize;
+    var scrollBounds = Limit({
+        min: -contentSize + viewSize,
+        max: 0
     });
-  };
-
-  var measure = (scrollSnaps, trim) => {
-    var containedSnaps = scrollSnaps.map(scrollBounds.constrain);
-    var {
-      min,
-      max
-    } = findDuplicates(containedSnaps);
-    if (!contentExceedsView) return alignedWithinView;
-    if (!trim) return containedSnaps;
-    return containedSnaps.slice(min - 1, max + 1);
-  };
-
-  return {
-    measure
-  };
+    var alignedWithinView = [
+        alignment.measure(contentSize)
+    ];
+    var contentExceedsView = contentSize > viewSize;
+    var findDuplicates = function(scrollSnaps) {
+        var startSnap = scrollSnaps[0];
+        var endSnap = scrollSnaps[scrollSnaps.length - 1];
+        var min = scrollSnaps.lastIndexOf(startSnap) + 1;
+        var max = scrollSnaps.indexOf(endSnap);
+        return Limit({
+            min: min,
+            max: max
+        });
+    };
+    var measure = function(scrollSnaps, trim) {
+        var containedSnaps = scrollSnaps.map(scrollBounds.constrain);
+        var ref = findDuplicates(containedSnaps), min = ref.min, max = ref.max;
+        if (!contentExceedsView) return alignedWithinView;
+        if (!trim) return containedSnaps;
+        return containedSnaps.slice(min - 1, max + 1);
+    };
+    return {
+        measure: measure
+    };
 }
-//# sourceMappingURL=scrollContain.js.map

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

@@ -1,23 +1,17 @@
 import { Limit } from './limit';
 export function ScrollLimit(params) {
-  var {
-    contentSize,
-    loop
-  } = params;
-
-  function measure(scrollSnaps) {
-    var startSnap = scrollSnaps[0];
-    var endSnap = scrollSnaps[scrollSnaps.length - 1];
-    var min = loop ? startSnap - contentSize : endSnap;
-    var max = startSnap;
-    return Limit({
-      min,
-      max
-    });
-  }
-
-  return {
-    measure
-  };
+    var measure = function measure(scrollSnaps) {
+        var startSnap = scrollSnaps[0];
+        var endSnap = scrollSnaps[scrollSnaps.length - 1];
+        var min = loop ? startSnap - contentSize : endSnap;
+        var max = startSnap;
+        return Limit({
+            min: min,
+            max: max
+        });
+    };
+    var contentSize = params.contentSize, loop = params.loop;
+    return {
+        measure: measure
+    };
 }
-//# sourceMappingURL=scrollLimit.js.map

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

@@ -1,35 +1,25 @@
 import { Limit } from './limit';
 export function ScrollLooper(params) {
-  var {
-    contentSize,
-    location,
-    limit,
-    pxToPercent
-  } = params;
-  var min = limit.min + pxToPercent.measure(0.1);
-  var max = limit.max + pxToPercent.measure(0.1);
-  var {
-    reachedMin,
-    reachedMax
-  } = Limit({
-    min,
-    max
-  });
-
-  function shouldLoop(direction) {
-    if (direction === 1) return reachedMax(location.get());
-    if (direction === -1) return reachedMin(location.get());
-    return false;
-  }
-
-  function loop(vectors, direction) {
-    if (!shouldLoop(direction)) return;
-    var loopDistance = contentSize * (direction * -1);
-    vectors.forEach(v => v.add(loopDistance));
-  }
-
-  return {
-    loop
-  };
+    var shouldLoop = function shouldLoop(direction) {
+        if (direction === 1) return reachedMax(location.get());
+        if (direction === -1) return reachedMin(location.get());
+        return false;
+    };
+    var loop = function loop(vectors, direction) {
+        if (!shouldLoop(direction)) return;
+        var loopDistance = contentSize * (direction * -1);
+        vectors.forEach(function(v) {
+            return v.add(loopDistance);
+        });
+    };
+    var contentSize = params.contentSize, location = params.location, limit = params.limit, pxToPercent = params.pxToPercent;
+    var min = limit.min + pxToPercent.measure(0.1);
+    var max = limit.max + pxToPercent.measure(0.1);
+    var ref = Limit({
+        min: min,
+        max: max
+    }), reachedMin = ref.reachedMin, reachedMax = ref.reachedMax;
+    return {
+        loop: loop
+    };
 }
-//# sourceMappingURL=scrollLooper.js.map

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

@@ -1,16 +1,10 @@
 export function ScrollProgress(params) {
-  var {
-    max,
-    length: scrollLength
-  } = params.limit;
-
-  function get(n) {
-    var currentLocation = n - max;
-    return currentLocation / -scrollLength;
-  }
-
-  return {
-    get
-  };
+    var get = function get(n) {
+        var currentLocation = n - max;
+        return currentLocation / -scrollLength;
+    };
+    var _limit = params.limit, max = _limit.max, scrollLength = _limit.length;
+    return {
+        get: get
+    };
 }
-//# sourceMappingURL=scrollProgress.js.map

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

@@ -1,38 +1,31 @@
 import { Counter } from './counter';
 import { Limit } from './limit';
 export function ScrollSnap(params) {
-  var {
-    snapSizes,
-    alignment,
-    loop
-  } = params;
-  var alignments = snapSizes.map(alignment.measure);
-
-  var distancesBetweenScrollSnaps = () => {
-    var limit = Limit({
-      min: 0,
-      max: snapSizes.length - 1
-    });
-    var counter = Counter({
-      limit,
-      start: 0,
-      loop
-    });
-    return snapSizes.map((size, index) => {
-      var next = counter.set(index + 1).get();
-      return size + alignments[index] - alignments[next];
-    });
-  };
-
-  var distancesBetween = distancesBetweenScrollSnaps();
-
-  var measure = index => {
-    var sizes = distancesBetween.slice(0, index);
-    return sizes.reduce((a, s) => a - s, alignments[0]);
-  };
-
-  return {
-    measure
-  };
+    var snapSizes = params.snapSizes, alignment = params.alignment, loop = params.loop;
+    var alignments = snapSizes.map(alignment.measure);
+    var distancesBetweenScrollSnaps = function() {
+        var limit = Limit({
+            min: 0,
+            max: snapSizes.length - 1
+        });
+        var counter = Counter({
+            limit: limit,
+            start: 0,
+            loop: loop
+        });
+        return snapSizes.map(function(size, index) {
+            var next = counter.set(index + 1).get();
+            return size + alignments[index] - alignments[next];
+        });
+    };
+    var distancesBetween = distancesBetweenScrollSnaps();
+    var measure = function(index) {
+        var sizes = distancesBetween.slice(0, index);
+        return sizes.reduce(function(a, s) {
+            return a - s;
+        }, alignments[0]);
+    };
+    return {
+        measure: measure
+    };
 }
-//# sourceMappingURL=scrollSnap.js.map

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

@@ -1,83 +1,71 @@
 export function ScrollTarget(params) {
-  var {
-    loop,
-    limit,
-    scrollSnaps,
-    contentSize
-  } = params;
-  var {
-    reachedMax,
-    reachedAny,
-    removeOffset
-  } = limit;
-
-  var minDistance = (d1, d2) => Math.abs(d1) < Math.abs(d2) ? d1 : d2;
-
-  var findTargetSnap = target => {
-    var distance = removeOffset(target);
-    var ascDiffsToSnaps = scrollSnaps.map(scrollSnap => scrollSnap - distance).map(diffToSnap => shortcut(diffToSnap, 0)).map((diff, i) => ({
-      diff,
-      index: i
-    })).sort((d1, d2) => Math.abs(d1.diff) - Math.abs(d2.diff));
-    var {
-      index
-    } = ascDiffsToSnaps[0];
-    return {
-      index,
-      distance
+    var loop = params.loop, limit = params.limit, scrollSnaps = params.scrollSnaps, contentSize = params.contentSize;
+    var reachedMax = limit.reachedMax, reachedAny = limit.reachedAny, removeOffset = limit.removeOffset;
+    var minDistance = function(d1, d2) {
+        return Math.abs(d1) < Math.abs(d2) ? d1 : d2;
     };
-  };
-
-  var shortcut = (target, direction) => {
-    var t1 = target;
-    var t2 = target + contentSize;
-    var t3 = target - contentSize;
-    if (!loop) return t1;
-    if (!direction) return minDistance(minDistance(t1, t2), t3);
-    var shortest = minDistance(t1, direction === 1 ? t2 : t3);
-    return Math.abs(shortest) * direction;
-  };
-
-  var findTargetIndex = (target, index) => {
-    var reachedBound = !loop && reachedAny(target);
-    if (!reachedBound) return index;
-    var {
-      min,
-      max
-    } = params.index;
-    return reachedMax(target) ? min : max;
-  };
-
-  var byIndex = (index, direction) => {
-    var diffToSnap = scrollSnaps[index] - params.target.get();
-    var distance = shortcut(diffToSnap, direction);
-    return {
-      index,
-      distance
+    var findTargetSnap = function(target) {
+        var distance = removeOffset(target);
+        var ascDiffsToSnaps = scrollSnaps.map(function(scrollSnap) {
+            return scrollSnap - distance;
+        }).map(function(diffToSnap) {
+            return shortcut(diffToSnap, 0);
+        }).map(function(diff, i) {
+            return {
+                diff: diff,
+                index: i
+            };
+        }).sort(function(d1, d2) {
+            return Math.abs(d1.diff) - Math.abs(d2.diff);
+        });
+        var index = ascDiffsToSnaps[0].index;
+        return {
+            index: index,
+            distance: distance
+        };
+    };
+    var shortcut = function(target, direction) {
+        var t1 = target;
+        var t2 = target + contentSize;
+        var t3 = target - contentSize;
+        if (!loop) return t1;
+        if (!direction) return minDistance(minDistance(t1, t2), t3);
+        var shortest = minDistance(t1, direction === 1 ? t2 : t3);
+        return Math.abs(shortest) * direction;
+    };
+    var findTargetIndex = function(target, index) {
+        var reachedBound = !loop && reachedAny(target);
+        if (!reachedBound) return index;
+        var _index = params.index, min = _index.min, max = _index.max;
+        return reachedMax(target) ? min : max;
+    };
+    var byIndex = function(index, direction) {
+        var diffToSnap = scrollSnaps[index] - params.target.get();
+        var distance = shortcut(diffToSnap, direction);
+        return {
+            index: index,
+            distance: distance
+        };
     };
-  };
-
-  var byDistance = (distance, snap) => {
-    var target = params.target.get() + distance;
-    var targetSnap = findTargetSnap(target);
-    var index = findTargetIndex(target, targetSnap.index);
-    var reachedBound = !loop && reachedAny(target);
-    if (!snap || reachedBound) return {
-      index,
-      distance
+    var byDistance = function(distance, snap) {
+        var target = params.target.get() + distance;
+        var targetSnap = findTargetSnap(target);
+        var index = findTargetIndex(target, targetSnap.index);
+        var reachedBound = !loop && reachedAny(target);
+        if (!snap || reachedBound) return {
+            index: index,
+            distance: distance
+        };
+        var diffToSnap = scrollSnaps[index] - targetSnap.distance;
+        var snapDistance = distance + shortcut(diffToSnap, 0);
+        return {
+            index: index,
+            distance: snapDistance
+        };
     };
-    var diffToSnap = scrollSnaps[index] - targetSnap.distance;
-    var snapDistance = distance + shortcut(diffToSnap, 0);
     return {
-      index,
-      distance: snapDistance
+        byDistance: byDistance,
+        byIndex: byIndex,
+        shortcut: shortcut
     };
-  };
-
-  return {
-    byDistance,
-    byIndex,
-    shortcut
-  };
 }
-//# sourceMappingURL=scrollTarget.js.map