chore: implement pitch helper functions edge-cases and tests

Author: vanshika2720

js/utils/__tests__/musicutils.test.js

@@ -23,6 +23,7 @@ global._ = jest.fn(str => str);
 global.window = {
     btoa: jest.fn(str => Buffer.from(str, "utf8").toString("base64"))
 };
+global.INVALIDPITCH = "Not a valid pitch name";
 
 const {
     scaleDegreeToPitchMapping,
@@ -97,14 +98,15 @@ const {
     numberToPitchSharp,
     getNumber,
     getNoteFromInterval,
-    numberToPitch,
-    GetNotesForInterval,
-    base64Encode,
-    NOTESFLAT,
     NOTESSHARP,
     MUSICALMODES,
     getStepSizeUp,
-    getStepSizeDown
+    getStepSizeDown,
+    INVALIDPITCH,
+    numberToPitch,
+    GetNotesForInterval,
+    base64Encode,
+    NOTESFLAT
 } = require("../musicutils");
 
 describe("musicutils", () => {
@@ -2241,39 +2243,6 @@ describe("getPitchInfo", () => {
     });
 });
 
-describe("_calculate_pitch_number", () => {
-    let activity, tur;
-
-    beforeEach(() => {
-        activity = {
-            errorMsg: jest.fn()
-        };
-
-        tur = {
-            singer: {
-                lastNotePlayed: null,
-                inNoteBlock: {},
-                notePitches: {},
-                noteOctaves: {},
-                keySignature: "C major",
-                movable: false,
-                pitchNumberOffset: 0
-            }
-        };
-    });
-
-    it("calculates pitch number for a standard note string", () => {
-        const val = _calculate_pitch_number(activity, "C4", tur);
-        expect(typeof val).toBe("number");
-    });
-
-    it("calculates pitch number relative to another note", () => {
-        const valC4 = _calculate_pitch_number(activity, "C4", tur);
-        const valC5 = _calculate_pitch_number(activity, "C5", tur);
-        expect(valC5).toBeGreaterThan(valC4);
-    });
-});
-
 describe("NOTESFLAT", () => {
     it("should contain 12 chromatic notes", () => {
         expect(NOTESFLAT.length).toBe(12);
@@ -2404,3 +2373,96 @@ describe("getStepSizeUp", () => {
         expect(result).toBe(0);
     });
 });
+
+describe("_calculate_pitch_number", () => {
+    it("should return the correct pitch number for common notes", () => {
+        expect(_calculate_pitch_number("C", 4)).toBe(60);
+        expect(_calculate_pitch_number("A", 4)).toBe(69);
+        expect(_calculate_pitch_number("C", 5)).toBe(72);
+    });
+
+    it("should maintain enharmonic consistency", () => {
+        expect(_calculate_pitch_number("C#", 4)).toBe(61);
+        expect(_calculate_pitch_number("Db", 4)).toBe(61);
+    });
+
+    it("should return INVALIDPITCH for invalid input", () => {
+        expect(_calculate_pitch_number("Invalid", 4)).toBe("Not a valid pitch name");
+        expect(_calculate_pitch_number(null, 4)).toBe("Not a valid pitch name");
+    });
+});
+
+describe("getPitchInfo", () => {
+    it("should correctly parse string inputs", () => {
+        const info = getPitchInfo("C#5");
+        expect(info).toEqual({
+            name: "C#",
+            octave: 5,
+            pitchNumber: 73
+        });
+
+        const info10 = getPitchInfo("C10");
+        expect(info10).toEqual({
+            name: "C",
+            octave: 10,
+            pitchNumber: 132
+        });
+
+        // F𝄪5 (F double-sharp) → same pitch as G5 = (5+1)*12 + 7 = 79
+        const infoDoubleSharp = getPitchInfo("F\u{1D12A}5");
+        expect(infoDoubleSharp.pitchNumber).toBe(79);
+        expect(infoDoubleSharp.octave).toBe(5);
+
+        // Bb𝄫5 (B double-flat) → same pitch as A5 = (5+1)*12 + 9 = 81
+        const infoDoubleFlat = getPitchInfo("B\u{1D12B}5");
+        expect(infoDoubleFlat.pitchNumber).toBe(81);
+        expect(infoDoubleFlat.octave).toBe(5);
+
+        // Cx4 (C textual double-sharp) → same pitch as D4 = (4+1)*12 + 2 = 62
+        const infoX = getPitchInfo("Cx4");
+        expect(infoX.pitchNumber).toBe(62);
+        expect(infoX.octave).toBe(4);
+    });
+
+    it("should correctly parse numeric inputs", () => {
+        const info = getPitchInfo(60);
+        expect(info).toEqual({
+            name: "C",
+            octave: 4,
+            pitchNumber: 60
+        });
+    });
+
+    it("should handle invalid inputs", () => {
+        const info = getPitchInfo("InvalidNote");
+        expect(info).toEqual({
+            name: null,
+            octave: null,
+            pitchNumber: "Not a valid pitch name"
+        });
+    });
+
+    it("should handle accidental offset accumulation edge cases", () => {
+        // Gb-1: G(7) + flat(-1) = index 6 (G♭). (-1+1)*12 + 6 = 6
+        const infoGbNeg1 = getPitchInfo("Gb-1");
+        expect(infoGbNeg1.pitchNumber).toBe(6);
+        expect(infoGbNeg1.octave).toBe(-1);
+
+        // D𝄫-1 enharmonic of C at oct -1: (-1+1)*12 + 2 + (-2) = 0
+        // Note: D𝄫-2 (oct=-2) gives -12; octave must be -1 to reach pitch 0.
+        const infoDdblFlatNeg1 = getPitchInfo("D\u{1D12B}-1");
+        expect(infoDdblFlatNeg1.pitchNumber).toBe(0);
+        expect(infoDdblFlatNeg1.octave).toBe(-1);
+
+        // E##4: E(4) + ##(+2) → index 6 (F#). (4+1)*12 + 4 + 2 = 66
+        // Spelled with two ASCII '#' chars; each contributes +1 via ACCIDENTAL_SEMITONE_MAP.
+        const infoEDblSharp4 = getPitchInfo("E##4");
+        expect(infoEDblSharp4.pitchNumber).toBe(66);
+        expect(infoEDblSharp4.octave).toBe(4);
+
+        // Fx10: F(5) + x(+2) → index 7 (G). (10+1)*12 + 5 + 2 = 139
+        const infoFx10 = getPitchInfo("Fx10");
+        expect(infoFx10.pitchNumber).toBe(139);
+        expect(infoFx10.octave).toBe(10);
+    });
+});

js/utils/musicutils.js

@@ -4745,50 +4745,115 @@ function getNote(
 }
 
 /**
- * Calculate the pitch number based on the activity, pitch value, and tur parameters.
- * @function
- * @param {Object} activity - The activity object.
- * @param {string|number} np - The pitch value (note name or frequency in Hertz).
- * @param {Object} tur - The tur parameters containing singer information.
- * @returns {number} The calculated pitch number.
+ * Maps accidental characters to their semitone offsets.
+ * Named distinctly to avoid collision with the ACCIDENTAL_MAP in abc.js
+ * (which maps accidentals to ABC notation strings, not semitone offsets).
+ * @constant {Object.<string, number>}
  */
-const _calculate_pitch_number = (activity, np, tur) => {
-    let obj;
-    if (tur.singer.lastNotePlayed !== null) {
-        if (typeof np === "string") {
-            obj = noteToObj(np);
-        } else {
-            // Hertz
-            obj = frequencyToPitch(np);
+const ACCIDENTAL_SEMITONE_MAP = {
+    "#": 1,
+    "♯": 1,
+    "b": -1,
+    "♭": -1,
+    "x": 2, // double-sharp (textual)
+    "𝄪": 2, // double-sharp (Unicode)
+    "𝄫": -2 // double-flat (Unicode)
+};
+
+/**
+ * Parses a pitch string into its note name and octave components.
+ * Handles single and double accidentals (#, b, ♯, ♭, x, 𝄪, 𝄫).
+ * @param {string} str - The pitch string (e.g. "C4", "A#10", "F𝄪5").
+ * @returns {Array} An array containing [normalizedNoteName, octave].
+ */
+function _parse_pitch_string(str) {
+    const match = str.match(/^([A-Ga-g])([#b♭♯𝄪𝄫x]*)(\-?\d+)$/);
+    if (match) {
+        const baseLetter = match[1].toUpperCase();
+        const accidentalStr = match[2];
+        const octave = parseInt(match[3], 10);
+
+        if (!accidentalStr) {
+            // No accidentals; return as-is
+            return [baseLetter, octave];
         }
-    } else if (
-        tur.singer.inNoteBlock in tur.singer.notePitches &&
-        tur.singer.notePitches[last(tur.singer.inNoteBlock)].length > 0
-    ) {
-        obj = getNote(
-            tur.singer.notePitches[last(tur.singer.inNoteBlock)][0],
-            tur.singer.noteOctaves[last(tur.singer.inNoteBlock)][0],
-            0,
-            tur.singer.keySignature,
-            tur.singer.movable,
-            null,
-            activity.errorMsg
+
+        // Sum up semitone offsets for all accidental characters.
+        // 𝄪 and 𝄫 are multi-byte but treated as single code points by spread.
+        const accidentalChars = [...accidentalStr];
+        const semitoneOffset = accidentalChars.reduce(
+            (sum, char) => sum + (ACCIDENTAL_SEMITONE_MAP[char] || 0),
+            0
         );
-    } else {
-        try {
-            if (typeof np === "string") {
-                obj = noteToObj(np);
-            } else {
-                // Hertz
-                obj = frequencyToPitch(np);
-            }
-        } catch (e) {
-            activity.errorMsg(INVALIDPITCH);
-            obj = ["G", 4];
+
+        // Build a normalized name using canonical SHARP/FLAT symbols.
+        let normalizedName;
+        if (semitoneOffset === 0) {
+            normalizedName = baseLetter;
+        } else if (semitoneOffset === 1) {
+            normalizedName = baseLetter + SHARP;
+        } else if (semitoneOffset === -1) {
+            normalizedName = baseLetter + FLAT;
+        } else if (semitoneOffset === 2) {
+            normalizedName = baseLetter + DOUBLESHARP;
+        } else if (semitoneOffset === -2) {
+            normalizedName = baseLetter + DOUBLEFLAT;
+        } else {
+            // For unusual combinations, keep semitone representation as extra sharps/flats
+            const sym = semitoneOffset > 0 ? SHARP : FLAT;
+            normalizedName = baseLetter + sym.repeat(Math.abs(semitoneOffset));
         }
+
+        return [normalizedName, octave];
+    }
+    // Fallback: no octave digit found – normalize accidentals and default octave to 4
+    return [str.replace("#", SHARP).replace("b", FLAT), 4];
+}
+
+/**
+ * Calculates a pitch number from a note name and octave.
+ * @param {string} noteName - The name of the note (e.g. "C", "C#").
+ * @param {number} octave - The octave number.
+ * @returns {number|string} The calculated pitch number or INVALIDPITCH if calculation fails.
+ */
+function _calculate_pitch_number(noteName, octave) {
+    if (typeof noteName !== "string") {
+        return INVALIDPITCH;
+    }
+
+    let name = noteName.replace("#", SHARP).replace("b", FLAT);
+
+    // Handle double accidentals (𝄪 / 𝄫) by computing offset directly from
+    // the base note letter, since they won't appear in NOTESSHARP/NOTESFLAT.
+    if (name.includes(DOUBLESHARP) || name.includes(DOUBLEFLAT)) {
+        const offset = name.includes(DOUBLESHARP) ? 2 : -2;
+        const baseLetter = name.replace(DOUBLESHARP, "").replace(DOUBLEFLAT, "");
+        let baseIndex = NOTESSHARP.indexOf(baseLetter);
+        if (baseIndex === -1) baseIndex = NOTESFLAT.indexOf(baseLetter);
+        if (baseIndex === -1) return INVALIDPITCH;
+        const rawPitch = (parseInt(octave, 10) + 1) * 12 + baseIndex + offset;
+        return rawPitch;
+    }
+
+    if (EQUIVALENTSHARPS[name]) {
+        name = EQUIVALENTSHARPS[name];
+    } else if (EQUIVALENTFLATS[name]) {
+        name = EQUIVALENTFLATS[name];
+    } else if (EQUIVALENTNATURALS[name]) {
+        name = EQUIVALENTNATURALS[name];
+    }
+
+    let pitchIndex = NOTESSHARP.indexOf(name);
+    if (pitchIndex === -1) {
+        pitchIndex = NOTESFLAT.indexOf(name);
+    }
+
+    if (pitchIndex === -1) {
+        return INVALIDPITCH;
     }
-    return pitchToNumber(obj[0], obj[1], tur.singer.keySignature) - tur.singer.pitchNumberOffset;
-};
+
+    return (parseInt(octave, 10) + 1) * 12 + pitchIndex;
+}
 
 /**
  * Build the scale based on the given key signature.
@@ -6120,11 +6185,44 @@ const convertFactor = factor => {
  * @param {*} tur - The tur object.
  * @returns {*} The pitch information based on the specified type.
  */
-const getPitchInfo = (activity, type, currentNote, tur) => {
-    // A variety of conversions.
+/**
+ * Get pitch information based on the note or pitch provided.
+ * @function
+ * @param {string|number} noteOrPitch - The note name (e.g. "C4") or a numeric pitch index.
+ * @returns {Object|string} If called with one argument, returns { name, octave, pitchNumber }. Otherwise returns legacy values.
+ */
+const getPitchInfo = function (activity, type, currentNote, tur) {
+    if (arguments.length === 1) {
+        const noteOrPitch = activity;
+        let name, octave, pitchNumber;
+
+        if (typeof noteOrPitch === "number") {
+            pitchNumber = noteOrPitch;
+            octave = Math.floor(pitchNumber / 12) - 1;
+            name = NOTESSHARP[pitchNumber % 12];
+        } else if (typeof noteOrPitch === "string") {
+            [name, octave] = _parse_pitch_string(noteOrPitch);
+            pitchNumber = _calculate_pitch_number(name, octave);
+        } else {
+            return INVALIDPITCH;
+        }
+
+        if (pitchNumber === INVALIDPITCH) {
+            return { name: null, octave: null, pitchNumber: INVALIDPITCH };
+        }
+
+        return {
+            name: name.replace(SHARP, "#").replace(FLAT, "b"),
+            octave: parseInt(octave, 10),
+            pitchNumber: pitchNumber
+        };
+    }
+
+    // Legacy behavior for 4 arguments
     let pitch;
     let octave;
     let obj;
+    let cents;
     if (Number(currentNote)) {
         // If it is a frequency, convert it to a pitch/octave.
         obj = frequencyToPitch(currentNote);
@@ -6133,8 +6231,7 @@ const getPitchInfo = (activity, type, currentNote, tur) => {
         cents = obj[2];
     } else {
         // Turn the note into pitch and octave.
-        pitch = currentNote.substr(0, currentNote.length - 1);
-        octave = currentNote[currentNote.length - 1];
+        [pitch, octave] = _parse_pitch_string(currentNote);
     }
     // Remap double sharps/double flats.
     if (pitch.includes(DOUBLESHARP)) {
@@ -6173,7 +6270,7 @@ const getPitchInfo = (activity, type, currentNote, tur) => {
             case "solfege class":
                 if (type === "solfege class") {
                     // Remove sharps and flats.
-                    pitch = pitch.replace(SHARP).replace(FLAT);
+                    pitch = pitch.replace(SHARP, "").replace(FLAT, "");
                 }
                 if (tur.singer.movable === false) {
                     return SOLFEGECONVERSIONTABLE[pitch];
@@ -6205,7 +6302,7 @@ const getPitchInfo = (activity, type, currentNote, tur) => {
                     (octave - 4) * YSTAFFOCTAVEHEIGHT
                 );
             case "pitch number":
-                return _calculate_pitch_number(activity, pitch, tur);
+                return _calculate_pitch_number(pitch, octave);
             case "pitch in hertz":
                 // This function ignores cents.
                 return activity.logo.synth._getFrequency(