@elliemae/ds-utilities 2.3.0-alpha.8 → 2.3.0-next.2

package/cjs/hooks/useWindowScrollerList.js

@@ -0,0 +1,65 @@
+'use strict';
+
+var React = require('react');
+
+function getScrollOffset() {
+  let element = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+    scrollTop: 0,
+    scrollLeft: 0
+  };
+  return {
+    top: element.scrollTop,
+    left: element.scrollLeft
+  };
+}
+
+function getPositionOffset(listEl, scrollableEl) {
+  const scrollOffset = getScrollOffset(scrollableEl);
+  const elementRect = listEl.getBoundingClientRect();
+  const containerRect = scrollableEl.getBoundingClientRect();
+  return {
+    top: elementRect.top + scrollOffset.top - containerRect.top,
+    left: elementRect.left + scrollOffset.top - containerRect.left
+  };
+}
+
+function isParent(parentNode, childNode) {
+  return childNode.parentNode === parentNode || childNode.parentNode && isParent(parentNode, childNode.parentNode);
+}
+
+function useWindowScrollerList(_ref) {
+  let {
+    listInstance,
+    outerListRef
+  } = _ref;
+  const scrollableParent = React.useRef();
+  const listOffset = React.useRef();
+
+  const getElementOffset = () => {
+    listOffset.current = getPositionOffset(outerListRef.current, scrollableParent.current);
+  };
+
+  const handleScroll = e => {
+    if (!scrollableParent.current) {
+      const containerTarget = e.target === document ? document.body : e.target;
+      scrollableParent.current = isParent(containerTarget, outerListRef.current) && containerTarget;
+    }
+
+    if (!scrollableParent.current) return;
+    getElementOffset();
+    const scrollOffset = getScrollOffset(scrollableParent.current);
+    const scrollTop = Math.max(0, scrollOffset.top - listOffset.current.top);
+    if (listInstance.current) listInstance.current.scrollTo(scrollTop);
+  };
+
+  React.useEffect(() => {
+    window.addEventListener('scroll', handleScroll, true);
+    window.addEventListener('resize', getElementOffset, true);
+    return () => {
+      window.removeEventListener('scroll', handleScroll, true);
+      window.removeEventListener('resize', getElementOffset, true);
+    };
+  }, []);
+}
+
+module.exports = useWindowScrollerList;

package/cjs/hooks/useWindowSize.js

@@ -0,0 +1,27 @@
+'use strict';
+
+require('core-js/modules/web.dom-collections.iterator.js');
+var React = require('react');
+
+function useWindowSize() {
+  const [size, setSize] = React.useState([0, 0]);
+  React.useLayoutEffect(() => {
+    if (!window) return false;
+
+    function updateSize() {
+      setSize([window.innerWidth, window.innerHeight]);
+    }
+
+    window.addEventListener('resize', updateSize);
+    window.addEventListener('orientationchange', updateSize);
+    updateSize();
+    return () => {
+      window.removeEventListener('resize', updateSize);
+      window.removeEventListener('orientationchange', updateSize);
+    };
+  }, []);
+  if (!window) return false;
+  return size;
+}
+
+module.exports = useWindowSize;

package/cjs/index.js

@@ -0,0 +1,268 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var getComponentFromProps = require('./getComponentFromProps.js');
+var onClickHandlerForNonInteractiveElements = require('./onClickHandlerForNonInteractiveElements.js');
+var capitalize = require('./capitalize.js');
+var operators = require('./operators.js');
+var utils = require('./utils.js');
+var system = require('./system.js');
+var useMeasure = require('use-measure');
+var useExecutionTimer = require('./hooks/useExecutionTimer.js');
+var useExpandState = require('./hooks/useExpandState.js');
+var useHotkeys = require('./hooks/useHotkeys.js');
+var useHoverHandlersDelay = require('./hooks/useHoverHandlersDelay.js');
+var useResizeObserver = require('./hooks/useResizeObserver.js');
+var useShouldRecalculate = require('./hooks/useShouldRecalculate.js');
+var useWindowScrollerList = require('./hooks/useWindowScrollerList.js');
+var useWindowSize = require('./hooks/useWindowSize.js');
+var useForceUpdate = require('use-force-update');
+var useOnclickoutside = require('use-onclickoutside');
+var uncontrollable = require('uncontrollable');
+var usePrevious = require('./hooks/usePrevious.js');
+var useCancellableDelayedCallback = require('./hooks/useCancellableDelayedCallback.js');
+var useDerivedStateFromProps = require('./hooks/useDerivedStateFromProps.js');
+var useSetRef = require('./hooks/useSetRef.js');
+var useParentElement = require('./hooks/useParentElement.js');
+var useOnElementResize = require('./hooks/useOnElementResize.js');
+var useIsShowingEllipsis = require('./hooks/useIsShowingEllipsis.js');
+var timeUtils = require('./timeUtils.js');
+var compose = require('./compose.js');
+var platform = require('./platform.js');
+var reactTypesUtility = require('./reactTypesUtility.js');
+var scrollingTimer = require('./scrollingTimer.js');
+var validations = require('./validations.js');
+var lodash = require('lodash');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var useMeasure__default = /*#__PURE__*/_interopDefaultLegacy(useMeasure);
+var useForceUpdate__default = /*#__PURE__*/_interopDefaultLegacy(useForceUpdate);
+var useOnclickoutside__default = /*#__PURE__*/_interopDefaultLegacy(useOnclickoutside);
+
+
+
+exports.getComponentFromProps = getComponentFromProps;
+exports.onClickHandlerForNonInteractiveElements = onClickHandlerForNonInteractiveElements;
+exports.capitalize = capitalize.capitalize;
+exports.checkEmpty = operators.checkEmpty;
+exports.checkNotEmpty = operators.checkNotEmpty;
+exports.contains = operators.contains;
+exports.equal = operators.equal;
+exports.greaterThan = operators.greaterThan;
+exports.greaterThanOrEquals = operators.greaterThanOrEquals;
+exports.isIn = operators.isIn;
+exports.isNotIn = operators.isNotIn;
+exports.isNotNull = operators.isNotNull;
+exports.isNull = operators.isNull;
+exports.lessThanOrEquals = operators.lessThanOrEquals;
+exports.notEqual = operators.notEqual;
+exports.startsWith = operators.startsWith;
+exports.validDate = operators.validDate;
+exports.addOrRemove = utils.addOrRemove;
+exports.arrayMove = utils.arrayMove;
+exports.cx = utils.cx;
+exports.hashArray = utils.hashArray;
+exports.removeUndefinedProperties = utils.removeUndefinedProperties;
+exports.runAll = utils.runAll;
+exports.safeCall = utils.safeCall;
+exports.toggleInArray = utils.toggleInArray;
+exports.toggleInObject = utils.toggleInObject;
+exports.logger = system.logger;
+exports.mergeRefs = system.mergeRefs;
+exports.setRef = system.setRef;
+Object.defineProperty(exports, 'useMeasure', {
+	enumerable: true,
+	get: function () { return useMeasure__default["default"]; }
+});
+exports.useExecutionTimer = useExecutionTimer;
+exports.useExpandState = useExpandState;
+exports.useHotkeys = useHotkeys;
+exports.useHoverHandlersDelay = useHoverHandlersDelay;
+exports.useResizeObserver = useResizeObserver;
+exports.useShouldRecalculate = useShouldRecalculate;
+exports.useWindowScrollerList = useWindowScrollerList;
+exports.useWindowSize = useWindowSize;
+Object.defineProperty(exports, 'useForceUpdate', {
+	enumerable: true,
+	get: function () { return useForceUpdate__default["default"]; }
+});
+Object.defineProperty(exports, 'useOnClickOutside', {
+	enumerable: true,
+	get: function () { return useOnclickoutside__default["default"]; }
+});
+Object.defineProperty(exports, 'useUncontrolled', {
+	enumerable: true,
+	get: function () { return uncontrollable.useUncontrolled; }
+});
+exports.usePrevious = usePrevious;
+exports.useCancellableDelayedCallback = useCancellableDelayedCallback;
+exports.useDerivedStateFromProps = useDerivedStateFromProps;
+exports.useSetRef = useSetRef.useSetRef;
+exports.useParentElement = useParentElement.useParentElement;
+exports.useOnElementResize = useOnElementResize.useOnElementResize;
+exports.useIsShowingEllipsis = useIsShowingEllipsis.useIsShowingEllipsis;
+exports.addLeadingZeros = timeUtils.addLeadingZeros;
+exports.getVisibleTimeByFormat = timeUtils.getVisibleTimeByFormat;
+exports.compose = compose.compose;
+exports.DOCUMENT = platform.DOCUMENT;
+exports.WINDOW = platform.WINDOW;
+exports.isClassComponent = reactTypesUtility.isClassComponent;
+exports.isCompositeTypeElement = reactTypesUtility.isCompositeTypeElement;
+exports.isDOMTypeElement = reactTypesUtility.isDOMTypeElement;
+exports.isElement = reactTypesUtility.isElement;
+exports.isFunctionComponent = reactTypesUtility.isFunctionComponent;
+exports.isReactComponent = reactTypesUtility.isReactComponent;
+exports.resetTimer = scrollingTimer.resetTimer;
+exports.isGreaterThan = validations.isGreaterThan;
+exports.isRequired = validations.isRequired;
+exports.isValidDate = validations.isValidDate;
+Object.defineProperty(exports, 'cloneDeep', {
+	enumerable: true,
+	get: function () { return lodash.cloneDeep; }
+});
+Object.defineProperty(exports, 'curry', {
+	enumerable: true,
+	get: function () { return lodash.curry; }
+});
+Object.defineProperty(exports, 'debounce', {
+	enumerable: true,
+	get: function () { return lodash.debounce; }
+});
+Object.defineProperty(exports, 'differenceBy', {
+	enumerable: true,
+	get: function () { return lodash.differenceBy; }
+});
+Object.defineProperty(exports, 'differenceWith', {
+	enumerable: true,
+	get: function () { return lodash.differenceWith; }
+});
+Object.defineProperty(exports, 'filter', {
+	enumerable: true,
+	get: function () { return lodash.filter; }
+});
+Object.defineProperty(exports, 'findIndex', {
+	enumerable: true,
+	get: function () { return lodash.findIndex; }
+});
+Object.defineProperty(exports, 'get', {
+	enumerable: true,
+	get: function () { return lodash.get; }
+});
+Object.defineProperty(exports, 'groupBy', {
+	enumerable: true,
+	get: function () { return lodash.groupBy; }
+});
+Object.defineProperty(exports, 'isBoolean', {
+	enumerable: true,
+	get: function () { return lodash.isBoolean; }
+});
+Object.defineProperty(exports, 'isEmpty', {
+	enumerable: true,
+	get: function () { return lodash.isEmpty; }
+});
+Object.defineProperty(exports, 'isEqual', {
+	enumerable: true,
+	get: function () { return lodash.isEqual; }
+});
+Object.defineProperty(exports, 'isEqualWith', {
+	enumerable: true,
+	get: function () { return lodash.isEqualWith; }
+});
+Object.defineProperty(exports, 'isFunction', {
+	enumerable: true,
+	get: function () { return lodash.isFunction; }
+});
+Object.defineProperty(exports, 'isNaN', {
+	enumerable: true,
+	get: function () { return lodash.isNaN; }
+});
+Object.defineProperty(exports, 'isObject', {
+	enumerable: true,
+	get: function () { return lodash.isObject; }
+});
+Object.defineProperty(exports, 'isString', {
+	enumerable: true,
+	get: function () { return lodash.isString; }
+});
+Object.defineProperty(exports, 'maxBy', {
+	enumerable: true,
+	get: function () { return lodash.maxBy; }
+});
+Object.defineProperty(exports, 'meanBy', {
+	enumerable: true,
+	get: function () { return lodash.meanBy; }
+});
+Object.defineProperty(exports, 'noop', {
+	enumerable: true,
+	get: function () { return lodash.noop; }
+});
+Object.defineProperty(exports, 'omit', {
+	enumerable: true,
+	get: function () { return lodash.omit; }
+});
+Object.defineProperty(exports, 'orderBy', {
+	enumerable: true,
+	get: function () { return lodash.orderBy; }
+});
+Object.defineProperty(exports, 'padStart', {
+	enumerable: true,
+	get: function () { return lodash.padStart; }
+});
+Object.defineProperty(exports, 'parseInt', {
+	enumerable: true,
+	get: function () { return lodash.parseInt; }
+});
+Object.defineProperty(exports, 'pick', {
+	enumerable: true,
+	get: function () { return lodash.pick; }
+});
+Object.defineProperty(exports, 'pickBy', {
+	enumerable: true,
+	get: function () { return lodash.pickBy; }
+});
+Object.defineProperty(exports, 'property', {
+	enumerable: true,
+	get: function () { return lodash.property; }
+});
+Object.defineProperty(exports, 'pull', {
+	enumerable: true,
+	get: function () { return lodash.pull; }
+});
+Object.defineProperty(exports, 'range', {
+	enumerable: true,
+	get: function () { return lodash.range; }
+});
+Object.defineProperty(exports, 'set', {
+	enumerable: true,
+	get: function () { return lodash.set; }
+});
+Object.defineProperty(exports, 'sortBy', {
+	enumerable: true,
+	get: function () { return lodash.sortBy; }
+});
+Object.defineProperty(exports, 'sumBy', {
+	enumerable: true,
+	get: function () { return lodash.sumBy; }
+});
+Object.defineProperty(exports, 'throttle', {
+	enumerable: true,
+	get: function () { return lodash.throttle; }
+});
+Object.defineProperty(exports, 'transform', {
+	enumerable: true,
+	get: function () { return lodash.transform; }
+});
+Object.defineProperty(exports, 'uniq', {
+	enumerable: true,
+	get: function () { return lodash.uniq; }
+});
+Object.defineProperty(exports, 'uniqBy', {
+	enumerable: true,
+	get: function () { return lodash.uniqBy; }
+});
+Object.defineProperty(exports, 'values', {
+	enumerable: true,
+	get: function () { return lodash.values; }
+});

package/cjs/onClickHandlerForNonInteractiveElements.js

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * onClickHandler: callback
+ *
+ * @param onClickHandler
+ */
+var onClickHandlerForNonInteractiveElements = (onClickHandler => ({
+  role: 'button',
+  tabIndex: '0',
+  onClick: onClickHandler,
+  onKeyPress: event => {
+    event.stopPropagation();
+    const {
+      keycode,
+      key
+    } = event;
+    if (key === 'Enter') onClickHandler(event);else if (keycode === 13) onClickHandler(event);
+  }
+}));
+
+module.exports = onClickHandlerForNonInteractiveElements;

package/cjs/operators.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+var lodash = require('lodash');
+
+/**
+ * Check if the value is null undefined ''
+ *
+ * @param value
+ */
+
+const checkNotEmpty = value => value === '' || value === undefined || value == [] || value === null || lodash.isEmpty(value);
+const checkEmpty = value => !lodash.isEmpty(value);
+/**
+ * @param value: number
+ * @param comparator: number
+ * @param value
+ * @param comparator
+ */
+
+const greaterThan = (value, comparator) => value > comparator;
+/**
+ * Check if a valid date with format MM/DD/YYYY
+ *
+ * @param {*} value: string
+ * @param value
+ */
+
+const validDate = value => {
+  const dateValidationRegex = /^\d{1,2}\/\d{1,2}\/\d{4}$/;
+  if (!dateValidationRegex.test(value)) return false;
+  const [m, d, y] = value.split('/').map(n => Number(n));
+  return m === Number(new Date(y, m - 1, d).getMonth()) + 1 && d === Number(new Date(y, m - 1, d).getDate());
+};
+const equal = (a, b) => a === b;
+const notEqual = (a, b) => !equal(a, b);
+const isNull = a => checkNotEmpty(a);
+const isNotNull = a => !isNull(a);
+const isIn = (a, b) => b.indexOf(a) > -1;
+const isNotIn = (a, b) => !isIn(a, b);
+const greaterThanOrEquals = (value, comparator) => value >= comparator;
+const lessThanOrEquals = (value, comparator) => value <= comparator;
+const startsWith = (value, comparator) => String(value).startsWith(comparator);
+const contains = (value, comparator) => String(value).includes(comparator);
+
+exports.checkEmpty = checkEmpty;
+exports.checkNotEmpty = checkNotEmpty;
+exports.contains = contains;
+exports.equal = equal;
+exports.greaterThan = greaterThan;
+exports.greaterThanOrEquals = greaterThanOrEquals;
+exports.isIn = isIn;
+exports.isNotIn = isNotIn;
+exports.isNotNull = isNotNull;
+exports.isNull = isNull;
+exports.lessThanOrEquals = lessThanOrEquals;
+exports.notEqual = notEqual;
+exports.startsWith = startsWith;
+exports.validDate = validDate;

package/cjs/platform.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const DOCUMENT = typeof document !== 'undefined' ? document : null;
+const WINDOW = typeof window !== 'undefined' ? window : null;
+
+exports.DOCUMENT = DOCUMENT;
+exports.WINDOW = WINDOW;

package/cjs/reactTypesUtility.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+function isClassComponent(component) {
+  return !!(typeof component === 'function' && !!component.prototype.isReactComponent);
+}
+function isFunctionComponent(component) {
+  return typeof component === 'function' && String(component).includes('return React.createElement');
+}
+function isReactComponent(component) {
+  return !!(isClassComponent(component) || isFunctionComponent(component));
+}
+function isElement(element) {
+  return /*#__PURE__*/React__default["default"].isValidElement(element);
+}
+function isDOMTypeElement(element) {
+  return isElement(element) && typeof element.type === 'string';
+}
+function isCompositeTypeElement(element) {
+  return isElement(element) && typeof element.type === 'function';
+}
+
+exports.isClassComponent = isClassComponent;
+exports.isCompositeTypeElement = isCompositeTypeElement;
+exports.isDOMTypeElement = isDOMTypeElement;
+exports.isElement = isElement;
+exports.isFunctionComponent = isFunctionComponent;
+exports.isReactComponent = isReactComponent;

package/cjs/scrollingTimer.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function resetTimer(func) {
+  let timeout;
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    const context = this;
+
+    const lastCall = () => {
+      timeout = null;
+      func.apply(context, args);
+    };
+
+    clearTimeout(timeout);
+    timeout = setTimeout(lastCall, 300);
+  };
+}
+
+exports.resetTimer = resetTimer;

package/cjs/system.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/esnext.async-iterator.reduce.js');
+require('core-js/modules/esnext.iterator.reduce.js');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.filter.js');
+var lodash = require('lodash');
+
+const setRef = (ref, value) => {
+  if (lodash.isFunction(ref)) {
+    ref(value);
+  } else if (ref) {
+    ref.current = value;
+  }
+};
+function mergeRefs() {
+  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
+    refs[_key] = arguments[_key];
+  }
+
+  return node => {
+    if (!node) return;
+    refs.forEach(ref => {
+      if (lodash.isFunction(ref)) {
+        ref(node);
+      } else if (ref) {
+        ref.current = node;
+      }
+    });
+  };
+}
+function logger() {}
+
+exports.logger = logger;
+exports.mergeRefs = mergeRefs;
+exports.setRef = setRef;

package/cjs/timeUtils.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/esnext.async-iterator.reduce.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.reduce.js');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.filter.js');
+var lodash = require('lodash');
+
+const getVisibleTimeByFormat = format => ({
+  showHours: format.indexOf('H') > -1 || format.indexOf('h') > -1 || format.indexOf('k') > -1,
+  showMinutes: format.indexOf('m') > -1,
+  showSeconds: format.indexOf('s') > -1,
+  use12Hours: format.indexOf('A') > -1 || format.indexOf('h') > -1 || format.indexOf('a') > -1
+});
+const addLeadingZeros = count => number => lodash.padStart(String(number), count, '0');
+
+exports.addLeadingZeros = addLeadingZeros;
+exports.getVisibleTimeByFormat = getVisibleTimeByFormat;