« get me outta code hell

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

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

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

  relations(relation, track) {
    function getScopedRelations(album) {
      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});
            },
          }),
      };
    }

    return {
      scopeSwitcher:
        relation('generateChronologyLinksScopeSwitcher'),

      wiki:
        getScopedRelations(null),

      album:
        getScopedRelations(track.album),
    };
  },

  generate(relations) {
    function slotScopedRelations(scope) {
      return scope.chronologyLinks.slots({
        showOnly: true,

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

    return relations.scopeSwitcher.slots({
      scopes: [
        'wiki',
        'album',
      ],

      contents: [
        slotScopedRelations(relations.wiki),
        slotScopedRelations(relations.album),
      ],
    });
  },
};