iter-tools-es/impls/$starts-with-any-seq/async-starts-with-any-seq.js

The iterable toolbox

const {
  asyncIterableCurry,
  asyncEnsureIterable
} = require('../../internal/async-iterable.js');

const {
  __asyncZipAll
} = require('../$zip-all/async-zip-all.js');

const {
  __asyncPeekerate
} = require('../$peekerate/async-peekerate.js');

const none = Symbol('none');

async function _asyncStartsWithAnySeq(peekr, subseqPeekr, same) {
  if (subseqPeekr.done || subseqPeekr.value.includes(none)) return true;
  const matches = subseqPeekr.value.map(() => true);

  while (!peekr.done && !subseqPeekr.done) {
    const {
      value
    } = peekr;
    const {
      value: seqValue
    } = subseqPeekr;

    for (let i = 0; i < seqValue.length; i++) {
      if (!matches[i]) continue;

      if (seqValue[i] === none) {
        return true;
      } else {
        matches[i] = same(seqValue[i], value);
      }
    }

    await Promise.all([subseqPeekr.advance(), peekr.advance()]);
  }

  return subseqPeekr.done && matches.includes(true);
}

exports._asyncStartsWithAnySeq = _asyncStartsWithAnySeq;

async function __asyncStartsWithAnySeq(iterable, seqs, same = Object.is) {
  if (!seqs.length) return false;
  const peekr = await __asyncPeekerate(iterable);
  const subseqPeekr = await __asyncPeekerate(__asyncZipAll(seqs, {
    filler: none
  }));
  const seqFound = await _asyncStartsWithAnySeq(peekr, subseqPeekr, same);
  await subseqPeekr.return();
  await peekr.return();
  return seqFound;
}

exports.__asyncStartsWithAnySeq = __asyncStartsWithAnySeq;
const asyncStartsWithAnySeq = /*#__PURE__*/asyncIterableCurry(__asyncStartsWithAnySeq, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,

  validateArgs(args) {
    args[1] = args[1].map(arg => asyncEnsureIterable(arg));
  }

});
exports.asyncStartsWithAnySeq = asyncStartsWithAnySeq;