feat: Add collections

CHANGELOG.md

···
 ## 3.5.0
 
 - **Improve audio playback, processing and error handling**.
-- **No longer resets shuffle history when the collection or search changes**.
+- **Added collections, an alternative to playlists**. Tracks can only appear once in a collection and cannot be ordered.
 - **Basic setup for themes**.
+- No longer resets shuffle history when the collection or search changes.
 - WebDAV improvements.
 - Removed Fission/Webnative user layer (discontinued).
 - Minor improvements/fixes to the artwork downloading process.

src/Core/Themes/Sunrise/Playlists/View.elm

···
             Index ->
                 index playlists selectedPlaylist bgColor authMethodSupportsPublicData
 
-            New ->
-                new
+            NewCollection ->
+                newCollection
+
+            NewPlaylist ->
+                newPlaylist
         )
 
 
···
         isSelected playlist =
             Maybe.map (\s -> ( s.autoGenerated, s.name )) selectedPlaylist == Just ( playlist.autoGenerated, playlist.name )
 
-        customPlaylists =
+        ( customCollections, customPlaylists ) =
             playlists
                 |> List.filterNot (.autoGenerated >> Maybe.isJust)
                 |> List.sortBy lowercaseName
+                |> List.partition .collection
 
         customPlaylistListItem playlist =
             if isSelected playlist then
···
                 , isSelected = False
                 }
 
-        directoryPlaylists =
+        directoryCollections =
             playlists
                 |> List.filter (.autoGenerated >> Maybe.isJust)
                 |> List.sortBy lowercaseName
···
           , NavigateToPage Page.Index
           )
         , ( Icon Icons.add
+          , Label "Create a new collection" Shown
+          , NavigateToPage (Page.Playlists NewCollection)
+          )
+        , ( Icon Icons.add
           , Label "Create a new playlist" Shown
-          , NavigateToPage (Page.Playlists New)
+          , NavigateToPage (Page.Playlists NewPlaylist)
           )
         ]
 
···
 
       else
         Kit.canister
-            [ Kit.h1 "Playlists"
+            [ Kit.h1 "Collections & Playlists"
 
             -- Intro
             --------
             , intro
 
+            -- Custom Collections
+            ---------------------
+            , if List.isEmpty customCollections then
+                nothing
+
+              else
+                raw
+                    [ category "Your Collections"
+                    , Themes.Sunrise.List.view
+                        Themes.Sunrise.List.Normal
+                        (List.map customPlaylistListItem customCollections)
+                    ]
+
             -- Custom Playlists
             -------------------
             , if List.isEmpty customPlaylists then
···
                         (List.map customPlaylistListItem customPlaylists)
                     ]
 
-            -- Directory Playlists
-            ----------------------
-            , if List.isEmpty directoryPlaylists then
+            -- Directory Collections
+            ------------------------
+            , if List.isEmpty directoryCollections then
                 nothing
 
               else
                 raw
-                    [ category "Autogenerated Directory Playlists"
+                    [ category "Autogenerated Directory Collections"
                     , Themes.Sunrise.List.view
                         Themes.Sunrise.List.Normal
-                        (List.map directoryPlaylistListItem directoryPlaylists)
+                        (List.map directoryPlaylistListItem directoryCollections)
                     ]
             ]
 
···
         Kit.centeredContent
             [ slab
                 Html.a
-                [ href (Page.toString <| Page.Playlists New) ]
+                [ href (Page.toString <| Page.Playlists NewPlaylist) ]
                 [ "block"
                 , "opacity-30"
                 , "text-inherit"
···
                 [ Icons.waves 64 Inherit ]
             , slab
                 Html.a
-                [ href (Page.toString <| Page.Playlists New) ]
+                [ href (Page.toString <| Page.Playlists NewPlaylist) ]
                 [ "block"
                 , "leading-normal"
                 , "mt-2"
···
                 ]
                 [ text "No playlists found, create one"
                 , lineBreak
-                , text "or enable directory playlists."
+                , text "or enable directory collections."
                 ]
             ]
 
···
 
 intro : Html Msg
 intro =
-    [ text "Playlists are not tied to the sources of its tracks, "
-    , text "same goes for favourites."
+    [ text "Collections and playlists are not tied to the sources of its tracks, "
+    , text "same goes for favourites. "
     , lineBreak
-    , text "There's also directory playlists, which are playlists derived from root directories."
+    , text "There's also directory collections, which are derived from root directories."
     ]
         |> raw
         |> Kit.intro
···
 -- NEW
 
 
-new : List (Html Msg)
-new =
+newCollection : List (Html Msg)
+newCollection =
     [ -----------------------------------------
       -- Navigation
       -----------------------------------------
···
     -----------------------------------------
     -- Content
     -----------------------------------------
-    , [ Kit.h2 "Name your playlist"
+    , [ Kit.h2 "Name your collection"
 
       --
       , [ onInput SetPlaylistCreationContext
         , placeholder "The Classics"
+        ]
+            |> Kit.textField
+            |> chunky [ "max-w-md", "mx-auto" ]
+
+      -- Button
+      ---------
+      , chunk
+            [ "mt-10" ]
+            [ Kit.button
+                Normal
+                Bypass
+                (text "Create collection")
+            ]
+      ]
+        |> Kit.canisterForm
+        |> List.singleton
+        |> Kit.centeredContent
+        |> List.singleton
+        |> slab
+            Html.form
+            [ onSubmit CreateCollection ]
+            [ "flex"
+            , "flex-grow"
+            , "text-center"
+            ]
+    ]
+
+
+newPlaylist : List (Html Msg)
+newPlaylist =
+    [ -----------------------------------------
+      -- Navigation
+      -----------------------------------------
+      Navigation.local
+        [ ( Icon Icons.arrow_back
+          , Label "Back to list" Hidden
+          , NavigateToPage (Page.Playlists Index)
+          )
+        ]
+
+    -----------------------------------------
+    -- Content
+    -----------------------------------------
+    , [ Kit.h2 "Name your playlist"
+
+      --
+      , [ onInput SetPlaylistCreationContext
+        , placeholder "Sunset"
         ]
             |> Kit.textField
             |> chunky [ "max-w-md", "mx-auto" ]

src/Core/Themes/Sunrise/Tracks/View.elm

···
                     model.selectedPlaylist
                         |> Maybe.andThen
                             (\playlist ->
-                                case playlist.autoGenerated of
-                                    Just _ ->
-                                        Nothing
+                                if playlist.collection || Maybe.isJust playlist.autoGenerated then
+                                    Nothing
 
-                                    Nothing ->
-                                        Just model.dnd
+                                else
+                                    Just model.dnd
                             )
                         |> Themes.Sunrise.Tracks.Scene.List.view
                             { bgColor = model.extractedBackdropColor
···
           Navigation.localWithTabindex
             tabindex_
             [ ( Icon Icons.waves
-              , Label "Playlists" Hidden
+              , Label "Collections & Playlists" Hidden
               , if pressedShift then
                     PerformMsg AssistWithSelectingPlaylist
 

src/Core/UI.elm

···
         AddTracksToPlaylist a ->
             Playlists.addTracksToPlaylist a
 
+        AssistWithAddingTracksToCollection a ->
+            Playlists.assistWithAddingTracksToCollection a
+
         AssistWithAddingTracksToPlaylist a ->
             Playlists.assistWithAddingTracksToPlaylist a
 
         AssistWithSelectingPlaylist ->
             Playlists.assistWithSelectingPlaylist
 
+        CreateCollection ->
+            Playlists.createCollection
+
         CreatePlaylist ->
-            Playlists.create
+            Playlists.createPlaylist
 
         DeactivatePlaylist ->
             Playlists.deactivate

src/Core/UI/Commands/Alfred.elm

···
 
             --
             , { icon = Just (Icons.queue_music 16)
+              , title = "Add current track to collection"
+              , value = Command (UI.AssistWithAddingTracksToCollection <| [ identifiedTrack ])
+              }
+
+            --
+            , { icon = Just (Icons.queue_music 16)
               , title = "Add current track to playlist"
               , value = Command (UI.AssistWithAddingTracksToPlaylist <| [ identifiedTrack ])
               }
···
         tracks ->
             List.concat
                 [ [ { icon = Just (Icons.queue_music 16)
+                    , title = "Add current selection to collection"
+                    , value = Command (UI.AssistWithAddingTracksToCollection tracks)
+                    }
+                  , { icon = Just (Icons.queue_music 16)
                     , title = "Add current selection to playlist"
                     , value = Command (UI.AssistWithAddingTracksToPlaylist tracks)
                     }

src/Core/UI/Page.elm

···
 module UI.Page exposing (Page(..), fromUrl, rewriteUrl, sameBase, sources, toString)
 
+import Material.Icons exposing (collections)
 import Maybe.Extra as Maybe
 import Sources exposing (Service(..))
 import UI.Playlists.Page as Playlists
···
         Playlists Playlists.Index ->
             "playlists"
 
-        Playlists Playlists.New ->
-            "playlists/new"
+        Playlists Playlists.NewCollection ->
+            "playlists/new/collection"
+
+        Playlists Playlists.NewPlaylist ->
+            "playlists/new/playlist"
 
         Playlists (Playlists.Edit playlistName) ->
             "playlists/edit/" ++ playlistName
···
         -----------------------------------------
         , map (Playlists Playlists.Index) (s "playlists")
         , map (Playlists << Playlists.Edit) (s "playlists" </> s "edit" </> string)
-        , map (Playlists Playlists.New) (s "playlists" </> s "new")
+        , map (Playlists Playlists.NewCollection) (s "playlists" </> s "new" </> s "collection")
+        , map (Playlists Playlists.NewPlaylist) (s "playlists" </> s "new" </> s "playlist")
 
         -----------------------------------------
         -- Queue

src/Core/UI/Playlists/Alfred.elm

···
 -- CREATE
 
 
-create : List IdentifiedTrack -> List Playlist -> Alfred UI.Msg
-create tracks playlists =
+create : { collectionMode : Bool } -> List IdentifiedTrack -> List Playlist -> Alfred UI.Msg
+create { collectionMode } tracks playlists =
     let
         index =
             makeIndex playlists
+
+        subject =
+            ifThenElse collectionMode "collection" "playlist"
     in
     Alfred.create
-        { action = createAction tracks
+        { action = createAction collectionMode tracks
         , index = index
         , message =
             if List.length tracks == 1 then
-                "Choose or create a playlist to add this track to."
+                "Choose or create a " ++ subject ++ " to add this track to."
 
             else
-                "Choose or create a playlist to add these tracks to."
+                "Choose or create a " ++ subject ++ " to add these tracks to."
         , operation = QueryOrMutation
         }
 
 
-createAction : List IdentifiedTrack -> Alfred.Action UI.Msg
-createAction tracks ctx =
+createAction : Bool -> List IdentifiedTrack -> Alfred.Action UI.Msg
+createAction collectionMode tracks ctx =
     let
         playlistTracks =
             Tracks.toPlaylistTracks tracks
···
             case Alfred.stringValue result.value of
                 Just playlistName ->
                     [ UI.AddTracksToPlaylist
-                        { playlistName = playlistName
+                        { collection = collectionMode
+                        , playlistName = playlistName
                         , tracks = playlistTracks
                         }
                     ]
···
             case ctx.searchTerm of
                 Just searchTerm ->
                     [ UI.AddTracksToPlaylist
-                        { playlistName = searchTerm
+                        { collection = collectionMode
+                        , playlistName = searchTerm
                         , tracks = playlistTracks
                         }
                     ]

src/Core/UI/Playlists/ContextMenu.elm

···
         Just _ ->
             ContextMenu
                 [ addToQueue identifiedTracksFromPlaylist
-                , convertToRegularPlaylist tracksFromPlaylist playlist
+                , convertToRegularCollection tracksFromPlaylist playlist
                 , downloadAsZip tracksFromPlaylist playlist
                 , storeInCache tracksFromPlaylist
                 ]
···
         }
 
 
-convertToRegularPlaylist tracksFromPlaylist playlist =
+convertToRegularCollection tracksFromPlaylist playlist =
     Item
         { icon = Icons.waves
-        , label = "Convert to regular playlist"
+        , label = "Save as regular collection"
         , msg =
             AddTracksToPlaylist
-                { playlistName = playlist.name
+                { collection = True
+                , playlistName = playlist.name
                 , tracks = List.map Tracks.playlistTrackFromTrack tracksFromPlaylist
                 }
 

src/Core/UI/Playlists/Directory.elm

···
 module UI.Playlists.Directory exposing (generate)
 
 import Dict exposing (Dict)
+import List.Extra as List
 import Playlists exposing (..)
 import Set exposing (Set)
 import Sources exposing (Source)
 import String.Ext as String
 import Tracks exposing (Track)
-import List.Extra as List
+
 
 
 -- 🔱
···
         |> List.map
             (\n ->
                 let
-                  s =
-                    String.split "/" n
+                    s =
+                        String.split "/" n
                 in
                 { autoGenerated = Just { level = List.length s - 1 }
+                , collection = True
                 , name = Maybe.withDefault n (List.last s)
                 , public = False
                 , tracks = []

src/Core/UI/Playlists/Page.elm

···
 type Page
     = Edit String
     | Index
-    | New
+    | NewCollection
+    | NewPlaylist

src/Core/UI/Playlists/State.elm

···
         |> andThen (Common.changeUrlUsingPage Page.Index)
 
 
-addTracksToPlaylist : { playlistName : String, tracks : List PlaylistTrack } -> Manager
-addTracksToPlaylist { playlistName, tracks } model =
+addTracksToPlaylist : { collection : Bool, playlistName : String, tracks : List PlaylistTrackWithoutMetadata } -> Manager
+addTracksToPlaylist { collection, playlistName, tracks } model =
     let
         properPlaylistName =
             String.trim playlistName
···
                 (\p -> Maybe.isNothing p.autoGenerated && p.name == properPlaylistName)
                 model.playlists
 
-        newCollection =
+        ( tracksAlreadyInPlaylist, newTracks ) =
+            playlistIndex
+                |> Maybe.andThen
+                    (\a ->
+                        if collection then
+                            Just a
+
+                        else
+                            Nothing
+                    )
+                |> Maybe.andThen (\idx -> List.getAt idx model.playlists)
+                |> Maybe.map
+                    (\p ->
+                        List.foldl
+                            (\track ( a, b, c ) ->
+                                case
+                                    List.findIndex
+                                        (\x ->
+                                            track.title == x.title && track.album == x.album && track.artist == x.artist
+                                        )
+                                        c
+                                of
+                                    Just idx ->
+                                        ( track :: a, b, List.removeAt idx c )
+
+                                    Nothing ->
+                                        ( a, track :: b, c )
+                            )
+                            ( [], [], p.tracks )
+                            tracks
+                    )
+                |> Maybe.map (\( a, b, _ ) -> ( a, b ))
+                |> Maybe.withDefault ( [], tracks )
+                |> Tuple.mapSecond
+                    (List.map
+                        (\track ->
+                            let
+                                newTrack : PlaylistTrack
+                                newTrack =
+                                    { album = track.album
+                                    , artist = track.artist
+                                    , title = track.title
+
+                                    --
+                                    , insertedAt = model.currentTime
+                                    }
+                            in
+                            newTrack
+                        )
+                    )
+
+        newInventory =
             case playlistIndex of
                 Just idx ->
                     List.updateAt
                         idx
-                        (\p -> { p | tracks = p.tracks ++ tracks })
+                        (\p -> { p | tracks = p.tracks ++ newTracks })
                         model.playlists
 
                 Nothing ->
                     { autoGenerated = Nothing
+                    , collection = collection
                     , name = properPlaylistName
                     , public = False
-                    , tracks = tracks
+                    , tracks = newTracks
                     }
                         :: model.playlists
 
         newModel =
             { model
-                | playlists = newCollection
-                , lastModifiedPlaylist = Just properPlaylistName
+                | playlists = newInventory
+                , lastModifiedPlaylist =
+                    Just
+                        { collection = collection
+                        , name = properPlaylistName
+                        }
             }
+
+        subject =
+            ifThenElse collection "collection" "playlist"
     in
-    (case tracks of
-        [ t ] ->
-            "Added __" ++ t.title ++ "__"
+    case newTracks of
+        [] ->
+            if collection then
+                (case tracksAlreadyInPlaylist of
+                    [ t ] ->
+                        "__" ++ t.title ++ "__ was"
 
-        l ->
-            "Added __" ++ String.fromInt (List.length l) ++ " tracks__"
-    )
-        |> (\s -> s ++ " to the __" ++ properPlaylistName ++ "__ playlist")
-        |> Notifications.success
-        |> Common.showNotificationWithModel newModel
-        |> andThen User.savePlaylists
+                    l ->
+                        "__" ++ String.fromInt (List.length l) ++ " tracks__ were"
+                )
+                    |> (\s -> s ++ " already added to the __" ++ properPlaylistName ++ "__ collection")
+                    |> Notifications.casual
+                    |> Common.showNotificationWithModel model
+
+            else
+                Return.singleton model
+
+        _ ->
+            (case newTracks of
+                [ t ] ->
+                    "Added __" ++ t.title ++ "__"
+
+                l ->
+                    "Added __" ++ String.fromInt (List.length l) ++ " tracks__"
+            )
+                |> (\s -> s ++ " to the __" ++ properPlaylistName ++ "__ " ++ subject)
+                |> Notifications.success
+                |> Common.showNotificationWithModel newModel
+                |> andThen User.savePlaylists
+
+
+assistWithAddingTracksToCollection : List IdentifiedTrack -> Manager
+assistWithAddingTracksToCollection tracks model =
+    model.playlists
+        |> List.filter (\p -> p.autoGenerated == Nothing && p.collection == True)
+        |> UI.Playlists.Alfred.create { collectionMode = True } tracks
+        |> (\a -> Alfred.assign a model)
 
 
 assistWithAddingTracksToPlaylist : List IdentifiedTrack -> Manager
 assistWithAddingTracksToPlaylist tracks model =
     model.playlists
-        |> List.filterNot (.autoGenerated >> Maybe.isJust)
-        |> UI.Playlists.Alfred.create tracks
+        |> List.filter (\p -> p.autoGenerated == Nothing && p.collection == False)
+        |> UI.Playlists.Alfred.create { collectionMode = False } tracks
         |> (\a -> Alfred.assign a model)
 
 
···
         |> (\a -> Alfred.assign a model)
 
 
-create : Manager
-create model =
+create : { collection : Bool } -> Manager
+create { collection } model =
     case model.newPlaylistContext of
         Just playlistName ->
             let
                 alreadyExists =
-                    List.any
+                    List.find
                         (.name >> (==) playlistName)
                         (List.filterNot (.autoGenerated >> Maybe.isJust) model.playlists)
 
                 playlist =
                     { autoGenerated = Nothing
+                    , collection = collection
                     , name = playlistName
                     , public = False
                     , tracks = []
                     }
             in
-            if alreadyExists then
-                "There's already a playlist with this name"
-                    |> Notifications.error
-                    |> Common.showNotificationWithModel model
+            case alreadyExists of
+                Just existingPlaylist ->
+                    (if existingPlaylist.collection then
+                        "There's already a collection using this name"
 
-            else
-                { model
-                    | lastModifiedPlaylist = Just playlist.name
-                    , newPlaylistContext = Nothing
-                    , playlists = playlist :: model.playlists
-                }
-                    |> User.savePlaylists
-                    |> andThen redirectToPlaylistIndexPage
+                     else
+                        "There's already a playlist using this name"
+                    )
+                        |> Notifications.error
+                        |> Common.showNotificationWithModel model
+
+                Nothing ->
+                    { model
+                        | lastModifiedPlaylist =
+                            Just
+                                { collection = playlist.collection
+                                , name = playlist.name
+                                }
+                        , newPlaylistContext = Nothing
+                        , playlists = playlist :: model.playlists
+                    }
+                        |> User.savePlaylists
+                        |> andThen redirectToPlaylistIndexPage
 
         Nothing ->
             Return.singleton model
 
 
+createCollection : Manager
+createCollection =
+    create { collection = True }
+
+
+createPlaylist : Manager
+createPlaylist =
+    create { collection = False }
+
+
 deactivate : Manager
 deactivate =
     deselect
···
                     List.partition (.autoGenerated >> Maybe.isJust) model.playlists
 
                 alreadyExists =
-                    List.any
+                    List.find
                         (.name >> (==) properName)
                         notAutoGenerated
 
···
                         (\p -> ifThenElse (p.name == oldName) { p | name = properName } p)
                         notAutoGenerated
             in
-            if alreadyExists then
-                "There's already a playlist with this name"
-                    |> Notifications.error
-                    |> Common.showNotificationWithModel
-                        { model | editPlaylistContext = Nothing }
+            case alreadyExists of
+                Just existingPlaylist ->
+                    (if existingPlaylist.collection then
+                        "There's already a collection using this name"
+
+                     else
+                        "There's already a playlist using this name"
+                    )
+                        |> Notifications.error
+                        |> Common.showNotificationWithModel
+                            { model | editPlaylistContext = Nothing }
+
+                Nothing ->
+                    if validName then
+                        { model
+                            | editPlaylistContext = Nothing
+                            , lastModifiedPlaylist =
+                                case model.lastModifiedPlaylist of
+                                    Just l ->
+                                        if l.name == oldName then
+                                            Just { l | name = newName }
+
+                                        else
+                                            Just l
 
-            else if validName then
-                { model
-                    | editPlaylistContext = Nothing
-                    , lastModifiedPlaylist = Just properName
-                    , playlists = newCollection ++ autoGenerated
-                }
-                    |> User.savePlaylists
-                    |> andThen redirectToPlaylistIndexPage
+                                    Nothing ->
+                                        Nothing
+                            , playlists = newCollection ++ autoGenerated
+                        }
+                            |> User.savePlaylists
+                            |> andThen redirectToPlaylistIndexPage
 
-            else
-                redirectToPlaylistIndexPage model
+                    else
+                        redirectToPlaylistIndexPage model
 
         Nothing ->
             redirectToPlaylistIndexPage model

src/Core/UI/Queue/ContextMenu.elm

···
             }
         , Item
             { icon = Icons.waves
+            , label = "Add to collection"
+            , msg = AssistWithAddingTracksToCollection tracks
+            , active = False
+            }
+        , Item
+            { icon = Icons.waves
             , label = "Add to playlist"
             , msg = AssistWithAddingTracksToPlaylist tracks
             , active = False
···
       else
         [ Item
             { icon = Icons.waves
+            , label = "Add queue picks to collection"
+            , msg =
+                manualEntries
+                    |> List.map .identifiedTrack
+                    |> AssistWithAddingTracksToCollection
+            , active = False
+            }
+        , Item
+            { icon = Icons.waves
             , label = "Add queue picks to playlist"
             , msg =
                 manualEntries
···
                     |> QueueMsg
 
             --
+            , active = False
+            }
+        , Item
+            { icon = Icons.waves
+            , label = "Add to collection"
+            , msg = AssistWithAddingTracksToCollection tracks
             , active = False
             }
         , Item

src/Core/UI/Tracks/ContextMenu.elm

···
     { cached : List String
     , cachingInProgress : List String
     , currentTime : Time.Posix
-    , lastModifiedPlaylistName : Maybe String
+    , lastModifiedPlaylistName : Maybe { collection : Bool, name : String }
     , selectedPlaylist : Maybe Playlist
     , showAlternativeMenu : Bool
     , sources : List Source
···
 
 playlistActions :
     { selectedPlaylist : Maybe Playlist
-    , lastModifiedPlaylistName : Maybe String
+    , lastModifiedPlaylistName : Maybe { collection : Bool, name : String }
     }
     -> List IdentifiedTrack
     -> List (ContextMenu.Item Msg)
···
                 )
                 selectedPlaylist
 
-        maybeAddToLastModifiedPlaylist =
+        maybeAddToLastModifiedPlaylist { collection } =
             Maybe.andThen
-                (\n ->
-                    if Maybe.map .name selectedPlaylist /= Just n then
+                (\l ->
+                    if Maybe.map .name selectedPlaylist /= Just l.name && l.collection == collection then
                         justAnItem
                             { icon = Icons.waves
-                            , label = "Add to \"" ++ n ++ "\""
+                            , label = "Add to \"" ++ l.name ++ "\""
                             , msg =
                                 AddTracksToPlaylist
-                                    { playlistName = n
+                                    { collection = collection
+                                    , playlistName = l.name
                                     , tracks = Tracks.toPlaylistTracks tracks
                                     }
 
···
         -----------------------------------------
         Just playlist ->
             Maybe.values
-                [ justAnItem
+                [ maybeAddToLastModifiedPlaylist { collection = True }
+                , justAnItem
                     { icon = Icons.waves
-                    , label = "Remove from playlist"
+                    , label =
+                        if playlist.collection then
+                            "Remove from collection"
+
+                        else
+                            "Remove from playlist"
                     , msg = RemoveTracksFromPlaylist playlist tracks
 
                     --
                     , active = False
                     }
-                , maybeAddToLastModifiedPlaylist
                 , justAnItem
                     { icon = Icons.waves
-                    , label = "Add to another playlist"
+                    , label =
+                        if playlist.collection then
+                            "Add to another collection"
+
+                        else
+                            "Add to playlist"
+                    , msg = AssistWithAddingTracksToCollection tracks
+
+                    --
+                    , active = False
+                    }
+                , maybeAddToLastModifiedPlaylist { collection = False }
+                , justAnItem
+                    { icon = Icons.waves
+                    , label =
+                        if playlist.collection then
+                            "Add to playlist"
+
+                        else
+                            "Add to another playlist"
                     , msg = AssistWithAddingTracksToPlaylist tracks
 
                     --
···
         -----------------------------------------
         _ ->
             Maybe.values
-                [ maybeAddToLastModifiedPlaylist
+                [ maybeAddToLastModifiedPlaylist { collection = True }
+                , justAnItem
+                    { icon = Icons.waves
+                    , label = "Add to collection"
+                    , msg = AssistWithAddingTracksToCollection tracks
+                    , active = False
+                    }
+                , maybeAddToLastModifiedPlaylist { collection = False }
                 , justAnItem
                     { icon = Icons.waves
                     , label = "Add to playlist"

src/Core/UI/Types.elm

···
 import LastFm
 import Management
 import Notifications exposing (Notification)
-import Playlists exposing (Playlist, PlaylistTrack)
+import Playlists exposing (Playlist, PlaylistTrack, PlaylistTrackWithoutMetadata)
 import Queue
 import Random
 import Sources exposing (Source)
···
     -- Playlists
     -----------------------------------------
     , editPlaylistContext : Maybe { oldName : String, newName : String }
-    , lastModifiedPlaylist : Maybe String
+    , lastModifiedPlaylist : Maybe { collection : Bool, name : String }
     , newPlaylistContext : Maybe String
     , playlists : List Playlist
     , playlistToActivate : Maybe String
···
       -- Playlists
       -----------------------------------------
     | ActivatePlaylist Playlist
-    | AddTracksToPlaylist { playlistName : String, tracks : List PlaylistTrack }
+    | AddTracksToPlaylist { collection : Bool, playlistName : String, tracks : List PlaylistTrackWithoutMetadata }
+    | AssistWithAddingTracksToCollection (List IdentifiedTrack)
     | AssistWithAddingTracksToPlaylist (List IdentifiedTrack)
     | AssistWithSelectingPlaylist
+    | CreateCollection
     | CreatePlaylist
     | DeactivatePlaylist
     | DeletePlaylist { playlistName : String }

src/Library/Playlists.elm

···
 module Playlists exposing (..)
 
+import Time
+
+
+
 -- 🌳
 
 
 type alias Playlist =
     { autoGenerated : Maybe { level : Int }
+    , collection : Bool
     , name : String
     , public : Bool
     , tracks : List PlaylistTrack
     }
 
 
+type alias PlaylistTrackWithoutMetadata =
+    { album : Maybe String
+    , artist : Maybe String
+    , title : String
+    }
+
+
 type alias PlaylistTrack =
     { album : Maybe String
     , artist : Maybe String
     , title : String
+
+    --
+    , insertedAt : Time.Posix
     }
 
 

src/Library/Playlists/Encoding.elm

···
 import Json.Decode.Ext as Decode
 import Json.Encode as Encode
 import Json.Encode.Ext exposing (..)
-import Maybe.Extra as Maybe exposing (isJust)
+import Maybe.Extra as Maybe
 import Playlists exposing (..)
+import Time.Ext as Time
 
 
 
···
                 Nothing ->
                     Encode.null
           )
+        , ( "collection", Encode.bool playlist.collection )
         , ( "name", Encode.string playlist.name )
         , ( "public", Encode.bool playlist.public )
         , ( "tracks", Encode.list encodePlaylistTrack playlist.tracks )
···
         [ ( "album", encodeMaybe playlistTrack.album Encode.string )
         , ( "artist", encodeMaybe playlistTrack.artist Encode.string )
         , ( "title", Encode.string playlistTrack.title )
+
+        --
+        , ( "insertAt", Time.encode playlistTrack.insertedAt )
         ]
 
 
···
 
 decoder : Decode.Decoder Playlist
 decoder =
-    Decode.map4 Playlist
+    Decode.map5 Playlist
         (Decode.field "autoGenerated" <| Decode.maybe <| Decode.map (\l -> { level = l }) <| Decode.field "level" Decode.int)
+        (Decode.optionalField "collection" Decode.bool False)
         (Decode.field "name" Decode.string)
         (Decode.optionalField "public" Decode.bool False)
         (Decode.field "tracks" <| Decode.list playlistTrackDecoder)
···
 
 playlistTrackDecoder : Decode.Decoder PlaylistTrack
 playlistTrackDecoder =
-    Decode.map3 PlaylistTrack
+    Decode.map4 PlaylistTrack
         (Decode.maybe <| Decode.field "album" Decode.string)
         (Decode.maybe <| Decode.field "artist" Decode.string)
         (Decode.field "title" Decode.string)
+        (Decode.optionalField "insertedAt" Time.decoder Time.default)

src/Library/Playlists/Matching.elm

···
     List.foldl
         (\( i, t ) ( identifiedTracks, remainingPlaylistTracks ) ->
             let
-                imaginaryPlaylistTrack =
+                im =
                     { album = t.tags.album
                     , artist = t.tags.artist
                     , title = t.tags.title
···
                 ( matches, remainingPlaylistTracksWithoutMatches ) =
                     List.foldl
                         (\( pi, pt ) ->
-                            if imaginaryPlaylistTrack == pt then
+                            if im.title == pt.title && im.album == pt.album && im.artist == pt.artist then
                                 Tuple.mapBoth
                                     ((::) ( playlistTrackIdentifiers i pi, t ))
                                     identity

src/Library/Tracks.elm

···
 import Base64
 import List.Extra as List
 import Maybe.Extra as Maybe
-import Playlists exposing (Playlist, PlaylistTrack)
+import Playlists exposing (Playlist, PlaylistTrack, PlaylistTrackWithoutMetadata)
 import String.Ext as String
 import Time
 import Time.Ext as Time
···
         |> Maybe.withDefault False
 
 
-playlistTrackFromTrack : Track -> PlaylistTrack
+playlistTrackFromTrack : Track -> PlaylistTrackWithoutMetadata
 playlistTrackFromTrack track =
     { album = track.tags.album
     , artist = track.tags.artist
···
     }
 
 
-toPlaylistTracks : List IdentifiedTrack -> List PlaylistTrack
+toPlaylistTracks : List IdentifiedTrack -> List PlaylistTrackWithoutMetadata
 toPlaylistTracks =
     List.map (Tuple.second >> playlistTrackFromTrack)