react-native-windows 0.0.0-canary.480 → 0.0.0-canary.481

package/Microsoft.ReactNative/ReactInstanceSettings.idl

@@ -100,7 +100,8 @@ namespace Microsoft.ReactNative
 
     DOC_STRING(
       "The name of the JavaScript bundle file to load. This should be a relative path from @.BundleRootPath. "
-      "The `.bundle` extension will be appended to the end, when looking for the bundle file.")
+      "The `.bundle` extension will be appended to the end, when looking for the bundle file.\n"
+      "If using an embedded RCDATA resource, this identifies the resource ID that stores the bundle. See @.BundleRootPath.")
     DOC_DEFAULT("index.windows")
     String JavaScriptBundleFile { get; set; };
 
@@ -176,7 +177,16 @@ namespace Microsoft.ReactNative
       "If this is not provided, the value of @.JavaScriptBundleFile is used.")
     String DebugBundlePath { get; set; };
 
-    DOC_STRING("Base path used for the location of the bundle.")
+    DOC_STRING(
+      "Base path used for the location of the bundle. \n"
+      "This can be an `ms-appx://` or `ms-appdata://` URI (if the app is UWP or packaged using MSIX), "
+      "a filesystem path, or a URI pointing at an embedded resource.\n"
+      "Examples:\n\n"
+      "- `ms-appx:///Bundle` - locates the bundle in the MSIX package. See [URI schemes](https://docs.microsoft.com/windows/uwp/app-resources/uri-schemes) for other UWP/MSIX valid URI formats."
+      "- `C:\\foo\\bar` - locates the bundle in the local filesystem. Note [UWP app file access permissions](https://docs.microsoft.com/windows/uwp/files/file-access-permissions)."
+      "- `resource://moduleName` - locates the bundle as an embedded RCDATA resource in moduleName. Specify the resource ID in @.JavaScriptBundleFile."
+      "- `resource://` - locates the bundle as an embedded RCDATA resource in the running process's module. Specify the resource ID in @.JavaScriptBundleFile."
+    )
     DOC_DEFAULT("ms-appx:///Bundle/")
     String BundleRootPath { get; set; };
 

package/Microsoft.ReactNative/Utils/LocalBundleReader.cpp

@@ -15,6 +15,45 @@
 
 namespace Microsoft::ReactNative {
 
+std::string GetBundleFromEmbeddedResource(winrt::hstring str) {
+  winrt::Windows::Foundation::Uri uri(str);
+  auto moduleName = uri.Host();
+  auto path = uri.Path();
+  // skip past the leading / slash
+  auto resourceName = path.c_str() + 1;
+
+  auto hmodule = GetModuleHandle(moduleName != L"" ? moduleName.c_str() : nullptr);
+  if (!hmodule) {
+    throw std::invalid_argument(fmt::format("Couldn't find module {}", winrt::to_string(moduleName)));
+  }
+
+  auto resource = FindResourceW(hmodule, resourceName, RT_RCDATA);
+  if (!resource) {
+    throw std::invalid_argument(fmt::format(
+        "Couldn't find resource {} in module {}", winrt::to_string(resourceName), winrt::to_string(moduleName)));
+  }
+
+  auto hglobal = LoadResource(hmodule, resource);
+  if (!hglobal) {
+    throw std::invalid_argument(fmt::format(
+        "Couldn't load resource {} in module {}", winrt::to_string(resourceName), winrt::to_string(moduleName)));
+  }
+
+  auto start = static_cast<char *>(LockResource(hglobal));
+  if (!start) {
+    throw std::invalid_argument(fmt::format(
+        "Couldn't lock resource {} in module {}", winrt::to_string(resourceName), winrt::to_string(moduleName)));
+  }
+
+  auto size = SizeofResource(hmodule, resource);
+  if (!size) {
+    throw std::invalid_argument(fmt::format(
+        "Couldn't get size of resource {} in module {}", winrt::to_string(resourceName), winrt::to_string(moduleName)));
+  }
+
+  return std::string(start, start + size);
+}
+
 std::future<std::string> LocalBundleReader::LoadBundleAsync(const std::string &bundleUri) {
   winrt::hstring str(Microsoft::Common::Unicode::Utf8ToUtf16(bundleUri));
 
@@ -26,6 +65,8 @@ std::future<std::string> LocalBundleReader::LoadBundleAsync(const std::string &b
   if (bundleUri._Starts_with("ms-app")) {
     winrt::Windows::Foundation::Uri uri(str);
     file = co_await winrt::Windows::Storage::StorageFile::GetFileFromApplicationUriAsync(uri);
+  } else if (bundleUri._Starts_with("resource://")) {
+    co_return GetBundleFromEmbeddedResource(str);
   } else {
     file = co_await winrt::Windows::Storage::StorageFile::GetFileFromPathAsync(str);
   }

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,7 +10,7 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.0.0-canary.480</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.0.0-canary.481</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>0</ReactNativeWindowsMinor>
     <ReactNativeWindowsPatch>0</ReactNativeWindowsPatch>

package/Shared/OInstance.cpp

@@ -509,7 +509,15 @@ void InstanceImpl::loadBundleInternal(std::string &&jsBundleRelativePath, bool s
       std::string bundlePath = (fs::path(m_devSettings->bundleRootPath) / jsBundleRelativePath).string();
       auto bundleString = FileMappingBigString::fromPath(bundlePath);
 #else
-      std::string bundlePath = (fs::path(m_devSettings->bundleRootPath) / (jsBundleRelativePath + ".bundle")).string();
+      std::string bundlePath;
+      if (m_devSettings->bundleRootPath._Starts_with("resource://")) {
+        auto uri = winrt::Windows::Foundation::Uri(
+            winrt::to_hstring(m_devSettings->bundleRootPath), winrt::to_hstring(jsBundleRelativePath));
+        bundlePath = winrt::to_string(uri.ToString());
+      } else {
+        bundlePath = (fs::path(m_devSettings->bundleRootPath) / (jsBundleRelativePath + ".bundle")).string();
+      }
+
       auto bundleString = std::make_unique<::Microsoft::ReactNative::StorageFileBigString>(bundlePath);
 #endif
       m_innerInstance->loadScriptFromString(std::move(bundleString), std::move(jsBundleRelativePath), synchronously);
@@ -517,11 +525,9 @@ void InstanceImpl::loadBundleInternal(std::string &&jsBundleRelativePath, bool s
   } catch (const std::exception &e) {
     m_devSettings->errorCallback(e.what());
   } catch (const winrt::hresult_error &hrerr) {
-    std::stringstream ss;
-    ss << "[" << std::hex << std::showbase << std::setw(8) << static_cast<uint32_t>(hrerr.code()) << "] "
-       << winrt::to_string(hrerr.message());
+    auto error = fmt::format("[0x{:0>8x}] {}", static_cast<uint32_t>(hrerr.code()), winrt::to_string(hrerr.message()));
 
-    m_devSettings->errorCallback(std::move(ss.str()));
+    m_devSettings->errorCallback(std::move(error));
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.0.0-canary.480",
+  "version": "0.0.0-canary.481",
   "license": "MIT",
   "repository": {
     "type": "git",

package/stubs/glog/logging.h

@@ -74,7 +74,7 @@ typedef int LogSeverity;
 inline void FlushLogFiles(LogSeverity min_severity) {}
 
 #define google GlogStub
-static const int INFO = 1;
+static const int GLOG_INFO = 1;
 
 #endif
 

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/debug/react_native_assert.h

@@ -1,64 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// No header guards since it is legitimately possible to include this file more
-// than once with and without REACT_NATIVE_DEBUG.
-
-// react_native_assert allows us to opt-in to specific asserts on Android and
-// test before moving on. When all issues have been found, maybe we can use
-// `UNDEBUG` flag to disable NDEBUG in debug builds on Android.
-
-#include "flags.h"
-
-#undef react_native_assert
-
-#ifndef REACT_NATIVE_DEBUG
-
-#define react_native_assert(e) ((void)0)
-
-#else // REACT_NATIVE_DEBUG
-
-#ifdef __ANDROID__
-
-#include <android/log.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-void react_native_assert_fail(
-    const char *func,
-    const char *file,
-    int line,
-    const char *expr);
-#ifdef __cplusplus
-}
-#endif // __cpusplus
-
-#define react_native_assert(e) \
-  ((e) ? (void)0 : react_native_assert_fail(__func__, __FILE__, __LINE__, #e))
-
-#else // __ANDROID__
-
-#include <glog/logging.h>
-#include <cassert>
-
-// For all platforms, but iOS+Xcode especially: flush logs because some might be
-// lost on iOS if an assert is hit right after this. If you are trying to debug
-// something actively and have added lots of LOG statements to track down an
-// issue, there is race between flushing the final logs and stopping execution
-// when the assert hits. Thus, if we know an assert will fail, we force flushing
-// to happen right before the assert.
-#define react_native_assert(cond)                           \
-  if (!(cond)) {                                            \
-    LOG(ERROR) << "react_native_assert failure: " << #cond; \
-    google::FlushLogFiles(google::INFO);               \
-    assert(cond);                                           \
-  }
-
-#endif // platforms besides __ANDROID__
-
-#endif // REACT_NATIVE_DEBUG

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/mounting/StubViewTree.cpp

@@ -1,310 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#include "StubViewTree.h"
-
-#include <glog/logging.h>
-#include <react/debug/react_native_assert.h>
-
-#ifdef STUB_VIEW_TREE_VERBOSE
-#define STUB_VIEW_LOG(code) code
-#else
-#define STUB_VIEW_LOG(code)
-#endif
-
-namespace facebook {
-namespace react {
-
-StubViewTree::StubViewTree(ShadowView const &shadowView) {
-  auto view = std::make_shared<StubView>();
-  view->update(shadowView);
-  rootTag = shadowView.tag;
-  registry[shadowView.tag] = view;
-}
-
-StubView const &StubViewTree::getRootStubView() const {
-  return *registry.at(rootTag);
-}
-
-StubView const &StubViewTree::getStubView(Tag tag) const {
-  return *registry.at(tag);
-}
-
-size_t StubViewTree::size() const {
-  return registry.size();
-}
-
-void StubViewTree::mutate(ShadowViewMutationList const &mutations) {
-  STUB_VIEW_LOG({ LOG(ERROR) << "StubView: Mutating Begin"; });
-  for (auto const &mutation : mutations) {
-    switch (mutation.type) {
-      case ShadowViewMutation::Create: {
-        react_native_assert(mutation.parentShadowView == ShadowView{});
-        react_native_assert(mutation.oldChildShadowView == ShadowView{});
-        react_native_assert(mutation.newChildShadowView.props);
-        auto stubView = std::make_shared<StubView>();
-        stubView->update(mutation.newChildShadowView);
-        auto tag = mutation.newChildShadowView.tag;
-        STUB_VIEW_LOG({
-          LOG(ERROR) << "StubView: Create [" << tag << "] ##"
-                     << std::hash<ShadowView>{}((ShadowView)*stubView);
-        });
-        react_native_assert(registry.find(tag) == registry.end());
-        registry[tag] = stubView;
-        break;
-      }
-
-      case ShadowViewMutation::Delete: {
-        STUB_VIEW_LOG({
-          LOG(ERROR) << "StubView: Delete [" << mutation.oldChildShadowView.tag
-                     << "] ##"
-                     << std::hash<ShadowView>{}(mutation.oldChildShadowView);
-        });
-        react_native_assert(mutation.parentShadowView == ShadowView{});
-        react_native_assert(mutation.newChildShadowView == ShadowView{});
-        auto tag = mutation.oldChildShadowView.tag;
-        react_native_assert(registry.find(tag) != registry.end());
-        auto stubView = registry[tag];
-        if ((ShadowView)(*stubView) != mutation.oldChildShadowView) {
-          LOG(ERROR)
-              << "StubView: ASSERT FAILURE: DELETE mutation assertion failure: oldChildShadowView does not match stubView: ["
-              << mutation.oldChildShadowView.tag << "] stub hash: ##"
-              << std::hash<ShadowView>{}((ShadowView)*stubView)
-              << " old mutation hash: ##"
-              << std::hash<ShadowView>{}(mutation.oldChildShadowView);
-#ifdef RN_DEBUG_STRING_CONVERTIBLE
-          LOG(ERROR) << "StubView: "
-                     << getDebugPropsDescription((ShadowView)*stubView, {});
-          LOG(ERROR) << "OldChildShadowView: "
-                     << getDebugPropsDescription(
-                            mutation.oldChildShadowView, {});
-#endif
-        }
-        react_native_assert(
-            (ShadowView)(*stubView) == mutation.oldChildShadowView);
-        registry.erase(tag);
-        break;
-      }
-
-      case ShadowViewMutation::Insert: {
-        if (!mutation.mutatedViewIsVirtual()) {
-          react_native_assert(mutation.oldChildShadowView == ShadowView{});
-          auto parentTag = mutation.parentShadowView.tag;
-          auto childTag = mutation.newChildShadowView.tag;
-          if (registry.find(parentTag) == registry.end()) {
-            LOG(ERROR)
-                << "StubView: ASSERT FAILURE: INSERT mutation assertion failure: parentTag not found: ["
-                << parentTag << "] inserting child: [" << childTag << "]";
-          }
-          if (registry.find(childTag) == registry.end()) {
-            LOG(ERROR)
-                << "StubView: ASSERT FAILURE: INSERT mutation assertion failure: childTag not found: ["
-                << parentTag << "] inserting child: [" << childTag << "]";
-          }
-          react_native_assert(registry.find(parentTag) != registry.end());
-          auto parentStubView = registry[parentTag];
-          react_native_assert(registry.find(childTag) != registry.end());
-          auto childStubView = registry[childTag];
-          childStubView->update(mutation.newChildShadowView);
-          STUB_VIEW_LOG({
-            LOG(ERROR) << "StubView: Insert [" << childTag << "] into ["
-                       << parentTag << "] @" << mutation.index << "("
-                       << parentStubView->children.size() << " children)";
-          });
-          react_native_assert(childStubView->parentTag == NO_VIEW_TAG);
-          react_native_assert(
-              mutation.index >= 0 &&
-              parentStubView->children.size() >=
-                  static_cast<size_t>(mutation.index));
-          childStubView->parentTag = parentTag;
-          parentStubView->children.insert(
-              parentStubView->children.begin() + mutation.index, childStubView);
-        } else {
-          auto childTag = mutation.newChildShadowView.tag;
-          react_native_assert(registry.find(childTag) != registry.end());
-          auto childStubView = registry[childTag];
-          childStubView->update(mutation.newChildShadowView);
-        }
-        break;
-      }
-
-      case ShadowViewMutation::Remove: {
-        if (!mutation.mutatedViewIsVirtual()) {
-          react_native_assert(mutation.newChildShadowView == ShadowView{});
-          auto parentTag = mutation.parentShadowView.tag;
-          auto childTag = mutation.oldChildShadowView.tag;
-          if (registry.find(parentTag) == registry.end()) {
-            LOG(ERROR)
-                << "StubView: ASSERT FAILURE: REMOVE mutation assertion failure: parentTag not found: ["
-                << parentTag << "] removing child: [" << childTag << "]";
-          }
-          react_native_assert(registry.find(parentTag) != registry.end());
-          auto parentStubView = registry[parentTag];
-          STUB_VIEW_LOG({
-            LOG(ERROR) << "StubView: Remove [" << childTag << "] from ["
-                       << parentTag << "] @" << mutation.index << " with "
-                       << parentStubView->children.size() << " children";
-          });
-          react_native_assert(
-              mutation.index >= 0 &&
-              parentStubView->children.size() >
-                  static_cast<size_t>(mutation.index));
-          react_native_assert(registry.find(childTag) != registry.end());
-          auto childStubView = registry[childTag];
-          if ((ShadowView)(*childStubView) != mutation.oldChildShadowView) {
-            LOG(ERROR)
-                << "StubView: ASSERT FAILURE: REMOVE mutation assertion failure: oldChildShadowView does not match oldStubView: ["
-                << mutation.oldChildShadowView.tag << "] stub hash: ##"
-                << std::hash<ShadowView>{}((ShadowView)*childStubView)
-                << " old mutation hash: ##"
-                << std::hash<ShadowView>{}(mutation.oldChildShadowView);
-#ifdef RN_DEBUG_STRING_CONVERTIBLE
-            LOG(ERROR) << "ChildStubView: "
-                       << getDebugPropsDescription(
-                              (ShadowView)*childStubView, {});
-            LOG(ERROR) << "OldChildShadowView: "
-                       << getDebugPropsDescription(
-                              mutation.oldChildShadowView, {});
-#endif
-          }
-          react_native_assert(
-              (ShadowView)(*childStubView) == mutation.oldChildShadowView);
-          react_native_assert(childStubView->parentTag == parentTag);
-          STUB_VIEW_LOG({
-            std::string strChildList = "";
-            int i = 0;
-            for (auto const &child : parentStubView->children) {
-              strChildList.append(std::to_string(i));
-              strChildList.append(":");
-              strChildList.append(std::to_string(child->tag));
-              strChildList.append(", ");
-              i++;
-            }
-            LOG(ERROR) << "StubView: BEFORE REMOVE: Children of " << parentTag
-                       << ": " << strChildList;
-          });
-          react_native_assert(
-              mutation.index >= 0 &&
-              parentStubView->children.size() >
-                  static_cast<size_t>(mutation.index) &&
-              parentStubView->children[mutation.index]->tag ==
-                  childStubView->tag);
-          childStubView->parentTag = NO_VIEW_TAG;
-          parentStubView->children.erase(
-              parentStubView->children.begin() + mutation.index);
-        }
-        break;
-      }
-
-      case ShadowViewMutation::Update: {
-        STUB_VIEW_LOG({
-          LOG(ERROR) << "StubView: Update [" << mutation.newChildShadowView.tag
-                     << "] old hash: ##"
-                     << std::hash<ShadowView>{}(mutation.oldChildShadowView)
-                     << " new hash: ##"
-                     << std::hash<ShadowView>{}(mutation.newChildShadowView);
-        });
-        react_native_assert(mutation.oldChildShadowView.tag != 0);
-        react_native_assert(mutation.newChildShadowView.tag != 0);
-        react_native_assert(mutation.newChildShadowView.props);
-        react_native_assert(
-            mutation.newChildShadowView.tag == mutation.oldChildShadowView.tag);
-        react_native_assert(
-            registry.find(mutation.newChildShadowView.tag) != registry.end());
-        auto oldStubView = registry[mutation.newChildShadowView.tag];
-        react_native_assert(oldStubView->tag != 0);
-        if ((ShadowView)(*oldStubView) != mutation.oldChildShadowView) {
-          LOG(ERROR)
-              << "StubView: ASSERT FAILURE: UPDATE mutation assertion failure: oldChildShadowView does not match oldStubView: ["
-              << mutation.oldChildShadowView.tag << "] old stub hash: ##"
-              << std::hash<ShadowView>{}((ShadowView)*oldStubView)
-              << " old mutation hash: ##"
-              << std::hash<ShadowView>{}(mutation.oldChildShadowView);
-#ifdef RN_DEBUG_STRING_CONVERTIBLE
-          LOG(ERROR) << "OldStubView: "
-                     << getDebugPropsDescription((ShadowView)*oldStubView, {});
-          LOG(ERROR) << "OldChildShadowView: "
-                     << getDebugPropsDescription(
-                            mutation.oldChildShadowView, {});
-#endif
-        }
-        react_native_assert(
-            (ShadowView)(*oldStubView) == mutation.oldChildShadowView);
-        oldStubView->update(mutation.newChildShadowView);
-
-        // Hash for stub view and the ShadowView should be identical - this
-        // tests that StubView and ShadowView hash are equivalent.
-        react_native_assert(
-            std::hash<ShadowView>{}((ShadowView)*oldStubView) ==
-            std::hash<ShadowView>{}(mutation.newChildShadowView));
-
-        break;
-      }
-    }
-  }
-  STUB_VIEW_LOG({ LOG(ERROR) << "StubView: Mutating End"; });
-
-  // For iOS especially: flush logs because some might be lost on iOS if an
-  // assert is hit right after this.
-  google::FlushLogFiles(google::INFO);
-}
-
-bool operator==(StubViewTree const &lhs, StubViewTree const &rhs) {
-  if (lhs.registry.size() != rhs.registry.size()) {
-    STUB_VIEW_LOG({
-      LOG(ERROR) << "Registry sizes are different. Sizes: LHS: "
-                 << lhs.registry.size() << " RHS: " << rhs.registry.size();
-
-      [&](std::ostream &stream) -> std::ostream & {
-        stream << "Tags in LHS: ";
-        for (auto const &pair : lhs.registry) {
-          auto &lhsStubView = *lhs.registry.at(pair.first);
-          stream << "[" << lhsStubView.tag << "]##"
-                 << std::hash<ShadowView>{}((ShadowView)lhsStubView) << " ";
-        }
-        return stream;
-      }(LOG(ERROR));
-
-      [&](std::ostream &stream) -> std::ostream & {
-        stream << "Tags in RHS: ";
-        for (auto const &pair : rhs.registry) {
-          auto &rhsStubView = *rhs.registry.at(pair.first);
-          stream << "[" << rhsStubView.tag << "]##"
-                 << std::hash<ShadowView>{}((ShadowView)rhsStubView) << " ";
-        }
-        return stream;
-      }(LOG(ERROR));
-    });
-
-    return false;
-  }
-
-  for (auto const &pair : lhs.registry) {
-    auto &lhsStubView = *lhs.registry.at(pair.first);
-    auto &rhsStubView = *rhs.registry.at(pair.first);
-
-    if (lhsStubView != rhsStubView) {
-      STUB_VIEW_LOG({
-        LOG(ERROR) << "Registry entries are different. LHS: ["
-                   << lhsStubView.tag << "] ##"
-                   << std::hash<ShadowView>{}((ShadowView)lhsStubView)
-                   << " RHS: [" << rhsStubView.tag << "] ##"
-                   << std::hash<ShadowView>{}((ShadowView)rhsStubView);
-      });
-      return false;
-    }
-  }
-
-  return true;
-}
-
-bool operator!=(StubViewTree const &lhs, StubViewTree const &rhs) {
-  return !(lhs == rhs);
-}
-
-} // namespace react
-} // namespace facebook