public void RunModule(string script, LoadModuleDelegate loadModuleCallback)
{
moduleLoadException = null;
JavaScriptModuleRecord rootRecord = contextSwitch.With(() =>
{
return(createModule(null, null, (name) =>
{
if (string.IsNullOrEmpty(name))
{
return new ModuleInfo {
SourceCode = script
};
}
else
{
return loadModuleCallback(name);
}
}));
});
//startModuleParseQueue();
moduleReadyEvent.WaitOne();
throwIfExceptionInLoading();
contextSwitch.With(() =>
{
JavaScriptModuleRecord.RunModule(rootRecord);
});
}
public static extern IntPtr CompilePrelude(
[MarshalAs(UnmanagedType.LPWStr)] string prelude, [MarshalAs(UnmanagedType.LPWStr)] string fileName,
LoadModuleDelegate loadModuleHandler, EnterCancellableRegionDelegate enterCancellableRegionHandler,
ExitCancellableRegionDelegate exitCancellableRegionHandler, LogDelegate logHandler);
public static extern IntPtr CompilePrelude(
[MarshalAs(UnmanagedType.LPWStr)] string prelude, [MarshalAs(UnmanagedType.LPWStr)] string fileName,
LoadModuleDelegate loadModuleHandler, LogDelegate logHandler);
public static extern IntPtr CompilePrelude(
[MarshalAs(UnmanagedType.LPWStr)] string prelude, [MarshalAs(UnmanagedType.LPWStr)] string fileName,
LoadModuleDelegate loadModuleHandler, EnterCancellableRegionDelegate enterCancellableRegionHandler,
ExitCancellableRegionDelegate exitCancellableRegionHandler, LogDelegate logHandler);
public static extern IntPtr CompilePrelude(
[MarshalAs(UnmanagedType.LPWStr)] string prelude, [MarshalAs(UnmanagedType.LPWStr)] string fileName,
LoadModuleDelegate loadModuleHandler, LogDelegate logHandler);
public JSValue ProjectModuleClass(string proxyModuleScriptTemplate, string moduleName, string className, LoadModuleDelegate loadModuleCallback, string projectTo = null)
{
if (string.IsNullOrWhiteSpace(projectTo))
{
projectTo = "X" + Guid.NewGuid().ToString().Replace('-', '_');
}
string script_setRootObject = $"var {projectTo}={{}};";
string script_importModule = proxyModuleScriptTemplate
.Replace("{className}", className)
.Replace("{moduleName}", moduleName)
.Replace("{projectTo}", projectTo);
RunScript(script_setRootObject);
RunModule(script_importModule, loadModuleCallback);
return(GlobalObject.ReadProperty <JSValue>(projectTo));
}
/// <summary>
/// Load a module script, create an instance of specified exported class and map it as a global variable
/// </summary>
/// <param name="projectTo">the global variable name mapped to</param>
/// <param name="moduleName">module name</param>
/// <param name="className">class name to create an instance</param>
/// <param name="loadModuleCallback">local module script by name callback </param>
/// <returns>the mapped value</returns>
public JSValue ProjectModuleClass(string moduleName, string className, LoadModuleDelegate loadModuleCallback, string projectTo = null)
{
string template = "import { {className} } from '{moduleName}'; {projectTo}=new {className}();";
return(ProjectModuleClass(template, moduleName, className, loadModuleCallback, projectTo));
}
/// <summary>
/// Execute a ES6 module
/// </summary>
/// <param name="script">script content</param>
/// <param name="loadModuleCallback">callback to load imported script content</param>
public void RunModule(string script, LoadModuleDelegate loadModuleCallback)
{
ServiceNode.GetService <IContextService>().RunModule(script, loadModuleCallback);
}
private JavaScriptModuleRecord createModule(JavaScriptModuleRecord?parent, string name, LoadModuleDelegate loadModuleCallback)
{
bool isCreateFromSourceCode = string.IsNullOrEmpty(name);
//if module is cached, return cached value
if (!isCreateFromSourceCode && moduleCache.ContainsKey(name))
{
return(moduleCache[name]);
}
IRuntimeDebuggingService debugService = CurrentNode.GetService <IRuntimeDebuggingService>();
var result = JavaScriptModuleRecord.Create(parent, name);
#region init moudle callback delegates
FetchImportedModuleDelegate fetchImported = (JavaScriptModuleRecord reference, JavaScriptValue scriptName, out JavaScriptModuleRecord output) =>
{
output = createModule(reference, scriptName.ToString(), loadModuleCallback);
return(JavaScriptErrorCode.NoError);
};
FetchImportedModuleFromScriptDelegate fetchImportedFromScript = (JavaScriptSourceContext sourceContext, JavaScriptValue scriptName, out JavaScriptModuleRecord output) =>
{
output = createModule(null, scriptName.ToString(), loadModuleCallback);
return(JavaScriptErrorCode.NoError);
};
NotifyModuleReadyCallbackDelegate notifyReady = (module, jsvalue) =>
{
moduleReadyEvent.Set();
if (jsvalue.IsValid)
{
var valueService = CurrentNode.GetService <IJSValueService>();
valueService.ThrowIfErrorValue(jsvalue);
}
debugService.NotifyScriptReady();
return(JavaScriptErrorCode.NoError);
};
#endregion
Action parseModule = () =>
{
var scriptInfo = loadModuleCallback(name);
if (!string.IsNullOrEmpty(scriptInfo.Url))
{
JavaScriptModuleRecord.SetHostUrl(result, scriptInfo.Url);
}
JavaScriptModuleRecord.ParseScript(result, scriptInfo.SourceCode, debugService.GetScriptContext(name, scriptInfo.SourceCode));
//debugService.AddScriptSource(name, script);
System.Diagnostics.Debug.WriteLine($"module {name} Parsed");
};
JavaScriptModuleRecord.SetFetchModuleCallback(result, fetchImported);
JavaScriptModuleRecord.SetFetchModuleScriptCallback(result, fetchImportedFromScript);
JavaScriptModuleRecord.SetNotifyReady(result, notifyReady);
if (!string.IsNullOrEmpty(name))
{
JavaScriptModuleRecord.SetHostUrl(result, name);
}
else
{
JavaScriptModuleRecord.SetHostUrl(result, "<Generated_ModuleRoot>");
}
moduleParseQueue.Add(new moduleItem(
parseModule,
fetchImported,
fetchImportedFromScript,
notifyReady));
if (!isCreateFromSourceCode)
{
moduleCache.Add(name, result);//cache the module if it's not directly from RunModule function
}
System.Diagnostics.Debug.WriteLine($"{name} module created");
return(result);
}
