Feat/gh helpers (#1)

* feat: add new helpers for string manipulation and CTRF formatting

* refactor: update module resolution and remove esm compatibility script

* chore: update duration formatting logic

Author: Ma11hewThomas

README.md

@@ -17,6 +17,7 @@ import {
 	mapHelper,
 	pluckHelper,
 	reverseHelper,
+	sliceHelper,
 	someHelper,
 	sortByHelper,
 	sortHelper,
@@ -187,6 +188,74 @@ describe("lengthEqualHelper", () => {
 	});
 });
 
+describe("sliceHelper", () => {
+	it("returns slice of array as regular helper", () => {
+		const array = ["a", "b", "c", "d", "e"];
+		expect(sliceHelper.fn(array, 1, 4)).toEqual(["b", "c", "d"]);
+	});
+
+	it("works as block helper with Handlebars context", () => {
+		const array = ["item1", "item2", "item3", "item4"];
+		const mockOptions = {
+			fn: (item: string) => `<li>${item}</li>`,
+		};
+		const result = sliceHelper.fn(array, 1, 3, mockOptions);
+		expect(result).toBe("<li>item2</li><li>item3</li>");
+	});
+
+	it("handles string indices", () => {
+		const array = [1, 2, 3, 4, 5];
+		expect(sliceHelper.fn(array, "1", "4")).toEqual([2, 3, 4]);
+	});
+
+	it("uses defaults for invalid indices", () => {
+		const array = ["a", "b", "c"];
+		expect(sliceHelper.fn(array, "invalid", "also_invalid")).toEqual(["a", "b", "c"]);
+		expect(sliceHelper.fn(array, 0, "invalid")).toEqual(["a", "b", "c"]);
+	});
+
+	it("returns empty string for non-array input", () => {
+		expect(sliceHelper.fn(null, 0, 2)).toBe("");
+		expect(sliceHelper.fn("not an array", 0, 2)).toBe("");
+	});
+
+	it("handles edge cases with indices", () => {
+		const array = ["a", "b", "c"];
+		// Start index beyond array length
+		expect(sliceHelper.fn(array, 5, 10)).toEqual([]);
+		// Negative start index with positive end (should return empty like native slice)
+		expect(sliceHelper.fn(array, -1, 2)).toEqual([]);
+		// Negative start index without end (should return last item)
+		expect(sliceHelper.fn(array, -1)).toEqual(["c"]);
+		// Negative indices both (should work like native slice)
+		expect(sliceHelper.fn(array, -2, -1)).toEqual(["b"]);
+		// End index beyond array length
+		expect(sliceHelper.fn(array, 0, 10)).toEqual(["a", "b", "c"]);
+	});
+
+	it("works for pagination scenarios", () => {
+		const testResults = [
+			{ name: "test1" }, { name: "test2" }, { name: "test3" },
+			{ name: "test4" }, { name: "test5" }, { name: "test6" }
+		];
+		
+		// Page 1: items 0-2
+		expect(sliceHelper.fn(testResults, 0, 3)).toEqual([
+			{ name: "test1" }, { name: "test2" }, { name: "test3" }
+		]);
+		
+		// Page 2: items 3-5
+		expect(sliceHelper.fn(testResults, 3, 6)).toEqual([
+			{ name: "test4" }, { name: "test5" }, { name: "test6" }
+		]);
+	});
+
+	it("should be categorized as Array helper", () => {
+		expect(sliceHelper.category).toBe("Array");
+		expect(sliceHelper.name).toBe("slice");
+	});
+});
+
 describe("mapHelper", () => {
 	it("maps array with function", () => {
 		const double = (x: number) => x * 2;

__tests__/helpers/array.test.ts

@@ -7,6 +7,10 @@ import {
 	filterPassedTestsHelper,
 	formatDurationFromTimesHelper,
 	formatDurationHelper,
+	formatTestMessageHelper,
+	formatTestMessagePreCodeHelper,
+	getCtrfEmojiHelper,
+	limitFailedTestsHelper,
 	sortTestsByFailRateHelper,
 	sortTestsByFlakyRateHelper,
 } from "../../src/helpers/ctrf";
@@ -174,6 +178,128 @@ describe("CTRF Helpers", () => {
 		});
 	});
 
+	describe("limitFailedTestsHelper", () => {
+		it("should filter failed tests and limit to specified number", () => {
+			const result = limitFailedTestsHelper.fn(mockTests, 1);
+
+			if (Array.isArray(result)) {
+				expect(result).toHaveLength(1);
+				expect(result[0].status).toBe("failed");
+				expect(result[0].name).toBe("Failing Test 1");
+			}
+		});
+
+		it("should return all failed tests when limit is greater than failed count", () => {
+			const result = limitFailedTestsHelper.fn(mockTests, 10);
+
+			if (Array.isArray(result)) {
+				expect(result).toHaveLength(2); // Only 2 failed tests in mockTests
+				expect(result.every((test: Test) => test.status === "failed")).toBe(true);
+				expect(result[0].name).toBe("Failing Test 1");
+				expect(result[1].name).toBe("Failing Test 2");
+			}
+		});
+
+		it("should handle zero limit", () => {
+			const result = limitFailedTestsHelper.fn(mockTests, 0);
+			expect(result).toHaveLength(0);
+		});
+
+		it("should handle negative limit by defaulting to 10", () => {
+			const result = limitFailedTestsHelper.fn(mockTests, -5);
+
+			if (Array.isArray(result)) {
+				expect(result).toHaveLength(2); // All 2 failed tests, since -5 defaults to 10
+				expect(result.every((test: Test) => test.status === "failed")).toBe(true);
+			}
+		});
+
+		it("should handle string limit by parsing to number", () => {
+			const result = limitFailedTestsHelper.fn(mockTests, "1");
+
+			if (Array.isArray(result)) {
+				expect(result).toHaveLength(1);
+				expect(result[0].status).toBe("failed");
+				expect(result[0].name).toBe("Failing Test 1");
+			}
+		});
+
+		it("should handle invalid string limit by defaulting to 10", () => {
+			const result = limitFailedTestsHelper.fn(mockTests, "invalid");
+
+			if (Array.isArray(result)) {
+				expect(result).toHaveLength(2); // All 2 failed tests, since "invalid" defaults to 10
+				expect(result.every((test: Test) => test.status === "failed")).toBe(true);
+			}
+		});
+
+		it("should handle undefined limit by defaulting to 10", () => {
+			const result = limitFailedTestsHelper.fn(mockTests, undefined);
+
+			if (Array.isArray(result)) {
+				expect(result).toHaveLength(2); // All 2 failed tests, since undefined defaults to 10
+				expect(result.every((test: Test) => test.status === "failed")).toBe(true);
+			}
+		});
+
+		it("should return empty array when no failed tests", () => {
+			const passedOnlyTests: Test[] = [
+				{ name: "Passed Test", status: "passed", duration: 1000 },
+				{ name: "Skipped Test", status: "skipped", duration: 0 },
+			];
+
+			const result = limitFailedTestsHelper.fn(passedOnlyTests, 5);
+			expect(result).toHaveLength(0);
+		});
+
+		it("should return empty array for non-array input", () => {
+			expect(limitFailedTestsHelper.fn(null, 5)).toEqual([]);
+			expect(limitFailedTestsHelper.fn(undefined, 5)).toEqual([]);
+			expect(limitFailedTestsHelper.fn("not-an-array", 5)).toEqual([]);
+			expect(limitFailedTestsHelper.fn({}, 5)).toEqual([]);
+		});
+
+		it("should handle edge case with many failed tests", () => {
+			const manyFailedTests: Test[] = Array.from({ length: 20 }, (_, i) => ({
+				name: `Failed Test ${i + 1}`,
+				status: "failed" as const,
+				duration: 1000,
+			}));
+
+			const result = limitFailedTestsHelper.fn(manyFailedTests, 3);
+
+			if (Array.isArray(result)) {
+				expect(result).toHaveLength(3);
+				expect(result[0].name).toBe("Failed Test 1");
+				expect(result[1].name).toBe("Failed Test 2");
+				expect(result[2].name).toBe("Failed Test 3");
+				expect(result.every((test: Test) => test.status === "failed")).toBe(true);
+			}
+		});
+
+		it("should preserve order of failed tests", () => {
+			const orderedTests: Test[] = [
+				{ name: "First Failed", status: "failed", duration: 100 },
+				{ name: "Passed Test", status: "passed", duration: 200 },
+				{ name: "Second Failed", status: "failed", duration: 300 },
+				{ name: "Third Failed", status: "failed", duration: 400 },
+			];
+
+			const result = limitFailedTestsHelper.fn(orderedTests, 2);
+
+			if (Array.isArray(result)) {
+				expect(result).toHaveLength(2);
+				expect(result[0].name).toBe("First Failed");
+				expect(result[1].name).toBe("Second Failed");
+			}
+		});
+
+		it("should be categorized as CTRF helper", () => {
+			expect(limitFailedTestsHelper.category).toBe("CTRF");
+			expect(limitFailedTestsHelper.name).toBe("limitFailedTests");
+		});
+	});
+
 	describe("filterOtherTestsHelper", () => {
 		it("should filter skipped, pending, and other status tests", () => {
 			const result = filterOtherTestsHelper.fn(mockTests);
@@ -333,7 +459,7 @@ describe("CTRF Helpers", () => {
 
 		it("should handle negative duration (stop before start)", () => {
 			const result = formatDurationFromTimesHelper.fn(2000, 1000);
-			expect(result).toBe("not captured");
+			expect(result).toBe("1ms");
 		});
 	});
 
@@ -371,6 +497,140 @@ describe("CTRF Helpers", () => {
 		});
 	});
 
+	describe("formatTestMessageHelper (formatTestMessage)", () => {
+		it("should convert ANSI codes to HTML and newlines to <br> for test messages", () => {
+			expect(formatTestMessageHelper.fn("Line1\nLine2")).toBe("Line1<br>Line2");
+			expect(formatTestMessageHelper.fn("Test \u001b[31mFAILED\u001b[0m\nNext line")).toBe("Test <span style=\"color:#A00\">FAILED</span><br>Next line");
+		});
+
+		it("should handle multiple newlines in test output", () => {
+			expect(formatTestMessageHelper.fn("Error\n\nStack trace")).toBe("Error<br><br>Stack trace");
+			expect(formatTestMessageHelper.fn("Line1\n\n\nLine4")).toBe("Line1<br><br>Line4");
+		});
+
+		it("should handle complex ANSI sequences in test failures", () => {
+			const input = "\u001b[32mExpected\u001b[0m\n\u001b[31mActual\u001b[0m\n\u001b[1mDiff\u001b[0m";
+			const expected = "<span style=\"color:#0A0\">Expected</span><br><span style=\"color:#A00\">Actual</span><br><b>Diff</b>";
+			expect(formatTestMessageHelper.fn(input)).toBe(expected);
+		});
+
+		it("should handle empty and null test messages", () => {
+			expect(formatTestMessageHelper.fn("")).toBe("No message available");
+			expect(formatTestMessageHelper.fn(null as unknown)).toBe("");
+			expect(formatTestMessageHelper.fn(undefined as unknown)).toBe("");
+		});
+
+		it("should handle non-string inputs gracefully", () => {
+			expect(formatTestMessageHelper.fn(123 as unknown)).toBe("");
+			expect(formatTestMessageHelper.fn({} as unknown)).toBe("");
+			expect(formatTestMessageHelper.fn([] as unknown)).toBe("");
+		});
+
+		it("should handle real-world test failure scenarios", () => {
+			const assertionError = "AssertionError: expected 'false' to be 'true'\n\u001b[31m- false\u001b[0m\n\u001b[32m+ true\u001b[0m";
+			const expected = "AssertionError: expected 'false' to be 'true'<br><span style=\"color:#A00\">- false</span><br><span style=\"color:#0A0\">+ true</span>";
+			expect(formatTestMessageHelper.fn(assertionError)).toBe(expected);
+		});
+
+		it("should handle Jest/Vitest style test output", () => {
+			const jestOutput = "\u001b[1m\u001b[32m✓\u001b[0m Test passed\n\u001b[1m\u001b[31m✗\u001b[0m Test failed\nStack trace";
+			const result = formatTestMessageHelper.fn(jestOutput);
+			expect(result).toContain("<b><span style=\"color:#0A0\">✓</span></b>");
+			expect(result).toContain("<b><span style=\"color:#A00\">✗</span></b>");
+			expect(result).toContain("<br>");
+		});
+
+		it("should be categorized as CTRF helper", () => {
+			expect(formatTestMessageHelper.category).toBe("CTRF");
+			expect(formatTestMessageHelper.name).toBe("formatTestMessage");
+		});
+	});
+
+	describe("formatTestMessagePreCodeHelper", () => {
+		it("should convert ANSI codes to HTML but preserve newlines for code formatting", () => {
+			expect(formatTestMessagePreCodeHelper.fn("Line1\nLine2")).toBe("Line1\nLine2");
+			expect(formatTestMessagePreCodeHelper.fn("Code \u001b[31mError\u001b[0m\nNext line")).toBe("Code <span style=\"color:#A00\">Error</span>\nNext line");
+		});
+
+		it("should minimize consecutive newlines but preserve single ones", () => {
+			expect(formatTestMessagePreCodeHelper.fn("Line1\n\nLine3")).toBe("Line1\nLine3");
+			expect(formatTestMessagePreCodeHelper.fn("Line1\n\n\nLine4")).toBe("Line1\nLine4");
+			expect(formatTestMessagePreCodeHelper.fn("Line1\n\n\n\nLine5")).toBe("Line1\nLine5");
+		});
+
+		it("should handle stack traces with ANSI codes", () => {
+			const stackTrace = "Error: Test failed\n  at test.js:10:5\n\u001b[31m  at runner.js:45:12\u001b[0m\n  at main.js:20:3";
+			const expected = "Error: Test failed\n  at test.js:10:5\n<span style=\"color:#A00\">  at runner.js:45:12</span>\n  at main.js:20:3";
+			expect(formatTestMessagePreCodeHelper.fn(stackTrace)).toBe(expected);
+		});
+
+		it("should handle code blocks with syntax highlighting", () => {
+			const codeBlock = "function test() {\n  \u001b[32mconsole.log\u001b[0m('hello');\n  \u001b[31mthrow new Error\u001b[0m('test');\n}";
+			const expected = "function test() {\n  <span style=\"color:#0A0\">console.log</span>('hello');\n  <span style=\"color:#A00\">throw new Error</span>('test');\n}";
+			expect(formatTestMessagePreCodeHelper.fn(codeBlock)).toBe(expected);
+		});
+
+		it("should handle empty and null inputs", () => {
+			expect(formatTestMessagePreCodeHelper.fn("")).toBe("No message available");
+			expect(formatTestMessagePreCodeHelper.fn(null as unknown)).toBe("");
+			expect(formatTestMessagePreCodeHelper.fn(undefined as unknown)).toBe("");
+		});
+
+		it("should handle non-string inputs gracefully", () => {
+			expect(formatTestMessagePreCodeHelper.fn(123 as unknown)).toBe("");
+			expect(formatTestMessagePreCodeHelper.fn({} as unknown)).toBe("");
+			expect(formatTestMessagePreCodeHelper.fn([] as unknown)).toBe("");
+		});
+
+		it("should be ideal for pre-formatted content", () => {
+			const preFormattedContent = "Code:\n  function add(a, b) {\n    \u001b[33mreturn a + b;\u001b[0m\n  }\n\n\nOutput:\n  \u001b[32m5\u001b[0m";
+			const expected = "Code:\n  function add(a, b) {\n    <span style=\"color:#A50\">return a + b;</span>\n  }\nOutput:\n  <span style=\"color:#0A0\">5</span>";
+			expect(formatTestMessagePreCodeHelper.fn(preFormattedContent)).toBe(expected);
+		});
+
+		it("should be categorized as CTRF helper", () => {
+			expect(formatTestMessagePreCodeHelper.category).toBe("CTRF");
+			expect(formatTestMessagePreCodeHelper.name).toBe("formatTestMessagePreCode");
+		});
+	});
+
+	describe("getCtrfEmojiHelper", () => {
+		it("should return correct emojis for test statuses", () => {
+			expect(getCtrfEmojiHelper.fn("passed")).toBe("✅");
+			expect(getCtrfEmojiHelper.fn("failed")).toBe("❌");
+			expect(getCtrfEmojiHelper.fn("skipped")).toBe("⏭️");
+			expect(getCtrfEmojiHelper.fn("pending")).toBe("⏳");
+			expect(getCtrfEmojiHelper.fn("other")).toBe("❓");
+		});
+
+		it("should return correct emojis for categories", () => {
+			expect(getCtrfEmojiHelper.fn("build")).toBe("🏗️");
+			expect(getCtrfEmojiHelper.fn("duration")).toBe("⏱️");
+			expect(getCtrfEmojiHelper.fn("flaky")).toBe("🍂");
+			expect(getCtrfEmojiHelper.fn("tests")).toBe("📝");
+			expect(getCtrfEmojiHelper.fn("result")).toBe("🧪");
+			expect(getCtrfEmojiHelper.fn("warning")).toBe("⚠️");
+		});
+
+		it("should return default emoji for unknown status", () => {
+			expect(getCtrfEmojiHelper.fn("unknown")).toBe("❓");
+			expect(getCtrfEmojiHelper.fn("invalid")).toBe("❓");
+		});
+
+		it("should return default emoji for non-string input", () => {
+			expect(getCtrfEmojiHelper.fn(null)).toBe("❓");
+			expect(getCtrfEmojiHelper.fn(undefined)).toBe("❓");
+			expect(getCtrfEmojiHelper.fn(123)).toBe("❓");
+			expect(getCtrfEmojiHelper.fn({})).toBe("❓");
+			expect(getCtrfEmojiHelper.fn([])).toBe("❓");
+		});
+
+		it("should be categorized as CTRF helper", () => {
+			expect(getCtrfEmojiHelper.category).toBe("CTRF");
+			expect(getCtrfEmojiHelper.name).toBe("getCtrfEmoji");
+		});
+	});
+
 	describe("Helper metadata", () => {
 		it("should have correct helper names", () => {
 			expect(sortTestsByFlakyRateHelper.name).toBe("sortTestsByFlakyRate");
@@ -384,6 +644,10 @@ describe("CTRF Helpers", () => {
 				"formatDurationFromTimes",
 			);
 			expect(formatDurationHelper.name).toBe("formatDuration");
+			expect(formatTestMessageHelper.name).toBe("formatTestMessage");
+			expect(formatTestMessagePreCodeHelper.name).toBe("formatTestMessagePreCode");
+			expect(getCtrfEmojiHelper.name).toBe("getCtrfEmoji");
+			expect(limitFailedTestsHelper.name).toBe("limitFailedTests");
 		});
 
 		it("should have correct helper categories", () => {
@@ -392,11 +656,15 @@ describe("CTRF Helpers", () => {
 				filterPassedTestsHelper,
 				filterFailedTestsHelper,
 				filterOtherTestsHelper,
+				limitFailedTestsHelper,
 				countFlakyTestsHelper,
 				anyFlakyTestsHelper,
 				sortTestsByFailRateHelper,
 				formatDurationFromTimesHelper,
 				formatDurationHelper,
+				formatTestMessageHelper,
+				formatTestMessagePreCodeHelper,
+				getCtrfEmojiHelper,
 			];
 
 			helpers.forEach((helper) => {