/// <summary>
/// Creates a new JavaScript function.
/// </summary>
/// <remarks>
/// Requires an active script context.
/// </remarks>
/// <param name="function">The method to call when the function is invoked.</param>
/// <param name="callbackData">Data to be provided to all function callbacks.</param>
/// <returns>The new function object.</returns>
public static JavaScriptValue CreateFunction(JavaScriptNativeFunction function, IntPtr callbackData)
{
JavaScriptValue reference;
Native.ThrowIfError(Native.JsCreateFunction(function, callbackData, out reference));
return(reference);
}
private JavascriptServerMiddleware(string rootDir, Predicate <HttpListenerContext> acceptRequest, bool transversalExecution, bool enableWebSocket, bool predicateCompat)
{
if (string.IsNullOrEmpty(rootDir))
{
throw new ArgumentNullException("rootDir");
}
_rootDirectory = rootDir;
_enableDirectoryTransversalExecution = transversalExecution;
_enableWebSocket = enableWebSocket;
if (acceptRequest == null)
{
_acceptRequestFunc = (ctx => !ctx.Request.RawUrl.StartsWith("/assets"));
}
else
{
_acceptRequestFunc = acceptRequest;
}
echoDelegate = JSEcho;
runScriptDelegate = JSRunScript;
writeFileDelegate = JSWriteFile;
readFileDelegate = JSReadFile;
getWebSocketClientIdDelegate = JSGetPushClients;
pushWebSocketMessageDelegate = JSPushMessage;
// initialize javascript runtime
// Create the runtime. We're only going to use one runtime for this host.
_jsRuntime = JavaScriptRuntime.Create();
}
private void InitializeChakra()
{
JavaScriptContext.Current = _runtime.CreateContext();
var consolePropertyId = default(JavaScriptPropertyId);
Native.ThrowIfError(
Native.JsGetPropertyIdFromName("console", out consolePropertyId));
var consoleObject = JavaScriptValue.CreateObject();
EnsureGlobalObject().SetProperty(consolePropertyId, consoleObject, true);
_consoleInfo = ConsoleInfo;
_consoleLog = ConsoleLog;
_consoleWarn = ConsoleWarn;
_consoleError = ConsoleError;
DefineHostCallback(consoleObject, "info", _consoleInfo);
DefineHostCallback(consoleObject, "log", _consoleLog);
DefineHostCallback(consoleObject, "warn", _consoleWarn);
DefineHostCallback(consoleObject, "error", _consoleError);
Debug.WriteLine("Chakra initialization successful.");
}
static void _define(JavaScriptValue globalObject, string callbackName, JavaScriptNativeFunction callback)
{
JavaScriptPropertyId propertyId = JavaScriptPropertyId.FromString(callbackName);
JavaScriptValue function = JavaScriptValue.CreateFunction(callback, IntPtr.Zero);
globalObject.SetProperty(propertyId, function, true);
m_apis.Add(callbackName);
}
private void InstallNativeRequire()
{
_nativeRequire = NativeRequire;
EnsureGlobalObject().SetProperty(
JavaScriptPropertyId.FromString("nativeRequire"),
JavaScriptValue.CreateFunction(_nativeRequire),
true);
}
private void DefineCallback
(JavaScriptValue hostObject, string callbackName, JavaScriptNativeFunction callbackDelegate)
{
var propertyId = JavaScriptPropertyId.FromString(callbackName);
var function = JavaScriptValue.CreateFunction(callbackDelegate);
hostObject.SetProperty(propertyId, function, true);
}
public void RegisterGlobalFunction(string name, JavaScriptNativeFunction func)
{
registeredFunctions.Add(func);
using (new JavaScriptContext.Scope(context)) {
var funcName = JavaScriptPropertyId.FromString(name);
var funcObj = JavaScriptValue.CreateFunction(func);
JavaScriptValue.GlobalObject.SetProperty(funcName, funcObj, true);
}
}
/// <summary>
/// This method binds a function to a specific field on a JavaScript object.
/// </summary>
/// <param name="name">The name of the field.</param>
/// <param name="jsFunction">The callback function to execute when the JavaScript function is invoked.</param>
public void AddFunction(string name, JavaScriptNativeFunction jsFunction)
{
_scope.Run(() =>
{
var jsValue = _binder.BindFunction(jsFunction);
_value.SetProperty(JavaScriptPropertyId.FromString(name), jsValue, true);
});
}
/// <summary>
/// This method creates a new <see cref="JavaScriptValue"/> representing a JavaScript function, and
/// performs the binding of the resulting function with the native host function.
/// </summary>
/// <param name="func">The host function used to create the JavaScript function and binding.</param>
/// <param name="instanceData">A pointer to the instance data that shoukld be passed on each execution of the instance.</param>
public JavaScriptValue BindInstanceFunction(JavaScriptNativeFunction func, IntPtr instanceData)
{
return(_scope.Run(() =>
{
var jsValue = JavaScriptValue.CreateFunction(func, instanceData);
return jsValue;
}));
}
public ChakraHost()
{
if (Native.JsCreateRuntime(JavaScriptRuntimeAttributes.None, null, out runtime) !=
JavaScriptErrorCode.NoError)
{
throw new Exception("failed to create runtime.");
}
if (Native.JsCreateContext(runtime, out context) != JavaScriptErrorCode.NoError)
throw new Exception("failed to create execution context.");
if (Native.JsSetCurrentContext(context) != JavaScriptErrorCode.NoError)
throw new Exception("failed to set current context.");
// ES6 Promise callback
JavaScriptPromiseContinuationCallback promiseContinuationCallback =
delegate (JavaScriptValue task, IntPtr callbackState)
{
promiseCallback = task;
};
if (Native.JsSetPromiseContinuationCallback(promiseContinuationCallback, IntPtr.Zero) !=
JavaScriptErrorCode.NoError)
throw new Exception("failed to setup callback for ES6 Promise");
// Bind to global object
// setTimeout
SetTimeoutJavaScriptNativeFunction = SetTimeout.SetTimeoutJavaScriptNativeFunction;
DefineHostCallback("setTimeout", SetTimeoutJavaScriptNativeFunction);
SendToHostJavaScriptNativeFunction = CommunicationManager.SendToHostJavaScriptNativeFunction;
DefineHostCallback("sendToHost", SendToHostJavaScriptNativeFunction);
// Projections
if (Native.JsProjectWinRTNamespace("ChakraBridge") != JavaScriptErrorCode.NoError)
throw new Exception("failed to project ChakraBridge namespace.");
this.window = new Window();
ProjectObjectToGlobal(new Console(), "console");
ProjectObjectToGlobal(this.window, "window");
ProjectObjectToGlobal(this.window.navigator, "navigator");
ProjectObjectToGlobal(this.window.document, "document");
// Add references
RunScript(@"XMLHttpRequest = ChakraBridge.XMLHttpRequest;
HTMLCanvasElement = ChakraBridge.HTMLCanvasElementWrapper;
atob = window.atob;
btoa = window.btoa;");
#if DEBUG
// Debug
if (Native.JsStartDebugging() != JavaScriptErrorCode.NoError)
throw new Exception("failed to start debugging.");
#endif
}
private static void DefineHostCallback(
JavaScriptValue obj,
string callbackName,
JavaScriptNativeFunction callback)
{
var propertyId = JavaScriptPropertyId.FromString(callbackName);
var function = JavaScriptValue.CreateFunction(callback);
obj.SetProperty(propertyId, function, true);
}
private void InitializeChakra()
{
JavaScriptContext.Current = _runtime.CreateContext();
_nativeLoggingHook = NativeLoggingHook;
EnsureGlobalObject().SetProperty(
JavaScriptPropertyId.FromString("nativeLoggingHook"),
JavaScriptValue.CreateFunction(_nativeLoggingHook),
true);
}
/// <summary>
/// This method creates a new <see cref="JavaScriptValue"/> representing a JavaScript function, and
/// performs the binding of the resulting function with the native host function. This ensures that the
/// host function will not be garbage collected as long as the JavaScript function has not been garbage
/// collected.
/// </summary>
/// <param name="func">The host function used to create the JavaScript function and binding.</param>
public JavaScriptValue BindFunction(JavaScriptNativeFunction func)
{
return(_scope.Run(() =>
{
var jsFunc = JsSafeDecorator.Decorate(func);
var jsValue = JavaScriptValue.CreateFunction(jsFunc);
Link(jsValue, jsFunc);
return jsValue;
}));
}
private void DefineEcho()
{
var globalObject = JavaScriptValue.GlobalObject;
var hostObject = JavaScriptValue.CreateObject();
var hostPropertyId = JavaScriptPropertyId.FromString("managedhost");
globalObject.SetProperty(hostPropertyId, hostObject, true);
EchoDelegate = Echo;
DefineCallback(hostObject, "echo", EchoDelegate);
}
// Private tools
private static void DefineHostCallback(string callbackName, JavaScriptNativeFunction callback)
{
Native.JsGetGlobalObject(out JavaScriptValue globalObject);
var propertyId = JavaScriptPropertyId.FromString(callbackName);
var function = JavaScriptValue.CreateFunction(callback, IntPtr.Zero);
globalObject.SetProperty(propertyId, function, true);
Native.JsAddRef(function, out uint refCount);
}
GenericWrapper(Type type)
{
this.type = type;
if (!type.IsGenericTypeDefinition)
{
throw new ChakraSharpException("Generic definition only");
}
thisPtr = GCHandle.Alloc(this);
mainValueSrc = body;
mainValue = JavaScriptValue.CreateFunction(mainValueSrc, GCHandle.ToIntPtr(thisPtr));
mainValue.AddRef();
}
/// <summary>
/// Returns a delegate that attempts to convert supplied arguments into a BaristaDelegate and returns the result.
/// </summary>
/// <param name="functionDelegate"></param>
/// <returns></returns>
private JavaScriptNativeFunction CreateNativeFunctionForDelegate(BaristaFunctionDelegate functionDelegate)
{
JavaScriptNativeFunction fnDelegate = (IntPtr callee, bool isConstructCall, IntPtr[] arguments, ushort argumentCount, IntPtr callbackData) =>
{
//Convert each argument into a native object.
var calleeObj = CreateValue(new JavaScriptValueSafeHandle(callee)) as JsObject;
var nativeArgs = new object[argumentCount - 1];
JsObject thisObj = null;
for (int i = 0; i < argumentCount; i++)
{
var currentArgument = arguments[i];
var argValueHandle = new JavaScriptValueSafeHandle(currentArgument);
var jsValue = CreateValue(argValueHandle);
if (i == 0)
{
thisObj = jsValue as JsObject;
}
else
{
if (Context.Converter.TryToObject(Context, jsValue, out object obj))
{
nativeArgs[i - 1] = obj;
}
else
{
throw new InvalidOperationException($"Unable to covert argument {i} into a value.");
}
}
}
try
{
var nativeResult = functionDelegate.DynamicInvoke(calleeObj, isConstructCall, thisObj, nativeArgs);
if (Context.Converter.TryFromObject(Context, nativeResult, out JsValue valueResult))
{
return(valueResult.Handle.DangerousGetHandle());
}
else
{
return(Context.Undefined.Handle.DangerousGetHandle());
}
}
catch (TargetInvocationException exceptionResult)
{
var jsError = CreateError(exceptionResult.InnerException);
m_engine.JsSetException(jsError.Handle);
return(Context.Undefined.Handle.DangerousGetHandle());
}
};
return(fnDelegate);
}
private void DefineHostCallback(
JavaScriptValue globalObject,
string callbackName,
JavaScriptNativeFunction callback,
IntPtr callbackData)
{
var propertyId = JavaScriptPropertyId.FromString(callbackName);
this.handles.Add(callback);
var function = JavaScriptValue.CreateFunction(callback, callbackData);
globalObject.SetProperty(propertyId, function, true);
}
public ChakraHost()
{
var code = Native.JsCreateRuntime(JavaScriptRuntimeAttributes.None, null, out runtime);
if (code != JavaScriptErrorCode.NoError)
{
throw new Exception("failed to create runtime.");
}
code = Native.JsCreateContext(runtime, out context);
if (code != JavaScriptErrorCode.NoError)
{
throw new Exception("failed to create execution context.");
}
ResetContext();
// ES6 Promise callback
JavaScriptPromiseContinuationCallback promiseContinuationCallback =
delegate(JavaScriptValue task, IntPtr callbackState)
{
promiseCallback = task;
};
code = Native.JsSetPromiseContinuationCallback(promiseContinuationCallback, IntPtr.Zero);
if (code != JavaScriptErrorCode.NoError)
{
throw new Exception("failed to setup callback for ES6 Promise");
}
// Projections
code = Native.JsProjectWinRTNamespace("ChakraBridge");
if (code != JavaScriptErrorCode.NoError)
{
throw new Exception("failed to project ChakraBridge namespace.");
}
PrintJavaScriptNativeFunction = PrintFun.PrintJavaScriptNativeFunction;
DefineHostCallback("print", PrintJavaScriptNativeFunction);
//ProjectObjectToGlobal(new Console(), "console");
#if DEBUG
// Debug
if (Native.JsStartDebugging() != JavaScriptErrorCode.NoError)
{
throw new Exception("failed to start debugging.");
}
#endif
}
/// <summary>
/// This method binds a getter and setter function to a specific field on a JavaScript object.
/// </summary>
/// <param name="name">The name of the field.</param>
/// <param name="getter">The function to invoke when the field is read.</param>
/// <param name="setter">The function to invoke when the field is written to.</param>
public void AddProperty(string name, JavaScriptNativeFunction getter, JavaScriptNativeFunction setter)
{
_scope.Run(() =>
{
var get = _binder.BindFunction(getter);
var set = _binder.BindFunction(setter);
var descriptor = JavaScriptValue.CreateObject();
descriptor.SetProperty(JavaScriptPropertyId.FromString("get"), get, true);
descriptor.SetProperty(JavaScriptPropertyId.FromString("set"), set, true);
_value.DefineProperty(JavaScriptPropertyId.FromString(name), descriptor);
});
}
public JavaScriptValue GetJavaScriptValue()
{
if (!thisPtr.IsAllocated)
{
thisPtr = GCHandle.Alloc(this);
}
if (!jsvalue.IsValid)
{
jsvalueSrc = Wrap();
jsvalue = JavaScriptValue.CreateFunction(jsvalueSrc, GCHandle.ToIntPtr(thisPtr));
jsvalue.AddRef();
}
return(jsvalue);
}
public static void AttachMethod(JavaScriptValue module, JavaScriptNativeFunction method, string id)
{
JavaScriptValue requireToString;
if (Native.JsCreateFunction(method, IntPtr.Zero, out requireToString) != JavaScriptErrorCode.NoError)
{
throw new Exception("Failed to create method");
}
if (Native.JsSetProperty(module, JavaScriptPropertyId.FromString(id), requireToString, false)
!= JavaScriptErrorCode.NoError)
{
throw new Exception("Failed to define tostring on require");
}
}
public OverloadEntry(MethodBase mi)
{
IEnumerable <ParameterData> ie;
if (mi.IsStatic || mi is ConstructorInfo)
{
ie = new ParameterData[] { new ParameterData()
{
name = "(static this)"
} };
}
else
{
ie = new ParameterData[] {
new ParameterData {
name = "this",
parameterType = mi.DeclaringType
}
};
}
ie = ie.Concat(mi.GetParameters().Select(e =>
{
var d = new ParameterData();
d.name = e.Name;
d.parameterType = e.ParameterType;
d.isOut = e.IsOut;
d.isParams = e.IsDefined(typeof(ParamArrayAttribute), false);
return(d);
}));
ps = ie.ToArray();
cachedFunction = null;
entityWrapper = null;
cachedData = default(GCHandle);
if (mi is ConstructorInfo)
{
entityWrapper = new ConstructorWrapper((ConstructorInfo)mi);
}
else if (mi is MethodInfo)
{
if (mi.IsStatic)
{
entityWrapper = new StaticMethodWrapper((MethodInfo)mi);
}
else
{
entityWrapper = new InstanceMethodWrapper((MethodInfo)mi);
}
}
}
private static JavaScriptValue toJSFunction <TResult> (IServiceNode node, Func <bool, TResult> callback)
{
var converter = node.GetService <IJSValueConverterService>();
JavaScriptNativeFunction f = (callee, isConstructCall, arguments, argumentCount, callbackData) =>
{
if (argumentCount != 1)
{
throw new InvalidOperationException("call from javascript did not pass enough parameters");
}
TResult result = callback(isConstructCall);
return(converter.ToJSValue <TResult>(result));
};
return(node.GetService <IJSValueService>().CreateFunction(f, IntPtr.Zero));
}
private Task <JavaScriptValue> ConvertPromiseToTask(JavaScriptValue promise)
{
// Get the 'then' function from the promise.
var thenFunction = promise.GetProperty(JavaScriptPropertyId.FromString("then"));
// Create resolve & reject callbacks and wire them to a TaskCompletionSource
JavaScriptNativeFunction[] state = new JavaScriptNativeFunction[2];
TaskCompletionSource <JavaScriptValue> completion = new TaskCompletionSource <JavaScriptValue>(state);
var resolveFunc = JavaScriptValue.CreateFunction(
state[0] = (callee, call, arguments, count, data) =>
{
if (count > 1)
{
completion.TrySetResult(arguments[1]);
}
else
{
completion.TrySetResult(JavaScriptValue.Undefined);
}
return(JavaScriptValue.Invalid);
});
var rejectFunc = JavaScriptValue.CreateFunction(
state[1] = (callee, call, arguments, count, data) =>
{
if (count > 1)
{
completion.TrySetException(new JavaScriptException(arguments[1]));
}
else
{
completion.TrySetException(
new JavaScriptException(JavaScriptValue.FromString("Unknown exception in JavaScript promise rejection.")));
}
return(JavaScriptValue.Invalid);
});
// Register the callbacks with the promise using the 'then' function.
thenFunction.CallFunction(promise, resolveFunc, rejectFunc);
// Return a task which will complete when the promise completes.
return(completion.Task);
}
private void DefineHostCallback(
JavaScriptValue globalObject,
string callbackName,
AsyncJavaScriptNativeFunction callback, // Note: this one is async
IntPtr callbackData)
{
var propertyId = JavaScriptPropertyId.FromString(callbackName);
// Create a promise-returning function from our Task-returning function.
JavaScriptNativeFunction nativeFunction = (callee, call, arguments, count, data) => this.jsTaskScheduler.CreatePromise(
callback(callee, call, arguments, count, data));
this.handles.Add(nativeFunction);
var function = JavaScriptValue.CreateFunction(
nativeFunction,
callbackData);
globalObject.SetProperty(propertyId, function, true);
}
private static void DefineHostCallback(JavaScriptValue globalObject, string callbackName, JavaScriptNativeFunction callback, IntPtr callbackData)
{
//
// Get property ID.
//
JavaScriptPropertyId propertyId = JavaScriptPropertyId.FromString(callbackName);
//
// Create a function
//
JavaScriptValue function = JavaScriptValue.CreateFunction(callback, callbackData);
//
// Set the property
//
globalObject.SetProperty(propertyId, function, true);
}
/// <summary>
/// Creates a safe function wrapper for the native function to ensure we propagate
/// errors in javascript appropriately.
/// </summary>
public static JavaScriptNativeFunction Decorate(JavaScriptNativeFunction fn)
{
return((v, s, args, argLength, data) =>
{
try
{
return fn(v, s, args, argLength, data);
}
catch (Exception e)
{
// Pass back entire stack trace to ensure all information makes it back through
var message = e.ToString();
var jsException = JavaScriptValue.CreateError(JavaScriptValue.FromString(message));
JavaScriptContext.SetException(jsException);
return JavaScriptValue.Invalid;
}
});
}
private static JavaScriptValue toJSMethod(IServiceNode node, Action a)
{
var converter = node.GetService <IJSValueConverterService>();
var jsValueService = node.GetService <IJSValueService>();
JavaScriptNativeFunction f = (callee, isConstructCall, arguments, argumentCount, callbackData) =>
{
if (argumentCount != 1)
{
throw new InvalidOperationException("call from javascript did not pass enough parameters");
}
a();
return(jsValueService.JSValue_Undefined);
};
return(jsValueService.CreateFunction(f, IntPtr.Zero));
}
public JsFunction CreateFunction(Delegate func, string name = null)
{
if (func == null)
{
throw new ArgumentNullException(nameof(func));
}
JavaScriptNativeFunction fnDelegate = null;
switch (func)
{
case BaristaFunctionDelegate fnBaristaFunctionDelegate:
fnDelegate = CreateNativeFunctionForDelegate(fnBaristaFunctionDelegate);
break;
default:
fnDelegate = CreateNativeFunctionForDelegate(func);
break;
}
JavaScriptValueSafeHandle fnHandle;
if (String.IsNullOrWhiteSpace(name))
{
fnHandle = m_engine.JsCreateFunction(fnDelegate, IntPtr.Zero);
}
else
{
var nameValue = CreateString(name);
fnHandle = m_engine.JsCreateNamedFunction(nameValue.Handle, fnDelegate, IntPtr.Zero);
}
//this is a special case where we cannot use our CreateValue<> method.
return(m_valuePool.GetOrAdd(fnHandle, () =>
{
var jsNativeFunction = new JsNativeFunction(m_engine, Context, fnHandle, fnDelegate);
jsNativeFunction.BeforeCollect += JsValueBeforeCollectCallback;
return jsNativeFunction;
}) as JsNativeFunction);
}
public JavaScriptNativeFunction HoldFunction(JavaScriptNativeFunction function)
{
Guid id = Guid.NewGuid();
if (!IsOneTime)
{
dict.Add(id, function);
return(function);
}
else
{
JavaScriptNativeFunction result = new JavaScriptNativeFunction((callee, isConstructCall, arguments, argumentCount, callbackData) =>
{
var r = function(callee, isConstructCall, arguments, argumentCount, callbackData);
dict.Remove(id);
return(r);
});
dict.Add(id, result);
return(result);
}
}
private static JavaScriptValue toJSMethod <T1, T2, T3, T4, T5, T6, T7> (IServiceNode node, Action <T1, T2, T3, T4, T5, T6, T7> a)
{
var converter = node.GetService <IJSValueConverterService>();
var jsValueService = node.GetService <IJSValueService>();
JavaScriptNativeFunction f = (callee, isConstructCall, arguments, argumentCount, callbackData) =>
{
if (argumentCount != 8)
{
throw new InvalidOperationException("call from javascript did not pass enough parameters");
}
T1 para1 = converter.FromJSValue <T1>(arguments[1]);
T2 para2 = converter.FromJSValue <T2>(arguments[2]);
T3 para3 = converter.FromJSValue <T3>(arguments[3]);
T4 para4 = converter.FromJSValue <T4>(arguments[4]);
T5 para5 = converter.FromJSValue <T5>(arguments[5]);
T6 para6 = converter.FromJSValue <T6>(arguments[6]);
T7 para7 = converter.FromJSValue <T7>(arguments[7]);
arguments[1].AddRef();
arguments[2].AddRef();
arguments[3].AddRef();
arguments[4].AddRef();
arguments[5].AddRef();
arguments[6].AddRef();
arguments[7].AddRef();
a(para1, para2, para3, para4, para5, para6, para7);
arguments[1].Release();
arguments[2].Release();
arguments[3].Release();
arguments[4].Release();
arguments[5].Release();
arguments[6].Release();
arguments[7].Release();
return(jsValueService.JSValue_Undefined);
};
return(jsValueService.CreateFunction(f, IntPtr.Zero));
}
internal static extern JavaScriptErrorCode JsCreateFunction(JavaScriptNativeFunction nativeFunction, IntPtr externalData, out JavaScriptValue function);
internal static extern JavaScriptErrorCode JsCreateNamedFunction(JavaScriptValue name, JavaScriptNativeFunction nativeFunction, IntPtr callbackState, out JavaScriptValue function);
/// <summary>
/// Creates a new JavaScript function.
/// </summary>
/// <remarks>
/// Requires an active script context.
/// </remarks>
/// <param name="function">The method to call when the function is invoked.</param>
/// <returns>The new function object.</returns>
internal static JavaScriptValue CreateFunction(JavaScriptNativeFunction function)
{
JavaScriptValue reference;
Native.ThrowIfError(Native.JsCreateFunction(function, IntPtr.Zero, out reference));
return reference;
}
/// <summary>
/// Creates a new JavaScript function.
/// </summary>
/// <remarks>
/// Requires an active script context.
/// </remarks>
/// <param name="function">The method to call when the function is invoked.</param>
/// <param name="callbackData">Data to be provided to all function callbacks.</param>
/// <returns>The new function object.</returns>
public static JavaScriptValue CreateFunction(JavaScriptNativeFunction function, IntPtr callbackData)
{
JavaScriptValue reference;
Native.ThrowIfError(Native.JsCreateFunction(function, callbackData, out reference));
return reference;
}
// Private tools
private static void DefineHostCallback(string callbackName, JavaScriptNativeFunction callback)
{
JavaScriptValue globalObject;
Native.JsGetGlobalObject(out globalObject);
JavaScriptPropertyId propertyId = JavaScriptPropertyId.FromString(callbackName);
JavaScriptValue function = JavaScriptValue.CreateFunction(callback, IntPtr.Zero);
globalObject.SetProperty(propertyId, function, true);
uint refCount;
Native.JsAddRef(function, out refCount);
}
