public JavaScriptValueSafeHandle JsRunSerializedScript(string script, byte[] buffer, JavaScriptSourceContext sourceContext, string sourceUrl)
{
Errors.ThrowIfError(LibChakraCore.JsRunSerializedScript(script, buffer, sourceContext, sourceUrl, out JavaScriptValueSafeHandle result));
result.NativeFunctionSource = nameof(LibChakraCore.JsRunSerializedScript);
if (result != JavaScriptValueSafeHandle.Invalid)
{
Errors.ThrowIfError(LibChakraCore.JsAddRef(result, out uint valueRefCount));
}
return(result);
}
public void JsParseScriptWithAttributeParsesAndReturnsAFunction()
{
if (CommonWindowsEngine == null)
{
return;
}
var script = "(()=>{return 6*7;})()";
string sourceUrl = "[eval code]";
using (var runtimeHandle = Engine.JsCreateRuntime(JavaScriptRuntimeAttributes.None, null))
{
using (var contextHandle = Engine.JsCreateContext(runtimeHandle))
{
Engine.JsSetCurrentContext(contextHandle);
var resultHandle = CommonWindowsEngine.JsParseScriptWithAttributes(script, JavaScriptSourceContext.GetNextSourceContext(), sourceUrl, JavaScriptParseScriptAttributes.None);
Assert.True(resultHandle != JavaScriptValueSafeHandle.Invalid);
var handleType = Engine.JsGetValueType(resultHandle);
Assert.True(handleType == JsValueType.Function);
resultHandle.Dispose();
}
}
}
public JavaScriptValueSafeHandle JsParseSerializedScriptWithCallback(JavaScriptSerializedScriptLoadSourceCallback scriptLoadCallback, JavaScriptSerializedScriptUnloadCallback scriptUnloadCallback, byte[] buffer, JavaScriptSourceContext sourceContext, string sourceUrl)
{
Errors.ThrowIfError(LibChakraCore.JsParseSerializedScriptWithCallback(scriptLoadCallback, scriptUnloadCallback, buffer, sourceContext, sourceUrl, out JavaScriptValueSafeHandle result));
result.NativeFunctionSource = nameof(LibChakraCore.JsParseSerializedScriptWithCallback);
if (result != JavaScriptValueSafeHandle.Invalid)
{
Errors.ThrowIfError(LibChakraCore.JsAddRef(result, out uint valueRefCount));
}
return(result);
}
public void JsSerializedScriptCanBeRun()
{
if (CommonWindowsEngine == null)
{
return;
}
var script = @"
var moose = function() {
//Trigger script loading
var str = arguments.callee.toString();
return 6*7;
};
moose();
";
string sourceUrl = "[eval code]";
using (var runtimeHandle = Engine.JsCreateRuntime(JavaScriptRuntimeAttributes.None, null))
{
using (var contextHandle = Engine.JsCreateContext(runtimeHandle))
{
Engine.JsSetCurrentContext(contextHandle);
byte[] buffer = new byte[1024];
uint bufferSize = (uint)buffer.Length;
CommonWindowsEngine.JsSerializeScript(script, buffer, ref bufferSize);
var resultHandle = CommonWindowsEngine.JsRunSerializedScript(script, buffer, JavaScriptSourceContext.GetNextSourceContext(), sourceUrl);
Assert.NotEqual(JavaScriptValueSafeHandle.Invalid, resultHandle);
var handleType = Engine.JsGetValueType(resultHandle);
Assert.True(handleType == JsValueType.Number);
Assert.Equal(42, Engine.JsNumberToInt(resultHandle));
resultHandle.Dispose();
}
Engine.JsCollectGarbage(runtimeHandle);
}
}
public void JsSerializedScriptCanBeParsed()
{
if (CommonWindowsEngine == null)
{
return;
}
var script = "(()=>{return 6*7;})()";
string sourceUrl = "[eval code]";
using (var runtimeHandle = Engine.JsCreateRuntime(JavaScriptRuntimeAttributes.None, null))
{
using (var contextHandle = Engine.JsCreateContext(runtimeHandle))
{
Engine.JsSetCurrentContext(contextHandle);
byte[] buffer = new byte[1024];
uint bufferSize = (uint)buffer.Length;
CommonWindowsEngine.JsSerializeScript(script, buffer, ref bufferSize);
var fnHandle = CommonWindowsEngine.JsParseSerializedScript(script, buffer, JavaScriptSourceContext.GetNextSourceContext(), sourceUrl);
Assert.NotEqual(JavaScriptValueSafeHandle.Invalid, fnHandle);
var handleType = Engine.JsGetValueType(fnHandle);
Assert.True(handleType == JsValueType.Function);
fnHandle.Dispose();
}
Engine.JsCollectGarbage(runtimeHandle);
}
}
public void JsSerializedScriptCanBeRunWithCallbacks()
{
if (CommonWindowsEngine == null)
{
return;
}
var script = @"
var moose1 = function() {
//Trigger script loading
var str = arguments.callee.toString();
return 6*7;
};
moose1();
";
string sourceUrl = "[eval code]";
bool loaded = false;
bool unloaded = false;
JavaScriptSerializedScriptLoadSourceCallback loadCallback = (JavaScriptSourceContext sourceContext, out StringBuilder scriptBuffer) =>
{
loaded = true;
scriptBuffer = new StringBuilder(script);
return(true);
};
JavaScriptSerializedScriptUnloadCallback unloadCallback = (JavaScriptSourceContext sourceContext) =>
{
unloaded = true;
};
var loadCallbackHandle = GCHandle.Alloc(loadCallback);
var unloadCallbackHandle = GCHandle.Alloc(unloadCallback);
try
{
using (var runtimeHandle = Engine.JsCreateRuntime(JavaScriptRuntimeAttributes.None, null))
{
using (var contextHandle = Engine.JsCreateContext(runtimeHandle))
{
Engine.JsSetCurrentContext(contextHandle);
byte[] buffer = new byte[1024];
uint bufferSize = (uint)buffer.Length;
CommonWindowsEngine.JsSerializeScript(script, buffer, ref bufferSize);
var resultHandle = CommonWindowsEngine.JsRunSerializedScriptWithCallback(loadCallback, unloadCallback, buffer, JavaScriptSourceContext.GetNextSourceContext(), sourceUrl);
Assert.NotEqual(JavaScriptValueSafeHandle.Invalid, resultHandle);
var handleType = Engine.JsGetValueType(resultHandle);
Assert.True(handleType == JsValueType.Number);
Assert.Equal(42, Engine.JsNumberToInt(resultHandle));
resultHandle.Dispose();
}
Engine.JsCollectGarbage(runtimeHandle);
}
Assert.True(loaded);
Assert.True(unloaded);
}
finally
{
loadCallbackHandle.Free();
unloadCallbackHandle.Free();
}
}
public void JsSerializedScriptCanBeParsedWithCallbacks()
{
if (CommonWindowsEngine == null)
{
return;
}
var script = "(()=>{return 6*7;})()";
string sourceUrl = "[eval code]";
bool loaded = false;
bool unloaded = false;
using (var runtimeHandle = Engine.JsCreateRuntime(JavaScriptRuntimeAttributes.None, null))
{
using (var contextHandle = Engine.JsCreateContext(runtimeHandle))
{
Engine.JsSetCurrentContext(contextHandle);
byte[] buffer = new byte[1024];
uint bufferSize = (uint)buffer.Length;
CommonWindowsEngine.JsSerializeScript(script, buffer, ref bufferSize);
JavaScriptSerializedScriptLoadSourceCallback loadCallback = (JavaScriptSourceContext sourceContext, out StringBuilder scriptBuffer) =>
{
loaded = true;
scriptBuffer = new StringBuilder(script);
return(true);
};
JavaScriptSerializedScriptUnloadCallback unloadCallback = (JavaScriptSourceContext sourceContext) =>
{
unloaded = true;
};
var fnHandle = CommonWindowsEngine.JsParseSerializedScriptWithCallback(loadCallback, unloadCallback, buffer, JavaScriptSourceContext.GetNextSourceContext(), sourceUrl);
Assert.NotEqual(JavaScriptValueSafeHandle.Invalid, fnHandle);
var handleType = Engine.JsGetValueType(fnHandle);
Assert.True(handleType == JsValueType.Function);
//Get the string representation of the function. This triggers the load callback.
var fnStringHandle = Engine.JsConvertValueToString(fnHandle);
var stringPtr = CommonWindowsEngine.JsStringToPointer(fnStringHandle, out ulong length);
Assert.True(stringPtr != IntPtr.Zero);
Assert.True(length > 0);
fnStringHandle.Dispose();
fnHandle.Dispose();
}
Engine.JsCollectGarbage(runtimeHandle);
}
Assert.True(loaded);
Assert.True(unloaded);
}
public void JsModuleCanBeImportedAndExecuted()
{
var mainModuleName = "";
var mainModuleSource = @"
import cube from 'foo';
const global = (new Function('return this;'))();
global.$EXPORTS = cube(3);
";
var fooModuleSource = @"
export default function cube(x) {
return x * x * x;
}
";
var mainModuleReady = false;
JavaScriptModuleRecord childModuleHandle = JavaScriptModuleRecord.Invalid;
JavaScriptFetchImportedModuleCallback fetchCallback = (IntPtr referencingModule, IntPtr specifier, out IntPtr dependentModuleRecord) =>
{
var moduleName = Engine.GetStringUtf8(new JavaScriptValueSafeHandle(specifier));
if (string.IsNullOrWhiteSpace(moduleName))
{
dependentModuleRecord = referencingModule;
return(false);
}
Assert.True(moduleName == "foo");
var moduleRecord = Engine.JsInitializeModuleRecord(new JavaScriptModuleRecord(referencingModule), new JavaScriptValueSafeHandle(specifier));
dependentModuleRecord = moduleRecord.DangerousGetHandle();
childModuleHandle = moduleRecord;
return(false);
};
JavaScriptFetchImportedModuleFromScriptCallback fetchFromScriptCallback = (IntPtr referencingModule, IntPtr specifier, out IntPtr dependentModuleRecord) =>
{
var moduleName = Engine.GetStringUtf8(new JavaScriptValueSafeHandle(specifier));
if (string.IsNullOrWhiteSpace(moduleName))
{
dependentModuleRecord = referencingModule;
return(false);
}
Assert.True(moduleName == "foo");
var moduleRecord = Engine.JsInitializeModuleRecord(new JavaScriptModuleRecord(referencingModule), new JavaScriptValueSafeHandle((IntPtr)specifier));
dependentModuleRecord = moduleRecord.DangerousGetHandle();
childModuleHandle = moduleRecord;
return(false);
};
JavaScriptNotifyModuleReadyCallback notifyCallback = (IntPtr referencingModule, IntPtr exceptionVar) =>
{
Assert.Equal(IntPtr.Zero, exceptionVar);
mainModuleReady = true;
return(false);
};
using (var runtimeHandle = Engine.JsCreateRuntime(JavaScriptRuntimeAttributes.None, null))
{
using (var contextHandle = Engine.JsCreateContext(runtimeHandle))
{
Engine.JsSetCurrentContext(contextHandle);
//Initialize the "main" module (Empty-string specifier).
var moduleNameHandle = Engine.JsCreateString(mainModuleName, (ulong)mainModuleName.Length);
var mainModuleHandle = Engine.JsInitializeModuleRecord(JavaScriptModuleRecord.Invalid, moduleNameHandle);
Assert.True(mainModuleHandle != JavaScriptModuleRecord.Invalid);
//Set the fetch callback.
var fetchCallbackDelegateHandle = GCHandle.Alloc(fetchCallback);
IntPtr fetchCallbackPtr = Marshal.GetFunctionPointerForDelegate(fetchCallback);
Engine.JsSetModuleHostInfo(mainModuleHandle, JavaScriptModuleHostInfoKind.FetchImportedModuleCallback, fetchCallbackPtr);
//Ensure the callback was set properly.
var moduleHostPtr = Engine.JsGetModuleHostInfo(mainModuleHandle, JavaScriptModuleHostInfoKind.FetchImportedModuleCallback);
Assert.Equal(fetchCallbackPtr, moduleHostPtr);
//Set the fetchScript callback
var fetchFromScriptCallbackDelegateHandle = GCHandle.Alloc(fetchCallback);
IntPtr fetchFromScriptCallbackPtr = Marshal.GetFunctionPointerForDelegate(fetchFromScriptCallback);
Engine.JsSetModuleHostInfo(mainModuleHandle, JavaScriptModuleHostInfoKind.FetchImportedModuleFromScriptCallback, fetchFromScriptCallbackPtr);
//Ensure the callback was set properly.
moduleHostPtr = Engine.JsGetModuleHostInfo(mainModuleHandle, JavaScriptModuleHostInfoKind.FetchImportedModuleFromScriptCallback);
Assert.Equal(fetchFromScriptCallbackPtr, moduleHostPtr);
//Set the notify callback
var notifyCallbackDelegateHandle = GCHandle.Alloc(fetchCallback);
IntPtr notifyCallbackPtr = Marshal.GetFunctionPointerForDelegate(notifyCallback);
Engine.JsSetModuleHostInfo(mainModuleHandle, JavaScriptModuleHostInfoKind.NotifyModuleReadyCallback, notifyCallbackPtr);
//Ensure the callback was set properly.
moduleHostPtr = Engine.JsGetModuleHostInfo(mainModuleHandle, JavaScriptModuleHostInfoKind.NotifyModuleReadyCallback);
Assert.Equal(notifyCallbackPtr, moduleHostPtr);
//Indicate the host-defined, main module.
Engine.JsSetModuleHostInfo(mainModuleHandle, JavaScriptModuleHostInfoKind.HostDefined, moduleNameHandle.DangerousGetHandle());
//Ensure the callback was set properly.
moduleHostPtr = Engine.JsGetModuleHostInfo(mainModuleHandle, JavaScriptModuleHostInfoKind.HostDefined);
Assert.Equal(moduleNameHandle.DangerousGetHandle(), moduleHostPtr);
// ParseModuleSource is sync, while additional fetch & evaluation are async.
var scriptBuffer = Encoding.UTF8.GetBytes(mainModuleSource);
var errorHandle = Engine.JsParseModuleSource(mainModuleHandle, JavaScriptSourceContext.GetNextSourceContext(), scriptBuffer, (uint)mainModuleSource.Length, JavaScriptParseModuleSourceFlags.DataIsUTF8);
Assert.True(errorHandle == JavaScriptValueSafeHandle.Invalid);
Assert.True(childModuleHandle != JavaScriptModuleRecord.Invalid);
Assert.False(mainModuleReady);
//Parse the foo now.
scriptBuffer = Encoding.UTF8.GetBytes(fooModuleSource);
errorHandle = Engine.JsParseModuleSource(childModuleHandle, JavaScriptSourceContext.GetNextSourceContext(), scriptBuffer, (uint)fooModuleSource.Length, JavaScriptParseModuleSourceFlags.DataIsUTF8);
Assert.True(errorHandle == JavaScriptValueSafeHandle.Invalid);
Assert.True(mainModuleReady);
//Now we're ready, evaluate the main module.
var evalResultHandle = Engine.JsModuleEvaluation(mainModuleHandle);
Assert.True(evalResultHandle != JavaScriptValueSafeHandle.Invalid);
//Result type of a module is always undefined per spec.
var evalResultType = Engine.JsGetValueType(evalResultHandle);
Assert.True(evalResultType == JsValueType.Undefined);
var resultHandle = Engine.GetGlobalVariable("$EXPORTS");
var handleType = Engine.JsGetValueType(resultHandle);
Assert.True(handleType == JsValueType.Number);
var result = Engine.JsNumberToInt(resultHandle);
Assert.Equal(27, result);
//Cleanup
Engine.JsSetModuleHostInfo(mainModuleHandle, JavaScriptModuleHostInfoKind.FetchImportedModuleCallback, IntPtr.Zero);
fetchCallbackDelegateHandle.Free();
Engine.JsSetModuleHostInfo(mainModuleHandle, JavaScriptModuleHostInfoKind.FetchImportedModuleFromScriptCallback, IntPtr.Zero);
fetchFromScriptCallbackDelegateHandle.Free();
Engine.JsSetModuleHostInfo(mainModuleHandle, JavaScriptModuleHostInfoKind.NotifyModuleReadyCallback, IntPtr.Zero);
notifyCallbackDelegateHandle.Free();
}
}
}
