@k-l-lambda/lilylet 0.1.63 → 0.1.65

package/lib/source/lilylet/types.d.ts

@@ -0,0 +1,253 @@
+export declare enum Phonet {
+    c = "c",
+    d = "d",
+    e = "e",
+    f = "f",
+    g = "g",
+    a = "a",
+    b = "b"
+}
+export declare enum Accidental {
+    natural = "natural",
+    sharp = "sharp",
+    flat = "flat",
+    doubleSharp = "doubleSharp",
+    doubleFlat = "doubleFlat"
+}
+export declare enum Clef {
+    treble = "treble",
+    bass = "bass",
+    alto = "alto"
+}
+export declare enum StemDirection {
+    up = "up",
+    down = "down",
+    auto = "auto"
+}
+export declare enum ArticulationType {
+    staccato = "staccato",
+    staccatissimo = "staccatissimo",
+    tenuto = "tenuto",
+    marcato = "marcato",
+    accent = "accent",
+    portato = "portato"
+}
+export declare enum OrnamentType {
+    trill = "trill",
+    turn = "turn",
+    mordent = "mordent",
+    prall = "prall",
+    fermata = "fermata",
+    shortFermata = "shortFermata",
+    arpeggio = "arpeggio"
+}
+export declare enum DynamicType {
+    ppp = "ppp",
+    pp = "pp",
+    p = "p",
+    mp = "mp",
+    mf = "mf",
+    f = "f",
+    ff = "ff",
+    fff = "fff",
+    sfz = "sfz",
+    rfz = "rfz",
+    fp = "fp"
+}
+export declare enum HairpinType {
+    crescendoStart = "crescendoStart",
+    crescendoEnd = "crescendoEnd",
+    diminuendoStart = "diminuendoStart",
+    diminuendoEnd = "diminuendoEnd"
+}
+export declare enum PedalType {
+    sustainOn = "sustainOn",
+    sustainOff = "sustainOff",
+    sostenutoOn = "sostenutoOn",
+    sostenutoOff = "sostenutoOff",
+    unaCordaOn = "unaCordaOn",
+    unaCordaOff = "unaCordaOff"
+}
+export declare enum BarlineType {
+    single = "|",
+    double = "||",
+    end = "|.",
+    repeatStart = ".|:",
+    repeatEnd = ":|.",
+    repeatBoth = ":..:"
+}
+export declare enum NavigationMarkType {
+    coda = "coda",
+    segno = "segno"
+}
+export interface Fraction {
+    numerator: number;
+    denominator: number;
+}
+export interface TimeSig extends Fraction {
+    symbol?: 'common' | 'cut';
+}
+export interface Pitch {
+    phonet: Phonet;
+    accidental?: Accidental;
+    octave: number;
+    courtesy?: boolean;
+}
+export interface Duration {
+    division: number;
+    dots: number;
+    tuplet?: Fraction;
+}
+export declare enum Placement {
+    above = "above",
+    below = "below"
+}
+export interface Articulation {
+    markType: 'articulation';
+    type: ArticulationType;
+    placement?: Placement;
+}
+export interface Ornament {
+    markType: 'ornament';
+    type: OrnamentType;
+}
+export interface Dynamic {
+    markType: 'dynamic';
+    type: DynamicType;
+}
+export interface Hairpin {
+    markType: 'hairpin';
+    type: HairpinType;
+}
+export interface Tie {
+    markType: 'tie';
+    start: boolean;
+}
+export interface Slur {
+    markType: 'slur';
+    start: boolean;
+}
+export interface Beam {
+    markType: 'beam';
+    start: boolean;
+}
+export interface Pedal {
+    markType: 'pedal';
+    type: PedalType;
+}
+export interface Fingering {
+    markType: 'fingering';
+    finger: number;
+    placement?: Placement;
+}
+export interface NavigationMark {
+    markType: 'navigation';
+    type: NavigationMarkType;
+}
+export interface MarkupMark {
+    markType: 'markup';
+    content: string;
+    placement?: Placement;
+}
+export type Mark = Articulation | Ornament | Dynamic | Hairpin | Tie | Slur | Beam | Pedal | Fingering | NavigationMark | MarkupMark;
+export interface KeySignature {
+    pitch: Phonet;
+    accidental?: Accidental;
+    mode: 'major' | 'minor';
+}
+export interface Tempo {
+    text?: string;
+    beat?: Duration;
+    bpm?: number;
+}
+export interface NoteEvent {
+    type: 'note';
+    pitches: Pitch[];
+    duration: Duration;
+    marks?: Mark[];
+    grace?: boolean;
+    tremolo?: number;
+    staff?: number;
+    stemDirection?: StemDirection;
+}
+export interface RestEvent {
+    type: 'rest';
+    duration: Duration;
+    invisible?: boolean;
+    fullMeasure?: boolean;
+    pitch?: Pitch;
+}
+export interface ContextChange {
+    type: 'context';
+    key?: KeySignature;
+    time?: Fraction;
+    partial?: Duration;
+    clef?: Clef;
+    ottava?: number;
+    stemDirection?: StemDirection;
+    tempo?: Tempo;
+    staff?: number;
+}
+export interface TremoloEvent {
+    type: 'tremolo';
+    pitchA: Pitch[];
+    pitchB: Pitch[];
+    count: number;
+    division: number;
+}
+export interface TupletEvent {
+    type: 'tuplet';
+    ratio: Fraction;
+    events: (NoteEvent | RestEvent | ContextChange)[];
+}
+export interface TimesEvent {
+    type: 'times';
+    ratio: Fraction;
+    events: (NoteEvent | RestEvent | ContextChange)[];
+}
+export interface PitchResetEvent {
+    type: 'pitchReset';
+}
+export interface BarlineEvent {
+    type: 'barline';
+    style: string;
+}
+export interface HarmonyEvent {
+    type: 'harmony';
+    text: string;
+}
+export interface MarkupEvent {
+    type: 'markup';
+    content: string;
+    placement?: Placement;
+}
+export type Event = NoteEvent | RestEvent | ContextChange | TremoloEvent | TupletEvent | TimesEvent | PitchResetEvent | BarlineEvent | HarmonyEvent | MarkupEvent;
+export interface Voice {
+    staff: number;
+    events: Event[];
+}
+export interface Metadata {
+    title?: string;
+    subtitle?: string;
+    composer?: string;
+    arranger?: string;
+    lyricist?: string;
+    opus?: string;
+    instrument?: string;
+    genre?: string;
+    autoBeam?: 'auto' | 'on' | 'off';
+}
+export interface Part {
+    name?: string;
+    voices: Voice[];
+}
+export interface Measure {
+    key?: KeySignature;
+    timeSig?: TimeSig;
+    parts: Part[];
+    partial?: boolean;
+}
+export interface LilyletDoc {
+    metadata?: Metadata;
+    measures: Measure[];
+}

package/lib/source/lilylet/types.js

@@ -0,0 +1,100 @@
+// === Enums ===
+export var Phonet;
+(function (Phonet) {
+    Phonet["c"] = "c";
+    Phonet["d"] = "d";
+    Phonet["e"] = "e";
+    Phonet["f"] = "f";
+    Phonet["g"] = "g";
+    Phonet["a"] = "a";
+    Phonet["b"] = "b";
+})(Phonet || (Phonet = {}));
+export var Accidental;
+(function (Accidental) {
+    Accidental["natural"] = "natural";
+    Accidental["sharp"] = "sharp";
+    Accidental["flat"] = "flat";
+    Accidental["doubleSharp"] = "doubleSharp";
+    Accidental["doubleFlat"] = "doubleFlat";
+})(Accidental || (Accidental = {}));
+export var Clef;
+(function (Clef) {
+    Clef["treble"] = "treble";
+    Clef["bass"] = "bass";
+    Clef["alto"] = "alto";
+})(Clef || (Clef = {}));
+export var StemDirection;
+(function (StemDirection) {
+    StemDirection["up"] = "up";
+    StemDirection["down"] = "down";
+    StemDirection["auto"] = "auto";
+})(StemDirection || (StemDirection = {}));
+export var ArticulationType;
+(function (ArticulationType) {
+    ArticulationType["staccato"] = "staccato";
+    ArticulationType["staccatissimo"] = "staccatissimo";
+    ArticulationType["tenuto"] = "tenuto";
+    ArticulationType["marcato"] = "marcato";
+    ArticulationType["accent"] = "accent";
+    ArticulationType["portato"] = "portato";
+})(ArticulationType || (ArticulationType = {}));
+export var OrnamentType;
+(function (OrnamentType) {
+    OrnamentType["trill"] = "trill";
+    OrnamentType["turn"] = "turn";
+    OrnamentType["mordent"] = "mordent";
+    OrnamentType["prall"] = "prall";
+    OrnamentType["fermata"] = "fermata";
+    OrnamentType["shortFermata"] = "shortFermata";
+    OrnamentType["arpeggio"] = "arpeggio";
+})(OrnamentType || (OrnamentType = {}));
+export var DynamicType;
+(function (DynamicType) {
+    DynamicType["ppp"] = "ppp";
+    DynamicType["pp"] = "pp";
+    DynamicType["p"] = "p";
+    DynamicType["mp"] = "mp";
+    DynamicType["mf"] = "mf";
+    DynamicType["f"] = "f";
+    DynamicType["ff"] = "ff";
+    DynamicType["fff"] = "fff";
+    DynamicType["sfz"] = "sfz";
+    DynamicType["rfz"] = "rfz";
+    DynamicType["fp"] = "fp";
+})(DynamicType || (DynamicType = {}));
+export var HairpinType;
+(function (HairpinType) {
+    HairpinType["crescendoStart"] = "crescendoStart";
+    HairpinType["crescendoEnd"] = "crescendoEnd";
+    HairpinType["diminuendoStart"] = "diminuendoStart";
+    HairpinType["diminuendoEnd"] = "diminuendoEnd";
+})(HairpinType || (HairpinType = {}));
+export var PedalType;
+(function (PedalType) {
+    PedalType["sustainOn"] = "sustainOn";
+    PedalType["sustainOff"] = "sustainOff";
+    PedalType["sostenutoOn"] = "sostenutoOn";
+    PedalType["sostenutoOff"] = "sostenutoOff";
+    PedalType["unaCordaOn"] = "unaCordaOn";
+    PedalType["unaCordaOff"] = "unaCordaOff";
+})(PedalType || (PedalType = {}));
+export var BarlineType;
+(function (BarlineType) {
+    BarlineType["single"] = "|";
+    BarlineType["double"] = "||";
+    BarlineType["end"] = "|.";
+    BarlineType["repeatStart"] = ".|:";
+    BarlineType["repeatEnd"] = ":|.";
+    BarlineType["repeatBoth"] = ":..:";
+})(BarlineType || (BarlineType = {}));
+export var NavigationMarkType;
+(function (NavigationMarkType) {
+    NavigationMarkType["coda"] = "coda";
+    NavigationMarkType["segno"] = "segno";
+})(NavigationMarkType || (NavigationMarkType = {}));
+// === Placement Direction ===
+export var Placement;
+(function (Placement) {
+    Placement["above"] = "above";
+    Placement["below"] = "below";
+})(Placement || (Placement = {}));

package/lib/tests/abc-abcjs-parse.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parse all tests/assets/abc/*.abc files with abcjs and report:
+ *  - warnings / parse errors from abcjs
+ *  - note / rest / bar counts
+ * This acts as a ground-truth reference: files abcjs parses cleanly are
+ * valid ABC; failures indicate either invalid ABC or abcjs limitations.
+ */
+export {};

package/lib/tests/abc-abcjs-parse.js

@@ -0,0 +1,90 @@
+/**
+ * Parse all tests/assets/abc/*.abc files with abcjs and report:
+ *  - warnings / parse errors from abcjs
+ *  - note / rest / bar counts
+ * This acts as a ground-truth reference: files abcjs parses cleanly are
+ * valid ABC; failures indicate either invalid ABC or abcjs limitations.
+ */
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const abcjs = require("abcjs");
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ABC_DIR = path.join(__dirname, "assets/abc");
+function countElements(tune) {
+    const stats = [];
+    for (const line of tune.lines) {
+        if (!line.staff)
+            continue;
+        for (const staff of line.staff) {
+            for (let vi = 0; vi < staff.voices.length; vi++) {
+                if (!stats[vi])
+                    stats[vi] = { notes: 0, rests: 0, bars: 0 };
+                for (const el of staff.voices[vi]) {
+                    if (el.el_type === "note") {
+                        if (el.rest)
+                            stats[vi].rests++;
+                        else
+                            stats[vi].notes++;
+                    }
+                    else if (el.el_type === "bar") {
+                        stats[vi].bars++;
+                    }
+                }
+            }
+        }
+    }
+    return stats;
+}
+const files = fs.readdirSync(ABC_DIR)
+    .filter(f => f.endsWith(".abc"))
+    .sort();
+console.log(`Parsing ${files.length} ABC files with abcjs\n`);
+console.log("=".repeat(60));
+let pass = 0;
+let warn = 0;
+const results = [];
+for (const file of files) {
+    const content = fs.readFileSync(path.join(ABC_DIR, file), "utf-8");
+    let tunes;
+    try {
+        tunes = abcjs.parseOnly(content);
+    }
+    catch (e) {
+        console.log(`CRASH ${file}`);
+        // known abcjs bug: cross-bar slur continuation in inline multi-voice format
+        console.log(`      ${e.message.split("\n")[0]}`);
+        continue;
+    }
+    const tune = tunes[0];
+    const voices = countElements(tune);
+    const totalNotes = voices.reduce((s, v) => s + v.notes, 0);
+    const totalRests = voices.reduce((s, v) => s + v.rests, 0);
+    const totalBars = voices.reduce((s, v) => s + v.bars, 0);
+    const warnings = tune.warnings;
+    results.push({ file, warnings, voices, totalNotes, totalRests, totalBars });
+    const tag = warnings ? "WARN" : "OK  ";
+    if (warnings)
+        warn++;
+    else
+        pass++;
+    console.log(`${tag}  ${file}`);
+    console.log(`      notes=${totalNotes}  rests=${totalRests}  bars=${totalBars}  voices=${voices.length}`);
+    if (warnings) {
+        for (const w of warnings) {
+            console.log(`      ⚠  ${w}`);
+        }
+    }
+}
+console.log("\n" + "=".repeat(60));
+console.log(`Results: ${pass} clean, ${warn} with warnings, out of ${files.length} files`);
+// Summary: files that abcjs WARNS on — these are the ones to fix in lilylet
+if (warn > 0) {
+    console.log("\nFiles with abcjs warnings:");
+    for (const r of results) {
+        if (r.warnings)
+            console.log(`  ${r.file}`);
+    }
+}

package/lib/tests/abc-abcjs-svg.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/abc-abcjs-svg.js

@@ -0,0 +1,143 @@
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { DOMImplementation, XMLSerializer } from "@xmldom/xmldom";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Setup DOM mock for abcjs (browser DOM required)
+const domImpl = new DOMImplementation();
+const doc = domImpl.createDocument("http://www.w3.org/1999/xhtml", "html", null);
+const body = doc.createElement("body");
+(doc.documentElement || doc).appendChild(body);
+const NodeProto = Object.getPrototypeOf(doc.createElement("span"));
+function patchEl(el) {
+    if (!el || el._patched)
+        return el;
+    el._patched = true;
+    if (!el.style)
+        el.style = {};
+    el.addEventListener = () => { };
+    el.removeEventListener = () => { };
+    el.getBBox = () => ({ width: 8, height: 12, x: 0, y: 0 });
+    const origAC = el.appendChild.bind(el);
+    el.appendChild = (child) => { patchEl(child); return origAC(child); };
+    const origIB = el.insertBefore.bind(el);
+    el.insertBefore = (child, ref) => { patchEl(child); return origIB(child, ref); };
+    return el;
+}
+const origCE = doc.createElement.bind(doc);
+const origCENS = doc.createElementNS.bind(doc);
+doc.createElement = (tag) => patchEl(origCE(tag));
+doc.createElementNS = (ns, tag) => patchEl(origCENS(ns, tag));
+if (!Object.getOwnPropertyDescriptor(NodeProto, "children")) {
+    Object.defineProperty(NodeProto, "children", {
+        get() {
+            const a = [];
+            let c = this.firstChild;
+            while (c) {
+                if (c.nodeType === 1)
+                    a.push(c);
+                c = c.nextSibling;
+            }
+            return a;
+        },
+        configurable: true,
+    });
+}
+if (!Object.getOwnPropertyDescriptor(NodeProto, "parentElement")) {
+    Object.defineProperty(NodeProto, "parentElement", {
+        get() { return (this.parentNode?.nodeType === 1) ? this.parentNode : null; },
+        configurable: true,
+    });
+}
+if (!Object.getOwnPropertyDescriptor(NodeProto, "textContent")) {
+    Object.defineProperty(NodeProto, "textContent", {
+        get() { return this.nodeValue || ""; },
+        set(v) {
+            while (this.firstChild)
+                this.removeChild(this.firstChild);
+            this.appendChild(doc.createTextNode(v));
+        },
+        configurable: true,
+    });
+}
+doc.querySelector = (sel) => sel === "body" ? body : null;
+doc.querySelectorAll = () => [];
+global.document = doc;
+global.window = { addEventListener: () => { } };
+// Now import abcjs (after DOM is set up)
+const abcjsMod = await import("abcjs");
+const abcjs = abcjsMod.default ?? abcjsMod;
+const ABC_DIR = path.join(__dirname, "assets/abc");
+const OUT_DIR = path.join(__dirname, "output/from-abc-svg");
+const LOG_FILE = path.join(__dirname, "output/abc-abcjs-svg.log");
+fs.mkdirSync(OUT_DIR, { recursive: true });
+const abcFiles = fs.readdirSync(ABC_DIR).filter(f => f.endsWith(".abc")).sort();
+const serializer = new XMLSerializer();
+const logLines = [];
+let passCount = 0;
+let skipCount = 0;
+for (const fname of abcFiles) {
+    const abcPath = path.join(ABC_DIR, fname);
+    const abcContent = fs.readFileSync(abcPath, "utf-8");
+    const baseName = fname.replace(/\.abc$/, "");
+    const svgPath = path.join(OUT_DIR, baseName + ".svg");
+    try {
+        // Create a fresh div container for each file
+        const div = doc.createElement("div");
+        patchEl(div);
+        abcjs.renderAbc(div, abcContent, {});
+        // Collect all non-empty SVGs (abcjs may produce one per tune + empty placeholders)
+        const svgs = [];
+        collectSvgs(div, svgs);
+        const nonEmpty = svgs.filter(s => s.childNodes?.length > 0);
+        if (nonEmpty.length === 0) {
+            throw new Error("No non-empty SVG element found in output");
+        }
+        const svgStr = nonEmpty.map(s => serializer.serializeToString(s)).join("\n");
+        fs.writeFileSync(svgPath, svgStr, "utf-8");
+        console.log(`PASS  ${fname}`);
+        passCount++;
+    }
+    catch (err) {
+        const msg = err?.message || String(err);
+        console.error(`SKIP  ${fname}  — ${msg}`);
+        logLines.push(`${fname}: ${msg}`);
+        skipCount++;
+    }
+}
+fs.writeFileSync(LOG_FILE, logLines.join("\n") + (logLines.length ? "\n" : ""), "utf-8");
+console.log(`\nResults: ${passCount} pass, ${skipCount} skip out of ${abcFiles.length}`);
+if (logLines.length) {
+    console.log(`Error log: ${LOG_FILE}`);
+}
+function findLastNonEmptySvg(el) {
+    const svgs = [];
+    collectSvgs(el, svgs);
+    // Return the last SVG that has children
+    for (let i = svgs.length - 1; i >= 0; i--) {
+        if (svgs[i].childNodes?.length > 0)
+            return svgs[i];
+    }
+    return svgs[svgs.length - 1] ?? null;
+}
+function collectSvgs(el, out) {
+    if (el.tagName === "svg" || el.localName === "svg")
+        out.push(el);
+    let c = el.firstChild;
+    while (c) {
+        collectSvgs(c, out);
+        c = c.nextSibling;
+    }
+}
+function findFirstSvg(el) {
+    if (el.tagName === "svg" || el.localName === "svg")
+        return el;
+    let c = el.firstChild;
+    while (c) {
+        const found = findFirstSvg(c);
+        if (found)
+            return found;
+        c = c.nextSibling;
+    }
+    return null;
+}

package/lib/tests/abc-decoder.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/abc-decoder.js

@@ -0,0 +1,67 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { abcDecoder, parseCode } from "../source/lilylet/index.js";
+import { serializeLilyletDoc } from "../source/lilylet/serializer.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ABC_DIR = path.join(__dirname, "assets/abc");
+const OUTPUT_DIR = path.join(__dirname, "output/from-abc");
+const main = () => {
+    const files = fs.readdirSync(ABC_DIR).filter(f => f.endsWith(".abc")).sort();
+    console.log(`Found ${files.length} ABC files\n`);
+    // Ensure output directory exists
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+    let pass = 0;
+    let fail = 0;
+    const errors = [];
+    for (const file of files) {
+        const filePath = path.join(ABC_DIR, file);
+        const baseName = path.basename(file, ".abc");
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const doc = abcDecoder.decode(content);
+            if (!doc.measures || doc.measures.length === 0) {
+                throw new Error("No measures produced");
+            }
+            // Write JSON output
+            const jsonPath = path.join(OUTPUT_DIR, `${baseName}.json`);
+            fs.writeFileSync(jsonPath, JSON.stringify(doc, null, 2));
+            // Write .lyl output
+            const lylContent = serializeLilyletDoc(doc);
+            const lylPath = path.join(OUTPUT_DIR, `${baseName}.lyl`);
+            fs.writeFileSync(lylPath, lylContent);
+            const measureCount = doc.measures.length;
+            const noteCount = doc.measures.reduce((sum, m) => sum + m.parts.reduce((psum, p) => psum + p.voices.reduce((vsum, v) => vsum + v.events.filter(e => e.type === "note").length, 0), 0), 0);
+            // Verify .lyl can be parsed back
+            const reparsed = parseCode(lylContent);
+            const reparsedMeasures = reparsed.measures.length;
+            console.log(`  ${file}`);
+            console.log(`    Measures: ${measureCount}, Notes: ${noteCount}, Reparsed: ${reparsedMeasures} measures`);
+            console.log(`    -> ${baseName}.json, ${baseName}.lyl`);
+            pass++;
+        }
+        catch (err) {
+            fail++;
+            errors.push({ file, error: err.message || String(err) });
+            console.log(`FAIL: ${file}`);
+            console.log(`  ${err.message?.substring(0, 200)}\n`);
+        }
+    }
+    console.log(`\n${"=".repeat(60)}`);
+    console.log(`Results: ${pass} pass, ${fail} fail out of ${files.length}`);
+    console.log(`Output: ${OUTPUT_DIR}`);
+    if (fail > 0) {
+        const errorTypes = new Map();
+        for (const e of errors) {
+            const key = e.error.substring(0, 80);
+            errorTypes.set(key, (errorTypes.get(key) || 0) + 1);
+        }
+        console.log(`\nError distribution:`);
+        const sorted = Array.from(errorTypes.entries()).sort((a, b) => b[1] - a[1]);
+        for (const [msg, count] of sorted.slice(0, 15)) {
+            console.log(`  ${count}x: ${msg}`);
+        }
+    }
+    process.exit(fail > 0 ? 1 : 0);
+};
+main();

package/lib/tests/abc-mei-compare.d.ts

@@ -0,0 +1 @@
+export {};