@wise/dynamic-flow-client 2.2.0-beta-baf68b.13 → 2.2.0-beta-4f3927.14

package/build/main.js

@@ -525,6 +525,168 @@ var require_react_webcam = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/screenfull@5.2.0/node_modules/screenfull/dist/screenfull.js
+var require_screenfull = __commonJS({
+  "../../node_modules/.pnpm/screenfull@5.2.0/node_modules/screenfull/dist/screenfull.js"(exports, module2) {
+    (function() {
+      "use strict";
+      var document2 = typeof window !== "undefined" && typeof window.document !== "undefined" ? window.document : {};
+      var isCommonjs = typeof module2 !== "undefined" && module2.exports;
+      var fn = function() {
+        var val;
+        var fnMap = [
+          [
+            "requestFullscreen",
+            "exitFullscreen",
+            "fullscreenElement",
+            "fullscreenEnabled",
+            "fullscreenchange",
+            "fullscreenerror"
+          ],
+          // New WebKit
+          [
+            "webkitRequestFullscreen",
+            "webkitExitFullscreen",
+            "webkitFullscreenElement",
+            "webkitFullscreenEnabled",
+            "webkitfullscreenchange",
+            "webkitfullscreenerror"
+          ],
+          // Old WebKit
+          [
+            "webkitRequestFullScreen",
+            "webkitCancelFullScreen",
+            "webkitCurrentFullScreenElement",
+            "webkitCancelFullScreen",
+            "webkitfullscreenchange",
+            "webkitfullscreenerror"
+          ],
+          [
+            "mozRequestFullScreen",
+            "mozCancelFullScreen",
+            "mozFullScreenElement",
+            "mozFullScreenEnabled",
+            "mozfullscreenchange",
+            "mozfullscreenerror"
+          ],
+          [
+            "msRequestFullscreen",
+            "msExitFullscreen",
+            "msFullscreenElement",
+            "msFullscreenEnabled",
+            "MSFullscreenChange",
+            "MSFullscreenError"
+          ]
+        ];
+        var i = 0;
+        var l = fnMap.length;
+        var ret = {};
+        for (; i < l; i++) {
+          val = fnMap[i];
+          if (val && val[1] in document2) {
+            for (i = 0; i < val.length; i++) {
+              ret[fnMap[0][i]] = val[i];
+            }
+            return ret;
+          }
+        }
+        return false;
+      }();
+      var eventNameMap = {
+        change: fn.fullscreenchange,
+        error: fn.fullscreenerror
+      };
+      var screenfull2 = {
+        request: function(element, options) {
+          return new Promise(function(resolve, reject) {
+            var onFullScreenEntered = function() {
+              this.off("change", onFullScreenEntered);
+              resolve();
+            }.bind(this);
+            this.on("change", onFullScreenEntered);
+            element = element || document2.documentElement;
+            var returnPromise = element[fn.requestFullscreen](options);
+            if (returnPromise instanceof Promise) {
+              returnPromise.then(onFullScreenEntered).catch(reject);
+            }
+          }.bind(this));
+        },
+        exit: function() {
+          return new Promise(function(resolve, reject) {
+            if (!this.isFullscreen) {
+              resolve();
+              return;
+            }
+            var onFullScreenExit = function() {
+              this.off("change", onFullScreenExit);
+              resolve();
+            }.bind(this);
+            this.on("change", onFullScreenExit);
+            var returnPromise = document2[fn.exitFullscreen]();
+            if (returnPromise instanceof Promise) {
+              returnPromise.then(onFullScreenExit).catch(reject);
+            }
+          }.bind(this));
+        },
+        toggle: function(element, options) {
+          return this.isFullscreen ? this.exit() : this.request(element, options);
+        },
+        onchange: function(callback) {
+          this.on("change", callback);
+        },
+        onerror: function(callback) {
+          this.on("error", callback);
+        },
+        on: function(event, callback) {
+          var eventName = eventNameMap[event];
+          if (eventName) {
+            document2.addEventListener(eventName, callback, false);
+          }
+        },
+        off: function(event, callback) {
+          var eventName = eventNameMap[event];
+          if (eventName) {
+            document2.removeEventListener(eventName, callback, false);
+          }
+        },
+        raw: fn
+      };
+      if (!fn) {
+        if (isCommonjs) {
+          module2.exports = { isEnabled: false };
+        } else {
+          window.screenfull = { isEnabled: false };
+        }
+        return;
+      }
+      Object.defineProperties(screenfull2, {
+        isFullscreen: {
+          get: function() {
+            return Boolean(document2[fn.fullscreenElement]);
+          }
+        },
+        element: {
+          enumerable: true,
+          get: function() {
+            return document2[fn.fullscreenElement];
+          }
+        },
+        isEnabled: {
+          enumerable: true,
+          get: function() {
+            return Boolean(document2[fn.fullscreenEnabled]);
+          }
+        }
+      });
+      if (isCommonjs) {
+        module2.exports = screenfull2;
+      } else {
+        window.screenfull = screenfull2;
+      }
+    })();
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -5847,6 +6009,7 @@ var import_react36 = require("react");
 var import_react35 = require("react");
 var import_react_intl30 = require("react-intl");
 var import_react_webcam = __toESM(require_react_webcam());
+var import_screenfull = __toESM(require_screenfull());
 
 // src/step/cameraStep/cameraCapture/CameraCapture.messages.ts
 var import_react_intl22 = require("react-intl");
@@ -6206,6 +6369,24 @@ var CameraCapture = ({
   const webcamReference = (0, import_react35.useRef)(null);
   const { videoConstraints } = useVideoConstraints(direction);
   const intl = (0, import_react_intl30.useIntl)();
+  const lockOrientation = (0, import_react35.useCallback)(() => {
+    if (window.screen.orientation && "lock" in window.screen.orientation && typeof window.screen.orientation.lock === "function") {
+      window.screen.orientation.lock("portrait").then(() => {
+        console.log("orientation locked");
+      }).catch((e) => {
+        console.log(e);
+      });
+    }
+  }, []);
+  const enterFullScreen = (0, import_react35.useCallback)(() => {
+    if (mode === "CAPTURE" && isMobileDevice && !import_screenfull.default.isFullscreen && import_screenfull.default.isEnabled) {
+      import_screenfull.default.request(document.documentElement, { navigationUI: "show" }).then(() => {
+        lockOrientation();
+      }).catch((e) => {
+        console.log(e);
+      });
+    }
+  }, [mode, isMobileDevice, lockOrientation]);
   const handleCapture = (0, import_react35.useCallback)(async () => {
     var _a, _b, _c, _d, _e, _f;
     if (((_a = webcamReference == null ? void 0 : webcamReference.current) == null ? void 0 : _a.video) && ((_c = (_b = webcamReference == null ? void 0 : webcamReference.current) == null ? void 0 : _b.video) == null ? void 0 : _c.readyState) >= 3) {
@@ -6242,11 +6423,12 @@ var CameraCapture = ({
   );
   const handleUserMedia = (0, import_react35.useCallback)(
     (stream) => {
+      enterFullScreen();
       setReady(true);
       setIsVideoMirrored(isSelfieCamera(stream));
       void trackCameraFeedStarted(onEvent, { direction }, stream);
     },
-    [setIsVideoMirrored, onEvent, direction]
+    [setIsVideoMirrored, onEvent, direction, enterFullScreen]
   );
   const handleReviewSubmit = () => {
     onCapture((reviewImage == null ? void 0 : reviewImage.blob) || null);
@@ -6257,23 +6439,10 @@ var CameraCapture = ({
   };
   const handleRetryCameraAccess = () => setMode("CAPTURE");
   (0, import_react35.useEffect)(() => {
-    if (mode === "CAPTURE" && isMobileDevice && !document.fullscreenElement) {
-      document.documentElement.requestFullscreen({ navigationUI: "show" }).then(() => {
-        if (window.screen.orientation && "lock" in window.screen.orientation && typeof window.screen.orientation.lock === "function") {
-          window.screen.orientation.lock("portrait").then(() => {
-            console.log("orientation locked");
-          }).catch((e) => {
-            console.log(e);
-          });
-        }
-      }).catch((e) => {
-        console.log(e);
-      });
-    }
     return () => {
       var _a, _b;
-      if (document.fullscreenElement !== null) {
-        document.exitFullscreen().then(() => {
+      if ((mode !== "CAPTURE" || !isMobileDevice) && import_screenfull.default.isFullscreen) {
+        import_screenfull.default.exit().then(() => {
           console.log("Document Exited from Full screen mode");
         }).catch((err) => {
           console.error(err);
@@ -7867,4 +8036,11 @@ classnames/index.js:
   	Licensed under the MIT License (MIT), see
   	http://jedwatson.github.io/classnames
   *)
+
+screenfull/dist/screenfull.js:
+  (*!
+  * screenfull
+  * v5.2.0 - 2021-11-03
+  * (c) Sindre Sorhus; MIT License
+  *)
 */