@everyonesoftware/common 7.0.0 → 9.0.0

package/outputs/testIndex.cjs

@@ -1917,6 +1917,97 @@ var JavascriptArrayList = class _JavascriptArrayList {
   }
 };
 
+// sources/MutableIndexable.ts
+var MutableIndexable = class _MutableIndexable {
+  static create(values) {
+    return List.create(values);
+  }
+  toArray() {
+    return _MutableIndexable.toArray(this);
+  }
+  static toArray(indexable) {
+    return Indexable.toArray(indexable);
+  }
+  any() {
+    return _MutableIndexable.any(this);
+  }
+  static any(indexable) {
+    return Indexable.any(indexable);
+  }
+  getCount() {
+    return _MutableIndexable.getCount(this);
+  }
+  static getCount(indexable) {
+    return Indexable.getCount(indexable);
+  }
+  equals(right, equalFunctions) {
+    return _MutableIndexable.equals(this, right, equalFunctions);
+  }
+  static equals(left, right, equalFunctions) {
+    return Indexable.equals(left, right, equalFunctions);
+  }
+  toString(toStringFunctions) {
+    return _MutableIndexable.toString(this, toStringFunctions);
+  }
+  static toString(indexable, toStringFunctions) {
+    return Indexable.toString(indexable, toStringFunctions);
+  }
+  concatenate(...toConcatenate) {
+    return _MutableIndexable.concatenate(this, ...toConcatenate);
+  }
+  static concatenate(indexable, ...toConcatenate) {
+    return Indexable.concatenate(indexable, ...toConcatenate);
+  }
+  map(mapping) {
+    return _MutableIndexable.map(this, mapping);
+  }
+  static map(indexable, mapping) {
+    return Indexable.map(indexable, mapping);
+  }
+  flatMap(mapping) {
+    return _MutableIndexable.flatMap(this, mapping);
+  }
+  static flatMap(indexable, mapping) {
+    return Indexable.flatMap(indexable, mapping);
+  }
+  where(condition) {
+    return _MutableIndexable.where(this, condition);
+  }
+  static where(indexable, condition) {
+    return Indexable.where(indexable, condition);
+  }
+  instanceOf(typeOrTypeCheck) {
+    return _MutableIndexable.instanceOf(this, typeOrTypeCheck);
+  }
+  static instanceOf(indexable, typeOrTypeCheck) {
+    return Indexable.instanceOf(indexable, typeOrTypeCheck);
+  }
+  first(condition) {
+    return _MutableIndexable.first(this, condition);
+  }
+  static first(indexable, condition) {
+    return Indexable.first(indexable, condition);
+  }
+  last(condition) {
+    return _MutableIndexable.last(this, condition);
+  }
+  static last(indexable, condition) {
+    return Indexable.last(indexable, condition);
+  }
+  [Symbol.iterator]() {
+    return Indexable[Symbol.iterator](this);
+  }
+  static [Symbol.iterator](indexable) {
+    return Iterable[Symbol.iterator](indexable);
+  }
+  contains(value, equalFunctions) {
+    return _MutableIndexable.contains(this, value, equalFunctions);
+  }
+  static contains(indexable, value, equalFunctions) {
+    return Indexable.contains(indexable, value, equalFunctions);
+  }
+};
+
 // sources/javascript.ts
 var JavascriptMap = Map;
 var JavascriptSet = Set;
@@ -2764,73 +2855,73 @@ var List = class _List {
     return _List.toArray(this);
   }
   static toArray(list2) {
-    return Indexable.toArray(list2);
+    return MutableIndexable.toArray(list2);
   }
   any() {
     return _List.any(this);
   }
   static any(list2) {
-    return Indexable.any(list2);
+    return MutableIndexable.any(list2);
   }
   getCount() {
     return _List.getCount(this);
   }
   static getCount(list2) {
-    return Indexable.getCount(list2);
+    return MutableIndexable.getCount(list2);
   }
   equals(right, equalFunctions) {
     return _List.equals(this, right, equalFunctions);
   }
   static equals(left, right, equalFunctions) {
-    return Indexable.equals(left, right, equalFunctions);
+    return MutableIndexable.equals(left, right, equalFunctions);
   }
   toString(toStringFunctions) {
     return _List.toString(this, toStringFunctions);
   }
   static toString(list2, toStringFunctions) {
-    return Indexable.toString(list2, toStringFunctions);
+    return MutableIndexable.toString(list2, toStringFunctions);
   }
   concatenate(...toConcatenate) {
     return _List.concatenate(this, ...toConcatenate);
   }
   static concatenate(list2, ...toConcatenate) {
-    return Indexable.concatenate(list2, ...toConcatenate);
+    return MutableIndexable.concatenate(list2, ...toConcatenate);
   }
   map(mapping) {
     return _List.map(this, mapping);
   }
   static map(list2, mapping) {
-    return Indexable.map(list2, mapping);
+    return MutableIndexable.map(list2, mapping);
   }
   flatMap(mapping) {
     return _List.flatMap(this, mapping);
   }
   static flatMap(list2, mapping) {
-    return Indexable.flatMap(list2, mapping);
+    return MutableIndexable.flatMap(list2, mapping);
   }
   where(condition) {
     return _List.where(this, condition);
   }
   static where(list2, condition) {
-    return Indexable.where(list2, condition);
+    return MutableIndexable.where(list2, condition);
   }
   instanceOf(typeOrTypeCheck) {
     return _List.instanceOf(this, typeOrTypeCheck);
   }
   static instanceOf(list2, typeOrTypeCheck) {
-    return Indexable.instanceOf(list2, typeOrTypeCheck);
+    return MutableIndexable.instanceOf(list2, typeOrTypeCheck);
   }
   first(condition) {
     return _List.first(this, condition);
   }
   static first(list2, condition) {
-    return Indexable.first(list2, condition);
+    return MutableIndexable.first(list2, condition);
   }
   last(condition) {
     return _List.last(this, condition);
   }
   static last(list2, condition) {
-    return Indexable.last(list2, condition);
+    return MutableIndexable.last(list2, condition);
   }
   [Symbol.iterator]() {
     return _List[Symbol.iterator](this);
@@ -2842,7 +2933,7 @@ var List = class _List {
     return _List.contains(this, value, equalFunctions);
   }
   static contains(list2, value, equalFunctions) {
-    return Indexable.contains(list2, value, equalFunctions);
+    return MutableIndexable.contains(list2, value, equalFunctions);
   }
 };
 
@@ -5632,15 +5723,13 @@ var Test = class _Test {
 
 // tests/assertTest.ts
 var AssertTest = class _AssertTest {
-  name;
-  constructor(name) {
-    this.name = name;
+  constructor() {
   }
   /**
    * Create a new {@link AssertTest} object.
    */
-  static create(name) {
-    return new _AssertTest(name);
+  static create() {
+    return new _AssertTest();
   }
   fail(message) {
     PreCondition.assertNotEmpty(message, "message");
@@ -5707,13 +5796,13 @@ function test(runner) {
     runner.testType("AssertTest", () => {
       runner.testFunction("assertThrows()", () => {
         runner.test("with throwing action", (test2) => {
-          const at = AssertTest.create("fake-test-name");
+          const at = AssertTest.create();
           at.assertThrows(() => {
             throw new Error("abc");
           }, new Error("abc"));
         });
         runner.test("with non-throwing action", (test2) => {
-          const at = AssertTest.create("fake-test-name");
+          const at = AssertTest.create();
           test2.assertThrows(
             () => at.assertThrows(() => {
             }, new Error("oops")),
@@ -5727,27 +5816,27 @@ function test(runner) {
       });
       runner.testFunction("assertThrowsAsync()", () => {
         runner.test("with throwing sync action", async (test2) => {
-          const at = AssertTest.create("fake-test-name");
+          const at = AssertTest.create();
           await at.assertThrowsAsync(() => {
             throw new Error("abc");
           }, new Error("abc"));
         });
         runner.test("with throwing async action", async (test2) => {
-          const at = AssertTest.create("fake-test-name");
+          const at = AssertTest.create();
           await at.assertThrowsAsync(async () => {
             throw new Error("abc");
           }, new Error("abc"));
         });
         runner.test("with rejected Promise", async (test2) => {
-          const at = AssertTest.create("fake-test-name");
+          const at = AssertTest.create();
           await at.assertThrowsAsync(Promise.reject(new Error("abc")), new Error("abc"));
         });
         runner.test("with throwing action that returns a rejected Promise", async (test2) => {
-          const at = AssertTest.create("fake-test-name");
+          const at = AssertTest.create();
           await at.assertThrowsAsync(() => Promise.reject(new Error("abc")), new Error("abc"));
         });
         runner.test("with non-throwing async action", async (test2) => {
-          const at = AssertTest.create("fake-test-name");
+          const at = AssertTest.create();
           await test2.assertThrowsAsync(
             async () => await at.assertThrowsAsync(async () => {
             }, new Error("oops")),
@@ -5812,12 +5901,9 @@ var FailedTest = class _FailedTest {
   getTestAction() {
     return this.testAction;
   }
-  getError() {
+  getTestError() {
     return this.error;
   }
-  getErrorMessage() {
-    return this.error instanceof Error && this.error.stack ? this.error.stack : `${this.error}`;
-  }
 };
 
 // tests/skippedTest.ts
@@ -5970,6 +6056,7 @@ var TestRunner = class _TestRunner {
 var ConsoleTestRunnerUI = class {
   writeStream;
   styles;
+  getErrorStringOptions;
   constructor() {
     this.styles = Map2.create();
   }
@@ -6042,6 +6129,10 @@ var ConsoleTestRunnerUI = class {
       return result;
     });
   }
+  setGetErrorStringOptions(options) {
+    this.getErrorStringOptions = options;
+    return this;
+  }
   beforeTestGroup(testGroup) {
     PreCondition.assertNotUndefinedAndNotNull(testGroup, "testGroup");
     return AsyncResult.empty();
@@ -6099,7 +6190,8 @@ var ConsoleTestRunnerUI = class {
           await this.writeString(`${++counter}) `);
           await this.writeFullTestActionName(failedTest.getTestAction());
           await this.writeLine();
-          await this.indent(() => this.writeLine(failedTest.getErrorMessage()));
+          const testError = failedTest.getTestError();
+          await this.indent(() => this.writeLine(testError.getErrorString(this.getErrorStringOptions)));
           await this.writeLine();
         }
       }
@@ -6172,6 +6264,132 @@ var TreeConsoleTestRunnerUI = class _TreeConsoleTestRunnerUI extends ConsoleTest
   }
 };
 
+// tests/AssertTestCreator.ts
+var AssertTestCreator = class _AssertTestCreator {
+  constructor() {
+  }
+  static create() {
+    return new _AssertTestCreator();
+  }
+  createTest() {
+    return AssertTest.create();
+  }
+};
+
+// tests/TestCreator.ts
+var TestCreator = class {
+  /**
+   * Create the default {@link TestCreator}.
+   */
+  static create() {
+    return AssertTestCreator.create();
+  }
+};
+
+// tests/BasicTestError.ts
+var import_url = require("url");
+var import_path = __toESM(require("path"), 1);
+var BasicTestError = class _BasicTestError {
+  error;
+  constructor(error) {
+    PreCondition.assertNotUndefinedAndNotNull(error, "error");
+    this.error = error;
+  }
+  static create(error) {
+    return new _BasicTestError(error);
+  }
+  getError() {
+    return this.error;
+  }
+  getErrorString(options) {
+    let result = this.error instanceof Error && this.error.stack ? this.error.stack : `${this.error}`;
+    const currentFolderPath = process.cwd();
+    if (options?.removeNonProjectPaths ?? false) {
+      result = _BasicTestError.removeNonProjectPaths(result, currentFolderPath);
+    }
+    if (options?.relativeFilePaths ?? false) {
+      result = _BasicTestError.makeFilePathsRelative(result, currentFolderPath);
+    }
+    return result;
+  }
+  static getStackFrameLineMatch(line) {
+    return line.match(/^(\s*)at (.*) \((.+)\)$/) ?? line.match(/^(\s*)at (.+)$/);
+  }
+  static normalizePath(path2) {
+    return path2.replace(/\\/g, "/");
+  }
+  static getStackFrameAbsolutePath(stackFrameLocation) {
+    let result = _BasicTestError.normalizePath(stackFrameLocation);
+    if (result.startsWith("file:///")) {
+      result = _BasicTestError.normalizePath((0, import_url.fileURLToPath)(result));
+    } else if (!/^[A-Za-z]:[\\/]/.test(result) && !result.startsWith("/")) {
+      result = void 0;
+    }
+    return result;
+  }
+  static removeNonProjectPaths(errorString, currentFolderPath) {
+    currentFolderPath = _BasicTestError.normalizePath(currentFolderPath);
+    return errorString.split("\n").filter((line) => {
+      let keepLine = true;
+      const stackFrameLineMatch = _BasicTestError.getStackFrameLineMatch(line);
+      if (stackFrameLineMatch) {
+        const hasFunctionName = stackFrameLineMatch.length === 4;
+        const location = hasFunctionName ? stackFrameLineMatch[3] : stackFrameLineMatch[2];
+        const filePath = _BasicTestError.getStackFrameAbsolutePath(location);
+        keepLine = !!filePath && filePath.startsWith(currentFolderPath) && !filePath.includes("/node_modules/");
+      }
+      return keepLine;
+    }).join("\n");
+  }
+  static makeFilePathsRelative(errorString, currentFolderPath) {
+    return errorString.split("\n").map((line) => {
+      const stackFrameLineMatch = _BasicTestError.getStackFrameLineMatch(line);
+      if (stackFrameLineMatch) {
+        const hasFunctionName = stackFrameLineMatch.length === 4;
+        const indentation = stackFrameLineMatch[1];
+        const functionName = hasFunctionName ? stackFrameLineMatch[2] : void 0;
+        const location = hasFunctionName ? stackFrameLineMatch[3] : stackFrameLineMatch[2];
+        let relativeLocation = location;
+        const pathMatch = location.match(/^(.*?):(\d+):(\d+)$/);
+        if (pathMatch) {
+          const absolutePath = _BasicTestError.getStackFrameAbsolutePath(location);
+          if (absolutePath) {
+            const relativePath = import_path.default.relative(currentFolderPath, absolutePath);
+            relativeLocation = _BasicTestError.normalizePath(relativePath);
+          }
+        }
+        if (relativeLocation !== location) {
+          if (functionName) {
+            line = `${indentation}at ${functionName} (${relativeLocation})`;
+          } else {
+            line = `${indentation}at ${relativeLocation}`;
+          }
+        }
+      }
+      return line;
+    }).join("\n");
+  }
+};
+
+// tests/BasicTestErrorCreator.ts
+var BasicTestErrorCreator = class _BasicTestErrorCreator {
+  constructor() {
+  }
+  static create() {
+    return new _BasicTestErrorCreator();
+  }
+  createTestError(error) {
+    return BasicTestError.create(error);
+  }
+};
+
+// tests/TestErrorCreator.ts
+var TestErrorCreator = class {
+  static create() {
+    return BasicTestErrorCreator.create();
+  }
+};
+
 // tests/consoleTestRunner.ts
 var ConsoleTestRunner = class _ConsoleTestRunner {
   writeStream;
@@ -6182,19 +6400,23 @@ var ConsoleTestRunner = class _ConsoleTestRunner {
   passedTestCount;
   skippedTests;
   testFailures;
+  testCreator;
+  testErrorCreator;
   ui;
-  constructor(ui) {
+  constructor(testCreator, testErrorCreator, ui) {
     this.writeStream = IndentedCharacterWriteStream.create(NodeJSCharacterWriteStream.create(process.stdout));
     this.testActions = List.create();
     this.testActionInsertIndex = 0;
     this.passedTestCount = 0;
     this.skippedTests = List.create();
     this.testFailures = List.create();
+    this.testCreator = testCreator || TestCreator.create();
+    this.testErrorCreator = testErrorCreator || TestErrorCreator.create();
     this.ui = ui || ConsoleTestRunnerUI.tree();
     this.ui.setWriteStream(this.writeStream);
   }
-  static create(ui) {
-    return new _ConsoleTestRunner(ui);
+  static create(testCreator, testErrorCreator, ui) {
+    return new _ConsoleTestRunner(testCreator, testErrorCreator, ui);
   }
   static run(testFunctionOrTestFunctions) {
     let testFunction;
@@ -6243,6 +6465,10 @@ var ConsoleTestRunner = class _ConsoleTestRunner {
     this.ui.setStyles(styles);
     return this;
   }
+  setGetErrorStringOptions(options) {
+    this.ui.setGetErrorStringOptions(options);
+    return this;
+  }
   /**
    * Get the number of {@link TestAction}s that have yet to be executed.
    */
@@ -6261,7 +6487,14 @@ var ConsoleTestRunner = class _ConsoleTestRunner {
   }
   insertTestAction(testActionName, testActionType, skip, action) {
     const parentTestAction = this.getCurrentTestAction();
-    const testAction = TestAction.create(parentTestAction, testActionName, testActionType, skip, action);
+    const testAction = TestAction.create(parentTestAction, testActionName, testActionType, skip, async () => {
+      try {
+        await action();
+      } catch (error) {
+        const testError = this.testErrorCreator.createTestError(error);
+        await this.afterFailedTest(testAction, testError);
+      }
+    });
     this.testActions.insert(this.testActionInsertIndex, testAction);
     this.testActionInsertIndex++;
   }
@@ -6438,12 +6671,7 @@ var ConsoleTestRunner = class _ConsoleTestRunner {
       skip,
       async () => {
         this.resetTestActionInsertIndex();
-        try {
-          await testGroupAction();
-        } catch (error) {
-          const currentTestGroupAction = this.getCurrentTestAction();
-          await this.afterFailedTest(currentTestGroupAction, error);
-        }
+        await testGroupAction();
       }
     );
     this.insertTestAction(
@@ -6463,22 +6691,18 @@ var ConsoleTestRunner = class _ConsoleTestRunner {
       skip,
       async () => {
         const currentTestAction = this.getCurrentTestAction();
-        try {
-          await this.beforeTest(currentTestAction);
-          const skip2 = currentTestAction.getSkip();
-          if (skip2?.getShouldSkip()) {
-            await this.afterSkippedTest(currentTestAction, skip2);
-          } else {
-            this.currentTest = AssertTest.create(testName);
-            try {
-              await testAction(this.currentTest);
-            } finally {
-              this.currentTest = void 0;
-            }
-            await this.afterPassedTest(currentTestAction);
+        await this.beforeTest(currentTestAction);
+        const skip2 = currentTestAction.getSkip();
+        if (skip2?.getShouldSkip()) {
+          await this.afterSkippedTest(currentTestAction, skip2);
+        } else {
+          this.currentTest = this.testCreator.createTest();
+          try {
+            await testAction(this.currentTest);
+          } finally {
+            this.currentTest = void 0;
           }
-        } catch (error) {
-          await this.afterFailedTest(currentTestAction, error);
+          await this.afterPassedTest(currentTestAction);
         }
       }
     );