JavaScript - Revision history

94.15.232.180: /* Can I run x - How compliant is the JavaScript in PowerUI? */

2018-09-06T00:18:45Z

‎Can I run x - How compliant is the JavaScript in PowerUI?

94.15.232.180 at 00:16, 6 September 2018

2018-09-06T00:16:43Z

Show changes

TheLogan: /* Calling JS from C# */

2017-12-01T09:30:56Z

‎Calling JS from C#

Bablakeluke: /* Passing Ambiguous Functions */

2017-04-21T07:42:28Z

‎Passing Ambiguous Functions

Bablakeluke: /* Passing Ambiguous Functions */

2017-04-21T07:42:09Z

‎Passing Ambiguous Functions

Bablakeluke: /* Passing Ambiguous Functions */

2017-04-21T07:40:11Z

‎Passing Ambiguous Functions

Bablakeluke: /* Passing Ambiguous Functions */

2017-04-21T07:38:55Z

‎Passing Ambiguous Functions

Bablakeluke: /* Interaction with the rest of your code */

2017-04-21T07:36:34Z

‎Interaction with the rest of your code

Bablakeluke at 03:40, 21 April 2017

2017-04-21T03:40:03Z

Bablakeluke: /* Can I run x - How compliant is the JavaScript in PowerUI? */

2017-04-21T02:47:49Z

‎Can I run x - How compliant is the JavaScript in PowerUI?

@@ Line 13: / Line 13: @@
 == Can I run x - How compliant is the JavaScript in PowerUI? ==
-The best option? Just try it and see what happens! At the moment, this depends on the Web API's that you intend to use. PowerUI currently has broad support for a variety of web APIs.
+The best option? Just try it and see what happens! At the moment, this depends on the Web API's that you intend to use. PowerUI currently has broad support for a variety of web APIs. The API coverage is enough such that jQuery and basic React works for example.
 == Interaction with the rest of your code ==

← Older revision		Revision as of 09:30, 1 December 2017
Line 186:		Line 186:

	=== Calling JS from C# ===		=== Calling JS from C# ===
		+
		+	==== JavaScript ====
		+	With the new JavaScript engine calling JS from C# is as easy as
		+
		+	<syntaxhighlight lang="javascript">
		+	document.Run("FunctionName", Arguments);
		+	</syntaxhighlight>
		+
		+	==== Nitrasic - ''obsolete''====

	You'll want to get the ScriptEngine and use the CallGlobalFunction method. Work in progress!		You'll want to get the ScriptEngine and use the CallGlobalFunction method. Work in progress!

@@ Line 165: / Line 165: @@
+     }
+}
 And how the above affects the JavaScript is like so:

@@ Line 165: / Line 165: @@
+     }
+}
 </syntaxhighlight>

@@ Line 156: / Line 156: @@
          if(typeValue == null || typeValue == "string"){
-             // It's not a constant string. Can't disambiguate (fallback on a default):
+             // It's not a constant string - Can't disambiguate (fallback on a default)
              return group.Match(new Type[]{typeof(string), typeof(Action<string>)});
+         }

@@ Line 128: / Line 128: @@
 </syntaxhighlight>
-Whenever one of your functions is ambiguous, it should define a special disambiguation method. The one for addEventListener uses that first argument to figure out the most appropriate one is (e.g. when it spots 'mousedown' it knows it's a MouseEvent). Here's how to define a disambiguation method:
+Whenever one of your functions is ambiguous, it should define a special disambiguation method. The one for addEventListener uses that first argument to figure out the most appropriate one (e.g. when it spots 'mousedown' it knows it's a MouseEvent). Here's how to define a disambiguation method:
 <syntaxhighlight lang="csharp">

@@ Line 59: / Line 59: @@
 == Interaction with the rest of your code ==
-Nitrassic like C# is a .NET language - that means they can call each other with no overhead when crossing the boundary. In short, you get the best of all worlds because it acts like JavaScript with all of the types available to C# being also available to the JavaScript engine.
+Nitrassic's JavaScript is a .NET language like C# - that means they can call each other with no overhead when crossing the boundary. In short, you get the best of all worlds because it acts like JavaScript with all of the types available to C# being also available to the JavaScript engine.
 === Calling C#/Unity methods from JS ===

← Older revision		Revision as of 03:40, 21 April 2017
Line 56:		Line 56:

	We're working on the above points and any help with that would be greatly appreciated!		We're working on the above points and any help with that would be greatly appreciated!
		+
		+	== Interaction with the rest of your code ==
		+
		+	Nitrassic like C# is a .NET language - that means they can call each other with no overhead when crossing the boundary. In short, you get the best of all worlds because it acts like JavaScript with all of the types available to C# being also available to the JavaScript engine.
		+
		+	=== Calling C#/Unity methods from JS ===
		+
		+	Nitrassic has no particular issues calling C# methods from your project - it "just works" unless you explicitly block it from doing so:
		+
		+	<syntaxhighlight lang="javascript">
		+
		+	// You can use the Unity API too:
		+	var go = new GameObject();
		+
		+	go.name = "MadeWithLoveByRealJavaScript";
		+
		+	// Or if you have some static C# class just call it like you would from C#:
		+	MyCSharpClass.HelloFromJavaScript();
		+
		+	</syntaxhighlight>
		+
		+	==== Passing Functions ====
		+
		+	This is an awesome aspect of Nitrassic and it's highly recommended you make use of it! If you pass a JavaScript function in the place of a delegate (or relatives, like Action) then it will automagically adopt that delegates type. Like this - here's the C#:
		+
		+	<syntaxhighlight lang="csharp">
		+
		+	public static class MyCallbacks{
		+
		+	public static void RunLater(Action<string> onDone){
		+	// ..Do something..
		+	onDone("Hello from C#!");
		+	}
		+
		+	}
		+
		+	</syntaxhighlight>
		+
		+	And here's the JavaScript:
		+
		+	<syntaxhighlight lang="javascript">
		+
		+	// Usually you'd use this for event based stuff.
		+	MyCallbacks.RunLater(function(a){
		+	// The type tracker knows 'a' is a string:
		+	console.log(a);
		+	});
		+
		+	</syntaxhighlight>
		+
		+
		+	==== Passing Ambiguous Functions ====
		+
		+	If your C# function is overloaded (there's multiple versions of it) then it might be ambiguous. addEventListener is a perfect example of when this happens:
		+
		+	<syntaxhighlight lang="javascript">
		+
		+	// Add a mousedown event listener:
		+	myElement.addEventListener("mousedown",function(e){
		+	// The type tracker is magic enough to figure out that
		+	// 'e' is a MouseEvent - the following has no runtime overhead:
		+	console.log(e.clientX);
		+	});
		+
		+	// Add a keydown event listener:
		+	myElement.addEventListener("keydown",function(e){
		+	// The type tracker is magic enough to figure out that
		+	// 'e' is a KeyboardEvent.
		+	});
		+
		+	</syntaxhighlight>
		+
		+	Whenever one of your functions is ambiguous, it should define a special disambiguation method. The one for addEventListener uses that first argument to figure out the most appropriate one is (e.g. when it spots 'mousedown' it knows it's a MouseEvent). Here's how to define a disambiguation method:
		+
		+	<syntaxhighlight lang="csharp">
		+
		+	public static class MyCallbacks{
		+
		+	// These two methods are ambiguous so we'll define a disambiguation method:
		+	[JSProperties(Disambiguation="RunLaterDisambig")]
		+	public static void RunLater(string type, Action<string> onDone){
		+	// ..Do something..
		+	onDone("Hello from C#!");
		+	}
		+
		+	public static void RunLater(string type, Action<int> onDone){
		+	// ..Do something..
		+	onDone(140);
		+	}
		+
		+	public MethodInfo RunLaterDisambig(MethodGroup group,FunctionCallExpression fce){
		+
		+	// This runs when compiling each call like MyCallbacks.RunLater("something",function(x){ });
		+	// 'group' is the set of 2 methods we need to select from.
		+	// 'fce' is the function call expression in the source which requires disambiguation.
		+
		+	// Assuming that we can identify which one to use based on that textual first arg, we can do this:
		+	string typeValue = fce.Arg(0) as string;
		+
		+	if(typeValue == null \|\| typeValue == "string"){
		+	// It's not a constant string. Can't disambiguate (fallback on a default):
		+	return group.Match(new Type[]{typeof(string), typeof(Action<string>)});
		+	}
		+
		+	// Otherwise use the int version:
		+	return group.Match(new Type[]{typeof(string), typeof(Action<int>)});
		+	}
		+	}
		+
		+	</syntaxhighlight>
		+
		+	=== Calling JS from C# ===
		+
		+	You'll want to get the ScriptEngine and use the CallGlobalFunction method. Work in progress!

← Older revision		Revision as of 02:47, 21 April 2017
Line 24:		Line 24:

	// A is both a string and a number. It 'collapses' to Object.		// A is both a string and a number. It 'collapses' to Object.
		+
		+	</syntaxhighlight>
		+
		+	Note that collapsing function arguments is perfectly fine:
		+
		+	<syntaxhighlight lang="javascript">
		+
		+	function Adder(a,b){
		+	return a+b;
		+	}
		+
		+	Adder(1,2);
		+	Adder("hello ","world!");

	</syntaxhighlight>		</syntaxhighlight>