expo-modules-core 0.6.1 → 0.7.0

package/ios/Swift/Views/AnyViewProp.swift

@@ -3,7 +3,7 @@ import UIKit
 /**
  Type-erased protocol for view props classes.
  */
-public protocol AnyViewProp: AnyDefinition {
+public protocol AnyViewProp: ViewManagerDefinitionComponent {
   /**
    Name of the view prop that JavaScript refers to.
    */

package/ios/Swift/Views/ComponentData.swift

@@ -0,0 +1,95 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+
+/**
+ Custom component data extending `RCTComponentData`. Its main purpose is to handle event-based props (callbacks),
+ but it also simplifies capturing the view config so we can omit some reflections that React Native executes.
+ */
+@objc(EXComponentData)
+public final class ComponentData: EXComponentDataCompatibleWrapper {
+  /**
+   Weak pointer to the holder of a module that the component data was created for.
+   */
+  weak var moduleHolder: ModuleHolder?
+
+  /**
+   Initializer that additionally takes the original view module to have access to its definition.
+   */
+  @objc
+  public init(viewModule: ViewModuleWrapper, managerClass: ViewModuleWrapper.Type, bridge: RCTBridge) {
+    self.moduleHolder = viewModule.wrappedModuleHolder
+    super.init(managerClass: managerClass, bridge: bridge, eventDispatcher: bridge.eventDispatcher())
+  }
+
+  // MARK: RCTComponentData
+
+  /**
+   Creates a setter for the specific prop. For non-event props we just let React Native do its job.
+   Events are handled differently to conveniently use them in Swift.
+   */
+  public override func createPropBlock(_ propName: String, isShadowView: Bool) -> RCTPropBlockAlias {
+    // Expo Modules Core doesn't support shadow views yet, so fall back to the default implementation.
+    if isShadowView {
+      return super.createPropBlock(propName, isShadowView: isShadowView)
+    }
+
+    // If the prop is defined as an event, create our own event setter.
+    if moduleHolder?.viewManager?.eventNames.contains(propName) == true {
+      return createEventSetter(eventName: propName, bridge: self.manager?.bridge)
+    }
+
+    // Otherwise also fall back to the default implementation.
+    return super.createPropBlock(propName, isShadowView: isShadowView)
+  }
+
+  /**
+   The base `RCTComponentData` class does some Objective-C dynamic calls in this function, but we don't
+   need to do these slow operations since the Sweet API gives us necessary details without reflections.
+   */
+  public override func viewConfig() -> [String: Any] {
+    var propTypes: [String: Any] = [:]
+    var directEvents: [String] = []
+    let superClass: AnyClass? = managerClass.superclass()
+
+    if let eventNames = moduleHolder?.viewManager?.eventNames {
+      for eventName in eventNames {
+        directEvents.append(RCTNormalizeInputEventName(eventName))
+        propTypes[eventName] = "BOOL"
+      }
+    }
+
+    return [
+      "propTypes": propTypes,
+      "directEvents": directEvents,
+      "bubblingEvents": [String](),
+      "baseModuleName": superClass?.moduleName() as Any
+    ]
+  }
+}
+
+/**
+ Creates a setter for the event prop.
+ */
+private func createEventSetter(eventName: String, bridge: RCTBridge?) -> RCTPropBlockAlias {
+  return { [weak bridge] (target: RCTComponent, value: Any) in
+    // Find view's property that is named as the prop and is wrapped by `Event`.
+    let child = Mirror(reflecting: target).children.first {
+      $0.label == "_\(eventName)"
+    }
+    guard let event = child?.value as? AnyEventInternal else {
+      return
+    }
+
+    // For callbacks React Native passes a bool value whether the prop is specified or not.
+    if value as? Bool == true {
+      event.settle { [weak target] (body: Any) in
+        if let target = target {
+          let componentEvent = RCTComponentEvent(name: eventName, viewTag: target.reactTag, body: ["payload": body])
+          bridge?.eventDispatcher().send(componentEvent)
+        }
+      }
+    } else {
+      event.invalidate()
+    }
+  }
+}

package/ios/Swift/Views/ConcreteViewProp.swift

@@ -36,22 +36,20 @@ public final class ConcreteViewProp<ViewType: UIView, PropType: AnyArgument>: An
     // Method's signature must be type-erased to conform to `AnyViewProp` protocol.
     // Given view must be castable to the generic `ViewType` type.
     guard let view = view as? ViewType else {
-      throw IncompatibleViewError(propName: name, viewType: ViewType.self)
+      throw IncompatibleViewException((propName: name, viewType: ViewType.self))
     }
     guard let value = try propType.cast(value) as? PropType else {
-      throw Conversions.CastingError<PropType>(value: value)
+      throw Conversions.CastingException<PropType>(value)
     }
     setter(view, value)
   }
 }
 
 /**
- An error that is thrown when the view passed to prop's setter doesn't match the type in setter's definition.
+ An exception that is thrown when the view passed to prop's setter doesn't match the type in setter's definition.
  */
-internal struct IncompatibleViewError: CodedError {
-  let propName: String
-  let viewType: UIView.Type
-  var description: String {
-    "Tried to set prop `\(propName)` on the view that isn't `\(viewType)`"
+internal class IncompatibleViewException: GenericException<(propName: String, viewType: UIView.Type)> {
+  override var reason: String {
+    "Tried to set prop '\(param.propName)' on the view that isn't \(param.viewType)"
   }
 }

package/ios/Swift/Views/ViewFactory.swift

@@ -3,7 +3,7 @@ import UIKit
 /**
  A definition of the view factory that creates views.
  */
-internal struct ViewFactory: AnyDefinition {
+internal struct ViewFactory: ViewManagerDefinitionComponent {
   typealias FactoryClosureType = () -> UIView
 
   let factory: FactoryClosureType

package/ios/Swift/Views/ViewManagerDefinition.swift

@@ -3,7 +3,7 @@ import UIKit
 /**
  The definition of the view manager. It's part of the module definition to scope only view-related definitions.
  */
-public struct ViewManagerDefinition: AnyDefinition {
+public final class ViewManagerDefinition: ObjectDefinition {
   /**
    The view factory that lets us create views.
    */
@@ -14,13 +14,29 @@ public struct ViewManagerDefinition: AnyDefinition {
    */
   let props: [AnyViewProp]
 
-  init(definitions: [AnyDefinition]) {
+  /**
+   Names of the events that the view can send to JavaScript.
+   */
+  let eventNames: [String]
+
+  /**
+   Default initializer receiving children definitions from the result builder.
+   */
+  override init(definitions: [AnyDefinition]) {
     self.factory = definitions
       .compactMap { $0 as? ViewFactory }
       .last
 
     self.props = definitions
       .compactMap { $0 as? AnyViewProp }
+
+    self.eventNames = Array(
+      definitions
+        .compactMap { ($0 as? EventsDefinition)?.names }
+        .joined()
+    )
+
+    super.init(definitions: definitions)
   }
 
   /**
@@ -39,3 +55,8 @@ public struct ViewManagerDefinition: AnyDefinition {
     }
   }
 }
+
+/**
+ The protocol for definition components that can only be handled by the view manager builder.
+ */
+public protocol ViewManagerDefinitionComponent: AnyDefinition {}

package/ios/Swift/Views/ViewManagerDefinitionBuilder.swift

@@ -1,4 +1,3 @@
-
 #if swift(>=5.4)
 /**
  A result builder that captures scoped definitions specific for view managers, such as `ViewFactory` and `ConcreteViewProp`.

package/ios/Swift/Views/ViewManagerDefinitionComponents.swift

@@ -0,0 +1,26 @@
+/// Here we implement the components exclusive for view managers.
+
+// MARK: View factory
+
+/**
+ Defines the factory creating a native view when the module is used as a view.
+ */
+public func view(_ closure: @escaping () -> UIView) -> ViewManagerDefinitionComponent {
+  return ViewFactory(closure)
+}
+
+// MARK: Props
+
+/**
+ Creates a view prop that defines its name and setter.
+ */
+public func prop<ViewType: UIView, PropType: AnyArgument>(
+  _ name: String,
+  _ setter: @escaping (ViewType, PropType) -> Void
+) -> ViewManagerDefinitionComponent {
+  return ConcreteViewProp(
+    name: name,
+    propType: ArgumentType(PropType.self),
+    setter: setter
+  )
+}

package/ios/Swift/Views/ViewModuleWrapper.swift

@@ -93,7 +93,7 @@ public final class ViewModuleWrapper: RCTViewManager, DynamicModuleWrapperProtoc
    */
   @objc
   public class func propConfig_proxiedProperties() -> [String] {
-    return ["NSDictionary", "__custom__"];
+    return ["NSDictionary", "__custom__"]
   }
 
   /**
@@ -126,7 +126,7 @@ public final class ViewModuleWrapper: RCTViewManager, DynamicModuleWrapperProtoc
     let prefixedViewName = "ViewManagerAdapter_\(module.name())"
 
     return prefixedViewName.withCString { viewNamePtr in
-      // Create a new meta class that inherits from `ViewModuleWrapper`. The class name passed here, doesn't work for Swift classes,
+      // Create a new class that inherits from `ViewModuleWrapper`. The class name passed here, doesn't work for Swift classes,
       // so we also have to override `moduleName` class method.
       let wrapperClass: AnyClass? = objc_allocateClassPair(ViewModuleWrapper.self, viewNamePtr, 0)
 
@@ -141,3 +141,6 @@ public final class ViewModuleWrapper: RCTViewManager, DynamicModuleWrapperProtoc
     }
   }
 }
+
+// The direct event implementation can be cached and lazy-loaded (global and static variables are lazy by default in Swift).
+let directEventBlockImplementation = imp_implementationWithBlock({ ["RCTDirectEventBlock"] } as @convention(block) () -> [String])

package/ios/Tests/ArgumentTypeSpec.swift

@@ -7,7 +7,6 @@ import Nimble
 
 class ArgumentTypeSpec: QuickSpec {
   override func spec() {
-
     it("casts primitives") {
       let type = ArgumentType(Int.self)
       let value = 123
@@ -34,7 +33,7 @@ class ArgumentTypeSpec: QuickSpec {
       let value: Double? = nil
       let anyValue = value as Any
 
-      expect { try type.cast(anyValue) }.to(throwError(errorType: Conversions.NullCastError<Double>.self))
+      expect { try type.cast(anyValue) }.to(throwError(errorType: Conversions.NullCastException<Double>.self))
     }
 
     it("casts arrays") {
@@ -104,7 +103,7 @@ class ArgumentTypeSpec: QuickSpec {
 
         // "841" is not a raw value of any `IntTestEnum` case
         expect { try type.cast("string instead of int") }.to(throwError {
-          expect($0).to(beAKindOf(EnumCastingError.self))
+          expect($0).to(beAKindOf(EnumCastingException.self))
         })
       }
 
@@ -113,7 +112,7 @@ class ArgumentTypeSpec: QuickSpec {
 
         // "841" is not a raw value of any `IntTestEnum` case
         expect { try type.cast(841) }.to(throwError {
-          expect($0).to(beAKindOf(EnumNoSuchValueError.self))
+          expect($0).to(beAKindOf(EnumNoSuchValueException.self))
         })
       }
 

package/ios/Tests/ConstantsSpec.swift

@@ -9,7 +9,7 @@ class ConstantsSpec: QuickSpec {
 
     it("takes closure resolving to dictionary") {
       let holder = mockModuleHolder(appContext) {
-        $0.constants {
+        constants {
           return ["test": 123]
         }
       }
@@ -18,15 +18,15 @@ class ConstantsSpec: QuickSpec {
 
     it("takes the dictionary") {
       let holder = mockModuleHolder(appContext) {
-        $0.constants(["test": 123])
+        constants(["test": 123])
       }
       expect(holder.getConstants()["test"] as? Int) == 123
     }
 
     it("merges multiple constants definitions") {
       let holder = mockModuleHolder(appContext) {
-        $0.constants(["test": 456, "test2": 789])
-        $0.constants(["test": 123])
+        constants(["test": 456, "test2": 789])
+        constants(["test": 123])
       }
       let consts = holder.getConstants()
       expect(consts["test"] as? Int) == 123

package/ios/Tests/ConvertiblesSpec.swift

@@ -37,7 +37,7 @@ class ConvertiblesSpec: QuickSpec {
 
       it("throws when no string") {
         expect { try URL.convert(from: 29.5) }.to(
-          throwError(errorType: Conversions.ConvertingError<URL>.self)
+          throwError(errorType: Conversions.ConvertingException<URL>.self)
         )
       }
     }
@@ -61,22 +61,22 @@ class ConvertiblesSpec: QuickSpec {
       }
 
       it("throws when array size is unexpected") { // different than two
-        expect { try CGPoint.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingError<CGPoint>.self))
-        expect { try CGPoint.convert(from: [x]) }.to(throwError(errorType: Conversions.ConvertingError<CGPoint>.self))
-        expect { try CGPoint.convert(from: [x, y, x]) }.to(throwError(errorType: Conversions.ConvertingError<CGPoint>.self))
+        expect { try CGPoint.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingException<CGPoint>.self))
+        expect { try CGPoint.convert(from: [x]) }.to(throwError(errorType: Conversions.ConvertingException<CGPoint>.self))
+        expect { try CGPoint.convert(from: [x, y, x]) }.to(throwError(errorType: Conversions.ConvertingException<CGPoint>.self))
       }
 
       it("throws when dict is missing some keys") {
         expect { try CGPoint.convert(from: ["test": x]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.MissingKeysError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.MissingKeysError<Double>(keys: ["x", "y"]).description
+          expect($0).to(beAKindOf(Conversions.MissingKeysException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.MissingKeysException<Double>(["x", "y"]).description
         })
       }
 
       it("throws when dict has uncastable keys") {
         expect { try CGPoint.convert(from: ["x": x, "y": "string"]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.CastingValuesError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.CastingValuesError<Double>(keys: ["y"]).description
+          expect($0).to(beAKindOf(Conversions.CastingValuesException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.CastingValuesException<Double>(["y"]).description
         })
       }
     }
@@ -100,22 +100,22 @@ class ConvertiblesSpec: QuickSpec {
       }
 
       it("throws when array size is unexpected") { // different than two
-        expect { try CGSize.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingError<CGSize>.self))
-        expect { try CGSize.convert(from: [width]) }.to(throwError(errorType: Conversions.ConvertingError<CGSize>.self))
-        expect { try CGSize.convert(from: [width, height, width]) }.to(throwError(errorType: Conversions.ConvertingError<CGSize>.self))
+        expect { try CGSize.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingException<CGSize>.self))
+        expect { try CGSize.convert(from: [width]) }.to(throwError(errorType: Conversions.ConvertingException<CGSize>.self))
+        expect { try CGSize.convert(from: [width, height, width]) }.to(throwError(errorType: Conversions.ConvertingException<CGSize>.self))
       }
 
       it("throws when dict is missing some keys") {
         expect { try CGSize.convert(from: ["width": width]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.MissingKeysError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.MissingKeysError<Double>(keys: ["height"]).description
+          expect($0).to(beAKindOf(Conversions.MissingKeysException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.MissingKeysException<Double>(["height"]).description
         })
       }
 
       it("throws when dict has uncastable keys") {
         expect { try CGSize.convert(from: ["width": "test", "height": height]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.CastingValuesError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.CastingValuesError<Double>(keys: ["width"]).description
+          expect($0).to(beAKindOf(Conversions.CastingValuesException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.CastingValuesException<Double>(["width"]).description
         })
       }
     }
@@ -139,22 +139,22 @@ class ConvertiblesSpec: QuickSpec {
       }
 
       it("throws when array size is unexpected") { // different than two
-        expect { try CGVector.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingError<CGVector>.self))
-        expect { try CGVector.convert(from: [dx]) }.to(throwError(errorType: Conversions.ConvertingError<CGVector>.self))
-        expect { try CGVector.convert(from: [dx, dy, dx]) }.to(throwError(errorType: Conversions.ConvertingError<CGVector>.self))
+        expect { try CGVector.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingException<CGVector>.self))
+        expect { try CGVector.convert(from: [dx]) }.to(throwError(errorType: Conversions.ConvertingException<CGVector>.self))
+        expect { try CGVector.convert(from: [dx, dy, dx]) }.to(throwError(errorType: Conversions.ConvertingException<CGVector>.self))
       }
 
       it("throws when dict is missing some keys") {
         expect { try CGVector.convert(from: ["dx": dx]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.MissingKeysError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.MissingKeysError<Double>(keys: ["dy"]).description
+          expect($0).to(beAKindOf(Conversions.MissingKeysException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.MissingKeysException<Double>(["dy"]).description
         })
       }
 
       it("throws when dict has uncastable keys") {
         expect { try CGVector.convert(from: ["dx": "dx", "dy": dy]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.CastingValuesError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.CastingValuesError<Double>(keys: ["dx"]).description
+          expect($0).to(beAKindOf(Conversions.CastingValuesException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.CastingValuesException<Double>(["dx"]).description
         })
       }
     }
@@ -184,22 +184,22 @@ class ConvertiblesSpec: QuickSpec {
       }
 
       it("throws when array size is unexpected") { // different than four
-        expect { try CGRect.convert(from: [x]) }.to(throwError(errorType: Conversions.ConvertingError<CGRect>.self))
-        expect { try CGRect.convert(from: [x, y]) }.to(throwError(errorType: Conversions.ConvertingError<CGRect>.self))
-        expect { try CGRect.convert(from: [x, y, width, height, y]) }.to(throwError(errorType: Conversions.ConvertingError<CGRect>.self))
+        expect { try CGRect.convert(from: [x]) }.to(throwError(errorType: Conversions.ConvertingException<CGRect>.self))
+        expect { try CGRect.convert(from: [x, y]) }.to(throwError(errorType: Conversions.ConvertingException<CGRect>.self))
+        expect { try CGRect.convert(from: [x, y, width, height, y]) }.to(throwError(errorType: Conversions.ConvertingException<CGRect>.self))
       }
 
       it("throws when dict is missing some keys") {
         expect { try CGRect.convert(from: ["x": x]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.MissingKeysError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.MissingKeysError<Double>(keys: ["y", "width", "height"]).description
+          expect($0).to(beAKindOf(Conversions.MissingKeysException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.MissingKeysException<Double>(["y", "width", "height"]).description
         })
       }
 
       it("throws when dict has uncastable keys") {
         expect { try CGRect.convert(from: ["x": x, "y": nil, "width": width, "height": "\(height)"]) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.CastingValuesError<Double>.self))
-          expect(($0 as! CodedError).description) == Conversions.CastingValuesError<Double>(keys: ["y", "height"]).description
+          expect($0).to(beAKindOf(Conversions.CastingValuesException<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.CastingValuesException<Double>(["y", "height"]).description
         })
       }
     }
@@ -213,8 +213,8 @@ class ConvertiblesSpec: QuickSpec {
       }
       func testInvalidHexColor(_ hex: String) {
         expect { try CGColor.convert(from: hex) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.InvalidHexColorError.self))
-          expect(($0 as! CodedError).description) == Conversions.InvalidHexColorError(hex: hex).description
+          expect($0).to(beAKindOf(Conversions.InvalidHexColorException.self))
+          expect(($0 as! CodedError).description) == Conversions.InvalidHexColorException(hex).description
         })
       }
 
@@ -256,8 +256,8 @@ class ConvertiblesSpec: QuickSpec {
       it("throws when int overflows") {
         let hex = 0xBBAA88FF2
         expect { try CGColor.convert(from: hex) }.to(throwError {
-          expect($0).to(beAKindOf(Conversions.HexColorOverflowError.self))
-          expect(($0 as! CodedError).description) == Conversions.HexColorOverflowError(hex: UInt64(hex)).description
+          expect($0).to(beAKindOf(Conversions.HexColorOverflowException.self))
+          expect(($0 as! CodedError).description) == Conversions.HexColorOverflowException(UInt64(hex)).description
         })
       }
     }

package/ios/Tests/ExceptionsSpec.swift

@@ -0,0 +1,112 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+import Quick
+import Nimble
+
+@testable import ExpoModulesCore
+
+final class ExceptionsSpec: QuickSpec {
+  override func spec() {
+    it("has name") {
+      let error = TestException()
+      expect(error.name) == "TestException"
+    }
+
+    it("has code") {
+      let error = TestException()
+      expect(error.code) == "ERR_TEST"
+    }
+
+    it("has reason") {
+      let error = TestException()
+      expect(error.reason) == "This is the test exception"
+    }
+
+    it("can be chained once") {
+      func throwable() throws {
+        do {
+          throw TestExceptionCause()
+        } catch {
+          throw TestException().causedBy(error)
+        }
+      }
+      expect { try throwable() }.to(throwError { error in
+        testChainedExceptionTypes(error: error, types: [TestException.self, TestExceptionCause.self])
+      })
+    }
+
+    it("can be chained twice") {
+      func throwable() throws {
+        do {
+          do {
+            throw TestExceptionCause()
+          } catch {
+            throw TestExceptionCause().causedBy(error)
+          }
+        } catch {
+          throw TestException().causedBy(error)
+        }
+      }
+      expect { try throwable() }.to(throwError { error in
+        testChainedExceptionTypes(error: error, types: [TestException.self, TestExceptionCause.self, TestExceptionCause.self])
+      })
+    }
+
+    it("includes cause description") {
+      func throwable() throws {
+        do {
+          throw TestExceptionCause()
+        } catch {
+          throw TestException().causedBy(error)
+        }
+      }
+      expect { try throwable() }.to(throwError { error in
+        if let error = error as? TestException, let cause = error.cause as? TestExceptionCause {
+          expect(error.description).to(contain(cause.description))
+        } else {
+          fail("Error and its cause are not of expected types.")
+        }
+      })
+    }
+
+    it("has root cause") {
+      let a = TestException()
+      let b = TestException().causedBy(a)
+      let c = TestException().causedBy(b)
+
+      expect(c.rootCause) === a
+    }
+  }
+}
+
+class TestException: Exception {
+  override var reason: String {
+    "This is the test exception"
+  }
+}
+
+class TestExceptionCause: Exception {
+  override var reason: String {
+    "This is the cause of the test exception"
+  }
+}
+
+/**
+ Tests whether the exception chain matches given types and their order.
+ */
+private func testChainedExceptionTypes(error: Error, types: [Error.Type]) {
+  var next: Error? = error
+
+  for errorType in types {
+    let expectedErrorTypeName = String(describing: errorType)
+    let currentErrorTypeName = String(describing: type(of: next!))
+
+    expect(currentErrorTypeName).to(equal(expectedErrorTypeName), description: "The cause is not of type \(expectedErrorTypeName)")
+
+    if let chainableException = next as? ChainableException {
+      next = chainableException.cause
+    } else {
+      next = nil
+    }
+  }
+}