@zync/zync-screnplay-player 0.1.187

package/dist/screenplay/RemotionRenderer/helpers/cleanFacemetadata.js

@@ -0,0 +1,29 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+export var cleanFacemetadata = function cleanFacemetadata(faceMetadata) {
+  var _faceMetadata$face_me, _averaged$face_data, _averaged$sample_coun;
+  if (!faceMetadata) {
+    return faceMetadata;
+  }
+  var rawFrames = (_faceMetadata$face_me = faceMetadata.face_metadata) !== null && _faceMetadata$face_me !== void 0 ? _faceMetadata$face_me : [];
+  var frames = rawFrames.filter(function (_ref) {
+    var face_data = _ref.face_data;
+    return Boolean(face_data);
+  });
+  var averaged = rawFrames.find(function (_ref2) {
+    var aggregation = _ref2.aggregation;
+    return aggregation === "average";
+  });
+  return _objectSpread(_objectSpread({}, faceMetadata), {}, {
+    metadata: {
+      videoProperties: faceMetadata.video_properties,
+      frames: frames,
+      averageFaceData: (_averaged$face_data = averaged === null || averaged === void 0 ? void 0 : averaged.face_data) !== null && _averaged$face_data !== void 0 ? _averaged$face_data : null,
+      averageSampleCount: (_averaged$sample_coun = averaged === null || averaged === void 0 ? void 0 : averaged.sample_count) !== null && _averaged$sample_coun !== void 0 ? _averaged$sample_coun : 0
+    }
+  });
+};

package/dist/screenplay/RemotionRenderer/helpers/convertToSeconds.js

@@ -0,0 +1,14 @@
+/**
+ * Converts seconds and a portion of frames to a numeric value of seconds.
+ *
+ * @param {number} seconds - The number of full seconds.
+ * @param {number} nthFrame - The current frame within the second.
+ * @param {number} delayInSeconds - Optional delay that adds up to the calculation
+ * @param {number} frameRate - The frame rate (frames per second).
+ * @return {number} The total time in seconds (with decimals for frames).
+ */
+export var convertToSeconds = function convertToSeconds(seconds, nthFrame) {
+  var delayInSeconds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var frameRate = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 24;
+  return seconds + nthFrame / frameRate + delayInSeconds;
+};

package/dist/screenplay/RemotionRenderer/helpers/faceBasedVideoStyles.js

@@ -0,0 +1,212 @@
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _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(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+/**
+ * Calculate video styles based on face detection metadata
+ * This helper adjusts video positioning and transform origin to center faces in the viewport
+ * when zooming, accounting for objectFit: "cover" behavior
+ */
+export var getFaceBasedVideoStyles = function getFaceBasedVideoStyles(_ref) {
+  var faceMetadata = _ref.faceMetadata,
+    videoZoom = _ref.videoZoom,
+    sourceVideoOrientation = _ref.sourceVideoOrientation,
+    containerWidth = _ref.containerWidth,
+    containerHeight = _ref.containerHeight,
+    _ref$currentFrame = _ref.currentFrame,
+    currentFrame = _ref$currentFrame === void 0 ? 0 : _ref$currentFrame,
+    _ref$interpolate = _ref.interpolate,
+    interpolate = _ref$interpolate === void 0 ? false : _ref$interpolate,
+    _ref$existingTransfor = _ref.existingTransform,
+    existingTransform = _ref$existingTransfor === void 0 ? "" : _ref$existingTransfor;
+  // Validate inputs
+  if (!containerWidth || !containerHeight || containerWidth <= 0 || containerHeight <= 0) {
+    console.warn('getFaceBasedVideoStyles: Invalid container dimensions', {
+      containerWidth: containerWidth,
+      containerHeight: containerHeight
+    });
+    return {
+      styles: {
+        transformOrigin: "center center"
+      },
+      faceDebugInfo: null
+    };
+  }
+
+  // Default styles when no face data or zoom is available
+  var defaultStyles = {
+    styles: {
+      transformOrigin: "center center",
+      objectPosition: sourceVideoOrientation === "portrait" ? "0% 30%" : undefined
+    },
+    faceDebugInfo: null
+  };
+  if (!(faceMetadata !== null && faceMetadata !== void 0 && faceMetadata.metadata)) {
+    return defaultStyles;
+  }
+  var _faceMetadata$metadat = faceMetadata.metadata,
+    videoProperties = _faceMetadata$metadat.videoProperties,
+    frames = _faceMetadata$metadat.frames;
+
+  // Find face data for current frame with interpolation support
+  var getFaceDataForFrame = function getFaceDataForFrame(targetFrame) {
+    if (!frames || frames.length === 0) return null;
+
+    // Find exact frame or closest frames for interpolation
+    var exactFrame = frames.find(function (f) {
+      return f.frame_index === targetFrame && f.face_detected;
+    });
+    if (exactFrame) return exactFrame.face_data;
+    if (!interpolate) {
+      // Find closest frame with face data
+      var _framesWithFaces = frames.filter(function (f) {
+        return f.face_detected && f.face_data;
+      });
+      if (_framesWithFaces.length === 0) return null;
+      return _framesWithFaces.reduce(function (closest, current) {
+        var closestDiff = Math.abs(closest.frame_index - targetFrame);
+        var currentDiff = Math.abs(current.frame_index - targetFrame);
+        return currentDiff < closestDiff ? current : closest;
+      }).face_data;
+    }
+
+    // Interpolate between frames
+    var framesWithFaces = frames.filter(function (f) {
+      return f.face_detected && f.face_data;
+    }).sort(function (a, b) {
+      return a.frame_index - b.frame_index;
+    });
+    if (framesWithFaces.length === 0) return null;
+    if (framesWithFaces.length === 1) return framesWithFaces[0].face_data;
+
+    // Find surrounding frames
+    var prevFrame = null;
+    var nextFrame = null;
+    for (var i = 0; i < framesWithFaces.length; i++) {
+      if (framesWithFaces[i].frame_index <= targetFrame) {
+        prevFrame = framesWithFaces[i];
+      }
+      if (framesWithFaces[i].frame_index >= targetFrame && !nextFrame) {
+        nextFrame = framesWithFaces[i];
+      }
+    }
+
+    // If we only have frames on one side, use the closest one
+    if (!prevFrame) return nextFrame.face_data;
+    if (!nextFrame) return prevFrame.face_data;
+
+    // Interpolate between frames
+    var progress = (targetFrame - prevFrame.frame_index) / (nextFrame.frame_index - prevFrame.frame_index);
+    var _prevFrame$face_data$ = _slicedToArray(prevFrame.face_data.face_center, 2),
+      prevX = _prevFrame$face_data$[0],
+      prevY = _prevFrame$face_data$[1];
+    var _nextFrame$face_data$ = _slicedToArray(nextFrame.face_data.face_center, 2),
+      nextX = _nextFrame$face_data$[0],
+      nextY = _nextFrame$face_data$[1];
+    return {
+      face_center: [prevX + (nextX - prevX) * progress, prevY + (nextY - prevY) * progress],
+      // Use the closer frame's bbox for simplicity
+      face_bbox: progress < 0.5 ? prevFrame.face_data.face_bbox : nextFrame.face_data.face_bbox
+    };
+  };
+  var faceData = getFaceDataForFrame(currentFrame);
+  if (!faceData || !videoProperties) {
+    return defaultStyles;
+  }
+  var face_center = faceData.face_center;
+  var _face_center = _slicedToArray(face_center, 2),
+    faceCenterX = _face_center[0],
+    faceCenterY = _face_center[1];
+  var sourceWidth = videoProperties.width,
+    sourceHeight = videoProperties.height;
+
+  // Calculate how objectFit: "cover" affects the video
+  var sourceAspectRatio = sourceWidth / sourceHeight;
+  var containerAspectRatio = containerWidth / containerHeight;
+  var visibleVideoWidth, visibleVideoHeight;
+  var cropOffsetX = 0,
+    cropOffsetY = 0;
+  if (sourceAspectRatio > containerAspectRatio) {
+    // Source is wider than container - video will be cropped horizontally
+    // The video height will fill the container, width will be cropped
+    visibleVideoHeight = sourceHeight;
+    visibleVideoWidth = sourceHeight * containerAspectRatio;
+    cropOffsetX = (sourceWidth - visibleVideoWidth) / 2;
+  } else {
+    // Source is taller than container - video will be cropped vertically  
+    // The video width will fill the container, height will be cropped
+    visibleVideoWidth = sourceWidth;
+    visibleVideoHeight = sourceWidth / containerAspectRatio;
+    cropOffsetY = (sourceHeight - visibleVideoHeight) / 2;
+  }
+
+  // Check if face is within the visible (non-cropped) area
+  var faceInVisibleArea = faceCenterX >= cropOffsetX && faceCenterX <= cropOffsetX + visibleVideoWidth && faceCenterY >= cropOffsetY && faceCenterY <= cropOffsetY + visibleVideoHeight;
+  if (!faceInVisibleArea) {
+    console.warn('Face is outside visible video area after cropping');
+    return defaultStyles;
+  }
+
+  // Calculate face position as percentage of the VISIBLE video area
+  var faceXInVisible = faceCenterX - cropOffsetX;
+  var faceYInVisible = faceCenterY - cropOffsetY;
+  var faceXPercent = faceXInVisible / visibleVideoWidth * 100;
+  var faceYPercent = faceYInVisible / visibleVideoHeight * 100;
+
+  // Calculate how much to translate the video to center the face
+  // If face is at 10.7% from left, we need to move video right by (50 - 10.7) = 39.3%
+  var translateXPercent = 50 - faceXPercent; // Positive = move right
+  var translateYPercent = 50 - faceYPercent; // Positive = move down
+
+  // Convert percentages to actual pixel values based on container size
+  var translateXPx = translateXPercent / 100 * containerWidth;
+  var translateYPx = translateYPercent / 100 * containerHeight;
+
+  // Debug logging
+  console.log('Face positioning debug:', {
+    faceCenterX: faceCenterX,
+    faceCenterY: faceCenterY,
+    visibleVideoWidth: visibleVideoWidth,
+    visibleVideoHeight: visibleVideoHeight,
+    cropOffsetX: cropOffsetX,
+    cropOffsetY: cropOffsetY,
+    faceXInVisible: faceXInVisible,
+    faceYInVisible: faceYInVisible,
+    faceXPercent: faceXPercent.toFixed(1),
+    faceYPercent: faceYPercent.toFixed(1),
+    translateXPercent: translateXPercent.toFixed(1),
+    translateYPercent: translateYPercent.toFixed(1),
+    translateXPx: translateXPx.toFixed(1),
+    translateYPx: translateYPx.toFixed(1)
+  });
+
+  // Combine face positioning with existing transforms
+  var faceTransform = "translate(".concat(translateXPx, "px, ").concat(translateYPx, "px)");
+  var combinedTransform = existingTransform ? "".concat(existingTransform, " ").concat(faceTransform) : faceTransform;
+  return {
+    styles: {
+      transformOrigin: "".concat(faceXPercent, "% ").concat(faceYPercent, "%"),
+      transform: combinedTransform
+    },
+    faceDebugInfo: {
+      faceXPercent: faceXPercent,
+      faceYPercent: faceYPercent,
+      objectPositionX: objectPositionX,
+      objectPositionY: objectPositionY,
+      faceCenterX: faceCenterX,
+      faceCenterY: faceCenterY,
+      sourceWidth: sourceWidth,
+      sourceHeight: sourceHeight,
+      containerWidth: containerWidth,
+      containerHeight: containerHeight,
+      visibleVideoWidth: visibleVideoWidth,
+      visibleVideoHeight: visibleVideoHeight,
+      cropOffsetX: cropOffsetX,
+      cropOffsetY: cropOffsetY,
+      faceXInVisible: faceXInVisible,
+      faceYInVisible: faceYInVisible
+    }
+  };
+};