react-native-windows 0.81.1 → 0.82.0-preview.1

package/Microsoft.ReactNative/Views/Image/ReactImageBrush.cpp

@@ -1,247 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#include "pch.h"
-
-#include <UI.Composition.Effects.h>
-#include "Effects.h"
-#include "ReactImageBrush.h"
-#include "XamlView.h"
-
-#include <winrt/Windows.Graphics.Display.h>
-#include <winrt/Windows.Graphics.Effects.h>
-#include <sstream>
-
-namespace winrt {
-using namespace winrt::Windows::Storage::Streams;
-using namespace comp;
-using namespace xaml;
-using namespace xaml::Media;
-using namespace comp::Effects;
-} // namespace winrt
-
-namespace Microsoft::ReactNative {
-/*static*/ winrt::com_ptr<ReactImageBrush> ReactImageBrush::Create() {
-  return winrt::make_self<ReactImageBrush>();
-}
-
-void ReactImageBrush::OnConnected() {
-  UpdateCompositionBrush();
-}
-
-void ReactImageBrush::OnDisconnected() {
-  // Dispose of composition resources when no longer in use.
-  if (CompositionBrush()) {
-    CompositionBrush(nullptr);
-  }
-}
-
-void ReactImageBrush::ResizeMode(facebook::react::ImageResizeMode value) {
-  if (m_resizeMode != value) {
-    const bool forceEffectBrush{
-        value == facebook::react::ImageResizeMode::Repeat || m_resizeMode == facebook::react::ImageResizeMode::Repeat};
-    m_resizeMode = value;
-    UpdateCompositionBrush(forceEffectBrush);
-  }
-}
-
-void ReactImageBrush::BlurRadius(float value) {
-  if (m_blurRadius != value) {
-    const bool forceEffectBrush{value == 0 || m_blurRadius == 0};
-    m_blurRadius = value;
-    UpdateCompositionBrush(forceEffectBrush);
-  }
-}
-
-void ReactImageBrush::TintColor(winrt::Color value) {
-  bool sameColor{
-      value.A == m_tintColor.A && value.R == m_tintColor.R && value.G == m_tintColor.G && value.B == m_tintColor.B};
-
-  if (!sameColor) {
-    const bool forceEffectBrush{value.A == 0 || m_tintColor.A == 0};
-    m_tintColor = value;
-    UpdateCompositionBrush(forceEffectBrush);
-  }
-}
-
-void ReactImageBrush::AvailableSize(winrt::Size const &value) {
-  if (m_availableSize != value) {
-    m_availableSize = value;
-    UpdateCompositionBrush();
-  }
-}
-
-void ReactImageBrush::Source(winrt::LoadedImageSurface const &value) {
-  if (m_loadedImageSurface != value) {
-    bool updateSurface{m_loadedImageSurface};
-
-    m_loadedImageSurface = value;
-
-    if (updateSurface) {
-      comp::CompositionSurfaceBrush surfaceBrush{GetOrCreateSurfaceBrush()};
-      surfaceBrush.Surface(m_loadedImageSurface);
-    }
-
-    UpdateCompositionBrush();
-  }
-}
-
-void ReactImageBrush::UpdateCompositionBrush(bool forceEffectBrush) {
-  if (m_loadedImageSurface) {
-    comp::CompositionSurfaceBrush surfaceBrush{GetOrCreateSurfaceBrush()};
-    surfaceBrush.Stretch(ResizeModeToStretch());
-
-    auto compositionBrush{surfaceBrush.as<comp::CompositionBrush>()};
-    if (ResizeMode() == facebook::react::ImageResizeMode::Repeat || BlurRadius() > 0 || m_tintColor.A != 0) {
-      // The effects used for ResizeMode::Repeat and tintColor are conditional, so if we
-      // are switching to/from those modes, then we need to create a new CompositionBrush.
-      // The CompositionSurfaceBrush holding the image is used as its source.
-      compositionBrush = GetOrCreateEffectBrush(surfaceBrush, forceEffectBrush);
-
-      // https://microsoft.github.io/Win2D/html/P_Microsoft_Graphics_Canvas_Effects_GaussianBlurEffect_BlurAmount.htm
-      // "You can compute the blur radius of the kernel by multiplying the standard deviation by 3.
-      // The units of both the standard deviation and blur radius are DIPs.
-      // A value of zero DIPs disables this effect entirely."
-      if (m_blurRadius > 0) {
-        compositionBrush.Properties().InsertScalar(BlurBlurAmount, m_blurRadius / 3);
-      }
-
-      if (m_tintColor.A != 0) {
-        compositionBrush.Properties().InsertColor(TintColorColor, m_tintColor);
-      }
-    }
-
-    // The CompositionBrush is only set after the image is first loaded and anytime
-    // we switch between Surface and Effect brushes (to/from ResizeMode::Repeat)
-    if (CompositionBrush() != compositionBrush) {
-      if (ResizeMode() == facebook::react::ImageResizeMode::Repeat) {
-        surfaceBrush.HorizontalAlignmentRatio(0.0f);
-        surfaceBrush.VerticalAlignmentRatio(0.0f);
-      } else {
-        surfaceBrush.HorizontalAlignmentRatio(0.5f);
-        surfaceBrush.VerticalAlignmentRatio(0.5f);
-      }
-
-      CompositionBrush(compositionBrush);
-    }
-  }
-}
-
-bool ReactImageBrush::IsImageSmallerThanView() {
-  if (m_loadedImageSurface) {
-    auto surface{GetOrCreateSurfaceBrush().Surface().as<winrt::LoadedImageSurface>()};
-    winrt::Size dipsSize{surface.DecodedSize()};
-
-    return (dipsSize.Height < AvailableSize().Height) && (dipsSize.Width < AvailableSize().Width);
-  }
-
-  return false;
-}
-
-comp::CompositionStretch ReactImageBrush::ResizeModeToStretch() {
-  auto stretch{comp::CompositionStretch::None};
-
-  switch (ResizeMode()) {
-    case facebook::react::ImageResizeMode::Contain:
-      stretch = comp::CompositionStretch::Uniform;
-      break;
-
-    case facebook::react::ImageResizeMode::Cover:
-      stretch = comp::CompositionStretch::UniformToFill;
-      break;
-
-    case facebook::react::ImageResizeMode::Stretch:
-      stretch = comp::CompositionStretch::Fill;
-      break;
-
-    case facebook::react::ImageResizeMode::Center:
-    case facebook::react::ImageResizeMode::Repeat:
-      stretch = IsImageSmallerThanView() ? comp::CompositionStretch::None : comp::CompositionStretch::Uniform;
-      break;
-  }
-
-  return stretch;
-}
-
-comp::CompositionSurfaceBrush ReactImageBrush::GetOrCreateSurfaceBrush() {
-  // If it doesn't exist, create it
-  if (!CompositionBrush()) {
-    comp::CompositionSurfaceBrush surfaceBrush{Microsoft::ReactNative::GetCompositor().CreateSurfaceBrush()};
-    surfaceBrush.Surface(m_loadedImageSurface);
-
-    return surfaceBrush;
-  }
-
-  auto surfaceBrush{CompositionBrush().try_as<comp::CompositionSurfaceBrush>()};
-
-  // If ResizeMode is set to Repeat, then we're using a CompositionEffectBrush.
-  // Get the CompositionSurfaceBrush from its source.
-  if (!surfaceBrush) {
-    auto effectBrush{CompositionBrush().as<comp::CompositionEffectBrush>()};
-    assert(effectBrush);
-
-    surfaceBrush = effectBrush.GetSourceParameter(L"source").as<comp::CompositionSurfaceBrush>();
-  }
-
-  return surfaceBrush;
-}
-
-comp::CompositionEffectBrush ReactImageBrush::GetOrCreateEffectBrush(
-    comp::CompositionSurfaceBrush const &surfaceBrush,
-    bool forceEffectBrush) {
-  if (!m_effectBrush || forceEffectBrush) {
-    winrt::IGraphicsEffectSource sourceParameter = comp::CompositionEffectSourceParameter{L"source"};
-    winrt::IGraphicsEffect effect{nullptr};
-    std::vector<winrt::hstring> animatedProperties;
-
-    if (ResizeMode() == facebook::react::ImageResizeMode::Repeat) {
-      // BorderEffect
-      auto borderEffect{winrt::make<winrt::Microsoft::ReactNative::implementation::BorderEffect>()};
-
-      borderEffect.ExtendX(winrt::Microsoft::ReactNative::CanvasEdgeBehavior::Wrap);
-      borderEffect.ExtendY(winrt::Microsoft::ReactNative::CanvasEdgeBehavior::Wrap);
-
-      borderEffect.Source(sourceParameter);
-      effect = borderEffect;
-    }
-
-    if (m_blurRadius > 0) {
-      // GaussianBlurEffect
-      auto blurEffect{winrt::make<winrt::Microsoft::ReactNative::implementation::GaussianBlurEffect>()};
-      blurEffect.Name(L"Blur");
-
-      // https://microsoft.github.io/Win2D/html/P_Microsoft_Graphics_Canvas_Effects_GaussianBlurEffect_BlurAmount.htm
-      // "You can compute the blur radius of the kernel by multiplying the standard deviation by 3.
-      // The units of both the standard deviation and blur radius are DIPs.
-      // A value of zero DIPs disables this effect entirely."
-      blurEffect.BlurAmount(m_blurRadius / 3);
-      animatedProperties.push_back({BlurBlurAmount});
-      blurEffect.Source(!effect ? sourceParameter : effect);
-      effect = blurEffect;
-    }
-
-    // tintColor
-    if (m_tintColor.A != 0) {
-      auto tintColorEffect{winrt::make<winrt::Microsoft::ReactNative::implementation::ColorSourceEffect>()};
-      tintColorEffect.Name(L"TintColor");
-      tintColorEffect.Color(m_tintColor);
-
-      auto compositeEffect{winrt::make<winrt::Microsoft::ReactNative::implementation::CompositeStepEffect>()};
-      compositeEffect.Mode(winrt::Microsoft::ReactNative::CanvasComposite::SourceIn);
-      compositeEffect.Source(tintColorEffect);
-      animatedProperties.push_back({TintColorColor});
-      compositeEffect.Destination(!effect ? sourceParameter : effect);
-      effect = compositeEffect;
-    }
-
-    comp::CompositionEffectFactory effectFactory{
-        Microsoft::ReactNative::GetCompositor().CreateEffectFactory(effect, animatedProperties)};
-
-    m_effectBrush = effectFactory.CreateBrush();
-    m_effectBrush.SetSourceParameter(L"source", surfaceBrush);
-  }
-
-  return m_effectBrush;
-}
-
-} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/Image/ReactImageBrush.h

@@ -1,67 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <UI.Xaml.Media.h>
-#include <react/renderer/imagemanager/primitives.h>
-#include <winrt/Windows.Foundation.h>
-#include "CppWinRTIncludes.h"
-
-namespace Microsoft::ReactNative {
-
-struct ReactImageBrush : xaml::Media::XamlCompositionBrushBaseT<ReactImageBrush> {
-  using Super = xaml::Media::XamlCompositionBrushBaseT<ReactImageBrush>;
-
-  ReactImageBrush() = default;
-
- public:
-  static winrt::com_ptr<ReactImageBrush> Create();
-
-  // XamlCompositionBaseBrush Overrides
-  void OnConnected();
-  void OnDisconnected();
-
-  // Public Properties
-  facebook::react::ImageResizeMode ResizeMode() {
-    return m_resizeMode;
-  }
-  void ResizeMode(facebook::react::ImageResizeMode value);
-
-  float BlurRadius() {
-    return m_blurRadius;
-  }
-  void BlurRadius(float value);
-
-  winrt::Windows::UI::Color TintColor() {
-    return m_tintColor;
-  }
-  void TintColor(winrt::Windows::UI::Color value);
-
-  winrt::Windows::Foundation::Size AvailableSize() {
-    return m_availableSize;
-  }
-  void AvailableSize(winrt::Windows::Foundation::Size const &value);
-
-  void Source(xaml::Media::LoadedImageSurface const &value);
-
- private:
-  static constexpr auto TintColorColor{L"TintColor.Color"};
-  static constexpr auto BlurBlurAmount{L"Blur.BlurAmount"};
-
-  void UpdateCompositionBrush(bool forceEffectBrush = false);
-  bool IsImageSmallerThanView();
-  comp::CompositionStretch ResizeModeToStretch();
-  comp::CompositionSurfaceBrush GetOrCreateSurfaceBrush();
-  comp::CompositionEffectBrush GetOrCreateEffectBrush(
-      comp::CompositionSurfaceBrush const &surfaceBrush,
-      bool forceEffectBrush = false);
-
-  float m_blurRadius{0};
-  facebook::react::ImageResizeMode m_resizeMode{facebook::react::ImageResizeMode::Contain};
-  winrt::Windows::UI::Color m_tintColor{winrt::Colors::Transparent()};
-  winrt::Windows::Foundation::Size m_availableSize{};
-  xaml::Media::LoadedImageSurface m_loadedImageSurface{nullptr};
-  comp::CompositionEffectBrush m_effectBrush{nullptr};
-};
-} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/KeyboardEventHandler.cpp

@@ -1,261 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#include "pch.h"
-
-#include <UI.Xaml.Input.h>
-#include <winrt/Windows.System.h>
-#include <winrt/Windows.UI.Core.h>
-#include "Utils/Helpers.h"
-#include "Utils/KeyboardUtils.h"
-#include "Utils/PropertyHandlerUtils.h"
-#include "Views/KeyboardEventHandler.h"
-#include "XamlHelper.h"
-
-#ifdef USE_WINUI3
-#include <winrt/Microsoft.UI.Input.h>
-#endif
-
-using namespace std::placeholders;
-
-static constexpr auto ALT_KEY = "altKey";
-static constexpr auto CTRL_KEY = "ctrlKey";
-static constexpr auto META_KEY = "metaKey";
-static constexpr auto SHIFT_KEY = "shiftKey";
-static constexpr auto EVENT_PHASE = "handledEventPhase";
-static constexpr auto KEY = "key";
-static constexpr auto TARGET = "target";
-static constexpr auto CODE = "code";
-static constexpr auto TIMESTAMP = "timestamp";
-
-template <>
-struct json_type_traits<Microsoft::ReactNative::HandledKeyboardEvent> {
-  static Microsoft::ReactNative::HandledKeyboardEvent parseJson(const winrt::Microsoft::ReactNative::JSValue &json) {
-    Microsoft::ReactNative::HandledKeyboardEvent event;
-
-    for (auto const &pair : json.AsObject()) {
-      const std::string &propertyName = pair.first;
-      const auto &propertyValue = pair.second;
-
-      if (propertyName == ALT_KEY)
-        event.altKey = propertyValue.AsBoolean();
-      else if (propertyName == SHIFT_KEY)
-        event.shiftKey = propertyValue.AsBoolean();
-      else if (propertyName == CTRL_KEY)
-        event.ctrlKey = propertyValue.AsBoolean();
-      else if (propertyName == META_KEY)
-        event.metaKey = propertyValue.AsBoolean();
-      else if (propertyName == CODE)
-        event.code = propertyValue.AsString();
-      else if (propertyName == EVENT_PHASE)
-        event.handledEventPhase =
-            Microsoft::ReactNative::asEnum<Microsoft::ReactNative::HandledEventPhase>(propertyValue);
-    }
-
-    return event;
-  }
-};
-
-namespace Microsoft::ReactNative {
-
-std::vector<HandledKeyboardEvent> KeyboardHelper::FromJS(winrt::Microsoft::ReactNative::JSValue const &obj) {
-  if (obj.Type() == winrt::Microsoft::ReactNative::JSValueType::Array) {
-    return json_type_traits<std::vector<HandledKeyboardEvent>>::parseJson(obj);
-  }
-  return std::vector<HandledKeyboardEvent>{};
-}
-
-static folly::dynamic ToEventData(ReactKeyboardEvent event, double timestamp) {
-  return folly::dynamic::object(TARGET, event.target)(ALT_KEY, event.altKey)(CTRL_KEY, event.ctrlKey)(KEY, event.key)(
-      META_KEY, event.metaKey)(SHIFT_KEY, event.shiftKey)(CODE, event.code)(TIMESTAMP, timestamp);
-}
-
-KeyboardEventBaseHandler::KeyboardEventBaseHandler(KeyboardEventCallback &&keyDown, KeyboardEventCallback &&keyUp)
-    : m_keyDownCallback(std::move(keyDown)), m_keyUpCallback(std::move(keyUp)) {}
-
-PreviewKeyboardEventHandler::PreviewKeyboardEventHandler(KeyboardEventCallback &&keyDown, KeyboardEventCallback &&keyUp)
-    : KeyboardEventBaseHandler(std::move(keyDown), std::move(keyUp)) {}
-
-void PreviewKeyboardEventHandler::hook(XamlView xamlView) {
-  auto uiElement = xamlView.as<xaml::UIElement>();
-  if (uiElement.try_as<xaml::IUIElement7>()) {
-    if (m_keyDownCallback)
-      m_previewKeyDownRevoker = uiElement.PreviewKeyDown(winrt::auto_revoke, m_keyDownCallback);
-
-    if (m_keyUpCallback)
-      m_previewKeyUpRevoker = uiElement.PreviewKeyUp(winrt::auto_revoke, m_keyUpCallback);
-  }
-}
-
-void PreviewKeyboardEventHandler::unhook() {
-  m_previewKeyDownRevoker.revoke();
-  m_previewKeyUpRevoker.revoke();
-}
-
-KeyboardEventHandler::KeyboardEventHandler(KeyboardEventCallback &&keyDown, KeyboardEventCallback &&keyUp)
-    : KeyboardEventBaseHandler(std::move(keyDown), std::move(keyUp)) {}
-
-void KeyboardEventHandler::hook(XamlView xamlView) {
-  auto uiElement = xamlView.as<xaml::UIElement>();
-  if (m_keyDownCallback)
-    m_keyDownRevoker = uiElement.KeyDown(winrt::auto_revoke, m_keyDownCallback);
-
-  if (m_keyUpCallback)
-    m_keyUpRevoker = uiElement.KeyUp(winrt::auto_revoke, m_keyUpCallback);
-}
-
-void KeyboardEventHandler::unhook() {
-  m_keyDownRevoker.revoke();
-  m_keyUpRevoker.revoke();
-}
-
-PreviewKeyboardEventHandlerOnRoot::PreviewKeyboardEventHandlerOnRoot(const Mso::React::IReactContext &context)
-    : PreviewKeyboardEventHandler(
-          std::bind(&PreviewKeyboardEventHandlerOnRoot::OnPreKeyDown, this, _1, _2),
-          std::bind(&PreviewKeyboardEventHandlerOnRoot::OnPreKeyUp, this, _1, _2)),
-      m_context(&context) {}
-
-void PreviewKeyboardEventHandlerOnRoot::OnPreKeyDown(
-    winrt::IInspectable const & /*sender*/,
-    xaml::Input::KeyRoutedEventArgs const &args) {
-  DispatchEventToJs("topKeyDown", args);
-}
-
-void PreviewKeyboardEventHandlerOnRoot::OnPreKeyUp(
-    winrt::IInspectable const & /*sender*/,
-    xaml::Input::KeyRoutedEventArgs const &args) {
-  DispatchEventToJs("topKeyUp", args);
-}
-
-HandledKeyboardEventHandler::HandledKeyboardEventHandler() {}
-
-void HandledKeyboardEventHandler::UpdateHandledKeyboardEvents(
-    std::string const &propertyName,
-    winrt::Microsoft::ReactNative::JSValue const &value) {
-  if (propertyName == "keyDownEvents") {
-    m_handledKeyDownKeyboardEvents = KeyboardHelper::FromJS(value);
-  } else if (propertyName == "keyUpEvents")
-    m_handledKeyUpKeyboardEvents = KeyboardHelper::FromJS(value);
-}
-
-void HandledKeyboardEventHandler::hook(XamlView xamlView) {
-  unhook();
-
-  EnsureKeyboardEventHandler();
-  m_previewKeyboardEventHandler->hook(xamlView);
-  m_keyboardEventHandler->hook(xamlView);
-}
-
-void HandledKeyboardEventHandler::unhook() {
-  if (m_previewKeyboardEventHandler)
-    m_previewKeyboardEventHandler->unhook();
-  if (m_keyboardEventHandler)
-    m_keyboardEventHandler->unhook();
-}
-
-void HandledKeyboardEventHandler::EnsureKeyboardEventHandler() {
-  if (!m_previewKeyboardEventHandler) {
-    m_previewKeyboardEventHandler = make_unique<PreviewKeyboardEventHandler>(
-        std::bind(
-            &HandledKeyboardEventHandler::KeyboardEventHandledHandler,
-            this,
-            KeyboardEventPhase::PreviewKeyDown,
-            _1,
-            _2),
-        std::bind(
-            &HandledKeyboardEventHandler::KeyboardEventHandledHandler, this, KeyboardEventPhase::PreviewKeyUp, _1, _2));
-  }
-
-  if (!m_keyboardEventHandler) {
-    m_keyboardEventHandler = make_unique<KeyboardEventHandler>(
-        std::bind(&HandledKeyboardEventHandler::KeyboardEventHandledHandler, this, KeyboardEventPhase::KeyDown, _1, _2),
-        std::bind(&HandledKeyboardEventHandler::KeyboardEventHandledHandler, this, KeyboardEventPhase::KeyUp, _1, _2));
-  }
-}
-
-void HandledKeyboardEventHandler::KeyboardEventHandledHandler(
-    KeyboardEventPhase phase,
-    winrt::IInspectable const & /*sender*/,
-    xaml::Input::KeyRoutedEventArgs const &args) {
-  HandledEventPhase currentEventPhase =
-      (phase == KeyboardEventPhase::PreviewKeyUp || phase == KeyboardEventPhase::PreviewKeyDown)
-      ? HandledEventPhase::Capturing
-      : HandledEventPhase::Bubbling;
-
-  auto event = KeyboardHelper::CreateKeyboardEvent(currentEventPhase, args);
-
-  bool shouldMarkHandled = false;
-  if (phase == KeyboardEventPhase::PreviewKeyDown || phase == KeyboardEventPhase::KeyDown)
-    shouldMarkHandled = KeyboardHelper::ShouldMarkKeyboardHandled(m_handledKeyDownKeyboardEvents, event);
-  else
-    shouldMarkHandled = KeyboardHelper::ShouldMarkKeyboardHandled(m_handledKeyUpKeyboardEvents, event);
-
-  if (shouldMarkHandled)
-    args.Handled(true);
-}
-
-/* static */ bool KeyboardHelper::ShouldMarkKeyboardHandled(
-    std::vector<HandledKeyboardEvent> const &handledEvents,
-    HandledKeyboardEvent currentEvent) {
-  for (auto const &event : handledEvents) {
-    if (event.code == currentEvent.code && (event.altKey == currentEvent.altKey) &&
-        (event.ctrlKey == currentEvent.ctrlKey) && (event.shiftKey == currentEvent.shiftKey) &&
-        (event.metaKey == currentEvent.metaKey) && event.handledEventPhase == currentEvent.handledEventPhase)
-      return true;
-  }
-  return false;
-}
-
-template <typename T>
-void UpdateModifiedKeyStatusTo(T &event) {
-  auto const &coreWindow = winrt::CoreWindow::GetForCurrentThread();
-  event.altKey = IsModifiedKeyPressed(coreWindow, winrt::Windows::System::VirtualKey::Menu);
-  event.shiftKey = IsModifiedKeyPressed(coreWindow, winrt::Windows::System::VirtualKey::Shift);
-  event.metaKey = IsModifiedKeyPressed(coreWindow, winrt::Windows::System::VirtualKey::LeftWindows) ||
-      IsModifiedKeyPressed(coreWindow, winrt::Windows::System::VirtualKey::RightWindows);
-  event.ctrlKey = IsModifiedKeyPressed(coreWindow, winrt::Windows::System::VirtualKey::Control);
-  event.capLocked = KeyboardHelper::IsModifiedKeyLocked(coreWindow, winrt::Windows::System::VirtualKey::CapitalLock);
-};
-
-void PreviewKeyboardEventHandlerOnRoot::DispatchEventToJs(
-    std::string &&eventName,
-    xaml::Input::KeyRoutedEventArgs const &args) {
-  const auto timestamp =
-      std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now().time_since_epoch()).count();
-  if (auto source = args.OriginalSource().try_as<xaml::FrameworkElement>()) {
-    auto reactId = getViewId(*m_context, source);
-    if (reactId.isValid) {
-      ReactKeyboardEvent event;
-      event.target = reactId.tag;
-      UpdateModifiedKeyStatusTo(event);
-      event.key = FromVirtualKey(args.Key(), event.shiftKey, event.capLocked);
-      event.code = CodeFromVirtualKey(args.OriginalKey());
-
-      m_context->DispatchEvent(event.target, std::move(eventName), ToEventData(event, timestamp));
-    }
-  }
-}
-
-HandledKeyboardEvent KeyboardHelper::CreateKeyboardEvent(
-    HandledEventPhase phase,
-    xaml::Input::KeyRoutedEventArgs const &args) {
-  HandledKeyboardEvent event;
-  event.handledEventPhase = phase;
-  UpdateModifiedKeyStatusTo(event);
-  event.code = CodeFromVirtualKey(args.OriginalKey());
-
-  return event;
-}
-
-bool KeyboardHelper::IsModifiedKeyLocked(
-    winrt::CoreWindow const &coreWindow,
-    winrt::Windows::System::VirtualKey virtualKey) {
-#ifdef USE_WINUI3
-  auto const &keyState = winrt::Microsoft::UI::Input::InputKeyboardSource::GetKeyStateForCurrentThread(virtualKey);
-#else
-  auto const &keyState = coreWindow.GetKeyState(virtualKey);
-#endif // USE_WINUI3
-  return (keyState & winrt::CoreVirtualKeyStates::Locked) == winrt::CoreVirtualKeyStates::Locked;
-}
-
-} // namespace Microsoft::ReactNative