nitrogen 0.2.24 → 0.29.5

package/src/views/CppHybridViewComponent.ts

@@ -0,0 +1,304 @@
+import type { SourceFile } from '../syntax/SourceFile.js'
+import type { HybridObjectSpec } from '../syntax/HybridObjectSpec.js'
+import { createIndentation, indent } from '../utils.js'
+import {
+  createFileMetadataString,
+  escapeCppName,
+  isFunction,
+  isNotDuplicate,
+} from '../syntax/helpers.js'
+import { getHybridObjectName } from '../syntax/getHybridObjectName.js'
+import { includeHeader } from '../syntax/c++/includeNitroHeader.js'
+import { createHostComponentJs } from './createHostComponentJs.js'
+import { Property } from '../syntax/Property.js'
+import { FunctionType } from '../syntax/types/FunctionType.js'
+import { VoidType } from '../syntax/types/VoidType.js'
+import { HybridObjectType } from '../syntax/types/HybridObjectType.js'
+import { NamedWrappingType } from '../syntax/types/NamedWrappingType.js'
+import { OptionalType } from '../syntax/types/OptionalType.js'
+
+interface ViewComponentNames {
+  propsClassName: `${string}Props`
+  stateClassName: `${string}State`
+  nameVariable: `${string}ComponentName`
+  shadowNodeClassName: `${string}ShadowNode`
+  descriptorClassName: `${string}ComponentDescriptor`
+  component: `${string}Component`
+  manager: `${string}Manager`
+}
+
+export function getViewComponentNames(
+  spec: HybridObjectSpec
+): ViewComponentNames {
+  const name = getHybridObjectName(spec.name)
+  return {
+    propsClassName: `${name.HybridT}Props`,
+    stateClassName: `${name.HybridT}State`,
+    nameVariable: `${name.HybridT}ComponentName`,
+    shadowNodeClassName: `${name.HybridT}ShadowNode`,
+    descriptorClassName: `${name.HybridT}ComponentDescriptor`,
+    component: `${name.HybridT}Component`,
+    manager: `${name.HybridT}Manager`,
+  }
+}
+
+function getHybridRefProperty(spec: HybridObjectSpec): Property {
+  const hybrid = new HybridObjectType(spec)
+  const type = new FunctionType(new VoidType(), [
+    new NamedWrappingType('ref', hybrid),
+  ])
+  return new Property('hybridRef', new OptionalType(type), false)
+}
+
+export function createViewComponentShadowNodeFiles(
+  spec: HybridObjectSpec
+): SourceFile[] {
+  if (!spec.isHybridView) {
+    throw new Error(
+      `Cannot create View Component ShadowNode code for ${spec.name} - it's not a HybridView!`
+    )
+  }
+
+  const { T, HybridT } = getHybridObjectName(spec.name)
+  const {
+    propsClassName,
+    stateClassName,
+    nameVariable,
+    shadowNodeClassName,
+    descriptorClassName,
+    component,
+  } = getViewComponentNames(spec)
+
+  const namespace = spec.config.getCxxNamespace('c++', 'views')
+
+  const props = [...spec.properties, getHybridRefProperty(spec)]
+  const properties = props.map(
+    (p) => `CachedProp<${p.type.getCode('c++')}> ${escapeCppName(p.name)};`
+  )
+  const cases = props.map((p) => `case hashString("${p.name}"): return true;`)
+  const includes = props
+    .flatMap((p) =>
+      p.getRequiredImports('c++').map((i) => includeHeader(i, true))
+    )
+    .filter(isNotDuplicate)
+
+  // .hpp code
+  const shadowIndent = createIndentation(shadowNodeClassName.length)
+  const componentHeaderCode = `
+${createFileMetadataString(`${component}.hpp`)}
+
+#pragma once
+
+#include <optional>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/CachedProp.hpp>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+${includes.join('\n')}
+
+namespace ${namespace} {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char ${nameVariable}[];
+
+  /**
+   * Props for the "${spec.name}" View.
+   */
+  class ${propsClassName} final: public react::ViewProps {
+  public:
+    ${propsClassName}() = default;
+    ${propsClassName}(const ${propsClassName}&);
+    ${propsClassName}(const react::PropsParserContext& context,
+  ${createIndentation(propsClassName.length)}   const ${propsClassName}& sourceProps,
+  ${createIndentation(propsClassName.length)}   const react::RawProps& rawProps);
+
+  public:
+    ${indent(properties.join('\n'), '    ')}
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "${spec.name}" View.
+   */
+  class ${stateClassName} final {
+  public:
+    ${stateClassName}() = default;
+
+  public:
+    void setProps(const ${propsClassName}& props) { _props.emplace(props); }
+    const std::optional<${propsClassName}>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  ${stateClassName}(const ${stateClassName}& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("${stateClassName} does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("${stateClassName} does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<${propsClassName}> _props;
+  };
+
+  /**
+   * The Shadow Node for the "${spec.name}" View.
+   */
+  using ${shadowNodeClassName} = react::ConcreteViewShadowNode<${nameVariable} /* "${HybridT}" */,
+        ${shadowIndent}                                 ${propsClassName} /* custom props */,
+        ${shadowIndent}                                 react::ViewEventEmitter /* default */,
+        ${shadowIndent}                                 ${stateClassName} /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "${spec.name}" View.
+   */
+  class ${descriptorClassName} final: public react::ConcreteComponentDescriptor<${shadowNodeClassName}> {
+  public:
+    ${descriptorClassName}(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from \`${propsClassName}\`.
+     */
+    std::shared_ptr<const react::Props> cloneProps(const react::PropsParserContext& context,
+                                                   const std::shared_ptr<const react::Props>& props,
+                                                   react::RawProps rawProps) const override;
+#ifdef ANDROID
+    void adopt(react::ShadowNode& shadowNode) const override;
+#endif
+  };
+
+  /* The actual view for "${spec.name}" needs to be implemented in platform-specific code. */
+
+} // namespace ${namespace}
+`.trim()
+
+  // .cpp code
+  const propInitializers = [
+    'react::ViewProps(context, sourceProps, rawProps, filterObjectKeys)',
+  ]
+  const propCopyInitializers = ['react::ViewProps()']
+  for (const prop of props) {
+    const name = escapeCppName(prop.name)
+    const type = prop.type.getCode('c++')
+
+    let valueConversion = `value`
+    if (isFunction(prop.type)) {
+      // Due to a React limitation, functions cannot be passed to native directly,
+      // because RN converts them to booleans (`true`). Nitro knows this and just
+      // wraps functions as objects - the original function is stored in `f`.
+      valueConversion = `value.asObject(*runtime).getProperty(*runtime, "f")`
+    }
+
+    propInitializers.push(
+      `
+${name}([&]() -> CachedProp<${type}> {
+  try {
+    const react::RawValue* rawValue = rawProps.at("${prop.name}", nullptr, nullptr);
+    if (rawValue == nullptr) return sourceProps.${name};
+    const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+    return CachedProp<${type}>::fromRawValue(*runtime, ${valueConversion}, sourceProps.${name});
+  } catch (const std::exception& exc) {
+    throw std::runtime_error(std::string("${spec.name}.${prop.name}: ") + exc.what());
+  }
+}())`.trim()
+    )
+    propCopyInitializers.push(`${name}(other.${name})`)
+  }
+
+  const ctorIndent = createIndentation(propsClassName.length * 2)
+  const descriptorIndent = createIndentation(descriptorClassName.length)
+  const componentCode = `
+${createFileMetadataString(`${component}.cpp`)}
+
+#include "${component}.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.hpp>
+#include <react/renderer/core/RawValue.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+namespace ${namespace} {
+
+  extern const char ${nameVariable}[] = "${T}";
+
+  ${propsClassName}::${propsClassName}(const react::PropsParserContext& context,
+  ${ctorIndent}   const ${propsClassName}& sourceProps,
+  ${ctorIndent}   const react::RawProps& rawProps):
+    ${indent(propInitializers.join(',\n'), '    ')} { }
+
+  ${propsClassName}::${propsClassName}(const ${propsClassName}& other):
+    ${indent(propCopyInitializers.join(',\n'), '    ')} { }
+
+  bool ${propsClassName}::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      ${indent(cases.join('\n'), '      ')}
+      default: return false;
+    }
+  }
+
+  ${descriptorClassName}::${descriptorClassName}(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> ${descriptorClassName}::cloneProps(const react::PropsParserContext& context,
+                                      ${descriptorIndent}             const std::shared_ptr<const react::Props>& props,
+                                      ${descriptorIndent}             react::RawProps rawProps) const {
+    // 1. Prepare raw props parser
+    rawProps.parse(rawPropsParser_);
+    // 2. Copy props with Nitro's cached copy constructor
+    return ${shadowNodeClassName}::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void ${descriptorClassName}::adopt(react::ShadowNode& shadowNode) const {
+    // This is called immediately after \`ShadowNode\` is created, cloned or in progress.
+    // On Android, we need to wrap props in our state, which gets routed through Java and later unwrapped in JNI/C++.
+    auto& concreteShadowNode = dynamic_cast<${shadowNodeClassName}&>(shadowNode);
+    const ${propsClassName}& props = concreteShadowNode.getConcreteProps();
+    ${stateClassName} state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace ${namespace}
+`.trim()
+
+  const files: SourceFile[] = [
+    {
+      name: `${component}.hpp`,
+      content: componentHeaderCode,
+      language: 'c++',
+      platform: 'shared',
+      subdirectory: ['views'],
+    },
+    {
+      name: `${component}.cpp`,
+      content: componentCode,
+      language: 'c++',
+      platform: 'shared',
+      subdirectory: ['views'],
+    },
+  ]
+  const jsFiles = createHostComponentJs(spec)
+  files.push(...(jsFiles as unknown as SourceFile[]))
+  return files
+}

package/src/views/createHostComponentJs.ts

@@ -0,0 +1,34 @@
+import type { Language } from '../getPlatformSpecs.js'
+import type { HybridObjectSpec } from '../syntax/HybridObjectSpec.js'
+import type { SourceFile } from '../syntax/SourceFile.js'
+import { getHybridObjectName } from '../syntax/getHybridObjectName.js'
+import { indent } from '../utils.js'
+
+export function createHostComponentJs(spec: HybridObjectSpec): SourceFile[] {
+  const { T } = getHybridObjectName(spec.name)
+
+  const props = spec.properties.map((p) => `"${p.name}": true`)
+  props.push(`"hybridRef": true`)
+
+  const code = `
+{
+  "uiViewClassName": "${T}",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    ${indent(props.join(',\n'), '    ')}
+  }
+}
+  `.trim()
+
+  return [
+    {
+      content: code,
+      language: 'json' as Language,
+      name: `${T}Config.json`,
+      platform: 'shared',
+      subdirectory: [],
+    },
+  ]
+}

package/src/views/kotlin/KotlinHybridViewManager.ts

@@ -0,0 +1,258 @@
+import type { SourceFile } from '../../syntax/SourceFile.js'
+import type { HybridObjectSpec } from '../../syntax/HybridObjectSpec.js'
+import {
+  createViewComponentShadowNodeFiles,
+  getViewComponentNames,
+} from '../CppHybridViewComponent.js'
+import {
+  createFileMetadataString,
+  escapeCppName,
+} from '../../syntax/helpers.js'
+import { getHybridObjectName } from '../../syntax/getHybridObjectName.js'
+import { addJNINativeRegistration } from '../../syntax/kotlin/JNINativeRegistrations.js'
+import { indent } from '../../utils.js'
+
+export function createKotlinHybridViewManager(
+  spec: HybridObjectSpec
+): SourceFile[] {
+  const cppFiles = createViewComponentShadowNodeFiles(spec)
+  const javaSubNamespace = spec.config.getAndroidPackage('java/kotlin', 'views')
+  const javaNamespace = spec.config.getAndroidPackage('java/kotlin')
+  const cxxNamespace = spec.config.getCxxNamespace('c++', 'views')
+  const { JHybridTSpec, HybridTSpec } = getHybridObjectName(spec.name)
+  const {
+    manager,
+    stateClassName,
+    component,
+    propsClassName,
+    descriptorClassName,
+  } = getViewComponentNames(spec)
+  const stateUpdaterName = `${stateClassName}Updater`
+  const autolinking = spec.config.getAutolinkedHybridObjects()
+  const viewImplementation = autolinking[spec.name]?.kotlin
+  if (viewImplementation == null) {
+    throw new Error(
+      `Cannot create Kotlin HybridView ViewManager for ${spec.name} - it is not autolinked in nitro.json!`
+    )
+  }
+
+  const viewManagerCode = `
+${createFileMetadataString(`${manager}.kt`)}
+
+package ${javaSubNamespace}
+
+import android.view.View
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import ${javaNamespace}.*
+
+/**
+ * Represents the React Native \`ViewManager\` for the "${spec.name}" Nitro HybridView.
+ */
+class ${manager}: SimpleViewManager<View>() {
+  private val views = hashMapOf<View, ${viewImplementation}>()
+
+  override fun getName(): String {
+    return "${spec.name}"
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): View {
+    val hybridView = ${viewImplementation}(reactContext)
+    val view = hybridView.view
+    views[view] = hybridView
+    return view
+  }
+
+  override fun onDropViewInstance(view: View) {
+    super.onDropViewInstance(view)
+    views.remove(view)
+  }
+
+  override fun updateState(view: View, props: ReactStylesDiffMap, stateWrapper: StateWrapper): Any? {
+    val hybridView = views[view] ?: throw Error("Couldn't find view $view in local views table!")
+
+    // 1. Update each prop individually
+    hybridView.beforeUpdate()
+    ${stateUpdaterName}.updateViewProps(hybridView, stateWrapper)
+    hybridView.afterUpdate()
+
+    // 2. Continue in base View props
+    return super.updateState(view, props, stateWrapper)
+  }
+}
+  `.trim()
+
+  const updaterKotlinCode = `
+${createFileMetadataString(`${stateUpdaterName}.kt`)}
+
+package ${javaSubNamespace}
+
+import com.facebook.react.uimanager.StateWrapper
+import ${javaNamespace}.*
+
+internal class ${stateUpdaterName} {
+  companion object {
+    /**
+     * Updates the props for [view] through C++.
+     * The [state] prop is expected to contain [view]'s props as wrapped Fabric state.
+     */
+    @Suppress("KotlinJniMissingFunction")
+    @JvmStatic
+    external fun updateViewProps(view: ${HybridTSpec}, state: StateWrapper)
+  }
+}
+  `.trim()
+
+  const updaterJniDescriptor = spec.config.getAndroidPackage(
+    'c++/jni',
+    'views',
+    stateUpdaterName
+  )
+  const updaterJniHeaderCode = `
+${createFileMetadataString(`J${stateUpdaterName}.hpp`)}
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/fabric/CoreComponentsRegistry.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "${JHybridTSpec}.hpp"
+#include "views/${component}.hpp"
+
+namespace ${cxxNamespace} {
+
+using namespace facebook;
+
+class J${stateUpdaterName}: public jni::JavaClass<J${stateUpdaterName}> {
+public:
+  static constexpr auto kJavaDescriptor = "L${updaterJniDescriptor};";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<${JHybridTSpec}::javaobject> view,
+                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", J${stateUpdaterName}::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<${descriptorClassName}>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace ${cxxNamespace}
+  `.trim()
+
+  const propsUpdaterCalls = spec.properties.map((p) => {
+    const name = escapeCppName(p.name)
+    const setter = p.getSetterName('other')
+    return `
+if (props.${name}.isDirty) {
+  view->${setter}(props.${name}.value);
+  // TODO: Set isDirty = false
+}
+    `.trim()
+  })
+  const updaterJniCppCode = `
+${createFileMetadataString(`J${stateUpdaterName}.cpp`)}
+
+#include "J${stateUpdaterName}.hpp"
+#include "views/${component}.hpp"
+#include <NitroModules/NitroDefines.hpp>
+
+namespace ${cxxNamespace} {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<${stateClassName}>;
+
+void J${stateUpdaterName}::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<${JHybridTSpec}::javaobject> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
+  ${JHybridTSpec}* view = javaView->cthis();
+
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapperInterface.get();
+  if (!stateWrapperInterface->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) {
+      throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapper = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+            static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)};
+
+  std::shared_ptr<const react::State> state = stateWrapper->cthis()->getState();
+  auto concreteState = std::dynamic_pointer_cast<const ConcreteStateData>(state);
+  const ${stateClassName}& data = concreteState->getData();
+  const std::optional<${propsClassName}>& maybeProps = data.getProps();
+  if (!maybeProps.has_value()) {
+    // Props aren't set yet!
+    throw std::runtime_error("${stateClassName}'s data doesn't contain any props!");
+  }
+  const ${propsClassName}& props = maybeProps.value();
+  ${indent(propsUpdaterCalls.join('\n'), '  ')}
+
+  // Update hybridRef if it changed
+  if (props.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = props.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      std::shared_ptr<${JHybridTSpec}> shared = javaView->cthis()->shared_cast<${JHybridTSpec}>();
+      maybeFunc.value()(shared);
+    }
+    // TODO: Set isDirty = false
+  }
+}
+
+} // namespace ${cxxNamespace}
+`.trim()
+
+  addJNINativeRegistration({
+    namespace: cxxNamespace,
+    className: `J${stateUpdaterName}`,
+    import: {
+      name: `views/J${stateUpdaterName}.hpp`,
+      space: 'user',
+      language: 'c++',
+    },
+  })
+
+  return [
+    ...cppFiles,
+    {
+      content: viewManagerCode,
+      language: 'kotlin',
+      name: `${manager}.kt`,
+      platform: 'android',
+      subdirectory: [...javaSubNamespace.split('.')],
+    },
+    {
+      content: updaterKotlinCode,
+      language: 'kotlin',
+      name: `${stateUpdaterName}.kt`,
+      platform: 'android',
+      subdirectory: [...javaSubNamespace.split('.')],
+    },
+    {
+      content: updaterJniHeaderCode,
+      language: 'c++',
+      name: `J${stateUpdaterName}.hpp`,
+      platform: 'android',
+      subdirectory: ['views'],
+    },
+    {
+      content: updaterJniCppCode,
+      language: 'c++',
+      name: `J${stateUpdaterName}.cpp`,
+      platform: 'android',
+      subdirectory: ['views'],
+    },
+  ]
+}