Best JavaScript code snippets using builtins.Array.fill(Showing top 15 results out of 666)

constructor(props) {
    super(props);
    this.dx = Array(text.length)
      .fill()
      .map(_ => new Animated.Value(randomNumber(min, max)));
    this.dy = Array(text.length)
      .fill()
      .map(_ => new Animated.Value(randomNumber(min, max)));
    this.fontSize = new Animated.Value(randomNumber(12, 50));
  }

test('concurrency: 4', async t => {
  const concurrency = 4;
  let running = 0;

  await pMap(new Array(100).fill(0), async () => {
    running++;
    t.true(running <= concurrency);
    await delay(randomInt(30, 200));
    running--;
  }, {concurrency});
});

(function() {
  let mw1 = handler => {
    return ctx => handler(ctx).then(res => res);
  };

  const broker = createBroker({
    middlewares: Array(5).fill(mw1)
  });

  bench2.add("5 middlewares", done => {
    return broker.call("users.empty").then(done);
  });
})();

/**
  * Recalculates piece availability across all peers in the torrent.
  */
 recalculate () {
  this._pieces.fill(0)

  for (const wire of this._torrent.wires) {
   for (let i = 0; i < this._numPieces; ++i) {
    this._pieces[i] += wire.peerPieces.get(i)
   }
  }
 }

willBeShownSoon(container, deadline) {
  const CanvasSurface = require('client/surface/canvas_surface');
  this.surface = new CanvasSurface(container, wallGeometry);
  this.canvas = this.surface.context;
  this.imageData = this.canvas.getImageData(0, 0, this.surface.virtualRect.w, this.surface.virtualRect.h);
  this.raw = new Array(this.surface.virtualRect.w * this.surface.virtualRect.h).fill(0);
  return Promise.resolve();
 }

it('should use next host when a host is busy', function () {
   return client.connect()
    .then(() => Promise.all(new Array(150).fill(null).map(() => client.execute('SELECT * FROM paused'))))
    .then(results => {
     const hosts = cluster.dc(0).nodes.map(n => n.address);
     // First 100 items should be the first host (50 * 2 connections)
     assertArray(results.slice(0, 100).map(rs => rs.info.queriedHost), hosts[0]);
     // The next 50 items should be the second host
     assertArray(results.slice(100).map(rs => rs.info.queriedHost), hosts[1]);
    })
    .then(() => validateStateOfPool(client, cluster));
  });

constructor(dumpparam, domparam, elementparam, root, dommapparam) {
    dump = dumpparam;
    dom = domparam;
    dommap = dommapparam;
    elements = elementparam;
    ts = new Array(domparam.length).fill(0);
    calculateTotalSizesIterative(root);
    this.ts = ts;
  }

Array(8).fill().map(() =>
  ({
    name: loremipsum({ count: 1, units: 'words' }),
    source: { uri: randomUser() },
    header: loremipsum({ count: 3, units: 'words' }),
    text: loremipsum({ count: 15, units: 'words' }),
    primaryColor: randomColor(),
    secondaryColor: randomColor()
  })
)

generateColumnData(source) {
  let size = _.reduce(source, (o, arr) => {
   return Math.max(o, arr.length);
  }, 0);
  let range = new Array(size).fill(0);
  return _.map(source, (v, k) => ([k].concat(v).concat(range)).slice(0, size + 1));
 }

constructor(props) {
    super(props);
    this.state = { features: [] };
    const { width, height } = Dimensions.get('window');
    this.points = Array(8)
      .fill()
      .map(_ => [
        randomNumber(100, width - 100),
        randomNumber(50, 200)
      ]);
    this.r = this.points.map(_ => new Animated.Value(0));
  }

const zeropad = (value, length) => {
 let stringArray = [];
 if (value === "") {
  stringArray = Array(length).fill(0);
 } else {
  stringArray.push(value);
  for (let i = 0; i < length - value.toString().length; i++) {
   stringArray.unshift(0);
  }
 }
 return stringArray.join("");
}

(function() {
  const mw = handler => {
    return ctx => handler(ctx).then(res => res);
  };

  // Add 10 middlewares
  const broker = new ServiceBroker({ logger: false, middlewares: Array(10).fill(mw) });
  broker.loadService(__dirname + "/../user.service");
  broker.start();

  bench.add("With 10 middlewares", done => {
    return broker.call("users.find").then(done);
  });
})();

constructor(props) {
    super(props);
    this.data = Array(dataLength).fill().map((_, index) => ({
      index,
      value: new Animated.Value(randomNumber(min, max))
    }));
  }

function radixsort(keys, values, offset, length) {
  let tempKeys = new Array(length).fill(0);
  let tempValues = new Array(length).fill(0);
  countsort(keys, tempKeys, values, tempValues, offset, 0, length, 0);
  countsort(tempKeys, keys, tempValues, values, 0, offset, length, 1);
  countsort(keys, tempKeys, values, tempValues, offset, 0, length, 2);
  countsort(tempKeys, keys, tempValues, values, 0, offset, length, 3);
}

constructor(props) {
    super(props);
    this.data = Array(dataLength).fill().map((_, index) => ({
      index,
      value: new Animated.Value(randomNumber(min, max))
    }));
  }