1 files changed, 166 insertions, 60 deletions

diff --git a/src/content/dependencies/generateAlbumSidebar.js b/src/content/dependencies/generateAlbumSidebar.js
index 5ef4501b..a8190521 100644
--- a/src/content/dependencies/generateAlbumSidebar.js
+++ b/src/content/dependencies/generateAlbumSidebar.js
@@ -1,79 +1,185 @@
+import {sortAlbumsTracksChronologically} from '#sort';
+import {stitchArrays, transposeArrays} from '#sugar';
+
 export default {
   contentDependencies: [
     'generateAlbumSidebarGroupBox',
-    'generateAlbumSidebarTrackSection',
-    'linkAlbum',
+    'generateAlbumSidebarSeriesBox',
+    'generateAlbumSidebarTrackListBox',
+    'generatePageSidebar',
+    'generatePageSidebarConjoinedBox',
+    'generateTrackReleaseBox',
   ],
 
-  extraDependencies: ['html'],
+  extraDependencies: ['html', 'wikiData'],
 
-  relations(relation, album, track) {
-    const relations = {};
+  sprawl: ({groupData}) => ({
+    // TODO: Series aren't their own things, so we access them weirdly.
+    seriesData:
+      groupData.flatMap(group => group.serieses),
+  }),
 
-    relations.albumLink =
-      relation('linkAlbum', album);
+  query(sprawl, album, track) {
+    const query = {};
 
-    relations.groupBoxes =
-      album.groups.map(group =>
-        relation('generateAlbumSidebarGroupBox', album, group));
+    query.groups =
+      album.groups;
 
-    relations.trackSections =
-      album.trackSections.map(trackSection =>
-        relation('generateAlbumSidebarTrackSection', album, track, trackSection));
+    query.groupSerieses =
+      query.groups
+        .map(group =>
+          group.serieses
+            .filter(series => series.albums.includes(album)));
 
-    return relations;
-  },
+    query.disconnectedSerieses =
+      sprawl.seriesData
+        .filter(series =>
+          series.albums.includes(album) &&
+          !query.groups.includes(series.group));
+
+    if (track) {
+      const albumTrackMap =
+        new Map(transposeArrays([
+          track.allReleases.map(t => t.album),
+          track.allReleases,
+        ]));
+
+      const allReleaseAlbums =
+        sortAlbumsTracksChronologically(
+          Array.from(albumTrackMap.keys()),
+          {getDate: album => albumTrackMap.get(album).date});
+
+      const currentReleaseIndex =
+        allReleaseAlbums.indexOf(track.album);
+
+      const earlierReleaseAlbums =
+        allReleaseAlbums.slice(0, currentReleaseIndex);
+
+      const laterReleaseAlbums =
+        allReleaseAlbums.slice(currentReleaseIndex + 1);
 
-  data(album, track) {
-    return {isAlbumPage: !track};
+      query.earlierReleaseTracks =
+        earlierReleaseAlbums.map(album => albumTrackMap.get(album));
+
+      query.laterReleaseTracks =
+        laterReleaseAlbums.map(album => albumTrackMap.get(album));
+    }
+
+    return query;
   },
 
+  relations: (relation, query, _sprawl, album, track) => ({
+    sidebar:
+      relation('generatePageSidebar'),
+
+    conjoinedBox:
+      relation('generatePageSidebarConjoinedBox'),
+
+    trackListBox:
+      relation('generateAlbumSidebarTrackListBox', album, track),
+
+    groupBoxes:
+      query.groups
+        .map(group =>
+          relation('generateAlbumSidebarGroupBox', album, group)),
+
+    seriesBoxes:
+      query.groupSerieses
+        .map(serieses => serieses
+          .map(series =>
+            relation('generateAlbumSidebarSeriesBox', album, series))),
+
+    disconnectedSeriesBoxes:
+      query.disconnectedSerieses
+        .map(series =>
+          relation('generateAlbumSidebarSeriesBox', album, series)),
+
+    earlierTrackReleaseBoxes:
+      (track
+        ? query.earlierReleaseTracks
+            .map(track =>
+              relation('generateTrackReleaseBox', track))
+        : null),
+
+    laterTrackReleaseBoxes:
+      (track
+        ? query.laterReleaseTracks
+            .map(track =>
+              relation('generateTrackReleaseBox', track))
+        : null),
+  }),
+
+  data: (_query, _sprawl, album, track) => ({
+    isAlbumPage: !track,
+    isTrackPage: !!track,
+
+    albumStyle: album.style,
+  }),
+
   generate(data, relations, {html}) {
-    const trackListBox = {
-      class: 'track-list-sidebar-box',
-      content:
-        html.tags([
-          html.tag('h1', relations.albumLink),
-          relations.trackSections,
-        ]),
-    };
-
-    if (data.isAlbumPage) {
-      const groupBoxes =
-        relations.groupBoxes
-          .map(content => ({
-            class: 'individual-group-sidebar-box',
-            content: content.slot('mode', 'album'),
-          }));
-
-      return {
-        leftSidebarMultiple: [
-          ...groupBoxes,
-          trackListBox,
-        ],
-      };
+    const presentGroupsLikeAlbum =
+      data.isAlbumPage ||
+      data.albumStyle === 'single';
+
+    for (const box of [
+      ...relations.groupBoxes,
+      ...relations.seriesBoxes.flat(),
+      ...relations.disconnectedSeriesBoxes,
+    ]) {
+      box.setSlot('mode', presentGroupsLikeAlbum ? 'album' : 'track');
     }
 
-    const conjoinedGroupBox = {
-      class: 'conjoined-group-sidebar-box',
-      content:
-        relations.groupBoxes
-          .flatMap((content, i, {length}) => [
-            content.slot('mode', 'track'),
-            i < length - 1 &&
-              html.tag('hr', {
-                style: `border-color: var(--primary-color); border-style: none none dotted none`
-              }),
-          ])
-          .filter(Boolean),
-    };
-
-    return {
-      // leftSidebarStickyMode: 'column',
-      leftSidebarMultiple: [
-        trackListBox,
-        conjoinedGroupBox,
+    const groupBoxes =
+      (presentGroupsLikeAlbum
+        ? [
+            relations.disconnectedSeriesBoxes,
+
+            stitchArrays({
+              groupBox: relations.groupBoxes,
+              seriesBoxes: relations.seriesBoxes,
+            }).map(({groupBox, seriesBoxes}) => [
+                groupBox,
+                seriesBoxes.map(seriesBox => [
+                  html.tag('div',
+                    {class: 'sidebar-box-joiner'},
+                    {class: 'collapsible'}),
+                  seriesBox,
+                ]),
+              ]),
+          ]
+        : [
+            relations.conjoinedBox.slots({
+              attributes: {class: 'conjoined-group-sidebar-box'},
+              boxes:
+                ([relations.disconnectedSeriesBoxes,
+                  stitchArrays({
+                    groupBox: relations.groupBoxes,
+                    seriesBoxes: relations.seriesBoxes,
+                  }).flatMap(({groupBox, seriesBoxes}) => [
+                      groupBox,
+                      ...seriesBoxes,
+                    ]),
+                ]).flat()
+                  .map(box => box.content), /* TODO: Kludge. */
+            })
+          ]);
+
+    return relations.sidebar.slots({
+      boxes: [
+        data.isAlbumPage &&
+          groupBoxes,
+
+        data.isTrackPage &&
+          relations.earlierTrackReleaseBoxes,
+
+        relations.trackListBox,
+
+        data.isTrackPage &&
+          relations.laterTrackReleaseBoxes,
+
+        data.isTrackPage &&
+          groupBoxes,
       ],
-    };
+    });
   },
 };