Home

Index

How to use the wrapCallback function from highland

Find comprehensive JavaScript highland.wrapCallback code examples handpicked from public code repositorys.

highland.wrapCallback is a higher-order function that takes a callback-based function and returns a new function that works with Highland streams.

readEBU.js

16
17
18
19
20
21
22
23
24

var H = require('highland');
var fs = require('fs');
var mac = require('../index.js');

var readdir = H.wrapCallback(fs.readdir);
var readFile = H.wrapCallback(fs.readFile);

var playback = new mac.Playback(0, mac.bmdModeHD1080i50, mac.bmdFormat10BitYUV);

+ 27 other calls in file

convertEBU.js

GitHub: Streampunk/macadam

22
23
24
25
26
27
28
29
30
31
var fs = require('fs');
var mac = require('../index.js');

var readdir = H.wrapCallback(fs.readdir);
var readFile = H.wrapCallback(fs.readFile);
var writeFile = H.wrapCallback(fs.writeFile);

var playback = new mac.Playback(0, mac.bmdModeHD1080i50, mac.bmdFormat10BitYUV);

var rootFolder = 'E:/media/EBU_test_sets/filexchange.ebu.ch/EBU test sets - Creative Commons (BY-NC-ND)/HDTV test sequences/1080i25/';

+ 17 other calls in file

How does highland.wrapCallback work?

highland.wrapCallback is a function that takes a Node.js-style callback function and returns a new function that returns a Highland stream instead of calling the original callback directly. When the new function is called, it passes any arguments received to the original callback and emits the result as a single value in the Highland stream.

updateRegisters.js

GitHub: Streampunk/kelvinadon

23
24
25
26
27
28
29
30
31
32
const elementsURL = 'https://registry.smpte-ra.org/view/published/Elements.xml';
const labelsURL = 'https://registry.smpte-ra.org/view/published/Labels.xml';

const http = (groupsURL.startsWith('https')) ? require('https') : require('http');

const gzip = H.wrapCallback(zlib.gzip);
const writeFile = H.wrapCallback(fs.writeFile);

var ulCache = {};
var memberOf = {};

+ 5 other calls in file

finance-stream.js

GitHub: xat/finance-stream

3
4
5
6
7
8
9
10
11
12
var objectPath = require('object-path');
var format = require('util').format;

var YQL_API = 'http://query.yahooapis.com/v1/public/yql';

var getGot = _.wrapCallback(got);

var slice = Array.prototype.slice;

var isString = function(val) {

Ai Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
const highland = require("highland");

// Define a function that accepts a callback and returns the result using the callback
function asyncFunc(param1, param2, callback) {
  setTimeout(() => {
    if (param1 === "error") {
      callback(new Error("Something went wrong!"), null);
    } else {
      callback(null, `${param1}-${param2}`);
    }
  }, 1000);
}

// Use wrapCallback to convert the async function to a stream that can be piped
const stream = highland.wrapCallback(asyncFunc);

// Call the stream with parameters and handle the result
stream("hello", "world")
  .each((result) => console.log(result))
  .errors((err) => console.error(err));

In this example, asyncFunc is a function that takes two parameters and a callback. It returns the result using the callback in a Node.js-style callback pattern. highland.wrapCallback is used to convert asyncFunc to a Highland.js stream, which can be piped and manipulated like any other Highland.js stream. The stream is then called with the parameters hello and world, and the result is printed to the console using console.log. If an error occurs, it is printed to the console using console.error.

index.js

GitHub: histograph/graphmalizer-core

8
9
10
11
12
13
14
15
16
function Graphmalizer (userConfig) {
  // store configuration with user overrides
  var conf = config(userConfig)

  // setup neo4j client
  var batchCommit = H.wrapCallback(neoBatch(conf.Neo4J))

  // setup input checker '~ schema validation'
  var checkInput = inputChecker(conf.types)

+ 3 other calls in file

index.js

GitHub: clauseHQ/aws-cfn-deploy-action

94
95
96
97
98
99
100
101
102
103
    }))
};

return H([getStackInputs(inputKeys)])
  .doto(log('processed input: synchronous'))
  .flatMap(({ Template, ...inputs }) => H.wrapCallback(fs.readFile)(Template)
    .map(body => body.toString('utf8'))
    .map(TemplateBody => ({
      ...inputs,
      TemplateBody

index.js

GitHub: ak--47/mixpanel-import

136
137
138
139
140
141
142
143
144
145

if (config.recordType === 'table') return flushLookupTable(stream, config);
if (config.recordType === 'export') return exportEvents(stream, config);
if (config.recordType === 'peopleExport') return exportProfiles(stream, config);

const flush = _.wrapCallback(callbackify(flushToMixpanel));

const mpPipeline = _.pipeline(
	// * transforms
	_.map((data) => {

+ 115 other calls in file

gitStreaming.js

GitHub: ariutta/cross-platform-text

4
5
6
7
8
9
10
11
12
13
14
var execStreaming = highland.wrapCallback(exec);


module.exports = {
  checkout: highland.wrapCallback(git.checkout),
  merge: highland.wrapCallback(git.merge),
  push: highland.wrapCallback(git.push),
  status: highland.wrapCallback(git.status),
  createTag: highland.wrapCallback(git.tag),
  readTags: execStreaming('git tag')
            .split('\r')

+ 5 other calls in file

launchSeleniumServer.js

GitHub: ariutta/cross-platform-text

95
96
97
98
99
100
101
102
103
104
105
  });
}


function launch(preferredPort) {
  return getFreePort(preferredPort).flatMap(function(port) {
    var seleniumServerStream = highland.wrapCallback(selenium)({stdio: 'pipe'})
    .errors(function(err) {
      console.log('seleniumServer error');
      console.log(err);
    })

+ 2 other calls in file

launchLocalServer.js

GitHub: ariutta/cross-platform-text

6
7
8
9
10
11
12
13
14
15
16
17
  root: __dirname + '/../../',
  showDir: true,
  autoIndex: true
});


var getFreePort = highland.wrapCallback(freeport);


/*
function getPort(preferredPort) {
  return highland([preferredPort])

client.js

GitHub: shirish87/browser-console

54
55
56
57
58
59
60
61
62
  return path.join(__dirname, this._path, f);
};

Client.prototype.build = function build(callback) {
  var that = this;
  var readFile = _.wrapCallback(fs.readFile);

  // None of these actions are actually executed
  // until something comes along to 'thunk' it

utils.js

GitHub: amsross/io-mattross-transitland

7
8
9
10
11
12
13
14
15
16
17
const errors = require('restify-errors')
const expire = 1 * 60 * 60 * 24 * 7 * 52


module.exports.checkRedis = redis => type => match => otherwise => {
  const key = `transitland:${type}:${match}`.replace(/ /g, '')
  return h.wrapCallback(redis.get.bind(redis))(key)
    .compact()
    .map(JSON.parse)
    .otherwise(otherwise)
    .compact()

+ 5 other calls in file

input.js

GitHub: achannarasappa/sub

0
1
2
3
4
5
6
7
8
9
10
11
12
const _ = require('highland');
const glob = require('glob');
const fs = require('fs');
const R = require('ramda');


const readFile = _.wrapCallback(fs.readFile);


const inputStream = (filePatterns) => {


  const paths = R.chain(glob.sync, filePatterns);

+ 3 other calls in file

hound-stash-config-generator.js

GitHub: nippe/hound-stash-config-generator

39
40
41
42
43
44
45
46
47
48

opt.uri = '/projects';

let globalArray = [];

const requestStream = H.wrapCallback(request);

const checkBounderies = (htmlBody) => {
    const body = JSON.parse(htmlBody);
    if (!_.get('isLastPage')(body)) {

+ 5 other calls in file

Other functions in highland

Sorted by popularity

highland.pipeline is the most popular function in highland (1364 examples)

Other popular packages:

Home

About