@bnb-chain/reed-solomon/dist/node.adapter.js

lighting implement for reed solomon

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var node_worker_threads = require('node:worker_threads');
var path = require('path');
var index = require('./index.js');
var utils = require('./utils.js');
require('ethereum-cryptography/sha256.js');
require('@ethersproject/base64');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var path__default = /*#__PURE__*/_interopDefaultLegacy(path);

class NodeAdapterReedSolomon extends index.ReedSolomon {
  /**
   * @deprecated please use `encodeInSubWorker` instead
   * @param {*} p
   * @param {*} sourceData
   * @returns
   */
  async encodeInWorker(p, sourceData) {
    return new Promise((resolve, reject) => {
      if (node_worker_threads.isMainThread) {
        // RES is `encodeShards` Array
        const RES = [];
        const chunkList = utils.splitPrice(sourceData, this.segmentSize);
        const threads = new Set();

        for (let i = 0; i < chunkList.length; i++) {
          const worker = new node_worker_threads.Worker(p, {
            workerData: {
              index: i,
              chunk: chunkList[i],
            },
          });
          threads.add(worker);
        }

        for (const w of threads) {
          w.on('error', (err) => {
            reject(err);
          });
          w.on('exit', () => {
            threads.delete(w);
            // console.log(`Thread exiting, ${threads.size} running...`)
            if (threads.size === 0) {
              const sortedRes = this.sortByIndex(RES);
              resolve(this.getChecksumsByEncodeShards(sortedRes));
            }
          });

          w.on('message', (message) => {
            // console.log('message', message.encodeData.index)
            RES[message.index] = message;
          });
        }
      } else {
        const { chunk, index } = node_worker_threads.workerData;

        const encodeShard = this.getEncodeShard(chunk, index);
        node_worker_threads.parentPort.postMessage(encodeShard);
      }
    });
  }

  async encodeInSubWorker(sourceData) {
    return new Promise((resolve, reject) => {
      if (!node_worker_threads.isMainThread) return;

      // RES is `encodeShards` Array
      const RES = [];
      const chunkList = utils.splitPrice(sourceData, this.segmentSize);
      const threads = new Set();
      const subWorkerFile = path__default["default"].join(__dirname, 'sub-worker.js');

      for (let i = 0; i < chunkList.length; i++) {
        const worker = new node_worker_threads.Worker(subWorkerFile, {
          workerData: {
            index: i,
            chunk: chunkList[i],
          },
        });
        threads.add(worker);
      }

      for (const w of threads) {
        w.on('error', (err) => {
          reject(err);
        });
        w.on('exit', () => {
          threads.delete(w);
          // console.log(`Thread exiting, ${threads.size} running...`)
          if (threads.size === 0) {
            const sortedRes = this.sortByIndex(RES);
            resolve(this.getChecksumsByEncodeShards(sortedRes));
          }
        });

        w.on('message', (message) => {
          // console.log('message', message.encodeData.index)
          RES[message.index] = message;
        });
      }
    });
  }
}

exports.NodeAdapterReedSolomon = NodeAdapterReedSolomon;
//# sourceMappingURL=node.adapter.js.map