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

Signed-off-by: Lexus Drumgold <unicornware@flexdevelopment.llc>

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