TypeScript through2.default函数代码示例

var createOutStream = function(socket, id: string) {
  return through(function(chunk, enc, cb) {
    socket.emit(id, {
      data: chunk.toString('utf8'),
    });
    cb();
  })
};

var createInStream = function(socket, id : string){
  var stream = through(function(chunk, enc, cb){
    cb(null, String(chunk));
  });
  socket.on(id, function(data){
    if(!data.end){
      stream.write(data.payload);
    }else{
      stream.end();
    }
  });
  return stream;
};

function createStdoutStream(out: NodeJS.WritableStream, logFormat: string) {
    const tapSafeLogOutput = through2(function(chunk: Buffer, enc: string, callback: Function) {
            // All log records always end in a newline, so we want to strip
            // it off pre-prefixing and add it back afterwards.
            const lines = stripAnsi(chunk.toString()).trim().split('\n'),
                prefixedLines = _.map(lines, function(line) {
                        return '# ' + chalk.grey('LOG: ' + line);
                    }).join('\n') + '\n';

            callback(null, prefixedLines);
        }),
        outputStream = process.env.TAP === '1' ? tapSafeLogOutput : out,
        formattedStream = bunyanFormat({outputMode: logFormat}, outputStream);

    tapSafeLogOutput.pipe(out);

    return formattedStream;
}

 async streamMissingWalletAddresses(params: CSP.StreamWalletMissingAddressesParams) {
   const { chain, network, pubKey, res } = params;
   const wallet = await WalletStorage.collection.findOne({ pubKey });
   const walletId = wallet!._id!;
   const query = { chain, network, wallets: walletId, spentHeight: { $gte: SpentHeightIndicators.minimum } };
   const cursor = CoinStorage.collection.find(query).addCursorFlag('noCursorTimeout', true);
   const seen = {};
   const stringifyWallets = (wallets: Array<ObjectId>) => wallets.map(w => w.toHexString());
   const allMissingAddresses = new Array<string>();
   let totalMissingValue = 0;
   const missingStream = cursor.pipe(
     through2(
       { objectMode: true },
       async (spentCoin: MongoBound<ICoin>, _, done) => {
         if (!seen[spentCoin.spentTxid]) {
           seen[spentCoin.spentTxid] = true;
           // find coins that were spent with my coins
           const spends = await CoinStorage.collection
             .find({ chain, network, spentTxid: spentCoin.spentTxid })
             .addCursorFlag('noCursorTimeout', true)
             .toArray();
           const missing = spends
             .filter(coin => !stringifyWallets(coin.wallets).includes(walletId.toHexString()))
             .map(coin => {
               const { _id, wallets, address, value } = coin;
               totalMissingValue += value;
               allMissingAddresses.push(address);
               return { _id, wallets, address, value, expected: walletId.toHexString() };
             });
           if (missing.length > 0) {
             return done(undefined, { txid: spentCoin.spentTxid, missing });
           }
         }
         return done();
       },
       function(done) {
         this.push({ allMissingAddresses, totalMissingValue });
         done();
       }
     )
   );
   missingStream.pipe(new StringifyJsonStream()).pipe(res);
 }

  new Promise((resolve) => {
    (gitRawCommits({
      from: args.from,
      to: args.to || 'HEAD',
      format: '%B%n-hash-%n%H%n-gitTags-%n%D%n-committerDate-%n%ci%n-authorName-%n%aN%n',
    }) as NodeJS.ReadStream)
      .on('error', err => {
        logger.fatal('An error happened: ' + err.message);
        process.exit(1);
      })
      .pipe(through((chunk: Buffer, enc: string, callback: Function) => {
        // Replace github URLs with `@XYZ#123`
        const commit = chunk.toString('utf-8')
          .replace(/https?:\/\/github.com\/(.*?)\/issues\/(\d+)/g, '@$1#$2');

        callback(undefined, new Buffer(commit));
      }))
      .pipe(conventionalCommitsParser({
        headerPattern: /^(\w*)(?:\(([^)]*)\))?: (.*)$/,
        headerCorrespondence: ['type', 'scope', 'subject'],
        noteKeywords: ['BREAKING CHANGE'],
        revertPattern: /^revert:\s([\s\S]*?)\s*This reverts commit (\w*)\./,
        revertCorrespondence: [`header`, `hash`],
      }))
      .pipe(through.obj((chunk: JsonObject, _: string, cb: Function) => {
        try {
          const maybeTag = chunk.gitTags && (chunk.gitTags as string).match(/tag: (.*)/);
          const tags = maybeTag && maybeTag[1].split(/,/g);
          chunk['tags'] = tags;

          if (tags && tags.find(x => x == args.to)) {
            toSha = chunk.hash as string;
          }

          commits.push(chunk);
          cb();
        } catch (err) {
          cb(err);
        }
      }))
      .on('finish', resolve);
  })

var createSpawnStream = function(command, args, options, infoHandler) {
  options = options || {};
  options.stdio = ['pipe', 'pipe'];
  var outStream = createGenericStream(function(chunk, enc, cb) {
    cb(null, chunk);
  });
  var spawnThrough = through(function(chunk, enc, cb) {
    var stream = spawn(command, args, options);
    infoHandler({
      pid: stream.pid
    });
    stream.stdin.write(String(chunk));
    stream.stdin.end();
    stream.stdout.on('data', function(d) {
      outStream.write(String(d) + '\n');
    });
    cb();
  });
  return createDuplex(spawnThrough, outStream);
};

    files.forEach(filepath => {
        console.log(filepath);
        var bundledStream = through();
        var fileParts = filepath.split('/');
        var directory = fileParts.slice(0, fileParts.length - 1).join('/');
        var filename = fileParts[fileParts.length - 1].replace('.ts', '.out.js');

        if (filename == 'app.js')
            return;

        if (filename.indexOf('.out.out.') !== -1) {
            return;
        }

         console.log(`dir: ${directory} filename: ${filename}`);

        bundledStream
            .pipe(source(filename))
            .pipe(buffer())
            // .pipe(sm.init({loadMaps: true}))
            // .pipe(uglify())
            // .pipe(sm.write('./'))
            .pipe(gulp.dest(directory));

        globby(taskPath, function(err, entries) {
            if (err) {
                bundledStream.emit('error', err);
                return;
            }

            var b = browserify({
                entries: [filepath],
                debug: true,
                paths: ['scripts'],
                noParse:['lodash.js'],
                standalone: 'GLib'

            }).plugin('tsify',{target:'es5'});
            b.bundle().pipe(bundledStream);
        });
    });