@jsonlines/core/es/_chunks/duplex-base-32ed1b65.js

parse and stringify jsonlines files through streams

import 'core-js/modules/es.array.iterator';
import 'core-js/modules/es.promise';
import { _ as _classPrivateFieldSet, a as _classPrivateFieldGet } from './line-sep-6e4e0e79.js';
import { Duplex, pipeline } from 'stream';

function drain(writable) {
  if (writable.destroyed) {
    return Promise.reject(new Error("premature close"));
  }

  return new Promise((resolve, reject) => {
    const done = () => {
      // eslint-disable-next-line @typescript-eslint/no-use-before-define
      writable.removeListener("close", onClose); // eslint-disable-next-line @typescript-eslint/no-use-before-define

      writable.removeListener("drain", onDrain);
    };

    const onClose = () => {
      done();
      reject(new Error("premature close"));
    };

    const onDrain = () => {
      done();
      resolve();
    };

    writable.on("close", onClose);
    writable.on("drain", onDrain);
  });
}

function resolveAsyncValue(v) {
  return Promise.resolve(typeof v === "function" ? //
  v() : v);
}

async function resolveAsyncDuplexSource(asyncSource) {
  const sc = await resolveAsyncValue(asyncSource);

  if (Array.isArray(sc)) {
    const streams = await Promise.all(sc.map(v => resolveAsyncValue(v)));
    pipeline(streams);
    return {
      writable: streams[0],
      readable: streams[streams.length - 1]
    };
  } else {
    const writable = await resolveAsyncValue(sc.writable);
    const readable = await resolveAsyncValue(sc.readable);
    return {
      writable,
      readable
    };
  }
}

var _asyncSource = new WeakMap();

var _source = new WeakMap();

var _readSetup2 = new WeakMap();

class AsyncDuplexBase extends Duplex {
  constructor(asyncSource, options) {
    super(options);

    _asyncSource.set(this, {
      writable: true,
      value: void 0
    });

    _source.set(this, {
      writable: true,
      value: void 0
    });

    _readSetup2.set(this, {
      writable: true,
      value: void 0
    });

    _classPrivateFieldSet(this, _readSetup2, false);

    _classPrivateFieldSet(this, _asyncSource, asyncSource);
  }

  setupSourceOnce() {
    if (_classPrivateFieldGet(this, _source) === undefined) {
      const asyncSource = _classPrivateFieldGet(this, _asyncSource);

      if (!asyncSource) throw new Error("invalid state");

      _classPrivateFieldSet(this, _source, resolveAsyncDuplexSource(asyncSource));
    }

    return _classPrivateFieldGet(this, _source);
  }

  async __writeAsync__(chunk, encoding, callback) {
    let errIsFromCallback = false;

    try {
      const {
        writable
      } = await this.setupSourceOnce();
      let resolve;
      let reject;
      const p = new Promise((rsv, rjt) => {
        resolve = rsv;
        reject = rjt;
      });

      if (!writable.write(chunk, encoding, err => {
        if (err) reject(err);else resolve();
      })) {
        await drain(writable);
      }

      await p;

      try {
        callback();
      } catch (err) {
        errIsFromCallback = true;
        throw err;
      }
    } catch (err) {
      if (!errIsFromCallback) callback(err);else throw err;
    }
  }

  _write(chunk, encoding, callback) {
    void this.__writeAsync__(chunk, encoding, callback);
  }

  _read(size) {
    if (!_classPrivateFieldGet(this, _readSetup2)) {
      void this.setupSourceOnce().then(({
        readable
      }) => {
        readable.on("readable", () => {
          let chunk;

          while (null !== (chunk = readable.read(size))) {
            if (!this.push(chunk)) break;
          }
        }).on("end", () => {
          // EOF
          this.push(null);
        });

        _classPrivateFieldSet(this, _readSetup2, true);
      });
    }
  }

  _final(callback) {
    void this.setupSourceOnce().then(({
      writable
    }) => {
      writable.end(callback);
    });
  }

}

export { AsyncDuplexBase as A };
//# sourceMappingURL=duplex-base-32ed1b65.js.map