private static void ThrowException(string errorString)
{
// We ignore error since we're already in an error state.
JavaScriptValue errorValue = JavaScriptValue.FromString(errorString);
JavaScriptValue errorObject = JavaScriptValue.CreateError(errorValue);
JavaScriptContext.SetException(errorObject);
}
static JavaScriptValue TestJSNativeFunction2(JavaScriptValue callee,
[MarshalAs(UnmanagedType.U1)] bool isConstructCall,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] JavaScriptValue[] arguments,
ushort argumentCount,
IntPtr callbackData)
{
JavaScriptContext.SetException(JavaScriptValue.CreateError(JavaScriptValue.FromString("test error")));
return(JavaScriptValue.Invalid);
}
/// <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;
}
});
}
/// <summary>
/// User implemented callback to fetch additional imported modules in ES modules.
/// </summary>
/// <remarks>
/// The callback is invoked on the current runtime execution thread, therefore execution is blocked until
/// the callback completes. Notify the host to fetch the dependent module. This is the "import" part
/// before HostResolveImportedModule in ES6 spec. This notifies the host that the referencing module has
/// the specified module dependency, and the host needs to retrieve the module back.
///
/// Callback should:
/// 1. Check if the requested module has been requested before - if yes return the existing
/// module record
/// 2. If no create and initialize a new module record with JsInitializeModuleRecord to
/// return and schedule a call to JsParseModuleSource for the new record.
/// </remarks>
/// <param name="referencingModule">The referencing module that is requesting the dependent module.</param>
/// <param name="specifier">The specifier coming from the module source code.</param>
/// <param name="dependentModuleRecord">The ModuleRecord of the dependent module. If the module was requested
/// before from other source, return the existing ModuleRecord, otherwise
/// return a newly created ModuleRecord.</param>
/// <returns>
/// Returns a <c>JsNoError</c> if the operation succeeded an error code otherwise.
/// </returns>
/// <see cref="JavaScriptFetchImportedModuleCallBack"/>
private JavaScriptErrorCode LoadModuleImpl(JavaScriptModuleRecord referencingModule, JavaScriptValue specifier, out JavaScriptModuleRecord dependentModuleRecord)
{
var specifierString = specifier.ToString();
if (_moduleLeases.TryGetValue(specifierString, out var lease))
{
dependentModuleRecord = lease.Module;
return(JavaScriptErrorCode.NoError);
}
var alias = ResourceModuleUtils.GetResourceAlias(specifierString);
if (alias is null)
{
dependentModuleRecord = JavaScriptModuleRecord.Initialize(referencingModule, specifier);
dependentModuleRecord.HostUrl = specifierString; // Only for debugging
dependentModuleRecord.Exception = JavaScriptValue.CreateTypeError($"Failed to resolve module for specifier '{specifierString}'");
_moduleLeases.Add(specifierString, new ModuleLease(dependentModuleRecord));
dependentModuleRecord = _moduleLeases[specifierString].Module;
return(JavaScriptErrorCode.NoError);
}
dependentModuleRecord = JavaScriptModuleRecord.Initialize(referencingModule, specifier);
dependentModuleRecord.HostUrl = specifierString; // Only for debugging
_moduleLeases.Add(specifierString, new ModuleLease(dependentModuleRecord));
// Fire off a task in the threadpool
Task.Run(async() =>
{
var module = _moduleLeases[specifierString].Module;
try
{
var resource = await _resourceManager.GetResourceAsync(alias);
if (resource is object)
{
var script = _resourceScriptFactory.CreateFromExtension(resource, Path.GetExtension(specifierString));
_dispatcher.Invoke(() =>
{
using (_context.GetScope())
{
module.ParseSource(script);
}
});
}
else
{
_dispatcher.Invoke(() =>
{
using (_context.GetScope())
{
ThrowModuleException(module, JavaScriptValue.CreateError($"Could not find the resource '{specifierString}'"));
}
});
}
}
catch (Exception e)
{
_dispatcher.Invoke(() =>
{
using (_context.GetScope())
{
ThrowModuleException(module, JavaScriptValue.CreateError(e.Message));
}
});
}
void ThrowModuleException(JavaScriptModuleRecord module, JavaScriptValue error)
{
error.AddRef();
module.Exception = error;
if (!JavaScriptContext.HasException)
{
JavaScriptContext.SetException(error);
}
try
{
Native.ThrowIfError(JavaScriptErrorCode.ScriptException);
}
catch (Exception e)
{
OnResourceLoadError?.Invoke(e);
}
finally
{
error.Release();
}
}
});
return(JavaScriptErrorCode.NoError);
}
/// <summary>
/// This method will set a javascript exception on the current context.
/// </summary>
/// <param name="message">The message to use in the exception.</param>
public static void SetJsException(string message)
{
var error = JavaScriptValue.CreateError(JavaScriptValue.FromString(message));
JavaScriptContext.SetException(error);
}