testeranto.tiposkripto 0.2.22 → 0.3.2

package/dist/module/index.js

@@ -175,248 +175,6 @@ var BaseSetup = class {
   }
 };
 
-// src/BaseAction.ts
-var BaseAction = class {
-  constructor(name, actionCB) {
-    this.error = null;
-    this.artifacts = [];
-    this.name = name;
-    this.actionCB = actionCB;
-  }
-  addArtifact(path) {
-    if (typeof path !== "string") {
-      throw new Error(
-        `[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(
-          path
-        )}`
-      );
-    }
-    const normalizedPath = path.replace(/\\/g, "/");
-    this.artifacts.push(normalizedPath);
-  }
-  toObj() {
-    const obj = {
-      name: this.name,
-      status: this.status,
-      error: this.error ? `${this.error.name}: ${this.error.message}
-${this.error.stack}` : null,
-      artifacts: this.artifacts
-    };
-    return obj;
-  }
-  async test(store, testResourceConfiguration, artifactory) {
-    try {
-      const result = await this.performAction(
-        store,
-        this.actionCB,
-        testResourceConfiguration,
-        artifactory
-      );
-      this.status = true;
-      return result;
-    } catch (e) {
-      this.status = false;
-      this.error = e;
-      throw e;
-    }
-  }
-};
-
-// src/BaseCheck.ts
-var BaseCheck = class {
-  constructor(name, checkCB) {
-    this.artifacts = [];
-    this.name = name;
-    this.checkCB = checkCB;
-    this.error = false;
-    this.artifacts = [];
-  }
-  addArtifact(path) {
-    if (typeof path !== "string") {
-      throw new Error(
-        `[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(
-          path
-        )}`
-      );
-    }
-    const normalizedPath = path.replace(/\\/g, "/");
-    this.artifacts.push(normalizedPath);
-  }
-  toObj() {
-    const obj = {
-      name: this.name,
-      error: this.error,
-      artifacts: this.artifacts,
-      status: this.status
-    };
-    return obj;
-  }
-  async test(store, testResourceConfiguration, filepath, artifactory) {
-    const addArtifact = this.addArtifact.bind(this);
-    try {
-      const x = await this.verifyCheck(
-        store,
-        async (s) => {
-          try {
-            if (typeof this.checkCB === "function") {
-              const result = await this.checkCB(s);
-              return result;
-            } else {
-              return this.checkCB;
-            }
-          } catch (e) {
-            this.error = true;
-            throw e;
-          }
-        },
-        testResourceConfiguration,
-        artifactory
-      );
-      this.status = true;
-      return x;
-    } catch (e) {
-      this.status = false;
-      this.error = true;
-      throw e;
-    }
-  }
-};
-
-// src/BaseArrange.ts
-var BaseArrange = class extends BaseSetup {
-  setupThat(subject, testResourceConfiguration, artifactory, setupCB, initialValues) {
-    throw new Error("Method not implemented.");
-  }
-  constructor(features, acts, asserts, arrangeCB, initialValues) {
-    super(features, acts, asserts, arrangeCB, initialValues);
-  }
-  // Alias setup to arrange for AAA pattern
-  async arrange(subject, key, testResourceConfiguration, tester, artifactory, suiteNdx) {
-    return super.setup(
-      subject,
-      key,
-      testResourceConfiguration,
-      tester,
-      artifactory,
-      suiteNdx
-    );
-  }
-};
-
-// src/BaseAct.ts
-var BaseAct = class extends BaseAction {
-  performAction(store, actionCB, testResource, artifactory) {
-    throw new Error("Method not implemented.");
-  }
-  constructor(name, actCB) {
-    super(name, actCB);
-  }
-  // Alias performAction to performAct for AAA pattern
-  async performAct(store, actCB, testResource) {
-    return this.performAction(store, actCB, testResource);
-  }
-  // Alias test to act for AAA pattern
-  async act(store, testResourceConfiguration) {
-    return super.test(store, testResourceConfiguration);
-  }
-};
-
-// src/BaseAssert.ts
-var BaseAssert = class extends BaseCheck {
-  verifyCheck(store, checkCB, testResourceConfiguration, artifactory) {
-    throw new Error("Method not implemented.");
-  }
-  constructor(name, assertCB) {
-    super(name, assertCB);
-  }
-  // Alias verifyCheck to verifyAssert for AAA pattern
-  async verifyAssert(store, assertCB, testResourceConfiguration) {
-    return this.verifyCheck(store, assertCB, testResourceConfiguration);
-  }
-  // Alias test to verify for AAA pattern
-  async verify(store, testResourceConfiguration, filepath) {
-    return super.test(store, testResourceConfiguration, filepath);
-  }
-};
-
-// src/BaseMap.ts
-var BaseMap = class extends BaseSetup {
-  setupThat(subject, testResourceConfiguration, artifactory, setupCB, initialValues) {
-    throw new Error("Method not implemented.");
-  }
-  constructor(features, feeds, validates, mapCB, initialValues, tableData = []) {
-    super(features, feeds, validates, mapCB, initialValues);
-    this.tableData = tableData;
-  }
-  // Alias setup to map for TDT pattern
-  async map(subject, key, testResourceConfiguration, tester, artifactory, suiteNdx) {
-    return super.setup(
-      subject,
-      key,
-      testResourceConfiguration,
-      tester,
-      artifactory,
-      suiteNdx
-    );
-  }
-  // Method to get table data
-  getTableData() {
-    return this.tableData || [];
-  }
-};
-
-// src/BaseFeed.ts
-var BaseFeed = class extends BaseAction {
-  constructor(name, feedCB) {
-    super(name, feedCB);
-    // Row index being processed
-    this.rowIndex = -1;
-    this.rowData = null;
-  }
-  performAction(store, actionCB, testResource, artifactory) {
-    throw new Error("Method not implemented.");
-  }
-  // Set the current row data before processing
-  setRowData(index, data) {
-    this.rowIndex = index;
-    this.rowData = data;
-  }
-  // Alias performAction to feed for TDT pattern
-  async feed(store, feedCB, testResource) {
-    return this.performAction(store, feedCB, testResource);
-  }
-  // Alias test to processRow for TDT pattern
-  async processRow(store, testResourceConfiguration, rowIndex, rowData) {
-    this.setRowData(rowIndex, rowData);
-    return super.test(store, testResourceConfiguration);
-  }
-};
-
-// src/BaseValidate.ts
-var BaseValidate = class extends BaseCheck {
-  constructor(name, validateCB) {
-    super(name, validateCB);
-    // Expected result for the current row
-    this.expectedResult = null;
-  }
-  verifyCheck(store, checkCB, testResourceConfiguration, artifactory) {
-    throw new Error("Method not implemented.");
-  }
-  // Set expected result before validation
-  setExpectedResult(expected) {
-    this.expectedResult = expected;
-  }
-  // Alias verifyCheck to validate for TDT pattern
-  async validate(store, validateCB, testResourceConfiguration) {
-    return this.verifyCheck(store, validateCB, testResourceConfiguration);
-  }
-  // Alias test to check for TDT pattern
-  async check(store, testResourceConfiguration, filepath, expectedResult) {
-    this.setExpectedResult(expectedResult);
-    return super.test(store, testResourceConfiguration, filepath);
-  }
-};
-
 // src/BaseGiven.ts
 var BaseGiven = class extends BaseSetup {
   constructor(features, whens, thens, givenCB, initialValues) {
@@ -685,6 +443,53 @@ var BaseGiven = class extends BaseSetup {
   }
 };
 
+// src/BaseAction.ts
+var BaseAction = class {
+  constructor(name, actionCB) {
+    this.error = null;
+    this.artifacts = [];
+    this.name = name;
+    this.actionCB = actionCB;
+  }
+  addArtifact(path) {
+    if (typeof path !== "string") {
+      throw new Error(
+        `[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(
+          path
+        )}`
+      );
+    }
+    const normalizedPath = path.replace(/\\/g, "/");
+    this.artifacts.push(normalizedPath);
+  }
+  toObj() {
+    const obj = {
+      name: this.name,
+      status: this.status,
+      error: this.error ? `${this.error.name}: ${this.error.message}
+${this.error.stack}` : null,
+      artifacts: this.artifacts
+    };
+    return obj;
+  }
+  async test(store, testResourceConfiguration, artifactory) {
+    try {
+      const result = await this.performAction(
+        store,
+        this.actionCB,
+        testResourceConfiguration,
+        artifactory
+      );
+      this.status = true;
+      return result;
+    } catch (e) {
+      this.status = false;
+      this.error = e;
+      throw e;
+    }
+  }
+};
+
 // src/BaseWhen.ts
 var BaseWhen = class extends BaseAction {
   constructor(name, whenCB) {
@@ -713,6 +518,66 @@ var BaseWhen = class extends BaseAction {
   }
 };
 
+// src/BaseCheck.ts
+var BaseCheck = class {
+  constructor(name, checkCB) {
+    this.artifacts = [];
+    this.name = name;
+    this.checkCB = checkCB;
+    this.error = false;
+    this.artifacts = [];
+  }
+  addArtifact(path) {
+    if (typeof path !== "string") {
+      throw new Error(
+        `[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(
+          path
+        )}`
+      );
+    }
+    const normalizedPath = path.replace(/\\/g, "/");
+    this.artifacts.push(normalizedPath);
+  }
+  toObj() {
+    const obj = {
+      name: this.name,
+      error: this.error,
+      artifacts: this.artifacts,
+      status: this.status
+    };
+    return obj;
+  }
+  async test(store, testResourceConfiguration, filepath, artifactory) {
+    const addArtifact = this.addArtifact.bind(this);
+    try {
+      const x = await this.verifyCheck(
+        store,
+        async (s) => {
+          try {
+            if (typeof this.checkCB === "function") {
+              const result = await this.checkCB(s);
+              return result;
+            } else {
+              return this.checkCB;
+            }
+          } catch (e) {
+            this.error = true;
+            throw e;
+          }
+        },
+        testResourceConfiguration,
+        artifactory
+      );
+      this.status = true;
+      return x;
+    } catch (e) {
+      this.status = false;
+      this.error = true;
+      throw e;
+    }
+  }
+};
+
 // src/BaseThen.ts
 var BaseThen = class extends BaseCheck {
   constructor(name, thenCB) {
@@ -749,6 +614,286 @@ var BaseThen = class extends BaseCheck {
   }
 };
 
+// src/BaseValue.ts
+var BaseValue = class extends BaseSetup {
+  constructor(features, tableRows, confirmCB, initialValues) {
+    super(features, [], [], confirmCB, initialValues);
+    this.tableRows = tableRows;
+  }
+  // Override setup to process table rows
+  async setup(subject, key, testResourceConfiguration, tester, artifactory, suiteNdx) {
+    this.key = key;
+    this.fails = 0;
+    const actualArtifactory = artifactory || ((fPath, value) => {
+    });
+    const valueArtifactory = (fPath, value) => actualArtifactory(`value-${key}/${fPath}`, value);
+    try {
+      this.store = await this.setupThat(
+        subject,
+        testResourceConfiguration,
+        valueArtifactory,
+        this.setupCB,
+        this.initialValues
+      );
+      this.status = true;
+    } catch (e) {
+      this.status = false;
+      this.failed = true;
+      this.fails++;
+      this.error = e;
+      return this.store;
+    }
+    try {
+      for (const [rowIndex, row] of (this.tableRows || []).entries()) {
+        try {
+          const rowArtifactory = this.createArtifactoryForRow(
+            key,
+            rowIndex,
+            suiteNdx
+          );
+          const rowResult = await this.processRow(row, rowIndex, rowArtifactory, testResourceConfiguration);
+          if (rowResult !== void 0) {
+            tester(rowResult);
+          }
+        } catch (e) {
+          this.failed = true;
+          this.fails++;
+          this.error = e;
+        }
+      }
+    } catch (e) {
+      this.error = e;
+      this.failed = true;
+      this.fails++;
+    } finally {
+      try {
+        await this.afterEach(this.store, this.key, valueArtifactory);
+      } catch (e) {
+        this.failed = true;
+        this.fails++;
+        this.error = e;
+      }
+    }
+    return this.store;
+  }
+  async processRow(row, rowIndex, artifactory, testResourceConfiguration) {
+    return row;
+  }
+  createArtifactoryForRow(key, rowIndex, suiteNdx) {
+    const self = this;
+    if (self._parent && self._parent.createArtifactory) {
+      return self._parent.createArtifactory({
+        valueKey: key,
+        rowIndex,
+        suiteIndex: suiteNdx
+      });
+    }
+    return {
+      writeFileSync: (filename, payload) => {
+        let path = "";
+        if (suiteNdx !== void 0) {
+          path += `suite-${suiteNdx}/`;
+        }
+        path += `value-${key}/`;
+        path += `row-${rowIndex} ${filename}`;
+        console.log(`[Artifactory] Would write to: ${path}`);
+        console.log(`[Artifactory] Content: ${payload.substring(0, 100)}...`);
+      },
+      screenshot: (filename, payload) => {
+        console.log(`[Artifactory] Would take screenshot: ${filename}`);
+      }
+    };
+  }
+};
+
+// src/BaseShould.ts
+var BaseShould = class extends BaseAction {
+  constructor(name, shouldCB) {
+    super(name, shouldCB);
+    // Current row data
+    this.currentRow = [];
+    this.rowIndex = -1;
+  }
+  // Set current row data
+  setRowData(rowIndex, rowData) {
+    this.rowIndex = rowIndex;
+    this.currentRow = rowData;
+  }
+  // Process the current row
+  async processRow(store, testResourceConfiguration, artifactory) {
+    try {
+      const result = await this.performAction(
+        store,
+        this.actionCB,
+        testResourceConfiguration,
+        artifactory
+      );
+      this.status = true;
+      return result;
+    } catch (e) {
+      this.status = false;
+      this.error = e;
+      throw e;
+    }
+  }
+};
+
+// src/BaseExpected.ts
+var BaseExpected = class extends BaseCheck {
+  constructor(name, expectedCB) {
+    super(name, expectedCB);
+    // Expected value for current row
+    this.expectedValue = null;
+  }
+  // Set expected value for current row
+  setExpectedValue(expected) {
+    this.expectedValue = expected;
+  }
+  // Validate current row
+  async validateRow(store, testResourceConfiguration, filepath, expectedValue, artifactory) {
+    this.setExpectedValue(expectedValue);
+    return this.test(store, testResourceConfiguration, filepath, artifactory);
+  }
+};
+
+// src/BaseDescribe.ts
+var BaseDescribe = class _BaseDescribe extends BaseSetup {
+  constructor(features, its, describeCB, initialValues) {
+    super(features, its, [], describeCB, initialValues);
+    this.its = its;
+  }
+  // Override setup to handle Its differently
+  async setup(subject, key, testResourceConfiguration, tester, artifactory, suiteNdx) {
+    this.key = key;
+    this.fails = 0;
+    const actualArtifactory = artifactory || ((fPath, value) => {
+    });
+    const describeArtifactory = (fPath, value) => actualArtifactory(`describe-${key}/${fPath}`, value);
+    try {
+      this.store = await this.setupThat(
+        subject,
+        testResourceConfiguration,
+        describeArtifactory,
+        this.setupCB,
+        this.initialValues
+      );
+      this.status = true;
+    } catch (e) {
+      this.status = false;
+      this.failed = true;
+      this.fails++;
+      this.error = e;
+      return this.store;
+    }
+    try {
+      for (const [itNdx, itStep] of (this.its || []).entries()) {
+        try {
+          const itArtifactory = this.createArtifactoryForIt(
+            key,
+            itNdx,
+            suiteNdx
+          );
+          if (itStep && itStep instanceof _BaseDescribe) {
+            const nestedResult = await itStep.setup(
+              this.store,
+              `${key}.nested${itNdx}`,
+              testResourceConfiguration,
+              tester,
+              itArtifactory,
+              suiteNdx
+            );
+            this.store = nestedResult;
+          } else {
+            const result = await itStep.test(
+              this.store,
+              testResourceConfiguration,
+              itArtifactory
+            );
+            if (result !== void 0) {
+              if (typeof result === "boolean" || result === null || result === void 0) {
+                tester(result);
+              } else {
+                this.store = result;
+              }
+            }
+          }
+        } catch (e) {
+          this.failed = true;
+          this.fails++;
+          this.error = e;
+        }
+      }
+    } catch (e) {
+      this.error = e;
+      this.failed = true;
+      this.fails++;
+    } finally {
+      try {
+        await this.afterEach(this.store, this.key, describeArtifactory);
+      } catch (e) {
+        this.failed = true;
+        this.fails++;
+        this.error = e;
+      }
+    }
+    return this.store;
+  }
+  createArtifactoryForIt(key, itIndex, suiteNdx) {
+    const self = this;
+    if (self._parent && self._parent.createArtifactory) {
+      return self._parent.createArtifactory({
+        describeKey: key,
+        itIndex,
+        suiteIndex: suiteNdx
+      });
+    }
+    return {
+      writeFileSync: (filename, payload) => {
+        let path = "";
+        if (suiteNdx !== void 0) {
+          path += `suite-${suiteNdx}/`;
+        }
+        path += `describe-${key}/`;
+        path += `it-${itIndex} ${filename}`;
+        console.log(`[Artifactory] Would write to: ${path}`);
+        console.log(`[Artifactory] Content: ${payload.substring(0, 100)}...`);
+      },
+      screenshot: (filename, payload) => {
+        console.log(`[Artifactory] Would take screenshot: ${filename}`);
+      }
+    };
+  }
+};
+
+// src/BaseIt.ts
+var BaseIt = class extends BaseAction {
+  // It can perform both actions and assertions
+  constructor(name, itCB) {
+    super(name, itCB);
+  }
+  // Override test to handle both mutations and assertions
+  async test(store, testResourceConfiguration, artifactory) {
+    try {
+      const result = await this.performAction(
+        store,
+        this.actionCB,
+        testResourceConfiguration,
+        artifactory
+      );
+      this.status = true;
+      return result;
+    } catch (e) {
+      this.status = false;
+      this.error = e;
+      throw e;
+    }
+  }
+  // Alias performAction to performIt
+  async performIt(store, itCB, testResource, artifactory) {
+    return this.performAction(store, itCB, testResource, artifactory);
+  }
+};
+
 // src/index.ts
 var BaseAdapter = () => ({
   prepareAll: async (input, testResource, artifactory) => {
@@ -856,47 +1001,39 @@ var DefaultAdapter = (p) => {
     ...mapped
   };
 };
-function createAAASpecification() {
+function createDescribeItSpecification() {
   return {
-    // Create a suite with AAA pattern
+    // Create a suite with Describe-It pattern
     Suite: {
-      Default: (Suite, Arrange, Act, Assert) => (name, arrangements) => {
-        const givens = {};
-        for (const [key, arrangement] of Object.entries(arrangements)) {
-          const { features, acts, asserts, arrangeCB, initialValues } = arrangement;
-          givens[key] = Arrange.Default(
+      Default: (Suite, Describe, It) => (name, descriptions) => {
+        const setups = {};
+        for (const [key, description] of Object.entries(descriptions)) {
+          const { features, its, describeCB, initialValues } = description;
+          setups[key] = Describe.Default(
             features,
-            acts,
-            asserts,
-            arrangeCB,
+            its,
+            describeCB,
             initialValues
           );
         }
-        return Suite.Default(name, givens);
+        return Suite.Default(name, setups);
       }
     },
-    // Arrange maps to Given
-    Arrange: {
-      Default: (features, acts, asserts, arrangeCB, initialValues) => {
-        return (Arrange) => Arrange.Default(
+    // Describe maps to Setup
+    Describe: {
+      Default: (features, its, describeCB, initialValues) => {
+        return (Describe) => Describe.Default(
           features,
-          acts,
-          asserts,
-          arrangeCB,
+          its,
+          describeCB,
           initialValues
         );
       }
     },
-    // Act maps to When
-    Act: {
-      Default: (name, actCB) => {
-        return (Act) => Act.Default(name, actCB);
-      }
-    },
-    // Assert maps to Then
-    Assert: {
-      Default: (name, assertCB) => {
-        return (Assert) => Assert.Default(name, assertCB);
+    // It can mix mutations and assertions
+    It: {
+      Default: (name, itCB) => {
+        return (It) => It.Default(name, itCB);
       }
     }
   };
@@ -905,130 +1042,111 @@ function createTDTSpecification() {
   return {
     // Create a suite with TDT pattern
     Suite: {
-      Default: (Suite, Map, Feed, Validate) => (name, maps) => {
-        const givens = {};
-        for (const [key, map] of Object.entries(maps)) {
-          const {
+      Default: (Suite, Value, Should, Expected) => (name, confirms) => {
+        const setups = {};
+        for (const [key, confirm] of Object.entries(confirms)) {
+          const { features, tableRows, confirmCB, initialValues } = confirm;
+          setups[key] = Value.Default(
             features,
-            feeds,
-            validates,
-            mapCB,
-            initialValues,
-            tableData
-          } = map;
-          givens[key] = Map.Default(
-            features,
-            feeds,
-            validates,
-            mapCB,
-            initialValues,
-            tableData
+            tableRows,
+            confirmCB,
+            initialValues
           );
         }
-        return Suite.Default(name, givens);
+        return Suite.Default(name, setups);
       }
     },
-    // Map maps to Given
-    Map: {
-      Default: (features, feeds, validates, mapCB, initialValues, tableData = []) => {
-        return (Map) => Map.Default(
+    // Value maps to Setup (sets up table data)
+    Value: {
+      Default: (features, tableRows, confirmCB, initialValues) => {
+        return (Value) => Value.Default(
           features,
-          feeds,
-          validates,
-          mapCB,
-          initialValues,
-          tableData
+          tableRows,
+          confirmCB,
+          initialValues
         );
       }
     },
-    // Feed maps to When
-    Feed: {
-      Default: (name, feedCB) => {
-        return (Feed) => Feed.Default(name, feedCB);
+    // Should processes each row (like Action)
+    Should: {
+      Default: (name, shouldCB) => {
+        return (Should) => Should.Default(name, shouldCB);
       }
     },
-    // Validate maps to Then
-    Validate: {
-      Default: (name, validateCB) => {
-        return (Validate) => Validate.Default(name, validateCB);
+    // Expected validates each row (like Check)
+    Expected: {
+      Default: (name, expectedCB) => {
+        return (Expected) => Expected.Default(name, expectedCB);
       }
     }
   };
 }
-function AAA() {
-  const spec = createAAASpecification();
+function DescribeIt() {
   return {
     Suite: {
-      Default: (name, arrangements) => {
-        console.warn("AAA.Suite.Default called without proper context");
-        return { name, arrangements };
-      }
-    },
-    Arrange: {
-      Default: (features, acts, asserts, arrangeCB, initialValues) => {
-        console.warn("AAA.Arrange.Default called without proper context");
-        return { features, acts, asserts, arrangeCB, initialValues };
+      Default: (name, descriptions) => {
+        console.warn("DescribeIt.Suite.Default: This helper function requires proper context from a test specification. Use createDescribeItSpecification() for full functionality.");
+        return { name, descriptions };
       }
     },
-    Act: {
-      Default: (name, actCB) => {
-        console.warn("AAA.Act.Default called without proper context");
-        return { name, actCB };
+    Describe: {
+      Default: (features, its, describeCB, initialValues) => {
+        console.warn("DescribeIt.Describe.Default: This helper function requires proper context. Use createDescribeItSpecification() for full functionality.");
+        return { features, its, describeCB, initialValues };
       }
     },
-    Assert: {
-      Default: (name, assertCB) => {
-        console.warn("AAA.Assert.Default called without proper context");
-        return { name, assertCB };
+    It: {
+      Default: (name, itCB) => {
+        console.warn("DescribeIt.It.Default: This helper function requires proper context. Use createDescribeItSpecification() for full functionality.");
+        return { name, itCB };
       }
     }
   };
 }
-function TDT() {
+function Confirm() {
   return {
     Suite: {
-      Default: (name, maps) => {
-        console.warn("TDT.Suite.Default called without proper context");
-        return { name, maps };
+      Default: (name, confirms) => {
+        console.warn("Confirm.Suite.Default: This helper function requires proper context from a test specification. Use createTDTSpecification() for full functionality.");
+        return { name, confirms };
       }
     },
-    Map: {
-      Default: (features, feeds, validates, mapCB, initialValues, tableData = []) => {
-        console.warn("TDT.Map.Default called without proper context");
-        return { features, feeds, validates, mapCB, initialValues, tableData };
+    Value: {
+      Default: (features, tableRows, confirmCB, initialValues) => {
+        console.warn("Confirm.Value.Default: This helper function requires proper context. Use createTDTSpecification() for full functionality.");
+        return { features, tableRows, confirmCB, initialValues };
       }
     },
-    Feed: {
-      Default: (name, feedCB) => {
-        console.warn("TDT.Feed.Default called without proper context");
-        return { name, feedCB };
+    Should: {
+      Default: (name, shouldCB) => {
+        console.warn("Confirm.Should.Default: This helper function requires proper context. Use createTDTSpecification() for full functionality.");
+        return { name, shouldCB };
       }
     },
-    Validate: {
-      Default: (name, validateCB) => {
-        console.warn("TDT.Validate.Default called without proper context");
-        return { name, validateCB };
+    Expected: {
+      Default: (name, expectedCB) => {
+        console.warn("Confirm.Expected.Default: This helper function requires proper context. Use createTDTSpecification() for full functionality.");
+        return { name, expectedCB };
       }
     }
   };
 }
 export {
-  AAA,
-  BaseAct,
   BaseAction,
   BaseAdapter,
-  BaseArrange,
-  BaseAssert,
   BaseCheck,
-  BaseFeed,
+  BaseDescribe,
+  BaseExpected,
   BaseGiven,
-  BaseMap,
+  BaseIt,
   BaseSetup,
+  BaseShould,
   BaseThen,
-  BaseValidate,
+  BaseValue,
   BaseWhen,
+  Confirm,
   DefaultAdapter,
-  TDT,
-  createAAASpecification,
+  DescribeIt,
+  createDescribeItSpecification,
   createTDTSpecification
 };