text-guitar-chart 0.0.1

package/test/layoutChordStrings.test.js

@@ -0,0 +1,193 @@
+// @ts-check
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import layoutChordStrings from "../lib/layoutChordStrings.js";
+
+describe("layoutChordStrings", () => {
+  test("handles empty string list", () => {
+    const result = layoutChordStrings([], 3);
+    const expected = "";
+    assert.equal(result, expected);
+  });
+
+  test("handles single string", () => {
+    const strings = ["ABC\nDEF"];
+    const result = layoutChordStrings(strings, 1);
+    const expected = `ABC
+DEF`;
+    assert.equal(result, expected);
+  });
+
+  test("handles single string with multiple columns", () => {
+    const strings = ["ABC"];
+    const result = layoutChordStrings(strings, 3);
+    const expected = "ABC";
+    assert.equal(result, expected);
+  });
+
+  test("layouts two strings of equal size in one row", () => {
+    const strings = ["ABC\nDEF", "123\n456"];
+    const result = layoutChordStrings(strings, 2);
+    const expected = `ABC 123
+DEF 456`;
+    assert.equal(result, expected);
+  });
+
+  test("layouts two strings of different widths", () => {
+    const strings = ["A\nB", "12345\n67890"];
+    const result = layoutChordStrings(strings, 2);
+    const expected = `A     12345
+B     67890`;
+    assert.equal(result, expected);
+  });
+
+  test("layouts two strings of different heights", () => {
+    const strings = ["A\nB\nC", "12\n34"];
+    const result = layoutChordStrings(strings, 2);
+    const expected = `A  12
+B  34
+C`;
+    assert.equal(result, expected);
+  });
+
+  test("layouts strings into multiple rows", () => {
+    const strings = ["A", "B", "C", "D"];
+    const result = layoutChordStrings(strings, 2);
+    const expected = `A  B
+
+C  D`;
+    assert.equal(result, expected);
+  });
+
+  test("layouts strings into multiple rows with spacing 2", () => {
+    const strings = ["A", "B", "C", "D"];
+    const result = layoutChordStrings(strings, 2, 2);
+    const expected = `A   B
+
+
+C   D`;
+    assert.equal(result, expected);
+  });
+
+  test("layouts strings into multiple rows with spacing 3", () => {
+    const strings = ["A", "B", "C", "D"];
+    const result = layoutChordStrings(strings, 2, 3);
+    const expected = `A    B
+
+
+
+C    D`;
+    assert.equal(result, expected);
+  });
+
+  test("layouts strings into multiple rows with different sizes", () => {
+    const strings = ["ABC\nDEF", "12", "XY\nZ", "!"];
+    const result = layoutChordStrings(strings, 2);
+    const expected = `ABC 12
+DEF
+
+XY  !
+Z`;
+    assert.equal(result, expected);
+  });
+
+  test("handles three columns", () => {
+    const strings = ["A", "B", "C", "D", "E", "F"];
+    const result = layoutChordStrings(strings, 3);
+    const expected = `A  B  C
+
+D  E  F`;
+    assert.equal(result, expected);
+  });
+
+  test("layouts with incomplete last row", () => {
+    const strings = ["A\nB", "C\nD", "E\nF", "G\nH", "I\nJ"];
+    const result = layoutChordStrings(strings, 3);
+    const expected = `A  C  E
+B  D  F
+
+G  I
+H  J`;
+    assert.equal(result, expected);
+  });
+
+  test("pads strings to match the tallest string in their row", () => {
+    const strings = ["A", "B\nC\nD", "E"];
+    const result = layoutChordStrings(strings, 3);
+    const expected = `A  B  E
+   C
+   D`;
+    assert.equal(result, expected);
+  });
+
+  test("pads strings to match the widest string in their column", () => {
+    const strings = ["A", "LONGTEXT", "B", "X"];
+    const result = layoutChordStrings(strings, 2);
+    const expected = `A        LONGTEXT
+
+B        X`;
+    assert.equal(result, expected);
+  });
+
+  test("handles single character strings in grid", () => {
+    const strings = ["A", "B", "C", "D", "E", "F", "G", "H", "I"];
+    const result = layoutChordStrings(strings, 3);
+    const expected = `A  B  C
+
+D  E  F
+
+G  H  I`;
+    assert.equal(result, expected);
+  });
+
+  test("handles multiline strings with varying line lengths", () => {
+    const strings = [
+      "A\nBB\nCCC",
+      "1\n22\n333\n4444",
+      "X"
+    ];
+    const result = layoutChordStrings(strings, 2);
+    const expected = `A    1
+BB   22
+CCC  333
+     4444
+
+X`;
+    assert.equal(result, expected);
+  });
+
+  test("defaults to 3 columns when not specified", () => {
+    const strings = ["A", "B", "C", "D", "E", "F"];
+    const result = layoutChordStrings(strings);
+    const expected = `A  B  C
+
+D  E  F`;
+    assert.equal(result, expected);
+  });
+
+  test("handles single column layout", () => {
+    const strings = ["ABC", "DEF", "GHI"];
+    const result = layoutChordStrings(strings, 1);
+    const expected = `ABC
+
+DEF
+
+GHI`;
+    assert.equal(result, expected);
+  });
+
+  test("handles strings with trailing newlines", () => {
+    const strings = ["A\n", "B\n"];
+    const result = layoutChordStrings(strings, 2);
+    const expected = `A  B`;
+    assert.equal(result, expected);
+  });
+
+  test("handles empty strings in the array", () => {
+    const strings = ["", "B", ""];
+    const result = layoutChordStrings(strings, 3);
+    const expected = `B`;
+    assert.equal(result, expected);
+  });
+});

package/test/splitStringInRectangles.test.js

@@ -0,0 +1,98 @@
+// @ts-check
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import splitStringInRectangles from "../lib/splitStringInRectangles.js";
+
+describe("splitStringInRectangles", () => {
+  test("should return empty array for empty string", () => {
+    const result = splitStringInRectangles("");
+    assert.deepEqual(result, []);
+  });
+
+  test("should return empty array for string with only spaces", () => {
+    const result = splitStringInRectangles("   \n   \n   ");
+    assert.deepEqual(result, []);
+  });
+
+  test("should extract single rectangle", () => {
+    const input = "ABC\nDEF\nGHI";
+    const result = splitStringInRectangles(input);
+    assert.deepEqual(result, ["ABC\nDEF\nGHI"]);
+  });
+
+  test("should extract two rectangles separated horizontally", () => {
+    const input = "ABC   XYZ\nDEF   UVW";
+    const result = splitStringInRectangles(input);
+    assert.equal(result.length, 2);
+    assert.ok(result.includes("ABC\nDEF"));
+    assert.ok(result.includes("XYZ\nUVW"));
+  });
+
+  test("should extract two rectangles separated vertically", () => {
+    const input = "ABC\nDEF\n\nXYZ\nUVW";
+    const result = splitStringInRectangles(input);
+    assert.equal(result.length, 2);
+    assert.ok(result.includes("ABC\nDEF"));
+    assert.ok(result.includes("XYZ\nUVW"));
+  });
+
+  test("should treat diagonally adjacent characters as one rectangle", () => {
+    const input = "A  \n B \n  C";
+    const result = splitStringInRectangles(input);
+    assert.equal(result.length, 1);
+    assert.equal(result[0], "A  \n B \n  C");
+  });
+
+  test("should extract multiple rectangles in complex layout", () => {
+    const input = "AA    BB\nAA    BB\n\n  CC\n  CC";
+    const result = splitStringInRectangles(input);
+    assert.equal(result.length, 3);
+    assert.ok(result.includes("AA\nAA"));
+    assert.ok(result.includes("BB\nBB"));
+    assert.ok(result.includes("CC\nCC"));
+  });
+
+  test("should handle single character", () => {
+    const input = "X";
+    const result = splitStringInRectangles(input);
+    assert.deepEqual(result, ["X"]);
+  });
+
+  test("should handle single line with multiple rectangles", () => {
+    const input = "ABC   DEF   GHI";
+    const result = splitStringInRectangles(input);
+    assert.equal(result.length, 3);
+    assert.ok(result.includes("ABC"));
+    assert.ok(result.includes("DEF"));
+    assert.ok(result.includes("GHI"));
+  });
+
+  test("should extract rectangles with varying heights", () => {
+    const input = "A\nA\nA\n\nBB\nBB";
+    const result = splitStringInRectangles(input);
+    assert.equal(result.length, 2);
+    assert.ok(result.includes("A\nA\nA"));
+    assert.ok(result.includes("BB\nBB"));
+  });
+
+  test("should handle rectangle at different positions", () => {
+    const input = "    X\n    X\n    X";
+    const result = splitStringInRectangles(input);
+    assert.equal(result.length, 1);
+    assert.equal(result[0], "X\nX\nX");
+  });
+
+  test("should handle complex diagonal connections", () => {
+    const input = "A   E\n B D \n  C  ";
+    const result = splitStringInRectangles(input);
+    assert.equal(result.length, 1);
+  });
+
+  test("should extract non-rectangular shapes as bounding rectangles", () => {
+    const input = "A \n A";
+    const result = splitStringInRectangles(input);
+    assert.equal(result.length, 1);
+    assert.equal(result[0], "A \n A");
+  });
+})