WIP - some changes to the serializers.

This was originally part of #1294, and was reverted in c64e5f6

Author: jasongrout

jupyter-js-widgets/src/manager-base.ts

@@ -375,21 +375,18 @@ abstract class ManagerBase<T> {
      * @returns Promise for a state dictionary
      */
     get_state(options: StateOptions): Promise<any> {
-        var that = this;
-        return utils.resolvePromisesDict(this._models).then(function(models) {
-            var state = {};
-            for (var model_id in models) {
-                if (models.hasOwnProperty(model_id)) {
-                    var model = models[model_id];
-                    state[model_id] = utils.resolvePromisesDict({
-                        model_name: model.name,
-                        model_module: model.module,
-                        model_module_version: model.get('_model_module_version'),
-                        state: model.constructor._serialize_state(model.get_state(options.drop_defaults), that)
-                    });
-                }
-            }
-            return utils.resolvePromisesDict(state);
+        return utils.resolvePromisesDict(this._models).then((models) => {
+            let state = {};
+            Object.keys(models).forEach(model_id => {
+                let model = models[model_id];
+                state[model_id] = {
+                    model_name: model.name,
+                    model_module: model.module,
+                    model_module_version: model.get('_model_module_version'),
+                    state: model.serialize(model.get_state(options.drop_defaults))
+                };
+            });
+            return state;
         }).catch(utils.reject('Could not get state of widget manager', true));
     };
 

jupyter-js-widgets/src/widget.ts

@@ -383,31 +383,35 @@ class WidgetModel extends Backbone.Model {
     /**
      * Serialize widget state.
      *
-     * A serializer is a function which takes in a state attribute and a widget,
-     * and synchronously returns a JSONable object. The returned object will
+     * @param state - a dictionary of state to be serialized
+     *
+     * A serializer is a function which takes in a state value and an options object
+     * {manager: widget manager instance, model: model instance, key: state key},
+     * and synchronously returns a JSONable object. The state values in the returned object will
      * have toJSON called if possible, and the final result should be a
      * primitive object that is a snapshot of the widget state that may have
      * binary array buffers.
      */
     serialize(state) {
         const serializers = (this.constructor as typeof WidgetModel).serializers || {};
-        for (const k of state) {
+        let newState = {};
+        Object.keys(state).forEach(k => {
             try {
                 if (serializers[k] && serializers[k].serialize) {
-                    state[k] = (serializers[k].serialize)(state[k], this);
+                    newState[k] = (serializers[k].serialize)(state[k], {manager: this.widget_manager, model: this, key: k});
                 } else {
-                    // the default serializer just deep-copies the object
-                    state[k] = JSON.parse(JSON.stringify(state[k]));
+                    // the default serializer just deep-copies the value
+                    newState[k] = JSON.parse(JSON.stringify(state[k]));
                 }
-                if (state[k].toJSON) {
-                    state[k] = state[k].toJSON();
+                if (newState[k].toJSON) {
+                    newState[k] = newState[k].toJSON();
                 }
             } catch (e) {
                 console.error("Error serializing widget state attribute: ", k);
                 throw e;
             }
-        }
-        return state;
+        });
+        return newState;
     }
 
     send_sync_message(state, callbacks) {
@@ -487,28 +491,6 @@ class WidgetModel extends Backbone.Model {
         return utils.resolvePromisesDict(deserialized);
     }
 
-    /**
-     * Returns a promise for the serialized state. The second argument
-     * is an instance of widget manager.
-     */
-    static _serialize_state(state, manager) {
-        var serializers = this.serializers;
-        var serialized;
-        if (serializers) {
-            serialized = {};
-            for (var k in state) {
-                if (serializers[k] && serializers[k].serialize) {
-                     serialized[k] = (serializers[k].serialize)(state[k], manager);
-                } else {
-                     serialized[k] = state[k];
-                }
-            }
-        } else {
-            serialized = state;
-        }
-        return utils.resolvePromisesDict(serialized);
-    }
-
     static serializers: any;
     widget_manager: any;
     state_change: any