nitrogen 0.2.23 → 0.29.4

package/lib/utils.js

@@ -0,0 +1,126 @@
+import path from 'path';
+import fs from 'fs';
+import { isNotDuplicate } from './syntax/helpers.js';
+import { readUserConfig } from './config/getConfig.js';
+import { NitroConfig } from './config/NitroConfig.js';
+export const NITROGEN_VERSION = process.env.npm_package_version ?? '?.?.?';
+export function capitalizeName(name) {
+    if (name.length === 0)
+        return name;
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+export function createIndentation(spacesCount) {
+    return Array.from(Array(spacesCount)).fill(' ').join('');
+}
+export function indent(string, indentation) {
+    let spaces;
+    if (typeof indentation === 'number') {
+        spaces = createIndentation(indentation);
+    }
+    else {
+        spaces = indentation;
+    }
+    return string.replaceAll('\n', `\n${spaces}`);
+}
+export function errorToString(error) {
+    if (error == null) {
+        return `null`;
+    }
+    if (typeof error !== 'object') {
+        return `${error}`;
+    }
+    if (error instanceof Error) {
+        let message = `${error.name}: ${error.message}`;
+        if (error.cause != null) {
+            message += ` (cause: ${JSON.stringify(error.cause)})`;
+        }
+        return message;
+    }
+    if ('toString' in error) {
+        return error.toString();
+    }
+    return JSON.stringify(error);
+}
+export function escapeComments(string) {
+    return string
+        .replace(/\/\*/g, '/ *') // Escape start of comment
+        .replace(/\*\//g, '* /') // Escape end of comment
+        .replace(/\/\//g, '/ /'); // Escape single-line comment
+}
+const HAS_UNIX_PATHS = path.join('a', 'b').includes('/');
+export function toUnixPath(p) {
+    if (HAS_UNIX_PATHS)
+        return p;
+    return p.replaceAll('\\', '/');
+}
+const sep = path.sep;
+export function unsafeFastJoin(...segments) {
+    // this function should really not take any unsafe strings like `/` or `\`.
+    return segments.join(sep);
+}
+function getFullPath(file) {
+    return unsafeFastJoin(file.platform, file.language, ...file.subdirectory, file.name);
+}
+/**
+ * Deduplicates all files via their full path.
+ * If content differs, you are f*cked.
+ */
+export function deduplicateFiles(files) {
+    const map = new Map();
+    for (const file of files) {
+        const filePath = getFullPath(file);
+        if (!map.has(filePath)) {
+            map.set(filePath, file);
+        }
+    }
+    return [...map.values()];
+}
+export function filterDuplicateHelperBridges(bridge, i, array) {
+    const otherIndex = array.findIndex((f2) => bridge.specializationName === f2.specializationName);
+    return otherIndex === i;
+}
+export function toLowerCamelCase(string) {
+    const parts = string.split('_').filter((part) => part !== '');
+    if (parts.length === 0)
+        return '';
+    const camelCaseString = parts[0].toLowerCase();
+    const camelCased = parts
+        .slice(1)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase());
+    return camelCaseString + camelCased.join('');
+}
+export function getBaseTypes(type) {
+    const baseTypes = type.getBaseTypes();
+    const symbol = type.getSymbol();
+    if (symbol != null) {
+        baseTypes.push(...symbol.getDeclaredType().getBaseTypes());
+    }
+    const recursive = baseTypes.flatMap((b) => [b, ...getBaseTypes(b)]);
+    return recursive.filter(isNotDuplicate);
+}
+export function getHybridObjectNitroModuleConfig(type) {
+    const symbol = type.getSymbol() ?? type.getAliasSymbol();
+    if (!symbol)
+        return undefined;
+    const declarations = symbol.getValueDeclaration() || symbol.getDeclarations()[0];
+    if (!declarations)
+        return undefined;
+    const sourceFile = declarations.getSourceFile();
+    let filePath = sourceFile.getFilePath();
+    while (true) {
+        // go up one dir
+        const newFilePath = path.resolve(path.join(filePath, '..'));
+        if (filePath === newFilePath) {
+            // going 'cd ..' in that path didn't change a thing - so we
+            // reached the root directory. we didn't find a nitro.json anywhere.
+            return undefined;
+        }
+        filePath = newFilePath;
+        const nitroJsonPath = path.join(filePath, 'nitro.json');
+        const hasNitroJson = fs.existsSync(nitroJsonPath);
+        if (hasNitroJson) {
+            const config = readUserConfig(nitroJsonPath);
+            return new NitroConfig(config);
+        }
+    }
+}

package/lib/views/CppHybridViewComponent.d.ts

@@ -0,0 +1,14 @@
+import type { SourceFile } from '../syntax/SourceFile.js';
+import type { HybridObjectSpec } from '../syntax/HybridObjectSpec.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 declare function getViewComponentNames(spec: HybridObjectSpec): ViewComponentNames;
+export declare function createViewComponentShadowNodeFiles(spec: HybridObjectSpec): SourceFile[];
+export {};

package/lib/views/CppHybridViewComponent.js

@@ -0,0 +1,254 @@
+import { createIndentation, indent } from '../utils.js';
+import { createFileMetadataString, escapeCppName, isFunction, } 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';
+export function getViewComponentNames(spec) {
+    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) {
+    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) {
+    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)));
+    // .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 = [
+        {
+            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);
+    return files;
+}

package/lib/views/createHostComponentJs.d.ts

@@ -0,0 +1,3 @@
+import type { HybridObjectSpec } from '../syntax/HybridObjectSpec.js';
+import type { SourceFile } from '../syntax/SourceFile.js';
+export declare function createHostComponentJs(spec: HybridObjectSpec): SourceFile[];

package/lib/views/createHostComponentJs.js

@@ -0,0 +1,27 @@
+import { getHybridObjectName } from '../syntax/getHybridObjectName.js';
+import { indent } from '../utils.js';
+export function createHostComponentJs(spec) {
+    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',
+            name: `${T}Config.json`,
+            platform: 'shared',
+            subdirectory: [],
+        },
+    ];
+}

package/lib/views/kotlin/KotlinHybridViewManager.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+import type { HybridObjectSpec } from '../../syntax/HybridObjectSpec.js';
+export declare function createKotlinHybridViewManager(spec: HybridObjectSpec): SourceFile[];

package/lib/views/kotlin/KotlinHybridViewManager.js

@@ -0,0 +1,229 @@
+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) {
+    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'],
+        },
+    ];
+}

package/lib/views/swift/SwiftHybridViewManager.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+import type { HybridObjectSpec } from '../../syntax/HybridObjectSpec.js';
+export declare function createSwiftHybridViewManager(spec: HybridObjectSpec): SourceFile[];