From 15b0b5422a3de8da52e14666909418405bdb8c39 Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Fri, 8 Sep 2023 16:09:16 -0300
Subject: data: update commentatorArtists

---
 src/data/things/thing.js | 55 +++++++++++++++++++++++++++++-------------------
 1 file changed, 33 insertions(+), 22 deletions(-)

diff --git a/src/data/things/thing.js b/src/data/things/thing.js
index 79d8ae0e..9e7f940f 100644
--- a/src/data/things/thing.js
+++ b/src/data/things/thing.js
@@ -5,7 +5,7 @@ import {inspect} from 'node:util';
 
 import {colors} from '#cli';
 import find from '#find';
-import {empty, stitchArrays} from '#sugar';
+import {empty, stitchArrays, unique} from '#sugar';
 import {filterMultipleArrays, getKebabCase} from '#wiki-data';
 
 import {
@@ -334,29 +334,40 @@ export function wikiData(thingClass) {
 // This one's kinda tricky: it parses artist "references" from the
 // commentary content, and finds the matching artist for each reference.
 // This is mostly useful for credits and listings on artist pages.
-export function commentatorArtists(){
-  return {
-    flags: {expose: true},
+export function commentatorArtists() {
+  return compositeFrom(`commentatorArtists`, [
+    exitWithoutDependency({dependency: 'commentary', mode: 'falsy', value: []}),
 
-    expose: {
-      dependencies: ['artistData', 'commentary'],
-
-      compute: ({artistData, commentary}) =>
-        artistData && commentary
-          ? Array.from(
-              new Set(
-                Array.from(
-                  commentary
-                    .replace(/<\/?b>/g, '')
-                    .matchAll(/<i>(?<who>.*?):<\/i>/g)
-                ).map(({groups: {who}}) =>
-                  find.artist(who, artistData, {mode: 'quiet'})
-                )
-              )
-            )
-          : [],
+    {
+      dependencies: ['commentary'],
+      compute: ({commentary}, continuation) =>
+        continuation({
+          '#artistRefs':
+            Array.from(
+              commentary
+                .replace(/<\/?b>/g, '')
+                .matchAll(/<i>(?<who>.*?):<\/i>/g))
+              .map(({groups: {who}}) => who),
+        }),
     },
-  };
+
+    withResolvedReferenceList({
+      list: '#artistRefs',
+      data: 'artistData',
+      into: '#artists',
+      find: find.artist,
+    }),
+
+    {
+      flags: {expose: true},
+
+      expose: {
+        dependencies: ['#artists'],
+        compute: ({'#artists': artists}) =>
+          unique(artists),
+      },
+    },
+  ]);
 }
 
 // Compositional utilities
-- 
cgit 1.3.0-6-gf8a5


From f39164ed44fe5c86f1f1911514d38a5549e51f92 Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Fri, 8 Sep 2023 16:17:05 -0300
Subject: data: rearrange track properties

---
 src/data/things/track.js | 153 +++++++++++++++++++++++------------------------
 1 file changed, 75 insertions(+), 78 deletions(-)

diff --git a/src/data/things/track.js b/src/data/things/track.js
index 8263d399..0cd39dca 100644
--- a/src/data/things/track.js
+++ b/src/data/things/track.js
@@ -62,12 +62,6 @@ export class Track extends Thing {
     urls: urls(),
     dateFirstReleased: simpleDate(),
 
-    artTags: referenceList({
-      class: ArtTag,
-      find: find.artTag,
-      data: 'artTagData',
-    }),
-
     color: compositeFrom(`Track.color`, [
       exposeUpdateValueOrContinue(),
       withContainingTrackSection(),
@@ -139,90 +133,28 @@ export class Track extends Thing {
       }),
     ]),
 
+    commentary: commentary(),
+    lyrics: simpleString(),
+
+    additionalFiles: additionalFiles(),
+    sheetMusicFiles: additionalFiles(),
+    midiProjectFiles: additionalFiles(),
+
     originalReleaseTrack: singleReference({
       class: Track,
       find: find.track,
       data: 'trackData',
     }),
 
-    // Note - this is an internal property used only to help identify a track.
-    // It should not be assumed in general that the album and dataSourceAlbum match
-    // (i.e. a track may dynamically be moved from one album to another, at
-    // which point dataSourceAlbum refers to where it was originally from, and is
-    // not generally relevant information). It's also not guaranteed that
-    // dataSourceAlbum is available (depending on the Track creator to optionally
-    // provide this property's update value).
+    // Internal use only - for directly identifying an album inside a track's
+    // util.inspect display, if it isn't indirectly available (by way of being
+    // included in an album's track list).
     dataSourceAlbum: singleReference({
       class: Album,
       find: find.album,
       data: 'albumData',
     }),
 
-    commentary: commentary(),
-    lyrics: simpleString(),
-    additionalFiles: additionalFiles(),
-    sheetMusicFiles: additionalFiles(),
-    midiProjectFiles: additionalFiles(),
-
-    // Update only
-
-    albumData: wikiData(Album),
-    artistData: wikiData(Artist),
-    artTagData: wikiData(ArtTag),
-    flashData: wikiData(Flash),
-    trackData: wikiData(Track),
-
-    // Expose only
-
-    commentatorArtists: commentatorArtists(),
-
-    album: compositeFrom(`Track.album`, [
-      withAlbum(),
-      exposeDependency({dependency: '#album'}),
-    ]),
-
-    date: compositeFrom(`Track.date`, [
-      exposeDependencyOrContinue({dependency: 'dateFirstReleased'}),
-      withAlbumProperty({property: 'date'}),
-      exposeDependency({dependency: '#album.date'}),
-    ]),
-
-    // Whether or not the track has "unique" cover artwork - a cover which is
-    // specifically associated with this track in particular, rather than with
-    // the track's album as a whole. This is typically used to select between
-    // displaying the track artwork and a fallback, such as the album artwork
-    // or a placeholder. (This property is named hasUniqueCoverArt instead of
-    // the usual hasCoverArt to emphasize that it does not inherit from the
-    // album.)
-    hasUniqueCoverArt: compositeFrom(`Track.hasUniqueCoverArt`, [
-      withHasUniqueCoverArt(),
-      exposeDependency({dependency: '#hasUniqueCoverArt'}),
-    ]),
-
-    otherReleases: compositeFrom(`Track.otherReleases`, [
-      exitWithoutDependency({dependency: 'trackData', mode: 'empty'}),
-      withOriginalRelease({selfIfOriginal: true}),
-
-      {
-        flags: {expose: true},
-        expose: {
-          dependencies: ['this', 'trackData', '#originalRelease'],
-          compute: ({
-            this: thisTrack,
-            trackData,
-            '#originalRelease': originalRelease,
-          }) =>
-            (originalRelease === thisTrack
-              ? []
-              : [originalRelease])
-              .concat(trackData.filter(track =>
-                track !== originalRelease &&
-                track !== thisTrack &&
-                track.originalReleaseTrack === originalRelease)),
-        },
-      },
-    ]),
-
     artistContribs: compositeFrom(`Track.artistContribs`, [
       inheritFromOriginalRelease({property: 'artistContribs'}),
 
@@ -283,6 +215,71 @@ export class Track extends Thing {
       }),
     ]),
 
+    artTags: referenceList({
+      class: ArtTag,
+      find: find.artTag,
+      data: 'artTagData',
+    }),
+
+    // Update only
+
+    albumData: wikiData(Album),
+    artistData: wikiData(Artist),
+    artTagData: wikiData(ArtTag),
+    flashData: wikiData(Flash),
+    trackData: wikiData(Track),
+
+    // Expose only
+
+    commentatorArtists: commentatorArtists(),
+
+    album: compositeFrom(`Track.album`, [
+      withAlbum(),
+      exposeDependency({dependency: '#album'}),
+    ]),
+
+    date: compositeFrom(`Track.date`, [
+      exposeDependencyOrContinue({dependency: 'dateFirstReleased'}),
+      withAlbumProperty({property: 'date'}),
+      exposeDependency({dependency: '#album.date'}),
+    ]),
+
+    // Whether or not the track has "unique" cover artwork - a cover which is
+    // specifically associated with this track in particular, rather than with
+    // the track's album as a whole. This is typically used to select between
+    // displaying the track artwork and a fallback, such as the album artwork
+    // or a placeholder. (This property is named hasUniqueCoverArt instead of
+    // the usual hasCoverArt to emphasize that it does not inherit from the
+    // album.)
+    hasUniqueCoverArt: compositeFrom(`Track.hasUniqueCoverArt`, [
+      withHasUniqueCoverArt(),
+      exposeDependency({dependency: '#hasUniqueCoverArt'}),
+    ]),
+
+    otherReleases: compositeFrom(`Track.otherReleases`, [
+      exitWithoutDependency({dependency: 'trackData', mode: 'empty'}),
+      withOriginalRelease({selfIfOriginal: true}),
+
+      {
+        flags: {expose: true},
+        expose: {
+          dependencies: ['this', 'trackData', '#originalRelease'],
+          compute: ({
+            this: thisTrack,
+            trackData,
+            '#originalRelease': originalRelease,
+          }) =>
+            (originalRelease === thisTrack
+              ? []
+              : [originalRelease])
+              .concat(trackData.filter(track =>
+                track !== originalRelease &&
+                track !== thisTrack &&
+                track.originalReleaseTrack === originalRelease)),
+        },
+      },
+    ]),
+
     // Specifically exclude re-releases from this list - while it's useful to
     // get from a re-release to the tracks it references, re-releases aren't
     // generally relevant from the perspective of the tracks being referenced.
-- 
cgit 1.3.0-6-gf8a5


From e01b73d286fbb11ac8ded59b4c23738dff195171 Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Fri, 8 Sep 2023 16:22:10 -0300
Subject: data: dimensions utility

---
 src/data/things/album.js |  8 +++-----
 src/data/things/thing.js | 10 ++++++++++
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/data/things/album.js b/src/data/things/album.js
index 01f52c2d..5e281f06 100644
--- a/src/data/things/album.js
+++ b/src/data/things/album.js
@@ -1,6 +1,6 @@
 import find from '#find';
 import {stitchArrays} from '#sugar';
-import {isDate, isDimensions, isTrackSectionList} from '#validators';
+import {isDate, isTrackSectionList} from '#validators';
 
 import {
   compositeFrom,
@@ -19,6 +19,7 @@ import Thing, {
   commentatorArtists,
   contribsPresent,
   contributionList,
+  dimensions,
   directory,
   fileExtension,
   flag,
@@ -171,10 +172,7 @@ export class Album extends Thing {
 
     bannerStyle: simpleString(),
     bannerFileExtension: fileExtension('jpg'),
-    bannerDimensions: {
-      flags: {update: true, expose: true},
-      update: {validate: isDimensions},
-    },
+    bannerDimensions: dimensions(),
 
     hasTrackNumbers: flag(true),
     isListedOnHomepage: flag(true),
diff --git a/src/data/things/thing.js b/src/data/things/thing.js
index 9e7f940f..0484b589 100644
--- a/src/data/things/thing.js
+++ b/src/data/things/thing.js
@@ -25,6 +25,7 @@ import {
   isColor,
   isContributionList,
   isDate,
+  isDimensions,
   isDirectory,
   isFileExtension,
   isName,
@@ -122,6 +123,15 @@ export function fileExtension(defaultFileExtension = null) {
   };
 }
 
+// Plain ol' image dimensions. This is a two-item array of positive integers,
+// corresponding to width and height respectively.
+export function dimensions() {
+  return {
+    flags: {update: true, expose: true},
+    update: {validate: isDimensions},
+  };
+}
+
 // Straightforward flag descriptor for a variety of property purposes.
 // Provide a default value, true or false!
 export function flag(defaultValue = false) {
-- 
cgit 1.3.0-6-gf8a5


From cd3e2ae7384d82f0f2758beb0ae38ce0fe9f5e09 Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Fri, 8 Sep 2023 16:25:22 -0300
Subject: data: duration utility

---
 src/data/things/thing.js | 10 ++++++++++
 src/data/things/track.js |  8 ++------
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/data/things/thing.js b/src/data/things/thing.js
index 0484b589..169fc1ca 100644
--- a/src/data/things/thing.js
+++ b/src/data/things/thing.js
@@ -27,6 +27,7 @@ import {
   isDate,
   isDimensions,
   isDirectory,
+  isDuration,
   isFileExtension,
   isName,
   isString,
@@ -132,6 +133,15 @@ export function dimensions() {
   };
 }
 
+// Duration! This is a number of seconds, possibly floating point, always
+// at minimum zero.
+export function duration() {
+  return {
+    flags: {update: true, expose: true},
+    update: {validate: isDuration},
+  };
+}
+
 // Straightforward flag descriptor for a variety of property purposes.
 // Provide a default value, true or false!
 export function flag(defaultValue = false) {
diff --git a/src/data/things/track.js b/src/data/things/track.js
index 0cd39dca..53798cda 100644
--- a/src/data/things/track.js
+++ b/src/data/things/track.js
@@ -19,7 +19,6 @@ import {
   isColor,
   isContributionList,
   isDate,
-  isDuration,
   isFileExtension,
 } from '#validators';
 
@@ -31,6 +30,7 @@ import Thing, {
   commentatorArtists,
   contributionList,
   directory,
+  duration,
   flag,
   name,
   referenceList,
@@ -54,11 +54,7 @@ export class Track extends Thing {
     name: name('Unnamed Track'),
     directory: directory(),
 
-    duration: {
-      flags: {update: true, expose: true},
-      update: {validate: isDuration},
-    },
-
+    duration: duration(),
     urls: urls(),
     dateFirstReleased: simpleDate(),
 
-- 
cgit 1.3.0-6-gf8a5


From 6fe22802d8220b983a488f4efee1834bacbdb166 Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Fri, 8 Sep 2023 17:20:48 -0300
Subject: data: cleaner withResolvedReferenceList notFoundMode implementation

---
 src/data/things/thing.js | 42 +++++++++++++++++++++++++++++-------------
 1 file changed, 29 insertions(+), 13 deletions(-)

diff --git a/src/data/things/thing.js b/src/data/things/thing.js
index 169fc1ca..96ac9b12 100644
--- a/src/data/things/thing.js
+++ b/src/data/things/thing.js
@@ -514,29 +514,45 @@ export function withResolvedReferenceList({
     }),
 
     {
-      options: {findFunction, notFoundMode},
       mapDependencies: {list, data},
-      mapContinuation: {matches: into},
+      options: {findFunction},
 
-      compute({list, data, '#options': {findFunction, notFoundMode}}, continuation) {
-        let matches =
-          list.map(ref => findFunction(ref, data, {mode: 'quiet'}));
+      compute: ({list, data, '#options': {findFunction}}, continuation) =>
+        continuation({
+          '#matches': list.map(ref => findFunction(ref, data, {mode: 'quiet'})),
+        }),
+    },
 
-        if (matches.every(match => match)) {
-          return continuation.raise({matches});
-        }
+    {
+      dependencies: ['#matches'],
+      mapContinuation: {into},
 
-        switch (notFoundMode) {
-          case 'filter':
-            matches = matches.filter(match => match);
-            return continuation.raise({matches});
+      compute: ({'#matches': matches}, continuation) =>
+        (matches.every(match => match)
+          ? continuation.raise({into: matches})
+          : continuation()),
+    },
+
+    {
+      dependencies: ['#matches'],
+      options: {notFoundMode},
+      mapContinuation: {into},
 
+      compute({
+        '#matches': matches,
+        '#options': {notFoundMode},
+      }, continuation) {
+        switch (notFoundMode) {
           case 'exit':
             return continuation.exit([]);
 
+          case 'filter':
+            matches = matches.filter(match => match);
+            return continuation.raise({into: matches});
+
           case 'null':
             matches = matches.map(match => match ?? null);
-            return continuation.raise({matches});
+            return continuation.raise({into: matches});
         }
       },
     },
-- 
cgit 1.3.0-6-gf8a5


From c82784ebb4e5141bfe97664f3252303b3e833863 Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Sat, 9 Sep 2023 08:13:44 -0300
Subject: data: withPropertyFrom{Object,List}, fillMissingListItems utils

---
 src/data/things/album.js     |  66 +++++++++-------------
 src/data/things/composite.js | 127 +++++++++++++++++++++++++++++++++++++++++++
 src/data/things/thing.js     |  11 +---
 src/data/things/track.js     |  16 +-----
 4 files changed, 159 insertions(+), 61 deletions(-)

diff --git a/src/data/things/album.js b/src/data/things/album.js
index 5e281f06..288caa04 100644
--- a/src/data/things/album.js
+++ b/src/data/things/album.js
@@ -8,8 +8,11 @@ import {
   exitWithoutUpdateValue,
   exposeDependency,
   exposeUpdateValueOrContinue,
+  fillMissingListItems,
   withFlattenedArray,
+  withPropertyFromList,
   withUnflattenedArray,
+  withUpdateValueAsDependency,
 } from '#composite';
 
 import Thing, {
@@ -81,50 +84,35 @@ export class Album extends Thing {
       exitWithoutDependency({dependency: 'trackData', value: []}),
       exitWithoutUpdateValue({value: [], mode: 'empty'}),
 
-      {
-        transform: (trackSections, continuation) =>
-          continuation(trackSections, {
-            '#sectionTrackRefs':
-              trackSections.map(section => section.tracks),
-
-            '#sectionDateOriginallyReleased':
-              trackSections
-                .map(({dateOriginallyReleased}) => dateOriginallyReleased ?? null),
-
-            '#sectionIsDefaultTrackSection':
-              trackSections
-                .map(({isDefaultTrackSection}) => isDefaultTrackSection ?? false),
-          }),
-      },
+      withUpdateValueAsDependency({into: '#sections'}),
 
-      {
-        dependencies: ['color'],
-        transform: (trackSections, {color: albumColor}, continuation) =>
-          continuation(trackSections, {
-            '#sectionColor':
-              trackSections
-                .map(({color: sectionColor}) => sectionColor ?? albumColor),
-          }),
-      },
+      withPropertyFromList({list: '#sections', property: 'tracks', into: '#sections.trackRefs'}),
+      withPropertyFromList({list: '#sections', property: 'dateOriginallyReleased'}),
+      withPropertyFromList({list: '#sections', property: 'isDefaultTrackSection'}),
+      withPropertyFromList({list: '#sections', property: 'color'}),
+
+      fillMissingListItems({list: '#sections.trackRefs', value: []}),
+      fillMissingListItems({list: '#sections.isDefaultTrackSection', value: false}),
+      fillMissingListItems({list: '#sections.color', dependency: 'color'}),
 
       withFlattenedArray({
-        from: '#sectionTrackRefs',
+        from: '#sections.trackRefs',
         into: '#trackRefs',
-        intoIndices: '#sectionStartIndex',
+        intoIndices: '#sections.startIndex',
       }),
 
       withResolvedReferenceList({
         list: '#trackRefs',
         data: 'trackData',
-        mode: 'null',
+        notFoundMode: 'null',
         find: find.track,
         into: '#tracks',
       }),
 
       withUnflattenedArray({
         from: '#tracks',
-        fromIndices: '#sectionStartIndex',
-        into: '#sectionTracks',
+        fromIndices: '#sections.startIndex',
+        into: '#sections.tracks',
       }),
 
       {
@@ -134,19 +122,19 @@ export class Album extends Thing {
 
         expose: {
           dependencies: [
-            '#sectionTracks',
-            '#sectionColor',
-            '#sectionDateOriginallyReleased',
-            '#sectionIsDefaultTrackSection',
-            '#sectionStartIndex',
+            '#sections.tracks',
+            '#sections.color',
+            '#sections.dateOriginallyReleased',
+            '#sections.isDefaultTrackSection',
+            '#sections.startIndex',
           ],
 
           transform: (trackSections, {
-            '#sectionTracks': tracks,
-            '#sectionColor': color,
-            '#sectionDateOriginallyReleased': dateOriginallyReleased,
-            '#sectionIsDefaultTrackSection': isDefaultTrackSection,
-            '#sectionStartIndex': startIndex,
+            '#sections.tracks': tracks,
+            '#sections.color': color,
+            '#sections.dateOriginallyReleased': dateOriginallyReleased,
+            '#sections.isDefaultTrackSection': isDefaultTrackSection,
+            '#sections.startIndex': startIndex,
           }) =>
             stitchArrays({
               tracks,
diff --git a/src/data/things/composite.js b/src/data/things/composite.js
index 1f6482f6..a5adc3e9 100644
--- a/src/data/things/composite.js
+++ b/src/data/things/composite.js
@@ -1089,6 +1089,133 @@ export function withUpdateValueAsDependency({
   };
 }
 
+// Gets a property of some object (in a dependency) and provides that value.
+// If the object itself is null, the provided dependency will also always be
+// null. By default, it'll also be null if the object doesn't have the listed
+// property (or its value is undefined/null); provide a value on {missing} to
+// default to something else here.
+export function withPropertyFromObject({
+  object,
+  property,
+  into = null,
+}) {
+  into ??=
+    (object.startsWith('#')
+      ? `${object}.${property}`
+      : `#${object}.${property}`);
+
+  return {
+    annotation: `withPropertyFromObject`,
+    flags: {expose: true, compose: true},
+
+    expose: {
+      mapDependencies: {object},
+      mapContinuation: {into},
+      options: {property},
+
+      compute({object, '#options': {property}}, continuation) {
+        if (object === null || object === undefined) return continuation({into: null});
+        if (!Object.hasOwn(object, property)) return continuation({into: null});
+        return continuation({into: object[property] ?? null});
+      },
+    },
+  };
+}
+
+// Gets a property from each of a list of objects (in a dependency) and
+// provides the results. This doesn't alter any list indices, so positions
+// which were null in the original list are kept null here. Objects which don't
+// have the specified property are also included in-place as null, by default;
+// provide a value on {missing} to default to something else here.
+export function withPropertyFromList({
+  list,
+  property,
+  into = null,
+  missing = null,
+}) {
+  into ??=
+    (list.startsWith('#')
+      ? `${list}.${property}`
+      : `#${list}.${property}`);
+
+  return {
+    annotation: `withPropertyFromList`,
+    flags: {expose: true, compose: true},
+
+    expose: {
+      mapDependencies: {list},
+      mapContinuation: {into},
+      options: {property},
+
+      compute({list, '#options': {property}}, continuation) {
+        if (list === undefined || empty(list)) {
+          return continuation({into: []});
+        }
+
+        return continuation({
+          into:
+            list.map(item => {
+              if (item === null || item === undefined) return null;
+              if (!Object.hasOwn(item, property)) return missing;
+              return item[property] ?? missing;
+            }),
+        });
+      },
+    },
+  };
+}
+
+// Replaces items of a list, which are null or undefined, with some fallback
+// value, either a constant (set {value}) or from a dependency ({dependency}).
+// By default, this replaces the passed dependency.
+export function fillMissingListItems({
+  list,
+  value,
+  dependency,
+  into = list,
+}) {
+  if (value !== undefined && dependency !== undefined) {
+    throw new TypeError(`Don't provide both value and dependency`);
+  }
+
+  if (value === undefined && dependency === undefined) {
+    throw new TypeError(`Missing value or dependency`);
+  }
+
+  if (dependency) {
+    return {
+      annotation: `fillMissingListItems.fromDependency`,
+      flags: {expose: true, compose: true},
+
+      expose: {
+        mapDependencies: {list, dependency},
+        mapContinuation: {into},
+
+        compute: ({list, dependency}, continuation) =>
+          continuation({
+            into: list.map(item => item ?? dependency),
+          }),
+      },
+    };
+  } else {
+    return {
+      annotation: `fillMissingListItems.fromValue`,
+      flags: {expose: true, compose: true},
+
+      expose: {
+        mapDependencies: {list},
+        mapContinuation: {into},
+        options: {value},
+
+        compute: ({list, '#options': {value}}, continuation) =>
+          continuation({
+            into: list.map(item => item ?? value),
+          }),
+      },
+    };
+  }
+}
+
 // Flattens an array with one level of nested arrays, providing as dependencies
 // both the flattened array as well as the original starting indices of each
 // successive source array.
diff --git a/src/data/things/thing.js b/src/data/things/thing.js
index 96ac9b12..a87e6ed6 100644
--- a/src/data/things/thing.js
+++ b/src/data/things/thing.js
@@ -15,6 +15,7 @@ import {
   exposeDependency,
   exposeDependencyOrContinue,
   raiseWithoutDependency,
+  withPropertyFromList,
   withUpdateValueAsDependency,
 } from '#composite';
 
@@ -408,14 +409,8 @@ export function withResolvedContribs({
       raise: {into: []},
     }),
 
-    {
-      mapDependencies: {from},
-      compute: ({from}, continuation) =>
-        continuation({
-          '#artistRefs': from.map(({who}) => who),
-          '#what': from.map(({what}) => what),
-        }),
-    },
+    withPropertyFromList({list: from, property: 'who', into: '#artistRefs'}),
+    withPropertyFromList({list: from, property: 'what', into: '#what'}),
 
     withResolvedReferenceList({
       list: '#artistRefs',
diff --git a/src/data/things/track.js b/src/data/things/track.js
index 53798cda..a307fda9 100644
--- a/src/data/things/track.js
+++ b/src/data/things/track.js
@@ -11,6 +11,7 @@ import {
   exposeDependency,
   exposeDependencyOrContinue,
   exposeUpdateValueOrContinue,
+  withPropertyFromObject,
   withResultOfAvailabilityCheck,
   withUpdateValueAsDependency,
 } from '#composite';
@@ -430,20 +431,7 @@ function withAlbumProperty({
 }) {
   return compositeFrom(`withAlbumProperty`, [
     withAlbum({notFoundMode}),
-
-    {
-      dependencies: ['#album'],
-      options: {property},
-      mapContinuation: {into},
-
-      compute: ({
-        '#album': album,
-        '#options': {property},
-      }, continuation) =>
-        (album
-          ? continuation.raise({into: album[property]})
-          : continuation.raise({into: null})),
-    },
+    withPropertyFromObject({object: '#album', property, into}),
   ]);
 }
 
-- 
cgit 1.3.0-6-gf8a5


From 57d07a308dfee6d16b49f7c009853b1789597e82 Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Sat, 9 Sep 2023 08:17:44 -0300
Subject: data: withAlbumProperty -> withPropertyFromAlbum

Also remove withAlbumProperties, since it's not used anywhere and
mostly serves as reference code.
---
 src/data/things/track.js | 59 ++++++++----------------------------------------
 1 file changed, 10 insertions(+), 49 deletions(-)

diff --git a/src/data/things/track.js b/src/data/things/track.js
index a307fda9..5e553b48 100644
--- a/src/data/things/track.js
+++ b/src/data/things/track.js
@@ -75,7 +75,7 @@ export class Track extends Thing {
             : continuation()),
       },
 
-      withAlbumProperty({property: 'color'}),
+      withPropertyFromAlbum({property: 'color'}),
 
       exposeDependency({
         dependency: '#album.color',
@@ -103,7 +103,7 @@ export class Track extends Thing {
       exposeUpdateValueOrContinue(),
 
       // Expose album's trackCoverArtFileExtension if no update value set.
-      withAlbumProperty({property: 'trackCoverArtFileExtension'}),
+      withPropertyFromAlbum({property: 'trackCoverArtFileExtension'}),
       exposeDependencyOrContinue({dependency: '#album.trackCoverArtFileExtension'}),
 
       // Fallback to 'jpg'.
@@ -123,7 +123,7 @@ export class Track extends Thing {
 
       exposeUpdateValueOrContinue(),
 
-      withAlbumProperty({property: 'trackArtDate'}),
+      withPropertyFromAlbum({property: 'trackArtDate'}),
       exposeDependency({
         dependency: '#album.trackArtDate',
         update: {validate: isDate},
@@ -159,7 +159,7 @@ export class Track extends Thing {
       withResolvedContribs({from: '#updateValue', into: '#artistContribs'}),
       exposeDependencyOrContinue({dependency: '#artistContribs'}),
 
-      withAlbumProperty({property: 'artistContribs'}),
+      withPropertyFromAlbum({property: 'artistContribs'}),
       exposeDependency({
         dependency: '#album.artistContribs',
         update: {validate: isContributionList},
@@ -187,7 +187,7 @@ export class Track extends Thing {
       withResolvedContribs({from: '#updateValue', into: '#coverArtistContribs'}),
       exposeDependencyOrContinue({dependency: '#coverArtistContribs'}),
 
-      withAlbumProperty({property: 'trackCoverArtistContribs'}),
+      withPropertyFromAlbum({property: 'trackCoverArtistContribs'}),
       exposeDependency({
         dependency: '#album.trackCoverArtistContribs',
         update: {validate: isContributionList},
@@ -237,7 +237,7 @@ export class Track extends Thing {
 
     date: compositeFrom(`Track.date`, [
       exposeDependencyOrContinue({dependency: 'dateFirstReleased'}),
-      withAlbumProperty({property: 'date'}),
+      withPropertyFromAlbum({property: 'date'}),
       exposeDependency({dependency: '#album.date'}),
     ]),
 
@@ -424,56 +424,17 @@ function withAlbum({
 // property name prefixed with '#album.' (by default). If the track's album
 // isn't available, then by default, the property will be provided as null;
 // set {notFoundMode: 'exit'} to early exit instead.
-function withAlbumProperty({
+function withPropertyFromAlbum({
   property,
   into = '#album.' + property,
   notFoundMode = 'null',
 }) {
-  return compositeFrom(`withAlbumProperty`, [
+  return compositeFrom(`withPropertyFromAlbum`, [
     withAlbum({notFoundMode}),
     withPropertyFromObject({object: '#album', property, into}),
   ]);
 }
 
-// Gets the listed properties from this track's album, providing them as
-// dependencies (by default) with '#album.' prefixed before each property
-// name. If the track's album isn't available, then by default, the same
-// dependency names will be provided as null; set {notFoundMode: 'exit'}
-// to early exit instead.
-function withAlbumProperties({
-  properties,
-  prefix = '#album',
-  notFoundMode = 'null',
-}) {
-  return compositeFrom(`withAlbumProperties`, [
-    withAlbum({notFoundMode}),
-
-    {
-      dependencies: ['#album'],
-      options: {properties, prefix},
-
-      compute({
-        '#album': album,
-        '#options': {properties, prefix},
-      }, continuation) {
-        const raise = {};
-
-        if (album) {
-          for (const property of properties) {
-            raise[prefix + '.' + property] = album[property];
-          }
-        } else {
-          for (const property of properties) {
-            raise[prefix + '.' + property] = null;
-          }
-        }
-
-        return continuation.raise(raise);
-      },
-    },
-  ]);
-}
-
 // Gets the track section containing this track from its album's track list.
 // If notFoundMode is set to 'exit', this will early exit if the album can't be
 // found or if none of its trackSections includes the track for some reason.
@@ -486,7 +447,7 @@ function withContainingTrackSection({
   }
 
   return compositeFrom(`withContainingTrackSection`, [
-    withAlbumProperty({property: 'trackSections', notFoundMode}),
+    withPropertyFromAlbum({property: 'trackSections', notFoundMode}),
 
     {
       dependencies: ['this', '#album.trackSections'],
@@ -585,7 +546,7 @@ function withHasUniqueCoverArt({
           : continuation.raise({into: true})),
     },
 
-    withAlbumProperty({property: 'trackCoverArtistContribs'}),
+    withPropertyFromAlbum({property: 'trackCoverArtistContribs'}),
 
     {
       dependencies: ['#album.trackCoverArtistContribs'],
-- 
cgit 1.3.0-6-gf8a5


From 726118e7e8eefa9002562ca2dd0a4f6deb8a05b9 Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Sat, 9 Sep 2023 08:26:33 -0300
Subject: data: refactor {missing} out of withPropertyFrom{Object,List}

---
 src/data/things/composite.js | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/src/data/things/composite.js b/src/data/things/composite.js
index a5adc3e9..b37b8e31 100644
--- a/src/data/things/composite.js
+++ b/src/data/things/composite.js
@@ -1090,10 +1090,8 @@ export function withUpdateValueAsDependency({
 }
 
 // Gets a property of some object (in a dependency) and provides that value.
-// If the object itself is null, the provided dependency will also always be
-// null. By default, it'll also be null if the object doesn't have the listed
-// property (or its value is undefined/null); provide a value on {missing} to
-// default to something else here.
+// If the object itself is null, or the object doesn't have the listed property,
+// the provided dependency will also be null.
 export function withPropertyFromObject({
   object,
   property,
@@ -1113,11 +1111,10 @@ export function withPropertyFromObject({
       mapContinuation: {into},
       options: {property},
 
-      compute({object, '#options': {property}}, continuation) {
-        if (object === null || object === undefined) return continuation({into: null});
-        if (!Object.hasOwn(object, property)) return continuation({into: null});
-        return continuation({into: object[property] ?? null});
-      },
+      compute: ({object, '#options': {property}}, continuation) =>
+        (object === null || object === undefined
+          ? continuation({into: null})
+          : continuation({into: object[property] ?? null})),
     },
   };
 }
@@ -1125,13 +1122,11 @@ export function withPropertyFromObject({
 // Gets a property from each of a list of objects (in a dependency) and
 // provides the results. This doesn't alter any list indices, so positions
 // which were null in the original list are kept null here. Objects which don't
-// have the specified property are also included in-place as null, by default;
-// provide a value on {missing} to default to something else here.
+// have the specified property are retained in-place as null.
 export function withPropertyFromList({
   list,
   property,
   into = null,
-  missing = null,
 }) {
   into ??=
     (list.startsWith('#')
@@ -1154,11 +1149,10 @@ export function withPropertyFromList({
 
         return continuation({
           into:
-            list.map(item => {
-              if (item === null || item === undefined) return null;
-              if (!Object.hasOwn(item, property)) return missing;
-              return item[property] ?? missing;
-            }),
+            list.map(item =>
+              (item === null || item === undefined
+                ? null
+                : item[property] ?? null)),
         });
       },
     },
-- 
cgit 1.3.0-6-gf8a5


From 7a21c665d888b0db4c47c72049f7649bf1dabcde Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Sat, 9 Sep 2023 08:47:38 -0300
Subject: data: withPropertiesFrom{Object,List}

---
 src/data/things/album.js     | 19 +++++++-----
 src/data/things/composite.js | 72 ++++++++++++++++++++++++++++++++++++++++++++
 src/data/things/thing.js     | 17 ++++++-----
 3 files changed, 94 insertions(+), 14 deletions(-)

diff --git a/src/data/things/album.js b/src/data/things/album.js
index 288caa04..e11d0909 100644
--- a/src/data/things/album.js
+++ b/src/data/things/album.js
@@ -10,7 +10,7 @@ import {
   exposeUpdateValueOrContinue,
   fillMissingListItems,
   withFlattenedArray,
-  withPropertyFromList,
+  withPropertiesFromList,
   withUnflattenedArray,
   withUpdateValueAsDependency,
 } from '#composite';
@@ -86,17 +86,22 @@ export class Album extends Thing {
 
       withUpdateValueAsDependency({into: '#sections'}),
 
-      withPropertyFromList({list: '#sections', property: 'tracks', into: '#sections.trackRefs'}),
-      withPropertyFromList({list: '#sections', property: 'dateOriginallyReleased'}),
-      withPropertyFromList({list: '#sections', property: 'isDefaultTrackSection'}),
-      withPropertyFromList({list: '#sections', property: 'color'}),
+      withPropertiesFromList({
+        list: '#sections',
+        properties: [
+          'tracks',
+          'dateOriginallyReleased',
+          'isDefaultTrackSection',
+          'color',
+        ],
+      }),
 
-      fillMissingListItems({list: '#sections.trackRefs', value: []}),
+      fillMissingListItems({list: '#sections.tracks', value: []}),
       fillMissingListItems({list: '#sections.isDefaultTrackSection', value: false}),
       fillMissingListItems({list: '#sections.color', dependency: 'color'}),
 
       withFlattenedArray({
-        from: '#sections.trackRefs',
+        from: '#sections.tracks',
         into: '#trackRefs',
         intoIndices: '#sections.startIndex',
       }),
diff --git a/src/data/things/composite.js b/src/data/things/composite.js
index b37b8e31..e3225563 100644
--- a/src/data/things/composite.js
+++ b/src/data/things/composite.js
@@ -1119,6 +1119,39 @@ export function withPropertyFromObject({
   };
 }
 
+// Gets the listed properties from some object, providing each property's value
+// as a dependency prefixed with the same name as the object (by default).
+// If the object itself is null, all provided dependencies will be null;
+// if it's missing only select properties, those will be provided as null.
+export function withPropertiesFromObject({
+  object,
+  properties,
+  prefix =
+    (object.startsWith('#')
+      ? object
+      : `#${object}`),
+}) {
+  return {
+    annotation: `withPropertiesFromObject`,
+    flags: {expose: true, compose: true},
+
+    expose: {
+      mapDependencies: {object},
+      options: {prefix, properties},
+
+      compute: ({object, '#options': {prefix, properties}}, continuation) =>
+        continuation(
+          Object.fromEntries(
+            properties.map(property => [
+              `${prefix}.${property}`,
+              (object === null || object === undefined
+                ? null
+                : object[property] ?? null),
+            ]))),
+    },
+  };
+}
+
 // Gets a property from each of a list of objects (in a dependency) and
 // provides the results. This doesn't alter any list indices, so positions
 // which were null in the original list are kept null here. Objects which don't
@@ -1159,6 +1192,45 @@ export function withPropertyFromList({
   };
 }
 
+// Gets the listed properties from each of a list of objects, providing lists
+// of property values each into a dependency prefixed with the same name as the
+// list (by default). Like withPropertyFromList, this doesn't alter indices.
+export function withPropertiesFromList({
+  list,
+  properties,
+  prefix =
+    (list.startsWith('#')
+      ? list
+      : `#${list}`),
+}) {
+  return {
+    annotation: `withPropertiesFromList`,
+    flags: {expose: true, compose: true},
+
+    expose: {
+      mapDependencies: {list},
+      options: {prefix, properties},
+
+      compute({list, '#options': {prefix, properties}}, continuation) {
+        const lists =
+          Object.fromEntries(
+            properties.map(property => [`${prefix}.${property}`, []]));
+
+        for (const item of list) {
+          for (const property of properties) {
+            lists[`${prefix}.${property}`].push(
+              (item === null || item === undefined
+                ? null
+                : item[property] ?? null));
+          }
+        }
+
+        return continuation(lists);
+      }
+    }
+  }
+}
+
 // Replaces items of a list, which are null or undefined, with some fallback
 // value, either a constant (set {value}) or from a dependency ({dependency}).
 // By default, this replaces the passed dependency.
diff --git a/src/data/things/thing.js b/src/data/things/thing.js
index a87e6ed6..52f0b773 100644
--- a/src/data/things/thing.js
+++ b/src/data/things/thing.js
@@ -15,7 +15,7 @@ import {
   exposeDependency,
   exposeDependencyOrContinue,
   raiseWithoutDependency,
-  withPropertyFromList,
+  withPropertiesFromList,
   withUpdateValueAsDependency,
 } from '#composite';
 
@@ -409,21 +409,24 @@ export function withResolvedContribs({
       raise: {into: []},
     }),
 
-    withPropertyFromList({list: from, property: 'who', into: '#artistRefs'}),
-    withPropertyFromList({list: from, property: 'what', into: '#what'}),
+    withPropertiesFromList({
+      list: from,
+      properties: ['who', 'what'],
+      prefix: '#contribs',
+    }),
 
     withResolvedReferenceList({
-      list: '#artistRefs',
+      list: '#contribs.who',
       data: 'artistData',
-      into: '#who',
+      into: '#contribs.who',
       find: find.artist,
       notFoundMode: 'null',
     }),
 
     {
-      dependencies: ['#who', '#what'],
+      dependencies: ['#contribs.who', '#contribs.what'],
       mapContinuation: {into},
-      compute({'#who': who, '#what': what}, continuation) {
+      compute({'#contribs.who': who, '#contribs.what': what}, continuation) {
         filterMultipleArrays(who, what, (who, _what) => who);
         return continuation({
           into: stitchArrays({who, what}),
-- 
cgit 1.3.0-6-gf8a5


From ceaed5fef3ce2c5d59a6606a6318164b93294f2b Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Sat, 9 Sep 2023 09:01:09 -0300
Subject: data: clean up some track property implementations

---
 src/data/things/track.js | 47 ++++++++++++++++++++---------------------------
 1 file changed, 20 insertions(+), 27 deletions(-)

diff --git a/src/data/things/track.js b/src/data/things/track.js
index 5e553b48..25d316eb 100644
--- a/src/data/things/track.js
+++ b/src/data/things/track.js
@@ -61,22 +61,12 @@ export class Track extends Thing {
 
     color: compositeFrom(`Track.color`, [
       exposeUpdateValueOrContinue(),
-      withContainingTrackSection(),
 
-      {
-        dependencies: ['#trackSection'],
-        compute: ({'#trackSection': trackSection}, continuation) =>
-          // Album.trackSections guarantees the track section will have a
-          // color property (inheriting from the album's own color), but only
-          // if it's actually present! Color will be inherited directly from
-          // album otherwise.
-          (trackSection
-            ? trackSection.color
-            : continuation()),
-      },
+      withContainingTrackSection(),
+      withPropertyFromObject({object: '#trackSection', property: 'color'}),
+      exposeDependencyOrContinue({dependency: '#trackSection.color'}),
 
       withPropertyFromAlbum({property: 'color'}),
-
       exposeDependency({
         dependency: '#album.color',
         update: {validate: isColor},
@@ -94,19 +84,13 @@ export class Track extends Thing {
     // of the album's main artwork. It does inherit trackCoverArtFileExtension,
     // if present on the album.
     coverArtFileExtension: compositeFrom(`Track.coverArtFileExtension`, [
-      // No cover art file extension if the track doesn't have unique artwork
-      // in the first place.
-      withHasUniqueCoverArt(),
-      exitWithoutDependency({dependency: '#hasUniqueCoverArt', mode: 'falsy'}),
+      exitWithoutUniqueCoverArt(),
 
-      // Expose custom coverArtFileExtension update value first.
       exposeUpdateValueOrContinue(),
 
-      // Expose album's trackCoverArtFileExtension if no update value set.
       withPropertyFromAlbum({property: 'trackCoverArtFileExtension'}),
       exposeDependencyOrContinue({dependency: '#album.trackCoverArtFileExtension'}),
 
-      // Fallback to 'jpg'.
       exposeConstant({
         value: 'jpg',
         update: {validate: isFileExtension},
@@ -175,13 +159,7 @@ export class Track extends Thing {
     // typically varies by release and isn't defined by the musical qualities
     // of the track.
     coverArtistContribs: compositeFrom(`Track.coverArtistContribs`, [
-      {
-        dependencies: ['disableUniqueCoverArt'],
-        compute: ({disableUniqueCoverArt}, continuation) =>
-          (disableUniqueCoverArt
-            ? null
-            : continuation()),
-      },
+      exitWithoutUniqueCoverArt(),
 
       withUpdateValueAsDependency(),
       withResolvedContribs({from: '#updateValue', into: '#coverArtistContribs'}),
@@ -559,6 +537,21 @@ function withHasUniqueCoverArt({
   ]);
 }
 
+// Shorthand for checking if the track has unique cover art and exposing a
+// fallback value if it isn't.
+function exitWithoutUniqueCoverArt({
+  value = null,
+} = {}) {
+  return compositeFrom(`exitWithoutUniqueCoverArt`, [
+    withHasUniqueCoverArt(),
+    exitWithoutDependency({
+      dependency: '#hasUniqueCoverArt',
+      mode: 'falsy',
+      value,
+    }),
+  ]);
+}
+
 function trackReverseReferenceList({
   property: refListProperty,
 }) {
-- 
cgit 1.3.0-6-gf8a5


From 7b32066dd9629bbb220c2e2425b5294070b5a0db Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Sat, 9 Sep 2023 09:16:50 -0300
Subject: infra, data: cut unneeded boilerplate from top-level compositions

---
 src/data/things/album.js | 17 ++++++++---------
 src/data/things/index.js | 13 +++++++++++--
 src/data/things/track.js | 48 ++++++++++++++++++++++++------------------------
 3 files changed, 43 insertions(+), 35 deletions(-)

diff --git a/src/data/things/album.js b/src/data/things/album.js
index e11d0909..07859537 100644
--- a/src/data/things/album.js
+++ b/src/data/things/album.js
@@ -3,7 +3,6 @@ import {stitchArrays} from '#sugar';
 import {isDate, isTrackSectionList} from '#validators';
 
 import {
-  compositeFrom,
   exitWithoutDependency,
   exitWithoutUpdateValue,
   exposeDependency,
@@ -51,7 +50,7 @@ export class Album extends Thing {
     trackArtDate: simpleDate(),
     dateAddedToWiki: simpleDate(),
 
-    coverArtDate: compositeFrom(`Album.coverArtDate`, [
+    coverArtDate: [
       withResolvedContribs({from: 'coverArtistContribs'}),
       exitWithoutDependency({dependency: '#resolvedContribs', mode: 'empty'}),
 
@@ -60,7 +59,7 @@ export class Album extends Thing {
         dependency: 'date',
         update: {validate: isDate},
       }),
-    ]),
+    ],
 
     artistContribs: contributionList(),
     coverArtistContribs: contributionList(),
@@ -80,7 +79,7 @@ export class Album extends Thing {
       data: 'artTagData',
     }),
 
-    trackSections: compositeFrom(`Album.trackSections`, [
+    trackSections: [
       exitWithoutDependency({dependency: 'trackData', value: []}),
       exitWithoutUpdateValue({value: [], mode: 'empty'}),
 
@@ -150,13 +149,13 @@ export class Album extends Thing {
             }),
         },
       },
-    ]),
+    ],
 
-    coverArtFileExtension: compositeFrom(`Album.coverArtFileExtension`, [
+    coverArtFileExtension: [
       withResolvedContribs({from: 'coverArtistContribs'}),
       exitWithoutDependency({dependency: '#resolvedContribs', mode: 'empty'}),
       fileExtension('jpg'),
-    ]),
+    ],
 
     trackCoverArtFileExtension: fileExtension('jpg'),
 
@@ -189,7 +188,7 @@ export class Album extends Thing {
     hasWallpaperArt: contribsPresent('wallpaperArtistContribs'),
     hasBannerArt: contribsPresent('bannerArtistContribs'),
 
-    tracks: compositeFrom(`Album.tracks`, [
+    tracks: [
       exitWithoutDependency({dependency: 'trackData', value: []}),
       exitWithoutDependency({dependency: 'trackSections', mode: 'empty', value: []}),
 
@@ -209,7 +208,7 @@ export class Album extends Thing {
       }),
 
       exposeDependency({dependency: '#resolvedReferenceList'}),
-    ]),
+    ],
   });
 
   static [Thing.getSerializeDescriptors] = ({
diff --git a/src/data/things/index.js b/src/data/things/index.js
index 3b73a772..4d8d9d1f 100644
--- a/src/data/things/index.js
+++ b/src/data/things/index.js
@@ -2,6 +2,7 @@ import * as path from 'node:path';
 import {fileURLToPath} from 'node:url';
 
 import {logError} from '#cli';
+import {compositeFrom} from '#composite';
 import * as serialize from '#serialize';
 import {openAggregate, showAggregate} from '#sugar';
 
@@ -130,8 +131,16 @@ function evaluatePropertyDescriptors() {
         throw new Error(`Missing [Thing.getPropertyDescriptors] function`);
       }
 
-      constructor.propertyDescriptors =
-        constructor[Thing.getPropertyDescriptors](opts);
+      const results = constructor[Thing.getPropertyDescriptors](opts);
+
+      for (const [key, value] of Object.entries(results)) {
+        if (Array.isArray(value)) {
+          results[key] = compositeFrom(`${constructor.name}.${key}`, value);
+          continue;
+        }
+      }
+
+      constructor.propertyDescriptors = results;
     },
 
     showFailedClasses(failedClasses) {
diff --git a/src/data/things/track.js b/src/data/things/track.js
index 25d316eb..a8d59023 100644
--- a/src/data/things/track.js
+++ b/src/data/things/track.js
@@ -59,7 +59,7 @@ export class Track extends Thing {
     urls: urls(),
     dateFirstReleased: simpleDate(),
 
-    color: compositeFrom(`Track.color`, [
+    color: [
       exposeUpdateValueOrContinue(),
 
       withContainingTrackSection(),
@@ -71,7 +71,7 @@ export class Track extends Thing {
         dependency: '#album.color',
         update: {validate: isColor},
       }),
-    ]),
+    ],
 
     // Disables presenting the track as though it has its own unique artwork.
     // This flag should only be used in select circumstances, i.e. to override
@@ -83,7 +83,7 @@ export class Track extends Thing {
     // track's unique cover artwork, if any, and does not inherit the extension
     // of the album's main artwork. It does inherit trackCoverArtFileExtension,
     // if present on the album.
-    coverArtFileExtension: compositeFrom(`Track.coverArtFileExtension`, [
+    coverArtFileExtension: [
       exitWithoutUniqueCoverArt(),
 
       exposeUpdateValueOrContinue(),
@@ -95,13 +95,13 @@ export class Track extends Thing {
         value: 'jpg',
         update: {validate: isFileExtension},
       }),
-    ]),
+    ],
 
     // Date of cover art release. Like coverArtFileExtension, this represents
     // only the track's own unique cover artwork, if any. This exposes only as
     // the track's own coverArtDate or its album's trackArtDate, so if neither
     // is specified, this value is null.
-    coverArtDate: compositeFrom(`Track.coverArtDate`, [
+    coverArtDate: [
       withHasUniqueCoverArt(),
       exitWithoutDependency({dependency: '#hasUniqueCoverArt', mode: 'falsy'}),
 
@@ -112,7 +112,7 @@ export class Track extends Thing {
         dependency: '#album.trackArtDate',
         update: {validate: isDate},
       }),
-    ]),
+    ],
 
     commentary: commentary(),
     lyrics: simpleString(),
@@ -136,7 +136,7 @@ export class Track extends Thing {
       data: 'albumData',
     }),
 
-    artistContribs: compositeFrom(`Track.artistContribs`, [
+    artistContribs: [
       inheritFromOriginalRelease({property: 'artistContribs'}),
 
       withUpdateValueAsDependency(),
@@ -148,17 +148,17 @@ export class Track extends Thing {
         dependency: '#album.artistContribs',
         update: {validate: isContributionList},
       }),
-    ]),
+    ],
 
-    contributorContribs: compositeFrom(`Track.contributorContribs`, [
+    contributorContribs: [
       inheritFromOriginalRelease({property: 'contributorContribs'}),
       contributionList(),
-    ]),
+    ],
 
     // Cover artists aren't inherited from the original release, since it
     // typically varies by release and isn't defined by the musical qualities
     // of the track.
-    coverArtistContribs: compositeFrom(`Track.coverArtistContribs`, [
+    coverArtistContribs: [
       exitWithoutUniqueCoverArt(),
 
       withUpdateValueAsDependency(),
@@ -170,25 +170,25 @@ export class Track extends Thing {
         dependency: '#album.trackCoverArtistContribs',
         update: {validate: isContributionList},
       }),
-    ]),
+    ],
 
-    referencedTracks: compositeFrom(`Track.referencedTracks`, [
+    referencedTracks: [
       inheritFromOriginalRelease({property: 'referencedTracks'}),
       referenceList({
         class: Track,
         find: find.track,
         data: 'trackData',
       }),
-    ]),
+    ],
 
-    sampledTracks: compositeFrom(`Track.sampledTracks`, [
+    sampledTracks: [
       inheritFromOriginalRelease({property: 'sampledTracks'}),
       referenceList({
         class: Track,
         find: find.track,
         data: 'trackData',
       }),
-    ]),
+    ],
 
     artTags: referenceList({
       class: ArtTag,
@@ -208,16 +208,16 @@ export class Track extends Thing {
 
     commentatorArtists: commentatorArtists(),
 
-    album: compositeFrom(`Track.album`, [
+    album: [
       withAlbum(),
       exposeDependency({dependency: '#album'}),
-    ]),
+    ],
 
-    date: compositeFrom(`Track.date`, [
+    date: [
       exposeDependencyOrContinue({dependency: 'dateFirstReleased'}),
       withPropertyFromAlbum({property: 'date'}),
       exposeDependency({dependency: '#album.date'}),
-    ]),
+    ],
 
     // Whether or not the track has "unique" cover artwork - a cover which is
     // specifically associated with this track in particular, rather than with
@@ -226,12 +226,12 @@ export class Track extends Thing {
     // or a placeholder. (This property is named hasUniqueCoverArt instead of
     // the usual hasCoverArt to emphasize that it does not inherit from the
     // album.)
-    hasUniqueCoverArt: compositeFrom(`Track.hasUniqueCoverArt`, [
+    hasUniqueCoverArt: [
       withHasUniqueCoverArt(),
       exposeDependency({dependency: '#hasUniqueCoverArt'}),
-    ]),
+    ],
 
-    otherReleases: compositeFrom(`Track.otherReleases`, [
+    otherReleases: [
       exitWithoutDependency({dependency: 'trackData', mode: 'empty'}),
       withOriginalRelease({selfIfOriginal: true}),
 
@@ -253,7 +253,7 @@ export class Track extends Thing {
                 track.originalReleaseTrack === originalRelease)),
         },
       },
-    ]),
+    ],
 
     // Specifically exclude re-releases from this list - while it's useful to
     // get from a re-release to the tracks it references, re-releases aren't
-- 
cgit 1.3.0-6-gf8a5


From a9b96deeca6b2dacb7fac309c47e7bc6289270e6 Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Sat, 9 Sep 2023 09:29:51 -0300
Subject: data: be more permissive of steps w/ no special expose behavior

---
 src/data/things/composite.js | 30 +++++++++++-------------------
 1 file changed, 11 insertions(+), 19 deletions(-)

diff --git a/src/data/things/composite.js b/src/data/things/composite.js
index e3225563..2dd92f17 100644
--- a/src/data/things/composite.js
+++ b/src/data/things/composite.js
@@ -432,13 +432,8 @@ export function compositeFrom(firstArg, secondArg) {
           ? step.expose
           : step);
 
-      const stepComputes = !!expose.compute;
-      const stepTransforms = !!expose.transform;
-
-      if (!stepComputes && !stepTransforms) {
-        push(new TypeError(`Steps must provide compute or transform (or both)`));
-        return;
-      }
+      const stepComputes = !!expose?.compute;
+      const stepTransforms = !!expose?.transform;
 
       if (
         stepTransforms && !stepComputes &&
@@ -459,7 +454,7 @@ export function compositeFrom(firstArg, secondArg) {
       // Unmapped dependencies are exposed on the final composition only if
       // they're "public", i.e. pointing to update values of other properties
       // on the CacheableObject.
-      for (const dependency of expose.dependencies ?? []) {
+      for (const dependency of expose?.dependencies ?? []) {
         if (typeof dependency === 'string' && dependency.startsWith('#')) {
           continue;
         }
@@ -470,22 +465,14 @@ export function compositeFrom(firstArg, secondArg) {
       // Mapped dependencies are always exposed on the final composition.
       // These are explicitly for reading values which are named outside of
       // the current compositional step.
-      for (const dependency of Object.values(expose.mapDependencies ?? {})) {
+      for (const dependency of Object.values(expose?.mapDependencies ?? {})) {
         exposeDependencies.add(dependency);
       }
     });
   }
 
-  if (!baseComposes) {
-    if (baseUpdates) {
-      if (!anyStepsTransform) {
-        aggregate.push(new TypeError(`Expected at least one step to transform`));
-      }
-    } else {
-      if (!anyStepsCompute) {
-        aggregate.push(new TypeError(`Expected at least one step to compute`));
-      }
-    }
+  if (!baseComposes && !baseUpdates && !anyStepsCompute) {
+    aggregate.push(new TypeError(`Expected at least one step to compute`));
   }
 
   aggregate.close();
@@ -615,6 +602,11 @@ export function compositeFrom(firstArg, secondArg) {
           ? step.expose
           : step);
 
+      if (!expose) {
+        debug(() => `step #${i+1} - no expose description, nothing to do for this step`);
+        continue;
+      }
+
       const callingTransformForThisStep =
         expectingTransform && expose.transform;
 
-- 
cgit 1.3.0-6-gf8a5


From 9109356037ce98af378765302841c957cc96b8d8 Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Sat, 9 Sep 2023 09:33:04 -0300
Subject: data: exitWithoutContribs utility

---
 src/data/things/album.js |  9 +++------
 src/data/things/thing.js | 17 +++++++++++++++++
 2 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/src/data/things/album.js b/src/data/things/album.js
index 07859537..dc8d3189 100644
--- a/src/data/things/album.js
+++ b/src/data/things/album.js
@@ -23,6 +23,7 @@ import Thing, {
   contributionList,
   dimensions,
   directory,
+  exitWithoutContribs,
   fileExtension,
   flag,
   name,
@@ -31,7 +32,6 @@ import Thing, {
   simpleString,
   urls,
   wikiData,
-  withResolvedContribs,
   withResolvedReferenceList,
 } from './thing.js';
 
@@ -51,9 +51,7 @@ export class Album extends Thing {
     dateAddedToWiki: simpleDate(),
 
     coverArtDate: [
-      withResolvedContribs({from: 'coverArtistContribs'}),
-      exitWithoutDependency({dependency: '#resolvedContribs', mode: 'empty'}),
-
+      exitWithoutContribs({contribs: 'coverArtistContribs'}),
       exposeUpdateValueOrContinue(),
       exposeDependency({
         dependency: 'date',
@@ -152,8 +150,7 @@ export class Album extends Thing {
     ],
 
     coverArtFileExtension: [
-      withResolvedContribs({from: 'coverArtistContribs'}),
-      exitWithoutDependency({dependency: '#resolvedContribs', mode: 'empty'}),
+      exitWithoutContribs({contribs: 'coverArtistContribs'}),
       fileExtension('jpg'),
     ],
 
diff --git a/src/data/things/thing.js b/src/data/things/thing.js
index 52f0b773..fe9000b4 100644
--- a/src/data/things/thing.js
+++ b/src/data/things/thing.js
@@ -436,6 +436,23 @@ export function withResolvedContribs({
   ]);
 }
 
+// Shorthand for exiting if the contribution list (usually a property's update
+// value) resolves to empty - ensuring that the later computed results are only
+// returned if these contributions are present.
+export function exitWithoutContribs({
+  contribs,
+  value = null,
+}) {
+  return compositeFrom(`exitWithoutContribs`, [
+    withResolvedContribs({from: contribs}),
+    exitWithoutDependency({
+      dependency: '#resolvedContribs',
+      mode: 'empty',
+      value,
+    }),
+  ]);
+}
+
 // Resolves a reference by using the provided find function to match it
 // within the provided thingData dependency. This will early exit if the
 // data dependency is null, or, if notFoundMode is set to 'exit', if the find
-- 
cgit 1.3.0-6-gf8a5


From 3083e006fb8be524ca8e37c3194b78b0bf37861f Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Sat, 9 Sep 2023 09:33:14 -0300
Subject: data: rearrange Album properties, use exitWithoutContribs more

---
 src/data/things/album.js | 84 +++++++++++++++++++++++++++++-------------------
 1 file changed, 51 insertions(+), 33 deletions(-)

diff --git a/src/data/things/album.js b/src/data/things/album.js
index dc8d3189..2a8c59ed 100644
--- a/src/data/things/album.js
+++ b/src/data/things/album.js
@@ -59,23 +59,44 @@ export class Album extends Thing {
       }),
     ],
 
-    artistContribs: contributionList(),
-    coverArtistContribs: contributionList(),
-    trackCoverArtistContribs: contributionList(),
-    wallpaperArtistContribs: contributionList(),
-    bannerArtistContribs: contributionList(),
+    coverArtFileExtension: [
+      exitWithoutContribs({contribs: 'coverArtistContribs'}),
+      fileExtension('jpg'),
+    ],
 
-    groups: referenceList({
-      class: Group,
-      find: find.group,
-      data: 'groupData',
-    }),
+    trackCoverArtFileExtension: fileExtension('jpg'),
 
-    artTags: referenceList({
-      class: ArtTag,
-      find: find.artTag,
-      data: 'artTagData',
-    }),
+    wallpaperFileExtension: [
+      exitWithoutContribs({contribs: 'wallpaperArtistContribs'}),
+      fileExtension('jpg'),
+    ],
+
+    bannerFileExtension: [
+      exitWithoutContribs({contribs: 'bannerArtistContribs'}),
+      fileExtension('jpg'),
+    ],
+
+    wallpaperStyle: [
+      exitWithoutContribs({contribs: 'wallpaperArtistContribs'}),
+      simpleString(),
+    ],
+
+    bannerStyle: [
+      exitWithoutContribs({contribs: 'bannerArtistContribs'}),
+      simpleString(),
+    ],
+
+    bannerDimensions: [
+      exitWithoutContribs({contribs: 'bannerArtistContribs'}),
+      dimensions(),
+    ],
+
+    hasTrackNumbers: flag(true),
+    isListedOnHomepage: flag(true),
+    isListedInGalleries: flag(true),
+
+    commentary: commentary(),
+    additionalFiles: additionalFiles(),
 
     trackSections: [
       exitWithoutDependency({dependency: 'trackData', value: []}),
@@ -149,26 +170,23 @@ export class Album extends Thing {
       },
     ],
 
-    coverArtFileExtension: [
-      exitWithoutContribs({contribs: 'coverArtistContribs'}),
-      fileExtension('jpg'),
-    ],
-
-    trackCoverArtFileExtension: fileExtension('jpg'),
-
-    wallpaperStyle: simpleString(),
-    wallpaperFileExtension: fileExtension('jpg'),
-
-    bannerStyle: simpleString(),
-    bannerFileExtension: fileExtension('jpg'),
-    bannerDimensions: dimensions(),
+    artistContribs: contributionList(),
+    coverArtistContribs: contributionList(),
+    trackCoverArtistContribs: contributionList(),
+    wallpaperArtistContribs: contributionList(),
+    bannerArtistContribs: contributionList(),
 
-    hasTrackNumbers: flag(true),
-    isListedOnHomepage: flag(true),
-    isListedInGalleries: flag(true),
+    groups: referenceList({
+      class: Group,
+      find: find.group,
+      data: 'groupData',
+    }),
 
-    commentary: commentary(),
-    additionalFiles: additionalFiles(),
+    artTags: referenceList({
+      class: ArtTag,
+      find: find.artTag,
+      data: 'artTagData',
+    }),
 
     // Update only
 
-- 
cgit 1.3.0-6-gf8a5