Inconsistency with "typeof" results

[Muchaszewski]

As of now I couldn't find a good way of creating internal JavaScript objects from text to pass them into engine, so I'm using kind of hack

        public static object CreateObject(string document)
        {
            var sb = new StringBuilder();
            sb.Append($"var __obj__ = {document}");
            _engine.ExecuteCommand(sb.ToString());
            return _engine.Script.__obj__;   
        } 

This method produces a mostly valid "object" for most of the purposes but typeof from this object returns function instead of the required type such as array or object etc...

This being mentioned such code is returning false
C#

managed.setScriptData("csharpObjectFromText", JSUtils.CreateObject("[]"));
V8ScriptEngine.Execute(script); 

JS

var array = Managed.getScriptData("csharpObjectFromText");
if(typeof array === typeof []) //expected true

I just hope this is not my misunderstanding of javascript objects using ClearScript.

[ClearScriptLib]

Hi @Muchaszewski,

First, your CreateObject method could simply be this:

public static object CreateObject(string document)
{
    return _engine.Evaluate(document);
}

Second, how do setScriptData and getScriptData work?

[Muchaszewski]

Thanks for a tip.

Those methods are pretty straightforward. Just dictionary storage.

        public Dictionary<string, object> ScriptResults = new Dictionary<string, object>();

        public void setScriptData(string name, object value)
        {
            ScriptResults[name] = value;
        }

        public object getScriptData(string name)
        {
            if (ScriptResults.ContainsKey(name))
            {
                return ScriptResults[name];
            }
            return null;
        }

[ClearScriptLib]

@Muchaszewski, is it possible that, when your script calls getScriptData, it gets an object that was created by a different instance of V8ScriptEngine? That would explain what you're seeing.

A script engine cannot be given direct access to an object created by another script engine, so ClearScript provides a proxy that marshals invocations across script engine boundaries. JavaScript's typeof always returns "function" when applied to a ClearScript proxy.

Note that, although ClearScript supports this setup, it isn't recommended. Invocations across script engines incur heavy overhead, and the full capabilities of the target object may not be accessible.

If the object belongs to the same script engine, ClearScript should hand it off without a proxy, resulting in the expected behavior. Please let us know if that's not the case.

[Muchaszewski]

I confirm that the case. CreateObject is using a different instance of V8ScriptEngine. This is due to the limitation I have encountered. Settings up Engine.MaxRuntimeStackUsage = 50 and invoking CreateObject always created stack overflow on complicated enough objects, or when reaching stack limit and trying to create anything.

My idea to prevent developers from passing object from different instances of an engine, and making them wonder about errors that can occur from that, simple check and a setting for instantiation of an engine.

Engine = new V8ScriptEngine();
Engine.AllowProxyObjects = true; //Default is false

[ClearScriptLib]

@Muchaszewski, the runtime stack usage limit is specified in bytes. A value of 50 actually selects an internal minimum, which is currently 16 KiB, and while that may be enough to run simple scripts, it's not surprising that you can easily overflow it by calling into the host and back out to script code.

Consider increasing that limit, or not specifying one at all. A higher limit will let you reign in runaway scripts without having to deal with the overhead of external script objects.

[Muchaszewski]

Ok. I will close this ticket as the issue with inconsistency is solved.

As mentioned above would be nice to have documentation on that behavior that multiple V8ScriptEngine "talking" to each other may cause an error, this is not so obvious as my example has shown :)