idmission-web-sdk 2.2.106 → 2.2.108

package/dist/sdk2.esm.js

@@ -6,7 +6,6 @@ import styled, { keyframes, useTheme, ThemeProvider as ThemeProvider$1 } from 's
 import { useTranslation, initReactI18next } from 'react-i18next';
 import { Upload } from 'tus-js-client';
 import SparkMD5 from 'spark-md5';
-import useResizeObserver from 'use-resize-observer';
 import { ImageSegmenter, FilesetResolver, ImageClassifier, FaceDetector, ObjectDetector } from '@mediapipe/tasks-vision';
 import { createStore, useStore, create } from 'zustand';
 import { useDebouncedCallback, useThrottledCallback } from 'use-debounce';
@@ -204,7 +203,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
   return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-var webSdkVersion = '2.2.106';
+var webSdkVersion = '2.2.108';
 
 function getPlatform() {
   // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -6130,6 +6129,122 @@ var ButtonContainer = styled.div(templateObject_4$j || (templateObject_4$j = __m
 var Button$1 = styled(LoaderButton)(templateObject_5$c || (templateObject_5$c = __makeTemplateObject(["\n  white-space: nowrap;\n  margin: auto;\n"], ["\n  white-space: nowrap;\n  margin: auto;\n"])));
 var templateObject_1$E, templateObject_2$x, templateObject_3$p, templateObject_4$j, templateObject_5$c;
 
+// This is a simplified version of https://github.com/ZeeCoder/use-resize-observer.
+// We have removed all options and made it compliant with React Compiler/React 19.
+function useResizeObserver() {
+  // Using a single instance throughout the hook's lifetime
+  var resizeObserverRef = useRef();
+  var _a = useState({}),
+    size = _a[0],
+    setSize = _a[1];
+  // In certain edge cases the RO might want to report a size change just after
+  // the component unmounted.
+  var didUnmount = useRef(false);
+  useEffect(function () {
+    didUnmount.current = false;
+    return function () {
+      didUnmount.current = true;
+    };
+  }, []);
+  // Using a ref to track the previous width / height to avoid unnecessary renders.
+  var previous = useRef({});
+  // This block is kinda like a useEffect, only it's called whenever a new
+  // element could be resolved based on the ref option. It also has a cleanup
+  // function.
+  var refCallback = useResolvedElement(useCallback(function (element) {
+    // We only use a single Resize Observer instance, and we're instantiating it on demand, only once there's something to observe.
+    // This instance is also recreated when the `box` option changes, so that a new observation is fired if there was a previously observed element with a different box option.
+    resizeObserverRef.current || (resizeObserverRef.current = new ResizeObserver(function (entries) {
+      var entry = entries[0];
+      var reportedWidth = extractSize(entry, 'inlineSize');
+      var reportedHeight = extractSize(entry, 'blockSize');
+      var newWidth = reportedWidth ? Math.round(reportedWidth) : undefined;
+      var newHeight = reportedHeight ? Math.round(reportedHeight) : undefined;
+      if (previous.current.width !== newWidth || previous.current.height !== newHeight) {
+        var newSize = {
+          width: newWidth,
+          height: newHeight
+        };
+        previous.current.width = newWidth;
+        previous.current.height = newHeight;
+        if (!didUnmount.current) {
+          setSize(newSize);
+        }
+      }
+    }));
+    resizeObserverRef.current.observe(element);
+    return function () {
+      var _a, _b;
+      (_b = (_a = resizeObserverRef.current) === null || _a === void 0 ? void 0 : _a.unobserve) === null || _b === void 0 ? void 0 : _b.call(_a, element);
+    };
+  }, []));
+  return useMemo(function () {
+    return {
+      ref: refCallback,
+      width: size.width,
+      height: size.height
+    };
+  }, [refCallback, size.width, size.height]);
+}
+// This could've been more streamlined with internal state instead of abusing
+// refs to such extent, but then composing hooks and components could not opt out of unnecessary renders.
+function useResolvedElement(subscriber) {
+  var lastReportRef = useRef(null);
+  var cbElementRef = useRef(null);
+  // Calling re-evaluation after each render without using a dep array,
+  // as the ref object's current value could've changed since the last render.
+  useEffect(function () {
+    evaluateSubscription();
+  });
+  var evaluateSubscription = useCallback(function () {
+    var cbElement = cbElementRef.current;
+    // Ugly ternary. But smaller than an if-else block.
+    var element = cbElement ? cbElement : null;
+    if (lastReportRef.current && lastReportRef.current.element === element && lastReportRef.current.subscriber === subscriber) {
+      return;
+    }
+    if (lastReportRef.current && lastReportRef.current.cleanup) {
+      lastReportRef.current.cleanup();
+    }
+    lastReportRef.current = {
+      element: element,
+      subscriber: subscriber,
+      // Only calling the subscriber, if there's an actual element to report.
+      // Setting cleanup to undefined unless a subscriber returns one, as an existing cleanup function would've been just called.
+      cleanup: element ? subscriber(element) : undefined
+    };
+  }, [subscriber]);
+  // making sure we call the cleanup function on unmount
+  useEffect(function () {
+    return function () {
+      if (lastReportRef.current && lastReportRef.current.cleanup) {
+        lastReportRef.current.cleanup();
+        lastReportRef.current = null;
+      }
+    };
+  }, []);
+  return useCallback(function (element) {
+    cbElementRef.current = element;
+    evaluateSubscription();
+  }, [evaluateSubscription]);
+}
+function extractSize(entry, sizeType) {
+  if (!entry.contentBoxSize) {
+    // The dimensions in `contentBoxSize` and `contentRect` are equivalent according to the spec.
+    // See the 6th step in the description for the RO algorithm:
+    // https://drafts.csswg.org/resize-observer/#create-and-populate-resizeobserverentry-h
+    // > Set this.contentRect to logical this.contentBoxSize given target and observedBox of "content-box".
+    // In real browser implementations of course these objects differ, but the width/height values should be equivalent.
+    return entry.contentRect[sizeType === 'inlineSize' ? 'width' : 'height'];
+  }
+  // A couple bytes smaller than calling Array.isArray() and just as effective here.
+  return entry.contentBoxSize[0] ? entry.contentBoxSize[0][sizeType] :
+  // TS complains about this, because the RO entry type follows the spec and does not reflect Firefox's current
+  // behaviour of returning objects instead of arrays for `borderBoxSize` and `contentBoxSize`.
+  // @ts-expect-error TS2339: Property '0' does not exist on type 'ResizeObserverSize'.
+  entry.contentBoxSize[sizeType];
+}
+
 var IdCapture = function IdCapture(_a) {
   var _b, _c, _d, _e, _f, _g, _h;
   var requiredDocumentType = _a.requiredDocumentType,
@@ -12904,8 +13019,9 @@ function VideoSignatureContextProvider(_a) {
     (function () {
       return __awaiter(_this, void 0, void 0, function () {
         var stream, tracks, audioTrack;
-        return __generator(this, function (_a) {
-          switch (_a.label) {
+        var _a;
+        return __generator(this, function (_b) {
+          switch (_b.label) {
             case 0:
               if (!!outputCanvas.current) return [3 /*break*/, 2];
               return [4 /*yield*/, new Promise(function (resolve) {
@@ -12917,17 +13033,18 @@ function VideoSignatureContextProvider(_a) {
                 }, 10);
               })];
             case 1:
-              _a.sent();
-              _a.label = 2;
+              _b.sent();
+              _b.label = 2;
             case 2:
               startRecordingVideo();
               if (captureAudio) startRecordingAudio();
               stream = outputCanvas.current.captureStream(24 /* fps */);
               tracks = [stream.getVideoTracks()[0]];
-              audioTrack = audioStream.getAudioTracks()[0];
+              audioTrack = (_a = audioStream === null || audioStream === void 0 ? void 0 : audioStream.getAudioTracks()) === null || _a === void 0 ? void 0 : _a[0];
               if (audioTrack) tracks.push(audioTrack);
               signatureRecorder.current = new MediaRecorder(new MediaStream(tracks), {
-                videoBitsPerSecond: 270000
+                videoBitsPerSecond: 270000,
+                audioBitsPerSecond: 32000
               });
               signatureRecorder.current.start();
               signatureRecorder.current.ondataavailable = function (event) {