Remove support for classes as compilers, parsers

Class versions have not been used in ages.
Support for them is pretty complex for something that isn’t used.
So, let’s make everything smaller for everyone instead.
And the alternative is fine:

```js
class Parser {} // Say this is your previous class, and you still want classes.

processor.parser = function (doc, file) {
  return new Parser(doc, file).parse()
}
```

…same with compilers.

You also should set `compiler` and `parser` instead of `Compiler` and `Parser`.
The old version is still supported but will be removed.

This also drops the `CompilerClass`, `CompilerFunction`, `ParserClass`,
and `ParserFunction` types.
Use `Compiler` and `Parser` instead.

Author: wooorm

index.d.ts

@@ -5,12 +5,8 @@ export type {
   // `CompileResultMap` is typed and exposed below.
   CompileResults,
   Compiler,
-  CompilerClass,
-  CompilerFunction,
   // `Data` is typed and exposed below.
   Parser,
-  ParserClass,
-  ParserFunction,
   Pluggable,
   PluggableList,
   Plugin,

index.test-d.ts

@@ -187,31 +187,18 @@ unified()
 
 unified().use(function () {
   // Function.
-  this.Parser = function (doc, file) {
+  this.parser = function (doc, file) {
     expectType<string>(doc)
     expectType<VFile>(file)
     return {type: ''}
   }
 
-  // Class.
-  this.Parser = class {
-    parse() {
-      return {type: 'x'}
-    }
-  }
-
   // Function.
-  this.Compiler = function (tree, file) {
+  this.compiler = function (tree, file) {
     expectType<UnistNode>(tree)
     expectType<VFile>(file)
     return ''
   }
-
-  this.Compiler = class {
-    compile() {
-      return ''
-    }
-  }
 })
 
 // # Plugins w/ transformer

lib/index.js

@@ -23,20 +23,14 @@
  *   The node that the compiler receives (default: `Node`).
  * @template {CompileResults} [Result=CompileResults]
  *   The thing that the compiler yields (default: `CompileResults`).
- * @typedef {CompilerClass<Tree, Result> | CompilerFunction<Tree, Result>} Compiler
+ * @callback Compiler
  *   A **compiler** handles the compiling of a syntax tree to something else
- *   (in most cases, text).
+ *   (in most cases, text) (TypeScript type).
  *
  *   It is used in the stringify phase and called with a {@link Node `Node`}
  *   and {@link VFile `VFile`} representation of the document to compile.
- *
- *   `Compiler` can be a normal function, in which case it should return the
- *   textual representation of the given tree (typically `string`).
- *
- *   `Compiler` can also be a constructor function (a function with a `compile`
- *   field in its `prototype`), in which case it is constructed with `new`.
- *   Instances must have a `compile` method that is called without arguments
- *   and typically returns a `string`.
+ *   It should return the textual representation of the given tree (typically
+ *   `string`).
  *
  *   > 👉 **Note**: unified typically compiles by serializing: most compilers
  *   > return `string` (or `Uint8Array`).
@@ -50,27 +44,6 @@
  *   > {@link CompileResultMap `CompileResultMap`}.
  *
  *   [rehype-react]: https://github.com/rehypejs/rehype-react
- */
-
-/**
- * @template {Node} [Tree=Node]
- *   The node that the compiler receives (default: `Node`)
- * @template {CompileResults} [Result=CompileResults]
- *   The thing that the compiler yields (default: `CompileResults`).
- * @typedef {({
- *   prototype: {compile(): Result}
- *   new (tree: Tree, file: VFile): CompilerClass<Tree, Result>['prototype']
- * })} CompilerClass
- *   Class to compile trees.
- */
-
-/**
- * @template {Node} [Tree=Node]
- *   The node that the compiler receives (default: `Node`).
- * @template {CompileResults} [Result=CompileResults]
- *   The thing that the compiler yields (default: `CompileResults`).
- * @callback CompilerFunction
- *   Regular function to compile a tree.
  * @param {Tree} tree
  *   Tree to compile.
  * @param {VFile} file
@@ -83,36 +56,13 @@
 /**
  * @template {Node} [Tree=Node]
  *   The node that the parser yields (default: `Node`)
- * @typedef {ParserClass<Tree> | ParserFunction<Tree>} Parser
+ * @callback Parser
  *   A **parser** handles the parsing of text to a syntax tree.
  *
  *   It is used in the parse phase and is called with a `string` and
  *   {@link VFile `VFile`} of the document to parse.
- *
- *   `Parser` can be a normal function, in which case it must return the syntax
- *   tree representation of the given file ({@link Node `Node`}).
- *
- *   `Parser` can also be a constructor function (a function with a `parse`
- *   field in its `prototype`), in which case it is constructed with `new`.
- *   Instances must have a `parse` method that is called without arguments and
- *   must return a {@link Node `Node`}.
- */
-
-/**
- * @template {Node} [Tree=Node]
- *   The node that the parser yields (default: `Node`).
- * @typedef {({
- *   prototype: {parse(): Tree}
- *   new (document: string, file: VFile): ParserClass<Tree>['prototype']
- * })} ParserClass
- *   Class to parse files.
- */
-
-/**
- * @template {Node} [Tree=Node]
- *   The node that the parser yields (default: `Node`).
- * @callback ParserFunction
- *   Regular function to parse a file.
+ *   It must return the syntax tree representation of the given file
+ *   ({@link Node `Node`}).
  * @param {string} document
  *   Document to parse.
  * @param {VFile} file
@@ -403,13 +353,11 @@ import {trough} from 'trough'
 import {VFile} from 'vfile'
 import {CallableInstance} from './callable-instance.js'
 
-// To do: we could drop class support for the parser and compiler,
-// we don’t use that anymore?
-// Would be less breaking if we do `processor.compiler || processor.Compiler`.
+// To do: next major: drop `Compiler`, `Parser`: prefer lowercase.
 
 // To do: we could start yielding `never` in TS when a parser is missing and
 // `parse` is called.
-// Currently, we allow directly setting `processor.Parser`, which is untyped.
+// Currently, we allow directly setting `processor.parser`, which is untyped.
 
 const own = {}.hasOwnProperty
 
@@ -435,8 +383,10 @@ export class Processor extends CallableInstance {
     super('copy')
 
     /**
-     * Compiler to use.
+     * Compiler to use (deprecated).
      *
+     * @deprecated
+     *   Use `compiler` instead.
      * @type {(
      *   Compiler<
      *     CompileTree extends undefined ? Node : CompileTree,
@@ -448,8 +398,10 @@ export class Processor extends CallableInstance {
     this.Compiler = undefined
 
     /**
-     * Parser to use.
+     * Parser to use (deprecated).
      *
+     * @deprecated
+     *   Use `parser` instead.
      * @type {(
      *   Parser<ParseTree extends undefined ? Node : ParseTree> |
      *   undefined
@@ -470,6 +422,19 @@ export class Processor extends CallableInstance {
      */
     this.attachers = []
 
+    /**
+     * Compiler to use.
+     *
+     * @type {(
+     *   Compiler<
+     *     CompileTree extends undefined ? Node : CompileTree,
+     *     CompileResult extends undefined ? CompileResults : CompileResult
+     *   > |
+     *   undefined
+     * )}
+     */
+    this.compiler = undefined
+
     /**
      * Internal state to track where we are while freezing.
      *
@@ -497,6 +462,16 @@ export class Processor extends CallableInstance {
      */
     this.namespace = {}
 
+    /**
+     * Parser to use.
+     *
+     * @type {(
+     *   Parser<ParseTree extends undefined ? Node : ParseTree> |
+     *   undefined
+     * )}
+     */
+    this.parser = undefined
+
     /**
      * Internal list of configured transformers.
      *
@@ -687,26 +662,9 @@ export class Processor extends CallableInstance {
   parse(file) {
     this.freeze()
     const realFile = vfile(file)
-    const Parser = this.Parser
-    assertParser('parse', Parser)
-
-    if (newable(Parser, 'parse')) {
-      const ParserClass =
-        /** @type {ParserClass<ParseTree extends undefined ? Node : ParseTree>} */ (
-          Parser
-        )
-
-      const parserInstace = new ParserClass(String(realFile), realFile)
-
-      return parserInstace.parse()
-    }
-
-    const parserFunction =
-      /** @type {ParserFunction<ParseTree extends undefined ? Node : ParseTree>} */ (
-        Parser
-      )
-
-    return parserFunction(String(realFile), realFile)
+    const parser = this.parser || this.Parser
+    assertParser('parse', parser)
+    return parser(String(realFile), realFile)
   }
 
   /**
@@ -755,8 +713,8 @@ export class Processor extends CallableInstance {
     const self = this
 
     this.freeze()
-    assertParser('process', this.Parser)
-    assertCompiler('process', this.Compiler)
+    assertParser('process', this.parser || this.Parser)
+    assertCompiler('process', this.compiler || this.Compiler)
 
     return done ? executor(undefined, done) : new Promise(executor)
 
@@ -854,8 +812,8 @@ export class Processor extends CallableInstance {
     let result
 
     this.freeze()
-    assertParser('processSync', this.Parser)
-    assertCompiler('processSync', this.Compiler)
+    assertParser('processSync', this.parser || this.Parser)
+    assertCompiler('processSync', this.compiler || this.Compiler)
 
     this.process(file, realDone)
     assertDone('processSync', 'process', complete)
@@ -1036,35 +994,11 @@ export class Processor extends CallableInstance {
   stringify(tree, file) {
     this.freeze()
     const realFile = vfile(file)
-    const Compiler = this.Compiler
-    assertCompiler('stringify', Compiler)
+    const compiler = this.compiler || this.Compiler
+    assertCompiler('stringify', compiler)
     assertNode(tree)
 
-    if (newable(Compiler, 'compile')) {
-      const CompilerClass = /**
-       * @type {(
-       *   CompilerClass<
-       *     CompileTree extends undefined ? Node : CompileTree,
-       *     CompileResult extends undefined ? CompileResults : CompileResult
-       *   >
-       * )}
-       */ (Compiler)
-
-      const compilerInstace = new CompilerClass(tree, realFile)
-
-      return compilerInstace.compile()
-    }
-
-    const compilerFunction = /**
-     * @type {(
-     *   CompilerFunction<
-     *     CompileTree extends undefined ? Node : CompileTree,
-     *     CompileResult extends undefined ? CompileResults : CompileResult
-     *   >
-     * )}
-     */ (Compiler)
-
-    return compilerFunction(tree, realFile)
+    return compiler(tree, realFile)
   }
 
   /**
@@ -1270,45 +1204,6 @@ export class Processor extends CallableInstance {
  */
 export const unified = new Processor().freeze()
 
-/**
- * Check if `value` is a constructor.
- *
- * @param {unknown} value
- * @param {string} name
- * @returns {boolean}
- */
-function newable(value, name) {
-  const proto =
-    // Prototypes are `unknown`.
-    // type-coverage:ignore-next-line
-    typeof value === 'function' && /** @type {unknown} */ (value.prototype)
-
-  return (
-    proto !== null &&
-    typeof proto === 'object' &&
-    (keys(proto) || name in proto)
-  )
-}
-
-/**
- * Check if `value` is an object with keys.
- *
- * @param {object} value
- * @returns {boolean}
- */
-function keys(value) {
-  /** @type {string} */
-  let key
-
-  for (key in value) {
-    if (own.call(value, key)) {
-      return true
-    }
-  }
-
-  return false
-}
-
 /**
  * Assert a parser is available.
  *
@@ -1318,7 +1213,7 @@ function keys(value) {
  */
 function assertParser(name, value) {
   if (typeof value !== 'function') {
-    throw new TypeError('Cannot `' + name + '` without `Parser`')
+    throw new TypeError('Cannot `' + name + '` without `parser`')
   }
 }
 
@@ -1331,7 +1226,7 @@ function assertParser(name, value) {
  */
 function assertCompiler(name, value) {
   if (typeof value !== 'function') {
-    throw new TypeError('Cannot `' + name + '` without `Compiler`')
+    throw new TypeError('Cannot `' + name + '` without `compiler`')
   }
 }