expo-modules-core 1.11.13 → 1.12.1

package/common/cpp/LazyObject.h

@@ -32,10 +32,23 @@ public:
 
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
+  /**
+   If the given object is a host object of type `LazyObject`, it returns its backed object.
+   Otherwise, the given object is returned back.
+   */
+  static const jsi::Object &unwrapObjectIfNecessary(jsi::Runtime &runtime, const jsi::Object &object);
+
 private:
   const LazyObjectInitializer initializer;
   std::shared_ptr<jsi::Object> backedObject;
 
+  /**
+   Initializes the backed object. It shouldn't be invoked more than once, so first make sure that `backedObject` is a null pointer.
+   */
+  inline void initializeBackedObject(jsi::Runtime &runtime) {
+    backedObject = initializer(runtime);
+  }
+
 }; // class LazyObject
 
 } // namespace expo

package/common/cpp/NativeModule.cpp

@@ -0,0 +1,16 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+#include "JSIUtils.h"
+#include "EventEmitter.h"
+#include "NativeModule.h"
+
+namespace expo::NativeModule {
+
+void installClass(jsi::Runtime &runtime) {
+  jsi::Function eventEmitterClass = EventEmitter::getClass(runtime);
+  jsi::Function nativeModuleClass = common::createInheritingClass(runtime, "NativeModule", eventEmitterClass);
+
+  common::getCoreObject(runtime).setProperty(runtime, "NativeModule", nativeModuleClass);
+}
+
+} // namespace expo::NativeModule

package/common/cpp/NativeModule.h

@@ -0,0 +1,34 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+#pragma once
+
+#ifdef __cplusplus
+
+#include <jsi/jsi.h>
+
+namespace jsi = facebook::jsi;
+
+namespace expo::NativeModule {
+
+/**
+ Gets `expo.NativeModule` class in the given runtime.
+ */
+inline jsi::Function getClass(jsi::Runtime &runtime) {
+  return common::getCoreObject(runtime).getPropertyAsFunction(runtime, "NativeModule");
+}
+
+/**
+ Installs `expo.NativeModule` class in the given runtime.
+ */
+void installClass(jsi::Runtime &runtime);
+
+/**
+ Creates a new instance of the native module.
+ */
+inline jsi::Object createInstance(jsi::Runtime &runtime) {
+  return getClass(runtime).callAsConstructor(runtime).getObject(runtime);
+}
+
+} // namespace expo::NativeModule
+
+#endif // __cplusplus

package/common/cpp/ObjectDeallocator.cpp

@@ -8,14 +8,12 @@ namespace expo::common {
 void setDeallocator(
   jsi::Runtime &runtime,
   const std::shared_ptr<jsi::Object> &jsThis,
-  ObjectDeallocator::Block deallocatorBlock,
-  const std::string &key
+  ObjectDeallocator::Block deallocatorBlock
 ) {
-  std::shared_ptr<ObjectDeallocator> hostObjectPtr = std::make_shared<ObjectDeallocator>(
+  std::shared_ptr<ObjectDeallocator> objectDeallocator = std::make_shared<ObjectDeallocator>(
     deallocatorBlock
   );
-  jsi::Object jsDeallocator = jsi::Object::createFromHostObject(runtime, hostObjectPtr);
-  jsThis->setProperty(runtime, key.c_str(), jsi::Value(runtime, jsDeallocator));
+  jsThis->setNativeState(runtime, objectDeallocator);
 }
 
 } // namespace expo::common

package/common/cpp/ObjectDeallocator.h

@@ -8,7 +8,7 @@ namespace jsi = facebook::jsi;
 
 namespace expo::common {
 
-class JSI_EXPORT ObjectDeallocator : public jsi::HostObject {
+class JSI_EXPORT ObjectDeallocator : public jsi::NativeState {
 public:
   typedef std::function<void()> Block;
 
@@ -28,8 +28,7 @@ public:
 void setDeallocator(
   jsi::Runtime &runtime,
   const std::shared_ptr<jsi::Object> &jsThis,
-  ObjectDeallocator::Block deallocatorBlock,
-  const std::string &key = "__expo_object_deallocator__"
+  ObjectDeallocator::Block deallocatorBlock
 );
 
 } // namespace expo::common

package/common/cpp/SharedObject.cpp

@@ -0,0 +1,69 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+#include "SharedObject.h"
+#include "JSIUtils.h"
+
+namespace expo::SharedObject {
+
+#pragma mark - NativeState
+
+NativeState::NativeState(const ObjectId objectId, const ObjectReleaser releaser)
+: EventEmitter::NativeState(), objectId(objectId), releaser(releaser) {}
+
+NativeState::~NativeState() {
+  releaser(objectId);
+}
+
+#pragma mark - Utils
+
+void installBaseClass(jsi::Runtime &runtime, const ObjectReleaser releaser) {
+  jsi::Function baseClass = EventEmitter::getClass(runtime);
+  jsi::Function klass = expo::common::createInheritingClass(runtime, "SharedObject", baseClass);
+  jsi::Object prototype = klass.getPropertyAsObject(runtime, "prototype");
+
+  jsi::Function releaseFunction = jsi::Function::createFromHostFunction(
+    runtime,
+    jsi::PropNameID::forAscii(runtime, "release"),
+    1,
+    [releaser](jsi::Runtime &runtime, const jsi::Value &thisValue, const jsi::Value *args, size_t count) -> jsi::Value {
+      jsi::Object thisObject = thisValue.getObject(runtime);
+
+      if (thisObject.hasNativeState<NativeState>(runtime)) {
+        auto nativeState = thisObject.getNativeState<NativeState>(runtime);
+
+        releaser(nativeState->objectId);
+
+        // Should we reset the native state?
+        thisObject.setNativeState(runtime, nullptr);
+      }
+      return jsi::Value::undefined();
+    });
+
+  prototype.setProperty(runtime, "release", releaseFunction);
+
+  // This property should be deprecated, but it's still used when passing as a view prop.
+  defineProperty(runtime, &prototype, "__expo_shared_object_id__", common::PropertyDescriptor {
+    .get = [](jsi::Runtime &runtime, jsi::Object thisObject) {
+      if (thisObject.hasNativeState<NativeState>(runtime)) {
+        auto nativeState = thisObject.getNativeState<NativeState>(runtime);
+        return jsi::Value((int)nativeState->objectId);
+      }
+      return jsi::Value(0);
+    }
+  });
+
+  common::getCoreObject(runtime)
+    .setProperty(runtime, "SharedObject", klass);
+}
+
+jsi::Function getBaseClass(jsi::Runtime &runtime) {
+  return common::getCoreObject(runtime)
+    .getPropertyAsFunction(runtime, "SharedObject");
+}
+
+jsi::Function createClass(jsi::Runtime &runtime, const char *className, common::ClassConstructor constructor) {
+  jsi::Function baseSharedObjectClass = getBaseClass(runtime);
+  return common::createInheritingClass(runtime, className, baseSharedObjectClass, constructor);
+}
+
+} // namespace expo::SharedObject

package/common/cpp/SharedObject.h

@@ -0,0 +1,59 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+#pragma once
+
+#ifdef __cplusplus
+
+#include <jsi/jsi.h>
+#include "JSIUtils.h"
+#include "ObjectDeallocator.h"
+#include "EventEmitter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace expo::SharedObject {
+
+/**
+ Type of the shared object IDs.
+ */
+typedef long ObjectId;
+
+/**
+ Defines an object releaser block of the shared object.
+ */
+typedef std::function<void(const ObjectId)> ObjectReleaser;
+
+/**
+ Installs a base JavaScript class for all shared object with a shared release block.
+ */
+void installBaseClass(jsi::Runtime &runtime, const ObjectReleaser releaser);
+
+/**
+ Returns the base JavaScript class for all shared objects, i.e. `global.expo.SharedObject`.
+ */
+jsi::Function getBaseClass(jsi::Runtime &runtime);
+
+/**
+ Creates a concrete shared object class with the given name and constructor.
+ */
+jsi::Function createClass(jsi::Runtime &runtime, const char *className, common::ClassConstructor constructor);
+
+/**
+ Class representing a native state of the shared object.
+ */
+class JSI_EXPORT NativeState : public EventEmitter::NativeState {
+public:
+  const ObjectId objectId = 0;
+  const ObjectReleaser releaser;
+
+  /**
+   The default constructor that initializes a native state for the shared object with given ID.
+   */
+  NativeState(const ObjectId objectId, const ObjectReleaser releaser);
+
+  virtual ~NativeState();
+}; // class NativeState
+
+} // namespace expo::SharedObject
+
+#endif // __cplusplus

package/common/cpp/TestingSyncJSCallInvoker.h

@@ -0,0 +1,44 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+#pragma once
+
+#ifdef __cplusplus
+
+#include <ReactCommon/CallInvoker.h>
+
+namespace expo {
+
+/**
+ * Dummy CallInvoker that invokes everything immediately.
+ * Used in the test environment to check the async flow.
+ */
+class TestingSyncJSCallInvoker : public facebook::react::CallInvoker {
+public:
+  TestingSyncJSCallInvoker(std::shared_ptr<jsi::Runtime> runtime) : runtime(runtime) {}
+
+#if REACT_NATIVE_TARGET_VERSION >= 75
+  void invokeAsync(react::CallFunc &&func) noexcept override {
+    func(*runtime);
+  }
+
+  void invokeSync(react::CallFunc &&func) override {
+    func(*runtime);
+  }
+#else
+  void invokeAsync(std::function<void()> &&func) noexcept override {
+    func();
+  }
+
+  void invokeSync(std::function<void()> &&func) override {
+    func();
+  }
+#endif
+
+  ~TestingSyncJSCallInvoker() override = default;
+
+  std::shared_ptr<jsi::Runtime> runtime;
+};
+
+} // namespace expo
+
+#endif // __cplusplus

package/ios/Api/Builders/ClassComponentBuilder.swift

@@ -0,0 +1,34 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ A result builder that captures the ``ClassDefinition`` elements such as functions, constants and properties.
+ */
+@resultBuilder
+public struct ClassDefinitionBuilder<OwnerType> {
+  public static func buildBlock(_ elements: AnyClassDefinitionElement...) -> [AnyClassDefinitionElement] {
+    return elements
+  }
+
+  /**
+   Default implementation without any constraints that just returns type-erased element.
+   */
+  public static func buildExpression<ElementType: AnyClassDefinitionElement>(
+    _ element: ElementType
+  ) -> AnyClassDefinitionElement {
+    return element
+  }
+
+  /**
+   In case the element's owner type matches builder's generic type,
+   we need to instruct the function to pass `this` to the closure
+   as the first argument and deduct it from `argumentsCount`.
+   */
+  public static func buildExpression<ElementType: ClassDefinitionElement>(
+    _ element: ElementType
+  ) -> AnyClassDefinitionElement where ElementType.OwnerType == OwnerType {
+    if var function = element as? AnyFunctionDefinition {
+      function.takesOwner = true
+    }
+    return element
+  }
+}

package/ios/{Objects → Api/Builders}/ObjectDefinitionBuilder.swift

@@ -16,10 +16,10 @@ public struct ObjectDefinitionBuilder {
   }
 }
 
-extension SyncFunctionComponent: AnyObjectDefinitionElement {}
+extension SyncFunctionDefinition: AnyObjectDefinitionElement {}
 
-extension AsyncFunctionComponent: AnyObjectDefinitionElement {}
+extension AsyncFunctionDefinition: AnyObjectDefinitionElement {}
 
-extension PropertyComponent: AnyObjectDefinitionElement {}
+extension PropertyDefinition: AnyObjectDefinitionElement {}
 
 extension ConstantsDefinition: AnyObjectDefinitionElement {}

package/ios/Api/Builders/ViewDefinitionBuilder.swift

@@ -0,0 +1,53 @@
+/**
+ A result builder for the view elements such as prop setters or view events.
+ */
+@resultBuilder
+public struct ViewDefinitionBuilder<ViewType: UIView> {
+  public static func buildBlock(_ elements: AnyViewDefinitionElement...) -> [AnyViewDefinitionElement] {
+    return elements
+  }
+
+  /**
+   Accepts `Events` definition element of `View`.
+   */
+  public static func buildExpression(_ element: EventsDefinition) -> AnyViewDefinitionElement {
+    return element
+  }
+
+  /**
+   Accepts `Prop` definition element and lets to skip defining the view type — it's inferred from the `View` definition.
+   */
+  public static func buildExpression<PropType: AnyArgument>(_ element: ConcreteViewProp<ViewType, PropType>) -> AnyViewDefinitionElement {
+    return element
+  }
+
+  /**
+   Accepts lifecycle methods (such as `OnViewDidUpdateProps`) as a definition element.
+   */
+  public static func buildExpression(_ element: ViewLifecycleMethod<ViewType>) -> AnyViewDefinitionElement {
+    return element
+  }
+
+  /**
+   Accepts functions as a view definition elements.
+   */
+  public static func buildExpression<ElementType: ViewDefinitionFunctionElement>(
+    _ element: ElementType
+  ) -> AnyViewDefinitionElement {
+    return element
+  }
+
+  /**
+   Accepts functions that take the owner as a view definition elements.
+   */
+  public static func buildExpression<ElementType: ViewDefinitionFunctionElement>(
+    _ element: ElementType
+  ) -> AnyViewDefinitionElement where ElementType.ViewType == ViewType {
+    // Enforce async functions to run on the main queue
+    if var function = element as? AnyAsyncFunctionDefinition {
+      function.runOnQueue(.main)
+      function.takesOwner = true
+    }
+    return element
+  }
+}

package/ios/Api/Factories/AsyncFunctionFactories.swift

@@ -0,0 +1,173 @@
+/**
+ Asynchronous function without arguments.
+ */
+public func AsyncFunction<R>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping () throws -> R
+) -> AsyncFunctionDefinition<(), Void, R> {
+  return AsyncFunctionDefinition(
+    name,
+    firstArgType: Void.self,
+    dynamicArgumentTypes: [],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with one argument.
+ */
+public func AsyncFunction<R, A0: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0) throws -> R
+) -> AsyncFunctionDefinition<(A0), A0, R> {
+  return AsyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [~A0.self],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with two arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1) throws -> R
+) -> AsyncFunctionDefinition<(A0, A1), A0, R> {
+  return AsyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [~A0.self, ~A1.self],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with three arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2) throws -> R
+) -> AsyncFunctionDefinition<(A0, A1, A2), A0, R> {
+  return AsyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with four arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3) throws -> R
+) -> AsyncFunctionDefinition<(A0, A1, A2, A3), A0, R> {
+  return AsyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with five arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4) throws -> R
+) -> AsyncFunctionDefinition<(A0, A1, A2, A3, A4), A0, R> {
+  return AsyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with six arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4, A5) throws -> R
+) -> AsyncFunctionDefinition<(A0, A1, A2, A3, A4, A5), A0, R> {
+  return AsyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with seven arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6) throws -> R
+) -> AsyncFunctionDefinition<(A0, A1, A2, A3, A4, A5, A6), A0, R> {
+  return AsyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self,
+      ~A6.self
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with eight arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument, A7: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6, A7) throws -> R
+) -> AsyncFunctionDefinition<(A0, A1, A2, A3, A4, A5, A6, A7), A0, R> {
+  return AsyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self,
+      ~A6.self,
+      ~A7.self
+    ],
+    closure
+  )
+}

package/ios/{Classes/ClassComponentFactories.swift → Api/Factories/ClassFactories.swift}

@@ -5,7 +5,7 @@
  */
 public func Constructor<R>(
   @_implicitSelfCapture _ body: @escaping () throws -> R
-) -> SyncFunctionComponent<(), Void, R> {
+) -> SyncFunctionDefinition<(), Void, R> {
   return Function("constructor", body)
 }
 
@@ -14,7 +14,7 @@ public func Constructor<R>(
  */
 public func Constructor<R, A0: AnyArgument>(
   @_implicitSelfCapture _ body: @escaping (A0) throws -> R
-) -> SyncFunctionComponent<(A0), A0, R> {
+) -> SyncFunctionDefinition<(A0), A0, R> {
   return Function("constructor", body)
 }
 
@@ -23,7 +23,7 @@ public func Constructor<R, A0: AnyArgument>(
  */
 public func Constructor<R, A0: AnyArgument, A1: AnyArgument>(
   @_implicitSelfCapture _ body: @escaping (A0, A1) throws -> R
-) -> SyncFunctionComponent<(A0, A1), A0, R> {
+) -> SyncFunctionDefinition<(A0, A1), A0, R> {
   return Function("constructor", body)
 }
 
@@ -32,7 +32,7 @@ public func Constructor<R, A0: AnyArgument, A1: AnyArgument>(
  */
 public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
   @_implicitSelfCapture _ body: @escaping (A0, A1, A2) throws -> R
-) -> SyncFunctionComponent<(A0, A1, A2), A0, R> {
+) -> SyncFunctionDefinition<(A0, A1, A2), A0, R> {
   return Function("constructor", body)
 }
 
@@ -41,7 +41,7 @@ public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
  */
 public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
   @_implicitSelfCapture _ body: @escaping (A0, A1, A2, A3) throws -> R
-) -> SyncFunctionComponent<(A0, A1, A2, A3), A0, R> {
+) -> SyncFunctionDefinition<(A0, A1, A2, A3), A0, R> {
   return Function("constructor", body)
 }
 
@@ -50,7 +50,7 @@ public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3
  */
 public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
   @_implicitSelfCapture _ body: @escaping (A0, A1, A2, A3, A4) throws -> R
-) -> SyncFunctionComponent<(A0, A1, A2, A3, A4), A0, R> {
+) -> SyncFunctionDefinition<(A0, A1, A2, A3, A4), A0, R> {
   return Function("constructor", body)
 }
 
@@ -59,38 +59,38 @@ public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3
  */
 public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument>(
   @_implicitSelfCapture _ body: @escaping (A0, A1, A2, A3, A4, A5) throws -> R
-) -> SyncFunctionComponent<(A0, A1, A2, A3, A4, A5), A0, R> {
+) -> SyncFunctionDefinition<(A0, A1, A2, A3, A4, A5), A0, R> {
   return Function("constructor", body)
 }
 
 /**
- Creates the component describing a JavaScript class.
+ Creates the definition describing a JavaScript class.
  */
 public func Class(
   _ name: String,
-  @ClassComponentElementsBuilder<JavaScriptObject> @_implicitSelfCapture _ elements: () -> [AnyClassComponentElement]
-) -> ClassComponent {
-  return ClassComponent(name: name, associatedType: JavaScriptObject.self, elements: elements())
+  @ClassDefinitionBuilder<JavaScriptObject> @_implicitSelfCapture _ elements: () -> [AnyClassDefinitionElement]
+) -> ClassDefinition {
+  return ClassDefinition(name: name, associatedType: JavaScriptObject.self, elements: elements())
 }
 
 /**
- Creates the component describing a JavaScript class with an associated native shared object class.
+ Creates the definition describing a JavaScript class with an associated native shared object class.
  */
 public func Class<SharedObjectType: SharedObject>(
   _ name: String = String(describing: SharedObjectType.self),
   _ sharedObjectType: SharedObjectType.Type,
-  @ClassComponentElementsBuilder<SharedObjectType> @_implicitSelfCapture _ elements: () -> [AnyClassComponentElement]
-) -> ClassComponent {
-  return ClassComponent(name: name, associatedType: SharedObjectType.self, elements: elements())
+  @ClassDefinitionBuilder<SharedObjectType> @_implicitSelfCapture _ elements: () -> [AnyClassDefinitionElement]
+) -> ClassDefinition {
+  return ClassDefinition(name: name, associatedType: SharedObjectType.self, elements: elements())
 }
 
 /**
- Creates the component describing a JavaScript class with an associated native shared object class
+ Creates the definition describing a JavaScript class with an associated native shared object class
  and with the name that is inferred from the shared object type.
  */
 public func Class<SharedObjectType: SharedObject>(
   _ sharedObjectType: SharedObjectType.Type,
-  @ClassComponentElementsBuilder<SharedObjectType> @_implicitSelfCapture _ elements: () -> [AnyClassComponentElement]
-) -> ClassComponent {
-  return ClassComponent(name: String(describing: SharedObjectType.self), associatedType: SharedObjectType.self, elements: elements())
+  @ClassDefinitionBuilder<SharedObjectType> @_implicitSelfCapture _ elements: () -> [AnyClassDefinitionElement]
+) -> ClassDefinition {
+  return ClassDefinition(name: String(describing: SharedObjectType.self), associatedType: SharedObjectType.self, elements: elements())
 }