@onepercentio/one-ui 0.19.2 → 0.19.3

package/dist/hooks/ui/useTilt.js

@@ -1,143 +1,171 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.givenTheRelativePositionHowMuchToRotate = exports.calculateDistanceRelativeToBounds = exports.useTiltUpdates = void 0;
-const throttle_1 = __importDefault(require("lodash/throttle"));
-const react_1 = require("react");
-const helpers_1 = require("../../components/Parallax/math/helpers");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateDistanceRelativeToBounds = calculateDistanceRelativeToBounds;
+exports.default = useTilt;
+exports.givenTheRelativePositionHowMuchToRotate = givenTheRelativePositionHowMuchToRotate;
+exports.useTiltUpdates = useTiltUpdates;
+var _throttle = _interopRequireDefault(require("lodash/throttle"));
+var _react = require("react");
+var _helpers = require("../../components/Parallax/math/helpers");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 const MAX_TILT = {
-    x: 100,
-    y: 100,
+  x: 100,
+  y: 100
 };
-function useTiltUpdates(active, relativeToEl, onTilt, onInverseMatrix, sensorScale = 1, tiltLimit = MAX_TILT, options) {
-    (0, react_1.useEffect)(() => {
-        var _a;
-        if (active) {
-            const updatePositions = (relativeToX, relativeToY) => {
-                var _a, _b;
-                const el = relativeToEl.current;
-                const rect = el.getBoundingClientRect();
-                const { width: [x0, xW], height: [y0, yH], } = {
-                    width: [rect.left, el.clientWidth],
-                    height: [rect.top, el.clientHeight],
-                };
-                const distanceOffRight = calculateDistanceRelativeToBounds(relativeToX, x0, xW, (_a = options === null || options === void 0 ? void 0 : options.round) !== null && _a !== void 0 ? _a : true);
-                const distanceOffBottom = calculateDistanceRelativeToBounds(relativeToY, y0, yH, (_b = options === null || options === void 0 ? void 0 : options.round) !== null && _b !== void 0 ? _b : true);
-                const howMuchToRotateY = givenTheRelativePositionHowMuchToRotate(distanceOffRight, tiltLimit.y);
-                const howMuchToRotateX = givenTheRelativePositionHowMuchToRotate(distanceOffBottom, tiltLimit.x);
-                onTilt({
-                    y: howMuchToRotateX * 2,
-                    x: howMuchToRotateY * 2,
-                });
-            };
-            const handler = (0, throttle_1.default)(({ x, y }) => {
-                updatePositions(x, y);
-            }, 1000 / 30);
-            const touchHandler = (0, throttle_1.default)(({ touches }) => {
-                const { pageX, pageY } = touches[0];
-                updatePositions(pageX, pageY);
-            }, 1000 / 30);
-            window.addEventListener("mousemove", handler);
-            window.addEventListener("touchmove", touchHandler);
-            let _inverseMatrix;
-            const _limits = {
-                beta: undefined,
-                gamma: undefined,
-            };
-            const orientationListener = ({ beta, gamma, }) => {
-                beta = beta * 0.5;
-                gamma = gamma * 0.5;
-                if (!_inverseMatrix) {
-                    window.removeEventListener("mousemove", handler);
-                    window.removeEventListener("touchmove", touchHandler);
-                    const offset = 12.5;
-                    _limits.beta = [beta - offset, beta + offset];
-                    _limits.gamma = [gamma - offset, gamma + offset];
-                }
-                const _beta = Math.min(_limits.beta[1], Math.max(_limits.beta[0], beta));
-                const _gamma = Math.min(_limits.gamma[1], Math.max(_limits.gamma[0], gamma));
-                if (!_inverseMatrix && onInverseMatrix) {
-                    onInverseMatrix(() => {
-                        return (_inverseMatrix = (0, helpers_1.flattenMatrix)((0, helpers_1.invertMatrix)((0, helpers_1.generateMatrixFromOperations)({
-                            type: "rotateY",
-                            angle: _gamma,
-                        }, {
-                            type: "rotateX",
-                            angle: -_beta,
-                        }))));
-                    });
-                }
-                onTilt({
-                    y: -_beta * sensorScale,
-                    x: _gamma * sensorScale,
-                });
-            };
-            function removeListeners() {
-                window.removeEventListener("mousemove", handler);
-                window.removeEventListener("touchmove", touchHandler);
-            }
-            if ((_a = options === null || options === void 0 ? void 0 : options.gyroEnabled) !== null && _a !== void 0 ? _a : true) {
-                window.addEventListener("deviceorientation", orientationListener);
-                return () => {
-                    window.removeEventListener("deviceorientation", orientationListener);
-                    removeListeners();
-                };
-            }
-            else {
-                return () => removeListeners();
-            }
+function useTiltUpdates(active, relativeToEl, onTilt, onInverseMatrix) {
+  let sensorScale = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;
+  let tiltLimit = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : MAX_TILT;
+  let options = arguments.length > 6 ? arguments[6] : undefined;
+  (0, _react.useEffect)(function () {
+    if (active) {
+      var _options$gyroEnabled;
+      let removeListeners = function removeListeners() {
+        window.removeEventListener("mousemove", handler);
+        window.removeEventListener("touchmove", touchHandler);
+      };
+      const updatePositions = function updatePositions(relativeToX, relativeToY) {
+        var _options$round, _options$round2;
+        const el = relativeToEl.current;
+        const rect = el.getBoundingClientRect();
+        const _width$height = {
+            width: [rect.left, el.clientWidth],
+            height: [rect.top, el.clientHeight]
+          },
+          _width$height$width = _slicedToArray(_width$height.width, 2),
+          x0 = _width$height$width[0],
+          xW = _width$height$width[1],
+          _width$height$height = _slicedToArray(_width$height.height, 2),
+          y0 = _width$height$height[0],
+          yH = _width$height$height[1];
+        const distanceOffRight = calculateDistanceRelativeToBounds(relativeToX, x0, xW, (_options$round = options === null || options === void 0 ? void 0 : options.round) !== null && _options$round !== void 0 ? _options$round : true);
+        const distanceOffBottom = calculateDistanceRelativeToBounds(relativeToY, y0, yH, (_options$round2 = options === null || options === void 0 ? void 0 : options.round) !== null && _options$round2 !== void 0 ? _options$round2 : true);
+        const howMuchToRotateY = givenTheRelativePositionHowMuchToRotate(distanceOffRight, tiltLimit.y);
+        const howMuchToRotateX = givenTheRelativePositionHowMuchToRotate(distanceOffBottom, tiltLimit.x);
+        onTilt({
+          y: howMuchToRotateX * 2,
+          x: howMuchToRotateY * 2
+        });
+      };
+      const handler = (0, _throttle.default)(function (_ref) {
+        let x = _ref.x,
+          y = _ref.y;
+        updatePositions(x, y);
+      }, 1000 / 30);
+      const touchHandler = (0, _throttle.default)(function (_ref2) {
+        let touches = _ref2.touches;
+        const _touches$ = touches[0],
+          pageX = _touches$.pageX,
+          pageY = _touches$.pageY;
+        updatePositions(pageX, pageY);
+      }, 1000 / 30);
+      window.addEventListener("mousemove", handler);
+      window.addEventListener("touchmove", touchHandler);
+      let _inverseMatrix;
+      const _limits = {
+        beta: undefined,
+        gamma: undefined
+      };
+      const orientationListener = function orientationListener(_ref3) {
+        let beta = _ref3.beta,
+          gamma = _ref3.gamma;
+        beta = beta * 0.5;
+        gamma = gamma * 0.5;
+        if (!_inverseMatrix) {
+          window.removeEventListener("mousemove", handler);
+          window.removeEventListener("touchmove", touchHandler);
+          const offset = 12.5;
+          _limits.beta = [beta - offset, beta + offset];
+          _limits.gamma = [gamma - offset, gamma + offset];
+        }
+        const _beta = Math.min(_limits.beta[1], Math.max(_limits.beta[0], beta));
+        const _gamma = Math.min(_limits.gamma[1], Math.max(_limits.gamma[0], gamma));
+        if (!_inverseMatrix && onInverseMatrix) {
+          onInverseMatrix(function () {
+            return _inverseMatrix = (0, _helpers.flattenMatrix)((0, _helpers.invertMatrix)((0, _helpers.generateMatrixFromOperations)({
+              type: "rotateY",
+              angle: _gamma
+            }, {
+              type: "rotateX",
+              angle: -_beta
+            })));
+          });
         }
-    }, [active, onInverseMatrix, onTilt]);
+        onTilt({
+          y: -_beta * sensorScale,
+          x: _gamma * sensorScale
+        });
+      };
+      if ((_options$gyroEnabled = options === null || options === void 0 ? void 0 : options.gyroEnabled) !== null && _options$gyroEnabled !== void 0 ? _options$gyroEnabled : true) {
+        window.addEventListener("deviceorientation", orientationListener);
+        return function () {
+          window.removeEventListener("deviceorientation", orientationListener);
+          removeListeners();
+        };
+      } else {
+        return function () {
+          return removeListeners();
+        };
+      }
+    }
+  }, [active, onInverseMatrix, onTilt]);
 }
-exports.useTiltUpdates = useTiltUpdates;
+
 /**
  * This hook binds to two methods for calculating tilt
  *
  * When available: The device sensors
  * When on desktop: The mouse position relative to a ref
  */
-function useTilt(active, 
-/**
- * A scale to increase the values from the sensors
- *
- * @hack You can set this value to 0 as a way to disable the tilt calc on mobile
- */
-sensorScale = 1, maxTilt = MAX_TILT, options) {
-    const [tilt, setTilt] = (0, react_1.useState)({
-        x: 0,
-        y: 0,
-    });
-    const [tiltResetMatrix, setTiltResetMatrix] = (0, react_1.useState)(() => (0, helpers_1.flattenMatrix)((0, helpers_1.IDENTITY_MATRIX)()));
-    const relativeTo = (0, react_1.useRef)(null);
-    useTiltUpdates(active, relativeTo, setTilt, setTiltResetMatrix, sensorScale, maxTilt, options);
-    return {
-        /** The element to monitor mouse hover relative to */
-        relativeTo,
-        /**
-         * The matrix that represents the original tilt, so it can be used with the tilt prop to tilt relative to the user
-         * Use it on css like so transform: matrix3d(tiltResetMatrix.join(",")) rotateX(tilt.x) rotateY(tilt.y)
-         */
-        tiltResetMatrix,
-        /**
-         * How much tilt should be applied based
-         */
-        tilt,
-    };
+function useTilt(active) {
+  let sensorScale = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  let maxTilt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : MAX_TILT;
+  let options = arguments.length > 3 ? arguments[3] : undefined;
+  const _useState = (0, _react.useState)({
+      x: 0,
+      y: 0
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    tilt = _useState2[0],
+    setTilt = _useState2[1];
+  const _useState3 = (0, _react.useState)(function () {
+      return (0, _helpers.flattenMatrix)((0, _helpers.IDENTITY_MATRIX)());
+    }),
+    _useState4 = _slicedToArray(_useState3, 2),
+    tiltResetMatrix = _useState4[0],
+    setTiltResetMatrix = _useState4[1];
+  const relativeTo = (0, _react.useRef)(null);
+  useTiltUpdates(active, relativeTo, setTilt, setTiltResetMatrix, sensorScale, maxTilt, options);
+  return {
+    /** The element to monitor mouse hover relative to */
+    relativeTo: relativeTo,
+    /**
+     * The matrix that represents the original tilt, so it can be used with the tilt prop to tilt relative to the user
+     * Use it on css like so transform: matrix3d(tiltResetMatrix.join(",")) rotateX(tilt.x) rotateY(tilt.y)
+     */
+    tiltResetMatrix: tiltResetMatrix,
+    /**
+     * How much tilt should be applied based
+     */
+    tilt: tilt
+  };
 }
-exports.default = useTilt;
 function calculateDistanceRelativeToBounds(mousePosition, elementInitialPosition, elementSizeDimension, shouldRound) {
-    const normalizeInitialPosition = mousePosition - elementInitialPosition;
-    const doNotAllowGoingBeyondLowerLimit = Math.max(normalizeInitialPosition, 0);
-    const doNotAllowHoingBeyondHigherLimit = Math.min(doNotAllowGoingBeyondLowerLimit, elementSizeDimension);
-    const threeRule = (doNotAllowHoingBeyondHigherLimit * 100) / elementSizeDimension;
-    const result = (shouldRound ? Math.round(threeRule) : threeRule) / 100;
-    return result;
+  const normalizeInitialPosition = mousePosition - elementInitialPosition;
+  const doNotAllowGoingBeyondLowerLimit = Math.max(normalizeInitialPosition, 0);
+  const doNotAllowHoingBeyondHigherLimit = Math.min(doNotAllowGoingBeyondLowerLimit, elementSizeDimension);
+  const threeRule = doNotAllowHoingBeyondHigherLimit * 100 / elementSizeDimension;
+  const result = (shouldRound ? Math.round(threeRule) : threeRule) / 100;
+  return result;
 }
-exports.calculateDistanceRelativeToBounds = calculateDistanceRelativeToBounds;
 function givenTheRelativePositionHowMuchToRotate(relativePosition, maxRotation) {
-    return relativePosition * maxRotation - maxRotation / 2;
-}
-exports.givenTheRelativePositionHowMuchToRotate = givenTheRelativePositionHowMuchToRotate;
-//# sourceMappingURL=useTilt.js.map
+  return relativePosition * maxRotation - maxRotation / 2;
+}

package/dist/hooks/ui/useZoomable.js

@@ -1,151 +1,127 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = __importStar(require("react"));
-const useZoomable_module_scss_1 = __importDefault(require("./useZoomable.module.scss"));
-const react_dom_1 = __importDefault(require("react-dom"));
-const useHero_1 = __importDefault(require("../useHero"));
-const useMergeRefs_1 = require("../useMergeRefs");
-const ownEvent_1 = __importDefault(require("../../utils/ownEvent"));
+exports.default = useZoomable;
+var _react = _interopRequireWildcard(require("react"));
+var _useZoomableModule = _interopRequireDefault(require("./useZoomable.module.scss"));
+var _reactDom = _interopRequireDefault(require("react-dom"));
+var _useHero3 = _interopRequireDefault(require("../useHero"));
+var _useMergeRefs = require("../useMergeRefs");
+var _ownEvent = _interopRequireDefault(require("../../utils/ownEvent"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 const ON_HERO_START = {
-    onHeroStart: (clone) => clone.classList.add(useZoomable_module_scss_1.default.overBackdrop),
+  onHeroStart: function onHeroStart(clone) {
+    return clone.classList.add(_useZoomableModule.default.overBackdrop);
+  }
 };
+
 /**
  * Allows an element to be zoomable for fullscreen
  */
 function useZoomable(id) {
-    const zoomableID = (0, react_1.useMemo)(() => `zoomable-${id}`, []);
-    const getBackdrop = () => {
-        return document.querySelector(`[data-zoomable="${zoomableID}"]`);
-    };
-    const { heroRef, trigger } = (0, useHero_1.default)(zoomableID, {
-        "data-preffix": "zoomable",
-        repeatable: true,
+  const zoomableID = (0, _react.useMemo)(function () {
+    return "zoomable-".concat(id);
+  }, []);
+  const getBackdrop = function getBackdrop() {
+    return document.querySelector("[data-zoomable=\"".concat(zoomableID, "\"]"));
+  };
+  const _useHero = (0, _useHero3.default)(zoomableID, {
+      "data-preffix": "zoomable",
+      repeatable: true
     }, {
-        onHeroStart: (clone, ...args) => {
-            const bd = getBackdrop();
-            const removeCb = ({ currentTarget, target }) => {
-                if (target === currentTarget) {
-                    react_dom_1.default.unmountComponentAtNode(bd);
-                    bd.remove();
-                }
-            };
-            bd.style.opacity = "0";
-            ON_HERO_START.onHeroStart(clone, ...args);
-            const middlewayClick = () => {
-                bd.removeEventListener("transitionend", removeCb);
-                clone.removeEventListener("click", middlewayClick);
-                _zoom();
-            };
-            clone.addEventListener("click", middlewayClick);
-            bd.addEventListener("transitionend", removeCb);
-            bd.addEventListener("transitionstart", () => {
-                bd.addEventListener("transitioncancel", (0, ownEvent_1.default)(() => bd.removeEventListener("transitionend", removeCb)));
-            });
-        },
-    });
-    const zoomableEl = (0, react_1.useRef)(null);
-    function _unzoom() {
-        trigger();
-    }
-    function _zoom() {
-        const el = zoomableEl.current;
-        const elClone = el.cloneNode(true);
-        elClone.style.visibility = "hidden";
-        function HeroMount() {
-            const { heroRef } = (0, useHero_1.default)(zoomableID, {
-                "data-preffix": "zoomable",
-                repeatable: true,
-            }, {
-                onHeroStart: (clone, ...args) => {
-                    getBackdrop().style.opacity = "1";
-                    ON_HERO_START.onHeroStart(clone, ...args);
-                    const unzoomCb = () => {
-                        _unzoom();
-                        clone.removeEventListener("click", unzoomCb);
-                    };
-                    clone.addEventListener("click", unzoomCb);
-                },
-                onHeroEnd: () => {
-                    heroRef.current.classList.remove(useZoomable_module_scss_1.default.zoomableIndicator);
-                },
-            });
-            return (react_1.default.createElement("div", { ref: (ref) => {
-                    if (ref) {
-                        ref.appendChild(elClone);
-                        heroRef.current = elClone;
-                        const verticalProportion = el.clientWidth / el.clientHeight;
-                        const targetWidth = ref.clientHeight * verticalProportion;
-                        if (targetWidth > ref.clientWidth) {
-                            const horizontalProportion = el.clientHeight / el.clientWidth;
-                            elClone.style.width = ref.clientWidth + "px";
-                            elClone.style.height =
-                                ref.clientWidth * horizontalProportion + "px";
-                        }
-                        else {
-                            elClone.style.height = ref.clientHeight + "px";
-                            elClone.style.width = targetWidth + "px";
-                        }
-                    }
-                } }));
-        }
-        const existingBackdrop = getBackdrop();
-        if (!existingBackdrop) {
-            const backdrop = document.createElement("div");
-            backdrop.classList.add(useZoomable_module_scss_1.default.backdrop);
-            backdrop.addEventListener("click", _unzoom);
-            backdrop.setAttribute("data-zoomable", zoomableID);
-            document.body.appendChild(backdrop);
-            react_dom_1.default.render(react_1.default.createElement(HeroMount, null), backdrop);
+      onHeroStart: function onHeroStart(clone) {
+        var _ref2;
+        const bd = getBackdrop();
+        const removeCb = function removeCb(_ref) {
+          let currentTarget = _ref.currentTarget,
+            target = _ref.target;
+          if (target === currentTarget) {
+            _reactDom.default.unmountComponentAtNode(bd);
+            bd.remove();
+          }
+        };
+        bd.style.opacity = "0";
+        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
         }
-        else {
-            react_dom_1.default.render(react_1.default.createElement(HeroMount, null), existingBackdrop);
+        (_ref2 = ON_HERO_START).onHeroStart.apply(_ref2, [clone].concat(args));
+        const middlewayClick = function middlewayClick() {
+          bd.removeEventListener("transitionend", removeCb);
+          clone.removeEventListener("click", middlewayClick);
+          _zoom();
+        };
+        clone.addEventListener("click", middlewayClick);
+        bd.addEventListener("transitionend", removeCb);
+        bd.addEventListener("transitionstart", function () {
+          bd.addEventListener("transitioncancel", (0, _ownEvent.default)(function () {
+            return bd.removeEventListener("transitionend", removeCb);
+          }));
+        });
+      }
+    }),
+    heroRef = _useHero.heroRef,
+    trigger = _useHero.trigger;
+  const zoomableEl = (0, _react.useRef)(null);
+  function _unzoom() {
+    trigger();
+  }
+  function _zoom() {
+    const el = zoomableEl.current;
+    const elClone = el.cloneNode(true);
+    elClone.style.visibility = "hidden";
+    function HeroMount() {
+      return /*#__PURE__*/_react.default.createElement("div", {
+        ref: function ref(_ref4) {
+          if (_ref4) {
+            _ref4.appendChild(elClone);
+            const verticalProportion = el.clientWidth / el.clientHeight;
+            const targetWidth = _ref4.clientHeight * verticalProportion;
+            if (targetWidth > _ref4.clientWidth) {
+              const horizontalProportion = el.clientHeight / el.clientWidth;
+              elClone.style.width = _ref4.clientWidth + "px";
+              elClone.style.height = _ref4.clientWidth * horizontalProportion + "px";
+            } else {
+              elClone.style.height = _ref4.clientHeight + "px";
+              elClone.style.width = targetWidth + "px";
+            }
+          }
         }
+      });
     }
-    (0, react_1.useEffect)(() => {
-        const el = zoomableEl.current;
-        el.classList.add(useZoomable_module_scss_1.default.zoomableIndicator);
-        el.addEventListener("click", _zoom);
-        return () => {
-            el.classList.remove(useZoomable_module_scss_1.default.zoomableIndicator);
-            const bd = getBackdrop();
-            if (bd) {
-                bd.style.opacity = "0";
-                bd.addEventListener("transitionend", () => {
-                    bd.remove();
-                });
-            }
-        };
-    }, []);
-    const mergedRefs = (0, useMergeRefs_1.useMergeRefsFunc)(heroRef, zoomableEl);
-    return {
-        zoomableEl: mergedRefs,
+    const existingBackdrop = getBackdrop();
+    if (!existingBackdrop) {
+      const backdrop = document.createElement("div");
+      backdrop.classList.add(_useZoomableModule.default.backdrop);
+      backdrop.addEventListener("click", _unzoom);
+      backdrop.setAttribute("data-zoomable", zoomableID);
+      document.body.appendChild(backdrop);
+      _reactDom.default.render( /*#__PURE__*/_react.default.createElement(HeroMount, null), backdrop);
+    } else {
+      _reactDom.default.render( /*#__PURE__*/_react.default.createElement(HeroMount, null), existingBackdrop);
+    }
+  }
+  (0, _react.useEffect)(function () {
+    const el = zoomableEl.current;
+    el.classList.add(_useZoomableModule.default.zoomableIndicator);
+    el.addEventListener("click", _zoom);
+    return function () {
+      el.classList.remove(_useZoomableModule.default.zoomableIndicator);
+      const bd = getBackdrop();
+      if (bd) {
+        bd.style.opacity = "0";
+        bd.addEventListener("transitionend", function () {
+          bd.remove();
+        });
+      }
     };
-}
-exports.default = useZoomable;
-//# sourceMappingURL=useZoomable.js.map
+  }, []);
+  const mergedRefs = (0, _useMergeRefs.useMergeRefsFunc)(heroRef, zoomableEl);
+  return {
+    zoomableEl: mergedRefs
+  };
+}