Stop managing JSOneshotClosure by FinalizationRegistry

JSOneshotClosure manages its lifetime by itself, so it doesn't require
nondeterministic FinalizationRegistry. Additionally, use of FinalizationRegistry
was unsafe for the case:
1. JSOneshotClosure C1 is created
2. C1 is called, and destroyed
3. JSOneshotClosure C2 is created at the same address of C1
4. C1's finalizer callback is called

Author: kateinoigakukun

Plugins/PackageToJS/Templates/runtime.mjs

@@ -638,6 +638,12 @@ class SwiftRuntime {
                 (_a = this.closureDeallocator) === null || _a === void 0 ? void 0 : _a.track(func, host_func_id);
                 return func_ref;
             },
+            swjs_create_oneshot_function: (host_func_id, line, file) => {
+                const fileString = this.memory.getObject(file);
+                const func = (...args) => this.callHostFunction(host_func_id, line, fileString, args);
+                const func_ref = this.memory.retain(func);
+                return func_ref;
+            },
             swjs_create_typed_array: (constructor_ref, elementsPtr, length) => {
                 const ArrayType = this.memory.getObject(constructor_ref);
                 if (length == 0) {

Runtime/src/index.ts

@@ -557,6 +557,18 @@ export class SwiftRuntime {
                 return func_ref;
             },
 
+            swjs_create_oneshot_function: (
+                host_func_id: number,
+                line: number,
+                file: ref
+            ) => {
+                const fileString = this.memory.getObject(file) as string;
+                const func = (...args: any[]) =>
+                    this.callHostFunction(host_func_id, line, fileString, args);
+                const func_ref = this.memory.retain(func);
+                return func_ref;
+            },
+
             swjs_create_typed_array: <T extends Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array | Float32Array | Float64Array | Uint8ClampedArray>(
                 constructor_ref: ref,
                 elementsPtr: pointer,

Sources/JavaScriptKit/FundamentalObjects/JSClosure.swift

@@ -25,7 +25,7 @@ public class JSOneshotClosure: JSObject, JSClosureProtocol {
         // 2. Create a new JavaScript function which calls the given Swift function.
         hostFuncRef = JavaScriptHostFuncRef(bitPattern: ObjectIdentifier(self))
         _id = withExtendedLifetime(JSString(file)) { file in
-            swjs_create_function(hostFuncRef, line, file.asInternalJSRef())
+            swjs_create_oneshot_function(hostFuncRef, line, file.asInternalJSRef())
         }
 
         // 3. Retain the given body in static storage by `funcRef`.

Sources/_CJavaScriptKit/include/_CJavaScriptKit.h

@@ -278,6 +278,16 @@ IMPORT_JS_FUNCTION(swjs_create_function, JavaScriptObjectRef, (const JavaScriptH
                                                                unsigned int line,
                                                                JavaScriptObjectRef file))
 
+/// Creates a oneshot JavaScript thunk function that calls Swift side closure.
+///
+/// @param host_func_id The target Swift side function called by the created thunk function.
+/// @param line The line where the function is created. Will be used for diagnostics
+/// @param file The file name where the function is created. Will be used for diagnostics
+/// @returns A reference to the newly-created JavaScript thunk function
+IMPORT_JS_FUNCTION(swjs_create_oneshot_function, JavaScriptObjectRef, (const JavaScriptHostFuncRef host_func_id,
+                                                                       unsigned int line,
+                                                                       JavaScriptObjectRef file))
+
 /// Instantiates a new `TypedArray` object with given elements
 /// This is used to provide an efficient way to create `TypedArray`.
 ///