Support for Delegates

TypeShim.E2E/TypeShim.E2E.Wasm/ArrayPropertiesClass.cs

@@ -1,6 +1,6 @@
 using System.Runtime.InteropServices.JavaScript;
 
-namespace TypeShim.Sample;
+namespace TypeShim.E2E.Wasm;
 
 [TSExport]
 public class  ArrayPropertiesClass

TypeShim.E2E/TypeShim.E2E.Wasm/DelegatesTest.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Runtime.InteropServices.JavaScript;
+
+namespace TypeShim.E2E.Wasm;
+
+[TSExport]
+public class DelegatesTest
+{
+    public void InvokeVoidAction(Action action)
+    {
+        action();
+    }
+
+    public void InvokeStringAction(Action<string> action)
+    {
+        action("Hello");
+    }
+
+    public void InvokeInt32Action(Action<int> action)
+    {
+        action(42);
+    }
+
+    public void InvokeBoolAction(Action<bool> action)
+    {
+        action(true);
+    }
+
+    public void InvokeBool2Action(Action<bool, bool> action)
+    {
+        action(true, false);
+    }
+
+    public void InvokeBool3Action(Action<bool, bool, bool> action)
+    {
+        action(true, false, true);
+    }
+
+    public string InvokeStringFunc(Func<string> func)
+    {
+        return func();
+    }
+
+    public int InvokeInt32Func(Func<int> func)
+    {
+        return func();
+    }
+
+    public bool InvokeBoolFunc(Func<bool> func)
+    {
+        return func();
+    }
+
+    public bool InvokeBool2Func(Func<bool, bool> func)
+    {
+        return func(true);
+    }
+
+    public void InvokeExportedClassAction(Action<ExportedClass> action)
+    {
+        action(new ExportedClass { Id = 100 });
+    }
+
+    public Func<ExportedClass> GetExportedClassFunc() {
+        return () => new ExportedClass { Id = 200 };
+    }
+
+    public Func<ExportedClass, ExportedClass> GetExportedClassExportedClassFunc() {
+        return (ExportedClass classIn) => classIn;
+    }
+}

TypeShim.E2E/TypeShim.E2E.Wasm/ExportedClass.cs

@@ -1,4 +1,4 @@
-namespace TypeShim.Sample;
+namespace TypeShim.E2E.Wasm;
 
 [TSExport]
 public class ExportedClass // for referencing an exported class

TypeShim.E2E/TypeShim.E2E.Wasm/SimplePropertiesTest.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Runtime.InteropServices.JavaScript;
 
-namespace TypeShim.Sample;
+namespace TypeShim.E2E.Wasm;
 
 [TSExport]
 public class SimplePropertiesTest

TypeShim.E2E/TypeShim.E2E.Wasm/SimpleReturnMethodsClass.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Globalization;
 
-namespace TypeShim.Sample;
+namespace TypeShim.E2E.Wasm;
 
 [TSExport]
 public class SimpleReturnMethodsClass

TypeShim.E2E/TypeShim.E2E.Wasm/TaskPropertiesClass.cs

@@ -2,7 +2,7 @@
 using System.Runtime.InteropServices.JavaScript;
 using System.Threading.Tasks;
 
-namespace TypeShim.Sample;
+namespace TypeShim.E2E.Wasm;
 
 [TSExport]
 public class TaskPropertiesClass

TypeShim.E2E/TypeShim.E2E.Wasm/TaskReturnMethodsClass.cs

@@ -0,0 +1,14 @@
+using System.Threading.Tasks;
+
+namespace TypeShim.E2E.Wasm;
+
+[TSExport]
+public class TaskReturnMethodsClass
+{
+    public Task VoidTaskMethod() => Task.CompletedTask;
+    public Task<int> Int32TaskMethod() => Task.FromResult(42);
+    public Task<bool> BoolTaskMethod() => Task.FromResult(true);
+    public Task<string> StringTaskMethod() => Task.FromResult("Hello, from .NET Task");
+
+    public Task<ExportedClass> ExportedClassTaskMethod() => Task.FromResult(new ExportedClass() { Id = 420 });
+}

TypeShim.E2E/vitest/src/delegates.test.ts

@@ -0,0 +1,132 @@
+import { describe, test, expect, beforeEach } from 'vitest';
+import { DelegatesTest, ExportedClass } from '@typeshim/e2e-wasm-lib';
+
+describe('Delegates Test', () => {
+    let exportedClass: ExportedClass;
+    let testObject: DelegatesTest;
+    beforeEach(() => {
+        exportedClass = new ExportedClass({ Id: 2 });
+        testObject = new DelegatesTest();
+    });
+
+    test('Invoke Void Action', async () => {
+        let isInvoked = false;
+        testObject.InvokeVoidAction(() => {
+            isInvoked = true;
+        });
+        expect(isInvoked).toBe(true);
+    });
+
+    test('Invoke String Action', async () => {
+        let receivedString = "";
+        testObject.InvokeStringAction((arg0: string) => {
+            receivedString = arg0;
+        });
+        expect(receivedString).toBe("Hello");
+    });
+
+    test('Invoke Int32 Action', async () => {
+        let receivedInt = 0;
+        testObject.InvokeInt32Action((arg0: number) => {
+            receivedInt = arg0;
+        });
+        expect(receivedInt).toBe(42);
+    });
+
+    test('Invoke Bool Action', async () => {
+        let receivedBool = false;
+        testObject.InvokeBoolAction((arg0: boolean) => {
+            receivedBool = arg0;
+        });
+        expect(receivedBool).toBe(true);
+    });
+
+    test('Invoke Bool2 Action', async () => {
+        let receivedBool1 = false;
+        let receivedBool2 = false;
+        testObject.InvokeBool2Action((arg0: boolean, arg1: boolean) => {
+            receivedBool1 = arg0;
+            receivedBool2 = arg1;
+        });
+        expect(receivedBool1).toBe(true);
+        expect(receivedBool2).toBe(false);
+    });
+
+    test('Invoke Bool3 Action', async () => {
+        let receivedBool1 = false;
+        let receivedBool2 = false;
+        let receivedBool3 = false;
+        testObject.InvokeBool3Action((arg0: boolean, arg1: boolean, arg2: boolean) => {
+            receivedBool1 = arg0;
+            receivedBool2 = arg1;
+            receivedBool3 = arg2;
+        });
+        expect(receivedBool1).toBe(true);
+        expect(receivedBool2).toBe(false);
+        expect(receivedBool3).toBe(true);
+    });
+
+    test('Invoke String Func', async () => {
+        const result = testObject.InvokeStringFunc(() => {
+            return "Hello World";
+        });
+        expect(result).toBe("Hello World");
+    }); 
+
+    test('Invoke Int32 Func', async () => {
+        const result = testObject.InvokeInt32Func(() => {
+            return 12345;
+        });
+        expect(result).toBe(12345);
+    });
+
+    test('Invoke Bool Func', async () => {
+        const result = testObject.InvokeBoolFunc(() => {
+            return true;
+        });
+        expect(result).toBe(true);
+    });
+
+    test('Invoke Bool2 Func', async () => {
+        const result = testObject.InvokeBool2Func((arg0: boolean) => {
+            return arg0;
+        });
+        expect(result).toBe(true);
+    });
+
+    test('Invoke ExportedClass Action', async () => {
+        let receivedInstance: ExportedClass = null as any;
+        testObject.InvokeExportedClassAction((arg0: ExportedClass) => {
+            receivedInstance = arg0;
+        });
+        expect(receivedInstance).not.toBeNull();
+        expect(receivedInstance).toBeInstanceOf(ExportedClass);
+        expect(receivedInstance.Id).toBe(100);
+    });
+
+    test('Get ExportedClass Func', async () => {
+        const fn = testObject.GetExportedClassFunc();
+        const exportedInstance = fn();
+        expect(exportedInstance).not.toBeNull();
+        expect(exportedInstance).toBeInstanceOf(ExportedClass);
+        expect(exportedInstance.Id).toBe(200);
+    });
+
+    test('Get ExportedClassExportedClassFunc Proxy', async () => {
+        const instance = new ExportedClass({ Id: 300 });
+        const fn = testObject.GetExportedClassExportedClassFunc();
+        const retVal = fn(instance);
+        expect(retVal).not.toBeNull();
+        expect(retVal).toBeInstanceOf(ExportedClass);
+        expect(retVal.Id).toBe(300);
+    });
+
+    test('Get ExportedClassExportedClassFunc Initializer', async () => {
+        const instance = { Id: 250 };
+        const fn = testObject.GetExportedClassExportedClassFunc();
+        const retVal = fn(instance);
+        expect(retVal).not.toBeNull();
+        expect(retVal).toBeInstanceOf(ExportedClass);
+        expect(retVal.Id).toBe(250);
+    });
+});

TypeShim.E2E/vitest/src/simple-properties.test.ts

@@ -36,6 +36,32 @@ describe('Simple Properties Test', () => {
         expect(testObject.ExportedClassProperty).toBeInstanceOf(ExportedClass);
         expect(testObject.ExportedClassProperty.Id).toBe(2);
     });
+    test('Mutates ExportedClass property correctly', () => {
+        expect(testObject.ExportedClassProperty).toBeInstanceOf(ExportedClass);
+        expect(testObject.ExportedClassProperty.Id).toBe(2);
+        const newExportedClass = new ExportedClass({ Id: 99 });
+        testObject.ExportedClassProperty = newExportedClass;
+        expect(testObject.ExportedClassProperty).toBeInstanceOf(ExportedClass);
+        expect(testObject.ExportedClassProperty.Id).toBe(99);
+        // TODO: fix identity (https://github.com/ArcadeMode/TypeShim/issues/20)
+        // expect(testObject.ExportedClassProperty).toBe(newExportedClass);
+    });
+    test('Mutates ExportedClass property with Initializer', () => {
+        expect(testObject.ExportedClassProperty).toBeInstanceOf(ExportedClass);
+        expect(testObject.ExportedClassProperty.Id).toBe(2);
+        const exportedClassInitializer = { Id: 12345 };
+        testObject.ExportedClassProperty = exportedClassInitializer;
+        expect(testObject.ExportedClassProperty).toBeInstanceOf(ExportedClass);
+        expect(testObject.ExportedClassProperty.Id).toBe(12345);
+    });
+    test('Mutates ExportedClass property does not affect snapshot', () => {
+        const snapshot = SimplePropertiesTest.materialize(testObject);
+        expect(testObject.ExportedClassProperty).toBeInstanceOf(ExportedClass);
+        expect(testObject.ExportedClassProperty.Id).toBe(2);
+        const newExportedClass = new ExportedClass({ Id: 99 });
+        testObject.ExportedClassProperty = newExportedClass;
+        expect(snapshot.ExportedClassProperty.Id).toBe(2);
+    });
     test('Returns JSObject property by reference', () => {
         expect(testObject.JSObjectProperty).toBe(jsObject);
         const obj = testObject.JSObjectProperty as any;