Weird "done is not a function" error when used in esbuild environment with Vite & Vue

[maybeken]

Hi guys, I've found a weird bug after compiling unified along with remarks plugins in my Vue 3 + Vite project. I hope somebody who faces the same issue can find this post and maybe a permanent fix can be put in-place. This error doesn't seems to show when I was running in dev preview without building the app, can only happens after I build it for deployment on CDN.

This is the error that I am getting after digging the build JS file:

TypeError: done is not a function

Or actually the error as following when the project was minified after build:

TypeError: t is not a function

With some more digging, I realized there are some compile error when handling the code in Unified:

process(file, done) {
    const self = this;
    this.freeze();
    assertParser("process", this.parser || this.Parser);
    assertCompiler("process", this.compiler || this.Compiler);
    return done ? executor(void 0, done) : new Promise(executor);
    function executor(resolve, reject) {
      const realFile = vfile(file);
      const parseTree = (
        /** @type {HeadTree extends undefined ? Node : HeadTree} */
        /** @type {unknown} */
        self.parse(realFile)
      );
      self.run(parseTree, realFile, function(error, tree, file2) {
        if (error || !tree || !file2) {
          return realDone(error);
        }
        const compileTree = (
          /** @type {CompileTree extends undefined ? Node : CompileTree} */
          /** @type {unknown} */
          tree
        );
        const compileResult = self.stringify(compileTree, file2);
        if (looksLikeAValue(compileResult)) {
          file2.value = compileResult;
        } else {
          file2.result = compileResult;
        }
        realDone(
          error,
          /** @type {VFileWithOutput<CompileResult>} */
          file2
        );
      });
      function realDone(error, file2) {
        if (error || !file2) {
          reject(error);
        } else {
          done(void 0, file2);
        }
      }
    }
  }

Here is the original code

unified/lib/index.js

Lines 707 to 770 in 6838c70

	process(file, done) {
	const self = this
	this.freeze()
	assertParser('process', this.parser || this.Parser)
	assertCompiler('process', this.compiler || this.Compiler)
	return done ? executor(undefined, done) : new Promise(executor)
	// Note: `void`s needed for TS.
	/**
	* @param {((file: VFileWithOutput<CompileResult>) => undefined | void) | undefined} resolve
	* @param {(error: Error | undefined) => undefined | void} reject
	* @returns {undefined}
	*/
	function executor(resolve, reject) {
	const realFile = vfile(file)
	// Assume `ParseTree` (the result of the parser) matches `HeadTree` (the
	// input of the first transform).
	const parseTree =
	/** @type {HeadTree extends undefined ? Node : HeadTree} */ (
	/** @type {unknown} */ (self.parse(realFile))
	)
	self.run(parseTree, realFile, function (error, tree, file) {
	if (error || !tree || !file) {
	return realDone(error)
	}
	// Assume `TailTree` (the output of the last transform) matches
	// `CompileTree` (the input of the compiler).
	const compileTree =
	/** @type {CompileTree extends undefined ? Node : CompileTree} */ (
	/** @type {unknown} */ (tree)
	)
	const compileResult = self.stringify(compileTree, file)
	if (looksLikeAValue(compileResult)) {
	file.value = compileResult
	} else {
	file.result = compileResult
	}
	realDone(error, /** @type {VFileWithOutput<CompileResult>} */ (file))
	})
	/**
	* @param {Error | undefined} error
	* @param {VFileWithOutput<CompileResult> | undefined} [file]
	* @returns {undefined}
	*/
	function realDone(error, file) {
	if (error || !file) {
	reject(error)
	} else if (resolve) {
	resolve(file)
	} else {
	assert(done, '`done` is defined if `resolve` is not')
	done(undefined, file)
	}
	}
	}
	}

My assumption is that the line assert(done, 'done is defined if resolve is not') is being ignored after compiling, hence when done is undefined, the done() function still being called and results in error.

My current workaround is by changing async unified.process() to unified.processSync() as it does not take in the optional callback function to be called at the end, hence avoiding the problem completely.

As for long terms fix, I assume adding a if statement to check if done() is a function can fix the problem. However, it could be an issue with the compiler or compiler options that has nothing to do with unified.

Hope someone with more knowledge can enlighten me on this issue, thanks!

[wooorm]

Can you please make a reproduction — it is likely that the code you have is problematic