ui-frontend
diff --git a/‎__tests__/Conversion.ts
Lines changed: 23 additions & 1 deletion b/‎__tests__/Conversion.ts
Lines changed: 23 additions & 1 deletion
diff --git a/‎dist/Immutable.d.ts
Lines changed: 2 additions & 1 deletion b/‎dist/Immutable.d.ts
Lines changed: 2 additions & 1 deletion
diff --git a/‎dist/Record.js
Lines changed: 27 additions & 21 deletions b/‎dist/Record.js
Lines changed: 27 additions & 21 deletions
diff --git a/‎dist/Sequence.js
Lines changed: 82 additions & 48 deletions b/‎dist/Sequence.js
Lines changed: 82 additions & 48 deletions
@@ -45,7 +45,7 @@ describe('Conversion', () => {
     list: [1, 2, 3]
   };
 
-  var Point = Immutable.Record({x:0, y:0});
+  var Point = Immutable.Record({x:0, y:0}, 'Point');
 
   var immutableData = Map({
     deepList: Vector(
@@ -89,6 +89,27 @@ describe('Conversion', () => {
     list: Vector(1, 2, 3)
   });
 
+  var immutableOrderedDataString = 'OrderedMap { ' +
+    'deepList: Vector [ '+
+      'OrderedMap { '+
+        'position: "first"'+
+      ' }, ' +
+      'OrderedMap { '+
+        'position: "second"'+
+      ' }, '+
+      'OrderedMap { '+
+        'position: "third"'+
+      ' }' +
+    ' ], '+
+    'deepMap: OrderedMap { '+
+      'a: "A", '+
+      'b: "B"'+
+    ' }, '+
+    'point: Point { x: 10, y: 20 }, '+
+    'string: "Hello", '+
+    'list: Vector [ 1, 2, 3 ]'+
+  ' }';
+
   it('Converts deep JS to deep immutable sequences', () => {
     expect(Immutable.fromJSON(js)).is(immutableData);
   });
@@ -101,6 +122,7 @@ describe('Conversion', () => {
       return Array.isArray(this[key]) ? sequence.toVector() : sequence.toOrderedMap();
     });
     expect(seq).is(immutableOrderedData);
+    expect(seq.toString()).is(immutableOrderedDataString);
   });
 
   it('Converts deep sequences to JSON', () => {
 
@@ -993,7 +993,8 @@ export declare function OrderedMap<V>(array: Array<V>): Map<number, V>;
  *     myRecord.getAB() // 4
  *
  */
-export declare function Record(defaultValues: Object): RecordClass;
+export declare function Record(defaultValues: Sequence<string, any>, name?: string): RecordClass;
+export declare function Record(defaultValues: {[key: string]: any}, name?: string): RecordClass;
 
 export interface RecordClass {
   new (): Map<string, any>;
 
@@ -8,26 +8,29 @@ for(var Sequence____Key in Sequence){if(Sequence.hasOwnProperty(Sequence____Key)
     var RecordType = function(values) {
       this.$Record_map = ImmutableMap(values);
     };
+    defaultValues = Sequence(defaultValues);
     RecordType.prototype = Object.create(Record.prototype);
     RecordType.prototype.constructor = RecordType;
     RecordType.prototype.$Record_name = name;
     RecordType.prototype.$Record_defaultValues = defaultValues;
 
     var keys = Object.keys(defaultValues);
     RecordType.prototype.length = keys.length;
-    keys.forEach(function(key)  {
-      Object.defineProperty(RecordType.prototype, key, {
-        get: function() {
-          return this.get(key);
-        },
-        set: function(value) {
-          if (!this.__ownerID) {
-            throw new Error('Cannot set on an immutable record.');
+    if (Object.defineProperty) {
+      defaultValues.forEach(function(_, key)  {
+        Object.defineProperty(RecordType.prototype, key, {
+          get: function() {
+            return this.get(key);
+          },
+          set: function(value) {
+            if (!this.__ownerID) {
+              throw new Error('Cannot set on an immutable record.');
+            }
+            this.set(key, value);
           }
-          this.set(key, value);
-        }
-      });
-    }.bind(this));
+        });
+      }.bind(this));
+    }
 
     return RecordType;
   }
@@ -39,14 +42,14 @@ for(var Sequence____Key in Sequence){if(Sequence.hasOwnProperty(Sequence____Key)
   // @pragma Access
 
   Record.prototype.has=function(k) {"use strict";
-    return this.$Record_defaultValues.hasOwnProperty(k);
+    return this.$Record_defaultValues.has(k);
   };
 
   Record.prototype.get=function(k, undefinedValue) {"use strict";
     if (undefinedValue !== undefined && !this.has(k)) {
       return undefinedValue;
     }
-    return this.$Record_map.get(k, this.$Record_defaultValues[k]);
+    return this.$Record_map.get(k, this.$Record_defaultValues.get(k));
   };
 
   // @pragma Modification
@@ -63,19 +66,22 @@ for(var Sequence____Key in Sequence){if(Sequence.hasOwnProperty(Sequence____Key)
     if (k == null || !this.has(k)) {
       return this;
     }
-    if (this.__ownerID) {
-      this.$Record_map.set(k, v);
-      return this;
-    }
     var newMap = this.$Record_map.set(k, v);
-    if (newMap === this.$Record_map) {
+    if (this.__ownerID || newMap === this.$Record_map) {
       return this;
     }
     return this.$Record_make(newMap);
   };
 
   Record.prototype.delete=function(k) {"use strict";
-    return this.set(k, this.$Record_defaultValues[k]);
+    if (k == null || !this.has(k)) {
+      return this;
+    }
+    var newMap = this.$Record_map.delete(k);
+    if (this.__ownerID || newMap === this.$Record_map) {
+      return this;
+    }
+    return this.$Record_make(newMap);
   };
 
   // @pragma Mutability
@@ -97,7 +103,7 @@ for(var Sequence____Key in Sequence){if(Sequence.hasOwnProperty(Sequence____Key)
 
   Record.prototype.__iterate=function(fn, reverse) {"use strict";
     var record = this;
-    return Sequence(this.$Record_defaultValues).map(function(_, k)  {return record.get(k);}).__iterate(fn, reverse);
+    return this.$Record_defaultValues.map(function(_, k)  {return record.get(k);}).__iterate(fn, reverse);
   };
 
   Record.prototype.$Record_empty=function() {"use strict";
 
@@ -11,21 +11,12 @@ var Immutable = require('./Immutable');
       }
       if (!Array.isArray(value)) {
         if (value && value.constructor === Object) {
-          var keys = Object.keys(value);
-          var objectSequence = makeSequence();
-          objectSequence.length = keys.length;
-          objectSequence.toObject = function()  {return value;};
-          objectSequence.__iterate = objectIterator.bind(null, value, keys);
-          return objectSequence;
+          return new ObjectSequence(value);
         }
         value = [value];
       }
     }
-    var arraySequence = makeIndexedSequence();
-    arraySequence.length = value.length;
-    arraySequence.toArray = function()  {return value;};
-    arraySequence.__iterate = arrayIterator.bind(null, value);
-    return arraySequence;
+    return new ArraySequence(value);
   }
 
   Sequence.prototype.toString=function() {"use strict";
@@ -40,7 +31,7 @@ var Immutable = require('./Immutable');
   };
 
   Sequence.prototype.__toStringMapper=function(v, k) {"use strict";
-    return quoteString(k) + ': ' + quoteString(v);
+    return k + ': ' + quoteString(v);
   };
 
   Sequence.prototype.toJSON=function() {"use strict";
@@ -707,6 +698,85 @@ IndexedSequence.prototype.__toJS = IndexedSequence.prototype.toArray;
 IndexedSequence.prototype.__toStringMapper = quoteString;
 
 
+for(Sequence____Key in Sequence){if(Sequence.hasOwnProperty(Sequence____Key)){ObjectSequence[Sequence____Key]=Sequence[Sequence____Key];}}ObjectSequence.prototype=Object.create(____SuperProtoOfSequence);ObjectSequence.prototype.constructor=ObjectSequence;ObjectSequence.__superConstructor__=Sequence;
+  function ObjectSequence(object) {"use strict";
+    var keys = Object.keys(object);
+    this.$ObjectSequence_object = object;
+    this.$ObjectSequence_keys = keys;
+    this.length = keys.length;
+  }
+
+  ObjectSequence.prototype.toObject=function() {"use strict";
+    return this.$ObjectSequence_object;
+  };
+
+  ObjectSequence.prototype.get=function(key, undefinedValue) {"use strict";
+    if (undefinedValue !== undefined && !this.has(key)) {
+      return undefinedValue;
+    }
+    return this.$ObjectSequence_object[key];
+  };
+
+  ObjectSequence.prototype.has=function(key) {"use strict";
+    return this.$ObjectSequence_object.hasOwnProperty(key);
+  };
+
+  ObjectSequence.prototype.__iterate=function(fn, reverse) {"use strict";
+    var object = this.$ObjectSequence_object;
+    var keys = this.$ObjectSequence_keys;
+    var maxIndex = keys.length - 1;
+    for (var ii = 0; ii <= maxIndex; ii++) {
+      var iteration = reverse ? maxIndex - ii : ii;
+      if (fn(object[keys[iteration]], keys[iteration], object) === false) {
+        break;
+      }
+    }
+    return ii;
+  };
+
+
+
+for(var IndexedSequence____Key in IndexedSequence){if(IndexedSequence.hasOwnProperty(IndexedSequence____Key)){ArraySequence[IndexedSequence____Key]=IndexedSequence[IndexedSequence____Key];}}var ____SuperProtoOfIndexedSequence=IndexedSequence===null?null:IndexedSequence.prototype;ArraySequence.prototype=Object.create(____SuperProtoOfIndexedSequence);ArraySequence.prototype.constructor=ArraySequence;ArraySequence.__superConstructor__=IndexedSequence;
+  function ArraySequence(array) {"use strict";
+    this.$ArraySequence_array = array;
+    this.length = array.length;
+  }
+
+  ArraySequence.prototype.toArray=function() {"use strict";
+    return this.$ArraySequence_array;
+  };
+
+  ArraySequence.prototype.__iterate=function(fn, reverse, flipIndices) {"use strict";
+    var array = this.$ArraySequence_array;
+    var maxIndex = array.length - 1;
+    var lastIndex = -1;
+    if (reverse) {
+      for (var ii = maxIndex; ii >= 0; ii--) {
+        if (array.hasOwnProperty(ii) &&
+            fn(array[ii], flipIndices ? ii : maxIndex - ii, array) === false) {
+          return lastIndex + 1;
+        }
+        lastIndex = ii;
+      }
+      return array.length;
+    } else {
+      var didFinish = array.every(function(value, index)  {
+        if (fn(value, flipIndices ? maxIndex - index : index, array) === false) {
+          return false;
+        } else {
+          lastIndex = index;
+        }
+      });
+      return didFinish ? array.length : lastIndex + 1;
+    }
+  };
+
+
+ArraySequence.prototype.get = ObjectSequence.prototype.get;
+ArraySequence.prototype.has = ObjectSequence.prototype.has;
+
+
 function makeSequence() {
   return Object.create(Sequence.prototype);
 }
@@ -717,42 +787,6 @@ function makeIndexedSequence(parent) {
   return newSequence;
 }
 
-function arrayIterator(array, fn, reverse, flipIndices) {
-  var maxIndex = array.length - 1;
-  var lastIndex = -1;
-  if (reverse) {
-    for (var ii = maxIndex; ii >= 0; ii--) {
-      if (array.hasOwnProperty(ii) &&
-          fn(array[ii], flipIndices ? ii : maxIndex - ii, array) === false) {
-        return lastIndex + 1;
-      }
-      lastIndex = ii;
-    }
-    return array.length;
-  } else {
-    var didFinish = array.every(function(value, index)  {
-      if (fn(value, flipIndices ? maxIndex - index : index, array) === false) {
-        return false;
-      } else {
-        lastIndex = index;
-        return true;
-      }
-    });
-    return didFinish ? array.length : lastIndex + 1;
-  }
-}
-
-function objectIterator(object, keys, fn, reverse) {
-  var maxIndex = keys.length - 1;
-  for (var ii = 0; ii <= maxIndex; ii++) {
-    var iteration = reverse ? maxIndex - ii : ii;
-    if (fn(object[keys[iteration]], keys[iteration], object) === false) {
-      break;
-    }
-  }
-  return ii;
-}
-
 function getInDeepSequence(seq, keyPath, notFoundValue, pathOffset) {
   var nested = seq.get ? seq.get(keyPath[pathOffset], __SENTINEL) : __SENTINEL;
   if (nested === __SENTINEL) {