kekyo / dupenukem Goto Github PK

WebView attachable full-duplex asynchronous interoperable independent messaging library between .NET and JavaScript.

License: Apache License 2.0

C# 87.70% JavaScript 11.88% Batchfile 0.42%

android asynchronous attachable cefsharp dotnet edge2 full-duplex independent interoperable javascript messaging webview

dupenukem's Introduction

Kouji Matsui (kozy_kekyo)

🔭 I’m a self-employed Functional runtime engineer.
🌱 I’m a Master of Arts and Science degree.
👯 I’m looking for a job.
📫 How to reach me: Mastodon @[email protected] (English) / @[email protected] (Japanese) / Twitter @kozy_kekyo (English)
😄 English nickname's kozy, pronouns same as cozy. Japanese nickname's kekyo (I feel it pronounce's bit difficult :)
⚡ Fun fact: A bicycle rider. I'm good at long riding, maybe called randonner.

Hi! my name is Kouji Matsui. Please call me kozy (pronounce same as cozy) I'm an functional runtime engineer.

Active/showcase projects

Conceptual / Early stage

Small scripts / tools

IoT / Hardware design

Point implementation

Kinda joke

Community activities

Older (Retired/Archived)

dupenukem's People

Contributors

Stargazers

Watchers

dupenukem's Issues

Improve handling ability for result type.

Will validate return type both `Task` and `ValueTask`.

public Task<int> Sum(int a, int b) => Task.FromResult(a + b);
public ValueTask<int> Sum(int a, int b) => new ValueTask<int>(a + b);

Will validate any constant return type with synchronized method/function.

.NET:

public int Sum(int a, int b) => a + b;

// Requires dirty naming (ex: namespace).
using DupeNukem.Synchronized;
messenger.RegisterFunc<int, int, int>(this.Sum);

JavaScript:

/* async */ function add(a, b) {
  return a + b;
}

Support optional arguments

Since JavaScript does not perform type checking, a method call is always variable argument length.
Therefore, we want to allow JavaScript ---> .NET calls to omit arguments in the corresponding .NET method.

Currently, the number of arguments is strictly inspected, so we add the following operations in that section.

If the arguments from JavaScript are shorter than the arguments of the :
- Proposal 1: Make up all missing arguments with default values (default(T) in C#).
- Proposal 2: If the missing arguments have default values (OptionalAttribute and DefaultParameterValueAttribute), automatically compensate (otherwise, error).

Add automatic marshaler for .NET methods

Currently, we have to register manually on .NET side methods.

So, there is an idea for:

public sealed class Foo
{
    public Task<int> Add(int a, int b) => Task.FromResult(a + b);
    public Task<int> Sub(int a, int b) => Task.FromResult(a - b);
}

var foo = new Foo();

messenger = new Messenger();

// Current strategy:
messenger.RegisterFunc<int, int, int>(foo.Add);
messenger.RegisterFunc<int, int, int>(foo.Sub);

// Automatic interpretation for declared methods:
messenger.RegisterObject(foo);

Does this library could be used to substitute AddHostObjectToScript functionality?

This is not an issue report, this is a question.

Currently, AddHostObjectToScript is broken for WinUI3. You can see some of these reports here:

https://learn.microsoft.com/en-us/answers/questions/1291522/using-addhostobjecttoscript-in-maui-apps
dotnet/maui#9424
MicrosoftEdge/WebView2Feedback#2754

In my quests, I found this library that looks like that could be used to replace it. Am I correct?

Support CancellationToken.

And how to do it on JavaScript (It doesn't have any standard cancellation infrastructure)

Support ObsoleteAttribute to help debugging in JS side.

Will show obsoleted method warning on console.warn() or other.

Perhaps a mechanism that allows .NET method signatures to be displayed as hints would also be useful.

Expose JsonSerializerSettings

Make customizable for marshaling.

[Blazor] Add Blazor Support

How do I suppress these warnings?

I am running Blazor on my Webview2 . Along with this I am using your #1 (comment) example

        public Form()
        {
            InitializeComponent();

            var services = new ServiceCollection();
            services.AddWindowsFormsBlazorWebView();
#if DEBUG
            services.AddBlazorWebViewDeveloperTools();
#endif
            blazorWebView1.HostPage = "wwwroot\\index.html";
            blazorWebView1.Services = services.BuildServiceProvider();
            blazorWebView1.BlazorWebViewInitialized += BlazorWebViewInitialized;
            blazorWebView1.RootComponents.Add<Main>("#app");

        }

Support closure functions both .NET and JavaScript.

.NET proxy

public interface IJavaScriptTargetFunctionsPreDefined
{
    Task<int> add(int a, int b);
    Task<int> sub(int a, int b);
}

// Get (generate) a proxy.
var proxy = messenger.GetProxy<IJavaScriptTargetFunctionsPreDefined>();

var r1 = await proxy.add(1, 2);
var r2 = await proxy.sub(1, 2);

async function add(a, b) {
  return a + b;
}
async function sub(a, b) {
  return a - b;
}

JavaScript proxy

// "calculator" is a proxy.
window.calculator.Add(1, 2);
window.calculator.Sub(1, 2);

// (Already supported)

public sealed class Calculator
{
    public Task<int> Add(int a, int b) =>
        Task.FromResult(a + b);
    public Task<int> Sub(int a, int b) =>
        Task.FromResult(a - b);
}

// Register object AND generate a proxy into JavaScript.
var calculator = new Calculator();
message.RegisterObject("calculator", calculator);

Support Invoking Modules/Classes from JS in C#

I can see this is possible from C# to JS like so

var calculator = new Calculator();
messenger.RegisterObject(calculator)

How do I do this for JS? It seems I can only invoke functions from the window context.

Want to force unhooking events by calling Dispose()

To avoid memory leaks, when Dispose() is called, all hooked events are released.

Write sample code and gluing for some platforms

Planning it:

CefSharp
Android WebView

etc...

Support Reactive Extension

.NET: IObservable<T>
JavaScript: rxjs

MEMO:

How to do lifetime management.
How to control delegate/function callback.