/// <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); }