restream/build/Replaceable.js

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

/**
 * @typedef {import('.').Rule} Rule
 */

               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.
   * @constructor
   * @param {Rule|Rule[]} rules A single replacement rule, or multiple rules.
   * @example
   *
   * // markdown __ to html emphasise implementation
   * const stream = replaceStream({
   *  re: /__(\S+)__/g,
   *  replacement(match, p1) {
   *    return `<em>${p1}</em>`
   *  },
   * })
   */
  constructor(rules) {
    super()
    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 {function} */
        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)
    }
  }
}

const hideStack = (commonError, thrownError) => {
  if (!(thrownError instanceof Error)) throw thrownError
  const [, , commonLine] = commonError.stack.split('\n', 3)
  const i = thrownError.stack.indexOf(commonLine)
  if (i == -1) throw thrownError
  const stack = thrownError.stack.substr(0, i - 1)
  const li = stack.lastIndexOf('\n')
  thrownError.stack = stack.substr(0, li)
  throw thrownError
}

module.exports = Replaceable
//# sourceMappingURL=Replaceable.js.map