@valkey/valkey-glide-darwin-arm64 1.3.2 → 1.3.4-rc01

package/rust-client/node_modules/event-stream/test/readArray.asynct.js

@@ -1,89 +0,0 @@
-
-var es = require('../')
-  , it = require('it-is').style('colour')
-  , d = require('ubelt')
-
-function readStream(stream, pauseAt, done) {
-  if(!done) done = pauseAt, pauseAt = -1
-  var array = [] 
-  stream.on('data', function (data) {
-    array.push(data)
-    if(!--pauseAt )
-      stream.pause(), done(null, array)
-  })
-  stream.on('error', done)
-  stream.on('end', function (data) {
-    done(null, array)
-  })
-
-}
-
-exports ['read an array'] = function (test) {
-
-  var readThis = d.map(3, 6, 100, d.id) //array of multiples of 3 < 100
-
-  var reader = es.readArray(readThis)
-
-  var writer = es.writeArray(function (err, array){
-    if(err) throw err //unpossible
-    it(array).deepEqual(readThis)
-    test.done()     
-  })
-
-  reader.pipe(writer)
-}
-
-exports ['read an array and pause it.'] = function (test) {
-
-  var readThis = d.map(3, 6, 100, d.id) //array of multiples of 3 < 100
-
-  var reader = es.readArray(readThis)
-  
-  readStream(reader, 10, function (err, data) {
-    if(err) throw err
-    it(data).deepEqual([3, 6, 9, 12, 15, 18, 21, 24, 27, 30])
-    readStream(reader, 10, function (err, data) {
-      it(data).deepEqual([33, 36, 39, 42, 45, 48, 51, 54, 57, 60])
-      test.done() 
-    })
-    reader.resume()
-  })
-
-}
-
-exports ['reader is readable, but not writeable'] = function (test) {
-  var reader = es.readArray([1])
-  it(reader).has({
-    readable: true,
-    writable: false
-  })
-
-  test.done()
-}
-
-
-exports ['read one item per tick'] = function (test) {
-  var readThis = d.map(3, 6, 100, d.id) //array of multiples of 3 < 100
-  var drains = 0
-  var reader = es.readArray(readThis)
-  var tickMapper = es.map(function (data,callback) {
-    process.nextTick(function () {
-      callback(null, data)
-    })
-    //since tickMapper is returning false
-    //pipe should pause the writer until a drain occurs
-    return false
-  })
-  reader.pipe(tickMapper)
-  readStream(tickMapper, function (err, array) {
-    it(array).deepEqual(readThis)
-    it(array.length).deepEqual(readThis.length)
-    it(drains).equal(readThis.length)
-    test.done()
-  })
-  tickMapper.on('drain', function () {
-    drains ++
-  })
-
-}
-require('./helper')(module)

package/rust-client/node_modules/event-stream/test/readable.asynct.js

@@ -1,197 +0,0 @@
-
-var es = require('../')
-  , it = require('it-is').style('colour')
-  , u = require('ubelt')
-
-exports ['read an array'] = function (test) {
-
-
-  console.log('readable')
-  return test.end()
-  var readThis = u.map(3, 6, 100, u.id) //array of multiples of 3 < 100
-
-  console.log('readable')
-
-  var reader = 
-    es.readable(function (i, callback) {
-      if(i >= readThis.length)
-        return this.emit('end')
-      console.log('readable')
-      callback(null, readThis[i])
-    })
-
-  var writer = es.writeArray(function (err, array){
-    if(err) throw err
-    it(array).deepEqual(readThis)
-    test.done()
-  })
-
-  reader.pipe(writer)
-}
-
-exports ['read an array - async'] = function (test) {
-
-  var readThis = u.map(3, 6, 100, u.id) //array of multiples of 3 < 100
-
-  var reader = 
-    es.readable(function (i, callback) {
-      if(i >= readThis.length)
-        return this.emit('end')
-      u.delay(callback)(null, readThis[i])
-    })
-
-  var writer = es.writeArray(function (err, array){
-    if(err) throw err
-    it(array).deepEqual(readThis)
-    test.done()
-  })
-
-  reader.pipe(writer)
-}
-
-
-exports ['emit data then call next() also works'] = function (test) {
-
-  var readThis = u.map(3, 6, 100, u.id) //array of multiples of 3 < 100
-
-  var reader = 
-    es.readable(function (i, next) {
-      if(i >= readThis.length)
-        return this.emit('end')
-      this.emit('data', readThis[i])
-      next()
-    })
-
-  var writer = es.writeArray(function (err, array){
-    if(err) throw err
-    it(array).deepEqual(readThis)
-    test.done()     
-  })
-
-  reader.pipe(writer)
-}
-
-
-exports ['callback emits error, then stops'] = function (test) {
-
-  var err = new Error('INTENSIONAL ERROR')
-    , called = 0
-
-  var reader = 
-    es.readable(function (i, callback) {
-      if(called++)
-        return
-      callback(err)
-    })
-
-  reader.on('error', function (_err){
-    it(_err).deepEqual(err)
-    u.delay(function() {
-      it(called).equal(1)
-      test.done()
-    }, 50)()
-  })
-}
-
-exports['readable does not call read concurrently'] = function (test) {
-
-  var current = 0
-  var source = es.readable(function(count, cb){
-    current ++
-    if(count > 100)
-      return this.emit('end')
-    u.delay(function(){
-      current --
-      it(current).equal(0)      
-      cb(null, {ok: true, n: count});
-    })();
-  });
-
-  var destination = es.map(function(data, cb){
-    //console.info(data); 
-    cb();
-  });
-
-  var all = es.connect(source, destination);
-
-  destination.on('end', test.done)
-}
-
-exports ['does not raise a warning: Recursive process.nextTick detected'] = function (test) {
-    var readThisDelayed;
-
-    u.delay(function () {
-        readThisDelayed = [1, 3, 5];
-    })();
-
-    es.readable(function (count, callback) {
-
-        if (readThisDelayed) {
-            var that = this;
-            readThisDelayed.forEach(function (item) {
-                that.emit('data', item);
-            });
-
-            this.emit('end');
-            test.done();
-        }
-
-        callback();
-    });
-};
-
-//
-// emitting multiple errors is not supported by stream.
-//
-// I do not think that this is a good idea, at least, there should be an option to pipe to 
-// continue on error. it makes alot ef sense, if you are using Stream like I am, to be able to emit multiple errors.
-// an error might not necessarily mean the end of the stream. it depends on the error, at least.
-//
-// I will start a thread on the mailing list. I'd rather that than use a custom `pipe` implementation.
-// 
-// basically, I want to be able use pipe to transform objects, and if one object is invalid, 
-// the next might still be good, so I should get to choose if it's gonna stop.
-// re-enstate this test when this issue progresses.
-//
-// hmm. I could add this to es.connect by deregistering the error listener, 
-// but I would rather it be an option in core.
-
-/*
-exports ['emit multiple errors, with 2nd parameter (continueOnError)'] = function (test) {
-
-  var readThis = d.map(1, 100, d.id)
-    , errors = 0
-  var reader = 
-    es.readable(function (i, callback) {
-      console.log(i, readThis.length)
-      if(i >= readThis.length)
-        return this.emit('end')
-      if(!(readThis[i] % 7))
-        return callback(readThis[i])
-      callback(null, readThis[i])
-    }, true)
-
-  var writer = es.writeArray(function (err, array) {
-    if(err) throw err
-    it(array).every(function (u){
-      it(u % 7).notEqual(0)      
-    }).property('length', 80)
-    it(errors).equal(14)
-    test.done()     
-  })
-
-  reader.on('error', function (u) {
-    errors ++
-    console.log(u)
-    if('number' !== typeof u)
-      throw u
-
-    it(u % 7).equal(0)
-
-  })
-
-  reader.pipe(writer)
-}
-*/
-
-require('./helper')(module)

package/rust-client/node_modules/event-stream/test/replace.asynct.js

@@ -1,76 +0,0 @@
-var es = require('../')
-  , it = require('it-is').style('colour')
-  , d = require('ubelt')
-  , spec = require('stream-spec')
-
-var next = process.nextTick
-
-var fizzbuzz = '12F4BF78FB11F1314FB1617F19BF2223FB26F2829FB3132F34BF3738FB41F4344FB4647F49BF5253FB56F5859FB6162F64BF6768FB71F7374FB7677F79BF8283FB86F8889FB9192F94BF9798FB'
-  , fizz7buzz = '12F4BFseven8FB11F1314FB161sevenF19BF2223FB26F2829FB3132F34BF3seven38FB41F4344FB464sevenF49BF5253FB56F5859FB6162F64BF6seven68FBseven1Fseven3seven4FBseven6sevensevenFseven9BF8283FB86F8889FB9192F94BF9seven98FB'
-  , fizzbuzzwhitespce = '  12F4BF78FB11F1314FB1617F19BF2223FB26F2829FB3132F34BF3738FB41F4344FB4647F49BF5253FB56F5859FB6162F64BF6768FB71F7374FB7677F79BF8283FB86F8889FB9192F94BF9798FB  '
-
-exports ['fizz buzz'] = function (test) {
-
-  var readThis = d.map(1, 100, function (i) {
-    return (
-     ! (i % 3 || i % 5) ? "FB" :
-      !(i % 3) ? "F" :
-      !(i % 5) ? "B" :
-      ''+i
-    )
-  }) //array of multiples of 3 < 100
-
-  var reader = es.readArray(readThis)
-  var join = es.wait(function (err, string){
-    it(string).equal(fizzbuzz)
-    test.done()
-  })
-  reader.pipe(join)
-
-}
-
-
-exports ['fizz buzz replace'] = function (test) {
-  var split = es.split(/(1)/)
-  var replace = es.replace('7', 'seven')
-//  var x = spec(replace).through()
-  split
-    .pipe(replace)
-    .pipe(es.join(function (err, string) {
-      it(string).equal(fizz7buzz)
-    }))
-
-    replace.on('close', function () {
-//      x.validate()
-      test.done()
-    })
-
-  split.write(fizzbuzz)
-  split.end()
-
-}
-
-
-exports ['fizz buzz replace whitespace using regexp'] = function (test) {
-  var split = es.split(/(1)/)
-  var replaceLeading = es.replace(/^[\s]*/, '')
-  var replaceTrailing = es.replace(/[\s]*$/, '')
-//  var x = spec(replace).through()
-  split
-    .pipe(replaceLeading)
-    .pipe(replaceTrailing)
-    .pipe(es.join(function (err, string) {
-      it(string).equal(fizzbuzz)
-    }))
-
-    replaceTrailing.on('close', function () {
-//      x.validate()
-      test.done()
-    })
-
-  split.write(fizzbuzz)
-  split.end()
-
-}
-
-require('./helper')(module)

package/rust-client/node_modules/event-stream/test/simple-map.asynct.js

@@ -1,343 +0,0 @@
-'use strict';
-
-var es = require('../')
-  , it = require('it-is')
-  , u = require('ubelt')
-  , spec = require('stream-spec')
-  , Stream = require('stream')
-  , from = require('from')
-  , through = require('through')
-
-//REFACTOR THIS TEST TO USE es.readArray and es.writeArray
-
-function writeArray(array, stream) {
-
-  array.forEach( function (j) {
-    stream.write(j)
-  })
-  stream.end()
-
-}
-
-function readStream(stream, done) {
-
-  var array = [] 
-  stream.on('data', function (data) {
-    array.push(data)
-  })
-  stream.on('error', done)
-  stream.on('end', function (data) {
-    done(null, array)
-  })
-
-} 
-
-//call sink on each write,
-//and complete when finished.
-
-function pauseStream (prob, delay) { 
-  var pauseIf = (
-      'number' == typeof prob 
-    ? function () {
-        return Math.random() < prob
-      } 
-    : 'function' == typeof prob 
-    ? prob
-    : 0.1
-  )
-  var delayer = ( 
-      !delay 
-    ? process.nextTick
-    : 'number' == typeof delay 
-    ? function (next) { setTimeout(next, delay) }
-    : delay
-  )   
-
-  return es.through(function (data) {    
-    if(!this.paused && pauseIf()) {
-      console.log('PAUSE STREAM PAUSING')
-      this.pause()
-      var self = this
-      delayer(function () {
-        console.log('PAUSE STREAM RESUMING')
-        self.resume()
-      })
-    }
-    console.log("emit ('data', " + data + ')')
-    this.emit('data', data) 
-  })
-}
-
-exports ['simple map'] = function (test) {
-
-  var input = u.map(1, 1000, function () {
-    return Math.random() 
-  })
-  var expected = input.map(function (v) {
-    return v * 2
-  })
-
-  var pause = pauseStream(0.1)
-  var fs = from(input)
-  var ts = es.writeArray(function (err, ar) {
-    it(ar).deepEqual(expected)
-    test.done()
-  })
-  var map = es.through(function (data) {
-    this.emit('data', data * 2)
-  }) 
-
-  spec(map).through().validateOnExit()
-  spec(pause).through().validateOnExit()
-
-  fs.pipe(map).pipe(pause).pipe(ts)
-}
-
-exports ['simple map applied to a stream'] = function (test) {
-
-  var input = [1,2,3,7,5,3,1,9,0,2,4,6]
-  //create event stream from
-
-  var doubler = es.map(function (data, cb) {
-    cb(null, data * 2)
-  })
-
-  spec(doubler).through().validateOnExit()
-
-  //a map is only a middle man, so it is both readable and writable
-  
-  it(doubler).has({
-    readable: true,
-    writable: true,   
-  })
-
-  readStream(doubler, function (err, output) {
-    it(output).deepEqual(input.map(function (j) {
-      return j * 2
-    }))
-//    process.nextTick(x.validate)
-    test.done()
-  })
-  
-  writeArray(input, doubler)
-  
-}
-
-exports['pipe two maps together'] = function (test) {
-
-  var input = [1,2,3,7,5,3,1,9,0,2,4,6]
-  //create event stream from
-  function dd (data, cb) {
-    cb(null, data * 2)
-  }
-  var doubler1 = es.map(dd), doubler2 = es.map(dd)
-
-  doubler1.pipe(doubler2)
-  
-  spec(doubler1).through().validateOnExit()
-  spec(doubler2).through().validateOnExit()
-
-  readStream(doubler2, function (err, output) {
-    it(output).deepEqual(input.map(function (j) {
-      return j * 4
-    }))
-    test.done()
-  })
-  
-  writeArray(input, doubler1)
-
-}
-
-//next:
-//
-// test pause, resume and drian.
-//
-
-// then make a pipe joiner:
-//
-// plumber (evStr1, evStr2, evStr3, evStr4, evStr5)
-//
-// will return a single stream that write goes to the first 
-
-exports ['map will not call end until the callback'] = function (test) {
-
-  var ticker = es.map(function (data, cb) {
-    process.nextTick(function () {
-      cb(null, data * 2)
-    })
-  })
-
-  spec(ticker).through().validateOnExit()
-
-  ticker.write('x')
-  ticker.end() 
-
-  ticker.on('end', function () {
-    test.done()
-  })
-}
-
-
-exports ['emit error thrown'] = function (test) {
-
-  var err = new Error('INTENSIONAL ERROR')
-    , mapper = 
-  es.map(function () {
-    throw err
-  })
-
-  mapper.on('error', function (_err) {
-    it(_err).equal(err)  
-    test.done()
-  })
-
-//  onExit(spec(mapper).basic().validate)
-//need spec that says stream may error.
-
-  mapper.write('hello')
-
-}
-
-exports ['emit error calledback'] = function (test) {
-
-  var err = new Error('INTENSIONAL ERROR')
-    , mapper = 
-  es.map(function (data, callback) {
-    callback(err)
-  })
-
-  mapper.on('error', function (_err) {
-    it(_err).equal(err)  
-    test.done()
-  })
-
-  mapper.write('hello')
-
-}
-
-exports ['do not emit drain if not paused'] = function (test) {
-
-  var map = es.map(function (data, callback) {
-    u.delay(callback)(null, 1)
-    return true
-  })
-  
-  spec(map).through().pausable().validateOnExit()
-
-  map.on('drain', function () {
-    it(false).ok('should not emit drain unless the stream is paused')
-  })
-
-  it(map.write('hello')).equal(true)
-  it(map.write('hello')).equal(true)
-  it(map.write('hello')).equal(true)
-  setTimeout(function () {map.end()},10)
-  map.on('end', test.done)
-}
-
-exports ['emits drain if paused, when all '] = function (test) {
-  var active = 0
-  var drained = false
-  var map = es.map(function (data, callback) {
-    active ++
-    u.delay(function () {
-      active --
-      callback(null, 1)
-    })()
-    console.log('WRITE', false)
-    return false
-  })
-
-  spec(map).through().validateOnExit()
-
-  map.on('drain', function () {
-    drained = true
-    it(active).equal(0, 'should emit drain when all maps are done')
-  })
-
-  it(map.write('hello')).equal(false)
-  it(map.write('hello')).equal(false)
-  it(map.write('hello')).equal(false)
-
-  process.nextTick(function () {map.end()},10)
-
-  map.on('end', function () {
-    console.log('end')
-    it(drained).ok('shoud have emitted drain before end')
-    test.done() 
-  })
-
-}
-
-exports ['map applied to a stream with filtering'] = function (test) {
-
-  var input = [1,2,3,7,5,3,1,9,0,2,4,6]
-
-  var doubler = es.map(function (data, callback) {
-    if (data % 2)
-      callback(null, data * 2)
-    else
-      callback()
-  })
-  
-  readStream(doubler, function (err, output) {
-    it(output).deepEqual(input.filter(function (j) {
-      return j % 2
-    }).map(function (j) {
-      return j * 2
-    }))
-    test.done()
-  })
-  
-  spec(doubler).through().validateOnExit()
-
-  writeArray(input, doubler)
-  
-}
-
-exports ['simple mapSync applied to a stream'] = function (test) {
-
-  var input = [1,2,3,7,5,3,1,9,0,2,4,6]
-
-  var doubler = es.mapSync(function (data) {
-    return data * 2
-  })
-  
-  readStream(doubler, function (err, output) {
-    it(output).deepEqual(input.map(function (j) {
-      return j * 2
-    }))
-    test.done()
-  })
-  
-  spec(doubler).through().validateOnExit()
-
-  writeArray(input, doubler)
-  
-}
-
-exports ['mapSync applied to a stream with filtering'] = function (test) {
-
-  var input = [1,2,3,7,5,3,1,9,0,2,4,6]
-
-  var doubler = es.mapSync(function (data) {
-    if (data % 2)
-      return data * 2
-  })
-  
-  readStream(doubler, function (err, output) {
-    it(output).deepEqual(input.filter(function (j) {
-      return j % 2
-    }).map(function (j) {
-      return j * 2
-    }))
-    test.done()
-  })
-  
-  spec(doubler).through().validateOnExit()
-
-  writeArray(input, doubler)
-  
-}
-
-require('./helper')(module)