chore: adjust elm-review to new dev env

Justfile

···
 SYSTEM_DIR      := "./system"
 
 ESBUILD         := "node system/Js/esbuild.mjs"
+ELM_REVIEW      := NPM_DIR + "/.bin/elm-review " + SRC_DIR + " --config system/Review --compiler " + NPM_DIR + "/.bin/elm --elm-format-path " + NPM_DIR + "/.bin/elm-format"
 
 
 default: dev
···
 	echo "> Running elm-format"
 	{{NPM_DIR}}/.bin/elm-format {{SRC_DIR}} --yes
 	echo "> Running elm-review"
-	{{NPM_DIR}}/.bin/elm-review {{SRC_DIR}} --config system/Review --fix-all
+	{{ELM_REVIEW}} --fix-all
 
 
 @quality: check-versions
 	echo "> Running es-lint"
 	{{NPM_DIR}}/.bin/eslint src/Javascript/**/*
 	echo "> Running elm-review"
-	{{NPM_DIR}}/.bin/elm-review {{SRC_DIR}} --config system/Review
+	{{ELM_REVIEW}}
 
 
 @server:

src/Applications/UI/Tracks/Covers.elm

···
 import Base64
 import Conditional exposing (ifThenElse)
 import Dict
-import List.Extra as List
 import Maybe.Extra as Maybe
 import Tracks exposing (..)
 

src/Applications/UI/Tracks/Scene/Covers.elm

···
         nowPlayingId =
             Maybe.unwrap "" (.identifiedTrack >> Tuple.second >> .id) nowPlaying
 
-        album =
-            cover.identifiedTrackCover
-                |> Tuple.second
-                |> .tags
-                |> .album
-
         missingTracks =
-          List.any
-            (Tuple.first >> .isMissing)
-            cover.tracks
+            List.any
+                (Tuple.first >> .isMissing)
+                cover.tracks
 
         maybeBlobUrlFromCache =
             cachedCovers
···
 
         missingTracks =
             List.any
-              (Tuple.first >> .isMissing)
-              cover.tracks
+                (Tuple.first >> .isMissing)
+                cover.tracks
     in
     brick
         (if clickable then
···
             , "pt-px"
             , "truncate"
             ]
-            [
-                case sortBy of
-                  Album ->
+            [ case sortBy of
+                Album ->
                     if missingTracks then
-                      text "Missing tracks"
+                        text "Missing tracks"
 
                     else
-                      text (Maybe.withDefault "Unknown album" track.tags.album)
+                        text (Maybe.withDefault "Unknown album" track.tags.album)
 
-                  Artist ->
+                Artist ->
                     if missingTracks then
-                      text "Missing tracks"
+                        text "Missing tracks"
 
                     else
-                      text (Maybe.withDefault "Unknown artist" track.tags.artist)
+                        text (Maybe.withDefault "Unknown artist" track.tags.artist)
 
-                  _ ->
-                      nothing
+                _ ->
+                    nothing
             ]
 
         --
···
 
                     else if not missingTracks && Maybe.isJust track.tags.artist then
                         text (Maybe.withDefault "" track.tags.artist)
+
                     else
                         case List.length cover.trackIds of
                             1 ->
···
 
                             n ->
                                 text (String.fromInt n ++ " tracks")
-
 
                 Artist ->
                     case List.length cover.trackIds of

src/Library/Tracks.elm

···
 
 import Base64
 import List.Extra as List
+import Maybe.Extra as Maybe
 import Playlists exposing (Playlist, PlaylistTrack)
 import String.Ext as String
 import Time
 import Time.Ext as Time
-import Maybe.Extra as Maybe
 
 
 
···
     , scrollContext = ""
     }
 
+
 {-| If a track doesn't fit into a group, where does it go?
 -}
 fallbackCoverGroup : String
 fallbackCoverGroup =
-  "MISSING_TRACK_INFO"
+    "MISSING_TRACK_INFO"
+
 
 {-| This value is used as a fallback in the UI if the album is missing.
 -}
 fallbackAlbum : String
 fallbackAlbum =
-  ""
+    ""
+
 
 {-| This value is used as a fallback in the UI if the artist is missing.
 -}
 fallbackArtist : String
 fallbackArtist =
-  ""
+    ""
+
 
 
 -- MORE STUFF
···
 coverGroup : SortBy -> IdentifiedTrack -> String
 coverGroup sort ( identifiers, { tags } as track ) =
     if identifiers.isMissing then
-      "MISSING_TRACKS"
+        "MISSING_TRACKS"
+
     else
-    (case sort of
-        Artist ->
-            Maybe.unwrap fallbackCoverGroup (String.trim >> String.toLower) tags.artist
+        case sort of
+            Artist ->
+                Maybe.unwrap fallbackCoverGroup (String.trim >> String.toLower) tags.artist
 
-        Album ->
-            -- There is the possibility of albums with the same name,
-            -- such as "Greatests Hits".
-            -- To make sure we treat those as different albums,
-            -- we prefix the album by its parent directory.
+            Album ->
+                -- There is the possibility of albums with the same name,
+                -- such as "Greatests Hits".
+                -- To make sure we treat those as different albums,
+                -- we prefix the album by its parent directory.
+                case tags.album of
+                    Just album ->
+                        (identifiers.parentDirectory ++ album)
+                            |> String.trim
+                            |> String.toLower
 
-            case tags.album of
-              Just album ->
-                (identifiers.parentDirectory ++ album)
-                  |> String.trim
-                  |> String.toLower
-              Nothing ->
-                fallbackCoverGroup
-
-        PlaylistIndex ->
-            ""
+                    Nothing ->
+                        fallbackCoverGroup
 
-        Title ->
-            tags.title
-    )
+            PlaylistIndex ->
+                ""
 
+            Title ->
+                tags.title
 
 
 coverKey : Bool -> Track -> String
 coverKey isVariousArtists { tags } =
-      if isVariousArtists then
-          Maybe.withDefault "?" tags.album
+    if isVariousArtists then
+        Maybe.withDefault "?" tags.album
 
-      else
-          Maybe.withDefault "?" tags.artist ++ " --- " ++ Maybe.withDefault "?" tags.album
+    else
+        Maybe.withDefault "?" tags.artist ++ " --- " ++ Maybe.withDefault "?" tags.album
 
 
 isNowPlaying : IdentifiedTrack -> IdentifiedTrack -> Bool

src/Library/Tracks/Collection/Internal/Identify.elm

···
 
 import Dict
 import List.Extra as List
-import Maybe.Extra as Maybe
 import Time.Ext as Time
 import Tracks exposing (..)
-import Tracks.Favourites as Favourites
 
 
 

src/Library/Tracks/Favourites.elm

···
 
 import List.Extra as List
 import Maybe.Extra as Maybe
-import Tracks exposing (Favourite, IdentifiedTrack, Track)
-import Tracks exposing (fallbackArtist)
+import Tracks exposing (Favourite, IdentifiedTrack, Track, fallbackArtist)
 
 
 

src/Library/Tracks/Sorting.elm

···
 nr =
     .tags >> .nr
 
+
 isMissing : Identifiers -> Bool
 isMissing =
     .isMissing
···
     else
         order
 
+
 andThenCompareBools : (ctx -> Bool) -> ctx -> ctx -> Order -> Order
 andThenCompareBools fn a b order =
     if order == EQ then
         let
-          af = fn a
-          bf = fn b
+            af =
+                fn a
+
+            bf =
+                fn b
         in
         if af == bf then
-          EQ
+            EQ
+
         else if af == False then
-          GT
-        else
-          LT
+            GT
 
+        else
+            LT
 
     else
         order