@k-l-lambda/lilylet 0.1.39 → 0.1.40

package/source/lilylet/lilypondEncoder.ts

@@ -149,6 +149,21 @@ const BARLINE_MAP: Record<string, string> = {
 };
 
 
+// === Helper Functions ===
+
+/**
+ * Generate a spacer rest that fills a measure based on time signature.
+ * Uses multiplication syntax: s{denominator}*{numerator}
+ * @param timeSig - Time signature { numerator, denominator }
+ * @returns LilyPond spacer rest string (e.g., "s4*3" for 3/4, "s8*6" for 6/8)
+ */
+const getSpacerRest = (timeSig?: { numerator: number; denominator: number }): string => {
+	if (!timeSig) return 's1';
+	const { numerator, denominator } = timeSig;
+	return `s${denominator}*${numerator}`;
+};
+
+
 // === Pitch Environment for Relative Mode ===
 
 interface PitchEnv {
@@ -571,9 +586,10 @@ const encodeBarlineEvent = (event: BarlineEvent): string => {
 
 /**
  * Encode a harmony event (chord symbol)
+ * Uses the lilylet extension: \chords "text" (parsed by modified lotus grammar)
  */
 const encodeHarmonyEvent = (event: HarmonyEvent): string => {
-	return `^\\markup { ${event.text} }`;
+	return `\\chords "${event.text}"`;
 };
 
 
@@ -692,33 +708,76 @@ const encodeMetadata = (metadata: Metadata): string => {
 
 /**
  * Encode a complete LilyletDoc to LilyPond format
+ *
+ * Structure:
+ * - Multiple parts → outer <<>>
+ * - Part with multiple staves → GrandStaff
+ * - Part with single staff → standalone Staff
  */
 export const encode = (doc: LilyletDoc, options: RenderOptions = {}): string => {
 	const opts = { ...DEFAULT_OPTIONS, ...options };
 
-	// Collect all voices across measures, grouped by staff
-	const staffVoices: Map<number, string[][]> = new Map();  // staff -> measure -> voice content
+	// Filter out trailing empty measures (measures with no musical content)
+	const hasMusicContent = (measure: Measure): boolean => {
+		for (const part of measure.parts) {
+			for (const voice of part.voices) {
+				for (const event of voice.events) {
+					if (event.type === 'note' || event.type === 'rest' || event.type === 'tuplet' || event.type === 'tremolo') {
+						return true;
+					}
+				}
+			}
+		}
+		return false;
+	};
+
+	// Trim trailing empty measures
+	let measureCount = doc.measures.length;
+	while (measureCount > 0 && !hasMusicContent(doc.measures[measureCount - 1])) {
+		measureCount--;
+	}
+	const measures = doc.measures.slice(0, measureCount);
+
+	// Determine number of parts from the document
+	const partCount = Math.max(...measures.map(m => m.parts.length), 1);
+
+	// For each part, collect voices grouped by staff
+	// partVoices[partIndex][staff] = measureContents[][]  (measure -> voice contents)
+	type StaffVoicesMap = Map<number, string[][]>;
+	const partVoices: StaffVoicesMap[] = [];
+	for (let pi = 0; pi < partCount; pi++) {
+		partVoices.push(new Map());
+	}
+
+	// Track time signature for each measure (for spacer rests)
+	const measureTimeSigs: Array<{ numerator: number; denominator: number } | undefined> = [];
 
 	let currentKey: KeySignature | undefined;
-	let currentTimeSig: any;
+	let currentTimeSig: { numerator: number; denominator: number } | undefined;
 
-	for (let mi = 0; mi < doc.measures.length; mi++) {
-		const measure = doc.measures[mi];
+	for (let mi = 0; mi < measures.length; mi++) {
+		const measure = measures[mi];
 
 		// Update context from measure
 		if (measure.key) currentKey = measure.key;
 		if (measure.timeSig) currentTimeSig = measure.timeSig;
 
+		// Store time signature for this measure
+		measureTimeSigs[mi] = currentTimeSig;
+
 		// Process each part
-		for (const part of measure.parts) {
+		for (let pi = 0; pi < measure.parts.length; pi++) {
+			const part = measure.parts[pi];
+			const staffMap = partVoices[pi];
+
 			for (let vi = 0; vi < part.voices.length; vi++) {
 				const voice = part.voices[vi];
 				const staff = voice.staff || 1;
 
-				if (!staffVoices.has(staff)) {
-					staffVoices.set(staff, []);
+				if (!staffMap.has(staff)) {
+					staffMap.set(staff, []);
 				}
-				const staffMeasures = staffVoices.get(staff)!;
+				const staffMeasures = staffMap.get(staff)!;
 
 				// Ensure we have enough measure slots
 				while (staffMeasures.length <= mi) {
@@ -737,13 +796,9 @@ export const encode = (doc: LilyletDoc, options: RenderOptions = {}): string =>
 		}
 	}
 
-	// Build music content
-	const staffCount = Math.max(...Array.from(staffVoices.keys()));
-	const staffStrings: string[] = [];
-
-	for (let si = 1; si <= staffCount; si++) {
-		const measures = staffVoices.get(si) || [];
-
+	// Build a staff string (used for both GrandStaff children and standalone Staff)
+	// Staff ID format: "partIndex_staffIndex" (e.g., "1_1", "1_2", "2_1") for multi-part decoding
+	const buildStaffString = (measures: string[][], staffId: string, indent: string): string => {
 		// Find max voices per measure for this staff
 		const maxVoices = Math.max(...measures.map(m => m.length), 1);
 
@@ -751,16 +806,66 @@ export const encode = (doc: LilyletDoc, options: RenderOptions = {}): string =>
 		const voiceLines: string[] = [];
 		for (let vi = 0; vi < maxVoices; vi++) {
 			const measureContents = measures.map((m, mi) => {
-				const content = m[vi] || 's1';  // Space rest if no content
-				return `        ${content} |  % ${mi + 1}`;
+				// Use correct spacer rest based on time signature
+				const spacer = getSpacerRest(measureTimeSigs[mi]);
+				const content = m[vi] || spacer;
+				// Wrap each measure in its own \relative c' to reset pitch context
+				return `${indent}    \\relative c' { ${content} } |  % ${mi + 1}`;
 			});
-			voiceLines.push(`      \\new Voice \\relative c' {\n${measureContents.join('\n')}\n      }`);
+			voiceLines.push(`${indent}  \\new Voice {\n${measureContents.join('\n')}\n${indent}  }`);
 		}
 
-		staffStrings.push(`    \\new Staff = "${si}" <<\n${voiceLines.join('\n')}\n    >>`);
+		return `${indent}\\new Staff = "${staffId}" <<\n${voiceLines.join('\n')}\n${indent}>>`;
+	};
+
+	// Build music content for each part
+	const partStrings: string[] = [];
+
+	for (let pi = 0; pi < partCount; pi++) {
+		const staffMap = partVoices[pi];
+		const staffNums = Array.from(staffMap.keys()).sort((a, b) => a - b);
+
+		if (staffNums.length === 0) {
+			// Empty part, skip
+			continue;
+		}
+
+		const partIndex = pi + 1;  // 1-based part index
+
+		if (staffNums.length === 1) {
+			// Single staff part → standalone Staff
+			const staffNum = staffNums[0];
+			const measures = staffMap.get(staffNum)!;
+			const staffId = `${partIndex}_${staffNum}`;
+			const staffStr = buildStaffString(measures, staffId, '    ');
+			partStrings.push(staffStr);
+		} else {
+			// Multiple staves → GrandStaff
+			const staffStrings: string[] = [];
+			for (const staffNum of staffNums) {
+				const measures = staffMap.get(staffNum)!;
+				const staffId = `${partIndex}_${staffNum}`;
+				const staffStr = buildStaffString(measures, staffId, '      ');
+				staffStrings.push(staffStr);
+			}
+			partStrings.push(`    \\new GrandStaff <<\n${staffStrings.join('\n')}\n    >>`);
+		}
 	}
 
-	const musicContent = staffStrings.join('\n');
+	const musicContent = partStrings.join('\n');
+
+	// Determine outer wrapper
+	// - Single part with single staff → just Staff (no outer <<>>)
+	// - Single part with multiple staves → GrandStaff (no extra outer <<>>)
+	// - Multiple parts → outer <<>>
+	let scoreContent: string;
+	if (partCount === 1 && partStrings.length === 1) {
+		// Single part - use as-is (already has Staff or GrandStaff)
+		scoreContent = musicContent;
+	} else {
+		// Multiple parts - wrap in <<>>
+		scoreContent = `  <<\n${musicContent}\n  >>`;
+	}
 
 	// Build header
 	const headerContent = doc.metadata ? encodeMetadata(doc.metadata) : '  tagline = ##f';
@@ -769,7 +874,7 @@ export const encode = (doc: LilyletDoc, options: RenderOptions = {}): string =>
 	const paperWidth = typeof opts.paper?.width === 'number' ? `${opts.paper.width}\\mm` : opts.paper?.width || '210\\mm';
 	const paperHeight = typeof opts.paper?.height === 'number' ? `${opts.paper.height}\\mm` : opts.paper?.height || '297\\mm';
 
-	const lyDoc = `\\version "2.24.0"
+	const lyDoc = `\\version "2.22.0"
 
 \\language "english"
 
@@ -794,9 +899,7 @@ ${headerContent}
 }
 
 \\score {
-  \\new GrandStaff <<
-${musicContent}
-  >>
+${scoreContent}
 
   \\layout { }${opts.withMIDI ? '\n  \\midi { }' : ''}
 }

package/source/lilylet/meiEncoder.ts

@@ -60,7 +60,8 @@ const keyToFifths = (key?: { pitch: string; accidental?: Accidental; mode: strin
 
 	if (key.mode === 'minor') fifths -= 3;
 
-	return fifths;
+	// Clamp to valid range [-7, 7] since standard notation doesn't support more than 7 sharps/flats
+	return Math.max(-7, Math.min(7, fifths));
 };
 
 

package/lib/lilypondDecoder.d.ts

@@ -1,28 +0,0 @@
-/**
- * LilyPond to Lilylet Decoder
- *
- * Converts LilyPond notation files to Lilylet document format using the lotus parser.
- * This module is browser-compatible - it uses pre-compiled parser from lotus.
- */
-import * as lilyParser from "@k-l-lambda/lotus/lib/inc/lilyParser/index.js";
-import { LilyletDoc, Event, Fraction } from "./types";
-interface ParsedMeasure {
-    key: number | null;
-    timeSig: Fraction | null;
-    voices: ParsedVoice[];
-    partial: boolean;
-}
-interface ParsedVoice {
-    staff: number;
-    events: Event[];
-}
-declare const parseLilyDocument: (lilyDocument: lilyParser.LilyDocument) => ParsedMeasure[];
-/**
- * Decode a LilyPond string to LilyletDoc (synchronous, browser-compatible)
- */
-declare const decode: (lilypondSource: string) => LilyletDoc;
-/**
- * Decode from pre-parsed LilyDocument (synchronous, for when you already have parsed data)
- */
-declare const decodeFromDocument: (lilyDocument: lilyParser.LilyDocument) => LilyletDoc;
-export { decode, decodeFromDocument, parseLilyDocument, };