feat(nodes): BlockStatement

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

__tests__/types/index.ts

@@ -0,0 +1,6 @@
+/**
+ * @file Entry Point - Test Types
+ * @module tests/types
+ */
+
+export type { default as NodeObject } from './node-object'

__tests__/types/node-object.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Test Types - NodeObject
+ * @module tests/types/NodeObject
+ */
+
+import type { Node } from '@flex-development/esast'
+
+/**
+ * Create an object mapping a node type to a node.
+ *
+ * @template {Node} T - Node to map
+ */
+type NodeObject<T extends Node> = { [K in T['type']]: T }
+
+export type { NodeObject as default }

src/content/__tests__/statement.spec-d.ts

@@ -3,7 +3,8 @@
  * @module esast/content/tests/unit-d/statement
  */
 
-import type { EmptyStatement } from '@flex-development/esast'
+import type { NodeObject } from '#tests/types'
+import type { BlockStatement, EmptyStatement } from '@flex-development/esast'
 import type * as TestSubject from '../statement'
 
 describe('unit-d:content/statement', () => {
@@ -15,10 +16,14 @@ describe('unit-d:content/statement', () => {
   })
 
   describe('StatementMap', () => {
-    it('should match [emptyStatement: EmptyStatement]', () => {
+    it('should match NodeObject<BlockStatement>', () => {
       expectTypeOf<TestSubject.StatementMap>()
-        .toHaveProperty('emptyStatement')
-        .toEqualTypeOf<EmptyStatement>
+        .toMatchTypeOf<NodeObject<BlockStatement>>()
+    })
+
+    it('should match NodeObject<EmptyStatement>', () => {
+      expectTypeOf<TestSubject.StatementMap>()
+        .toMatchTypeOf<NodeObject<EmptyStatement>>()
     })
   })
 })

src/content/statement.ts

@@ -3,7 +3,7 @@
  * @module esast/content/statement
  */
 
-import type { EmptyStatement } from '@flex-development/esast'
+import type { BlockStatement, EmptyStatement } from '@flex-development/esast'
 
 /**
  * Union of registered esast nodes that can occur where a statement is expected.
@@ -26,6 +26,7 @@ type Statement = StatementMap[keyof StatementMap]
  *  }
  */
 interface StatementMap {
+  blockStatement: BlockStatement
   emptyStatement: EmptyStatement
 }
 

src/nodes/__tests__/statement-block.spec-d.ts

@@ -0,0 +1,47 @@
+/**
+ * @file Type Tests - BlockStatement
+ * @module esast/nodes/tests/unit-d/BlockStatement
+ */
+
+import type { Data, Parent, Statement } from '@flex-development/esast'
+import type { Nilable, Optional } from '@flex-development/tutils'
+import type * as TestSubject from '../statement-block'
+
+describe('unit-d:nodes/BlockStatement', () => {
+  type Subject = TestSubject.default
+  type SubjectData = TestSubject.BlockStatementData
+
+  it('should extend Parent', () => {
+    expectTypeOf<Subject>().toMatchTypeOf<Parent>()
+  })
+
+  it('should match [children: Statement[]]', () => {
+    expectTypeOf<Subject>()
+      .toHaveProperty('children')
+      .toEqualTypeOf<Statement[]>()
+  })
+
+  it('should match [data?: Optional<BlockStatementData>]', () => {
+    expectTypeOf<Subject>()
+      .toHaveProperty('data')
+      .toEqualTypeOf<Optional<SubjectData>>()
+  })
+
+  it('should match [type: "blockStatement"]', () => {
+    expectTypeOf<Subject>()
+      .toHaveProperty('type')
+      .toEqualTypeOf<'blockStatement'>()
+  })
+
+  describe('BlockStatementData', () => {
+    it('should extend Data', () => {
+      expectTypeOf<SubjectData>().toMatchTypeOf<Data>()
+    })
+
+    it('should match [static?: Nilable<boolean>]', () => {
+      expectTypeOf<SubjectData>()
+        .toHaveProperty('static')
+        .toEqualTypeOf<Nilable<boolean>>()
+    })
+  })
+})

src/nodes/index.ts

@@ -20,6 +20,10 @@ export type { default as StringLiteral } from './literal-string'
 export type { default as UndefinedLiteral } from './literal-undefined'
 export type { default as Node } from './node'
 export type { default as Parent } from './parent'
+export type {
+  default as BlockStatement,
+  BlockStatementData
+} from './statement-block'
 export type {
   default as EmptyStatement,
   EmptyStatementData

src/nodes/statement-block.ts

@@ -0,0 +1,55 @@
+/**
+ * @file Nodes - BlockStatement
+ * @module esast/nodes/BlockStatement
+ */
+
+import type { Data, Parent, Statement } from '@flex-development/esast'
+import type { Nilable, Optional } from '@flex-development/tutils'
+
+/**
+ * Info associated with block statements.
+ *
+ * @see {@linkcode Data}
+ *
+ * @extends {Data}
+ */
+interface BlockStatementData extends Data {
+  /**
+   * Static block statement?
+   */
+  static?: Nilable<boolean>
+}
+
+/**
+ * A block statement.
+ *
+ * Block statements group zero (`0`) or more statements. The block is delimited
+ * by a pair of braces ("curly braces") and contains a list of zero (`0`) or
+ * more statements and declarations.
+ *
+ * @see {@linkcode Parent}
+ *
+ * @extends {Parent}
+ */
+interface BlockStatement extends Parent {
+  /**
+   * List of children.
+   *
+   * @see {@linkcode Statement}
+   */
+  children: Statement[]
+
+  /**
+   * Info from the ecosystem.
+   *
+   * @see {@linkcode BlockStatementData}
+   */
+  data?: Optional<BlockStatementData>
+
+  /**
+   * Node type.
+   */
+  type: 'blockStatement'
+}
+
+export type { BlockStatementData, BlockStatement as default }

tsconfig.json

@@ -30,6 +30,7 @@
     "outDir": "dist",
     "paths": {
       "#src/*": ["src/*"],
+      "#tests/*": ["__tests__/*"],
       "@flex-development/esast": ["src/index"]
     },
     "preserveConstEnums": true,