Play collection (#1765)

if a person requests to play a track in a playlist or album, continue
playing from that track

Author: steveluc

ts/packages/agents/player/src/agent/playerGrammar.agr

@@ -37,19 +37,69 @@
 |   two -> 2
 |   three -> 3
 |   four -> 4
+|   five -> 5
+|   six -> 6
+|   seven -> 7
+|   eight -> 8
+|   nine -> 9
+|   ten -> 10
+|   eleven -> 11
+|   twelve -> 12
+|   thirteen -> 13
+|   fourteen -> 14
+|   fifteen -> 15
+|   sixteen -> 16
+|   seventeen -> 17
+|   eighteen -> 18
+|   nineteen -> 19
+|   twenty -> 20
+|   twenty\-one -> 21
+|   twenty\-two -> 22
+|   twenty\-three -> 23
+|   twenty\-four -> 24
+|   twenty\-five -> 25
+|   twenty\-six -> 26
+|   twenty\-seven -> 27
+|   twenty\-eight -> 28
+|   twenty\-nine -> 29
+|   thirty -> 30
 
 
 @ <Ordinal> = 
     first -> 1
 |   second -> 2
 |   third -> 3
-|   troisiemme -> 3
 |   fourth -> 4
+|   fifth -> 5
+|   sixth -> 6
+|   seventh -> 7
+|   eighth -> 8
+|   ninth -> 9
+|   tenth -> 10
+|   eleventh -> 11
+|   twelfth -> 12
+|   thirteenth -> 13
+|   fourteenth -> 14
+|   fifteenth -> 15
+|   sixteenth -> 16
+|   seventeenth -> 17
+|   eighteenth -> 18
+|   nineteenth -> 19
+|   twentieth -> 20
+|   twenty\-first -> 21
+|   twenty\-second -> 22
+|   twenty\-third -> 23
+|   twenty\-fourth -> 24
+|   twenty\-fifth -> 25
+|   twenty\-sixth -> 26
+|   twenty\-seventh -> 27
+|   twenty\-eighth -> 28
+|   twenty\-ninth -> 29
+|   thirtieth -> 30
 
 @ <TrackPhrase> = ((the)? <TrackTerm>)? $(trackName:<TrackName>)
                 | $(trackName:<TrackName>) <TrackTerm>
-@ <PlaySpecificTrack> = play $(trackName:<TrackPhrase>) -> { actionName: "playTrack", parameters: { trackName: $(trackName) } }
-                      | play $(trackName:<TrackPhrase>) by $(artist:<ArtistName>) -> { actionName: "playTrack", parameters: { trackName: $(trackName), artists: [$(artist)] } }
+@ <PlaySpecificTrack> = play $(trackName:<TrackPhrase>) by $(artist:<ArtistName>) -> { actionName: "playTrack", parameters: { trackName: $(trackName), artists: [$(artist)] } }
                       | play $(trackName:<TrackPhrase>) from (the)? album $(albumName:<AlbumName>) -> { actionName: "playTrack", parameters: { trackName: $(trackName), albumName: $(albumName) } }
                       | play $(trackName:<TrackPhrase>) by $(artist:<ArtistName>) from (the)? album $(albumName:<AlbumName>) -> { actionName: "playTrack", parameters: { trackName: $(trackName), artists: [$(artist)], albumName: $(albumName) } }                      
 

ts/packages/agents/player/src/client.ts

@@ -397,14 +397,23 @@ function updatePlaylistList(
     context.currentPlaylistList = playlists;
 }
 
+function updateTrackList(
+    collection: ITrackCollection,
+    context: IClientContext,
+) {
+    context.currentTrackList = collection;
+    context.lastTrackStartIndex = 0;
+    context.lastTrackEndIndex = collection.getTrackCount();
+
+    context.currentTrackList = collection;
+}
+
 async function updateTrackListAndPrint(
     collection: ITrackCollection,
     clientContext: IClientContext,
 ) {
     await printTrackNames(collection, clientContext);
-    clientContext.currentTrackList = collection;
-    clientContext.lastTrackStartIndex = 0;
-    clientContext.lastTrackEndIndex = collection.getTrackCount();
+    updateTrackList(collection, clientContext);
 }
 
 export async function getClientContext(
@@ -506,30 +515,62 @@ export async function searchForPlaylists(
 async function playTrackCollection(
     trackCollection: ITrackCollection,
     clientContext: IClientContext,
-    trackIndex = 0,
+    trackIndex: number | undefined = undefined,
 ) {
     const deviceId = await ensureSelectedDeviceId(clientContext);
     const tracks = trackCollection.getTracks();
     const playContext = trackCollection.getContext();
-    const singleTrackCollection = new TrackCollection([tracks[trackIndex]]);
-    const actionResult = await htmlTrackNames(
-        singleTrackCollection,
-        "Now playing",
-    );
-    if (playContext === undefined) {
-        const singleTracks = singleTrackCollection.getTracks();
-        const uris = singleTracks.map((track) => track.uri);
-        await play(clientContext.service, deviceId, uris);
-    } else {
-        await play(
-            clientContext.service,
-            deviceId,
-            undefined,
-            playContext,
-            trackIndex,
+    if (
+        trackIndex !== undefined &&
+        (trackIndex < 0 || trackIndex >= tracks.length)
+    ) {
+        return createErrorActionResult(
+            `Track index ${trackIndex} out of range for track collection of size ${tracks.length}`,
         );
+    } else {
+        if (trackIndex !== undefined) {
+            if (playContext === undefined) {
+                const singleTrackCollection = new TrackCollection([
+                    tracks[trackIndex],
+                ]);
+                const actionResult = await htmlTrackNames(
+                    singleTrackCollection,
+                    "Now playing",
+                );
+                const singleTracks = singleTrackCollection.getTracks();
+                const uris = singleTracks.map((track) => track.uri);
+                await play(clientContext.service, deviceId, uris);
+                return actionResult;
+            } else {
+                const trackCollectionFromTrackNumber = new TrackCollection(
+                    tracks.slice(trackIndex),
+                    playContext,
+                );
+                const actionResult = await htmlTrackNames(
+                    trackCollectionFromTrackNumber,
+                    "Now playing",
+                );
+                updateTrackList(trackCollectionFromTrackNumber, clientContext);
+                await play(
+                    clientContext.service,
+                    deviceId,
+                    undefined,
+                    playContext,
+                    trackIndex,
+                );
+                return actionResult;
+            }
+        } else {
+            const actionResult = await htmlTrackNames(
+                trackCollection,
+                "Now playing",
+            );
+            updateTrackList(trackCollection, clientContext);
+            const uris = tracks.map((track) => track.uri);
+            await play(clientContext.service, deviceId, uris, playContext);
+            return actionResult;
+        }
     }
-    return actionResult;
 }
 
 function randomShuffle<T>(array: T[]) {
@@ -551,8 +592,12 @@ async function playRandomAction(
         if (quantity > 0) {
             savedTracks.splice(quantity);
         }
-
-        const tracks = randomShuffle(savedTracks.map((track) => track.track));
+        const rawTracks = savedTracks.map((track) => track.track);
+        const uniqueTracks = new Map<string, SpotifyApi.TrackObjectFull>();
+        for (const track of rawTracks) {
+            uniqueTracks.set(track.id, track);
+        }
+        const tracks = randomShuffle(Array.from(uniqueTracks.values()));
         const collection = new TrackCollection(tracks);
         return playTrackCollection(collection, clientContext);
     }