react-native-windows 0.79.4 → 0.80.0-preview.2

package/Libraries/WebSocket/WebSocket.js

@@ -8,13 +8,318 @@
  * @flow
  */
 
-import typeof WebSocket from './WebSocket_old';
+import type {EventCallback} from '../../src/private/webapis/dom/events/EventTarget';
+import type {BlobData} from '../Blob/BlobTypes';
+import type {EventSubscription} from '../vendor/emitter/EventEmitter';
 
-// Use a global instead of a flag from ReactNativeFeatureFlags because this will
-// be read before apps have a chance to set overrides.
-const useBuiltInEventTarget = global.RN$useBuiltInEventTarget?.();
+import Event from '../../src/private/webapis/dom/events/Event';
+import {
+  getEventHandlerAttribute,
+  setEventHandlerAttribute,
+} from '../../src/private/webapis/dom/events/EventHandlerAttributes';
+import EventTarget from '../../src/private/webapis/dom/events/EventTarget';
+import MessageEvent from '../../src/private/webapis/html/events/MessageEvent';
+import CloseEvent from '../../src/private/webapis/websockets/events/CloseEvent';
+import Blob from '../Blob/Blob';
+import BlobManager from '../Blob/BlobManager';
+import NativeEventEmitter from '../EventEmitter/NativeEventEmitter';
+import binaryToBase64 from '../Utilities/binaryToBase64';
+import Platform from '../Utilities/Platform';
+import NativeWebSocketModule from './NativeWebSocketModule';
+import base64 from 'base64-js';
+import invariant from 'invariant';
 
-export default (useBuiltInEventTarget
-  ? // $FlowExpectedError[incompatible-cast]
-    require('./WebSocket_new').default
-  : require('./WebSocket_old').default) as WebSocket;
+type ArrayBufferView =
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float32Array
+  | Float64Array
+  | DataView;
+
+type BinaryType = 'blob' | 'arraybuffer';
+
+const CONNECTING = 0;
+const OPEN = 1;
+const CLOSING = 2;
+const CLOSED = 3;
+
+const CLOSE_NORMAL = 1000;
+
+// Abnormal closure where no code is provided in a control frame
+// https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.5
+const CLOSE_ABNORMAL = 1006;
+
+let nextWebSocketId = 0;
+
+type WebSocketEventDefinitions = {
+  websocketOpen: [{id: number, protocol: string}],
+  websocketClosed: [{id: number, code: number, reason: string}],
+  websocketMessage: [
+    | {type: 'binary', id: number, data: string}
+    | {type: 'text', id: number, data: string}
+    | {type: 'blob', id: number, data: BlobData},
+  ],
+  websocketFailed: [{id: number, message: string}],
+};
+
+/**
+ * Browser-compatible WebSockets implementation.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+ * See https://github.com/websockets/ws
+ */
+class WebSocket extends EventTarget {
+  static CONNECTING: number = CONNECTING;
+  static OPEN: number = OPEN;
+  static CLOSING: number = CLOSING;
+  static CLOSED: number = CLOSED;
+
+  CONNECTING: number = CONNECTING;
+  OPEN: number = OPEN;
+  CLOSING: number = CLOSING;
+  CLOSED: number = CLOSED;
+
+  _socketId: number;
+  _eventEmitter: NativeEventEmitter<WebSocketEventDefinitions>;
+  _subscriptions: Array<EventSubscription>;
+  _binaryType: ?BinaryType;
+
+  bufferedAmount: number;
+  extension: ?string;
+  protocol: ?string;
+  readyState: number = CONNECTING;
+  url: ?string;
+
+  constructor(
+    url: string,
+    protocols: ?string | ?Array<string>,
+    options: ?{headers?: {origin?: string, ...}, ...},
+  ) {
+    super();
+    this.url = url;
+    if (typeof protocols === 'string') {
+      protocols = [protocols];
+    }
+
+    const {headers = {}, ...unrecognized} = options || {};
+
+    // Preserve deprecated backwards compatibility for the 'origin' option
+    // $FlowFixMe[prop-missing]
+    if (unrecognized && typeof unrecognized.origin === 'string') {
+      console.warn(
+        'Specifying `origin` as a WebSocket connection option is deprecated. Include it under `headers` instead.',
+      );
+      /* $FlowFixMe[prop-missing] (>=0.54.0 site=react_native_fb,react_native_
+       * oss) This comment suppresses an error found when Flow v0.54 was
+       * deployed. To see the error delete this comment and run Flow. */
+      headers.origin = unrecognized.origin;
+      /* $FlowFixMe[prop-missing] (>=0.54.0 site=react_native_fb,react_native_
+       * oss) This comment suppresses an error found when Flow v0.54 was
+       * deployed. To see the error delete this comment and run Flow. */
+      delete unrecognized.origin;
+    }
+
+    // Warn about and discard anything else
+    if (Object.keys(unrecognized).length > 0) {
+      console.warn(
+        'Unrecognized WebSocket connection option(s) `' +
+          Object.keys(unrecognized).join('`, `') +
+          '`. ' +
+          'Did you mean to put these under `headers`?',
+      );
+    }
+
+    if (!Array.isArray(protocols)) {
+      protocols = null;
+    }
+
+    this._eventEmitter = new NativeEventEmitter(
+      // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
+      // If you want to use the native module on other platforms, please remove this condition and test its behavior
+      Platform.OS !== 'ios' ? null : NativeWebSocketModule,
+    );
+    this._socketId = nextWebSocketId++;
+    this._registerEvents();
+    NativeWebSocketModule.connect(url, protocols, {headers}, this._socketId);
+  }
+
+  get binaryType(): ?BinaryType {
+    return this._binaryType;
+  }
+
+  set binaryType(binaryType: BinaryType): void {
+    if (binaryType !== 'blob' && binaryType !== 'arraybuffer') {
+      throw new Error("binaryType must be either 'blob' or 'arraybuffer'");
+    }
+    if (this._binaryType === 'blob' || binaryType === 'blob') {
+      invariant(
+        BlobManager.isAvailable,
+        'Native module BlobModule is required for blob support',
+      );
+      if (binaryType === 'blob') {
+        BlobManager.addWebSocketHandler(this._socketId);
+      } else {
+        BlobManager.removeWebSocketHandler(this._socketId);
+      }
+    }
+    this._binaryType = binaryType;
+  }
+
+  close(code?: number, reason?: string): void {
+    if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {
+      return;
+    }
+
+    this.readyState = this.CLOSING;
+    this._close(code, reason);
+  }
+
+  send(data: string | ArrayBuffer | ArrayBufferView | Blob): void {
+    if (this.readyState === this.CONNECTING) {
+      throw new Error('INVALID_STATE_ERR');
+    }
+
+    if (data instanceof Blob) {
+      invariant(
+        BlobManager.isAvailable,
+        'Native module BlobModule is required for blob support',
+      );
+      BlobManager.sendOverSocket(data, this._socketId);
+      return;
+    }
+
+    if (typeof data === 'string') {
+      NativeWebSocketModule.send(data, this._socketId);
+      return;
+    }
+
+    if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+      NativeWebSocketModule.sendBinary(binaryToBase64(data), this._socketId);
+      return;
+    }
+
+    throw new Error('Unsupported data type');
+  }
+
+  ping(): void {
+    if (this.readyState === this.CONNECTING) {
+      throw new Error('INVALID_STATE_ERR');
+    }
+
+    NativeWebSocketModule.ping(this._socketId);
+  }
+
+  _close(code?: number, reason?: string): void {
+    // See https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
+    const statusCode = typeof code === 'number' ? code : CLOSE_NORMAL;
+    const closeReason = typeof reason === 'string' ? reason : '';
+    NativeWebSocketModule.close(statusCode, closeReason, this._socketId);
+
+    if (BlobManager.isAvailable && this._binaryType === 'blob') {
+      BlobManager.removeWebSocketHandler(this._socketId);
+    }
+  }
+
+  _unregisterEvents(): void {
+    this._subscriptions.forEach(e => e.remove());
+    this._subscriptions = [];
+  }
+
+  _registerEvents(): void {
+    this._subscriptions = [
+      this._eventEmitter.addListener('websocketMessage', ev => {
+        if (ev.id !== this._socketId) {
+          return;
+        }
+        let data: Blob | BlobData | ArrayBuffer | string = ev.data;
+        switch (ev.type) {
+          case 'binary':
+            data = base64.toByteArray(ev.data).buffer;
+            break;
+          case 'blob':
+            data = BlobManager.createFromOptions(ev.data);
+            break;
+        }
+        this.dispatchEvent(new MessageEvent('message', {data}));
+      }),
+      this._eventEmitter.addListener('websocketOpen', ev => {
+        if (ev.id !== this._socketId) {
+          return;
+        }
+        this.readyState = this.OPEN;
+        this.protocol = ev.protocol;
+        this.dispatchEvent(new Event('open'));
+      }),
+      this._eventEmitter.addListener('websocketClosed', ev => {
+        if (ev.id !== this._socketId) {
+          return;
+        }
+        this.readyState = this.CLOSED;
+        this.dispatchEvent(
+          new CloseEvent('close', {
+            code: ev.code,
+            reason: ev.reason,
+            // TODO: missing `wasClean` (exposed on iOS as `clean` but missing on Android)
+          }),
+        );
+        this._unregisterEvents();
+        this.close();
+      }),
+      this._eventEmitter.addListener('websocketFailed', ev => {
+        if (ev.id !== this._socketId) {
+          return;
+        }
+        this.readyState = this.CLOSED;
+        this.dispatchEvent(new Event('error'));
+        this.dispatchEvent(
+          new CloseEvent('close', {
+            code: CLOSE_ABNORMAL,
+            reason: ev.message,
+            // TODO: Expose `wasClean`
+          }),
+        );
+        this._unregisterEvents();
+        this.close();
+      }),
+    ];
+  }
+
+  get onclose(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'close');
+  }
+
+  set onclose(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'close', listener);
+  }
+
+  get onerror(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'error');
+  }
+
+  set onerror(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'error', listener);
+  }
+
+  get onmessage(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'message');
+  }
+
+  set onmessage(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'message', listener);
+  }
+
+  get onopen(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'open');
+  }
+
+  set onopen(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'open', listener);
+  }
+}
+
+export default WebSocket;

package/Libraries/vendor/core/ErrorUtils.js

@@ -8,7 +8,33 @@
  * @flow strict
  */
 
-import type {ErrorUtilsT} from '@react-native/js-polyfills/error-guard';
+// From @react-native/js-polyfills
+type ErrorHandler = (error: mixed, isFatal: boolean) => void;
+type Fn<Args: $ReadOnlyArray<mixed>, Return> = (...Args) => Return;
+export type ErrorUtils = {
+  applyWithGuard<TArgs: $ReadOnlyArray<mixed>, TOut>(
+    fun: Fn<TArgs, TOut>,
+    context?: mixed,
+    args?: ?TArgs,
+    unused_onError?: null,
+    unused_name?: ?string,
+  ): ?TOut,
+  applyWithGuardIfNeeded<TArgs: $ReadOnlyArray<mixed>, TOut>(
+    fun: Fn<TArgs, TOut>,
+    context?: mixed,
+    args?: ?TArgs,
+  ): ?TOut,
+  getGlobalHandler(): ErrorHandler,
+  guard<TArgs: $ReadOnlyArray<mixed>, TOut>(
+    fun: Fn<TArgs, TOut>,
+    name?: ?string,
+    context?: mixed,
+  ): ?(...TArgs) => ?TOut,
+  inGuard(): boolean,
+  reportError(error: mixed): void,
+  reportFatalError(error: mixed): void,
+  setGlobalHandler(fun: ErrorHandler): void,
+};
 
 /**
  * The particular require runtime that we are using looks for a global
@@ -22,4 +48,4 @@ import type {ErrorUtilsT} from '@react-native/js-polyfills/error-guard';
  * that use it aren't just using a global variable, so simply export the global
  * variable here. ErrorUtils is originally defined in a file named error-guard.js.
  */
-export default (global.ErrorUtils: ErrorUtilsT);
+export default global.ErrorUtils as ErrorUtils;

package/Libraries/vendor/emitter/EventEmitter.js

@@ -72,8 +72,12 @@ export default class EventEmitter<
   > = $ReadOnly<Record<string, $ReadOnlyArray<UnsafeObject>>>,
 > implements IEventEmitter<TEventToArgsMap>
 {
-  // $FlowFixMe[incompatible-type]
-  #registry: Registry<TEventToArgsMap> = {};
+  #registry: Registry<TEventToArgsMap>;
+
+  constructor() {
+    // $FlowFixMe[incompatible-type]
+    this.#registry = {};
+  }
 
   /**
    * Registers a listener that is called when the supplied event is emitted.

package/Microsoft.ReactNative/CompositionSwitcher.idl

@@ -31,6 +31,13 @@ namespace Microsoft.ReactNative.Composition.Experimental
     SwitchThumb,
   };
 
+  enum SnapAlignment
+  {
+    Start,
+    Center,
+    End,
+  };
+
   [webhosthidden]
   [uuid("172def51-9e1a-4e3c-841a-e5a470065acc")] // uuid needed for empty interfaces
   [version(0)]
@@ -120,6 +127,7 @@ namespace Microsoft.ReactNative.Composition.Experimental
     void SetMaximumZoomScale(Single maximumZoomScale);
     void SetMinimumZoomScale(Single minimumZoomScale);
     Boolean Horizontal;
+    void SetSnapPoints(Boolean snapToStart, Boolean snapToEnd, Windows.Foundation.Collections.IVectorView<Single> offsets, SnapAlignment snapToAlignment);
   }
 
   [webhosthidden]

package/Microsoft.ReactNative/Fabric/AbiComponentDescriptor.cpp

@@ -89,12 +89,6 @@ facebook::react::Props::Shared AbiComponentDescriptor::cloneProps(
     return ShadowNodeT::defaultSharedProps();
   }
 
-  if constexpr (std::is_base_of_v<facebook::react::YogaLayoutableShadowNode, ShadowNodeT>) {
-    if (facebook::react::ReactNativeFeatureFlags::excludeYogaFromRawProps()) {
-      rawProps.filterYogaStylePropsInDynamicConversion();
-    }
-  }
-
   rawProps.parse(rawPropsParser_);
 
   // Call old-style constructor

package/Microsoft.ReactNative/Fabric/Composition/CompositionContextHelper.cpp

@@ -1,6 +1,7 @@
 
 #include "pch.h"
 #include "CompositionContextHelper.h"
+#include <algorithm>
 #if __has_include("Composition.Experimental.SystemCompositionContextHelper.g.cpp")
 #include "Composition.Experimental.SystemCompositionContextHelper.g.cpp"
 #endif
@@ -26,6 +27,8 @@
 
 namespace Microsoft::ReactNative::Composition::Experimental {
 
+using namespace winrt::Microsoft::ReactNative::Composition::Experimental;
+
 template <typename TSpriteVisual>
 struct CompositionTypeTraits {};
 
@@ -74,6 +77,10 @@ struct CompositionTypeTraits<WindowsTypeTag> {
       winrt::Windows::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs;
   using InteractionTrackerValuesChangedArgs =
       winrt::Windows::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs;
+  using InteractionTrackerInertiaRestingValue =
+      winrt::Windows::UI::Composition::Interactions::InteractionTrackerInertiaRestingValue;
+  using InteractionTrackerInertiaModifier =
+      winrt::Windows::UI::Composition::Interactions::InteractionTrackerInertiaModifier;
   using ScalarKeyFrameAnimation = winrt::Windows::UI::Composition::ScalarKeyFrameAnimation;
   using ShapeVisual = winrt::Windows::UI::Composition::ShapeVisual;
   using SpriteVisual = winrt::Windows::UI::Composition::SpriteVisual;
@@ -143,6 +150,10 @@ struct CompositionTypeTraits<MicrosoftTypeTag> {
       winrt::Microsoft::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs;
   using InteractionTrackerValuesChangedArgs =
       winrt::Microsoft::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs;
+  using InteractionTrackerInertiaRestingValue =
+      winrt::Microsoft::UI::Composition::Interactions::InteractionTrackerInertiaRestingValue;
+  using InteractionTrackerInertiaModifier =
+      winrt::Microsoft::UI::Composition::Interactions::InteractionTrackerInertiaModifier;
   using ScalarKeyFrameAnimation = winrt::Microsoft::UI::Composition::ScalarKeyFrameAnimation;
   using ShapeVisual = winrt::Microsoft::UI::Composition::ShapeVisual;
   using SpriteVisual = winrt::Microsoft::UI::Composition::SpriteVisual;
@@ -782,9 +793,13 @@ struct CompScrollerVisual : winrt::implements<
   }
 
   void Horizontal(bool value) noexcept {
+    bool previousHorizontal = m_horizontal;
     m_horizontal = value;
 
-    UpdateInteractionModes();
+    if (previousHorizontal != m_horizontal) {
+      UpdateInteractionModes();
+      ConfigureSnapInertiaModifiers(); // Reconfigure modifiers when direction changes
+    }
   }
 
   void UpdateInteractionModes() noexcept {
@@ -855,6 +870,23 @@ struct CompScrollerVisual : winrt::implements<
     m_interactionTracker.MinScale(minimumZoomScale);
   }
 
+  void SetSnapPoints(
+      bool snapToStart,
+      bool snapToEnd,
+      winrt::Windows::Foundation::Collections::IVectorView<float> const &offsets,
+      SnapAlignment snapToAlignment) noexcept {
+    m_snapToStart = snapToStart;
+    m_snapToEnd = snapToEnd;
+    m_snapToAlignment = snapToAlignment;
+    m_snapToOffsets.clear();
+    if (offsets) {
+      for (auto const &offset : offsets) {
+        m_snapToOffsets.push_back(offset);
+      }
+    }
+    ConfigureSnapInertiaModifiers();
+  }
+
   void Opacity(float opacity) noexcept {
     m_visual.Opacity(opacity);
   }
@@ -1050,8 +1082,172 @@ struct CompScrollerVisual : winrt::implements<
          0});
   }
 
+  void ConfigureSnapInertiaModifiers() noexcept {
+    if (!m_visual || !m_contentVisual || !m_interactionTracker) {
+      return;
+    }
+
+    auto visualSize = m_visual.Size();
+    auto contentSize = m_contentVisual.Size();
+    if (visualSize.x <= 0 || visualSize.y <= 0 || contentSize.x <= 0 || contentSize.y <= 0) {
+      OutputDebugStringW(L"Invalid visual/content size\n");
+      return;
+    }
+
+    auto compositor = m_interactionTracker.Compositor();
+
+    // Collect and deduplicate all snap positions
+    std::vector<float> snapPositions;
+
+    if (m_snapToStart) {
+      snapPositions.push_back(0.0f);
+    }
+
+    snapPositions.insert(snapPositions.end(), m_snapToOffsets.begin(), m_snapToOffsets.end());
+
+    // Adjust snap positions based on alignment
+    const float viewportSize = m_horizontal ? visualSize.x : visualSize.y;
+    if (m_snapToAlignment == SnapAlignment::Center) {
+      // For center alignment, offset snap positions by half the viewport size
+      for (auto &position : snapPositions) {
+        position = std::max(0.0f, position - viewportSize / 2.0f);
+      }
+    } else if (m_snapToAlignment == SnapAlignment::End) {
+      // For end alignment, offset snap positions by the full viewport size
+      for (auto &position : snapPositions) {
+        position = std::max(0.0f, position - viewportSize);
+      }
+    }
+    // For Start alignment, no adjustment needed
+
+    std::sort(snapPositions.begin(), snapPositions.end());
+    snapPositions.erase(std::unique(snapPositions.begin(), snapPositions.end()), snapPositions.end());
+
+    std::vector<typename TTypeRedirects::InteractionTrackerInertiaRestingValue> restingValues;
+
+    for (size_t i = 0; i < snapPositions.size(); ++i) {
+      const auto position = snapPositions[i];
+      auto restingValue = TTypeRedirects::InteractionTrackerInertiaRestingValue::Create(compositor);
+
+      winrt::hstring axisComponent = m_horizontal ? L"X" : L"Y";
+      winrt::hstring conditionExpr;
+
+      // Build condition expression based on whether there's one or multiple snap points
+      if (snapPositions.size() == 1) {
+        conditionExpr = L"abs(this.Target.NaturalRestingPosition." + axisComponent + L" - snap) < 50";
+      } else {
+        if (i == 0) {
+          conditionExpr = L"this.Target.NaturalRestingPosition." + axisComponent + L" < midpoint";
+        } else if (i == snapPositions.size() - 1) {
+          conditionExpr = L"this.Target.NaturalRestingPosition." + axisComponent + L" >= midpoint";
+        } else {
+          conditionExpr = L"this.Target.NaturalRestingPosition." + axisComponent +
+              L" >= prevMidpoint && this.Target.NaturalRestingPosition." + axisComponent + L" < nextMidpoint";
+        }
+      }
+
+      auto conditionAnim = compositor.CreateExpressionAnimation();
+      conditionAnim.Expression(conditionExpr);
+
+      if (snapPositions.size() == 1) {
+        conditionAnim.SetScalarParameter(L"snap", position);
+      } else {
+        // Multiple snap points - use range-based conditions
+        if (i == 0) {
+          const auto nextPosition = snapPositions[i + 1];
+          const auto midpoint = (position + nextPosition) / 2.0f;
+          conditionAnim.SetScalarParameter(L"midpoint", midpoint);
+        } else if (i == snapPositions.size() - 1) {
+          const auto prevPosition = snapPositions[i - 1];
+          const auto midpoint = (prevPosition + position) / 2.0f;
+          conditionAnim.SetScalarParameter(L"midpoint", midpoint);
+        } else {
+          const auto prevPosition = snapPositions[i - 1];
+          const auto nextPosition = snapPositions[i + 1];
+          const auto prevMidpoint = (prevPosition + position) / 2.0f;
+          const auto nextMidpoint = (position + nextPosition) / 2.0f;
+          conditionAnim.SetScalarParameter(L"prevMidpoint", prevMidpoint);
+          conditionAnim.SetScalarParameter(L"nextMidpoint", nextMidpoint);
+        }
+      }
+
+      restingValue.Condition(conditionAnim);
+
+      // Resting value simply snaps to this position
+      auto restingAnim = compositor.CreateExpressionAnimation();
+      restingAnim.Expression(L"snap");
+      restingAnim.SetScalarParameter(L"snap", position);
+      restingValue.RestingValue(restingAnim);
+
+      restingValues.push_back(restingValue);
+    }
+
+    if (m_snapToEnd) {
+      auto endRestingValue = TTypeRedirects::InteractionTrackerInertiaRestingValue::Create(compositor);
+
+      // Create property sets to dynamically compute content - visual size
+      auto contentSizePropertySet = compositor.CreatePropertySet();
+      contentSizePropertySet.InsertVector2(L"Size", m_contentVisual.Size());
+
+      auto visualSizePropertySet = compositor.CreatePropertySet();
+      visualSizePropertySet.InsertVector2(L"Size", m_visual.Size());
+
+      winrt::hstring endPositionExpr = m_horizontal ? L"max(contentSize.Size.x - visualSize.Size.x, 0)"
+                                                    : L"max(contentSize.Size.y - visualSize.Size.y, 0)";
+
+      float prevPosition = snapPositions.empty() ? 0.0f : snapPositions.back();
+
+      winrt::hstring endConditionExpr = m_horizontal
+          ? L"this.Target.NaturalRestingPosition.X >= ((max(contentSize.Size.x - visualSize.Size.x, 0) + prevSnap) / 2.0)"
+          : L"this.Target.NaturalRestingPosition.Y >= ((max(contentSize.Size.y - visualSize.Size.y, 0) + prevSnap) / 2.0)";
+
+      auto endCondition = compositor.CreateExpressionAnimation();
+      endCondition.Expression(endConditionExpr);
+      endCondition.SetReferenceParameter(L"contentSize", contentSizePropertySet);
+      endCondition.SetReferenceParameter(L"visualSize", visualSizePropertySet);
+      endCondition.SetScalarParameter(L"prevSnap", prevPosition);
+
+      auto endResting = compositor.CreateExpressionAnimation();
+      endResting.Expression(endPositionExpr);
+      endResting.SetReferenceParameter(L"contentSize", contentSizePropertySet);
+      endResting.SetReferenceParameter(L"visualSize", visualSizePropertySet);
+
+      endRestingValue.Condition(endCondition);
+      endRestingValue.RestingValue(endResting);
+
+      restingValues.push_back(endRestingValue);
+    }
+
+    if (!restingValues.empty()) {
+      auto modifiers = winrt::single_threaded_vector<typename TTypeRedirects::InteractionTrackerInertiaModifier>();
+      for (auto &v : restingValues) {
+        auto modifier = v.as<typename TTypeRedirects::InteractionTrackerInertiaModifier>();
+        if (modifier) {
+          modifiers.Append(modifier);
+        }
+      }
+
+      if (m_horizontal) {
+        m_interactionTracker.ConfigurePositionXInertiaModifiers(modifiers);
+      } else {
+        m_interactionTracker.ConfigurePositionYInertiaModifiers(modifiers);
+      }
+    } else {
+      // Clear inertia modifiers when no snapping is configured
+      if (m_horizontal) {
+        m_interactionTracker.ConfigurePositionXInertiaModifiers({});
+      } else {
+        m_interactionTracker.ConfigurePositionYInertiaModifiers({});
+      }
+    }
+  }
+
   bool m_isScrollEnabled{true};
   bool m_horizontal{false};
+  bool m_snapToStart{true};
+  bool m_snapToEnd{true};
+  std::vector<float> m_snapToOffsets;
+  SnapAlignment m_snapToAlignment{SnapAlignment::Start};
   bool m_inertia{false};
   bool m_custom{false};
   winrt::Windows::Foundation::Numerics::float3 m_targetPosition;