ganic-pandora/cjs/ganic-pandora.development.js

A cool organic programming javascript library

'use strict';

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

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var ganicUsex = _interopDefault(require('ganic-usex'));
var ganic = _interopDefault(require('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;