Bug Fix: mergeAll refactoring, fix #284

Author: gcanti

src/index.ts

@@ -1192,12 +1192,21 @@ export interface IntersectionC<CS extends [Mixed, Mixed, ...Array<Mixed>]>
     unknown
   > {}
 
-const mergeAll = (us: Array<unknown>): any => {
-  let r: unknown = us[0]
-  for (let i = 1; i < us.length; i++) {
+const mergeAll = (base: any, us: Array<any>): any => {
+  let r: any = base
+  for (let i = 0; i < us.length; i++) {
     const u = us[i]
-    if (u !== r) {
-      r = Object.assign(r, u)
+    if (u !== base) {
+      // `u` contains a prismatic value or is the result of a stripping combinator
+      if (r === base) {
+        r = Object.assign({}, u)
+        continue
+      }
+      for (const k in u) {
+        if (u[k] !== base[k] || !r.hasOwnProperty(k)) {
+          r[k] = u[k]
+        }
+      }
     }
   }
   return r
@@ -1241,9 +1250,9 @@ export function intersection<CS extends [Mixed, Mixed, ...Array<Mixed>]>(
               us.push(validation.value)
             }
           }
-          return errors.length > 0 ? failures(errors) : success(mergeAll(us))
+          return errors.length > 0 ? failures(errors) : success(mergeAll(u, us))
         },
-    codecs.length === 0 ? identity : a => mergeAll(codecs.map(codec => codec.encode(a))),
+    codecs.length === 0 ? identity : a => mergeAll(a, codecs.map(codec => codec.encode(a))),
     codecs
   )
 }

test/PathReporter.ts

@@ -8,7 +8,9 @@ describe('PathReporter', () => {
     assert.deepStrictEqual(PathReporter.report(t.number.decode(function() {})), [
       'Invalid value <function0> supplied to : number'
     ])
-    assert.deepStrictEqual(PathReporter.report(t.number.decode(function f() {})), ['Invalid value f supplied to : number'])
+    assert.deepStrictEqual(PathReporter.report(t.number.decode(function f() {})), [
+      'Invalid value f supplied to : number'
+    ])
   })
 
   it('should say something whene there are no errors', () => {

test/intersection.ts

@@ -47,8 +47,20 @@ describe('intersection', () => {
     })
 
     it('should decode a prismatic value', () => {
-      const T = t.intersection([t.type({ a: t.string }), t.type({ b: NumberFromString })])
-      assertSuccess(T.decode({ a: 'a', b: '1' }), { a: 'a', b: 1 })
+      const T1 = t.intersection([t.type({ a: t.string }), t.type({ b: NumberFromString })])
+      assertSuccess(T1.decode({ a: 'a', b: '1' }), { a: 'a', b: 1 })
+      const T2 = t.intersection([t.type({ b: NumberFromString }), t.type({ a: t.string })])
+      assertSuccess(T2.decode({ a: 'a', b: '1' }), { a: 'a', b: 1 })
+      const T3 = t.intersection([t.type({ b: NumberFromString }), t.type({ a: t.string }), t.type({ c: t.string })])
+      assertSuccess(T3.decode({ a: 'a', b: '1', c: 'c' }), { a: 'a', b: 1, c: 'c' })
+      const T4 = t.intersection([
+        t.type({ b: NumberFromString }),
+        t.type({ a: t.string }),
+        t.type({ c: NumberFromString })
+      ])
+      assertSuccess(T4.decode({ a: 'a', b: '1', c: '2' }), { a: 'a', b: 1, c: 2 })
+      const T5 = t.intersection([t.type({ b: NumberFromString }), t.type({})])
+      assertSuccess(T5.decode({ b: '1' }), { b: 1 })
     })
 
     it('should fail decoding an invalid value', () => {