« get me outta code hell

generateScopedTrackChronologyLinks.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/generateScopedTrackChronologyLinks.js
blob: fb43203b5f1c71765edaf28dde797f0edd678d97 (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
import {sortAlbumsTracksChronologically} from '#sort';

import getChronologyRelations from '../util/getChronologyRelations.js';

export default {
  contentDependencies: [
    'generateChronologyLinks',
    'linkAlbum',
    'linkArtist',
    'linkTrack',
  ],

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

  relations(relation, album, track) {
    const albumFilter =
      (album
        ? track => track.album === album
        : () => true);

    return {
      chronologyLinks:
        relation('generateChronologyLinks'),

      artistChronologyContributions:
        getChronologyRelations(track, {
          contributions: [
            ...track.artistContribs ?? [],
            ...track.contributorContribs ?? [],
          ],

          linkArtist: artist => relation('linkArtist', artist),
          linkThing: track => relation('linkTrack', track),

          getThings(artist) {
            const getDate = thing => thing.date;

            const things =
              ([
                ...artist.tracksAsArtist,
                ...artist.tracksAsContributor,
              ]).filter(getDate)
                .filter(albumFilter);

            return sortAlbumsTracksChronologically(things, {getDate});
          },
        }),

      coverArtistChronologyContributions:
        getChronologyRelations(track, {
          contributions: track.coverArtistContribs ?? [],

          linkArtist: artist => relation('linkArtist', artist),

          linkThing: trackOrAlbum =>
            (trackOrAlbum.album
              ? relation('linkTrack', trackOrAlbum)
              : relation('linkAlbum', trackOrAlbum)),

          getThings(artist) {
            const getDate = thing => thing.coverArtDate ?? thing.date;

            const things =
              ([
                ...artist.albumsAsCoverArtist,
                ...artist.tracksAsCoverArtist,
              ]).filter(getDate)
                .filter(albumFilter);

            return sortAlbumsTracksChronologically(things, {getDate});
          },
        }),
    };
  },

  slots: {
    scope: {
      validate: v => v.is('wiki', 'album'),
    },

    visible: {type: 'boolean'},
  },

  generate: (relations, slots, {html, language}) =>
    html.tag('div', {class: 'scoped-chronology'},
      {class: 'scope-' + slots.scope},
      slots.visible && {style: 'display: block'},

      [
        html.tag('p',
          language.$('trackPage.nav.chronology.scope', {
            scope:
              html.tag('a', {class: 'scoped-chronology-switcher'},
                {href: '#'},
                language.$('trackPage.nav.chronology.scope', slots.scope)),
          })),

        relations.chronologyLinks.slots({
          chronologyInfoSets: [
            {
              headingString: 'misc.chronology.heading.track',
              contributions: relations.artistChronologyContributions,
            },
            {
              headingString: 'misc.chronology.heading.coverArt',
              contributions: relations.coverArtistChronologyContributions,
            },
          ],
        }),
      ]),
};