fix: fix Parcel.initialMeta value passing

packages/dataparcels/src/parcel/Parcel.js

@@ -338,7 +338,7 @@ export default class Parcel {
     modifyShapeDown = (updater: Function): Parcel => this._methods.modifyShapeDown(updater);
     modifyShapeUp = (updater: Function): Parcel => this._methods.modifyShapeUp(updater);
     modifyChange = (batcher: ParcelBatcher): Parcel => this._methods.modifyChange(batcher);
-    initialMeta = (initialMeta: ParcelMeta = {}): Parcel => this._methods.initialMeta(initialMeta);
+    initialMeta = (initialMeta: ParcelMeta): Parcel => this._methods.initialMeta(initialMeta);
     _boundarySplit = (config: *): Parcel => this._methods._boundarySplit(config);
 
     // Type methods

packages/dataparcels/src/parcel/__test__/ModifyMethods-test.js

@@ -240,47 +240,83 @@ test('Parcel.modifyShapeUp() should modify value', () => {
 });
 
 test('Parcel.initialMeta() should work', () => {
-    expect.assertions(3);
+    let handleChange = jest.fn();
 
-    let meta = {a:1, b:2};
+    let parcel = new Parcel({
+        value: 123,
+        handleChange
+    }).initialMeta({a:1, b:2});
 
-    var data = {
+    expect(parcel.data).toEqual({
         value: 123,
-        handleChange: (parcel: Parcel) => {
-            let {meta} = parcel.data;
-            expect({a:1, b:3}).toEqual(meta);
-            expect({a:1, b:3}).toEqual(parcel.initialMeta().meta);
-        }
-    };
+        meta: {
+            a: 1,
+            b: 2
+        },
+        child: undefined,
+        key: "^"
+    });
+
+    parcel.setMeta({b: 3});
 
-    let parcel = new Parcel(data).initialMeta(meta);
-    expect(meta).toEqual(parcel.meta);
-    parcel.setMeta({
-        b: 3
+    expect(handleChange.mock.calls[0][0].data).toEqual({
+        value: 123,
+        meta: {
+            a: 1,
+            b: 3
+        },
+        child: undefined,
+        key: "^"
     });
 });
 
 test('Parcel.initialMeta() should merge', () => {
-    expect.assertions(2);
+    let handleChange = jest.fn();
 
-    let meta = {a:1, b:2};
-    let meta2 = {b:1, c:3}; // this b will be ignored because it will have already been set by the time this is applied
+    let parcel = new Parcel({
+        value: 123,
+        handleChange
+    })
+        .initialMeta({a:1, b:2})
+        .initialMeta({b:3, c:4})
 
-    var data = {
+    expect(parcel.data).toEqual({
         value: 123,
-        handleChange: (parcel: Parcel) => {
-            let {meta} = parcel.data;
-            expect({a:1, b:3, c:3}).toEqual(meta);
-        }
-    };
+        meta: {
+            a: 1,
+            b: 2,
+            c: 4
+        },
+        child: undefined,
+        key: "^"
+    });
 
-    let parcel = new Parcel(data).initialMeta(meta).initialMeta(meta2);
-    expect({a:1, b:2, c:3}).toEqual(parcel.meta);
-    parcel.setMeta({
-        b: 3
+    parcel.setMeta({d: 5});
+
+    expect(handleChange.mock.calls[0][0].data).toEqual({
+        value: 123,
+        meta: {
+            a: 1,
+            b: 2,
+            c: 4,
+            d: 5
+        },
+        child: undefined,
+        key: "^"
     });
 });
 
+test('Parcel.initialMeta() should do nothing to data if all meta keys are already set', () => {
+
+    let parcel = new Parcel({
+        value: 123
+    }).initialMeta({a:1, b:2});
+
+    let parcel2 = parcel.initialMeta({a:1, b:2});
+
+    expect(parcel2.data).toEqual(parcel.data);
+});
+
 test('Sanity check: A big strange test of a big strange chain of deep updatery stuff', () => {
 
     let handleChange = jest.fn();

packages/dataparcels/src/parcel/methods/ModifyMethods.js

@@ -15,9 +15,7 @@ import filterNot from 'unmutable/lib/filterNot';
 import has from 'unmutable/lib/has';
 import isEmpty from 'unmutable/lib/isEmpty';
 import merge from 'unmutable/lib/merge';
-import set from 'unmutable/lib/set';
-import setIn from 'unmutable/lib/setIn';
-import pipe from 'unmutable/lib/util/pipe';
+import update from 'unmutable/lib/update';
 import pipeWith from 'unmutable/lib/util/pipeWith';
 
 let HashFunction = (fn: Function): string => `${HashString(fn.toString())}`;
@@ -114,34 +112,36 @@ export default (_this: Parcel): Object => ({
         });
     },
 
-    initialMeta: (initialMeta: ParcelMeta = {}): Parcel => {
+    initialMeta: (initialMeta: ParcelMeta): Parcel => {
         Types(`initialMeta()`, `initialMeta`, `object`)(initialMeta);
         let {meta} = _this._parcelData;
 
-        let partialMetaToSet = pipeWith(
+        let partialMetaToSet: {[key: string]: any} = pipeWith(
             initialMeta,
             filterNot((value, key) => has(key)(meta))
         );
 
-        let metaSetter = isEmpty()(partialMetaToSet)
-            ? ii => ii
-            : pipe(
-                setIn(['parcelData', 'meta'], merge(partialMetaToSet)(meta)),
-                set('onDispatch', (changeRequest: ChangeRequest) => {
-                    _this.batch((parcel: Parcel) => {
-                        parcel.setMeta(partialMetaToSet);
-                        parcel.dispatch(changeRequest);
-                    });
-                })
-            );
+        let create = (other = {}) => _this._create({
+            id: _this._id.pushModifier('im'),
+            ...other
+        });
 
-        return pipeWith(
-            {
-                id: _this._id.pushModifier('im')
-            },
-            metaSetter,
-            _this._create
-        );
+        if(isEmpty()(partialMetaToSet)) {
+            return create();
+        }
+
+        return create({
+            parcelData: pipeWith(
+                _this._parcelData,
+                update('meta', merge(partialMetaToSet))
+            ),
+            onDispatch: (changeRequest: ChangeRequest) => {
+                _this.batch((parcel: Parcel) => {
+                    parcel.setMeta(partialMetaToSet);
+                    parcel.dispatch(changeRequest);
+                });
+            }
+        });
     },
 
     _boundarySplit: ({handleChange}: *): Parcel => {