ganic-pandora/umd/ganic-pandora.development.js

A cool organic programming javascript library

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('ganic-usex'), require('ganic')) :
  typeof define === 'function' && define.amd ? define(['exports', 'ganic-usex', 'ganic'], factory) :
  (global = global || self, factory(global.GanicPandora = {}, global.GanicUseX, global.Ganic));
}(this, (function (exports, ganicUsex, ganic) { 'use strict';

  ganicUsex = ganicUsex && ganicUsex.hasOwnProperty('default') ? ganicUsex['default'] : ganicUsex;
  ganic = ganic && ganic.hasOwnProperty('default') ? ganic['default'] : ganic;

  var broswerInfo = {
    isMobile: /mobile/i.test(navigator.userAgent),
    isIE: /MSIE/i.test(navigator.userAgent) || /Trident/i.test(navigator.userAgent)
  };

  var useBrowser = function useBrowser() {
    return broswerInfo;
  };

  function _slicedToArray(arr, i) {
    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
  }

  function _arrayWithHoles(arr) {
    if (Array.isArray(arr)) return arr;
  }

  function _iterableToArrayLimit(arr, i) {
    if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
      return;
    }

    var _arr = [];
    var _n = true;
    var _d = false;
    var _e = undefined;

    try {
      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);

        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"] != null) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  function _nonIterableRest() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance");
  }

  var useCallback = ganicUsex.useCallback,
      useState = ganicUsex.useState,
      useEffect = ganicUsex.useEffect;

  var useClick = function useClick() {
    var _useState = useState({
      clientX: 0,
      clientY: 0
    }),
        _useState2 = _slicedToArray(_useState, 2),
        position = _useState2[0],
        setPosition = _useState2[1];

    var mouseTracker = useCallback(function (_ref) {
      var clientX = _ref.clientX,
          clientY = _ref.clientY;
      return setPosition({
        clientX: clientX + 1,
        clientY: clientY + 1
      });
    });
    useEffect(function () {
      document.addEventListener('click', mouseTracker);
      document.addEventListener('touchend', mouseTracker, {
        passive: true
      });
      return function () {
        document.removeEventListener('click', mouseTracker);
        document.removeEventListener('touchend', mouseTracker);
      };
    });
    return position;
  };

  var useClick_1 = useClick;

  var attach = ganic.attach;
  var useRef = ganicUsex.useRef;
  var runningIntervals = {};
  var intervalRefSets = {};

  var removeRefLastDelay = function removeRefLastDelay(ref) {
    if (intervalRefSets[ref.lastDelay]) {
      intervalRefSets[ref.lastDelay].delete(ref);
    }
  };

  var removeRefDelay = function removeRefDelay(ref) {
    if (intervalRefSets[ref.delay]) {
      intervalRefSets[ref.delay].delete(ref);
    }
  };

  var addRef = function addRef(ref) {
    removeRefLastDelay(ref);
    var delay = ref.delay;

    if (typeof delay === 'number') {
      if (intervalRefSets[delay]) {
        intervalRefSets[delay].add(ref);
      } else {
        intervalRefSets[delay] = new Set([ref]);
      }

      if (!runningIntervals[delay]) {
        runningIntervals[delay] = setInterval(function () {
          return callRefs(delay);
        }, delay);
      }
    }
  };

  var getRefSet = function getRefSet(delay) {
    return intervalRefSets[delay];
  };

  var callRefs = function callRefs(delay) {
    var refSet = getRefSet(delay);

    if (!refSet || !refSet.size) {
      clearInterval(runningIntervals[delay]);
      runningIntervals[delay] = null;
      intervalRefSets[delay] = null;
      return;
    }

    refSet.forEach(function (ref) {
      ref.callback();
    });
  };

  var useGlobalInterval = function useGlobalInterval(callback, delay) {
    var ref = useRef();
    ref.callback = callback;
    attach(function (interval) {
      ref.lastDelay = ref.delay;
      ref.delay = interval;
      addRef(ref);
      return function () {
        removeRefDelay(ref);
      };
    }, delay);
  };

  var useGlobalInterval_1 = useGlobalInterval;

  var useState$1 = ganicUsex.useState;

  var getDocumentElementCount = function getDocumentElementCount() {
    return document.querySelectorAll('*').length;
  };

  var getDocInfo = function getDocInfo() {
    return {
      count: getDocumentElementCount()
    };
  };

  var initDocInfo = getDocInfo();

  var useDocument = function useDocument() {
    var _useState = useState$1(initDocInfo),
        _useState2 = _slicedToArray(_useState, 2),
        docInfo = _useState2[0],
        setDocInfo = _useState2[1];

    useGlobalInterval_1(function () {
      return setDocInfo(getDocInfo());
    }, 100);
    return docInfo;
  };

  var useDocument_1 = useDocument;

  var useState$2 = ganicUsex.useState;
  var listeners = new Set();

  var wakeListeners = function wakeListeners(fps) {
    listeners.forEach(function (fn) {
      return fn(fps);
    });
  };

  var running = false;

  var runFPSChecker = function runFPSChecker() {
    var be = Date.now();
    var fps = 0;

    var loop = function loop() {
      if (!listeners.size) {
        running = false;
        return;
      }

      running = true;
      var now = Date.now();
      fps = Math.round(1000 / (now - be));
      be = now;
      requestAnimationFrame(loop);

      if (fps <= 60) {
        wakeListeners(fps);
      }
    };

    requestAnimationFrame(loop);
  };

  var requestFPS = function requestFPS(fn) {
    listeners.add(fn);

    if (running) {
      return;
    }

    runFPSChecker();
  };

  var useFPS = function useFPS() {
    var _useState = useState$2(0),
        _useState2 = _slicedToArray(_useState, 2),
        fps = _useState2[0],
        setFPS = _useState2[1];

    requestFPS(setFPS);
    return fps;
  };

  var useFPS_1 = useFPS;

  var useRef$1 = ganicUsex.useRef,
      useState$3 = ganicUsex.useState;

  var useMotion = function useMotion(value, timeBudget) {
    var _useState = useState$3(value),
        _useState2 = _slicedToArray(_useState, 2),
        current = _useState2[0],
        setCurrent = _useState2[1];

    var ref = useRef$1();

    if (ref.target !== value) {
      ref.startValue = current;
      ref.target = value;
      ref.startAt = Date.now();
    }

    var defaultInterval = 50;
    var timeout = timeBudget < defaultInterval;
    var approached = current === ref.target;
    var interval = approached ? null : defaultInterval;
    useGlobalInterval_1(function () {
      var timeSpent = Date.now() - ref.startAt;
      var timeLeft = timeBudget - timeSpent;

      if (timeLeft <= interval) {
        setCurrent(ref.target);
        return;
      }

      setCurrent(function (_current) {
        var diff = ref.target - ref.startValue;
        var times = timeBudget / interval;
        var approach = diff / times;
        return _current + approach;
      });
    }, interval);

    if (timeout && !approached) {
      setCurrent(ref.target);
    }

    return current;
  };

  var useMotion_1 = useMotion;

  var useCallback$1 = ganicUsex.useCallback,
      useState$4 = ganicUsex.useState,
      useEffect$1 = ganicUsex.useEffect;

  var useMouse = function useMouse() {
    var _useState = useState$4({
      clientX: 0,
      clientY: 0
    }),
        _useState2 = _slicedToArray(_useState, 2),
        position = _useState2[0],
        setPosition = _useState2[1];

    var mouseTracker = useCallback$1(function (_ref) {
      var clientX = _ref.clientX,
          clientY = _ref.clientY;
      return setPosition({
        clientX: clientX + 1,
        clientY: clientY + 1
      });
    });
    useEffect$1(function () {
      document.addEventListener('mousemove', mouseTracker);
      document.addEventListener('touchend', mouseTracker, {
        passive: true
      });
      return function () {
        document.removeEventListener('mousemove', mouseTracker);
        document.removeEventListener('touchend', mouseTracker);
      };
    });
    return position;
  };

  var useMouse_1 = useMouse;

  var useRef$2 = ganicUsex.useRef,
      useEffect$2 = ganicUsex.useEffect;

  var mouseUpEffect = function mouseUpEffect(ref) {
    var fn = function fn(e) {
      if (typeof ref.current === 'function') {
        ref.current(e);
      }
    };

    document.documentElement.addEventListener('mouseup', fn);
    document.documentElement.addEventListener('touchend', fn, {
      passive: true
    });
    return function () {
      document.documentElement.removeEventListener('mouseup', fn);
      document.documentElement.removeEventListener('touchend', fn, {
        passive: true
      });
      ref.current = null;
    };
  };

  var useMouseUp = function useMouseUp(fn) {
    var ref = useRef$2();
    ref.current = fn;
    useEffect$2(mouseUpEffect, ref);
  };

  var useMouseUp_1 = useMouseUp;

  var useState$5 = ganicUsex.useState,
      useInterval = ganicUsex.useInterval,
      useCallback$2 = ganicUsex.useCallback;

  var usePress = function usePress(onPress) {
    var interlude = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;

    var _useState = useState$5(null),
        _useState2 = _slicedToArray(_useState, 2),
        interval = _useState2[0],
        setInterval = _useState2[1];

    useInterval(onPress, interval);
    useMouseUp_1(function () {
      setInterval(null);
    });
    var attachPress = useCallback$2(function (fn) {
      return function (e) {
        setInterval(interlude);

        if (typeof fn === 'function') {
          fn(e);
        }
      };
    });
    return attachPress;
  };

  var usePress_1 = usePress;

  var floor = function floor(num) {
    var unit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
    return Math.floor(num - num % unit);
  };

  var math_floor = floor;

  var useState$6 = ganicUsex.useState,
      useRef$3 = ganicUsex.useRef;

  var getRefRect = function getRefRect(domRef) {
    var unit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;

    if (!domRef.current || !domRef.current.parentElement || !domRef.current.getBoundingClientRect) {
      return;
    }

    var _domRef$current$getBo = domRef.current.getBoundingClientRect(),
        _domRef$current$getBo2 = _domRef$current$getBo.width,
        width = _domRef$current$getBo2 === void 0 ? 0 : _domRef$current$getBo2,
        _domRef$current$getBo3 = _domRef$current$getBo.height,
        height = _domRef$current$getBo3 === void 0 ? 0 : _domRef$current$getBo3,
        _domRef$current$getBo4 = _domRef$current$getBo.top,
        top = _domRef$current$getBo4 === void 0 ? 0 : _domRef$current$getBo4,
        _domRef$current$getBo5 = _domRef$current$getBo.right,
        right = _domRef$current$getBo5 === void 0 ? 0 : _domRef$current$getBo5,
        _domRef$current$getBo6 = _domRef$current$getBo.bottom,
        bottom = _domRef$current$getBo6 === void 0 ? 0 : _domRef$current$getBo6,
        _domRef$current$getBo7 = _domRef$current$getBo.left,
        left = _domRef$current$getBo7 === void 0 ? 0 : _domRef$current$getBo7;

    return {
      width: math_floor(width, unit),
      height: math_floor(height, unit),
      top: math_floor(top, unit),
      right: math_floor(right, unit),
      bottom: math_floor(bottom, unit),
      left: math_floor(left, unit)
    };
  };

  var useRectRef = function useRectRef() {
    var ref = useRef$3();

    var _useState = useState$6(function () {
      return getRefRect(ref);
    }),
        _useState2 = _slicedToArray(_useState, 2),
        rect = _useState2[0],
        setRect = _useState2[1];

    useGlobalInterval_1(function () {
      return setRect(getRefRect(ref));
    }, 100);
    return [rect, ref];
  };

  var useRectRef_1 = useRectRef;

  var useCallback$3 = ganicUsex.useCallback,
      useState$7 = ganicUsex.useState;

  var useReducer = function useReducer(reducer, initState) {
    var _useState = useState$7(initState),
        _useState2 = _slicedToArray(_useState, 2),
        state = _useState2[0],
        setState = _useState2[1];

    var dispatch = useCallback$3(function (action) {
      return setState(function (s) {
        return reducer(s, action);
      });
    });
    return [state, dispatch];
  };

  var useReducer_1 = useReducer;

  var useState$8 = ganicUsex.useState;

  var getStoredValue = function getStoredValue(key, initValue) {
    if (!key) {
      return initValue;
    }

    try {
      return JSON.parse(window.localStorage[key]);
    } catch (e) {
      return initValue;
    }
  };

  var setStoredValue = function setStoredValue(key, value) {
    if (!key) {
      return;
    }

    try {
      window.localStorage[key] = JSON.stringify(value);
    } catch (e) {}
  };

  var useStorage = function useStorage(key, defaultValue) {
    var _useState = useState$8(function () {
      return getStoredValue(key, defaultValue);
    }),
        _useState2 = _slicedToArray(_useState, 2),
        value = _useState2[0],
        setValue = _useState2[1];

    setStoredValue(key, value);
    return [value, setValue];
  };

  var useStorage_1 = useStorage;

  var useState$9 = ganicUsex.useState;

  var getViewport = function getViewport() {
    var unit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
    return {
      width: math_floor(window.innerWidth, unit),
      height: math_floor(window.innerHeight, unit),
      scrollX: math_floor(document.documentElement.scrollLeft, unit),
      scrollY: math_floor(document.documentElement.scrollTop, unit)
    };
  };

  var useViewport = function useViewport() {
    var unit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;

    var _useState = useState$9(getViewport),
        _useState2 = _slicedToArray(_useState, 2),
        viewport = _useState2[0],
        setViewport = _useState2[1];

    useGlobalInterval_1(function () {
      return setViewport(getViewport(unit));
    }, 100);
    return viewport;
  };

  var useViewport_1 = useViewport;

  var ganicPandora = {
    useBrowser: useBrowser,
    useClick: useClick_1,
    useDocument: useDocument_1,
    useFPS: useFPS_1,
    useGlobalInterval: useGlobalInterval_1,
    useMotion: useMotion_1,
    useMouse: useMouse_1,
    useMouseUp: useMouseUp_1,
    usePress: usePress_1,
    useRectRef: useRectRef_1,
    useReducer: useReducer_1,
    useStorage: useStorage_1,
    useViewport: useViewport_1
  };
  var ganicPandora_1 = ganicPandora.useBrowser;
  var ganicPandora_2 = ganicPandora.useClick;
  var ganicPandora_3 = ganicPandora.useDocument;
  var ganicPandora_4 = ganicPandora.useFPS;
  var ganicPandora_5 = ganicPandora.useGlobalInterval;
  var ganicPandora_6 = ganicPandora.useMotion;
  var ganicPandora_7 = ganicPandora.useMouse;
  var ganicPandora_8 = ganicPandora.useMouseUp;
  var ganicPandora_9 = ganicPandora.usePress;
  var ganicPandora_10 = ganicPandora.useRectRef;
  var ganicPandora_11 = ganicPandora.useReducer;
  var ganicPandora_12 = ganicPandora.useStorage;
  var ganicPandora_13 = ganicPandora.useViewport;

  exports.default = ganicPandora;
  exports.useBrowser = ganicPandora_1;
  exports.useClick = ganicPandora_2;
  exports.useDocument = ganicPandora_3;
  exports.useFPS = ganicPandora_4;
  exports.useGlobalInterval = ganicPandora_5;
  exports.useMotion = ganicPandora_6;
  exports.useMouse = ganicPandora_7;
  exports.useMouseUp = ganicPandora_8;
  exports.usePress = ganicPandora_9;
  exports.useRectRef = ganicPandora_10;
  exports.useReducer = ganicPandora_11;
  exports.useStorage = ganicPandora_12;
  exports.useViewport = ganicPandora_13;

  Object.defineProperty(exports, '__esModule', { value: true });

})));