linked-rolls 0.33.0 → 0.35.0

package/lib/notes.d.ts

@@ -4,6 +4,7 @@ export type NotePart = {
 } | {
     type: 'reference';
     id: string;
+    label?: string;
 };
 /** The note in the pieces it is shown in: stretches of text and what they refer to. */
 export declare const partsOfNote: (note: string) => NotePart[];
@@ -11,7 +12,8 @@ export declare const partsOfNote: (note: string) => NotePart[];
 export declare const referencesInNote: (note: string) => string[];
 /**
  * The note as it reads, with every reference resolved to the name the
- * edition gives that entity. A reference nothing answers to keeps its id,
- * so that the gap is visible rather than silent.
+ * edition gives that entity, or to the words the note puts in its place.
+ * A reference nothing answers to keeps its id, so that the gap is visible
+ * rather than silent.
  */
 export declare const resolveNote: (note: string, nameOf: (id: string) => string | undefined) => string;

package/lib/notes.js

@@ -1,10 +1,15 @@
 /**
- * A note refers to a version or a copy instead of naming it, so that a
- * label the stemma decides is never written into the prose. A reference
- * reads `{{<id>}}`, where the id is the entity's, and is resolved when
- * the note is shown.
+ * A note refers to an entity instead of naming it, so that a label the
+ * stemma decides is never written into the prose. A reference reads
+ * `{{<id>}}`, where the id is the entity's, and is resolved when the note
+ * is shown.
+ *
+ * An entity the edition gives no name to, a perforation or an edit, needs
+ * the note's own words to stand in the sentence: `{{<id>|die Stanzung bei
+ * 7364,7 mm}}`. The name wins where the edition has one, so a siglum
+ * still follows the stemma and a written-out label cannot freeze it.
  */
-const reference = /\{\{\s*([^{}\s]+)\s*\}\}/g;
+const reference = /\{\{\s*([^{}|\s]+)\s*(?:\|([^{}]*))?\}\}/g;
 /** The note in the pieces it is shown in: stretches of text and what they refer to. */
 export const partsOfNote = (note) => {
     const parts = [];
@@ -13,7 +18,8 @@ export const partsOfNote = (note) => {
         const at = match.index ?? 0;
         if (at > read)
             parts.push({ type: 'text', text: note.slice(read, at) });
-        parts.push({ type: 'reference', id: match[1] });
+        const label = match[2]?.trim();
+        parts.push({ type: 'reference', id: match[1], ...(label && { label }) });
         read = at + match[0].length;
     }
     if (read < note.length)
@@ -24,9 +30,10 @@ export const partsOfNote = (note) => {
 export const referencesInNote = (note) => partsOfNote(note).flatMap(part => part.type === 'reference' ? [part.id] : []);
 /**
  * The note as it reads, with every reference resolved to the name the
- * edition gives that entity. A reference nothing answers to keeps its id,
- * so that the gap is visible rather than silent.
+ * edition gives that entity, or to the words the note puts in its place.
+ * A reference nothing answers to keeps its id, so that the gap is visible
+ * rather than silent.
  */
 export const resolveNote = (note, nameOf) => partsOfNote(note)
-    .map(part => part.type === 'text' ? part.text : nameOf(part.id) ?? part.id)
+    .map(part => part.type === 'text' ? part.text : nameOf(part.id) ?? part.label ?? part.id)
     .join('');

package/lib/reservations.d.ts

@@ -24,7 +24,7 @@ export interface Reservation<T extends string = ReservationType> {
  * the measurement leaves open, then who holds it.
  */
 export declare const reservationsAbout: (copy: RollCopy) => Reservation[];
-export declare const versionReservationTypes: readonly ['text-not-stated', 'witnessed-by-statement-only'];
+export declare const versionReservationTypes: readonly ['text-not-stated', 'witnessed-by-statement-only', 'no-direct-witness'];
 export type VersionReservationType = typeof versionReservationTypes[number];
 /** What the edition cannot vouch for in a version, in the order the checks are listed. */
 export declare const reservationsAboutVersion: (view: EditionView, version: Readonly<Version>) => Reservation<VersionReservationType>[];

package/lib/reservations.js

@@ -102,7 +102,8 @@ const checks = [
 export const reservationsAbout = (copy) => checks.flatMap(check => check(copy) ?? []);
 export const versionReservationTypes = [
     'text-not-stated',
-    'witnessed-by-statement-only'
+    'witnessed-by-statement-only',
+    'no-direct-witness'
 ];
 const textStated = (_view, version) => version.edits ? undefined : {
     type: 'text-not-stated',
@@ -115,6 +116,18 @@ const witnessedByFeatures = (view, version) => {
         note: 'No copy\'s features carry what the version inserts; only copies that state they carry it bear witness to it.'
     } : undefined;
 };
-const versionChecks = [textStated, witnessedByFeatures];
+/**
+ * A version every copy reaches only through a version derived from it.
+ * Its text is a reconstruction from below, as a lost state's is, and
+ * nothing surviving shows it as it stood.
+ */
+const witnessedAtFirstHand = (view, version) => {
+    const carriers = witnessesOf(view, version.id).filter(({ by }) => by === 'carriers');
+    return carriers.length > 0 && carriers.every(({ through }) => through !== undefined) ? {
+        type: 'no-direct-witness',
+        note: 'No copy carries it at first hand; it is attested only through the versions derived from it.'
+    } : undefined;
+};
+const versionChecks = [textStated, witnessedByFeatures, witnessedAtFirstHand];
 /** What the edition cannot vouch for in a version, in the order the checks are listed. */
 export const reservationsAboutVersion = (view, version) => versionChecks.flatMap(check => check(view, version) ?? []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-rolls",
-  "version": "0.33.0",
+  "version": "0.35.0",
   "description": "Digital editions of piano rolls: import, collation, editorial assumptions, JSON-LD export, and emulation through a reproducing system",
   "license": "MIT",
   "repository": {