fix(tools): mapStartToEvent is curried

ricardomatias · Feb 19, 2021 · 8b04cf7 · 8b04cf7
1 parent 8f78b17
commit 8b04cf7
Show file tree

Hide file tree

Showing 10 changed files with 138 additions and 59 deletions.
diff --git a/lib/composition/arp.ts b/lib/composition/arp.ts
@@ -35,7 +35,6 @@ export function createArp<T extends Scale | Chord>(
 
 	const eventsCount = Math.max(melody.length, rhythm.length);
 
-
 	if (isEvent(rhythm)) {
 		rhythm = R.compose(mapDurations, convertEventsToNotevalues)(rhythm);
 	} else {

diff --git a/lib/composition/chord-progression.ts b/lib/composition/chord-progression.ts
@@ -203,12 +203,12 @@ export function createChordProgression(
 		pattern = rhythm.map((event) => {
 			if (event.isRest) {
 				return ChordEvent({
-					...mapStartToEvent(event, time),
+					...mapStartToEvent(time, event),
 				});
 			}
 
 			return ChordEvent({
-				...mapStartToEvent(event, time),
+				...mapStartToEvent(time, event),
 				chord: chordNotes,
 				chordName: chord.name,
 			});

diff --git a/lib/composition/motif.ts b/lib/composition/motif.ts
@@ -29,11 +29,11 @@ export function createMotif(notes: Note[], rhythm: string[] | Event[], startTime
 		const note = choose(notes);
 
 		if (event.isRest) {
-			return NoteEvent(mapStartToEvent(event, start));
+			return NoteEvent(mapStartToEvent(start, event));
 		}
 
 		return NoteEvent({
-			...mapStartToEvent(event, start),
+			...mapStartToEvent(start, event),
 			note: note.n,
 			midi: note.m,
 		});

diff --git a/lib/composition/movement/default.ts b/lib/composition/movement/default.ts
@@ -109,7 +109,7 @@ function movement(key: Key, length: TimeFormat, turns: number, {
 						dur: 0,
 					};
 				}
-			}).filter(R.has('time'));
+			}).filter((evt) => R.has('time', evt));
 	} else if (rhythm === MovementRhythm.Turn) {
 		rhythmEvents = <TimelineEvent[]>Rhythm.turn(time, turns, {
 			minNoteValue: 8,

diff --git a/lib/composition/movement/turn.ts b/lib/composition/movement/turn.ts
@@ -131,33 +131,33 @@ function movement(key: Key, turns: Turn[] = DEFAULT_TURNS, length: TimeFormat, {
 		}
 
 		switch (turnType) {
-		case TurnMoves.Start:
+			case TurnMoves.Start:
 			// create a new key from the starting key
-			key = new Key(startingKey.root, startingKey.type);
-			mainKeyRoot = key.root;
-
-			key.modulateMode({ interval: interval as number });
-			break;
-		case TurnMoves.Keep:
-			break;
-		case TurnMoves.ModeUp:
-			key.modulateMode({ direction: Key.ModulateUp, interval: interval as number });
-
-			break;
-		case TurnMoves.ModeDown:
-			key.modulateMode({ direction: Key.ModulateDown, interval: interval as number });
-
-			break;
-		case TurnMoves.ModulateUp:
-			event.key = modulate(key, events, Key.ModulateUp, { type: turnType, interval: interval as Interval });
-
-			mainKeyRoot = key.root;
-			break;
-		case TurnMoves.ModulateDown:
-			event.key = modulate(key, events, Key.ModulateDown, { type: turnType, interval: interval as Interval });
-
-			mainKeyRoot = key.root;
-			break;
+				key = new Key(startingKey.root, startingKey.type);
+				mainKeyRoot = key.root;
+
+				key.modulateMode({ interval: interval as number });
+				break;
+			case TurnMoves.Keep:
+				break;
+			case TurnMoves.ModeUp:
+				key.modulateMode({ direction: Key.ModulateUp, interval: interval as number });
+
+				break;
+			case TurnMoves.ModeDown:
+				key.modulateMode({ direction: Key.ModulateDown, interval: interval as number });
+
+				break;
+			case TurnMoves.ModulateUp:
+				event.key = modulate(key, events, Key.ModulateUp, { type: turnType, interval: interval as Interval });
+
+				mainKeyRoot = key.root;
+				break;
+			case TurnMoves.ModulateDown:
+				event.key = modulate(key, events, Key.ModulateDown, { type: turnType, interval: interval as Interval });
+
+				mainKeyRoot = key.root;
+				break;
 		}
 
 		if (isTypeMod(turnType)) {

diff --git a/lib/composition/sequence.ts b/lib/composition/sequence.ts
@@ -159,27 +159,27 @@ export class Sequence {
 			let chord: Chord | undefined;
 
 			switch (romanPos) {
-			case 'I':
-				chord = scale.I?.chord;
-				break;
-			case 'II':
-				chord = scale.II?.chord;
-				break;
-			case 'III':
-				chord = scale.III?.chord;
-				break;
-			case 'IV':
-				chord = scale.IV?.chord;
-				break;
-			case 'V':
-				chord = scale.V?.chord;
-				break;
-			case 'VI':
-				chord = scale.VI?.chord;
-				break;
-			case 'VII':
-				chord = scale.VII?.chord;
-				break;
+				case 'I':
+					chord = scale.I?.chord;
+					break;
+				case 'II':
+					chord = scale.II?.chord;
+					break;
+				case 'III':
+					chord = scale.III?.chord;
+					break;
+				case 'IV':
+					chord = scale.IV?.chord;
+					break;
+				case 'V':
+					chord = scale.V?.chord;
+					break;
+				case 'VI':
+					chord = scale.VI?.chord;
+					break;
+				case 'VII':
+					chord = scale.VII?.chord;
+					break;
 			}
 
 			if (chord) this._chords.push(chord);

diff --git a/lib/core/Types.ts b/lib/core/Types.ts
@@ -11,4 +11,4 @@ export interface ChordEvent {
 export type CoreClassType = 'scale' | 'chord' | 'key'
 
 export type ChordDescriptor = { root: NoteSymbol, intervals: ChordIntervals | string } &
-	Partial<Pick<ChordDefinition, 'name' | 'symbol' | 'structure'>>
+Partial<Pick<ChordDefinition, 'name' | 'symbol' | 'structure'>>
diff --git a/lib/tools/event.ts b/lib/tools/event.ts
@@ -94,19 +94,31 @@ export const computeEventsNext = (events: Event[]): Event[] => {
 	});
 };
 
-export const mapStartToEvent = (event: Event, startTime: TimeFormat): Event => {
+
+/**
+ * Maps events to a new starting value
+ *
+ * @function mapStartToEvent
+ * @memberof Tools.Event
+ *
+ * @param {Event} event
+ * @param {TimeFormat} startTime
+ * @return {Event}
+ */
+export const mapStartToEvent = R.curry((startTime: TimeFormat, event: Event): Event => {
 	const start = new Time(startTime);
 	return ({
 		...event,
 		time: start.ticks + event.time,
 		next: start.ticks + event.next,
 	});
-};
+});
 
 /**
+ * Converts Event[] to notevalues (ie. 4n), ignores rests
+ *
  * @function convertEventsToNotevalues
  * @memberof Tools.Event
- * @description Converts Event[] to notevalues (ie. 4n), ignores rests
  *
  * @param {Event[]} events
  * @return {string[]}

diff --git a/lib/tools/midi.ts b/lib/tools/midi.ts
@@ -59,7 +59,7 @@ const findNearestVoice = R.curry((voices, baseVoice): { note: string, midiNote:
 
 /**
  * Find the nearest chord
- * @function findNearest
+ * @function findNearestChord
  * @memberof Tools.Midi
  *
  * @param {Array<Number>} baseChord

diff --git a/test/tools/event.spec.ts b/test/tools/event.spec.ts
@@ -1,4 +1,5 @@
-import { expandDuration } from '../../lib/tools/event';
+import * as R from 'ramda';
+import { expandDuration, mapStartToEvent } from '../../lib/tools/event';
 
 describe('An Event tools test suite', () => {
 	describe('#expandDuration', () => {
@@ -75,4 +76,71 @@ describe('An Event tools test suite', () => {
 		`);
 		});
 	});
+
+	describe('#mapStartToEvent', () => {
+		const events = [
+			{
+				dur: 480,
+				isRest: false,
+				next: 240,
+				time: 0,
+			},
+			{
+				dur: 600,
+				isRest: false,
+				next: 720,
+				time: 240,
+			},
+			{
+				dur: 640,
+				isRest: false,
+				next: 1360,
+				time: 720,
+			},
+		];
+
+		it('should map single', () => {
+			// when
+			const mapd = mapStartToEvent(480, events[0]);
+
+			// then
+			expect(mapd).toMatchInlineSnapshot(`
+			Object {
+			  "dur": 480,
+			  "isRest": false,
+			  "next": 720,
+			  "time": 480,
+			}
+		`);
+		});
+
+		it('should map multiple', () => {
+			// when
+			const mapd = R.map(mapStartToEvent(480), events);
+
+			// then
+			expect(mapd).toMatchInlineSnapshot(`
+			Array [
+			  Object {
+			    "dur": 480,
+			    "isRest": false,
+			    "next": 720,
+			    "time": 480,
+			  },
+			  Object {
+			    "dur": 600,
+			    "isRest": false,
+			    "next": 1200,
+			    "time": 720,
+			  },
+			  Object {
+			    "dur": 640,
+			    "isRest": false,
+			    "next": 1840,
+			    "time": 1200,
+			  },
+			]
+		`);
+		});
+	});
 });