@pingux/astro 1.27.0-alpha.25 → 1.27.0-alpha.26

package/lib/hooks/useCopyToClipboard/useCopyToClipboard.js

@@ -0,0 +1,69 @@
+import _regeneratorRuntime from "@babel/runtime-corejs3/regenerator";
+import _asyncToGenerator from "@babel/runtime-corejs3/helpers/esm/asyncToGenerator";
+
+var useCopyToClipboard = function useCopyToClipboard(value) {
+  var setIsCopied = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {};
+  return /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var textArea, isSuccessful;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+
+            if (!navigator.clipboard) {
+              _context.next = 7;
+              break;
+            }
+
+            _context.next = 4;
+            return navigator.clipboard.writeText(value);
+
+          case 4:
+            setIsCopied(true);
+            _context.next = 20;
+            break;
+
+          case 7:
+            // Workaround for copying in insecure origin
+            textArea = document.createElement('textarea');
+            textArea.value = value;
+            textArea.style.position = 'fixed';
+            document.body.appendChild(textArea);
+            textArea.focus();
+            textArea.select();
+            isSuccessful = document.execCommand('copy');
+            textArea.remove();
+
+            if (!isSuccessful) {
+              _context.next = 19;
+              break;
+            }
+
+            setIsCopied(isSuccessful);
+            _context.next = 20;
+            break;
+
+          case 19:
+            throw new Error('Unable to copy message');
+
+          case 20:
+            _context.next = 25;
+            break;
+
+          case 22:
+            _context.prev = 22;
+            _context.t0 = _context["catch"](0);
+            // eslint-disable-next-line no-console
+            console.error('Failed to copy: ', _context.t0);
+
+          case 25:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[0, 22]]);
+  }));
+};
+
+export default useCopyToClipboard;

package/lib/hooks/useCopyToClipboard/useCopyToClipboard.test.js

@@ -0,0 +1,64 @@
+import _Object$defineProperty from "@babel/runtime-corejs3/core-js-stable/object/define-property";
+import _Object$defineProperties from "@babel/runtime-corejs3/core-js-stable/object/define-properties";
+import _Object$getOwnPropertyDescriptors from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptors";
+import _forEachInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/for-each";
+import _Object$getOwnPropertyDescriptor from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor";
+import _filterInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/filter";
+import _Object$getOwnPropertySymbols from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols";
+import _Object$keys from "@babel/runtime-corejs3/core-js-stable/object/keys";
+import _regeneratorRuntime from "@babel/runtime-corejs3/regenerator";
+import _asyncToGenerator from "@babel/runtime-corejs3/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); enumerableOnly && (symbols = _filterInstanceProperty(symbols).call(symbols, function (sym) { return _Object$getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var _context2, _context3; var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? _forEachInstanceProperty(_context2 = ownKeys(Object(source), !0)).call(_context2, function (key) { _defineProperty(target, key, source[key]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(target, _Object$getOwnPropertyDescriptors(source)) : _forEachInstanceProperty(_context3 = ownKeys(Object(source))).call(_context3, function (key) { _Object$defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import useCopyToClipboard from './useCopyToClipboard';
+var mockCopyText = 'test';
+
+var originalClipboard = _objectSpread({}, global.navigator.clipboard);
+
+var originalExecCommand = global.document.execCommand;
+beforeEach(function () {
+  global.navigator.clipboard = {
+    writeText: jest.fn()
+  };
+  global.document.execCommand = jest.fn();
+  global.document.execCommand.mockReturnValue(true);
+});
+afterEach(function () {
+  jest.resetAllMocks();
+  global.navigator.clipboard = originalClipboard;
+  global.document.execCommand = originalExecCommand;
+});
+test('default return', function () {
+  var copyToClipboard = useCopyToClipboard();
+  expect(copyToClipboard).toEqual(expect.any(Function));
+});
+test('should copy text that passed in props', function () {
+  var copyToClipboard = useCopyToClipboard(mockCopyText);
+  copyToClipboard();
+  expect(navigator.clipboard.writeText).toHaveBeenCalledWith(mockCopyText);
+});
+test('should call setIsCopied once function will be called', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+  var mockSetIsCopied, copyToClipboard;
+  return _regeneratorRuntime.wrap(function _callee$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          mockSetIsCopied = jest.fn();
+          copyToClipboard = useCopyToClipboard(mockCopyText, mockSetIsCopied);
+          _context.next = 4;
+          return copyToClipboard();
+
+        case 4:
+          expect(mockSetIsCopied).toHaveBeenCalledWith(true);
+
+        case 5:
+        case "end":
+          return _context.stop();
+      }
+    }
+  }, _callee);
+})));

package/lib/hooks/useDebounce/index.js

@@ -0,0 +1 @@
+export { default } from './useDebounce';

package/lib/hooks/useDebounce/useDebounce.js

@@ -0,0 +1,26 @@
+import _setTimeout from "@babel/runtime-corejs3/core-js-stable/set-timeout";
+import _slicedToArray from "@babel/runtime-corejs3/helpers/esm/slicedToArray";
+import { useEffect, useState } from 'react';
+
+var useDebounce = function useDebounce(props) {
+  var value = props.value,
+      delay = props.delay;
+
+  var _useState = useState(value),
+      _useState2 = _slicedToArray(_useState, 2),
+      debouncedValue = _useState2[0],
+      setDebouncedValue = _useState2[1];
+
+  useEffect(function () {
+    var handler = _setTimeout(function () {
+      setDebouncedValue(value);
+    }, [delay]);
+
+    return function () {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+};
+
+export default useDebounce;

package/lib/hooks/useDebounce/useDebounce.test.js

@@ -0,0 +1,41 @@
+import { act, renderHook } from '@testing-library/react-hooks';
+import useDebounce from '../useDebounce';
+describe('useDebounce', function () {
+  jest.useFakeTimers();
+  it('Updates value only after `delay` milliseconds have expired', function () {
+    var _renderHook = renderHook(function (_ref) {
+      var value = _ref.value,
+          delay = _ref.delay;
+      return useDebounce({
+        value: value,
+        delay: delay
+      });
+    }, {
+      initialProps: {
+        value: 'foo',
+        delay: 500
+      }
+    }),
+        result = _renderHook.result,
+        rerender = _renderHook.rerender;
+
+    expect(result.current).toBe('foo');
+    act(function () {
+      return jest.advanceTimersByTime(510);
+    });
+    expect(result.current).toBe('foo');
+    rerender({
+      value: 'bar',
+      delay: 500
+    });
+    expect(result.current).toBe('foo');
+    act(function () {
+      return jest.advanceTimersByTime(498);
+    });
+    expect(result.current).toBe('foo');
+    act(function () {
+      return jest.advanceTimersByTime(3);
+    });
+    expect(result.current).toBe('bar');
+  });
+});

package/lib/hooks/useDeprecationWarning/index.js

@@ -0,0 +1 @@
+export { default } from './useDeprecationWarning';

package/lib/hooks/useDeprecationWarning/useDeprecationWarning.js

@@ -0,0 +1,40 @@
+import _Set from "@babel/runtime-corejs3/core-js-stable/set";
+import { useEffect } from 'react';
+var alreadyShown = new _Set();
+/**
+ * Provides a development-only console warning on component mount.
+ * @param {String} text - The deprecation warning text. It should describe what is being deprecated,
+ * when it is being deprecated (what lib version usually), and what to use instead.
+ * @param {object} options
+ * @param {boolean} options.isActive - whether warning should be shown
+ * @param {boolean} options.onlyOnce - if true then warning will be globally shown just once
+ * e.g. "\`MyField\` will be deprecated in Astro-UI 1.0.0, use \`MyOtherField\` instead."
+ */
+
+var useDeprecationWarning = function useDeprecationWarning() {
+  var text = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      _ref$onlyOnce = _ref.onlyOnce,
+      onlyOnce = _ref$onlyOnce === void 0 ? true : _ref$onlyOnce,
+      _ref$isActive = _ref.isActive,
+      isActive = _ref$isActive === void 0 ? true : _ref$isActive;
+
+  useEffect(function () {
+    if (!isActive) {
+      return;
+    }
+
+    if (onlyOnce && alreadyShown.has(text)) {
+      return;
+    }
+
+    if (process.env.NODE_ENV === 'development') {
+      alreadyShown.add(text); // eslint-disable-next-line no-console
+
+      console.warn("".concat(text), '\n', '\n', 'NOTE: This is a development-only warning and will not display in production.');
+    }
+  }, [isActive]);
+};
+
+export default useDeprecationWarning;

package/lib/hooks/useDeprecationWarning/useDeprecationWarning.test.js

@@ -0,0 +1,89 @@
+import _sliceInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/slice";
+import _toArray from "@babel/runtime-corejs3/helpers/esm/toArray";
+import { renderHook } from '@testing-library/react-hooks';
+import useDeprecationWarning from './useDeprecationWarning'; // since we cannot reset `alreadyShown` inside of module we will generate unique messages
+
+var uniqueIndex = 0;
+
+function generateUniqueMessage() {
+  var message = "Text ".concat(uniqueIndex);
+  uniqueIndex += 1;
+  return message;
+}
+
+beforeEach(function () {
+  process.env.NODE_ENV = 'development';
+
+  global.console.warn = function () {
+    return jest.mock();
+  }; // eslint-disable-line no-console
+
+});
+afterEach(function () {
+  process.env.NODE_ENV = 'test';
+  jest.restoreAllMocks();
+});
+test('default useDeprecationWarning', function () {
+  var spy = jest.spyOn(console, 'warn');
+  expect(spy).not.toHaveBeenCalled();
+  renderHook(function () {
+    return useDeprecationWarning();
+  });
+  expect(spy).toHaveBeenCalledTimes(1);
+});
+test('useDeprecationWarning with string', function () {
+  var string = generateUniqueMessage();
+  var spy = jest.spyOn(console, 'warn');
+  expect(spy).not.toHaveBeenCalled();
+  renderHook(function () {
+    return useDeprecationWarning(string);
+  });
+  expect(spy).toHaveBeenNthCalledWith(1, expect.stringMatching(string), expect.any(String), expect.any(String), expect.any(String));
+});
+test('useDeprecationWarning by default ignores duplicated messages', function () {
+  var spy = jest.spyOn(console, 'warn');
+  var message = generateUniqueMessage();
+  renderHook(function () {
+    return useDeprecationWarning(message);
+  });
+  renderHook(function () {
+    return useDeprecationWarning(message);
+  });
+  expect(spy).toHaveBeenCalledTimes(1);
+});
+test('useDeprecationWarning shows same message for few times if explicitly allowed', function () {
+  var spy = jest.spyOn(console, 'warn');
+  var message = generateUniqueMessage();
+  renderHook(function () {
+    return useDeprecationWarning(message, {
+      onlyOnce: false
+    });
+  });
+  renderHook(function () {
+    return useDeprecationWarning(message, {
+      onlyOnce: false
+    });
+  });
+  expect(spy).toHaveBeenCalledTimes(2);
+});
+test('shows message after isActive is flipped from false to true', function () {
+  var spy = jest.spyOn(console, 'warn');
+  var message = generateUniqueMessage();
+
+  var _renderHook = renderHook(function (_ref) {
+    var _ref2 = _toArray(_ref),
+        args = _sliceInstanceProperty(_ref2).call(_ref2, 0);
+
+    return useDeprecationWarning.apply(void 0, args);
+  }, {
+    initialProps: [message, {
+      isActive: false
+    }]
+  }),
+      rerender = _renderHook.rerender;
+
+  rerender([message, {
+    isActive: true
+  }]);
+  expect(spy).toHaveBeenCalledTimes(1);
+});

package/lib/hooks/useDevelopmentWarning/index.js

@@ -0,0 +1 @@
+export { default } from './useDevelopmentWarning';

package/lib/hooks/useDevelopmentWarning/useDevelopmentWarning.js

@@ -0,0 +1,17 @@
+import { useMemo } from 'react';
+/**
+ * Provides a development-only console warning.
+*/
+
+var useDevelopmentWarning = function useDevelopmentWarning(_ref) {
+  var message = _ref.message,
+      shouldTrigger = _ref.shouldTrigger;
+  useMemo(function () {
+    if (process.env.NODE_ENV === 'development' && shouldTrigger) {
+      // eslint-disable-next-line no-console
+      console.warn("".concat(message), '\n', '\n', 'NOTE: This is a development-only warning and will not display in production.');
+    }
+  }, [message, shouldTrigger]);
+};
+
+export default useDevelopmentWarning;

package/lib/hooks/useDevelopmentWarning/useDevelopmentWarning.test.js

@@ -0,0 +1,37 @@
+import { renderHook } from '@testing-library/react-hooks';
+import useDevelopmentWarning from './useDevelopmentWarning';
+var message = 'This is test message';
+beforeEach(function () {
+  process.env.NODE_ENV = 'development';
+
+  global.console.warn = function () {
+    return jest.mock();
+  }; // eslint-disable-line no-console
+
+});
+afterEach(function () {
+  process.env.NODE_ENV = 'test';
+  jest.restoreAllMocks();
+});
+test('useDevelopmentWarning with message and trigger false', function () {
+  var spy = jest.spyOn(console, 'warn');
+  expect(spy).not.toHaveBeenCalled();
+  renderHook(function () {
+    return useDevelopmentWarning({
+      message: message,
+      shouldTrigger: false
+    });
+  });
+  expect(spy).not.toHaveBeenCalled();
+});
+test('useDevelopmentWarning with message and trigger true', function () {
+  var spy = jest.spyOn(console, 'warn');
+  expect(spy).not.toHaveBeenCalled();
+  renderHook(function () {
+    return useDevelopmentWarning({
+      message: message,
+      shouldTrigger: true
+    });
+  });
+  expect(spy).toHaveBeenNthCalledWith(1, expect.stringMatching(message), expect.any(String), expect.any(String), expect.any(String));
+});

package/lib/hooks/useFallbackImage/index.js

@@ -0,0 +1 @@
+export { default } from './useFallbackImage';

package/lib/hooks/useFallbackImage/useFallbackImage.js

@@ -0,0 +1,32 @@
+import _setTimeout from "@babel/runtime-corejs3/core-js-stable/set-timeout";
+import { useEffect, useMemo } from 'react';
+
+var useFallbackImage = function useFallbackImage(_ref) {
+  var imageSrc = _ref.src,
+      onImageLoad = _ref.onImageLoad,
+      onImageError = _ref.onImageError,
+      fallbackTimeout = _ref.fallbackTimeout,
+      onFallbackTimeout = _ref.onFallbackTimeout;
+  var displayImage = useMemo(function () {
+    return document.createElement('img');
+  }, []);
+  useEffect(function () {
+    displayImage.src = imageSrc;
+    displayImage.onload = onImageLoad;
+    displayImage.onerror = onImageError;
+    return function () {
+      displayImage.onload = null;
+      displayImage.onerror = null;
+    };
+  }, []);
+  useEffect(function () {
+    var timeoutId = 0;
+    timeoutId = _setTimeout(onFallbackTimeout, fallbackTimeout);
+    return function () {
+      return clearTimeout(timeoutId);
+    };
+  }, []);
+  return displayImage;
+};
+
+export default useFallbackImage;

package/lib/hooks/useFallbackImage/useFallbackImage.test.js

@@ -0,0 +1,51 @@
+import _Object$defineProperty from "@babel/runtime-corejs3/core-js-stable/object/define-property";
+import _Object$defineProperties from "@babel/runtime-corejs3/core-js-stable/object/define-properties";
+import _Object$getOwnPropertyDescriptors from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptors";
+import _forEachInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/for-each";
+import _Object$getOwnPropertyDescriptor from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor";
+import _filterInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/filter";
+import _Object$getOwnPropertySymbols from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols";
+import _Object$keys from "@babel/runtime-corejs3/core-js-stable/object/keys";
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); enumerableOnly && (symbols = _filterInstanceProperty(symbols).call(symbols, function (sym) { return _Object$getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var _context, _context2; var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? _forEachInstanceProperty(_context = ownKeys(Object(source), !0)).call(_context, function (key) { _defineProperty(target, key, source[key]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(target, _Object$getOwnPropertyDescriptors(source)) : _forEachInstanceProperty(_context2 = ownKeys(Object(source))).call(_context2, function (key) { _Object$defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { renderHook } from '@testing-library/react-hooks';
+import useFallbackImage from './useFallbackImage';
+var defaultProps = {
+  src: 'test-src',
+  fallbackImage: 'test-fallback-src',
+  onImageLoad: jest.fn(),
+  onImageError: jest.fn(),
+  fallbackTimeout: 5,
+  onFallbackTimeout: jest.fn()
+};
+test('should return node if all props are correct ', function () {
+  var _renderHook = renderHook(function () {
+    return useFallbackImage(defaultProps);
+  }),
+      current = _renderHook.result.current;
+
+  expect(current).toBeInstanceOf(HTMLImageElement);
+});
+test('should not trigger onImageLoad if no fallback passed', function () {
+  renderHook(function () {
+    return useFallbackImage(_objectSpread(_objectSpread({}, defaultProps), {}, {
+      fallbackImage: null
+    }));
+  });
+  expect(defaultProps.onImageLoad).not.toHaveBeenCalled();
+});
+test('should not trigger onImageLoad if component unmounted', function () {
+  var _renderHook2 = renderHook(function () {
+    return useFallbackImage(_objectSpread(_objectSpread({}, defaultProps), {}, {
+      fallbackImage: null
+    }));
+  }),
+      unmount = _renderHook2.unmount;
+
+  unmount();
+  expect(defaultProps.onImageLoad).not.toHaveBeenCalled();
+});

package/lib/hooks/useField/index.js

@@ -0,0 +1 @@
+export { default } from './useField';