refactor(nodes): SatisfiesAssertion -> SatisfiesExpression

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

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

@@ -28,7 +28,7 @@ import type {
   ObjectExpression,
   ParenthesizedExpression,
   RelationalExpression,
-  SatisfiesAssertion,
+  SatisfiesExpression,
   SequenceExpression,
   TaggedTemplateExpression,
   TemplateLiteral,
@@ -166,9 +166,9 @@ describe('unit-d:content/expression', () => {
         .toMatchTypeOf<NodeObject<RelationalExpression>>()
     })
 
-    it('should match NodeObject<SatisfiesAssertion>', () => {
+    it('should match NodeObject<SatisfiesExpression>', () => {
       expectTypeOf<TestSubject.ExpressionMap>()
-        .toMatchTypeOf<NodeObject<SatisfiesAssertion>>()
+        .toMatchTypeOf<NodeObject<SatisfiesExpression>>()
     })
 
     it('should match NodeObject<SequenceExpression>', () => {

src/content/expression.ts

@@ -27,7 +27,7 @@ import type {
   ObjectExpression,
   ParenthesizedExpression,
   RelationalExpression,
-  SatisfiesAssertion,
+  SatisfiesExpression,
   SequenceExpression,
   TaggedTemplateExpression,
   TemplateLiteral,
@@ -84,7 +84,7 @@ interface ExpressionMap extends LiteralMap {
   objectExpression: ObjectExpression
   parenthesizedExpression: ParenthesizedExpression
   relationalExpression: RelationalExpression
-  satisfiesAssertion: SatisfiesAssertion
+  satisfiesExpression: SatisfiesExpression
   sequenceExpression: SequenceExpression
   taggedTemplateExpression: TaggedTemplateExpression
   templateLiteral: TemplateLiteral

src/content/node.ts

@@ -41,6 +41,7 @@ import type {
   RestType,
   Root,
   RootMap,
+  SatisfiesClause,
   SpreadElement,
   StaticBlock,
   Super,
@@ -124,6 +125,7 @@ interface NodeMap
   restElement: RestElement
   restType: RestType
   root: Root
+  satisfiesClause: SatisfiesClause
   spreadElement: SpreadElement
   staticBlock: StaticBlock
   super: Super

src/nodes/__tests__/expression-satisfies.spec-d.ts

@@ -0,0 +1,35 @@
+/**
+ * @file Type Tests - SatisfiesExpression
+ * @module esast/nodes/tests/unit-d/SatisfiesExpression
+ */
+
+import type { Data, Parent } from '@flex-development/esast'
+import type { Optional } from '@flex-development/tutils'
+import type * as TestSubject from '../expression-satisfies'
+
+describe('unit-d:nodes/SatisfiesExpression', () => {
+  type Subject = TestSubject.default
+  type SubjectData = TestSubject.SatisfiesExpressionData
+
+  it('should extend Parent', () => {
+    expectTypeOf<Subject>().toMatchTypeOf<Parent>()
+  })
+
+  it('should match [data?: Optional<SatisfiesExpressionData>]', () => {
+    expectTypeOf<Subject>()
+      .toHaveProperty('data')
+      .toEqualTypeOf<Optional<SubjectData>>()
+  })
+
+  it('should match [type: "satisfiesExpression"]', () => {
+    expectTypeOf<Subject>()
+      .toHaveProperty('type')
+      .toEqualTypeOf<'satisfiesExpression'>()
+  })
+
+  describe('SatisfiesExpressionData', () => {
+    it('should extend Data', () => {
+      expectTypeOf<SubjectData>().toMatchTypeOf<Data>()
+    })
+  })
+})

src/nodes/__tests__/assertion-satisfies.spec-d.ts → src/nodes/__tests__/satisfies-clause.spec-d.ts

@@ -1,33 +1,33 @@
 /**
- * @file Type Tests - SatisfiesAssertion
- * @module esast/nodes/tests/unit-d/SatisfiesAssertion
+ * @file Type Tests - SatisfiesClause
+ * @module esast/nodes/tests/unit-d/SatisfiesClause
  */
 
 import type { Data, Parent } from '@flex-development/esast'
 import type { Optional } from '@flex-development/tutils'
-import type * as TestSubject from '../assertion-satisfies'
+import type * as TestSubject from '../satisfies-clause'
 
-describe('unit-d:nodes/SatisfiesAssertion', () => {
+describe('unit-d:nodes/SatisfiesClause', () => {
   type Subject = TestSubject.default
-  type SubjectData = TestSubject.SatisfiesAssertionData
+  type SubjectData = TestSubject.SatisfiesClauseData
 
   it('should extend Parent', () => {
     expectTypeOf<Subject>().toMatchTypeOf<Parent>()
   })
 
-  it('should match [data?: Optional<SatisfiesAssertionData>]', () => {
+  it('should match [data?: Optional<SatisfiesClauseData>]', () => {
     expectTypeOf<Subject>()
       .toHaveProperty('data')
       .toEqualTypeOf<Optional<SubjectData>>()
   })
 
-  it('should match [type: "satisfiesAssertion"]', () => {
+  it('should match [type: "satisfiesClause"]', () => {
     expectTypeOf<Subject>()
       .toHaveProperty('type')
-      .toEqualTypeOf<'satisfiesAssertion'>()
+      .toEqualTypeOf<'satisfiesClause'>()
   })
 
-  describe('SatisfiesAssertionData', () => {
+  describe('SatisfiesClauseData', () => {
     it('should extend Data', () => {
       expectTypeOf<SubjectData>().toMatchTypeOf<Data>()
     })

src/nodes/assertion-satisfies.ts → src/nodes/expression-satisfies.ts

@@ -1,59 +1,59 @@
 /**
- * @file Nodes - SatisfiesAssertion
- * @module esast/nodes/SatisfiesAssertion
+ * @file Nodes - SatisfiesExpression
+ * @module esast/nodes/SatisfiesExpression
  */
 
 import type {
   Comments,
   Data,
   Expression,
   Parent,
-  TypeExpression
+  SatisfiesClause
 } from '@flex-development/esast'
 import type { Optional } from '@flex-development/tutils'
 
 /**
- * Info associated with `satisfies` assertions.
+ * Info associated with `satisfies` expressions.
  *
  * @see {@linkcode Data}
  *
  * @extends {Data}
  */
-interface SatisfiesAssertionData extends Data {}
+interface SatisfiesExpressionData extends Data {}
 
 /**
- * A `satisfies` assertion.
+ * A `satisfies` expression.
  *
  * @see {@linkcode Parent}
  * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-9.html#the-satisfies-operator
  *
  * @extends {Parent}
  */
-interface SatisfiesAssertion extends Parent {
+interface SatisfiesExpression extends Parent {
   /**
    * List of children.
    *
    * @see {@linkcode Comments}
    * @see {@linkcode Expression}
-   * @see {@linkcode TypeExpression}
+   * @see {@linkcode SatisfiesClause}
    */
   children: [
     expression: Expression,
     ...comments: Comments,
-    satisfies: TypeExpression
+    satisfies: SatisfiesClause
   ]
 
   /**
    * Info from the ecosystem.
    *
-   * @see {@linkcode SatisfiesAssertionData}
+   * @see {@linkcode SatisfiesExpressionData}
    */
-  data?: Optional<SatisfiesAssertionData>
+  data?: Optional<SatisfiesExpressionData>
 
   /**
    * Node type.
    */
-  type: 'satisfiesAssertion'
+  type: 'satisfiesExpression'
 }
 
-export type { SatisfiesAssertionData, SatisfiesAssertion as default }
+export type { SatisfiesExpressionData, SatisfiesExpression as default }

src/nodes/index.ts

@@ -5,10 +5,6 @@
  */
 
 export type { default as ArgumentList, ArgumentListData } from './argument-list'
-export type {
-  default as SatisfiesAssertion,
-  SatisfiesAssertionData
-} from './assertion-satisfies'
 export type {
   default as TypeAssertion,
   TypeAssertionData
@@ -193,6 +189,10 @@ export type {
   default as RelationalExpression,
   RelationalExpressionData
 } from './expression-relational'
+export type {
+  default as SatisfiesExpression,
+  SatisfiesExpressionData
+} from './expression-satisfies'
 export type {
   default as SequenceExpression,
   SequenceExpressionData
@@ -287,6 +287,10 @@ export type { default as RenamedProperty } from './property-renamed'
 export type { default as ShorthandProperty } from './property-shorthand'
 export type { default as SimpleProperty } from './property-simple'
 export type { default as Root, RootData } from './root'
+export type {
+  default as SatisfiesClause,
+  SatisfiesClauseData
+} from './satisfies-clause'
 export type {
   default as CallSignature,
   CallSignatureData

src/nodes/satisfies-clause.ts

@@ -0,0 +1,53 @@
+/**
+ * @file Nodes - SatisfiesClause
+ * @module esast/nodes/SatisfiesClause
+ */
+
+import type {
+  Comments,
+  Data,
+  Parent,
+  TypeExpression
+} from '@flex-development/esast'
+import type { Optional } from '@flex-development/tutils'
+
+/**
+ * Info associated with `satisfies` clauses.
+ *
+ * @see {@linkcode Data}
+ *
+ * @extends {Data}
+ */
+interface SatisfiesClauseData extends Data {}
+
+/**
+ * A `satisfies` clause.
+ *
+ * @see {@linkcode Parent}
+ * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-9.html#the-satisfies-operator
+ *
+ * @extends {Parent}
+ */
+interface SatisfiesClause extends Parent {
+  /**
+   * List of children.
+   *
+   * @see {@linkcode Comments}
+   * @see {@linkcode TypeExpression}
+   */
+  children: [...comments: Comments, type: TypeExpression]
+
+  /**
+   * Info from the ecosystem.
+   *
+   * @see {@linkcode SatisfiesClauseData}
+   */
+  data?: Optional<SatisfiesClauseData>
+
+  /**
+   * Node type.
+   */
+  type: 'satisfiesClause'
+}
+
+export type { SatisfiesClauseData, SatisfiesClause as default }