@onepercentio/one-ui 1.3.2 → 1.3.4

package/dist/hooks/ui/useTilt.js

@@ -0,0 +1,161 @@
+"use strict";
+
+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 }; }
+const MAX_TILT = {
+  x: 100,
+  y: 100
+};
+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)(() => {
+    if (active) {
+      var _options$gyroEnabled;
+      const updatePositions = (relativeToX, relativeToY) => {
+        var _options$round, _options$round2;
+        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, (_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)(_ref => {
+        let {
+          x,
+          y
+        } = _ref;
+        updatePositions(x, y);
+      }, 1000 / 30);
+      const touchHandler = (0, _throttle.default)(_ref2 => {
+        let {
+          touches
+        } = _ref2;
+        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 = _ref3 => {
+        let {
+          beta,
+          gamma
+        } = _ref3;
+        if ((beta !== null && beta !== void 0 ? beta : 0) + (gamma !== null && gamma !== void 0 ? gamma : 0) === 0) return;
+        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.flattenMatrix)((0, _helpers.invertMatrix)((0, _helpers.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 ((_options$gyroEnabled = options === null || options === void 0 ? void 0 : options.gyroEnabled) !== null && _options$gyroEnabled !== void 0 ? _options$gyroEnabled : true) {
+        window.addEventListener("deviceorientation", orientationListener);
+        return () => {
+          window.removeEventListener("deviceorientation", orientationListener);
+          removeListeners();
+        };
+      } else {
+        return () => removeListeners();
+      }
+    }
+  }, [active, onInverseMatrix, onTilt]);
+}
+
+/**
+ * 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) {
+  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 [tilt, setTilt] = (0, _react.useState)({
+    x: 0,
+    y: 0
+  });
+  const [tiltResetMatrix, setTiltResetMatrix] = (0, _react.useState)(() => (0, _helpers.flattenMatrix)((0, _helpers.IDENTITY_MATRIX)()));
+  const relativeTo = (0, _react.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 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;
+}
+function givenTheRelativePositionHowMuchToRotate(relativePosition, maxRotation) {
+  return relativePosition * maxRotation - maxRotation / 2;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_throttle","_interopRequireDefault","require","_react","_helpers","obj","__esModule","default","MAX_TILT","x","y","useTiltUpdates","active","relativeToEl","onTilt","onInverseMatrix","sensorScale","arguments","length","undefined","tiltLimit","options","useEffect","_options$gyroEnabled","updatePositions","relativeToX","relativeToY","_options$round","_options$round2","el","current","rect","getBoundingClientRect","width","x0","xW","height","y0","yH","left","clientWidth","top","clientHeight","distanceOffRight","calculateDistanceRelativeToBounds","round","distanceOffBottom","howMuchToRotateY","givenTheRelativePositionHowMuchToRotate","howMuchToRotateX","handler","throttle","_ref","touchHandler","_ref2","touches","pageX","pageY","window","addEventListener","_inverseMatrix","_limits","beta","gamma","orientationListener","_ref3","removeEventListener","offset","_beta","Math","min","max","_gamma","flattenMatrix","invertMatrix","generateMatrixFromOperations","type","angle","removeListeners","gyroEnabled","useTilt","maxTilt","tilt","setTilt","useState","tiltResetMatrix","setTiltResetMatrix","IDENTITY_MATRIX","relativeTo","useRef","mousePosition","elementInitialPosition","elementSizeDimension","shouldRound","normalizeInitialPosition","doNotAllowGoingBeyondLowerLimit","doNotAllowHoingBeyondHigherLimit","threeRule","result","relativePosition","maxRotation"],"sources":["../../../src/hooks/ui/useTilt.tsx"],"sourcesContent":["import throttle from \"lodash/throttle\";\nimport { RefObject, useEffect, useRef, useState } from \"react\";\nimport {\n  flattenMatrix,\n  generateMatrixFromOperations,\n  IDENTITY_MATRIX,\n  invertMatrix,\n} from \"../../components/Parallax/math/helpers\";\n\nconst MAX_TILT = {\n  x: 100,\n  y: 100,\n};\n\ntype Options = {\n  round?: boolean;\n  gyroEnabled?: boolean;\n};\n\nexport function useTiltUpdates(\n  active: boolean,\n  relativeToEl: RefObject<HTMLDivElement | null>,\n  onTilt: (p: { x: number; y: number }) => void,\n  onInverseMatrix?: (updateFunc: (matrix: number[]) => number[]) => void,\n  sensorScale: number = 1,\n  tiltLimit: { x: number; y: number } = MAX_TILT,\n  options?: Options\n) {\n  useEffect(() => {\n    if (active) {\n      const updatePositions = (relativeToX: number, relativeToY: number) => {\n        const el = relativeToEl.current!;\n        const rect = el.getBoundingClientRect();\n        const {\n          width: [x0, xW],\n          height: [y0, yH],\n        } = {\n          width: [rect.left, el.clientWidth],\n          height: [rect.top, el.clientHeight],\n        };\n        const distanceOffRight = calculateDistanceRelativeToBounds(\n          relativeToX,\n          x0,\n          xW,\n          options?.round ?? true\n        );\n        const distanceOffBottom = calculateDistanceRelativeToBounds(\n          relativeToY,\n          y0,\n          yH,\n          options?.round ?? true\n        );\n        const howMuchToRotateY = givenTheRelativePositionHowMuchToRotate(\n          distanceOffRight,\n          tiltLimit.y\n        );\n        const howMuchToRotateX = givenTheRelativePositionHowMuchToRotate(\n          distanceOffBottom,\n          tiltLimit.x\n        );\n\n        onTilt({\n          y: howMuchToRotateX * 2,\n          x: howMuchToRotateY * 2,\n        });\n      };\n      const handler = throttle(({ x, y }: MouseEvent) => {\n        updatePositions(x, y);\n      }, 1000 / 30);\n      const touchHandler = throttle(({ touches }: TouchEvent) => {\n        const { pageX, pageY } = touches[0];\n        updatePositions(pageX, pageY);\n      }, 1000 / 30);\n      window.addEventListener(\"mousemove\", handler);\n      window.addEventListener(\"touchmove\", touchHandler);\n      let _inverseMatrix: number[] | undefined;\n      const _limits: {\n        [k in \"beta\" | \"gamma\"]?: [number, number];\n      } = {\n        beta: undefined,\n        gamma: undefined,\n      };\n      const orientationListener: (e: DeviceOrientationEvent) => void = ({\n        beta,\n        gamma,\n      }) => {\n        if ((beta ?? 0) + (gamma ?? 0) === 0) return;\n        beta = beta! * 0.5;\n        gamma = gamma! * 0.5;\n        if (!_inverseMatrix) {\n          window.removeEventListener(\"mousemove\", handler);\n          window.removeEventListener(\"touchmove\", touchHandler);\n          const offset = 12.5;\n          _limits.beta = [beta! - offset, beta! + offset];\n          _limits.gamma = [gamma! - offset, gamma! + offset];\n        }\n        const _beta = Math.min(\n          _limits.beta![1],\n          Math.max(_limits.beta![0], beta!)\n        );\n        const _gamma = Math.min(\n          _limits.gamma![1],\n          Math.max(_limits.gamma![0], gamma!)\n        );\n        if (!_inverseMatrix && onInverseMatrix) {\n          onInverseMatrix(() => {\n            return (_inverseMatrix = flattenMatrix(\n              invertMatrix(\n                generateMatrixFromOperations(\n                  {\n                    type: \"rotateY\",\n                    angle: _gamma!,\n                  },\n                  {\n                    type: \"rotateX\",\n                    angle: -_beta!,\n                  }\n                )\n              )\n            ));\n          });\n        }\n        onTilt({\n          y: -_beta * sensorScale,\n          x: _gamma * sensorScale,\n        });\n      };\n      function removeListeners() {\n        window.removeEventListener(\"mousemove\", handler);\n        window.removeEventListener(\"touchmove\", touchHandler);\n      }\n      if (options?.gyroEnabled ?? true) {\n        window.addEventListener(\"deviceorientation\", orientationListener);\n        return () => {\n          window.removeEventListener(\"deviceorientation\", orientationListener);\n          removeListeners();\n        };\n      } else {\n        return () => removeListeners();\n      }\n    }\n  }, [active, onInverseMatrix, onTilt]);\n}\n\n/**\n * This hook binds to two methods for calculating tilt\n *\n * When available: The device sensors\n * When on desktop: The mouse position relative to a ref\n */\nexport default function useTilt(\n  active: boolean,\n  /**\n   * A scale to increase the values from the sensors\n   *\n   * @hack You can set this value to 0 as a way to disable the tilt calc on mobile\n   */\n  sensorScale: number = 1,\n  maxTilt: { x: number; y: number } = MAX_TILT,\n  options?: Options\n) {\n  const [tilt, setTilt] = useState<{ x: number; y: number }>({\n    x: 0,\n    y: 0,\n  });\n  const [tiltResetMatrix, setTiltResetMatrix] = useState<number[]>(() =>\n    flattenMatrix(IDENTITY_MATRIX())\n  );\n  const relativeTo = useRef<HTMLDivElement>(null);\n\n  useTiltUpdates(\n    active,\n    relativeTo,\n    setTilt,\n    setTiltResetMatrix,\n    sensorScale,\n    maxTilt,\n    options\n  );\n\n  return {\n    /** The element to monitor mouse hover relative to */\n    relativeTo,\n    /**\n     * The matrix that represents the original tilt, so it can be used with the tilt prop to tilt relative to the user\n     * Use it on css like so transform: matrix3d(tiltResetMatrix.join(\",\")) rotateX(tilt.x) rotateY(tilt.y)\n     */\n    tiltResetMatrix,\n\n    /**\n     * How much tilt should be applied based\n     */\n    tilt,\n  };\n}\n\nexport function calculateDistanceRelativeToBounds(\n  mousePosition: number,\n  elementInitialPosition: number,\n  elementSizeDimension: number,\n  shouldRound: boolean\n) {\n  const normalizeInitialPosition = mousePosition - elementInitialPosition;\n  const doNotAllowGoingBeyondLowerLimit = Math.max(normalizeInitialPosition, 0);\n  const doNotAllowHoingBeyondHigherLimit = Math.min(\n    doNotAllowGoingBeyondLowerLimit,\n    elementSizeDimension\n  );\n  const threeRule =\n    (doNotAllowHoingBeyondHigherLimit * 100) / elementSizeDimension;\n  const result = (shouldRound ? Math.round(threeRule) : threeRule) / 100;\n  return result;\n}\n\nexport function givenTheRelativePositionHowMuchToRotate(\n  relativePosition: number,\n  maxRotation: number\n) {\n  return relativePosition * maxRotation - maxRotation / 2;\n}\n"],"mappings":";;;;;;;;;AAAA,IAAAA,SAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,QAAA,GAAAF,OAAA;AAKgD,SAAAD,uBAAAI,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAEhD,MAAMG,QAAQ,GAAG;EACfC,CAAC,EAAE,GAAG;EACNC,CAAC,EAAE;AACL,CAAC;AAOM,SAASC,cAAcA,CAC5BC,MAAe,EACfC,YAA8C,EAC9CC,MAA6C,EAC7CC,eAAsE,EAItE;EAAA,IAHAC,WAAmB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC;EAAA,IACvBG,SAAmC,GAAAH,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAGT,QAAQ;EAAA,IAC9Ca,OAAiB,GAAAJ,SAAA,CAAAC,MAAA,OAAAD,SAAA,MAAAE,SAAA;EAEjB,IAAAG,gBAAS,EAAC,MAAM;IACd,IAAIV,MAAM,EAAE;MAAA,IAAAW,oBAAA;MACV,MAAMC,eAAe,GAAGA,CAACC,WAAmB,EAAEC,WAAmB,KAAK;QAAA,IAAAC,cAAA,EAAAC,eAAA;QACpE,MAAMC,EAAE,GAAGhB,YAAY,CAACiB,OAAQ;QAChC,MAAMC,IAAI,GAAGF,EAAE,CAACG,qBAAqB,CAAC,CAAC;QACvC,MAAM;UACJC,KAAK,EAAE,CAACC,EAAE,EAAEC,EAAE,CAAC;UACfC,MAAM,EAAE,CAACC,EAAE,EAAEC,EAAE;QACjB,CAAC,GAAG;UACFL,KAAK,EAAE,CAACF,IAAI,CAACQ,IAAI,EAAEV,EAAE,CAACW,WAAW,CAAC;UAClCJ,MAAM,EAAE,CAACL,IAAI,CAACU,GAAG,EAAEZ,EAAE,CAACa,YAAY;QACpC,CAAC;QACD,MAAMC,gBAAgB,GAAGC,iCAAiC,CACxDnB,WAAW,EACXS,EAAE,EACFC,EAAE,GAAAR,cAAA,GACFN,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEwB,KAAK,cAAAlB,cAAA,cAAAA,cAAA,GAAI,IACpB,CAAC;QACD,MAAMmB,iBAAiB,GAAGF,iCAAiC,CACzDlB,WAAW,EACXW,EAAE,EACFC,EAAE,GAAAV,eAAA,GACFP,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEwB,KAAK,cAAAjB,eAAA,cAAAA,eAAA,GAAI,IACpB,CAAC;QACD,MAAMmB,gBAAgB,GAAGC,uCAAuC,CAC9DL,gBAAgB,EAChBvB,SAAS,CAACV,CACZ,CAAC;QACD,MAAMuC,gBAAgB,GAAGD,uCAAuC,CAC9DF,iBAAiB,EACjB1B,SAAS,CAACX,CACZ,CAAC;QAEDK,MAAM,CAAC;UACLJ,CAAC,EAAEuC,gBAAgB,GAAG,CAAC;UACvBxC,CAAC,EAAEsC,gBAAgB,GAAG;QACxB,CAAC,CAAC;MACJ,CAAC;MACD,MAAMG,OAAO,GAAG,IAAAC,iBAAQ,EAACC,IAAA,IAA0B;QAAA,IAAzB;UAAE3C,CAAC;UAAEC;QAAc,CAAC,GAAA0C,IAAA;QAC5C5B,eAAe,CAACf,CAAC,EAAEC,CAAC,CAAC;MACvB,CAAC,EAAE,IAAI,GAAG,EAAE,CAAC;MACb,MAAM2C,YAAY,GAAG,IAAAF,iBAAQ,EAACG,KAAA,IAA6B;QAAA,IAA5B;UAAEC;QAAoB,CAAC,GAAAD,KAAA;QACpD,MAAM;UAAEE,KAAK;UAAEC;QAAM,CAAC,GAAGF,OAAO,CAAC,CAAC,CAAC;QACnC/B,eAAe,CAACgC,KAAK,EAAEC,KAAK,CAAC;MAC/B,CAAC,EAAE,IAAI,GAAG,EAAE,CAAC;MACbC,MAAM,CAACC,gBAAgB,CAAC,WAAW,EAAET,OAAO,CAAC;MAC7CQ,MAAM,CAACC,gBAAgB,CAAC,WAAW,EAAEN,YAAY,CAAC;MAClD,IAAIO,cAAoC;MACxC,MAAMC,OAEL,GAAG;QACFC,IAAI,EAAE3C,SAAS;QACf4C,KAAK,EAAE5C;MACT,CAAC;MACD,MAAM6C,mBAAwD,GAAGC,KAAA,IAG3D;QAAA,IAH4D;UAChEH,IAAI;UACJC;QACF,CAAC,GAAAE,KAAA;QACC,IAAI,CAACH,IAAI,aAAJA,IAAI,cAAJA,IAAI,GAAI,CAAC,KAAKC,KAAK,aAALA,KAAK,cAALA,KAAK,GAAI,CAAC,CAAC,KAAK,CAAC,EAAE;QACtCD,IAAI,GAAGA,IAAI,GAAI,GAAG;QAClBC,KAAK,GAAGA,KAAK,GAAI,GAAG;QACpB,IAAI,CAACH,cAAc,EAAE;UACnBF,MAAM,CAACQ,mBAAmB,CAAC,WAAW,EAAEhB,OAAO,CAAC;UAChDQ,MAAM,CAACQ,mBAAmB,CAAC,WAAW,EAAEb,YAAY,CAAC;UACrD,MAAMc,MAAM,GAAG,IAAI;UACnBN,OAAO,CAACC,IAAI,GAAG,CAACA,IAAI,GAAIK,MAAM,EAAEL,IAAI,GAAIK,MAAM,CAAC;UAC/CN,OAAO,CAACE,KAAK,GAAG,CAACA,KAAK,GAAII,MAAM,EAAEJ,KAAK,GAAII,MAAM,CAAC;QACpD;QACA,MAAMC,KAAK,GAAGC,IAAI,CAACC,GAAG,CACpBT,OAAO,CAACC,IAAI,CAAE,CAAC,CAAC,EAChBO,IAAI,CAACE,GAAG,CAACV,OAAO,CAACC,IAAI,CAAE,CAAC,CAAC,EAAEA,IAAK,CAClC,CAAC;QACD,MAAMU,MAAM,GAAGH,IAAI,CAACC,GAAG,CACrBT,OAAO,CAACE,KAAK,CAAE,CAAC,CAAC,EACjBM,IAAI,CAACE,GAAG,CAACV,OAAO,CAACE,KAAK,CAAE,CAAC,CAAC,EAAEA,KAAM,CACpC,CAAC;QACD,IAAI,CAACH,cAAc,IAAI7C,eAAe,EAAE;UACtCA,eAAe,CAAC,MAAM;YACpB,OAAQ6C,cAAc,GAAG,IAAAa,sBAAa,EACpC,IAAAC,qBAAY,EACV,IAAAC,qCAA4B,EAC1B;cACEC,IAAI,EAAE,SAAS;cACfC,KAAK,EAAEL;YACT,CAAC,EACD;cACEI,IAAI,EAAE,SAAS;cACfC,KAAK,EAAE,CAACT;YACV,CACF,CACF,CACF,CAAC;UACH,CAAC,CAAC;QACJ;QACAtD,MAAM,CAAC;UACLJ,CAAC,EAAE,CAAC0D,KAAK,GAAGpD,WAAW;UACvBP,CAAC,EAAE+D,MAAM,GAAGxD;QACd,CAAC,CAAC;MACJ,CAAC;MACD,SAAS8D,eAAeA,CAAA,EAAG;QACzBpB,MAAM,CAACQ,mBAAmB,CAAC,WAAW,EAAEhB,OAAO,CAAC;QAChDQ,MAAM,CAACQ,mBAAmB,CAAC,WAAW,EAAEb,YAAY,CAAC;MACvD;MACA,KAAA9B,oBAAA,GAAIF,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAE0D,WAAW,cAAAxD,oBAAA,cAAAA,oBAAA,GAAI,IAAI,EAAE;QAChCmC,MAAM,CAACC,gBAAgB,CAAC,mBAAmB,EAAEK,mBAAmB,CAAC;QACjE,OAAO,MAAM;UACXN,MAAM,CAACQ,mBAAmB,CAAC,mBAAmB,EAAEF,mBAAmB,CAAC;UACpEc,eAAe,CAAC,CAAC;QACnB,CAAC;MACH,CAAC,MAAM;QACL,OAAO,MAAMA,eAAe,CAAC,CAAC;MAChC;IACF;EACF,CAAC,EAAE,CAAClE,MAAM,EAAEG,eAAe,EAAED,MAAM,CAAC,CAAC;AACvC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACe,SAASkE,OAAOA,CAC7BpE,MAAe,EASf;EAAA,IAHAI,WAAmB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC;EAAA,IACvBgE,OAAiC,GAAAhE,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAGT,QAAQ;EAAA,IAC5Ca,OAAiB,GAAAJ,SAAA,CAAAC,MAAA,OAAAD,SAAA,MAAAE,SAAA;EAEjB,MAAM,CAAC+D,IAAI,EAAEC,OAAO,CAAC,GAAG,IAAAC,eAAQ,EAA2B;IACzD3E,CAAC,EAAE,CAAC;IACJC,CAAC,EAAE;EACL,CAAC,CAAC;EACF,MAAM,CAAC2E,eAAe,EAAEC,kBAAkB,CAAC,GAAG,IAAAF,eAAQ,EAAW,MAC/D,IAAAX,sBAAa,EAAC,IAAAc,wBAAe,EAAC,CAAC,CACjC,CAAC;EACD,MAAMC,UAAU,GAAG,IAAAC,aAAM,EAAiB,IAAI,CAAC;EAE/C9E,cAAc,CACZC,MAAM,EACN4E,UAAU,EACVL,OAAO,EACPG,kBAAkB,EAClBtE,WAAW,EACXiE,OAAO,EACP5D,OACF,CAAC;EAED,OAAO;IACL;IACAmE,UAAU;IACV;AACJ;AACA;AACA;IACIH,eAAe;IAEf;AACJ;AACA;IACIH;EACF,CAAC;AACH;AAEO,SAAStC,iCAAiCA,CAC/C8C,aAAqB,EACrBC,sBAA8B,EAC9BC,oBAA4B,EAC5BC,WAAoB,EACpB;EACA,MAAMC,wBAAwB,GAAGJ,aAAa,GAAGC,sBAAsB;EACvE,MAAMI,+BAA+B,GAAG1B,IAAI,CAACE,GAAG,CAACuB,wBAAwB,EAAE,CAAC,CAAC;EAC7E,MAAME,gCAAgC,GAAG3B,IAAI,CAACC,GAAG,CAC/CyB,+BAA+B,EAC/BH,oBACF,CAAC;EACD,MAAMK,SAAS,GACZD,gCAAgC,GAAG,GAAG,GAAIJ,oBAAoB;EACjE,MAAMM,MAAM,GAAG,CAACL,WAAW,GAAGxB,IAAI,CAACxB,KAAK,CAACoD,SAAS,CAAC,GAAGA,SAAS,IAAI,GAAG;EACtE,OAAOC,MAAM;AACf;AAEO,SAASlD,uCAAuCA,CACrDmD,gBAAwB,EACxBC,WAAmB,EACnB;EACA,OAAOD,gBAAgB,GAAGC,WAAW,GAAGA,WAAW,GAAG,CAAC;AACzD"}

package/dist/hooks/ui/useZoomable.js

@@ -0,0 +1,135 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useZoomable;
+var _react = _interopRequireWildcard(require("react"));
+var _client = require("react-dom/client");
+var _reactDom = _interopRequireDefault(require("react-dom"));
+var _useZoomableModule = _interopRequireDefault(require("./useZoomable.module.scss"));
+var _useHero = _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 (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; }
+/**
+ * Allows an element to be zoomable for fullscreen
+ */
+function useZoomable(id) {
+  const zoomableID = (0, _react.useMemo)(() => "zoomable-".concat(id), []);
+  const getBackdrop = () => {
+    return document.querySelector("[data-zoomable=\"".concat(zoomableID, "\"]"));
+  };
+  const {
+    heroRef,
+    trigger
+  } = (0, _useHero.default)(zoomableID, {
+    "data-preffix": "zoomable",
+    repeatable: true
+  }, {
+    onHeroStart: function (clone) {
+      const bd = getBackdrop();
+      const removeCb = _ref => {
+        let {
+          currentTarget,
+          target
+        } = _ref;
+        if (target === currentTarget) {
+          if ("unmountComponentAtNode" in _reactDom.default) _reactDom.default.unmountComponentAtNode(bd);else console.error("This component doesn't work with the new versions of react yet...");
+          bd.remove();
+        }
+      };
+      bd.style.opacity = "0";
+      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.default)(() => bd.removeEventListener("transitionend", removeCb)));
+      });
+    }
+  });
+  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() {
+      const {
+        heroRef
+      } = (0, _useHero.default)(zoomableID, {
+        "data-preffix": "zoomable",
+        repeatable: true
+      }, {
+        onHeroStart: function (clone) {
+          getBackdrop().style.opacity = "1";
+          const unzoomCb = () => {
+            _unzoom();
+            clone.removeEventListener("click", unzoomCb);
+          };
+          clone.addEventListener("click", unzoomCb);
+        },
+        onHeroEnd: () => {
+          heroRef.current.classList.remove(_useZoomableModule.default.zoomableIndicator);
+        }
+      });
+      return /*#__PURE__*/_react.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(_useZoomableModule.default.backdrop);
+      backdrop.addEventListener("click", _unzoom);
+      backdrop.setAttribute("data-zoomable", zoomableID);
+      document.body.appendChild(backdrop);
+      (0, _client.createRoot)(backdrop).render( /*#__PURE__*/_react.default.createElement(HeroMount, null));
+    } else {
+      (0, _client.createRoot)(existingBackdrop).render( /*#__PURE__*/_react.default.createElement(HeroMount, null));
+    }
+  }
+  (0, _react.useEffect)(() => {
+    const el = zoomableEl.current;
+    el.classList.add(_useZoomableModule.default.zoomableIndicator);
+    el.addEventListener("click", _zoom);
+    return () => {
+      el.classList.remove(_useZoomableModule.default.zoomableIndicator);
+      const bd = getBackdrop();
+      if (bd) {
+        bd.style.opacity = "0";
+        bd.addEventListener("transitionend", () => {
+          bd.remove();
+        });
+      }
+    };
+  }, []);
+  const mergedRefs = (0, _useMergeRefs.useMergeRefsFunc)(heroRef, zoomableEl);
+  return {
+    zoomableEl: mergedRefs
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_client","_reactDom","_interopRequireDefault","_useZoomableModule","_useHero","_useMergeRefs","_ownEvent","obj","__esModule","default","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","useZoomable","id","zoomableID","useMemo","concat","getBackdrop","document","querySelector","heroRef","trigger","useHero","repeatable","onHeroStart","clone","bd","removeCb","_ref","currentTarget","target","ReactDOM","unmountComponentAtNode","console","error","remove","style","opacity","middlewayClick","removeEventListener","_zoom","addEventListener","ownEvent","zoomableEl","useRef","_unzoom","el","current","elClone","cloneNode","visibility","HeroMount","unzoomCb","onHeroEnd","classList","Styles","zoomableIndicator","createElement","ref","appendChild","verticalProportion","clientWidth","clientHeight","targetWidth","horizontalProportion","width","height","existingBackdrop","backdrop","add","setAttribute","body","createRoot","render","useEffect","mergedRefs","useMergeRefsFunc"],"sources":["../../../src/hooks/ui/useZoomable.tsx"],"sourcesContent":["import React, { useEffect, useMemo, useRef } from \"react\";\nimport { createRoot } from \"react-dom/client\";\nimport ReactDOM from \"react-dom\";\nimport Styles from \"./useZoomable.module.scss\";\nimport useHero from \"../useHero\";\nimport { useMergeRefsFunc } from \"../useMergeRefs\";\nimport ownEvent from \"../../utils/ownEvent\";\n/**\n * Allows an element to be zoomable for fullscreen\n */\nexport default function useZoomable(id: string) {\n  const zoomableID = useMemo(() => `zoomable-${id}`, []);\n  const getBackdrop = () => {\n    return document.querySelector(\n      `[data-zoomable=\"${zoomableID}\"]`\n    )! as HTMLDivElement;\n  };\n  const { heroRef, trigger } = useHero(\n    zoomableID,\n    {\n      \"data-preffix\": \"zoomable\",\n      repeatable: true,\n    },\n    {\n      onHeroStart: (clone, ...args) => {\n        const bd = getBackdrop();\n        const removeCb = ({ currentTarget, target }: TransitionEvent) => {\n          if (target === currentTarget) {\n            if ((\"unmountComponentAtNode\" in ReactDOM) as any)\n              (ReactDOM as any).unmountComponentAtNode(bd);\n            else\n              console.error(\"This component doesn't work with the new versions of react yet...\")\n            bd.remove();\n          }\n        };\n        bd.style.opacity = \"0\";\n        const middlewayClick = () => {\n          bd.removeEventListener(\"transitionend\", removeCb);\n          clone.removeEventListener(\"click\", middlewayClick);\n          _zoom();\n        };\n        clone.addEventListener(\"click\", middlewayClick);\n        bd.addEventListener(\"transitionend\", removeCb);\n        bd.addEventListener(\"transitionstart\", () => {\n          bd.addEventListener(\n            \"transitioncancel\",\n            ownEvent(() => bd.removeEventListener(\"transitionend\", removeCb))\n          );\n        });\n      },\n    }\n  );\n  const zoomableEl = useRef<HTMLDivElement>(null);\n  function _unzoom() {\n    trigger();\n  }\n\n  function _zoom() {\n    const el = zoomableEl.current!;\n    const elClone = el.cloneNode(true) as HTMLDivElement;\n    elClone.style.visibility = \"hidden\";\n\n    function HeroMount() {\n      const { heroRef } = useHero(\n        zoomableID,\n        {\n          \"data-preffix\": \"zoomable\",\n          repeatable: true,\n        },\n        {\n          onHeroStart: (clone, ...args) => {\n            getBackdrop().style.opacity = \"1\";\n            const unzoomCb = () => {\n              _unzoom();\n              clone.removeEventListener(\"click\", unzoomCb);\n            };\n            clone.addEventListener(\"click\", unzoomCb);\n          },\n          onHeroEnd: () => {\n            heroRef.current!.classList.remove(Styles.zoomableIndicator);\n          },\n        }\n      );\n\n      return (\n        <div\n          ref={(ref) => {\n            if (ref) {\n              ref.appendChild(elClone);\n              (heroRef as any).current = elClone;\n              const verticalProportion = el.clientWidth / el.clientHeight;\n              const targetWidth = ref.clientHeight * verticalProportion;\n\n              if (targetWidth > ref.clientWidth) {\n                const horizontalProportion = el.clientHeight / el.clientWidth;\n                elClone.style.width = ref.clientWidth + \"px\";\n                elClone.style.height =\n                  ref.clientWidth * horizontalProportion + \"px\";\n              } else {\n                elClone.style.height = ref.clientHeight + \"px\";\n                elClone.style.width = targetWidth + \"px\";\n              }\n            }\n          }}\n        />\n      );\n    }\n\n    const existingBackdrop = getBackdrop();\n    if (!existingBackdrop) {\n      const backdrop = document.createElement(\"div\");\n\n      backdrop.classList.add(Styles.backdrop);\n      backdrop.addEventListener(\"click\", _unzoom);\n      backdrop.setAttribute(\"data-zoomable\", zoomableID);\n\n      document.body.appendChild(backdrop);\n      createRoot(backdrop).render(<HeroMount />);\n    } else {\n      createRoot(existingBackdrop).render(<HeroMount />);\n    }\n  }\n  useEffect(() => {\n    const el = zoomableEl.current!;\n    el.classList.add(Styles.zoomableIndicator);\n    el.addEventListener(\"click\", _zoom);\n    return () => {\n      el.classList.remove(Styles.zoomableIndicator);\n      const bd = getBackdrop();\n      if (bd) {\n        bd.style.opacity = \"0\";\n        bd.addEventListener(\"transitionend\", () => {\n          bd.remove();\n        });\n      }\n    };\n  }, []);\n\n  const mergedRefs = useMergeRefsFunc(heroRef, zoomableEl);\n\n  return {\n    zoomableEl: mergedRefs,\n  };\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,SAAA,GAAAC,sBAAA,CAAAH,OAAA;AACA,IAAAI,kBAAA,GAAAD,sBAAA,CAAAH,OAAA;AACA,IAAAK,QAAA,GAAAF,sBAAA,CAAAH,OAAA;AACA,IAAAM,aAAA,GAAAN,OAAA;AACA,IAAAO,SAAA,GAAAJ,sBAAA,CAAAH,OAAA;AAA4C,SAAAG,uBAAAK,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAAA,SAAAG,yBAAAC,WAAA,eAAAC,OAAA,kCAAAC,iBAAA,OAAAD,OAAA,QAAAE,gBAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,CAAAC,WAAA,WAAAA,WAAA,GAAAG,gBAAA,GAAAD,iBAAA,KAAAF,WAAA;AAAA,SAAAb,wBAAAS,GAAA,EAAAI,WAAA,SAAAA,WAAA,IAAAJ,GAAA,IAAAA,GAAA,CAAAC,UAAA,WAAAD,GAAA,QAAAA,GAAA,oBAAAA,GAAA,wBAAAA,GAAA,4BAAAE,OAAA,EAAAF,GAAA,UAAAQ,KAAA,GAAAL,wBAAA,CAAAC,WAAA,OAAAI,KAAA,IAAAA,KAAA,CAAAC,GAAA,CAAAT,GAAA,YAAAQ,KAAA,CAAAE,GAAA,CAAAV,GAAA,SAAAW,MAAA,WAAAC,qBAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,GAAA,IAAAhB,GAAA,QAAAgB,GAAA,kBAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAnB,GAAA,EAAAgB,GAAA,SAAAI,IAAA,GAAAR,qBAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAf,GAAA,EAAAgB,GAAA,cAAAI,IAAA,KAAAA,IAAA,CAAAV,GAAA,IAAAU,IAAA,CAAAC,GAAA,KAAAR,MAAA,CAAAC,cAAA,CAAAH,MAAA,EAAAK,GAAA,EAAAI,IAAA,YAAAT,MAAA,CAAAK,GAAA,IAAAhB,GAAA,CAAAgB,GAAA,SAAAL,MAAA,CAAAT,OAAA,GAAAF,GAAA,MAAAQ,KAAA,IAAAA,KAAA,CAAAa,GAAA,CAAArB,GAAA,EAAAW,MAAA,YAAAA,MAAA;AAC5C;AACA;AACA;AACe,SAASW,WAAWA,CAACC,EAAU,EAAE;EAC9C,MAAMC,UAAU,GAAG,IAAAC,cAAO,EAAC,kBAAAC,MAAA,CAAkBH,EAAE,CAAE,EAAE,EAAE,CAAC;EACtD,MAAMI,WAAW,GAAGA,CAAA,KAAM;IACxB,OAAOC,QAAQ,CAACC,aAAa,qBAAAH,MAAA,CACRF,UAAU,QAC/B,CAAC;EACH,CAAC;EACD,MAAM;IAAEM,OAAO;IAAEC;EAAQ,CAAC,GAAG,IAAAC,gBAAO,EAClCR,UAAU,EACV;IACE,cAAc,EAAE,UAAU;IAC1BS,UAAU,EAAE;EACd,CAAC,EACD;IACEC,WAAW,EAAE,SAAAA,CAACC,KAAK,EAAc;MAC/B,MAAMC,EAAE,GAAGT,WAAW,CAAC,CAAC;MACxB,MAAMU,QAAQ,GAAGC,IAAA,IAAgD;QAAA,IAA/C;UAAEC,aAAa;UAAEC;QAAwB,CAAC,GAAAF,IAAA;QAC1D,IAAIE,MAAM,KAAKD,aAAa,EAAE;UAC5B,IAAK,wBAAwB,IAAIE,iBAAQ,EACtCA,iBAAQ,CAASC,sBAAsB,CAACN,EAAE,CAAC,CAAC,KAE7CO,OAAO,CAACC,KAAK,CAAC,mEAAmE,CAAC;UACpFR,EAAE,CAACS,MAAM,CAAC,CAAC;QACb;MACF,CAAC;MACDT,EAAE,CAACU,KAAK,CAACC,OAAO,GAAG,GAAG;MACtB,MAAMC,cAAc,GAAGA,CAAA,KAAM;QAC3BZ,EAAE,CAACa,mBAAmB,CAAC,eAAe,EAAEZ,QAAQ,CAAC;QACjDF,KAAK,CAACc,mBAAmB,CAAC,OAAO,EAAED,cAAc,CAAC;QAClDE,KAAK,CAAC,CAAC;MACT,CAAC;MACDf,KAAK,CAACgB,gBAAgB,CAAC,OAAO,EAAEH,cAAc,CAAC;MAC/CZ,EAAE,CAACe,gBAAgB,CAAC,eAAe,EAAEd,QAAQ,CAAC;MAC9CD,EAAE,CAACe,gBAAgB,CAAC,iBAAiB,EAAE,MAAM;QAC3Cf,EAAE,CAACe,gBAAgB,CACjB,kBAAkB,EAClB,IAAAC,iBAAQ,EAAC,MAAMhB,EAAE,CAACa,mBAAmB,CAAC,eAAe,EAAEZ,QAAQ,CAAC,CAClE,CAAC;MACH,CAAC,CAAC;IACJ;EACF,CACF,CAAC;EACD,MAAMgB,UAAU,GAAG,IAAAC,aAAM,EAAiB,IAAI,CAAC;EAC/C,SAASC,OAAOA,CAAA,EAAG;IACjBxB,OAAO,CAAC,CAAC;EACX;EAEA,SAASmB,KAAKA,CAAA,EAAG;IACf,MAAMM,EAAE,GAAGH,UAAU,CAACI,OAAQ;IAC9B,MAAMC,OAAO,GAAGF,EAAE,CAACG,SAAS,CAAC,IAAI,CAAmB;IACpDD,OAAO,CAACZ,KAAK,CAACc,UAAU,GAAG,QAAQ;IAEnC,SAASC,SAASA,CAAA,EAAG;MACnB,MAAM;QAAE/B;MAAQ,CAAC,GAAG,IAAAE,gBAAO,EACzBR,UAAU,EACV;QACE,cAAc,EAAE,UAAU;QAC1BS,UAAU,EAAE;MACd,CAAC,EACD;QACEC,WAAW,EAAE,SAAAA,CAACC,KAAK,EAAc;UAC/BR,WAAW,CAAC,CAAC,CAACmB,KAAK,CAACC,OAAO,GAAG,GAAG;UACjC,MAAMe,QAAQ,GAAGA,CAAA,KAAM;YACrBP,OAAO,CAAC,CAAC;YACTpB,KAAK,CAACc,mBAAmB,CAAC,OAAO,EAAEa,QAAQ,CAAC;UAC9C,CAAC;UACD3B,KAAK,CAACgB,gBAAgB,CAAC,OAAO,EAAEW,QAAQ,CAAC;QAC3C,CAAC;QACDC,SAAS,EAAEA,CAAA,KAAM;UACfjC,OAAO,CAAC2B,OAAO,CAAEO,SAAS,CAACnB,MAAM,CAACoB,0BAAM,CAACC,iBAAiB,CAAC;QAC7D;MACF,CACF,CAAC;MAED,oBACE5E,MAAA,CAAAY,OAAA,CAAAiE,aAAA;QACEC,GAAG,EAAGA,GAAG,IAAK;UACZ,IAAIA,GAAG,EAAE;YACPA,GAAG,CAACC,WAAW,CAACX,OAAO,CAAC;YACvB5B,OAAO,CAAS2B,OAAO,GAAGC,OAAO;YAClC,MAAMY,kBAAkB,GAAGd,EAAE,CAACe,WAAW,GAAGf,EAAE,CAACgB,YAAY;YAC3D,MAAMC,WAAW,GAAGL,GAAG,CAACI,YAAY,GAAGF,kBAAkB;YAEzD,IAAIG,WAAW,GAAGL,GAAG,CAACG,WAAW,EAAE;cACjC,MAAMG,oBAAoB,GAAGlB,EAAE,CAACgB,YAAY,GAAGhB,EAAE,CAACe,WAAW;cAC7Db,OAAO,CAACZ,KAAK,CAAC6B,KAAK,GAAGP,GAAG,CAACG,WAAW,GAAG,IAAI;cAC5Cb,OAAO,CAACZ,KAAK,CAAC8B,MAAM,GAClBR,GAAG,CAACG,WAAW,GAAGG,oBAAoB,GAAG,IAAI;YACjD,CAAC,MAAM;cACLhB,OAAO,CAACZ,KAAK,CAAC8B,MAAM,GAAGR,GAAG,CAACI,YAAY,GAAG,IAAI;cAC9Cd,OAAO,CAACZ,KAAK,CAAC6B,KAAK,GAAGF,WAAW,GAAG,IAAI;YAC1C;UACF;QACF;MAAE,CACH,CAAC;IAEN;IAEA,MAAMI,gBAAgB,GAAGlD,WAAW,CAAC,CAAC;IACtC,IAAI,CAACkD,gBAAgB,EAAE;MACrB,MAAMC,QAAQ,GAAGlD,QAAQ,CAACuC,aAAa,CAAC,KAAK,CAAC;MAE9CW,QAAQ,CAACd,SAAS,CAACe,GAAG,CAACd,0BAAM,CAACa,QAAQ,CAAC;MACvCA,QAAQ,CAAC3B,gBAAgB,CAAC,OAAO,EAAEI,OAAO,CAAC;MAC3CuB,QAAQ,CAACE,YAAY,CAAC,eAAe,EAAExD,UAAU,CAAC;MAElDI,QAAQ,CAACqD,IAAI,CAACZ,WAAW,CAACS,QAAQ,CAAC;MACnC,IAAAI,kBAAU,EAACJ,QAAQ,CAAC,CAACK,MAAM,eAAC7F,MAAA,CAAAY,OAAA,CAAAiE,aAAA,CAACN,SAAS,MAAE,CAAC,CAAC;IAC5C,CAAC,MAAM;MACL,IAAAqB,kBAAU,EAACL,gBAAgB,CAAC,CAACM,MAAM,eAAC7F,MAAA,CAAAY,OAAA,CAAAiE,aAAA,CAACN,SAAS,MAAE,CAAC,CAAC;IACpD;EACF;EACA,IAAAuB,gBAAS,EAAC,MAAM;IACd,MAAM5B,EAAE,GAAGH,UAAU,CAACI,OAAQ;IAC9BD,EAAE,CAACQ,SAAS,CAACe,GAAG,CAACd,0BAAM,CAACC,iBAAiB,CAAC;IAC1CV,EAAE,CAACL,gBAAgB,CAAC,OAAO,EAAED,KAAK,CAAC;IACnC,OAAO,MAAM;MACXM,EAAE,CAACQ,SAAS,CAACnB,MAAM,CAACoB,0BAAM,CAACC,iBAAiB,CAAC;MAC7C,MAAM9B,EAAE,GAAGT,WAAW,CAAC,CAAC;MACxB,IAAIS,EAAE,EAAE;QACNA,EAAE,CAACU,KAAK,CAACC,OAAO,GAAG,GAAG;QACtBX,EAAE,CAACe,gBAAgB,CAAC,eAAe,EAAE,MAAM;UACzCf,EAAE,CAACS,MAAM,CAAC,CAAC;QACb,CAAC,CAAC;MACJ;IACF,CAAC;EACH,CAAC,EAAE,EAAE,CAAC;EAEN,MAAMwC,UAAU,GAAG,IAAAC,8BAAgB,EAACxD,OAAO,EAAEuB,UAAU,CAAC;EAExD,OAAO;IACLA,UAAU,EAAEgC;EACd,CAAC;AACH"}

package/dist/hooks/ui/useZoomable.module.scss

@@ -0,0 +1,34 @@
+@use "../../assets/styles/variables.scss" as *;
+
+.zoomableIndicator {
+  cursor: zoom-in;
+}
+
+$stubZIndex: 1000000;
+
+.backdrop {
+  position: fixed;
+  width: 100vw;
+  height: 100vh;
+  top: 0;
+  left: 0;
+  z-index: $stubZIndex;
+  background: var(--zoomable--backdrop-bg, #0009);
+  transition: opacity $fast linear;
+  opacity: 0;
+  > * {
+    height: 100%;
+    width: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    > * {
+      cursor: zoom-out;
+    }
+  }
+}
+
+.backdrop + * {
+  z-index: $stubZIndex + 1;
+  max-width: initial;
+}

package/dist/hooks/useAsyncControl.ai.md

@@ -0,0 +1,25 @@
+# Protecting an async function
+```tsx
+const control = useAsyncControl()
+
+control.process(() => anAsyncFunction());
+```
+
+# Using multiple async functions
+```tsx
+const control = useAsyncControl({
+    asyncFunctionOne,
+    asyncFunctionTwo,
+})
+
+control.asyncFunctionOne();
+control.asyncFunctionTwo();
+```
+
+# Storing data
+```tsx
+const [result, setResult] = useState()
+const control = useAsyncControl({anAsyncFunctionThatReturnsData})
+
+control.anAsyncFunctionThatReturnsData().then(setResult);
+```

package/dist/hooks/useAsyncControl.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.useAsyncControl = useAsyncControl;
+exports.useRawAsynControl = useRawAsynControl;
+var _react = require("react");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(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 source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function useRawAsynControl(functionsToWrap, _ref, _ref2) {
+  let [error, setError] = _ref;
+  let [loading, setLoading] = _ref2;
+  const _process = (0, _react.useCallback)(async asyncFn => {
+    try {
+      setLoading(true);
+      setError(undefined);
+      if (asyncFn instanceof Promise) await asyncFn;else return await asyncFn();
+    } catch (e) {
+      if (process.env.NODE_ENV === "development") console.error(e);
+      setError(e);
+      throw e;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const {
+    functionsToMemoize,
+    other
+  } = Object.entries(functionsToWrap || {}).reduce((r, _ref3) => {
+    let [k, func] = _ref3;
+    return _objectSpread(_objectSpread({}, r), typeof func === "function" ? {
+      functionsToMemoize: _objectSpread(_objectSpread({}, r.functionsToMemoize), {}, {
+        [k]: func
+      })
+    } : {
+      other: _objectSpread(_objectSpread({}, r.other), {}, {
+        [k]: func
+      })
+    });
+  }, {
+    functionsToMemoize: {},
+    other: {}
+  });
+  return _objectSpread(_objectSpread({
+    process: _process,
+    loading,
+    error,
+    setError,
+    setLoading
+  }, other), Object.entries(functionsToMemoize).reduce((r, _ref4) => {
+    let [k, v] = _ref4;
+    return _objectSpread(_objectSpread({}, r), {}, {
+      [k]: (0, _react.useMemo)(() => function () {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        return _process(() => v(...args));
+      }, [v])
+    });
+  }, {}));
+}
+function useAsyncControl(functionsToWrap) {
+  const error = (0, _react.useState)();
+  const loading = (0, _react.useState)(false);
+  return useRawAsynControl(functionsToWrap, error, loading);
+}
+
+/**
+ * This hook provides a way to handle async operations storing the loading state, or the error when it fails, it does not store information returned from the functions.
+ * @param functionsToWrap The functions to wrap in control.
+ * @returns
+ */
+var _default = exports.default = useAsyncControl;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","require","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","i","arguments","length","source","forEach","key","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","obj","value","_toPropertyKey","configurable","writable","arg","_toPrimitive","String","input","hint","prim","Symbol","toPrimitive","undefined","res","call","TypeError","Number","useRawAsynControl","functionsToWrap","_ref","_ref2","error","setError","loading","setLoading","_process","useCallback","asyncFn","Promise","e","process","env","NODE_ENV","console","functionsToMemoize","other","entries","reduce","r","_ref3","k","func","_ref4","v","useMemo","_len","args","Array","_key","useAsyncControl","useState","_default","exports","default"],"sources":["../../src/hooks/useAsyncControl.ts"],"sourcesContent":["import { SetStateAction, useCallback, useMemo, useState } from \"react\";\nimport { Primitive } from \"type-fest\";\n\ntype Arr<X> = [X, React.Dispatch<SetStateAction<X>>];\nexport type FunctionMap = {\n  [f: string]: ((...args: any[]) => Promise<any>) | Object | Primitive;\n};\nexport type Control<E extends any = any> = {\n  error?: E;\n  loading: boolean;\n};\nexport function useRawAsynControl<E = any, F extends FunctionMap = {}>(\n  functionsToWrap: F | undefined,\n  [error, setError]: Arr<E | undefined>,\n  [loading, setLoading]: Arr<boolean>\n) {\n  const _process = useCallback(async (asyncFn: (() => Promise<any>) | Promise<any>) => {\n    try {\n      setLoading(true);\n      setError(undefined);\n      if (asyncFn instanceof Promise) await asyncFn;\n      else return await asyncFn();\n    } catch (e) {\n      if (process.env.NODE_ENV === \"development\") console.error(e);\n      setError(e as E);\n      throw e;\n    } finally {\n      setLoading(false);\n    }\n  }, []);\n\n  const { functionsToMemoize, other } = Object.entries(\n    functionsToWrap || {}\n  ).reduce(\n    (r, [k, func]) => {\n      return {\n        ...r,\n        ...(typeof func === \"function\"\n          ? {\n              functionsToMemoize: {\n                ...r.functionsToMemoize,\n                [k]: func,\n              },\n            }\n          : {\n              other: {\n                ...r.other,\n                [k]: func,\n              },\n            }),\n      };\n    },\n    {\n      functionsToMemoize: {},\n      other: {},\n    } as {\n      functionsToMemoize: F;\n      other: F;\n    }\n  );\n\n  return {\n    process: _process,\n    loading,\n    error,\n    setError,\n    setLoading,\n    ...other,\n    ...Object.entries(functionsToMemoize).reduce(\n      (r, [k, v]) => ({\n        ...r,\n        [k]: useMemo(\n          () =>\n            (...args: any[]) =>\n              _process(() => (v as any)(...args)),\n          [v]\n        ),\n      }),\n      {} as F\n    ),\n  };\n}\n\nexport function useAsyncControl<\n  E = any,\n  F extends {\n    [f: string]: ((...args: any[]) => Promise<any>) | Object | Primitive;\n  } = {}\n>(functionsToWrap?: F) {\n  const error = useState<E | Error>();\n  const loading = useState<boolean>(false);\n\n  return useRawAsynControl(functionsToWrap, error, loading);\n}\n\n/**\n * This hook provides a way to handle async operations storing the loading state, or the error when it fails, it does not store information returned from the functions.\n * @param functionsToWrap The functions to wrap in control.\n * @returns\n */\nexport default useAsyncControl;\n"],"mappings":"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"}

package/dist/hooks/useContainedRepositioning.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useContainedRepositioning;
+var _debounce = _interopRequireDefault(require("lodash/debounce"));
+var _react = require("react");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * This hook takes an html and checks if its outside its parent
+ * If it is, it should move it so it can be totally visible inside the container
+ */
+function useContainedRepositioning(focused, getParent) {
+  let {
+    offset = 16,
+    scale = 1,
+    offsetLimit = Number.POSITIVE_INFINITY
+  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const elementToCheck = (0, _react.useRef)(null);
+  (0, _react.useEffect)(() => {
+    const el = elementToCheck.current;
+    if (!el) return;
+    const curr = el;
+    const relativeParent = getParent(curr);
+    if (process.env.NODE_ENV === "development") {
+      if (window.getComputedStyle(el).position !== "relative") throw new Error("The target element MUST have position relative so it can be moved");
+      if (window.getComputedStyle(relativeParent).position !== "relative") throw new Error("The relative to element MUST have position relative so it can calculate correctly the target position");
+    }
+    if (focused) {
+      curr.style.right = "0px";
+      const reposition = (0, _debounce.default)(() => {
+        const alreadyRight = Number(curr.style.right.replace("px", ""));
+        const limitOffset = relativeParent.scrollLeft + relativeParent.clientWidth;
+        const elWidth = curr.clientWidth * scale;
+        const offsetOfScale = (elWidth - curr.clientWidth) / 2;
+        const cardLimit = curr.offsetLeft - offsetOfScale + alreadyRight + elWidth;
+        const exceedingSpace = cardLimit - limitOffset;
+        const offsetLeft = curr.offsetLeft - offsetOfScale + alreadyRight - relativeParent.scrollLeft;
+        const isOverflowedRight = exceedingSpace > 0;
+        const isOverflowedLeft = offsetLeft < 0;
+        const limit = exceedingSpace + -offsetLeft;
+        if (isOverflowedRight) {
+          const val = Math.min(exceedingSpace - -Math.min(Math.abs(limit / 2), offset), offsetLimit);
+          curr.style.right = "".concat(val, "px");
+        }
+        if (isOverflowedLeft) {
+          const val = Math.max(offsetLeft - Math.min(Math.abs(limit) / 2, offset), -offsetLimit);
+          curr.style.right = "".concat(val, "px");
+        }
+        if (isOverflowedLeft || isOverflowedRight) {
+          curr.style.zIndex = "1000";
+        }
+      }, 50);
+      reposition();
+      reposition.flush();
+      relativeParent.addEventListener("scroll", reposition, {
+        passive: true
+      });
+      return () => {
+        reposition.cancel();
+        relativeParent.removeEventListener("scroll", reposition);
+        el.style.right = "0px";
+        const restore = _ref => {
+          let {
+            propertyName,
+            currentTarget
+          } = _ref;
+          const targetTransformation = window.getComputedStyle(currentTarget).right;
+          if (propertyName === "right" && targetTransformation === "0px") {
+            curr.style.zIndex = "";
+            el.removeEventListener("transitionend", restore);
+          }
+        };
+        el.addEventListener("transitionend", restore);
+      };
+    }
+  }, [focused]);
+  return {
+    elementToCheck
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_debounce","_interopRequireDefault","require","_react","obj","__esModule","default","useContainedRepositioning","focused","getParent","offset","scale","offsetLimit","Number","POSITIVE_INFINITY","arguments","length","undefined","elementToCheck","useRef","useEffect","el","current","curr","relativeParent","process","env","NODE_ENV","window","getComputedStyle","position","Error","style","right","reposition","debounce","alreadyRight","replace","limitOffset","scrollLeft","clientWidth","elWidth","offsetOfScale","cardLimit","offsetLeft","exceedingSpace","isOverflowedRight","isOverflowedLeft","limit","val","Math","min","abs","concat","max","zIndex","flush","addEventListener","passive","cancel","removeEventListener","restore","_ref","propertyName","currentTarget","targetTransformation"],"sources":["../../src/hooks/useContainedRepositioning.ts"],"sourcesContent":["import debounce from \"lodash/debounce\";\nimport { useEffect, useRef } from \"react\";\n\n/**\n * This hook takes an html and checks if its outside its parent\n * If it is, it should move it so it can be totally visible inside the container\n */\nexport default function useContainedRepositioning(\n  focused: boolean,\n  getParent: (el: HTMLElement) => HTMLElement,\n  {\n    offset = 16,\n    scale = 1,\n    offsetLimit = Number.POSITIVE_INFINITY,\n  }: {\n    /** The offset the element will be moved by from the closest bound */\n    offset?: number;\n\n    /** The scaled element width to be considered. usefull for when the focused element will change size */\n    scale?: number;\n\n    /** Limit offset */\n    offsetLimit?: number;\n  } = {}\n) {\n  const elementToCheck = useRef<HTMLDivElement>(null);\n  useEffect(() => {\n    const el = elementToCheck.current;\n    if (!el) return;\n\n    const curr = el;\n    const relativeParent = getParent(curr);\n\n    if (process.env.NODE_ENV === \"development\") {\n      if (window.getComputedStyle(el).position !== \"relative\")\n        throw new Error(\n          \"The target element MUST have position relative so it can be moved\"\n        );\n      if (window.getComputedStyle(relativeParent).position !== \"relative\")\n        throw new Error(\n          \"The relative to element MUST have position relative so it can calculate correctly the target position\"\n        );\n    }\n\n    if (focused) {\n      curr.style.right = `0px`;\n      const reposition = debounce(() => {\n        const alreadyRight = Number(curr.style.right.replace(\"px\", \"\"));\n        const limitOffset =\n          relativeParent.scrollLeft + relativeParent.clientWidth;\n        const elWidth = curr.clientWidth * scale;\n        const offsetOfScale = (elWidth - curr.clientWidth) / 2;\n        const cardLimit =\n          curr.offsetLeft - offsetOfScale + alreadyRight + elWidth;\n        const exceedingSpace = cardLimit - limitOffset;\n        const offsetLeft =\n          curr.offsetLeft -\n          offsetOfScale +\n          alreadyRight -\n          relativeParent.scrollLeft;\n        const isOverflowedRight = exceedingSpace > 0;\n        const isOverflowedLeft = offsetLeft < 0;\n        const limit = exceedingSpace + -offsetLeft;\n\n        if (isOverflowedRight) {\n          const val = Math.min(\n            exceedingSpace - -Math.min(Math.abs(limit / 2), offset),\n            offsetLimit\n          );\n          curr.style.right = `${val}px`;\n        }\n        if (isOverflowedLeft) {\n          const val = Math.max(\n            offsetLeft - Math.min(Math.abs(limit) / 2, offset),\n            -offsetLimit\n          );\n          curr.style.right = `${val}px`;\n        }\n        if (isOverflowedLeft || isOverflowedRight) {\n          curr.style.zIndex = \"1000\";\n        }\n      }, 50);\n      reposition();\n      reposition.flush();\n\n      relativeParent.addEventListener(\"scroll\", reposition, {\n        passive: true\n      });\n      return () => {\n        reposition.cancel();\n        relativeParent.removeEventListener(\"scroll\", reposition);\n        el.style.right = `0px`;\n        const restore = ({ propertyName, currentTarget }: TransitionEvent) => {\n          const targetTransformation = window.getComputedStyle(\n            currentTarget as HTMLDivElement\n          ).right;\n          if (propertyName === \"right\" && targetTransformation === \"0px\") {\n            curr.style.zIndex = \"\";\n            el.removeEventListener(\"transitionend\", restore);\n          }\n        };\n        el.addEventListener(\"transitionend\", restore);\n      };\n    }\n  }, [focused]);\n\n  return {\n    elementToCheck,\n  };\n}\n"],"mappings":"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"}