build(deps): bump @flex-development/tutils from 6.0.0-alpha.10 to 6.0.0-alpha.12

Signed-off-by: Lexus Drumgold <[email protected]>

Author: unicornware

package.json

@@ -83,10 +83,9 @@
   },
   "dependencies": {
     "@flex-development/docast": "1.0.0-alpha.12",
-    "@flex-development/tutils": "6.0.0-alpha.10",
+    "@flex-development/tutils": "6.0.0-alpha.12",
     "@types/unist": "2.0.6",
     "detab": "3.0.2",
-    "escape-string-regexp": "5.0.0",
     "unist-builder": "3.0.1",
     "unist-util-source": "4.0.2",
     "vfile": "5.3.7",
@@ -177,7 +176,7 @@
   },
   "resolutions": {
     "@ardatan/sync-fetch": "larsgw/sync-fetch#head=worker_threads",
-    "@flex-development/tutils": "6.0.0-alpha.10",
+    "@flex-development/tutils": "6.0.0-alpha.12",
     "unist-util-inspect@npm:7.0.1": "patch:unist-util-inspect@npm%3A7.0.1#patches/unist-util-inspect+7.0.1.dev.patch"
   },
   "engines": {

src/__tests__/attacher.spec-d.ts

@@ -5,20 +5,22 @@
 
 import type { Options } from '#src/interfaces'
 import type { Root } from '@flex-development/docast'
+import type { Optional } from '@flex-development/tutils'
 import type unified from 'unified'
 import type testSubject from '../attacher'
 
 describe('unit-d:attacher', () => {
   it('should be callable with [Options?]', () => {
-    // Act
-    type Params = [options?: Options | undefined]
+    // Arrange
+    type P = [options?: Optional<Options>]
 
-    expectTypeOf<typeof testSubject>().parameters.toEqualTypeOf<Params>()
+    // Expect
+    expectTypeOf<typeof testSubject>().parameters.toEqualTypeOf<P>()
   })
 
   it('should be typeof unified.Plugin', () => {
     // Arrange
-    type Plugin = unified.Plugin<[options?: Options | undefined], string, Root>
+    type Plugin = unified.Plugin<[options?: Optional<Options>], string, Root>
 
     // Expect
     expectTypeOf<typeof testSubject>().toEqualTypeOf<Plugin>()

src/__tests__/lexer.spec.ts

@@ -5,7 +5,7 @@
 
 import { LexerState, TokenKind } from '#src/enums'
 import type { Token } from '#src/interfaces'
-import type { Predicate } from '@flex-development/tutils'
+import { set, type Predicate } from '@flex-development/tutils'
 import fs from 'node:fs'
 import { VFile } from 'vfile'
 import TestSubject from '../lexer'
@@ -47,7 +47,7 @@ describe('unit:lexer', () => {
     it(`should return true if ${position} is equal to ${max}`, () => {
       // Arrange
       const subject = new TestSubject(document, file)
-      Object.assign(subject, { position: subject.tokens.length - 1 })
+      set(subject, 'position', subject.tokens.length - 1)
 
       // Act + Expect
       expect(subject.done).to.be.true
@@ -56,7 +56,7 @@ describe('unit:lexer', () => {
     it(`should return true if ${position} is greater than ${max}`, () => {
       // Arrange
       const subject = new TestSubject(document, file)
-      Object.assign(subject, { position: subject.tokens.length })
+      set(subject, 'position', subject.tokens.length)
 
       // Act + Expect
       expect(subject.done).to.be.true
@@ -98,7 +98,7 @@ describe('unit:lexer', () => {
 
     it('should return token sequence subset', () => {
       // Arrange
-      const condition: Predicate<Token> = (token: Token) => {
+      const condition: Predicate<Token[]> = (token: Token) => {
         return token.kind === TokenKind.EOF
       }
 
@@ -108,7 +108,7 @@ describe('unit:lexer', () => {
 
     it('should return token sequence subset from next k-th token', () => {
       // Arrange
-      const condition: Predicate<Token> = (token: Token) => {
+      const condition: Predicate<Token[]> = (token: Token) => {
         return token.kind === TokenKind.TAG_BLOCK_END
       }
 

src/__tests__/parser.spec.ts

@@ -4,8 +4,8 @@
  */
 
 import { LexerState, TokenKind } from '#src/enums'
-import type { Token } from '#src/interfaces'
 import type { Point } from '@flex-development/docast'
+import { cast } from '@flex-development/tutils'
 import fs from 'node:fs'
 import path from 'node:path'
 import { VFile } from 'vfile'
@@ -29,41 +29,41 @@ describe('unit:parser', () => {
 
     it('should throw if token is not of kind COMMENT_START', () => {
       // Arrange
-      let error: SyntaxError | undefined
+      const message: string = 'expected token of kind COMMENT_START'
+      let error!: SyntaxError
 
       // Act
       try {
         // @ts-expect-error ts(2445)
-        subject.parseComment({} as Token, 0)
+        subject.parseComment(cast({}), 0)
       } catch (e: unknown) {
-        error = e as typeof error
+        error = cast(e)
       }
 
       // Expect
-      expect(error).to.not.be.undefined
-      expect(error).toBeInstanceOf(SyntaxError)
-      expect(error?.message).to.equal('expected token of kind COMMENT_START')
+      expect(error).to.be.instanceof(SyntaxError)
+      expect(error).to.have.property('message', message)
     })
 
     it('should throw if token match is not of kind COMMENT_END', () => {
       // Arrange
       const kind: TokenKind = TokenKind.COMMENT_START
+      const message: string = 'expected token of kind COMMENT_END'
       const point: Point = { column: 1, line: 1, offset: 0 }
       const state: LexerState = LexerState.COMMENT
-      let error: SyntaxError | undefined
+      let error!: SyntaxError
 
       // Act
       try {
         // @ts-expect-error ts(2445)
         subject.parseComment({ kind, point, state, value: '/**' }, 0)
       } catch (e: unknown) {
-        error = e as typeof error
+        error = cast(e)
       }
 
       // Expect
-      expect(error).to.not.be.undefined
-      expect(error).toBeInstanceOf(SyntaxError)
-      expect(error?.message).to.equal('expected token of kind COMMENT_END')
+      expect(error).to.be.instanceof(SyntaxError)
+      expect(error).to.have.property('message', message)
     })
   })
 
@@ -77,22 +77,22 @@ describe('unit:parser', () => {
     it('should throw if token match is not of kind CONTEXT_END', () => {
       // Arrange
       const kind: TokenKind = TokenKind.CONTEXT_START
+      const message: string = 'expected token of kind CONTEXT_END'
       const point: Point = { column: 1, line: 36, offset: 1005 }
       const state: LexerState = LexerState.READY
-      let error: SyntaxError | undefined
+      let error!: SyntaxError
 
       // Act
       try {
         // @ts-expect-error ts(2445)
         subject.parseContext({ kind, point, state, value: '' }, 0)
       } catch (e: unknown) {
-        error = e as typeof error
+        error = cast(e)
       }
 
       // Expect
-      expect(error).to.not.be.undefined
-      expect(error).toBeInstanceOf(SyntaxError)
-      expect(error?.message).to.equal('expected token of kind CONTEXT_END')
+      expect(error).to.be.instanceof(SyntaxError)
+      expect(error).to.have.property('message', message)
     })
   })
 
@@ -111,42 +111,42 @@ describe('unit:parser', () => {
     it(`should throw if token is not of kind ${kinds[0]}`, () => {
       // Arrange
       const kind: keyof typeof TokenKind = kinds[0]!
-      let error: SyntaxError | undefined
+      const message: string = `expected token of kind ${kind}`
+      let error!: SyntaxError
 
       // Act
       try {
         // @ts-expect-error ts(2445)
-        subject.parseImplicitDescription({} as Token, 0)
+        subject.parseImplicitDescription(cast({}), 0)
       } catch (e: unknown) {
-        error = e as typeof error
+        error = cast(e)
       }
 
       // Expect
-      expect(error).to.not.be.undefined
-      expect(error).toBeInstanceOf(SyntaxError)
-      expect(error?.message).to.equal(`expected token of kind ${kind}`)
+      expect(error).to.be.instanceof(SyntaxError)
+      expect(error).to.have.property('message', message)
     })
 
     it(`should throw if token match is not of kind ${kinds[1]}`, () => {
       // Arrange
       const kind_expected: keyof typeof TokenKind = kinds[1]!
       const kind: TokenKind = TokenKind.IMPLICIT_DESCRIPTION_START
+      const message: string = `expected token of kind ${kind_expected}`
       const point: Point = { column: 4, line: 9, offset: 95 }
       const state: LexerState = LexerState.IMPLICIT_DESCRIPTION
-      let error: SyntaxError | undefined
+      let error!: SyntaxError
 
       // Act
       try {
         // @ts-expect-error ts(2445)
         subject.parseImplicitDescription({ kind, point, state, value: 'T' }, 0)
       } catch (e: unknown) {
-        error = e as typeof error
+        error = cast(e)
       }
 
       // Expect
-      expect(error).to.not.be.undefined
-      expect(error).toBeInstanceOf(SyntaxError)
-      expect(error?.message).to.equal(`expected token of kind ${kind_expected}`)
+      expect(error).to.be.instanceof(SyntaxError)
+      expect(error).to.have.property('message', message)
     })
   })
 
@@ -159,41 +159,41 @@ describe('unit:parser', () => {
 
     it('should throw if token is not of kind TAG_BLOCK_START', () => {
       // Arrange
-      let error: SyntaxError | undefined
+      const message: string = 'expected token of kind TAG_BLOCK_START'
+      let error!: SyntaxError
 
       // Act
       try {
         // @ts-expect-error ts(2445)
-        subject.parseTagBlock({} as Token, 0)
+        subject.parseTagBlock(cast({}), 0)
       } catch (e: unknown) {
-        error = e as typeof error
+        error = cast(e)
       }
 
       // Expect
-      expect(error).to.not.be.undefined
-      expect(error).toBeInstanceOf(SyntaxError)
-      expect(error?.message).to.equal('expected token of kind TAG_BLOCK_START')
+      expect(error).to.be.instanceof(SyntaxError)
+      expect(error).to.have.property('message', message)
     })
 
     it('should throw if token match is not of kind TAG_BLOCK_END', () => {
       // Arrange
       const kind: TokenKind = TokenKind.TAG_BLOCK_START
+      const message: string = 'expected token of kind TAG_BLOCK_END'
       const point: Point = { column: 4, line: 2, offset: 7 }
       const state: LexerState = LexerState.COMMENT
-      let error: SyntaxError | undefined
+      let error!: SyntaxError
 
       // Act
       try {
         // @ts-expect-error ts(2445)
         subject.parseTagBlock({ kind, point, state, value: '@' }, 0)
       } catch (e: unknown) {
-        error = e as typeof error
+        error = cast(e)
       }
 
       // Expect
-      expect(error).to.not.be.undefined
-      expect(error).toBeInstanceOf(SyntaxError)
-      expect(error?.message).to.equal('expected token of kind TAG_BLOCK_END')
+      expect(error).to.be.instanceof(SyntaxError)
+      expect(error).to.have.property('message', message)
     })
   })
 
@@ -206,42 +206,42 @@ describe('unit:parser', () => {
 
     it('should throw if token is not of kind TAG_INLINE_START', () => {
       // Arrange
-      let error: SyntaxError | undefined
+      const message: string = 'expected token of kind TAG_INLINE_START'
+      let error!: SyntaxError
 
       // Act
       try {
         // @ts-expect-error ts(2445)
-        subject.parseTagInline({} as Token, 0)
+        subject.parseTagInline(cast({}), 0)
       } catch (e: unknown) {
-        error = e as typeof error
+        error = cast(e)
       }
 
       // Expect
-      expect(error).to.not.be.undefined
-      expect(error).toBeInstanceOf(SyntaxError)
-      expect(error?.message).to.equal('expected token of kind TAG_INLINE_START')
+      expect(error).to.be.instanceof(SyntaxError)
+      expect(error).to.have.property('message', message)
     })
 
     it('should throw if token match is not of kind TAG_INLINE_END', () => {
       // Arrange
       const kind: TokenKind = TokenKind.TAG_INLINE_START
+      const message: string = 'expected token of kind TAG_INLINE_END'
       const point: Point = { column: 9, line: 21, offset: 631 }
       const state: LexerState = LexerState.COMMENT
       const value: string = '{@link psum}'
-      let error: SyntaxError | undefined
+      let error!: SyntaxError
 
       // Act
       try {
         // @ts-expect-error ts(2445)
         subject.parseTagInline({ kind, point, state, value }, 0)
       } catch (e: unknown) {
-        error = e as typeof error
+        error = cast(e)
       }
 
       // Expect
-      expect(error).to.not.be.undefined
-      expect(error).toBeInstanceOf(SyntaxError)
-      expect(error?.message).to.equal('expected token of kind TAG_INLINE_END')
+      expect(error).to.be.instanceof(SyntaxError)
+      expect(error).to.have.property('message', message)
     })
   })
 

src/__tests__/reader.spec.ts

@@ -3,6 +3,7 @@
  * @module docast-parse/tests/reader/unit
  */
 
+import { set } from '@flex-development/tutils'
 import fs from 'node:fs'
 import TestSubject from '../reader'
 
@@ -25,7 +26,7 @@ describe('unit:reader', () => {
     it('should return true if position is equal to document length', () => {
       // Arrange
       const subject = new TestSubject(document)
-      Object.assign(subject, { position: document.length })
+      set(subject, 'position', document.length)
 
       // Act + Expect
       expect(subject.eof).to.be.true
@@ -34,7 +35,7 @@ describe('unit:reader', () => {
     it('should return true if position is greater than document length', () => {
       // Arrange
       const subject = new TestSubject(document)
-      Object.assign(subject, { position: document.length + 1 })
+      set(subject, 'position', document.length + 1)
 
       // Act + Expect
       expect(subject.eof).to.be.true