Merge branch 'master' into typedarray_parser

src/common/Clone.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Copyright (c) 2016 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { assert, expect } from 'chai';
+import { clone } from './Clone';
+
+describe('clone', () => {
+  it('should clone simple objects', () => {
+    const test = {
+      a: 1,
+      b: 2
+    };
+
+    assert.deepEqual(clone(test), { a: 1, b: 2 });
+  });
+
+  it('should clone nested objects', () => {
+    const test = {
+      bar: {
+        a: 1,
+        b: 2,
+        c: {
+          foo: 'bar'
+        }
+      }
+    };
+
+    assert.deepEqual(clone(test), {
+      bar: {
+        a: 1,
+        b: 2,
+        c: {
+          foo: 'bar'
+        }
+      }
+    });
+  });
+
+  it('should clone null values', () => {
+    const test: any = {
+      a: null
+    };
+
+    assert.deepEqual(clone(test), { a: null });
+  });
+
+  it('should clone array values', () => {
+    const test = {
+      a: [1, 2, 3],
+      b: [1, null, 'test', { foo: 'bar' }]
+    };
+
+    assert.deepEqual(clone(test), {
+      a: [1, 2, 3],
+      b: [1, null, 'test', { foo: 'bar' }]
+    });
+  });
+
+  it('should stop mutation from occuring on the original object', () => {
+    const test = {
+      a: 1,
+      b: 2,
+      c: {
+        foo: 'bar'
+      }
+    };
+
+    const cloned = clone(test);
+
+    test.a = 5;
+    test.c.foo = 'barbaz';
+
+    assert.deepEqual(cloned, {
+      a: 1,
+      b: 2,
+      c: {
+        foo: 'bar'
+      }
+    });
+  });
+
+  it('should clone to a maximum depth of 5 by default', () => {
+    const test = {
+      a: {
+        b: {
+          c: {
+            d: {
+              e: {
+                f: 'foo'
+              }
+            }
+          }
+        }
+      }
+    };
+
+    const cloned = clone(test);
+
+    test.a.b.c.d.e.f = 'bar';
+
+    // The values at a greater depth then 5 should not be cloned
+    assert.equal((cloned as any).a.b.c.d.e.f, 'bar');
+  });
+
+  it('should allow an optional maximum depth to be set', () => {
+    const test = {
+      a: {
+        b: {
+          c: 'foo'
+        }
+      }
+    };
+
+    const cloned = clone(test, 2);
+
+    test.a.b.c = 'bar';
+
+    // The values at a greater depth then 2 should not be cloned
+    assert.equal((cloned as any).a.b.c, 'bar');
+  });
+
+  it('should not throw when cloning a recursive reference', () => {
+    const test = {
+      a: {
+        b: {
+          c: {}
+        }
+      }
+    };
+
+    test.a.b.c = test;
+
+    expect(() => clone(test)).to.not.throw();
+  });
+});

src/common/Clone.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2016 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+/*
+ * A simple utility for cloning values
+ */
+export function clone<T>(val: T, depth: number = 5): T | null {
+  if (typeof val !== 'object') {
+    return val;
+  }
+
+  // cloning null always returns null
+  if (val === null) {
+    return null;
+  }
+
+  // If we're cloning an array, use an array as the base, otherwise use an object
+  const clonedObject: any = Array.isArray(val) ? [] : {};
+
+  for (const key in val) {
+    // Recursively clone eack item unless we're at the maximum depth
+    clonedObject[key] = depth <= 1 ? val[key] : clone(val[key], depth - 1);
+  }
+
+  return clonedObject as T;
+}