restream/build/Replaceable.js

const { Transform } = require('stream');
const { checkRule, hideStack } = require('./lib');
let cleanStack = require('@artdeco/clean-stack'); if (cleanStack && cleanStack.__esModule) cleanStack = cleanStack.default;

               class Replaceable extends Transform {
  /**
   * Replaceable class that extends Transform and pushes data when it's done replacing each incoming chunk. If the replacement is passed as a function, it will work in the same way as the replacer for `string.replace` method (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace), taking the `match` as the first argument, and matched `p1`, `p2`, _etc_ parameters as following arguments. The replacer can also be an async function.
   * @param {(Rule|Array<Rule>)} rules A single replacement rule, or multiple rules.
   * @param {TransformOptions=} [options] The options for the transform stream.
   * @example
   *
   * // markdown __ to html emphasize implementation
   * const stream = replaceStream({
   *  re: /__(\S+)__/g,
   *  replacement(match, p1) {
   *    return `<em>${p1}</em>`
   *  },
   * })
   */
  constructor(rules, options) {
    super(options)
    const re = Array.isArray(rules) ? rules : [rules]
    const fr = re.filter(checkRule)
    this.rules = fr
  }

  /**
   * Stop executing further after the current rule.
   */
  brake() {
    this._broke = true
  }

  async reduce(chunk) {
    /** @type {string} */
    const s = await this.rules.reduce(async (acc, { re, replacement }) => {
      /** @type {string} */
      let string = await acc
      if (this._broke) return string

      if (typeof replacement == 'string') {
        string = string.replace(re, replacement)
      } else {
        /** @type {(Replacer|AsyncReplacer)} */
        const R = replacement.bind(this)
        const promises = []
        let commonError
        const t = string.replace(re, (match, ...args) => {
          commonError = new Error()
          try {
            if (this._broke) return match
            const p = R(match, ...args)
            if (p instanceof Promise) {
              promises.push(p)
            }
            return p
          } catch (e) { // hide stack for sync stack traces
            hideStack(commonError, e)
          }
        })
        if (promises.length) {
          try { // hide stack only for when throw happens before awaits
            const data = await Promise.all(promises)
            string = string.replace(re, () => data.shift())
          } catch (e) {
            hideStack(commonError, e)
          }
        } else {
          string = t
        }
      }
      return string
    }, `${chunk}`)

    return s
  }
  async _transform(chunk, _, next) {
    try {
      const s = await this.reduce(chunk)
      this.push(s)
      next()
    } catch (e) {
      const s = cleanStack(e.stack)
      e.stack = s
      next(e)
    }
  }
}

/**
 * The class for when serial execution of asynchronous replacements withing the same rule are needed.
 */
       class SerialAsyncReplaceable extends Replaceable {
  /**
   * @param {(Rule|Array<Rule>)} rules
   */
  constructor(rules) {
    super(rules)
    this.promise = Promise.resolve()
  }
  addItem(fn) {
    const pp = this.promise.then(fn)
    this.promise = pp
    return pp
  }
}

/**
 * @typedef {import('stream').TransformOptions} TransformOptions
 */

/* documentary types/rules.xml */
/**
 * @typedef {(match: string, ...params: string[]) => string} Replacer
 *
 * @typedef {(match: string, ...params: string[]) => Promise.<string>} AsyncReplacer
 *
 * @typedef {Object} Rule A replacement rule.
 * @prop {RegExp} re A Regular expression to match against.
 * @prop {string|Replacer|AsyncReplacer} replacement A replacement string, or a replacement string function.
 */


module.exports = Replaceable
module.exports.SerialAsyncReplaceable = SerialAsyncReplaceable