https://www.panjoclub-iz.com/_vendor/vue-scrollto.js

1/*!
2  * vue-scrollto v2.17.1
3  * (c) 2019 Randjelovic Igor
4  * @license MIT
5  */
6(function (global, factory) {
7  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
8  typeof define === 'function' && define.amd ? define(factory) :
9  (global = global || self, global['vue-scrollto'] = factory());
10}(this, function () { 'use strict';
11
12  function _typeof(obj) {
13    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
14      _typeof = function (obj) {
15        return typeof obj;
16      };
17    } else {
18      _typeof = function (obj) {
19        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
20      };
21    }
22
23    return _typeof(obj);
24  }
25
26  function _extends() {
27    _extends = Object.assign || function (target) {
28      for (var i = 1; i < arguments.length; i++) {
29        var source = arguments[i];
30
31        for (var key in source) {
32          if (Object.prototype.hasOwnProperty.call(source, key)) {
33            target[key] = source[key];
34          }
35        }
36      }
37
38      return target;
39    };
40
41    return _extends.apply(this, arguments);
42  }
43
44  /**
45   * https://github.com/gre/bezier-easing
46   * BezierEasing - use bezier curve for transition easing function
47   * by Gaëtan Renaudeau 2014 - 2015 – MIT License
48   */
49
50  // These values are established by empiricism with tests (tradeoff: performance VS precision)
51  var NEWTON_ITERATIONS = 4;
52  var NEWTON_MIN_SLOPE = 0.001;
53  var SUBDIVISION_PRECISION = 0.0000001;
54  var SUBDIVISION_MAX_ITERATIONS = 10;
55
56  var kSplineTableSize = 11;
57  var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
58
59  var float32ArraySupported = typeof Float32Array === 'function';
60
61  function A (aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; }
62  function B (aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; }
63  function C (aA1)      { return 3.0 * aA1; }
64
65  // Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
66  function calcBezier (aT, aA1, aA2) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT; }
67
68  // Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
69  function getSlope (aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1); }
70
71  function binarySubdivide (aX, aA, aB, mX1, mX2) {
72    var currentX, currentT, i = 0;
73    do {
74      currentT = aA + (aB - aA) / 2.0;
75      currentX = calcBezier(currentT, mX1, mX2) - aX;
76      if (currentX > 0.0) {
77        aB = currentT;
78      } else {
79        aA = currentT;
80      }
81    } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
82    return currentT;
83  }
84
85  function newtonRaphsonIterate (aX, aGuessT, mX1, mX2) {
86   for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
87     var currentSlope = getSlope(aGuessT, mX1, mX2);
88     if (currentSlope === 0.0) {
89       return aGuessT;
90     }
91     var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
92     aGuessT -= currentX / currentSlope;
93   }
94   return aGuessT;
95  }
96
97  function LinearEasing (x) {
98    return x;
99  }
100
101  var src = function bezier (mX1, mY1, mX2, mY2) {
102    if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) {
103      throw new Error('bezier x values must be in [0, 1] range');
104    }
105
106    if (mX1 === mY1 && mX2 === mY2) {
107      return LinearEasing;
108    }
109
110    // Precompute samples table
111    var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
112    for (var i = 0; i < kSplineTableSize; ++i) {
113      sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
114    }
115
116    function getTForX (aX) {
117      var intervalStart = 0.0;
118      var currentSample = 1;
119      var lastSample = kSplineTableSize - 1;
120
121      for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
122        intervalStart += kSampleStepSize;
123      }
124      --currentSample;
125
126      // Interpolate to provide an initial guess for t
127      var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
128      var guessForT = intervalStart + dist * kSampleStepSize;
129
130      var initialSlope = getSlope(guessForT, mX1, mX2);
131      if (initialSlope >= NEWTON_MIN_SLOPE) {
132        return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
133      } else if (initialSlope === 0.0) {
134        return guessForT;
135      } else {
136        return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
137      }
138    }
139
140    return function BezierEasing (x) {
141      // Because JavaScript number are imprecise, we should guarantee the extremes are right.
142      if (x === 0) {
143        return 0;
144      }
145      if (x === 1) {
146        return 1;
147      }
148      return calcBezier(getTForX(x), mY1, mY2);
149    };
150  };
151
152  var easings = {
153    ease: [0.25, 0.1, 0.25, 1.0],
154    linear: [0.0, 0.0, 1.0, 1.0],
155    'ease-in': [0.42, 0.0, 1.0, 1.0],
156    'ease-out': [0.0, 0.0, 0.58, 1.0],
157    'ease-in-out': [0.42, 0.0, 0.58, 1.0]
158  };
159
160  // https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md#feature-detection
161  var supportsPassive = false;
162
163  try {
164    var opts = Object.defineProperty({}, 'passive', {
165      get: function get() {
166        supportsPassive = true;
167      }
168    });
169    window.addEventListener('test', null, opts);
170  } catch (e) {}
171
172  var _ = {
173    $: function $(selector) {
174      if (typeof selector !== 'string') {
175        return selector;
176      }
177
178      return document.querySelector(selector);
179    },
180    on: function on(element, events, handler) {
181      var opts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {
182        passive: false
183      };
184
185      if (!(events instanceof Array)) {
186        events = [events];
187      }
188
189      for (var i = 0; i < events.length; i++) {
190        element.addEventListener(events[i], handler, supportsPassive ? opts : false);
191      }
192    },
193    off: function off(element, events, handler) {
194      if (!(events instanceof Array)) {
195        events = [events];
196      }
197
198      for (var i = 0; i < events.length; i++) {
199        element.removeEventListener(events[i], handler);
200      }
201    },
202    cumulativeOffset: function cumulativeOffset(element) {
203      var top = 0;
204      var left = 0;
205
206      do {
207        top += element.offsetTop || 0;
208        left += element.offsetLeft || 0;
209        element = element.offsetParent;
210      } while (element);
211
212      return {
213        top: top,
214        left: left
215      };
216    }
217  };
218
219  var abortEvents = ['mousedown', 'wheel', 'DOMMouseScroll', 'mousewheel', 'keyup', 'touchmove'];
220  var defaults = {
221    container: 'body',
222    duration: 500,
223    easing: 'ease',
224    offset: 0,
225    force: true,
226    cancelable: true,
227    onStart: false,
228    onDone: false,
229    onCancel: false,
230    x: false,
231    y: true
232  };
233  function setDefaults(options) {
234    defaults = _extends({}, defaults, options);
235  }
236  var scroller = function scroller() {
237    var element; // element to scroll to
238
239    var container; // container to scroll
240
241    var duration; // duration of the scrolling
242
243    var easing; // easing to be used when scrolling
244
245    var offset; // offset to be added (subtracted)
246
247    var force; // force scroll, even if element is visible
248
249    var cancelable; // indicates if user can cancel the scroll or not.
250
251    var onStart; // callback when scrolling is started
252
253    var onDone; // callback when scrolling is done
254
255    var onCancel; // callback when scrolling is canceled / aborted
256
257    var x; // scroll on x axis
258
259    var y; // scroll on y axis
260
261    var initialX; // initial X of container
262
263    var targetX; // target X of container
264
265    var initialY; // initial Y of container
266
267    var targetY; // target Y of container
268
269    var diffX; // difference
270
271    var diffY; // difference
272
273    var abort; // is scrolling aborted
274
275    var abortEv; // event that aborted scrolling
276
277    var abortFn = function abortFn(e) {
278      if (!cancelable) return;
279      abortEv = e;
280      abort = true;
281    };
282
283    var easingFn;
284    var timeStart; // time when scrolling started
285
286    var timeElapsed; // time elapsed since scrolling started
287
288    var progress; // progress
289
290    function scrollTop(container) {
291      var scrollTop = container.scrollTop;
292
293      if (container.tagName.toLowerCase() === 'body') {
294        // in firefox body.scrollTop always returns 0
295        // thus if we are trying to get scrollTop on a body tag
296        // we need to get it from the documentElement
297        scrollTop = scrollTop || document.documentElement.scrollTop;
298      }
299
300      return scrollTop;
301    }
302
303    function scrollLeft(container) {
304      var scrollLeft = container.scrollLeft;
305
306      if (container.tagName.toLowerCase() === 'body') {
307        // in firefox body.scrollLeft always returns 0
308        // thus if we are trying to get scrollLeft on a body tag
309        // we need to get it from the documentElement
310        scrollLeft = scrollLeft || document.documentElement.scrollLeft;
311      }
312
313      return scrollLeft;
314    }
315
316    function step(timestamp) {
317      if (abort) return done();
318      if (!timeStart) timeStart = timestamp;
319      timeElapsed = timestamp - timeStart;
320      progress = Math.min(timeElapsed / duration, 1);
321      progress = easingFn(progress);
322      topLeft(container, initialY + diffY * progress, initialX + diffX * progress);
323      timeElapsed < duration ? window.requestAnimationFrame(step) : done();
324    }
325
326    function done() {
327      if (!abort) topLeft(container, targetY, targetX);
328      timeStart = false;
329
330      _.off(container, abortEvents, abortFn);
331
332      if (abort && onCancel) onCancel(abortEv, element);
333      if (!abort && onDone) onDone(element);
334    }
335
336    function topLeft(element, top, left) {
337      if (y) element.scrollTop = top;
338      if (x) element.scrollLeft = left;
339
340      if (element.tagName.toLowerCase() === 'body') {
341        // in firefox body.scrollTop doesn't scroll the page
342        // thus if we are trying to scrollTop on a body tag
343        // we need to scroll on the documentElement
344        if (y) document.documentElement.scrollTop = top;
345        if (x) document.documentElement.scrollLeft = left;
346      }
347    }
348
349    function scrollTo(target, _duration) {
350      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
351
352      if (_typeof(_duration) === 'object') {
353        options = _duration;
354      } else if (typeof _duration === 'number') {
355        options.duration = _duration;
356      }
357
358      element = _.$(target);
359
360      if (!element) {
361        return console.warn('[vue-scrollto warn]: Trying to scroll to an element that is not on the page: ' + target);
362      }
363
364      container = _.$(options.container || defaults.container);
365      duration = options.duration || defaults.duration;
366      easing = options.easing || defaults.easing;
367      offset = options.offset || defaults.offset;
368      force = options.hasOwnProperty('force') ? options.force !== false : defaults.force;
369      cancelable = options.hasOwnProperty('cancelable') ? options.cancelable !== false : defaults.cancelable;
370      onStart = options.onStart || defaults.onStart;
371      onDone = options.onDone || defaults.onDone;
372      onCancel = options.onCancel || defaults.onCancel;
373      x = options.x === undefined ? defaults.x : options.x;
374      y = options.y === undefined ? defaults.y : options.y;
375
376      var cumulativeOffsetContainer = _.cumulativeOffset(container);
377
378      var cumulativeOffsetElement = _.cumulativeOffset(element);
379
380      if (typeof offset === 'function') {
381        offset = offset(element, container);
382      }
383
384      initialY = scrollTop(container);
385      targetY = cumulativeOffsetElement.top - cumulativeOffsetContainer.top + offset;
386      initialX = scrollLeft(container);
387      targetX = cumulativeOffsetElement.left - cumulativeOffsetContainer.left + offset;
388      abort = false;
389      diffY = targetY - initialY;
390      diffX = targetX - initialX;
391
392      if (!force) {
393        // When the container is the default (body) we need to use the viewport
394        // height, not the entire body height
395        var containerHeight = container.tagName.toLowerCase() === 'body' ? document.documentElement.clientHeight || window.innerHeight : container.offsetHeight;
396        var containerTop = initialY;
397        var containerBottom = containerTop + containerHeight;
398        var elementTop = targetY - offset;
399        var elementBottom = elementTop + element.offsetHeight;
400
401        if (elementTop >= containerTop && elementBottom <= containerBottom) {
402          // make sure to call the onDone callback even if there is no need to
403          // scroll the container. Fixes #111 (ref #118)
404          if (onDone) onDone(element);
405          return;
406        }
407      }
408
409      if (onStart) onStart(element);
410
411      if (!diffY && !diffX) {
412        if (onDone) onDone(element);
413        return;
414      }
415
416      if (typeof easing === 'string') {
417        easing = easings[easing] || easings['ease'];
418      }
419
420      easingFn = src.apply(src, easing);
421
422      _.on(container, abortEvents, abortFn, {
423        passive: true
424      });
425
426      window.requestAnimationFrame(step);
427      return function () {
428        abortEv = null;
429        abort = true;
430      };
431    }
432
433    return scrollTo;
434  };
435
436  var _scroller = scroller();
437
438  var bindings = []; // store binding data
439
440  function deleteBinding(el) {
441    for (var i = 0; i < bindings.length; ++i) {
442      if (bindings[i].el === el) {
443        bindings.splice(i, 1);
444        return true;
445      }
446    }
447
448    return false;
449  }
450
451  function findBinding(el) {
452    for (var i = 0; i < bindings.length; ++i) {
453      if (bindings[i].el === el) {
454        return bindings[i];
455      }
456    }
457  }
458
459  function getBinding(el) {
460    var binding = findBinding(el);
461
462    if (binding) {
463      return binding;
464    }
465
466    bindings.push(binding = {
467      el: el,
468      binding: {}
469    });
470    return binding;
471  }
472
473  function handleClick(e) {
474    e.preventDefault();
475    var ctx = getBinding(this).binding;
476
477    if (typeof ctx.value === 'string') {
478      return _scroller(ctx.value);
479    }
480
481    _scroller(ctx.value.el || ctx.value.element, ctx.value);
482  }
483
484  var VueScrollTo = {
485    bind: function bind(el, binding) {
486      getBinding(el).binding = binding;
487
488      _.on(el, 'click', handleClick);
489    },
490    unbind: function unbind(el) {
491      deleteBinding(el);
492
493      _.off(el, 'click', handleClick);
494    },
495    update: function update(el, binding) {
496      getBinding(el).binding = binding;
497    },
498    scrollTo: _scroller,
499    bindings: bindings
500  };
501
502  var install = function install(Vue, options) {
503    if (options) setDefaults(options);
504    Vue.directive('scroll-to', VueScrollTo);
505    Vue.prototype.$scrollTo = VueScrollTo.scrollTo;
506  };
507
508  if (typeof window !== 'undefined' && window.Vue) {
509    window.VueScrollTo = VueScrollTo;
510    window.VueScrollTo.setDefaults = setDefaults;
511    window.Vue.use(install);
512  }
513
514  VueScrollTo.install = install;
515
516  return VueScrollTo;
517
518}));