createBundleRendererCreator() — vue Function Reference

Source Code

packages/server-renderer/src/bundle-renderer/create-bundle-renderer.ts lines 32–159

export function createBundleRendererCreator(
  createRenderer: (options?: RenderOptions) => Renderer
) {
  return function createBundleRenderer(
    bundle: string | RenderBundle,
    rendererOptions: RenderOptions = {}
  ) {
    let files, entry, maps
    let basedir = rendererOptions.basedir

    // load bundle if given filepath
    if (
      typeof bundle === 'string' &&
      /\.js(on)?$/.test(bundle) &&
      path.isAbsolute(bundle)
    ) {
      if (fs.existsSync(bundle)) {
        const isJSON = /\.json$/.test(bundle)
        basedir = basedir || path.dirname(bundle)
        bundle = fs.readFileSync(bundle, 'utf-8')
        if (isJSON) {
          try {
            // @ts-expect-error
            bundle = JSON.parse(bundle)
          } catch (e: any) {
            throw new Error(`Invalid JSON bundle file: ${bundle}`)
          }
        }
      } else {
        throw new Error(`Cannot locate bundle file: ${bundle}`)
      }
    }

    if (typeof bundle === 'object') {
      entry = bundle.entry
      files = bundle.files
      basedir = basedir || bundle.basedir
      maps = createSourceMapConsumers(bundle.maps)
      if (typeof entry !== 'string' || typeof files !== 'object') {
        throw new Error(INVALID_MSG)
      }
    } else if (typeof bundle === 'string') {
      entry = '__vue_ssr_bundle__'
      files = { __vue_ssr_bundle__: bundle }
      maps = {}
    } else {
      throw new Error(INVALID_MSG)
    }

    const renderer = createRenderer(rendererOptions)

    const run = createBundleRunner(
      entry,
      files,
      basedir,
      rendererOptions.runInNewContext
    )

    return {
      renderToString: (context?: Object | undefined, cb?: any) => {
        if (typeof context === 'function') {
          cb = context
          context = {}
        }

        let promise
        if (!cb) {
          ;({ promise, cb } = createPromiseCallback())
        }

        run(context)
          .catch(err => {
            rewriteErrorTrace(err, maps)
            cb(err)
          })
          .then(app => {
            if (app) {
              //@ts-expect-error
              renderer.renderToString(app, context, (err, res) => {
                rewriteErrorTrace(err, maps)
                cb(err, res)
              })
            }
          })

        return promise
      },

      renderToStream: (context?: Object) => {
        const res = new PassThrough()
        run(context)
          .catch(err => {
            rewriteErrorTrace(err, maps)
            // avoid emitting synchronously before user can
            // attach error listener
            process.nextTick(() => {
              res.emit('error', err)
            })
          })
          .then(app => {
            if (app) {
              //@ts-expect-error
              const renderStream = renderer.renderToStream(app, context)

              renderStream.on('error', err => {
                rewriteErrorTrace(err, maps)
                res.emit('error', err)
              })

              // relay HTMLStream special events
              if (rendererOptions && rendererOptions.template) {
                renderStream.on('beforeStart', () => {
                  res.emit('beforeStart')
                })
                renderStream.on('beforeEnd', () => {
                  res.emit('beforeEnd')
                })
              }

              renderStream.pipe(res)
            }
          })

        return res
      }
    }
  }
}