cbvirtua 1.0.11 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cbvirtua",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "",
   "main": "index.js",
   "scripts": {

package/smoothscroll.js

@@ -0,0 +1,433 @@
+'use strict';
+
+// polyfill
+function polyfill() {
+  // aliases
+  var w = window;
+  var d = document;
+
+  // return if scroll behavior is supported and polyfill is not forced
+  if (
+    'scrollBehavior' in d.documentElement.style &&
+    w.__forceSmoothScrollPolyfill__ !== true
+  ) {
+    return;
+  }
+
+  // globals
+  var Element = w.HTMLElement || w.Element;
+  var SCROLL_TIME = 468;
+
+  // object gathering original scroll methods
+  var original = {
+    scroll: w.scroll || w.scrollTo,
+    scrollBy: w.scrollBy,
+    elementScroll: Element.prototype.scroll || scrollElement,
+    scrollIntoView: Element.prototype.scrollIntoView
+  };
+
+  // define timing method
+  var now =
+    w.performance && w.performance.now
+      ? w.performance.now.bind(w.performance)
+      : Date.now;
+
+  /**
+   * indicates if a the current browser is made by Microsoft
+   * @method isMicrosoftBrowser
+   * @param {String} userAgent
+   * @returns {Boolean}
+   */
+  function isMicrosoftBrowser(userAgent) {
+    var userAgentPatterns = ['MSIE ', 'Trident/', 'Edge/'];
+
+    return new RegExp(userAgentPatterns.join('|')).test(userAgent);
+  }
+
+  /*
+   * IE has rounding bug rounding down clientHeight and clientWidth and
+   * rounding up scrollHeight and scrollWidth causing false positives
+   * on hasScrollableSpace
+   */
+  var ROUNDING_TOLERANCE = isMicrosoftBrowser(w.navigator.userAgent) ? 1 : 0;
+
+  /**
+   * changes scroll position inside an element
+   * @method scrollElement
+   * @param {Number} x
+   * @param {Number} y
+   * @returns {undefined}
+   */
+  function scrollElement(x, y) {
+    this.scrollLeft = x;
+    this.scrollTop = y;
+  }
+
+  /**
+   * returns result of applying ease math function to a number
+   * @method ease
+   * @param {Number} k
+   * @returns {Number}
+   */
+  function ease(k) {
+    return 0.5 * (1 - Math.cos(Math.PI * k));
+  }
+
+  /**
+   * indicates if a smooth behavior should be applied
+   * @method shouldBailOut
+   * @param {Number|Object} firstArg
+   * @returns {Boolean}
+   */
+  function shouldBailOut(firstArg) {
+    if (
+      firstArg === null ||
+      typeof firstArg !== 'object' ||
+      firstArg.behavior === undefined ||
+      firstArg.behavior === 'auto' ||
+      firstArg.behavior === 'instant'
+    ) {
+      // first argument is not an object/null
+      // or behavior is auto, instant or undefined
+      return true;
+    }
+
+    if (typeof firstArg === 'object' && firstArg.behavior === 'smooth') {
+      // first argument is an object and behavior is smooth
+      return false;
+    }
+
+    // throw error when behavior is not supported
+    throw new TypeError(
+      'behavior member of ScrollOptions ' +
+        firstArg.behavior +
+        ' is not a valid value for enumeration ScrollBehavior.'
+    );
+  }
+
+  /**
+   * indicates if an element has scrollable space in the provided axis
+   * @method hasScrollableSpace
+   * @param {Node} el
+   * @param {String} axis
+   * @returns {Boolean}
+   */
+  function hasScrollableSpace(el, axis) {
+    if (axis === 'Y') {
+      return el.clientHeight + ROUNDING_TOLERANCE < el.scrollHeight;
+    }
+
+    if (axis === 'X') {
+      return el.clientWidth + ROUNDING_TOLERANCE < el.scrollWidth;
+    }
+  }
+
+  /**
+   * indicates if an element has a scrollable overflow property in the axis
+   * @method canOverflow
+   * @param {Node} el
+   * @param {String} axis
+   * @returns {Boolean}
+   */
+  function canOverflow(el, axis) {
+    var overflowValue = w.getComputedStyle(el, null)['overflow' + axis];
+
+    return overflowValue === 'auto' || overflowValue === 'scroll';
+  }
+
+  /**
+   * indicates if an element can be scrolled in either axis
+   * @method isScrollable
+   * @param {Node} el
+   * @param {String} axis
+   * @returns {Boolean}
+   */
+  function isScrollable(el) {
+    var isScrollableY = hasScrollableSpace(el, 'Y') && canOverflow(el, 'Y');
+    var isScrollableX = hasScrollableSpace(el, 'X') && canOverflow(el, 'X');
+
+    return isScrollableY || isScrollableX;
+  }
+
+  /**
+   * finds scrollable parent of an element
+   * @method findScrollableParent
+   * @param {Node} el
+   * @returns {Node} el
+   */
+  function findScrollableParent(el) {
+    while (el !== d.body && isScrollable(el) === false) {
+      el = el.parentNode || el.host;
+    }
+
+    return el;
+  }
+
+  /**
+   * self invoked function that, given a context, steps through scrolling
+   * @method step
+   * @param {Object} context
+   * @returns {undefined}
+   */
+  function step(context) {
+    var time = now();
+    var value;
+    var currentX;
+    var currentY;
+    var elapsed = (time - context.startTime) / SCROLL_TIME;
+
+    // avoid elapsed times higher than one
+    elapsed = elapsed > 1 ? 1 : elapsed;
+
+    // apply easing to elapsed time
+    value = ease(elapsed);
+
+    currentX = context.startX + (context.x - context.startX) * value;
+    currentY = context.startY + (context.y - context.startY) * value;
+
+    context.method.call(context.scrollable, currentX, currentY);
+
+    // scroll more if we have not reached our destination
+    if (currentX !== context.x || currentY !== context.y) {
+      w.requestAnimationFrame(step.bind(w, context));
+    }
+  }
+
+  /**
+   * scrolls window or element with a smooth behavior
+   * @method smoothScroll
+   * @param {Object|Node} el
+   * @param {Number} x
+   * @param {Number} y
+   * @returns {undefined}
+   */
+  function smoothScroll(el, x, y) {
+    var scrollable;
+    var startX;
+    var startY;
+    var method;
+    var startTime = now();
+
+    // define scroll context
+    if (el === d.body) {
+      scrollable = w;
+      startX = w.scrollX || w.pageXOffset;
+      startY = w.scrollY || w.pageYOffset;
+      method = original.scroll;
+    } else {
+      scrollable = el;
+      startX = el.scrollLeft;
+      startY = el.scrollTop;
+      method = scrollElement;
+    }
+
+    // scroll looping over a frame
+    step({
+      scrollable: scrollable,
+      method: method,
+      startTime: startTime,
+      startX: startX,
+      startY: startY,
+      x: x,
+      y: y
+    });
+  }
+
+  // ORIGINAL METHODS OVERRIDES
+  // w.scroll and w.scrollTo
+  w.scroll = w.scrollTo = function() {
+    // avoid action when no arguments are passed
+    if (arguments[0] === undefined) {
+      return;
+    }
+
+    // avoid smooth behavior if not required
+    if (shouldBailOut(arguments[0]) === true) {
+      original.scroll.call(
+        w,
+        arguments[0].left !== undefined
+          ? arguments[0].left
+          : typeof arguments[0] !== 'object'
+            ? arguments[0]
+            : w.scrollX || w.pageXOffset,
+        // use top prop, second argument if present or fallback to scrollY
+        arguments[0].top !== undefined
+          ? arguments[0].top
+          : arguments[1] !== undefined
+            ? arguments[1]
+            : w.scrollY || w.pageYOffset
+      );
+
+      return;
+    }
+
+    // LET THE SMOOTHNESS BEGIN!
+    smoothScroll.call(
+      w,
+      d.body,
+      arguments[0].left !== undefined
+        ? ~~arguments[0].left
+        : w.scrollX || w.pageXOffset,
+      arguments[0].top !== undefined
+        ? ~~arguments[0].top
+        : w.scrollY || w.pageYOffset
+    );
+  };
+
+  // w.scrollBy
+  w.scrollBy = function() {
+    // avoid action when no arguments are passed
+    if (arguments[0] === undefined) {
+      return;
+    }
+
+    // avoid smooth behavior if not required
+    if (shouldBailOut(arguments[0])) {
+      original.scrollBy.call(
+        w,
+        arguments[0].left !== undefined
+          ? arguments[0].left
+          : typeof arguments[0] !== 'object' ? arguments[0] : 0,
+        arguments[0].top !== undefined
+          ? arguments[0].top
+          : arguments[1] !== undefined ? arguments[1] : 0
+      );
+
+      return;
+    }
+
+    // LET THE SMOOTHNESS BEGIN!
+    smoothScroll.call(
+      w,
+      d.body,
+      ~~arguments[0].left + (w.scrollX || w.pageXOffset),
+      ~~arguments[0].top + (w.scrollY || w.pageYOffset)
+    );
+  };
+
+  // Element.prototype.scroll and Element.prototype.scrollTo
+  Element.prototype.scroll = Element.prototype.scrollTo = function() {
+    // avoid action when no arguments are passed
+    if (arguments[0] === undefined) {
+      return;
+    }
+
+    // avoid smooth behavior if not required
+    if (shouldBailOut(arguments[0]) === true) {
+      // if one number is passed, throw error to match Firefox implementation
+      if (typeof arguments[0] === 'number' && arguments[1] === undefined) {
+        throw new SyntaxError('Value could not be converted');
+      }
+
+      original.elementScroll.call(
+        this,
+        // use left prop, first number argument or fallback to scrollLeft
+        arguments[0].left !== undefined
+          ? ~~arguments[0].left
+          : typeof arguments[0] !== 'object' ? ~~arguments[0] : this.scrollLeft,
+        // use top prop, second argument or fallback to scrollTop
+        arguments[0].top !== undefined
+          ? ~~arguments[0].top
+          : arguments[1] !== undefined ? ~~arguments[1] : this.scrollTop
+      );
+
+      return;
+    }
+
+    var left = arguments[0].left;
+    var top = arguments[0].top;
+
+    // LET THE SMOOTHNESS BEGIN!
+    smoothScroll.call(
+      this,
+      this,
+      typeof left === 'undefined' ? this.scrollLeft : ~~left,
+      typeof top === 'undefined' ? this.scrollTop : ~~top
+    );
+  };
+
+  // Element.prototype.scrollBy
+  Element.prototype.scrollBy = function() {
+    // avoid action when no arguments are passed
+    if (arguments[0] === undefined) {
+      return;
+    }
+
+    // avoid smooth behavior if not required
+    if (shouldBailOut(arguments[0]) === true) {
+      original.elementScroll.call(
+        this,
+        arguments[0].left !== undefined
+          ? ~~arguments[0].left + this.scrollLeft
+          : ~~arguments[0] + this.scrollLeft,
+        arguments[0].top !== undefined
+          ? ~~arguments[0].top + this.scrollTop
+          : ~~arguments[1] + this.scrollTop
+      );
+
+      return;
+    }
+
+    this.scroll({
+      left: ~~arguments[0].left + this.scrollLeft,
+      top: ~~arguments[0].top + this.scrollTop,
+      behavior: arguments[0].behavior
+    });
+  };
+
+  // Element.prototype.scrollIntoView
+  Element.prototype.scrollIntoView = function() {
+    // avoid smooth behavior if not required
+    if (shouldBailOut(arguments[0]) === true) {
+      original.scrollIntoView.call(
+        this,
+        arguments[0] === undefined ? true : arguments[0]
+      );
+
+      return;
+    }
+
+    // LET THE SMOOTHNESS BEGIN!
+    var scrollableParent = findScrollableParent(this);
+    var parentRects = scrollableParent.getBoundingClientRect();
+    var clientRects = this.getBoundingClientRect();
+
+    if (scrollableParent !== d.body) {
+      // reveal element inside parent
+      smoothScroll.call(
+        this,
+        scrollableParent,
+        scrollableParent.scrollLeft + clientRects.left - parentRects.left,
+        scrollableParent.scrollTop + clientRects.top - parentRects.top
+      );
+
+      // reveal parent in viewport unless is fixed
+      if (w.getComputedStyle(scrollableParent).position !== 'fixed') {
+        w.scrollBy({
+          left: parentRects.left,
+          top: parentRects.top,
+          behavior: 'smooth'
+        });
+      }
+    } else {
+      // reveal element in viewport
+      w.scrollBy({
+        left: clientRects.left,
+        top: clientRects.top,
+        behavior: 'smooth'
+      });
+    }
+  };
+}
+
+if (typeof exports === 'object' && typeof module !== 'undefined') {
+  // commonjs
+  module.exports = { polyfill: polyfill };
+} else {
+  // global
+  polyfill();
+}
+'<svg t="1710421040192" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="4839" width="200" height="200"><path d="M895.063 350.163c-20.941-49.511-50.914-93.969-89.085-132.141-38.172-38.171-82.63-68.144-132.141-89.085C622.562 107.249 568.111 96.252 512 96.252c-56.112 0-110.562 10.997-161.837 32.685-49.511 20.941-93.969 50.914-132.141 89.085s-68.144 82.63-89.085 132.141C107.249 401.438 96.252 455.888 96.252 512c0 56.111 10.997 110.562 32.685 161.838 20.941 49.511 50.914 93.969 89.085 132.141 38.171 38.171 82.63 68.144 132.141 89.085 51.276 21.688 105.726 32.685 161.837 32.685 56.111 0 110.562-10.997 161.838-32.685 49.511-20.941 93.969-50.914 132.141-89.085 38.171-38.172 68.144-82.63 89.085-132.141 21.688-51.276 32.685-105.727 32.685-161.838-0.001-56.112-10.998-110.562-32.686-161.837zM512 864.252c-194.232 0-352.252-158.02-352.252-352.252S317.768 159.748 512 159.748 864.252 317.768 864.252 512 706.232 864.252 512 864.252z" fill="#070102" p-id="4840"></path><path d="M672 512c17.673 0 32-14.327 32-32s-14.327-32-32-32h-89.245l72.795-72.795c12.496-12.497 12.497-32.757 0-45.255-12.498-12.497-32.759-12.497-45.255 0L512 428.245l-98.295-98.294c-12.496-12.497-32.757-12.497-45.255 0-12.497 12.498-12.496 32.758 0 45.255L441.246 448H352c-17.673 0-32 14.327-32 32s14.327 32 32 32h127v64H352c-17.673 0-32 14.326-32 32s14.327 32 32 32h127v72c0 17.674 14.326 32 32 32s32-14.326 32-32v-72h129c17.673 0 32-14.326 32-32s-14.327-32-32-32H543v-64h129z" fill="#070102" p-id="4841"></path></svg>'
+'<svg t="1710421173145" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="11562" width="200" height="200"><path d="M512 64.581877c-247.101841 0-447.418123 200.316282-447.418123 447.418123s200.316282 447.418123 447.418123 447.418123 447.418123-200.316282 447.418123-447.418123S759.101841 64.581877 512 64.581877zM512 933.437401c-232.753041 0-421.437401-188.683337-421.437401-421.437401s188.683337-421.437401 421.437401-421.437401c232.753041 0 421.437401 188.683337 421.437401 421.437401S744.753041 933.437401 512 933.437401zM694.27744 557.26595c14.94948 0 28.14092 9.348925 28.14092 22.776749 0 11.403724-13.190417 21.431102-28.14092 21.431102l-157.308769 0 0 128.821971c0 11.406794-10.555403 24.792663-28.14399 24.792663-15.830547 0-29.024034-13.416568-29.024034-24.792663L479.800647 601.474824l-150.928455 0c-14.948457 0-27.290553-10.05603-27.290553-22.781866 0-12.078083 12.343119-21.427008 27.290553-21.427008l150.928455 0 0-67.075675-150.928455 0c-14.948457 0-27.290553-8.705266-27.290553-22.777773 0-11.401678 12.343119-20.786419 27.290553-20.786419l129.792065 0-104.622826-140.741441c-4.931313-11.05887-1.471514-28.000728 11.288091-34.169217 13.703093-6.623861 28.41312-0.62217 35.450397 8.731872l108.955504 146.742109 110.933555-136.095631c7.03523-10.05603 22.514783-23.778566 41.047882-12.67774 19.48068 11.667737 7.214309 34.83846 7.214309 34.83846L559.863101 446.597431l128.059608 0c14.954597 0 28.145014 9.380648 28.145014 22.13309 0 12.753465-13.190417 21.431102-28.145014 21.431102l-150.927431 0 0 67.071581 157.282163 0L694.27744 557.26595 694.27744 557.26595z" fill="#272636" p-id="11563"></path></svg>'
+'<svg t="1710253314880" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="15094" width="200" height="200"><path d="M983.490171 711.209155a510.049075 510.049075 0 0 1-109.616091 162.616925 510.049075 510.049075 0 0 1-361.761886 149.822518c-69.089803 0-136.004557-13.466114-199.14496-40.206427a510.752767 510.752767 0 0 1-162.616926-109.616091 510.049075 510.049075 0 0 1-149.822518-361.761886c0-69.089803 13.4981-136.004557 40.206427-199.14496a510.752767 510.752767 0 0 1 109.616091-162.616926A509.761201 509.761201 0 0 1 512.112194 0.47979a509.761201 509.761201 0 0 1 361.761886 149.822518 509.761201 509.761201 0 0 1 149.822518 361.761886c0 69.089803-13.594059 136.004557-40.206427 199.144961zM512.112194 73.567846C270.361855 73.567846 73.615846 270.313855 73.615846 512.064194s196.746009 438.496348 438.496348 438.496348 438.496348-196.746009 438.496348-438.496348S753.862533 73.567846 512.112194 73.567846zM267.962904 555.245321h207.621255V224.861721h73.088056v330.3836h207.58927l-244.149291 244.021347-244.14929-244.021347z" fill="#2c2c2c" p-id="15095"></path></svg>'
+'<svg t="1710253134151" class="icon" viewBox="0 0 1280 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="5527" width="200" height="200"><path d="M1099.264 372.032L640 831.296 180.8 372.032H0l640 640 640-640z" fill="#231916" p-id="5528"></path><path d="M1099.264 0L640 459.264 180.8 0H0l640 640L1280 0z" fill="#231916" p-id="5529"></path></svg>'