Home

Index

How to use the map function from bluebird

Find comprehensive JavaScript bluebird.map code examples handpicked from public code repositorys.

Bluebird.map is a function in a JavaScript library that provides a set of functions for working with promises, including functions for mapping an array of values to a new array of promises.

snoowrap.spec.js

1827
1828
1829
1830
1831
1832
1833
1834
1835
1836

describe('multireddits', () => {
  let multi, my_multi;
  before(async () => {
    multi = r.getUser('Lapper').getMultireddit('depthhub');
    await r.getMe().getMultireddits().then(my_multis => Promise.map(my_multis, m => m.delete()));
    my_multi = await multi.copy({new_name: require('crypto').randomBytes(8).toString('hex')});
  });
  it('can get information about a multireddit', async () => {
    const subs = await multi.subreddits;

116

981

fill-pix-certification-status-column-in-certification-courses-table.js

GitHub: 1024pix/pix

22
23
24
25
26
27
28
29
30
31
const eligibleCertificationIds = await _findEligibleCertifications(count);
logger.info(`\tOK : ${eligibleCertificationIds.length} certifications récupérées`);

logger.info('\tInscription du status dans la certification...');
let failedGenerations = 0;
await bluebird.map(
  eligibleCertificationIds,
  async (certificationId) => {
    try {
      await _updatePixCertificationStatus(certificationId);

196

How does bluebird.map work?

Bluebird.map works by taking an array of values and a function that returns a promise as input, and returning a new promise that resolves to an array of results. The function applies the given function to each value in the array, returning an array of promises. It then waits for all promises to be resolved or rejected, and returns a new promise that resolves to an array of the resolved values or rejects with the error of the first rejected promise. By providing a convenient and reliable way to perform these tasks, Bluebird.map can help to simplify and streamline complex asynchronous operations that involve mapping an array of values to a new array of promises.

generate-certif-cli.js

GitHub: 1024pix/pix

163
164
165
166
167
168
169
170
171
172
173
  databaseBuffer.nextId = maxSequenceId + 1;
}


async function _getMaxSequenceId() {
  const sequences = await knex('information_schema.sequences').pluck('sequence_name');
  const maxValues = await bluebird.map(sequences, (sequence) => knex(sequence).select('last_value').first());
  const { last_value: max } = maxBy(maxValues, 'last_value');
  return max;
}

192

+ 7 other calls in file

defaultWorkflow.js

GitHub: chenglou/node-huxley

81
82
83
84
85
86
87
88
89
90
    'them with previously recorded ones...\n'
  );
  return runTasks(compareScreenshots, opts, runnableTasks, runnablePaths);
})
.then(function() {
  return Promise.map(paths, function(dir, i) {
    return Promise.map(tasks[i], function(task) {
      var p = path.join(
        dir,
        consts.HUXLEY_FOLDER_NAME,

365

+ 3 other calls in file

Ai Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
const Promise = require("bluebird");

// Define an array of values
const values = [1, 2, 3, 4, 5];

// Define a function that returns a promise
const squareAsync = (value) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (typeof value === "number") {
        const result = value * value;
        resolve(result);
      } else {
        reject(new Error("Value must be a number"));
      }
    }, 1000);
  });
};

// Map the array of values to an array of promises
Promise.map(values, squareAsync)
  .then((results) => {
    // Output the results to the console
    console.log(`Original array: ${values}`);
    console.log(`Squared array: ${results}`);
  })
  .catch((error) => {
    // Output any errors to the console
    console.error(error);
  });

In this example, we use Promise.map() from the Bluebird library to map an array of values (values) to a new array of promises. The function squareAsync takes each value in the array and returns a promise that resolves to the square of the value after a delay of one second. Bluebird.map applies this function to each item in the array and collects the promises in a new array, which is resolved once all promises have been resolved or rejected. We output both the original array and the squared array to the console. In this case, the original array is [1, 2, 3, 4, 5], and the squared array is [1, 4, 9, 16, 25], which are the squares of the original values.

setup.js

GitHub: salesforce/refocus

59
60
61
62
63
64
65
66
67
68
  redisUrlForBull, jobQueues);
const createAuditEventsQueue = createBullJobQueue(conf.jobType.createAuditEvents,
  redisUrlForBull, jobQueues);

function resetJobQueue() {
  return Promise.map(jobQueue.workers, (w) =>
    new Promise((resolve) => w.shutdown(resolve))
  )
  .then(() => {
    jobQueue.workers = [];

125

+ 27 other calls in file

btrfsfishowAsync.js

GitHub: wisnuc/appifi

65
66
67
68
69
70
71

  // FIXME btrfs fi show returns success exit code and nothing if not root
  let stdout = await child.execAsync(cmd)
  let uuids = stdout.toString().split(/\n/).filter(l => l.length)

  return Promise.map(uuids, uuid => btrfsFiShowUUID(uuid))
}

+ 11 other calls in file

Document.js

GitHub: republik/plattform

154
155
156
157
158
159
160
161
162
163

if (doc._all) {
  // add content hash before mutating children by resolving
  processContentHashing(doc.type, { children: nodes })

  const idsFromNodes = await Promise.map(nodes, async (node) => {
    await Promise.all([
      contentUserResolver(doc.type, node, doc._users),
      processRepoImageUrlsInContent(doc.type, node, addFormatAuto),
      processEmbedImageUrlsInContent(doc.type, node, addFormatAuto),

+ 7 other calls in file

build.js

GitHub: owljsorg/owljs

127
128
129
130
131
132
133
134
135
136
137
    });
}


function buildRelease(sources, depsRequireCode, dir) {
    return dir.then(function(dir) {
        return Promise.map(sources, function(source) {
            return jobRunner.run(function() {
                var code = source.source;
                var sourceFileName = source.sourceFileName;
                code = astPasses.removeAsserts(code, sourceFileName);

+ 5 other calls in file

locales.js

GitHub: contentstack/cli

65
66
67
68
69
70
71
72
73
74
    addlogs(self.config, formatError(error), 'warn');
  })
}

let langUids = Object.keys(self.languages);
return Promise.map(
  langUids,
  function (langUid) {
    let lang = self.languages[langUid];
    if (!self.langUidMapper.hasOwnProperty(langUid) && lang.code !== self.masterLanguage) {

Crawler.js

GitHub: muhamed-didovic/vsdown

537
538
539
540
541
542
543
544
545
546
})(),
(async () => {
    let cnt = 0
    logger.info(`Starting download with concurrency: ${concurrency} ...`)
    // console.log('courses', courses);
    await Promise.map(courses, async (course, index) => {
        if (course.done) {
            console.log('DONE for:', course.title);
            cnt++
            return;

+ 26 other calls in file

bluebird-map-concurrency.js

GitHub: ThisIsManta/eslint-plugin-levitate

94
95
96
97
98
99
100
101
102
103
	code: `
		const Bluebird = require('bluebird')
		Bluebird.map([1, 2, 3])
	`,
	parserOptions: { ecmaVersion: 6, sourceType: 'module' },
	errors: [{ message: 'Expected Bluebird.map() to have a concurrency limit.', }]
},
{
	code: `
		const Bluebird = require('bluebird')

+ 677 other calls in file

service.js

GitHub: fdu-dev/second-hand-market

257
258
259
260
261
262
263
264
265
266
console.log('use amount api');
var date = new Date();
var dateStr = date.getFullYear() + '-' + (date.getMonth() + 1) + '-' + date.getDate() + ' 00:00:00';
var categories = ['电器日用', '校园代步', '闲置数码', '美妆衣物', '图书教材', '运动棋牌', '票券小物'];
var amount = {};
return Promise.map(categories, function(category) {
    var itemQuery = new AV.Query(Item);
    itemQuery.greaterThan("createdAt", new Date(dateStr));
    itemQuery.equalTo('category', category);
    itemQuery.notContainedIn("status", ["saled", "undercarriage"]);

+ 3 other calls in file

hbit-api.js

GitHub: HashBitorg/HBIT-API-Browser

1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
 * THE SOFTWARE.
 * 
 */
"use strict";
module.exports = function(Promise, INTERNAL) {
var PromiseMap = Promise.map;


Promise.prototype.filter = function Promise$filter(fn, options) {
    return PromiseMap(this, fn, options, INTERNAL);
};

gatsby-node.js

GitHub: phananhtruc98/blog_strapi

24
25
26
27
28
29
30
31
32
33
34
35
    doesIconExist = _require.doesIconExist;


sharp.simd(true);


function generateIcons(icons, srcIcon) {
  return Promise.map(icons, function (icon) {
    var size = parseInt(icon.sizes.substring(0, icon.sizes.lastIndexOf("x")));
    var imgPath = path.join("public", icon.src);
    return sharp(srcIcon).resize(size).toFile(imgPath).then(function () {});
  });

+ 3 other calls in file

ldap.js

GitHub: caremesh/validate-direct-address

148
149
150
151
152
153
154
155
156
157
if (_.isEmpty(urls)) {
  debug(`Couldn't find binding for ${binding}.  This probably means that the requested binding does not exist`);
  return undefined;
}

let results = await Promise.map(
  urls,
  async(url) => {
    let dnList = await getBaseDnList(url);
    debug({dnList});

+ 5 other calls in file

utils_api.js

GitHub: Emapic/emapic

910
911
912
913
914
915
916
917
918
919
    }
    return questions;
};

extractQuestionsMapFromSurvey = function(survey) {
    return Promise.map(survey.getQuestions({
        scope: 'includeAnswers'
    }), function(question) {
        switch (question.type) {
            case 'list-radio':

+ 2 other calls in file

import.js

GitHub: kclay/leaguebot

76
77
78
79
80
81
82
83
84
85
    return resp.send(this.text.error
        .add('Unable to view the sheet, make sure its public and use File->Publish to Web').e)
}


let weeks = await Promise.map(info.worksheets, async (sheet) => {
    let url = sheet._links['http://schemas.google.com/spreadsheets/2006#exportcsv']


    return await this.getCSV(url)

bluebird.test.js

GitHub: analystsfd/apm-agent-nodejs

736
737
738
739
740
741
742
743
744
745
746
test('Promise.map', function (t) {
  t.plan(4)
  twice(function () {
    var trans = ins.startTransaction()


    Promise.map([1, 2, 3], function (value) {
      return resolved(value)
    }).then(function (result) {
      t.deepEqual(result, [1, 2, 3])
      t.strictEqual(ins.currTransaction().id, trans.id)

+ 2 other calls in file

sample.each.js

GitHub: suguru03/func-comparator

28
29
30
31
32
33
34
35
36
37
    c = 0;
    neo_async.each(array, iterator, callback);
  },
  'bluebird': function() {
    c = 0;
    return Promise.map(array, promiseIterator);
  }
};

comparator

file_map.js

GitHub: JulienMalka/overleaf-unchained

193
194
195
196
197
198
199
200
201
202

/**
 * Map the files in this map to new values asynchronously, with an optional
 * limit on concurrency.
 * @param {function} iteratee like for _.mapValues
 * @param {number} [concurrency] as for BPromise.map
 * @return {Object}
 */
mapAsync(iteratee, concurrency) {
  assert.maybe.number(concurrency, 'bad concurrency')

+ 11 other calls in file

Other functions in bluebird

Sorted by popularity

bluebird.reject is the most popular function in bluebird (2988 examples)

Other popular packages:

Home

About