Merge branch 'v0'

Author: serkodev

packages/markdown-exit/src/common/utils.ts

@@ -5,6 +5,10 @@ import { decodeHTML } from 'entities'
 import * as mdurl from 'mdurl'
 import * as ucmicro from 'uc.micro'
 
+export function isString(obj: unknown): obj is string {
+  return typeof obj === 'string'
+}
+
 const _hasOwnProperty = Object.prototype.hasOwnProperty
 
 export function has(object: object, key: string | number | symbol): boolean {

packages/markdown-exit/src/index.ts

@@ -394,6 +394,7 @@ export class MarkdownExit {
    */
   use(plugin: PluginSimple): this
   use<T = any>(plugin: PluginWithOptions<T>, options?: T): this
+  use(plugin: PluginWithParams, ...params: any[]): this
   use(plugin: PluginWithParams, ...params: any[]): this {
     plugin.apply(plugin, [this, ...params])
     return this
@@ -495,21 +496,30 @@ export function createMarkdownExit(presetNameOrOptions?: any, options?: any): Ma
 }
 
 // hybrid types callable construct signatures hack
-type MarkdownExitConstructor = {
-  new(options?: MarkdownExitOptions): MarkdownExit
-  new(presetName: PresetName, options?: MarkdownExitOptions): MarkdownExit
-  (options?: MarkdownExitOptions): MarkdownExit
-  (presetName: PresetName, options?: MarkdownExitOptions): MarkdownExit
-} & typeof MarkdownExit
-
-function _MarkdownExit(presetName?: PresetName | MarkdownExitOptions, options?: MarkdownExitOptions): MarkdownExit {
-  return new MarkdownExit(presetName as any, options)
+
+/**
+ * Make class callable without `new` operator.
+ */
+function createCallableClass<T extends new (...args: any) => any>(Class: T) {
+  function callable(...args: ConstructorParameters<T>): InstanceType<T> {
+    return new Class(...args)
+  }
+
+  // bridge statics
+  Object.setPrototypeOf(callable, MarkdownExit)
+
+  // share the same instance prototype
+  ;(callable as any).prototype = MarkdownExit.prototype
+  ;(callable as any).prototype.constructor = callable
+
+  return callable as unknown as T
 }
 
-// bridge statics
-Object.setPrototypeOf(_MarkdownExit, MarkdownExit)
-// share the same instance prototype
-;(_MarkdownExit as any).prototype = MarkdownExit.prototype
-;(_MarkdownExit as any).prototype.constructor = _MarkdownExit
+// type and default const variable name must be the same
+// for correct d.ts generation
+type MarkdownExitConstructor = InstanceType<typeof MarkdownExit>
+
+// eslint-disable-next-line ts/no-redeclare
+const MarkdownExitConstructor = createCallableClass(MarkdownExit) as unknown as (typeof createMarkdownExit & typeof MarkdownExit)
 
-export default _MarkdownExit as MarkdownExitConstructor
+export default MarkdownExitConstructor

packages/markdown-exit/src/ruler.ts

@@ -21,39 +21,37 @@ export interface RuleOptions {
  * {@link MarkdownExit.use}.
  */
 export default class Ruler<T extends (...args: any[]) => any> {
+  /**
+   * List of added rules. Each element is:
+   *
+   * ```js
+   * {
+   *   name: XXX,
+   *   enabled: Boolean,
+   *   fn: Function(),
+   *   alt: [ name2, name3 ]
+   * }
+   * ```
+   */
   private __rules__: Array<{
     name: string
     enabled: boolean
     fn: T
     alt: string[]
-  }>
-
-  private __cache__: Record<string, T[]> | null
-
-  constructor() {
-    // List of added rules. Each element is:
-    //
-    // {
-    //   name: XXX,
-    //   enabled: Boolean,
-    //   fn: Function(),
-    //   alt: [ name2, name3 ]
-    // }
-    //
-    this.__rules__ = []
-
-    // Cached rule chains.
-    //
-    // First level - chain name, '' for default.
-    // Second level - diginal anchor for fast filtering by charcodes.
-    //
-    this.__cache__ = null
-  }
+  }> = []
 
-  // Helper methods, should not be used directly
+  /**
+   * Cached rule chains.
+   *
+   * First level - chain name, '' for default.
+   * Second level - diginal anchor for fast filtering by charcodes.
+   */
+  private __cache__: Record<string, T[]> | null = null
 
-  // Find rule index by name
-  //
+  /**
+   * Helper methods, should not be used directly
+   * Find rule index by name
+   */
   private __find__(name: string): number {
     for (let i = 0; i < this.__rules__.length; i++) {
       if (this.__rules__[i].name === name) {
@@ -63,8 +61,9 @@ export default class Ruler<T extends (...args: any[]) => any> {
     return -1
   }
 
-  // Build rules lookup cache
-  //
+  /**
+   * Build rules lookup cache
+   */
   private __compile__(): void {
     const chains = ['']
 

packages/markdown-exit/src/rules_block/state_block.ts

@@ -95,7 +95,10 @@ export default class StateBlock {
 
   level: number = 0
 
-  static Token: typeof Token = Token
+  /**
+   * re-export Token class to use in block rules
+   */
+  Token = Token
 
   constructor(src: string, md: MarkdownExit, env: MarkdownExitEnv, tokens: Token[]) {
     this.src = src
@@ -285,7 +288,4 @@ export default class StateBlock {
 
     return queue.join('')
   }
-
-  // re-export Token class to use in block rules
-  Token = Token
 }

packages/markdown-exit/tests/index.test.ts

@@ -1,5 +1,5 @@
-import { describe, expect, it } from 'vitest'
-import MarkdownExit from '../src'
+import { describe, expect, expectTypeOf, it } from 'vitest'
+import MarkdownExit, { createMarkdownExit } from '../src'
 
 describe('callable and constructable', () => {
   it('is constructable', () => {
@@ -54,4 +54,26 @@ describe('callable and constructable', () => {
     const inst = MarkdownExit()
     expect(inst.constructor).toBe(MarkdownExit)
   })
+
+  it('createMarkdownExit is not equal to MarkdownExit', () => {
+    expect(createMarkdownExit).not.toEqual(MarkdownExit)
+  })
+
+  it('types are correct', () => {
+    // newable
+    expectTypeOf(MarkdownExit).toBeConstructibleWith('commonmark')
+
+    // callable
+    expectTypeOf(MarkdownExit).toBeCallableWith('commonmark')
+
+    const a = new MarkdownExit()
+    const b = MarkdownExit()
+    expectTypeOf(a).toEqualTypeOf(b)
+
+    // direct use as type
+    expectTypeOf(a).toEqualTypeOf<MarkdownExit>()
+
+    expectTypeOf(a).toHaveProperty('use')
+    expectTypeOf(a.use).parameter(0).toBeFunction()
+  })
 })