transform.test.js

const { test } = require('tap')
const { run, map, filter, reduce, until, Emitter } = require('..')
const inputs = {
  array: [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
, object: { a: 0, b: 1, c: 2, d: 3, e: 4, f: 5, g: 6, h: 7, i: 8, j: 9 }
, string: '0123456789'
, number: 10
, function: me => { for (const v of inputs.array) me.next(v, v) }
, gen: function*(){ for (const v of inputs.array) yield v }
, agen: async function*(){ for (const v of inputs.array) { yield await v } }
, emitter: () => new Emitter({
    async run({ send }) { inputs.array.map(send) }
  })
}

// array test
test('array -> array', ({ same, plan }) => {
  plan(1)
  same([ 3, 9, 15, 21 ], run(
    inputs.array
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce([])
  ))
})

test('array -> object', ({ same, plan }) => {
  plan(1)
  same({ 1: 3, 3: 9, 5: 15, 7: 21 }, run(
    inputs.array
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce({})
  ))
})

test('array -> string', ({ same, plan }) => {
  plan(1)
  same('391521', run(
    inputs.array
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce('')
  ))
})

test('array -> number', ({ same, plan }) => {
  plan(1)
  same(48, run(
    inputs.array
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(0)
  ))
})

test('array -> function', ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.array
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce((acc, v) => acc.concat(v), [])
  ))
})

test('array -> generator', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.array
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(function*(initial){
      try {
        while (true) initial.push(yield)
      } finally { return initial }
    }, [])
  ))
})

test('array -> async generator', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], await run(
    inputs.array
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(async function*(initial){ 
      try {
        while (true) { await initial.push(yield) }
      } finally { return initial }
    }, [])
  ))
})

test('array -> emitter', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.array
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(new Emitter(function(v){ this.value.push(v) }, []))
  ))
})

// object
test('object -> array', ({ plan, same }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.object
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce([])
  ))
})

test('object -> object', ({ plan, same }) => {
  plan(1)
  same({ b: 3, d: 9, f: 15, h: 21 }, run(
    inputs.object
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce({})
  ))
})

test('object -> string', ({ plan, same }) => {
  plan(1)
  same('391521', run(
    inputs.object
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce('')
  ))
})

test('object -> number', ({ plan, same }) => {
  plan(1)
  same(48, run(
    inputs.object
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(0)
  ))
})

test('object -> function', ({ plan, same }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.object
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce((acc, v) => acc.concat(v), [])
  ))
})

test('object -> generator', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.object
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(function*(initial){ 
      try {
        while (true) initial.push(yield) 
      } finally { return initial }
    }, [])
  ))
})

test('object -> async generator', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], await run(
    inputs.object
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(async function*(initial){ 
      try {
        while (true) { await initial.push(yield) }
      } finally { return initial }
    }, [])
  ))
})

test('object -> emitter', ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.object
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(new Emitter(function(v){ this.value.push(v) }, []))
  ))
})

// string
test('string -> array', ({ plan, same }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.string
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce([])
  ))
})

test('string -> object', ({ plan, same }) => {
  plan(1)
  same({ 1: 3, 3: 9, 5: 15, 7: 21 }, run(
    inputs.string
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce({})
  ))
})

test('string -> string', ({ plan, same }) => {
  plan(1)
  same('391521', run(
    inputs.string
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce('')
  ))
})

test('string -> number', ({ plan, same }) => {
  plan(1)
  same(48, run(
    inputs.string
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(0)
  ))
})

test('string -> function', ({ plan, same }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.string
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce((acc, v) => acc.concat(v), [])
  ))
})

test('string -> generator', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.string
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(function*(initial){ 
      try {
        while (true) initial.push(yield) 
      } finally { return initial }
    }, [])
  ))
})

test('string -> async generator', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], await run(
    inputs.string
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(async function*(initial){ 
      try {
        while (true) { await initial.push(yield) }
      } finally { return initial }
    }, [])
  ))
})

test('string -> emitter', ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.string
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(new Emitter(function(v){ this.value.push(v) }, []))
  ))
})

// number
test('number -> array', ({ plan, same }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.number
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce([])
  ))
})

test('number -> object', ({ plan, same }) => {
  plan(1)
  same({ 1: 3, 3: 9, 5: 15, 7: 21 }, run(
    inputs.number
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce({})
  ))
})

test('number -> string', ({ plan, same }) => {
  plan(1)
  same('391521', run(
    inputs.number
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce('')
  ))
})

test('number -> number', ({ plan, same }) => {
  plan(1)
  same(48, run(
    inputs.number
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(0)
  ))
})

test('number -> function', ({ plan, same }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.number
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce((acc, v) => acc.concat(v), [])
  ))
})

test('number -> generator', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.number
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(function*(initial){ 
      try {
        while (true) initial.push(yield) 
      } finally { return initial }
    }, [])
  ))
})

test('number -> async generator', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], await run(
    inputs.number
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(async function*(initial){ 
      try {
        while (true) { await initial.push(yield) }
      } finally { return initial }
    }, [])
  ))
})

test('number -> emitter', ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.number
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(new Emitter(function(v){ this.value.push(v) }, []))
  ))
})

// function
test('function -> array', ({ plan, same }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.function
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce([])
  ))
})

test('function -> object', ({ plan, same }) => {
  plan(1)
  same({ 1: 3, 3: 9, 5: 15, 7: 21 }, run(
    inputs.function
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce({})
  ))
})

test('function -> string', ({ plan, same }) => {
  plan(1)
  same('391521', run(
    inputs.function
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce('')
  ))
})

test('function -> number', ({ plan, same }) => {
  plan(1)
  same(48, run(
    inputs.function
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(0)
  ))
})

test('function -> function', ({ plan, same }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.function
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce((acc, v) => acc.concat(v), [])
  ))
})

test('function -> generator', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.function
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(function*(initial){ 
      try {
        while (true) initial.push(yield) 
      } finally { return initial }
    }, [])
  ))
})

test('function -> async generator', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], await run(
    inputs.function
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(async function*(initial){ 
      try {
        while (true) { await initial.push(yield) }
      } finally { return initial }
    }, [])
  ))
})

test('function -> emitter', ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.function
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(new Emitter(function(v){ this.value.push(v) }, []))
  ))
})

// generator
test('generator -> array', async ({ same, plan }) => {
  same([3, 9, 15, 21], run(
    inputs.gen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce([])
  ))
})

test('generator -> object', async ({ same, plan }) => {
  plan(1)
  same({ 1: 3, 3: 9, 5: 15, 7: 21 }, run(
    inputs.gen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce({})
  ))
})

test('generator -> string', async ({ same, plan }) => {
  plan(1)
  same('391521', run(
    inputs.gen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce('')
  ))
})

test('generator -> number', async ({ same, plan }) => {
  plan(1)
  same(48, run(
    inputs.gen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(0)
  ))
})

test('generator -> function', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.gen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce((acc, v) => acc.concat(v), [])
  ))
})

test('generator -> generator', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.gen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(function*(initial){ 
      try {
        while (true) initial.push(yield) 
      } finally { return initial }
    }, [])
  ))
})

test('generator -> async generator', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], await run(
    inputs.gen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(async function*(initial){ 
      try {
        while (true) { await initial.push(yield) }
      } finally { return initial }
    }, [])
  ))
})

test('generator -> emitter', ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], run(
    inputs.gen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(new Emitter(function(v){ this.value.push(v) }, []))
  ))
})

// async generator
test('async generator -> array', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], await run(
    inputs.agen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce([])
  ))
})

test('async generator -> object', async ({ same, plan }) => {
  plan(1)
  same({ 1: 3, 3: 9, 5: 15, 7: 21 }, await run(
    inputs.agen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce({})
  ))
})

test('async generator -> string', async ({ same, plan }) => {
  plan(1)
  same('391521', await run(
    inputs.agen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce('')
  ))
})

test('async generator -> number', async ({ same, plan }) => {
  plan(1)
  same(48, await run(
    inputs.agen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(0)
  ))
})

test('async generator -> function', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], await run(
    inputs.agen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce((acc, v) => acc.concat(v), [])
  ))
})

test('async generator -> generator', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], await run(
    inputs.agen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(function*(initial){ 
      try {
        while (true) initial.push(yield initial.length) 
      } finally { return initial }
    }, [])
  ))
})

test('async generator -> async generator', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], await run(
    inputs.agen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(async function*(initial){ 
      try {
        while (true) { await initial.push(yield initial.length) }
      } finally { return initial }
    }, [])
  ))
})

test('async generator -> emitter', async ({ same, plan }) => {
  plan(1)
  same([3, 9, 15, 21], await run(
    inputs.agen
  , map(v => v * 3)
  , filter(v => v % 2)
  , until(4)
  , reduce(new Emitter(function(v){ this.value.push(v) }, []))
  ))
})