react-native-unistyles 3.5.3 → 3.6.0

package/README.md

@@ -190,6 +190,9 @@ Looking for help or you want to chat with me?
 
 [Join Discord](https://discord.gg/akGHf27P4C)
 
+## Contributing
+The repository uses a git submodule ([unifiber](https://github.com/uni-stack/unifiber)). Clone it with `git clone --recurse-submodules`, or run `git submodule update --init` in an existing clone.
+
 
 ## License
 

package/cxx/converters/BackgroundImageConverter.cpp

@@ -1,17 +1,177 @@
 #include "BackgroundImageConverter.h"
 
 #include <algorithm>
+#include <cxxreact/ReactNativeVersion.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 
-#if defined(RN_SERIALIZABLE_STATE) &&                                          \
-    __has_include(                                                             \
-        <react/renderer/components/view/BackgroundImagePropsConversions.h>)
-#include <react/renderer/components/view/BackgroundImagePropsConversions.h>
-#include <react/renderer/core/propsConversions.h>
+// React Native 0.83 added a C++ CSS parser for background images. Without
+// enableNativeCSSParsing, the native props parser only accepts the processed
+// form (array of gradient objects), so strings are converted here on both
+// platforms.
+#if __has_include(<react/renderer/css/CSSBackgroundImage.h>)
+#include <folly/Conv.h>
+#include <react/renderer/css/CSSBackgroundImage.h>
+#include <react/renderer/css/CSSValueParser.h>
 #define UNISTYLES_HAS_RN_BACKGROUND_IMAGE_PARSER 1
 #endif
 
 namespace margelo::nitro::unistyles::converters {
 
+#ifdef UNISTYLES_HAS_RN_BACKGROUND_IMAGE_PARSER
+namespace {
+
+using namespace facebook::react;
+
+using CSSLengthPercentage = std::variant<CSSLength, CSSPercentage>;
+using CSSGradientItems = std::vector<std::variant<CSSColorStop, CSSColorHint>>;
+
+// same output as React Native's processBackgroundImage.js
+folly::dynamic toPosition(const CSSLengthPercentage &value) {
+  if (std::holds_alternative<CSSLength>(value)) {
+    return std::get<CSSLength>(value).value;
+  }
+
+  return folly::to<std::string>(std::get<CSSPercentage>(value).value) + "%";
+}
+
+// ARGB, same as processColor
+int32_t toColor(const CSSColor &color) {
+  return static_cast<int32_t>((static_cast<uint32_t>(color.a) << 24) |
+                              (static_cast<uint32_t>(color.r) << 16) |
+                              (static_cast<uint32_t>(color.g) << 8) |
+                              static_cast<uint32_t>(color.b));
+}
+
+folly::dynamic toColorStops(const CSSGradientItems &items) {
+  folly::dynamic colorStops = folly::dynamic::array();
+
+  for (const auto &item : items) {
+    if (std::holds_alternative<CSSColorHint>(item)) {
+      colorStops.push_back(folly::dynamic::object("color", nullptr)(
+          "position", toPosition(std::get<CSSColorHint>(item).position)));
+
+      continue;
+    }
+
+    const auto &colorStop = std::get<CSSColorStop>(item);
+    auto color = toColor(colorStop.color);
+
+    colorStops.push_back(folly::dynamic::object("color", color)(
+        "position", colorStop.startPosition.has_value()
+                        ? toPosition(*colorStop.startPosition)
+                        : nullptr));
+
+    if (colorStop.endPosition.has_value()) {
+      colorStops.push_back(folly::dynamic::object("color", color)(
+          "position", toPosition(*colorStop.endPosition)));
+    }
+  }
+
+  return colorStops;
+}
+
+std::string toKeyword(CSSLinearGradientDirectionKeyword keyword) {
+  switch (keyword) {
+  case CSSLinearGradientDirectionKeyword::ToTopLeft:
+    return "to top left";
+  case CSSLinearGradientDirectionKeyword::ToTopRight:
+    return "to top right";
+  case CSSLinearGradientDirectionKeyword::ToBottomLeft:
+    return "to bottom left";
+  case CSSLinearGradientDirectionKeyword::ToBottomRight:
+    return "to bottom right";
+  }
+
+  return "to bottom right";
+}
+
+folly::dynamic toLinearGradient(const CSSLinearGradientFunction &gradient) {
+  folly::dynamic direction =
+      folly::dynamic::object("type", "angle")("value", 180.0);
+
+  if (gradient.direction.has_value()) {
+    const auto &value = gradient.direction->value;
+
+    direction =
+        std::holds_alternative<CSSAngle>(value)
+            ? folly::dynamic::object("type", "angle")(
+                  "value", std::get<CSSAngle>(value).degrees)
+            : folly::dynamic::object("type", "keyword")(
+                  "value",
+                  toKeyword(std::get<CSSLinearGradientDirectionKeyword>(value)));
+  }
+
+  return folly::dynamic::object("type", "linear-gradient")(
+      "direction", std::move(direction))("colorStops",
+                                         toColorStops(gradient.items));
+}
+
+std::string toSizeKeyword(CSSRadialGradientSizeKeyword keyword) {
+  switch (keyword) {
+  case CSSRadialGradientSizeKeyword::ClosestSide:
+    return "closest-side";
+  case CSSRadialGradientSizeKeyword::ClosestCorner:
+    return "closest-corner";
+  case CSSRadialGradientSizeKeyword::FarthestSide:
+    return "farthest-side";
+  case CSSRadialGradientSizeKeyword::FarthestCorner:
+    return "farthest-corner";
+  }
+
+  return "farthest-corner";
+}
+
+folly::dynamic toRadialGradient(const CSSRadialGradientFunction &gradient) {
+  folly::dynamic size = "farthest-corner";
+  folly::dynamic position = folly::dynamic::object("top", "50%")("left", "50%");
+
+  if (gradient.size.has_value()) {
+    const auto &value = *gradient.size;
+
+    if (std::holds_alternative<CSSRadialGradientSizeKeyword>(value)) {
+      size = toSizeKeyword(std::get<CSSRadialGradientSizeKeyword>(value));
+    } else {
+      const auto &explicitSize = std::get<CSSRadialGradientExplicitSize>(value);
+
+      size = folly::dynamic::object("x", toPosition(explicitSize.sizeX))(
+          "y", toPosition(explicitSize.sizeY));
+    }
+  }
+
+  if (gradient.position.has_value()) {
+    const auto &value = *gradient.position;
+
+    position = folly::dynamic::object();
+
+    if (value.top.has_value()) {
+      position["top"] = toPosition(*value.top);
+    }
+
+    if (value.bottom.has_value()) {
+      position["bottom"] = toPosition(*value.bottom);
+    }
+
+    if (value.left.has_value()) {
+      position["left"] = toPosition(*value.left);
+    }
+
+    if (value.right.has_value()) {
+      position["right"] = toPosition(*value.right);
+    }
+  }
+
+  auto isCircle = gradient.shape.has_value() &&
+                  *gradient.shape == CSSRadialGradientShape::Circle;
+
+  return folly::dynamic::object("type", "radial-gradient")(
+      "shape", isCircle ? "circle" : "ellipse")("size", std::move(size))(
+      "position", std::move(position))("colorStops",
+                                       toColorStops(gradient.items));
+}
+
+} // namespace
+#endif
+
 bool isBackgroundImagePropName(const std::string &propertyName) {
   return propertyName == "backgroundImage" ||
          propertyName == "experimental_backgroundImage";
@@ -37,19 +197,46 @@ bool hasSafeBackgroundImageColorStops(const folly::dynamic &backgroundImages) {
 std::optional<folly::dynamic>
 parseBackgroundImageString(const std::string &backgroundImageString) {
 #ifdef UNISTYLES_HAS_RN_BACKGROUND_IMAGE_PARSER
-  std::vector<facebook::react::BackgroundImage> backgroundImages;
+  using namespace facebook::react;
+
+  auto maybeBackgroundImages =
+      parseCSSProperty<CSSBackgroundImageList>(backgroundImageString);
 
-  facebook::react::parseUnprocessedBackgroundImageString(backgroundImageString,
-                                                         backgroundImages);
+  if (!std::holds_alternative<CSSBackgroundImageList>(maybeBackgroundImages)) {
+    return folly::dynamic::array();
+  }
+
+  folly::dynamic backgroundImages = folly::dynamic::array();
 
-  auto parsedBackgroundImages = facebook::react::toDynamic(backgroundImages);
+  for (const auto &backgroundImage :
+       std::get<CSSBackgroundImageList>(maybeBackgroundImages)) {
+    if (std::holds_alternative<CSSLinearGradientFunction>(backgroundImage)) {
+      backgroundImages.push_back(
+          toLinearGradient(std::get<CSSLinearGradientFunction>(backgroundImage)));
+    } else if (std::holds_alternative<CSSRadialGradientFunction>(
+                   backgroundImage)) {
+      backgroundImages.push_back(
+          toRadialGradient(std::get<CSSRadialGradientFunction>(backgroundImage)));
+    }
+  }
 
-  return hasSafeBackgroundImageColorStops(parsedBackgroundImages)
-             ? std::move(parsedBackgroundImages)
+  return hasSafeBackgroundImageColorStops(backgroundImages)
+             ? std::move(backgroundImages)
              : folly::dynamic::array();
 #else
   return std::nullopt;
 #endif
 }
 
+// React Native parses background image strings natively since 0.83, but only
+// with enableNativeCSSParsing. Otherwise its view props expect the processed
+// array and read a string as no background image.
+bool canReactNativeParseBackgroundImageString() {
+#if REACT_NATIVE_VERSION_MAJOR > 0 || REACT_NATIVE_VERSION_MINOR >= 83
+  return facebook::react::ReactNativeFeatureFlags::enableNativeCSSParsing();
+#else
+  return false;
+#endif
+}
+
 } // namespace margelo::nitro::unistyles::converters

package/cxx/converters/BackgroundImageConverter.h

@@ -10,5 +10,6 @@ bool isBackgroundImagePropName(const std::string &propertyName);
 bool hasSafeBackgroundImageColorStops(const folly::dynamic &backgroundImages);
 std::optional<folly::dynamic>
 parseBackgroundImageString(const std::string &backgroundImageString);
+bool canReactNativeParseBackgroundImageString();
 
 } // namespace margelo::nitro::unistyles::converters

package/cxx/core/HostUnistyle.cpp

@@ -19,6 +19,12 @@ std::vector<jsi::PropNameID> HostUnistyle::getPropertyNames(jsi::Runtime& rt) {
 
 HostUnistyle::~HostUnistyle() {
     if (this->_ownsStyleSheet) {
+        for (const auto& [_, unistyle] : this->_stylesheet->unistyles) {
+            if (unistyle->type == UnistyleType::DynamicFunction) {
+                std::static_pointer_cast<UnistyleDynamicFunction>(unistyle)->proxiedFunction.reset();
+            }
+        }
+
         this->_stylesheet->unistyles.clear();
     }
 }

package/cxx/hybridObjects/HybridShadowRegistry.cpp

@@ -265,6 +265,11 @@ jsi::Value HybridShadowRegistry::verify(jsi::Runtime &rt, const jsi::Value &this
 
 // the fibers React created the committed nodes with (weak, null once collected)
 jsi::Value HybridShadowRegistry::takeCommittedInstanceHandles(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    // runtime was replaced, the handles belong to the next one
+    if (!this->_unistylesRuntime->ownsRegistry()) {
+        return jsi::Array(rt, 0);
+    }
+
     auto instanceHandles = core::UnistylesRegistry::get().takeCommittedInstanceHandles();
     auto result = jsi::Array(rt, instanceHandles.size());
 

package/cxx/parser/Parser.cpp

@@ -1071,6 +1071,7 @@ jsi::Value parser::Parser::parseSecondLevel(jsi::Runtime &rt, Unistyle::Shared u
 folly::dynamic parser::Parser::parseStylesToShadowTreeStyles(jsi::Runtime& rt, const std::vector<std::shared_ptr<UnistyleData>>& unistyles) {
     jsi::Object convertedStyles(rt);
     auto& state = core::UnistylesRegistry::get().getState();
+    std::unordered_set<std::string> skippedBackgroundImages;
 
     for (const auto& unistyleData : unistyles) {
         if (!unistyleData->parsedStyle.has_value()) {
@@ -1080,8 +1081,23 @@ folly::dynamic parser::Parser::parseStylesToShadowTreeStyles(jsi::Runtime& rt, c
         helpers::enumerateJSIObject(
             rt,
             unistyleData->parsedStyle.value(),
-            [this, &rt, &state, &convertedStyles](const std::string& propertyName, jsi::Value& propertyValue) {
+            [this, &rt, &state, &convertedStyles, &skippedBackgroundImages](const std::string& propertyName, jsi::Value& propertyValue) {
+                if (converters::isBackgroundImagePropName(propertyName)) {
+                    skippedBackgroundImages.erase(propertyName);
+                }
+
                 if (converters::isBackgroundImagePropName(propertyName) && propertyValue.isString()) {
+                    // React Native parses the raw string natively and reads an array as the unprocessed syntax
+                    if (converters::canReactNativeParseBackgroundImageString()) {
+                        convertedStyles.setProperty(
+                            rt,
+                            propertyName.c_str(),
+                            propertyValue
+                        );
+
+                        return;
+                    }
+
                     auto maybeBackgroundImage = converters::parseBackgroundImageString(propertyValue.asString(rt).utf8(rt));
 
                     if (maybeBackgroundImage.has_value()) {
@@ -1094,11 +1110,9 @@ folly::dynamic parser::Parser::parseStylesToShadowTreeStyles(jsi::Runtime& rt, c
                         return;
                     }
 
-                    convertedStyles.setProperty(
-                        rt,
-                        propertyName.c_str(),
-                        propertyValue
-                    );
+                    // without a converter (React Native < 0.83) a raw string reads as no background image,
+                    // so leave the prop to React, which processes it in JS
+                    skippedBackgroundImages.insert(propertyName);
 
                     return;
                 }
@@ -1273,7 +1287,15 @@ folly::dynamic parser::Parser::parseStylesToShadowTreeStyles(jsi::Runtime& rt, c
         );
     }
 
-    return jsi::dynamicFromValue(rt, jsi::Value(rt, convertedStyles));
+    auto props = jsi::dynamicFromValue(rt, jsi::Value(rt, convertedStyles));
+
+    // a skipped string still wins over earlier styles in React,
+    // so drop the prop instead of writing an earlier style's value
+    for (const auto& propName : skippedBackgroundImages) {
+        props.erase(propName);
+    }
+
+    return props;
 }
 
 // shadow tree updates skip the props an inline style sets last, React (or an animation) owns them

package/ios/NativePlatform+ios.swift

@@ -14,6 +14,7 @@ class NativeIOSPlatform: HybridNativePlatformSpec {
 
     var dependencyListeners: Array<CxxDependencyListener> = []
     var imeListeners: Array<CxxImeListener> = []
+    var interfaceStyle: UIUserInterfaceStyle?
 
     override init() {
         super.init()
@@ -52,17 +53,27 @@ class NativeIOSPlatform: HybridNativePlatformSpec {
     }
 
     func getColorScheme() -> ColorScheme {
-        let interfaceStyle = UIScreen.main.traitCollection.userInterfaceStyle
-
-        switch (interfaceStyle) {
-        case .dark:
-            return ColorScheme.dark
-        case .light:
-            return ColorScheme.light
-        case .unspecified:
-            return ColorScheme.unspecified
-        default:
-            return ColorScheme.unspecified
+        func getColorSchemeFn() -> ColorScheme {
+            let interfaceStyle = self.interfaceStyle ?? (RCTKeyWindow()?.traitCollection ?? UIScreen.main.traitCollection).userInterfaceStyle
+
+            switch (interfaceStyle) {
+            case .dark:
+                return ColorScheme.dark
+            case .light:
+                return ColorScheme.light
+            case .unspecified:
+                return ColorScheme.unspecified
+            default:
+                return ColorScheme.unspecified
+            }
+        }
+
+        if Thread.isMainThread {
+            return getColorSchemeFn()
+        }
+
+        return DispatchQueue.main.sync {
+            return getColorSchemeFn()
         }
     }
 

package/ios/NativePlatformListener+ios.swift

@@ -7,6 +7,15 @@ extension NativeIOSPlatform {
         let orientationPublisher = NotificationCenter.default.publisher(for: UIDevice.orientationDidChangeNotification)
         let colorSchemePublisher = NotificationCenter.default.publisher(for: NSNotification.Name("RCTUserInterfaceStyleDidChangeNotification"))
 
+        colorSchemePublisher
+            .sink { [weak self] notification in
+                if let traitCollection = notification.userInfo?["traitCollection"] as? UITraitCollection,
+                   traitCollection.userInterfaceStyle != .unspecified {
+                    self?.interfaceStyle = traitCollection.userInterfaceStyle
+                }
+            }
+            .store(in: &cancellables)
+
         Publishers
             .MergeMany([windowPublisher, orientationPublisher, colorSchemePublisher])
             .throttle(for: .milliseconds(25), scheduler: RunLoop.main, latest: true)

package/lib/commonjs/components/native/deep/ActivityIndicator.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ActivityIndicator", {
+  enumerable: true,
+  get: function () {
+    return _ActivityIndicator.ActivityIndicator;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _ActivityIndicator.ActivityIndicator;
+  }
+});
+var _ActivityIndicator = require("../ActivityIndicator");
+//# sourceMappingURL=ActivityIndicator.js.map

package/lib/commonjs/components/native/deep/ActivityIndicator.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_ActivityIndicator","require"],"sourceRoot":"../../../../../src","sources":["components/native/deep/ActivityIndicator.ts"],"mappings":";;;;;;;;;;;;;;;;;AACA,IAAAA,kBAAA,GAAAC,OAAA","ignoreList":[]}

package/lib/commonjs/components/native/deep/Animated.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Animated", {
+  enumerable: true,
+  get: function () {
+    return _Animated.Animated;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _Animated.Animated;
+  }
+});
+var _Animated = require("../Animated");
+//# sourceMappingURL=Animated.js.map

package/lib/commonjs/components/native/deep/Animated.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_Animated","require"],"sourceRoot":"../../../../../src","sources":["components/native/deep/Animated.ts"],"mappings":";;;;;;;;;;;;;;;;;AACA,IAAAA,SAAA,GAAAC,OAAA","ignoreList":[]}

package/lib/commonjs/components/native/deep/FlatList.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "FlatList", {
+  enumerable: true,
+  get: function () {
+    return _FlatList.FlatList;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _FlatList.FlatList;
+  }
+});
+var _FlatList = require("../FlatList");
+//# sourceMappingURL=FlatList.js.map

package/lib/commonjs/components/native/deep/FlatList.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_FlatList","require"],"sourceRoot":"../../../../../src","sources":["components/native/deep/FlatList.ts"],"mappings":";;;;;;;;;;;;;;;;;AACA,IAAAA,SAAA,GAAAC,OAAA","ignoreList":[]}

package/lib/commonjs/components/native/deep/Image.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Image", {
+  enumerable: true,
+  get: function () {
+    return _Image.Image;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _Image.Image;
+  }
+});
+var _Image = require("../Image");
+//# sourceMappingURL=Image.js.map

package/lib/commonjs/components/native/deep/Image.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_Image","require"],"sourceRoot":"../../../../../src","sources":["components/native/deep/Image.ts"],"mappings":";;;;;;;;;;;;;;;;;AACA,IAAAA,MAAA,GAAAC,OAAA","ignoreList":[]}

package/lib/commonjs/components/native/deep/ImageBackground.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ImageBackground", {
+  enumerable: true,
+  get: function () {
+    return _ImageBackground.ImageBackground;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _ImageBackground.ImageBackground;
+  }
+});
+var _ImageBackground = require("../ImageBackground");
+//# sourceMappingURL=ImageBackground.js.map

package/lib/commonjs/components/native/deep/ImageBackground.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_ImageBackground","require"],"sourceRoot":"../../../../../src","sources":["components/native/deep/ImageBackground.ts"],"mappings":";;;;;;;;;;;;;;;;;AACA,IAAAA,gBAAA,GAAAC,OAAA","ignoreList":[]}

package/lib/commonjs/components/native/deep/KeyboardAvoidingView.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "KeyboardAvoidingView", {
+  enumerable: true,
+  get: function () {
+    return _KeyboardAvoidingView.KeyboardAvoidingView;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _KeyboardAvoidingView.KeyboardAvoidingView;
+  }
+});
+var _KeyboardAvoidingView = require("../KeyboardAvoidingView");
+//# sourceMappingURL=KeyboardAvoidingView.js.map

package/lib/commonjs/components/native/deep/KeyboardAvoidingView.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_KeyboardAvoidingView","require"],"sourceRoot":"../../../../../src","sources":["components/native/deep/KeyboardAvoidingView.ts"],"mappings":";;;;;;;;;;;;;;;;;AACA,IAAAA,qBAAA,GAAAC,OAAA","ignoreList":[]}

package/lib/commonjs/components/native/deep/Pressable.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Pressable", {
+  enumerable: true,
+  get: function () {
+    return _Pressable.Pressable;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _Pressable.Pressable;
+  }
+});
+var _Pressable = require("../Pressable");
+//# sourceMappingURL=Pressable.js.map

package/lib/commonjs/components/native/deep/Pressable.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_Pressable","require"],"sourceRoot":"../../../../../src","sources":["components/native/deep/Pressable.ts"],"mappings":";;;;;;;;;;;;;;;;;AACA,IAAAA,UAAA,GAAAC,OAAA","ignoreList":[]}

package/lib/commonjs/components/native/deep/RefreshControl.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "RefreshControl", {
+  enumerable: true,
+  get: function () {
+    return _RefreshControl.RefreshControl;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _RefreshControl.RefreshControl;
+  }
+});
+var _RefreshControl = require("../RefreshControl");
+//# sourceMappingURL=RefreshControl.js.map

package/lib/commonjs/components/native/deep/RefreshControl.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_RefreshControl","require"],"sourceRoot":"../../../../../src","sources":["components/native/deep/RefreshControl.ts"],"mappings":";;;;;;;;;;;;;;;;;AACA,IAAAA,eAAA,GAAAC,OAAA","ignoreList":[]}

package/lib/commonjs/components/native/deep/SafeAreaView.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "SafeAreaView", {
+  enumerable: true,
+  get: function () {
+    return _SafeAreaView.SafeAreaView;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _SafeAreaView.SafeAreaView;
+  }
+});
+var _SafeAreaView = require("../SafeAreaView");
+//# sourceMappingURL=SafeAreaView.js.map

package/lib/commonjs/components/native/deep/SafeAreaView.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_SafeAreaView","require"],"sourceRoot":"../../../../../src","sources":["components/native/deep/SafeAreaView.ts"],"mappings":";;;;;;;;;;;;;;;;;AACA,IAAAA,aAAA,GAAAC,OAAA","ignoreList":[]}

package/lib/commonjs/components/native/deep/ScrollView.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ScrollView", {
+  enumerable: true,
+  get: function () {
+    return _ScrollView.ScrollView;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _ScrollView.ScrollView;
+  }
+});
+var _ScrollView = require("../ScrollView");
+//# sourceMappingURL=ScrollView.js.map

package/lib/commonjs/components/native/deep/ScrollView.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_ScrollView","require"],"sourceRoot":"../../../../../src","sources":["components/native/deep/ScrollView.ts"],"mappings":";;;;;;;;;;;;;;;;;AACA,IAAAA,WAAA,GAAAC,OAAA","ignoreList":[]}