How to call Objective-C NSExpression( format: ....) from NativeScript? - ios

Question

I am working on expanding the NativeScript-Mapbox plugin to include the ability to render circles that resize as the map is zoomed. I am working off the example on this page.
On iOS, I am running into problem trying to translate this NSExpression call into NativeScript:
layer.circleRadius = [NSExpression expressionWithFormat: #"mgl_interpolate:withCurveType:parameters:stops:($zoomLevel, 'exponential', 1.75, %#)",
#{#12: #2, #22: #180}];
It looks to me that the NativeScript analogue to this call listed in tns-platform-declarations .. objc!Foundation.d.ts NSExpression definition is:
static expressionWithFormatArgumentArray(expressionFormat: string, _arguments: NSArray<any>): NSExpression;
Is this the correct method?
If so, how do I turn [12: 2, 22: 180] into an NSArray type?
Lacking documentation, I have tried creating an array of arrays and passing it to:
new NSArray( {objects: myArray} );
but it crashes horribly with a segfault.
Clearly, I am missing something.

Answer 1

The swift (not objective-c) object you're dealing with there is not an array, but a dictionary.
import Swift
print(type(of: [12: 2, 22: 180]))
// Dictionary<Int, Int>
The array that it's expecting is an array of all of the format substitution parameters that you want; in this case, that array is of length 1 and contains just the dictionary. You could translate this into your NativeScript JavaScript/TypeScript:
const expr = NSExpression.expressionWithFormatArgumentArray(
"mgl_interpolate:withCurveType:parameters:stops:($zoomLevel, 'exponential', 1.75, %#)",
[{12: 2, 22: 180}]);

Answer 2

To manually create an Native iOS object; it is almost always:
const x = NSArray.alloc().init();'
or
const y = new NSArray();
However a couple notes;
You almost always want to use NSMutableArray() rather than just plain NSArray as NSArray is static; and Mutable means you can change it. Since you are creating it in JS; you have to add the values to it after you create it so Mutable is the type you almost always need.
You can use new NSMutableArray(); in most cases; however I have ran in to cases where new doesn't work properly vs .alloc().init() on some native iOS objects even though new is basically is a wrapper that does .alloc().init(). I recommend you just always do .alloc().init() just to keep things consistent.;
If the iOS function call specifically takes an NSArray; then you can do things like this:
const myNSArray = NSArray.arrayWithArray([1,2,3,4,5]);
In this example; myNSArray would now be an NSArray object, and the [1,2,3,4,5] was originally a JS array object we passed in. By default calling any iOS function that expects a NSArray will auto-convert any JavaScript Array into a NSArray for you. Marshaling of most data types are automatically done for you.
If the iOS function has no valid types (i.e. a vardef type); or if the function has a variable number of arguments; then NativeScript may not be able to call it at all, and as such will crash with an error when you try.
Finally, if you have other questions on how to do things JS to iOS (or Android) in NativeScript; I would recommend you search on that keyword at http://searchcode.nativescript.rocks and then peruse the source code it finds that is using those specific keywords.
As for the NSExpression part of the question
const expr = NSExpression.expressionWithFormatArgumentArray(
"mgl_interpolate:withCurveType:parameters:stops:($zoomLevel, 'exponential', 1.75, %#)",
NSArray.arrayWithArray([NSDictionary.dictionaryWithDictionary({12: 2, 22: 180})]));
Because an Array has no specific object type that can go in it, it is safer to force the object type that we are putting into it as a NSDictionary as that is what iOS will be expecting. And just to make sure that what is being passed to the expressWithFormatArgumentArray is an NSArray, we are wrapping the JSArray we created with the NSArray.arrayWithArray() call. You can probably get away just doing [{}] but TS sometimes hates not knowing the types of things.

Answer 3

Ok, just to loop back and finish up this thread, I have /finally/ figured out how to get this to work without crashing.
The method requires an array with an NSDictionary type in it and it appears the NativeScript type definition for NSDictionary is incorrect per this issue and this one.
So after a few days of trial and error, converting the Objective-C call:
layer.circleRadius = [NSExpression expressionWithFormat: #"mgl_interpolate:withCurveType:parameters:stops:($zoomLevel, 'exponential', 1.75, %#)",
#{#12: #2, #22: #180}];
into TypeScript/NativeScript is completely counterintuitive:
let nsDict = new (NSDictionary as any)( [ 2, 180 ], [ 12, 22 ] );
let nsArray = NSArray.arrayWithArray( [ nsDict ] );
layer.circleRadius = NSExpression.expressionWithFormatArgumentArray(
"mgl_interpolate:withCurveType:parameters:stops:($zoomLevel, 'exponential', 1.75, %#)", nsArray );
This compiles and works. Note that the keys are in a separate array that follow the values, not the other way around.
If you use the NSDictionary approach suggested above you get a compile error because apparently the typing doesn't support that notation.
Upgrading to the latest NativeScript and core modules did allow it to compile the suggested NSArray() [] reference but the resulting code causes an exception:, namely:
const expr = NSExpression.expressionWithFormatArgumentArray( "mgl_interpolate:withCurveType:parameters:stops:($zoomLevel, 'exponential', 1.75, %#)", [{12: 2, 22: 180}]);
crashes with an exception.
The array, as far as I am able to tell, is not correctly marshalled into an NSDictionary instance. Same for using NSArray.arrayWithArray( [ ... ] );