first commit

node_modules/react-native/ReactCommon/react/renderer/element/Element.h

@@ -0,0 +1,166 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <functional>
+#include <memory>
+
+#include <react/renderer/core/ShadowNode.h>
+
+#include <react/renderer/element/ElementFragment.h>
+
+namespace facebook::react {
+
+/*
+ * `Element<>` is an abstraction layer that allows describing component
+ * hierarchy in a declarative way. Creating `Element`s themself does not create
+ * a component tree (aka `ShadowNode` tree) but describes some hierarchical
+ * structure that might be used to build an actual component tree (similar to
+ * XML Elements).
+ * `Element` provides some basic type-safety guarantees: all modifications
+ * of element objects require using objects (such as Props or State) of
+ * compatible type.
+ */
+template <typename ShadowNodeT>
+class Element final {
+ public:
+  using ConcreteProps = typename ShadowNodeT::ConcreteProps;
+  using SharedConcreteProps = std::shared_ptr<const ConcreteProps>;
+  using ConcreteState = typename ShadowNodeT::ConcreteState;
+  using ConcreteStateData = typename ShadowNodeT::ConcreteStateData;
+  using SharedConcreteState = std::shared_ptr<const ConcreteState>;
+  using ConcreteShadowNode = ShadowNodeT;
+  using ConcreteUnsharedShadowNode = std::shared_ptr<ConcreteShadowNode>;
+
+  using ConcreteReferenceCallback = std::function<void(const std::shared_ptr<const ShadowNodeT> &shadowNode)>;
+
+  /*
+   * Constructs an `Element`.
+   */
+  Element()
+  {
+    fragment_.componentHandle = ShadowNodeT::Handle();
+    fragment_.componentName = ShadowNodeT::Name();
+    fragment_.props = ShadowNodeT::defaultSharedProps();
+  }
+
+  /*
+   * Converts to `ElementFragment` object.
+   */
+  operator ElementFragment()
+  {
+    return fragment_;
+  }
+
+  /*
+   * Sets `tag`.
+   */
+  Element &tag(Tag tag)
+  {
+    fragment_.tag = tag;
+    return *this;
+  }
+
+  /*
+   * Sets `surfaceId`.
+   */
+  Element &surfaceId(SurfaceId surfaceId)
+  {
+    fragment_.surfaceId = surfaceId;
+    return *this;
+  }
+
+  /*
+   * Sets `props`.
+   */
+  Element &props(SharedConcreteProps props)
+  {
+    fragment_.props = props;
+    return *this;
+  }
+
+  /*
+   * Sets `props` using callback.
+   */
+  Element &props(std::function<SharedConcreteProps()> callback)
+  {
+    fragment_.props = callback();
+    return *this;
+  }
+
+  /*
+   * Sets `state` using callback.
+   */
+  Element &stateData(std::function<void(ConcreteStateData &)> callback)
+  {
+    fragment_.stateCallback = [callback = std::move(callback)](const State::Shared &state) -> StateData::Shared {
+      auto stateData = static_cast<const ConcreteState *>(state.get())->getData();
+      callback(stateData);
+      return std::make_shared<ConcreteStateData>(stateData);
+    };
+    return *this;
+  }
+
+  /*
+   * Sets children.
+   */
+  Element &children(std::vector<ElementFragment> children)
+  {
+    auto fragments = ElementFragment::List{};
+    fragments.reserve(children.size());
+    for (const auto &child : children) {
+      fragments.push_back(child);
+    }
+    fragment_.children = fragments;
+    return *this;
+  }
+
+  /*
+   * Calls the callback during component construction with a pointer to the
+   * component which is being constructed.
+   */
+  Element &reference(std::function<void(const ConcreteUnsharedShadowNode &shadowNode)> callback)
+  {
+    fragment_.referenceCallback = [callback =
+                                       std::move(callback)](const std::shared_ptr<const ShadowNode> &shadowNode) {
+      callback(
+          std::const_pointer_cast<ConcreteShadowNode>(std::static_pointer_cast<const ConcreteShadowNode>(shadowNode)));
+    };
+    return *this;
+  }
+
+  /*
+   * During component construction, assigns a given pointer to a component
+   * that is being constructed.
+   */
+  Element &reference(ConcreteUnsharedShadowNode &outShadowNode)
+  {
+    fragment_.referenceCallback = [&](const std::shared_ptr<const ShadowNode> &shadowNode) {
+      outShadowNode =
+          std::const_pointer_cast<ConcreteShadowNode>(std::static_pointer_cast<const ConcreteShadowNode>(shadowNode));
+    };
+    return *this;
+  }
+
+  /*
+   * Calls the callback with a reference to a just constructed component.
+   */
+  Element &finalize(std::function<void(ConcreteShadowNode &shadowNode)> finalizeCallback)
+  {
+    fragment_.finalizeCallback = [=](ShadowNode &shadowNode) {
+      return finalizeCallback(static_cast<ConcreteShadowNode &>(shadowNode));
+    };
+    return *this;
+  }
+
+ private:
+  friend class ComponentBuilder;
+  ElementFragment fragment_;
+};
+
+} // namespace facebook::react