Add JSNative utility class with static methods methods to efficiently manipulate typed JSInterop ob…

sdk/lib/js/dart2js/js_dart2js.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * Support for interoperating with JavaScript.
  *
  * This library provides access to JavaScript objects from Dart, allowing
  * Dart code to get and set properties, and call methods of JavaScript objects
  * and invoke JavaScript functions. The library takes care of converting
@@ skipping 689 matching lines @@
 }
 
 _callDartFunctionFast(callback, List arguments) {
   return Function.apply(callback, arguments);
 }
 
 _callDartFunctionFastCaptureThis(callback, self, List arguments) {
   return Function.apply(callback, [self]..addAll(arguments));
 }
 
-Function /*=F*/ allowInterop/*<F extends Function>*/(Function /*=F*/ f) {
+Function/*=F*/ allowInterop/*<F extends Function>*/(Function/*=F*/ f) {
   if (JS('bool', 'typeof(#) == "function"', f)) {
     // Already supports interop, just use the existing function.
     return f;
   } else {
     return _convertDartFunctionFast(f);
   }
 }
 
 Function allowInteropCaptureThis(Function f) {
   if (JS('bool', 'typeof(#) == "function"', f)) {
     // Behavior when the function is already a JS function is unspecified.
     throw new ArgumentError(
         "Function is already a JS function so cannot capture this.");
     return f;
   } else {
     return _convertDartFunctionFastCaptureThis(f);
   }
 }
+
+/// Utility methods to efficiently manipulate typed JSInterop objects in cases
+/// where the name to call is not known at runtime. You should only use these
+/// methods when the same effect cannot be achieved with @JS annotations.
+/// These methods would be extension methods on JSObject if Dart supported
+/// extension methods.
+class JSNative {

[sra1, 2016/07/20 18:19:20]

Maybe call JSUtils ? JavaScriptUtils ?
Or a dart:library

[Jacob, 2016/07/22 19:28:24]

added
dart:js_util

re-export it as 
package:js/js_util.dart
as we don't really want to be adding new dart:libraries

+  /**
+    * WARNING: performance of this method is much worse than other methods
+    * in JSNative. Only use this method as a last resort.
+    *
+    * Recursively converts a JSON-like collection of Dart objects to a
+    * collection of JavaScript objects and returns a [JsObject] proxy to it.
+    *
+    * [object] must be a [Map] or [Iterable], the contents of which are also
+    * converted. Maps and Iterables are copied to a new JavaScript object.
+    * Primitives and other transferrable values are directly converted to their
+    * JavaScript type, and all other objects are proxied.
+    */
+  static jsify(object) {
+    if ((object is! Map) && (object is! Iterable)) {
+      throw new ArgumentError("object must be a Map or Iterable");
+    }
+    return _convertDataTree(object);
+  }
+
+  static _convertDataTree(data) {
+    var _convertedObjects = new HashMap.identity();
+
+    _convert(o) {
+      if (_convertedObjects.containsKey(o)) {
+        return _convertedObjects[o];
+      }
+      if (o is Map) {
+        final convertedMap = JS('=Object', '{}');
+        _convertedObjects[o] = convertedMap;
+        for (var key in o.keys) {
+          JS('=Object', '#[#]=#', convertedMap, key, _convert(o[key]));
+        }
+        return convertedMap;
+      } else if (o is Iterable) {
+        var convertedList = [];
+        _convertedObjects[o] = convertedList;
+        convertedList.addAll(o.map(_convert));
+        return convertedList;
+      } else {
+        return o;
+      }
+    }
+
+    return _convert(data);
+  }
+
+  static JSObject newObject() => JS('=Object', '{}');
+
+  static hasProperty(o, name) => JS('bool', '# in #', name, o);
+  static getProperty(o, name) => JS('Object', '#[#]', o, name);
+  static setProperty(o, name, value) => JS('', '#[#]=#', o, name, value);
+
+  static callMethod(o, String method, List args) =>
+      JS('Object', '#[#].apply(#, #)', o, method, o, args);
+
+  static instanceof(o, Function type) => JS('bool', '# instanceof #', o, type);

[sra1, 2016/07/20 18:19:20]

instanceOf ?

[Jacob, 2016/07/22 19:28:24]

ran it by Bob and he thinks it is reasonable to stay consistent with the JS
names rather than dartifying the names as this is a low level JS interop utility
library.

+  static callConstructor(Function constr, List arguments) {
+    if (arguments == null) {
+      return JS('Object', 'new #()', constr);
+    }
+
+    if (JS('bool', '# instanceof Array', arguments)) {
+      int argumentCount = JS('int', '#.length', arguments);
+      switch (argumentCount) {
+        case 0:
+          return JS('Object', 'new #()', constr);
+
+        case 1:
+          var arg0 = JS('', '#[0]', arguments);
+          return JS('Object', 'new #(#)', constr, arg0);
+
+        case 2:
+          var arg0 = JS('', '#[0]', arguments);
+          var arg1 = JS('', '#[1]', arguments);
+          return JS('Object', 'new #(#, #)', constr, arg0, arg1);
+
+        case 3:
+          var arg0 = JS('', '#[0]', arguments);
+          var arg1 = JS('', '#[1]', arguments);
+          var arg2 = JS('', '#[2]', arguments);
+          return JS('Object', 'new #(#, #, #)', constr, arg0, arg1, arg2);
+
+        case 4:
+          var arg0 = JS('', '#[0]', arguments);
+          var arg1 = JS('', '#[1]', arguments);
+          var arg2 = JS('', '#[2]', arguments);
+          var arg3 = JS('', '#[3]', arguments);
+          return JS(
+              'Object', 'new #(#, #, #, #)', constr, arg0, arg1, arg2, arg3);
+      }
+    }
+
+    // The following code solves the problem of invoking a JavaScript
+    // constructor with an unknown number arguments.
+    // First bind the constructor to the argument list using bind.apply().
+    // The first argument to bind() is the binding of 'this', so add 'null' to
+    // the arguments list passed to apply().
+    // After that, use the JavaScript 'new' operator which overrides any binding
+    // of 'this' with the new instance.
+    var args = [null]..addAll(arguments);
+    var factoryFunction = JS('', '#.bind.apply(#, #)', constr, constr, args);
+    // Without this line, calling factoryFunction as a constructor throws
+    JS('String', 'String(#)', factoryFunction);
+    // This could return an UnknownJavaScriptObject, or a native
+    // object for which there is an interceptor
+    return JS('Object', 'new #()', factoryFunction);
+
+    // TODO(sra): Investigate:
+    //
+    //     var jsObj = JS('', 'Object.create(#.prototype)', constr);
+    //     JS('', '#.apply(#, #)', constr, jsObj,
+    //         []..addAll(arguments.map(_convertToJS)));
+    //     return _wrapToDart(jsObj);
+  }
+}