react-native-smooth-clip-view 0.2.9 → 0.4.0

package/cpp/SmoothClipRegistry.h

@@ -7,23 +7,43 @@
 
 namespace smoothclip {
 
+enum class ClipCurve : int32_t {
+  Circular = 0,
+  Continuous = 1,
+};
+
 struct Geometry {
   double x;
   double y;
   double width;
   double height;
   double radius;
+  // NaN means "use radius", allowing concise uniform-radius presentations.
+  double topLeftRadius = std::numeric_limits<double>::quiet_NaN();
+  double topRightRadius = std::numeric_limits<double>::quiet_NaN();
+  double bottomRightRadius = std::numeric_limits<double>::quiet_NaN();
+  double bottomLeftRadius = std::numeric_limits<double>::quiet_NaN();
+  ClipCurve curve = ClipCurve::Circular;
+};
+
+struct Shadow {
+  bool enabled = false;
+  double red = 0;
+  double green = 0;
+  double blue = 0;
+  double alpha = 1;
+  double offsetX = 0;
+  double offsetY = 0;
+  double blurRadius = 0;
+  double spreadDistance = 0;
 };
 
 struct Presentation {
   Geometry clip;
   double contentTranslateX;
   double contentTranslateY;
-};
-
-struct Keyframe {
-  double offset;
-  Presentation presentation;
+  double contentScale = 1.0;
+  Shadow shadow{};
 };
 
 struct TimingAnimation {
@@ -42,6 +62,7 @@ struct SpringAnimation {
   double initialVelocity;
   bool inheritVelocity;
   int32_t reduceMotion;
+  double energyThreshold = 6e-9;
 };
 
 struct AnimationStart {
@@ -62,19 +83,46 @@ struct CancelResult {
   Presentation presentation;
 };
 
+struct DriverSnapshot {
+  uint64_t driverId;
+  Presentation presentation;
+  bool ready;
+};
+
+struct BatchEntry {
+  uint64_t driverId;
+  Presentation presentation;
+};
+
+struct GroupMotionEntry {
+  uint64_t driverId;
+  bool hasFrom;
+  Presentation from;
+  Presentation target;
+};
+
+enum class GroupCancelBehavior : int32_t {
+  Freeze = 0,
+  Finish = 1,
+};
+
 using CompletionCallback =
-    std::function<void(uint64_t, int32_t, bool)>;
+    std::function<void(uint64_t, int32_t, int32_t, bool)>;
+using GroupCompletionCallback =
+    std::function<
+        void(uint64_t, int32_t, int32_t, bool, std::vector<DriverSnapshot>)>;
 
 void setCompletionCallback(
     const void *owner,
     CompletionCallback callback);
 void clearCompletionCallback(const void *owner);
+void setGroupCompletionCallback(
+    const void *owner,
+    GroupCompletionCallback callback);
+void clearGroupCompletionCallback(const void *owner);
 
-// recordVelocity gates the 'inherit' velocity-sample recording for this write.
-// Default true (the pre-flag behavior); Android's JS layer passes false for
-// setScalars hot writes on drivers without SmoothClipDriverOptions
-// .velocityTracking, so the per-frame drag stream skips the clock read and
-// channel copies. iOS callers never pass it and keep recording always.
+// Interactive writes always keep the two samples needed by a later
+// `initialVelocity: "inherit"` spring.
 void setPresentation(
     uint64_t driverId,
     Presentation presentation,
@@ -82,23 +130,39 @@ void setPresentation(
     bool overridePendingAnimation = false,
     bool recordVelocity = true);
 Presentation beginInteraction(uint64_t driverId);
+Presentation snapshotCurrent(uint64_t driverId);
+std::vector<DriverSnapshot> beginGroupInteraction(
+    const std::vector<uint64_t> &driverIds);
+std::vector<DriverSnapshot> snapshotGroup(
+    const std::vector<uint64_t> &driverIds);
+bool setPresentationBatch(const std::vector<BatchEntry> &entries);
+int32_t animateTimingGroup(
+    uint64_t controllerId,
+    std::vector<GroupMotionEntry> entries,
+    TimingAnimation animation,
+    int32_t completionTag = 0,
+    double startedAtHintS = std::numeric_limits<double>::quiet_NaN());
+int32_t animateSpringGroup(
+    uint64_t controllerId,
+    std::vector<GroupMotionEntry> entries,
+    SpringAnimation animation,
+    int32_t completionTag = 0,
+    double startedAtHintS = std::numeric_limits<double>::quiet_NaN());
+std::vector<DriverSnapshot> cancelAnimationGroup(
+    int32_t groupId,
+    GroupCancelBehavior behavior);
 int32_t animateTiming(
     uint64_t driverId,
     AnimationStart start,
     Presentation presentation,
-    TimingAnimation animation);
+    TimingAnimation animation,
+    int32_t completionTag = 0);
 int32_t animateSpring(
     uint64_t driverId,
     AnimationStart start,
     Presentation presentation,
-    SpringAnimation animation);
-int32_t animateKeyframes(
-    uint64_t driverId,
-    AnimationStart start,
-    Presentation presentation,
-    double durationMs,
-    std::vector<Keyframe> keyframes,
-    int32_t reduceMotion);
+    SpringAnimation animation,
+    int32_t completionTag = 0);
 int32_t rejectAnimation(uint64_t driverId);
 CancelResult cancelAnimation(
     uint64_t driverId,

package/cpp/SmoothClipSharedGeometry.h

@@ -1,50 +1,159 @@
 #pragma once
 
+#include "SmoothClipRegistry.h"
+
 #include <algorithm>
 #include <cmath>
 
 namespace smoothclip {
 
-struct NormalizedClip {
+/**
+ * Host-independent canonical clip geometry expressed as edges.
+ *
+ * The moving aperture is allowed to cross or sit outside any host. Hosts crop
+ * the rendered result; they never rewrite the geometry stored by the driver.
+ */
+struct CanonicalClip {
   double left = 0;
   double top = 0;
   double right = 0;
   double bottom = 0;
   double radius = 0;
+  double topLeftRadius = 0;
+  double topRightRadius = 0;
+  double bottomRightRadius = 0;
+  double bottomLeftRadius = 0;
+  ClipCurve curve = ClipCurve::Circular;
 };
 
-// Shared clip normalization emitting edges (Android's Outline consumes
-// edges). Mirrors ios/SmoothClipGeometry.h (SmoothClipNormalizeGeometry) and
-// ClipGeometryNormalizer.kt (normalizeClipGeometryPx); a change here must
-// land in all three.
-inline bool SmoothClipNormalize(
+inline double SmoothClipResolvedRadius(double overrideValue, double radius) {
+  return std::isfinite(overrideValue) ? overrideValue : radius;
+}
+
+/**
+ * Canonicalizes a requested rectangle without consulting host dimensions.
+ *
+ * Negative dimensions collapse to zero. Corner radii follow the CSS
+ * corner-overlap rule against the requested rectangle, using one common scale
+ * factor so their proportions are preserved.
+ */
+inline bool SmoothClipCanonicalize(
     double x,
     double y,
     double width,
     double height,
     double radius,
-    double hostWidth,
-    double hostHeight,
-    NormalizedClip &out) {
+    double topLeftRadius,
+    double topRightRadius,
+    double bottomRightRadius,
+    double bottomLeftRadius,
+    ClipCurve curve,
+    CanonicalClip &out) {
+  const double resolvedTopLeft =
+      SmoothClipResolvedRadius(topLeftRadius, radius);
+  const double resolvedTopRight =
+      SmoothClipResolvedRadius(topRightRadius, radius);
+  const double resolvedBottomRight =
+      SmoothClipResolvedRadius(bottomRightRadius, radius);
+  const double resolvedBottomLeft =
+      SmoothClipResolvedRadius(bottomLeftRadius, radius);
   if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(width) ||
       !std::isfinite(height) || !std::isfinite(radius) ||
-      !std::isfinite(hostWidth) || !std::isfinite(hostHeight)) {
+      !std::isfinite(resolvedTopLeft) ||
+      !std::isfinite(resolvedTopRight) ||
+      !std::isfinite(resolvedBottomRight) ||
+      !std::isfinite(resolvedBottomLeft) ||
+      (curve != ClipCurve::Circular && curve != ClipCurve::Continuous)) {
     return false;
   }
 
-  const double boundedHostWidth = std::max(0.0, hostWidth);
-  const double boundedHostHeight = std::max(0.0, hostHeight);
-  const double requestedRight = x + std::max(0.0, width);
-  const double requestedBottom = y + std::max(0.0, height);
-  out.left = std::min(boundedHostWidth, std::max(0.0, x));
-  out.top = std::min(boundedHostHeight, std::max(0.0, y));
-  out.right = std::min(boundedHostWidth, std::max(0.0, requestedRight));
-  out.bottom = std::min(boundedHostHeight, std::max(0.0, requestedBottom));
-  const double visibleWidth = std::max(0.0, out.right - out.left);
-  const double visibleHeight = std::max(0.0, out.bottom - out.top);
-  out.radius = std::min(
-      std::max(0.0, radius), std::min(visibleWidth, visibleHeight) / 2.0);
+  const double canonicalWidth = std::max(0.0, width);
+  const double canonicalHeight = std::max(0.0, height);
+  const double right = x + canonicalWidth;
+  const double bottom = y + canonicalHeight;
+  if (!std::isfinite(right) || !std::isfinite(bottom)) return false;
+  out.left = x;
+  out.top = y;
+  out.right = right;
+  out.bottom = bottom;
+
+  double topLeft = std::max(0.0, resolvedTopLeft);
+  double topRight = std::max(0.0, resolvedTopRight);
+  double bottomRight = std::max(0.0, resolvedBottomRight);
+  double bottomLeft = std::max(0.0, resolvedBottomLeft);
+  double scale = 1.0;
+  const auto includeLimit = [&scale](double available, double requested) {
+    if (requested > 0) scale = std::min(scale, available / requested);
+  };
+  includeLimit(canonicalWidth, topLeft + topRight);
+  includeLimit(canonicalWidth, bottomLeft + bottomRight);
+  includeLimit(canonicalHeight, topLeft + bottomLeft);
+  includeLimit(canonicalHeight, topRight + bottomRight);
+  scale = std::clamp(scale, 0.0, 1.0);
+
+  out.topLeftRadius = topLeft * scale;
+  out.topRightRadius = topRight * scale;
+  out.bottomRightRadius = bottomRight * scale;
+  out.bottomLeftRadius = bottomLeft * scale;
+  const bool uniform = out.topLeftRadius == out.topRightRadius &&
+      out.topLeftRadius == out.bottomRightRadius &&
+      out.topLeftRadius == out.bottomLeftRadius;
+  out.radius = uniform ? out.topLeftRadius : 0.0;
+  out.curve = curve;
   return true;
 }
 
+inline bool SmoothClipCanonicalize(
+    const Geometry &geometry,
+    CanonicalClip &out) {
+  return SmoothClipCanonicalize(
+      geometry.x,
+      geometry.y,
+      geometry.width,
+      geometry.height,
+      geometry.radius,
+      geometry.topLeftRadius,
+      geometry.topRightRadius,
+      geometry.bottomRightRadius,
+      geometry.bottomLeftRadius,
+      geometry.curve,
+      out);
+}
+
+inline bool SmoothClipCanonicalize(
+    double x,
+    double y,
+    double width,
+    double height,
+    double radius,
+    CanonicalClip &out) {
+  return SmoothClipCanonicalize(
+      x,
+      y,
+      width,
+      height,
+      radius,
+      radius,
+      radius,
+      radius,
+      radius,
+      ClipCurve::Circular,
+      out);
+}
+
+inline Geometry SmoothClipGeometry(const CanonicalClip &clip) {
+  Geometry geometry{
+      clip.left,
+      clip.top,
+      std::max(0.0, clip.right - clip.left),
+      std::max(0.0, clip.bottom - clip.top),
+      clip.radius};
+  geometry.topLeftRadius = clip.topLeftRadius;
+  geometry.topRightRadius = clip.topRightRadius;
+  geometry.bottomRightRadius = clip.bottomRightRadius;
+  geometry.bottomLeftRadius = clip.bottomLeftRadius;
+  geometry.curve = clip.curve;
+  return geometry;
+}
+
 } // namespace smoothclip

package/cpp/SmoothClipVelocityTracker.h

@@ -6,17 +6,18 @@
 namespace smoothclip {
 
 // The two most recent interactive samples used by `initialVelocity: 'inherit'`.
-// Channels are the seven presentation scalars (x, y, width, height, radius,
-// contentTranslateX, contentTranslateY) but the tracker is value-agnostic:
-// iOS records normalized (host-clamped) geometry, Android raw DIP — the
-// projection only needs both samples and the target in the same space.
+// Channels are the eleven geometry/content presentation scalars. Scale is stored
+// so histories remain coherent but excluded from velocity projection; each of
+// the four radius channels contributes one quarter of the uniform-radius weight.
+// Both platforms record raw canonical geometry, including off-host coordinates.
+// The projection only needs both samples and the target in the same space.
 // Shared by ios/SmoothClipView.mm and android/.../SmoothClipRegistry.cpp; a
 // behavior change here changes both platforms.
 struct VelocitySampleHistory {
   bool hasPrevious = false;
   bool hasLatest = false;
-  std::array<double, 7> previous{};
-  std::array<double, 7> latest{};
+  std::array<double, 11> previous{};
+  std::array<double, 11> latest{};
   double previousTimeS = 0;
   double latestTimeS = 0;
 };
@@ -40,7 +41,7 @@ inline constexpr double kVelocityFullCreditS = 1.0 / 60.0;
 
 inline void recordVelocitySample(
     VelocitySampleHistory &history,
-    const std::array<double, 7> &channels,
+    const std::array<double, 11> &channels,
     double nowS) {
   if (history.hasLatest && channels == history.latest) {
     // Identical re-record (a `from` seed equal to the last interactive
@@ -68,7 +69,7 @@ inline void recordVelocitySample(
 }
 
 // Only explicit interactive writes route through this recorder. Native
-// freeze/join/resume/static-finalization paths deliberately do not, so an
+// Native freeze and endpoint-finalization paths deliberately do not, so an
 // animation cannot manufacture a later inherited velocity. During ordinary
 // interaction, the staleness decay below is the forgetting mechanism and it
 // forgets gradually rather than all at once.
@@ -97,7 +98,7 @@ inline double velocityStalenessCredit(double holdS) {
 // Android seeds each integrator channel with scalar·displacement.
 inline double inheritedVelocity(
     const VelocitySampleHistory &history,
-    const std::array<double, 7> &target,
+    const std::array<double, 11> &target,
     double nowS) {
   if (!history.hasPrevious || !history.hasLatest) return 0;
   const double elapsed = history.latestTimeS - history.previousTimeS;
@@ -107,11 +108,14 @@ inline double inheritedVelocity(
   }
   double numerator = 0;
   double denominator = 0;
-  for (int index = 0; index < 7; index += 1) {
+  for (int index = 0; index < 11; index += 1) {
+    const double weight = index >= 4 && index <= 7
+        ? 0.25
+        : (index == 10 ? 0.0 : 1.0);
     const double sampleDelta = history.latest[index] - history.previous[index];
     const double destinationDelta = target[index] - history.latest[index];
-    numerator += sampleDelta * destinationDelta;
-    denominator += destinationDelta * destinationDelta;
+    numerator += weight * sampleDelta * destinationDelta;
+    denominator += weight * destinationDelta * destinationDelta;
   }
   if (denominator <= 1e-12) return 0;
   const double result = numerator / elapsed / denominator * credit;

package/ios/SmoothClipGeometry.h

@@ -2,40 +2,207 @@
 
 #include <math.h>
 
+typedef struct {
+  CGFloat topLeft;
+  CGFloat topRight;
+  CGFloat bottomRight;
+  CGFloat bottomLeft;
+} SmoothClipCornerRadii;
+
+typedef NS_ENUM(NSInteger, SmoothClipCornerCurve) {
+  SmoothClipCornerCurveCircular = 0,
+  SmoothClipCornerCurveContinuous = 1,
+};
+
 typedef struct {
   CGRect rect;
+  // Uniform-radius fast-path value; zero when canonical radii are unequal.
   CGFloat radius;
-} SmoothNormalizedClipGeometry;
+  SmoothClipCornerRadii radii;
+  SmoothClipCornerCurve curve;
+} SmoothClipCanonicalGeometry;
 
-/** Mirrors the Android and JavaScript geometry contract without allocating. */
-NS_INLINE BOOL SmoothClipNormalizeGeometry(
+NS_INLINE BOOL SmoothClipCornerRadiiEqual(
+    SmoothClipCornerRadii first,
+    SmoothClipCornerRadii second) {
+  return first.topLeft == second.topLeft &&
+      first.topRight == second.topRight &&
+      first.bottomRight == second.bottomRight &&
+      first.bottomLeft == second.bottomLeft;
+}
+
+NS_INLINE BOOL SmoothClipCornerRadiiAreUniform(
+    SmoothClipCornerRadii radii) {
+  return radii.topLeft == radii.topRight &&
+      radii.topLeft == radii.bottomRight &&
+      radii.topLeft == radii.bottomLeft;
+}
+
+NS_INLINE CGFloat SmoothClipSafeOverlapFactor(
+    CGFloat extent,
+    CGFloat firstRadius,
+    CGFloat secondRadius) {
+  const CGFloat sum = firstRadius + secondRadius;
+  return sum > 0 ? extent / sum : 1;
+}
+
+/**
+ * Canonicalizes the rectangle and four radii without allocating.
+ *
+ * The proportional overlap rule matches CSS border radii and the shared
+ * Android/C++ contract: all corners use one scale factor, preserving their
+ * relative shape while no opposing pair exceeds its edge.
+ */
+NS_INLINE BOOL SmoothClipCanonicalizeGeometry(
     CGFloat x,
     CGFloat y,
     CGFloat width,
     CGFloat height,
-    CGFloat radius,
-    CGSize hostSize,
-    SmoothNormalizedClipGeometry *result) {
+    CGFloat topLeftRadius,
+    CGFloat topRightRadius,
+    CGFloat bottomRightRadius,
+    CGFloat bottomLeftRadius,
+    NSInteger curveCode,
+    SmoothClipCanonicalGeometry *result) {
   if (!isfinite(x) || !isfinite(y) || !isfinite(width) ||
-      !isfinite(height) || !isfinite(radius) ||
-      !isfinite(hostSize.width) || !isfinite(hostSize.height)) {
+      !isfinite(height) || !isfinite(topLeftRadius) ||
+      !isfinite(topRightRadius) || !isfinite(bottomRightRadius) ||
+      !isfinite(bottomLeftRadius) ||
+      (curveCode != SmoothClipCornerCurveCircular &&
+       curveCode != SmoothClipCornerCurveContinuous)) {
     return NO;
   }
 
-  const CGFloat hostWidth = MAX(0, hostSize.width);
-  const CGFloat hostHeight = MAX(0, hostSize.height);
   const CGFloat requestedWidth = MAX(0, width);
   const CGFloat requestedHeight = MAX(0, height);
-  const CGFloat requestedRight = x + requestedWidth;
-  const CGFloat requestedBottom = y + requestedHeight;
-  const CGFloat left = MIN(hostWidth, MAX(0, x));
-  const CGFloat top = MIN(hostHeight, MAX(0, y));
-  const CGFloat right = MIN(hostWidth, MAX(0, requestedRight));
-  const CGFloat bottom = MIN(hostHeight, MAX(0, requestedBottom));
-  const CGFloat visibleWidth = MAX(0, right - left);
-  const CGFloat visibleHeight = MAX(0, bottom - top);
-
-  result->rect = CGRectMake(left, top, visibleWidth, visibleHeight);
-  result->radius = MIN(MAX(0, radius), MIN(visibleWidth, visibleHeight) / 2.0);
+  if (!isfinite(x + requestedWidth) || !isfinite(y + requestedHeight)) {
+    return NO;
+  }
+
+  SmoothClipCornerRadii radii = {
+      MAX(0, topLeftRadius),
+      MAX(0, topRightRadius),
+      MAX(0, bottomRightRadius),
+      MAX(0, bottomLeftRadius),
+  };
+  const CGFloat overlapScale = MIN(
+      1,
+      MIN(
+          MIN(
+              SmoothClipSafeOverlapFactor(
+                  requestedWidth, radii.topLeft, radii.topRight),
+              SmoothClipSafeOverlapFactor(
+                  requestedWidth, radii.bottomLeft, radii.bottomRight)),
+          MIN(
+              SmoothClipSafeOverlapFactor(
+                  requestedHeight, radii.topLeft, radii.bottomLeft),
+              SmoothClipSafeOverlapFactor(
+                  requestedHeight, radii.topRight, radii.bottomRight))));
+  radii.topLeft *= overlapScale;
+  radii.topRight *= overlapScale;
+  radii.bottomRight *= overlapScale;
+  radii.bottomLeft *= overlapScale;
+
+  result->rect = CGRectMake(x, y, requestedWidth, requestedHeight);
+  result->radii = radii;
+  result->radius = SmoothClipCornerRadiiAreUniform(radii)
+      ? radii.topLeft
+      : 0;
+  result->curve = (SmoothClipCornerCurve)curveCode;
   return YES;
 }
+
+/** Mirrors the Android and JavaScript geometry contract without allocating. */
+NS_INLINE BOOL SmoothClipCanonicalizeGeometry(
+    CGFloat x,
+    CGFloat y,
+    CGFloat width,
+    CGFloat height,
+    CGFloat radius,
+    SmoothClipCanonicalGeometry *result) {
+  return SmoothClipCanonicalizeGeometry(
+      x,
+      y,
+      width,
+      height,
+      radius,
+      radius,
+      radius,
+      radius,
+      SmoothClipCornerCurveCircular,
+      result);
+}
+
+/**
+ * Creates an empty path for an empty clip. Non-empty rounded rectangles use a
+ * stable nine-segment topology. Every corner is one cubic, including a
+ * zero-radius corner, so Core Animation can interpolate non-empty paths
+ * without a topology change.
+ */
+NS_INLINE CGPathRef SmoothClipCreateRoundedRectPath(
+    CGRect rect,
+    SmoothClipCornerRadii radii,
+    SmoothClipCornerCurve curve) CF_RETURNS_RETAINED {
+  CGMutablePathRef path = CGPathCreateMutable();
+  if (CGRectIsEmpty(rect)) return path;
+  const CGFloat minX = CGRectGetMinX(rect);
+  const CGFloat minY = CGRectGetMinY(rect);
+  const CGFloat maxX = CGRectGetMaxX(rect);
+  const CGFloat maxY = CGRectGetMaxY(rect);
+  // Circular is the exact cubic-circle coefficient. The portable continuous
+  // fallback uses kappa=1 so each cubic joins its straight edges with zero
+  // curvature, matching the portable Android path. Hit testing derives
+  // from this rendered path rather than maintaining a second curve model.
+  // Uniform
+  // continuous shapes use CALayer.cornerCurve for Apple's platform-native
+  // compositor shape and are intentionally not pixel-identical cross-platform.
+  const CGFloat controlFactor =
+      curve == SmoothClipCornerCurveContinuous
+      ? 1.0
+      : 0.5522847498307936;
+
+  CGPathMoveToPoint(path, NULL, minX + radii.topLeft, minY);
+  CGPathAddLineToPoint(path, NULL, maxX - radii.topRight, minY);
+  CGPathAddCurveToPoint(
+      path,
+      NULL,
+      maxX - radii.topRight + radii.topRight * controlFactor,
+      minY,
+      maxX,
+      minY + radii.topRight - radii.topRight * controlFactor,
+      maxX,
+      minY + radii.topRight);
+  CGPathAddLineToPoint(path, NULL, maxX, maxY - radii.bottomRight);
+  CGPathAddCurveToPoint(
+      path,
+      NULL,
+      maxX,
+      maxY - radii.bottomRight + radii.bottomRight * controlFactor,
+      maxX - radii.bottomRight +
+          radii.bottomRight * controlFactor,
+      maxY,
+      maxX - radii.bottomRight,
+      maxY);
+  CGPathAddLineToPoint(path, NULL, minX + radii.bottomLeft, maxY);
+  CGPathAddCurveToPoint(
+      path,
+      NULL,
+      minX + radii.bottomLeft - radii.bottomLeft * controlFactor,
+      maxY,
+      minX,
+      maxY - radii.bottomLeft + radii.bottomLeft * controlFactor,
+      minX,
+      maxY - radii.bottomLeft);
+  CGPathAddLineToPoint(path, NULL, minX, minY + radii.topLeft);
+  CGPathAddCurveToPoint(
+      path,
+      NULL,
+      minX,
+      minY + radii.topLeft - radii.topLeft * controlFactor,
+      minX + radii.topLeft - radii.topLeft * controlFactor,
+      minY,
+      minX + radii.topLeft,
+      minY);
+  CGPathCloseSubpath(path);
+  return path;
+}