BridgeJS: Add tests for computed properties and lazy-var

Author: kateinoigakukun

Plugins/BridgeJS/Tests/BridgeJSToolTests/Inputs/PropertyTypes.swift

@@ -19,6 +19,39 @@
     // SwiftHeapObject property (will be set later)
     @JS var sibling: PropertyHolder
 
+    // Lazy stored property - should this be supported or generate an error?
+    @JS lazy var lazyValue: String = "computed lazily"
+
+    // Computed property with getter only (readonly)
+    @JS var computedReadonly: Int {
+        return intValue * 2
+    }
+
+    // Computed property with getter and setter
+    @JS var computedReadWrite: String {
+        get {
+            return "Value: \(intValue)"
+        }
+        set {
+            // Parse the number from "Value: X" format
+            if let range = newValue.range(of: "Value: "),
+                let number = Int(String(newValue[range.upperBound...]))
+            {
+                intValue = number
+            }
+        }
+    }
+
+    // Property with property observers
+    @JS var observedProperty: Int {
+        willSet {
+            print("Will set to \(newValue)")
+        }
+        didSet {
+            print("Did set from \(oldValue)")
+        }
+    }
+
     @JS init(
         intValue: Int,
         floatValue: Float,

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PropertyTypes.Export.d.ts

@@ -25,6 +25,10 @@ export interface PropertyHolder extends SwiftHeapObject {
     readonly readonlyString: string;
     jsObject: any;
     sibling: PropertyHolder;
+    lazyValue: string;
+    computedReadonly: number;
+    computedReadWrite: string;
+    observedProperty: number;
 }
 export type Exports = {
     PropertyHolder: {

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PropertyTypes.Export.js

@@ -185,6 +185,44 @@ export async function createInstantiator(options, swift) {
                 set sibling(value) {
                     instance.exports.bjs_PropertyHolder_sibling_set(this.pointer, value.pointer);
                 }
+                get lazyValue() {
+                    instance.exports.bjs_PropertyHolder_lazyValue_get(this.pointer);
+                    const ret = tmpRetString;
+                    tmpRetString = undefined;
+                    return ret;
+                }
+                set lazyValue(value) {
+                    const valueBytes = textEncoder.encode(value);
+                    const valueId = swift.memory.retain(valueBytes);
+                    instance.exports.bjs_PropertyHolder_lazyValue_set(this.pointer, valueId, valueBytes.length);
+                    swift.memory.release(valueId);
+                }
+                get computedReadonly() {
+                    const ret = instance.exports.bjs_PropertyHolder_computedReadonly_get(this.pointer);
+                    return ret;
+                }
+                set computedReadonly(value) {
+                    instance.exports.bjs_PropertyHolder_computedReadonly_set(this.pointer, value);
+                }
+                get computedReadWrite() {
+                    instance.exports.bjs_PropertyHolder_computedReadWrite_get(this.pointer);
+                    const ret = tmpRetString;
+                    tmpRetString = undefined;
+                    return ret;
+                }
+                set computedReadWrite(value) {
+                    const valueBytes = textEncoder.encode(value);
+                    const valueId = swift.memory.retain(valueBytes);
+                    instance.exports.bjs_PropertyHolder_computedReadWrite_set(this.pointer, valueId, valueBytes.length);
+                    swift.memory.release(valueId);
+                }
+                get observedProperty() {
+                    const ret = instance.exports.bjs_PropertyHolder_observedProperty_get(this.pointer);
+                    return ret;
+                }
+                set observedProperty(value) {
+                    instance.exports.bjs_PropertyHolder_observedProperty_set(this.pointer, value);
+                }
             }
             return {
                 PropertyHolder,

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PropertyTypes.json

@@ -191,6 +191,42 @@
               "_0" : "PropertyHolder"
             }
           }
+        },
+        {
+          "isReadonly" : false,
+          "name" : "lazyValue",
+          "type" : {
+            "string" : {
+
+            }
+          }
+        },
+        {
+          "isReadonly" : false,
+          "name" : "computedReadonly",
+          "type" : {
+            "int" : {
+
+            }
+          }
+        },
+        {
+          "isReadonly" : false,
+          "name" : "computedReadWrite",
+          "type" : {
+            "string" : {
+
+            }
+          }
+        },
+        {
+          "isReadonly" : false,
+          "name" : "observedProperty",
+          "type" : {
+            "int" : {
+
+            }
+          }
         }
       ]
     }

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PropertyTypes.swift

@@ -272,6 +272,102 @@ public func _bjs_PropertyHolder_sibling_set(_self: UnsafeMutableRawPointer, valu
     #endif
 }
 
+@_expose(wasm, "bjs_PropertyHolder_lazyValue_get")
+@_cdecl("bjs_PropertyHolder_lazyValue_get")
+public func _bjs_PropertyHolder_lazyValue_get(_self: UnsafeMutableRawPointer) -> Void {
+    #if arch(wasm32)
+    var ret = Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().lazyValue
+    return ret.withUTF8 { ptr in
+        _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PropertyHolder_lazyValue_set")
+@_cdecl("bjs_PropertyHolder_lazyValue_set")
+public func _bjs_PropertyHolder_lazyValue_set(_self: UnsafeMutableRawPointer, valueBytes: Int32, valueLen: Int32) -> Void {
+    #if arch(wasm32)
+    let value = String(unsafeUninitializedCapacity: Int(valueLen)) { b in
+        _swift_js_init_memory(valueBytes, b.baseAddress.unsafelyUnwrapped)
+        return Int(valueLen)
+    }
+    Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().lazyValue = value
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PropertyHolder_computedReadonly_get")
+@_cdecl("bjs_PropertyHolder_computedReadonly_get")
+public func _bjs_PropertyHolder_computedReadonly_get(_self: UnsafeMutableRawPointer) -> Int32 {
+    #if arch(wasm32)
+    let ret = Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().computedReadonly
+    return Int32(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PropertyHolder_computedReadonly_set")
+@_cdecl("bjs_PropertyHolder_computedReadonly_set")
+public func _bjs_PropertyHolder_computedReadonly_set(_self: UnsafeMutableRawPointer, value: Int32) -> Void {
+    #if arch(wasm32)
+    Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().computedReadonly = Int(value)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PropertyHolder_computedReadWrite_get")
+@_cdecl("bjs_PropertyHolder_computedReadWrite_get")
+public func _bjs_PropertyHolder_computedReadWrite_get(_self: UnsafeMutableRawPointer) -> Void {
+    #if arch(wasm32)
+    var ret = Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().computedReadWrite
+    return ret.withUTF8 { ptr in
+        _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PropertyHolder_computedReadWrite_set")
+@_cdecl("bjs_PropertyHolder_computedReadWrite_set")
+public func _bjs_PropertyHolder_computedReadWrite_set(_self: UnsafeMutableRawPointer, valueBytes: Int32, valueLen: Int32) -> Void {
+    #if arch(wasm32)
+    let value = String(unsafeUninitializedCapacity: Int(valueLen)) { b in
+        _swift_js_init_memory(valueBytes, b.baseAddress.unsafelyUnwrapped)
+        return Int(valueLen)
+    }
+    Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().computedReadWrite = value
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PropertyHolder_observedProperty_get")
+@_cdecl("bjs_PropertyHolder_observedProperty_get")
+public func _bjs_PropertyHolder_observedProperty_get(_self: UnsafeMutableRawPointer) -> Int32 {
+    #if arch(wasm32)
+    let ret = Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().observedProperty
+    return Int32(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PropertyHolder_observedProperty_set")
+@_cdecl("bjs_PropertyHolder_observedProperty_set")
+public func _bjs_PropertyHolder_observedProperty_set(_self: UnsafeMutableRawPointer, value: Int32) -> Void {
+    #if arch(wasm32)
+    Unmanaged<PropertyHolder>.fromOpaque(_self).takeUnretainedValue().observedProperty = Int(value)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
 @_expose(wasm, "bjs_PropertyHolder_deinit")
 @_cdecl("bjs_PropertyHolder_deinit")
 public func _bjs_PropertyHolder_deinit(pointer: UnsafeMutableRawPointer) {