« get me outta code hell

linkThing.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/linkThing.js
blob: 320368a81e9e53387528d236ced5884ec14846a2 (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
export default {
  contentDependencies: ['linkTemplate'],
  extraDependencies: ['getColors', 'html', 'language'],

  relations: (relation) => ({
    linkTemplate:
      relation('linkTemplate'),
  }),

  data: (pathKey, thing) => ({
    name: thing.name,
    nameShort: thing.nameShort ?? thing.shortName,

    color: thing.color,

    path:
      (pathKey
        ? [pathKey, thing.directory]
        : null),
  }),

  slots: {
    content: {type: 'html'},

    preferShortName: {type: 'boolean', default: false},

    tooltip: {
      validate: v => v.oneOf(v.isBoolean, v.isHTML),
      default: false,
    },

    color: {
      validate: v => v.oneOf(v.isBoolean, v.isColor),
      default: true,
    },

    colorContext: {
      validate: v => v.is(
        'primary-only'),

      default: 'primary-only',
    },

    path: {
      validate: v => v.validateArrayItems(v.isString),
    },

    anchor: {type: 'boolean', default: false},
    linkless: {type: 'boolean', default: false},

    attributes: {type: 'attributes'},
    hash: {type: 'string'},
  },

  generate(data, relations, slots, {getColors, html, language}) {
    const {attributes} = slots;

    const path =
      slots.path ?? data.path;

    const name =
      (slots.preferShortName
        ? data.nameShort ?? data.name ?? null
        : data.name ?? null);

    const content =
      (html.isBlank(slots.content)
        ? language.sanitize(name)
        : slots.content);

    if (slots.color !== false) addColor: {
      const color =
        (typeof slots.color === 'string'
          ? slots.color
          : data.color);

      if (!color) {
        break addColor;
      }

      let selectColors;

      switch (slots.colorContext) {
        case 'primary-only':
          selectColors = {
            '--primary-color': 'primary',
          };
          break;

        default:
          break addColor;
      }

      const colors = getColors(color);
      const selectedColors = [];

      for (const [variable, key] of Object.entries(selectColors)) {
        selectedColors.push(`${variable}: ${colors[key]}`);
      }

      attributes.add('style', selectedColors);
    }

    let tooltip = null;
    if (slots.tooltip === true) {
      tooltip = name;
    } else if (typeof slots.tooltip === 'string') {
      tooltip = slots.tooltip;
    }

    return relations.linkTemplate
      .slots({
        path: slots.anchor ? [] : path,
        href: slots.anchor ? '' : null,
        content,
        tooltip,
        attributes,
        hash: slots.hash,
        linkless: slots.linkless,
      });
  },
}