« get me outta code hell

generateAlbumGalleryTrackGrid.js « dependencies « content « src - hsmusic-wiki - HSMusic - static wiki software cataloguing collaborative creation
about summary refs log tree commit diff
path: root/src/content/dependencies/generateAlbumGalleryTrackGrid.js
blob: 85e7576c4fe012ba54898e9be9dcff13c64fddc3 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
import {compareArrays, stitchArrays} from '#sugar';

export default {
  contentDependencies: [
    'generateAlbumGalleryCoverArtistsLine',
    'generateCoverGrid',
    'image',
    'linkAlbum',
    'linkTrack',
  ],

  extraDependencies: ['html', 'language'],

  query(album, label) {
    const query = {};

    query.artworks =
      album.tracks.map(track =>
        track.trackArtworks.find(artwork => artwork.label === label) ??
        null);

    const presentArtworks =
      query.artworks.filter(Boolean);

    if (presentArtworks.length > 1) {
      const allArtistArrays =
        presentArtworks
          .map(artwork => artwork.artistContribs
            .map(contrib => contrib.artist));

      const allSameArtists =
        allArtistArrays
          .slice(1)
          .every(artists => compareArrays(artists, allArtistArrays[0]));

      if (allSameArtists) {
        query.artistsForAllTrackArtworks =
          allArtistArrays[0];
      }
    }

    return query;
  },

  relations: (relation, query, album, _label) => ({
    coverArtistsLine:
      (query.artistsForAllTrackArtworks
        ? relation('generateAlbumGalleryCoverArtistsLine',
            query.artistsForAllTrackArtworks)
        : null),

    coverGrid:
      relation('generateCoverGrid'),

    albumLink:
      relation('linkAlbum', album),

    trackLinks:
      album.tracks
        .map(track => relation('linkTrack', track)),

    images:
      query.artworks
        .map(artwork => relation('image', artwork)),
  }),

  data: (query, album, _label) => ({
    trackNames:
      album.tracks
        .map(track => track.name),

    trackArtworkArtists:
      query.artworks.map(artwork =>
        (query.artistsForAllTrackArtworks
          ? null
       : artwork
          ? artwork.artistContribs
              .map(contrib => contrib.artist.name)
          : null)),
  }),

  slots: {
    attributes: {type: 'attributes', mutable: false},
  },

  generate: (data, relations, slots, {html, language}) =>
    html.tag('div',
      {[html.onlyIfContent]: true},

      slots.attributes,

      [
        relations.coverArtistsLine,

        relations.coverGrid.slots({
          links:
            relations.trackLinks,

          names:
            data.trackNames,

          images:
            stitchArrays({
              image: relations.images,
              name: data.trackNames,
            }).map(({image, name}) =>
                image.slots({
                  missingSourceContent:
                    language.$('misc.albumGalleryGrid.noCoverArt', {name}),
                })),

          info:
            data.trackArtworkArtists.map(artists =>
              language.$('misc.coverGrid.details.coverArtists', {
                [language.onlyIfOptions]: ['artists'],

                artists:
                  language.formatUnitList(artists),
              })),
        }),
      ]),
};