Using Modules and Invoking a Specific Function

[ravware]

Hello,

I looked through the examples, and tests and I am missing how to call a specific function using Modules.

Say this is the example:

import * as Test from 'module.js'

function TestStart()
{
	Debug.Message(Test.name);
}

And now say I want to call TestStart.

From the tests to call Modules there are a few parts:

1. set the flag for EnableDynamicModuleImports
2. set the Access flags to EnableAllLoading
3. pass a DocInfo

Now when I try to call TestStart I get a can not be found error.

...Evaluate(docInfo,ScriptInMemory);
....Invoke("TestStart",null);

I tried different variations of referencing the function and I am wondering what I need to pass to call fire TestStart.

[ClearScriptLib]

Hi @ravware,

Functions defined within modules aren't added to the global object. That would constitute a side effect of module evaluation, and side effects are often considered undesirable. The module system aims to establish a standard mechanism for sharing script resources, and that mechanism is import/export.

However, there are other ways. First, a module could deliberately create a side effect by leveraging globalThis:

import * as Test from 'module.js'
globalThis.TestStart = function () {
    Debug.Message(Test.name);
}

Another possibility is to import your module into a regular script. This is only possible with Dynamic Imports, which are disabled by default but can be enabled via V8ScriptEngineFlags.EnableDynamicModuleImports:

import('module.js').then(exports => {
    TestStart = () => {
        Debug.Message(exports.name);
    }
});

We don't see much difference between these approaches. Both use a small bit of throwaway code to expose module resources to regular scripts and the host application. Polluting the main module ("module.js") with side effects would be worse.

Good luck!

[Aenge]

@ravware @ClearScriptLib
I'm looking into this as well. I'm trying to something like

import {TownNPC} from './TownNPC.js'

function OnLoad() {
   var Definition = new TownNPC('Matthew');	
} 

function OnTalk() {
   npcSay('Hello!');
}

function OnTrade() {
   npcSay("I don't need that!");
}

and these functions would need to be called on the csharp side when those specific actions take place. There doesn't currently seem to be a (good) way to achieve this.

Using the global namespace as a way to access them could work. But that doesn't seem like a good option if using one v8 script engine with multiple asynchronous operations?

[ClearScriptLib]

Hi @Aenge,

Functions defined but not exported from a module – and not made accessible via the global object or some other means – are simply not accessible from outside the module. That's JavaScript language behavior that ClearScript can't change.

If you did export those functions, you could access them from the host via dynamic import. Here's a working example that demonstrates the technique:

var flags = V8ScriptEngineFlags.EnableDynamicModuleImports | V8ScriptEngineFlags.EnableTaskPromiseConversion;
using (var engine = new V8ScriptEngine(flags)) {
    engine.AddHostType(typeof(Console));
    engine.DocumentSettings.AddSystemDocument("MyModule.js", ModuleCategory.Standard, @"
        export function OnLoad() { Console.WriteLine('OnLoad called'); } 
        export function OnTalk() { Console.WriteLine('OnTalk called'); }
        export function OnTrade() { Console.WriteLine('OnTrade called'); }
    ");
    dynamic module = ((Task<object>)engine.Evaluate("import('MyModule.js')")).Result;
    module.OnLoad();
    module.OnTalk();
    module.OnTrade();
}

Note that we're adding a system document here only to show the contents of MyModule.js inline. It's just a way to populate the module cache without loading a file. If MyModule.js were a disk or web file, you could skip that step.

Good luck!

[Aenge]

dynamic module1 =   ((Task<object>)engine.Evaluate("import('MyModule1.js')")).Result;
dynamic module2 =   ((Task<object>)engine.Evaluate("import('MyModule2.js')")).Result;
...

Can I do something like this, where I evaluate all scripts once, store all of their results dynamically, and access the dynamic variables whenever I need something from that script?

[ClearScriptLib]

Can I do something like this, where I evaluate all scripts once, store all of their results dynamically, and access the dynamic variables whenever I need something from that script?

Absolutely. Script objects such as module1 and module2 remain valid until their parent script engine is disposed. After that they'll throw exceptions when accessed.