linked-rolls 0.27.0 → 0.28.0

package/README.md

@@ -88,9 +88,12 @@ no features to carry the symbols of a version. It states instead
 which versions it is held to carry, in `carries`, each under a belief
 that says how certainly and why. `witnessesOf` gathers the copies of a
 version, whether their features carry its symbols or they state that
-they carry it, and `carriageProblems` reports a statement made beside
-features that carry symbols already, or one naming a version the
-edition lacks.
+they carry it, a statement with the belief it rests on;
+`versionsWitnessedBy` gathers the same from the side of a copy.
+`carriageProblems` reports a statement made beside features that carry
+symbols already, or one naming a version the edition lacks. A copy may
+carry a `siglum`, as a version does; one without is named by its
+keeper.
 
 ```ts
 import { reservationsAbout, stateSource } from 'linked-rolls'

package/lib/RollCopy.d.ts

@@ -273,6 +273,12 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
      * @see crm:P44 has condition
      */
     conditions: RollConditionAssignment[];
+    /**
+     * A short siglum to identify the copy, e.g. "W1" or "S2". A copy
+     * without one is named by its keeper.
+     * @see reo:siglum
+     */
+    siglum?: string;
     /**
      * The institution or person holding this copy. Left out where it is
      * not known, as for a copy known only from a recording.

package/lib/Version.d.ts

@@ -1,6 +1,6 @@
 import { Edit } from "./Edit";
 import { Concept } from "./Agent";
-import { ActorAssignment, Certainty, DateAssignment, ReferenceAssumption } from "./Assumption";
+import { ActorAssignment, Belief, Certainty, DateAssignment, ReferenceAssumption } from "./Assumption";
 import { CollationTolerance } from "./Collation";
 import { AnySymbol } from "./Symbol";
 import { WithId, WithNote, WithType } from "./utils";
@@ -136,10 +136,14 @@ export declare const editsOf: (version: Readonly<Version>) => Edit[];
 export declare const insertedBy: (version: Readonly<Version>) => AnySymbol[];
 /** The ids of the symbols the version's edits delete. */
 export declare const deletedBy: (version: Readonly<Version>) => string[];
-/** The parents the version names, each with the certainty its derivation is held with. */
+/**
+ * The parents the version names, in the order of `basedOn`, each with the
+ * certainty its derivation is held with and the belief it rests on.
+ */
 export declare const derivationsOf: (version: Readonly<Version>) => {
     parent: string;
     certainty: Certainty;
+    belief?: Belief;
 }[];
 /**
  * The derivation the version's text is read against: the first of those

package/lib/Version.js

@@ -19,8 +19,14 @@ export const editsOf = (version) => version.edits ?? [];
 export const insertedBy = (version) => editsOf(version).flatMap(edit => edit.insert ?? []);
 /** The ids of the symbols the version's edits delete. */
 export const deletedBy = (version) => editsOf(version).flatMap(edit => edit.delete ?? []);
-/** The parents the version names, each with the certainty its derivation is held with. */
-export const derivationsOf = (version) => (version.basedOn ?? []).map(derivation => ({ parent: idOf(derivation), certainty: certaintyOf(derivation) }));
+/**
+ * The parents the version names, in the order of `basedOn`, each with the
+ * certainty its derivation is held with and the belief it rests on.
+ */
+export const derivationsOf = (version) => (version.basedOn ?? []).map(derivation => {
+    const belief = derivation['@annotation']?.belief;
+    return { parent: idOf(derivation), certainty: certaintyOf(derivation), ...(belief && { belief }) };
+});
 const rankOf = (derivation) => certainties.indexOf(certaintyOf(derivation));
 /**
  * The derivation the version's text is read against: the first of those

package/lib/editionOps.d.ts

@@ -44,6 +44,8 @@ export declare const unalignCopy: (copyId: string) => EditionOp;
 export declare const stateSource: (copyId: string, source: FeatureSource) => EditionOp;
 /** Takes back the statement, leaving the copy silent about its source again. */
 export declare const clearSource: (copyId: string) => EditionOp;
+/** Gives the copy the siglum it is referred to by, or takes it away where the siglum given is blank. */
+export declare const nameCopy: (copyId: string, siglum: string) => EditionOp;
 /**
  * States that the copy carries the version, under the belief given. It
  * is meant for a copy whose features are not read into symbols, such as

package/lib/editionOps.js

@@ -135,6 +135,14 @@ export const stateSource = (copyId, source) => onCopy(copyId, copy => {
 export const clearSource = (copyId) => onCopy(copyId, copy => {
     copy.readFrom = undefined;
 });
+/** Gives the copy the siglum it is referred to by, or takes it away where the siglum given is blank. */
+export const nameCopy = (copyId, siglum) => onCopy(copyId, copy => {
+    const trimmed = siglum.trim();
+    if (trimmed)
+        copy.siglum = trimmed;
+    else
+        delete copy.siglum;
+});
 /** A reference under the belief given, where one is given. */
 const referenceHeld = (id, belief) => ({ ...assignReference(id), ...(belief && { '@annotation': { id: v4(), belief } }) });
 /** The references less those that match, or nothing where none is left. */

package/lib/schema.json

@@ -2270,6 +2270,11 @@
                     "type": "string",
                     "ontology": "crm:P138i has representation"
                 },
+                "siglum": {
+                    "description": "A short siglum to identify the copy, e.g. \"W1\" or \"S2\". A copy without one is named by its keeper.",
+                    "type": "string",
+                    "ontology": "reo:siglum"
+                },
                 "@id": {
                     "description": "A unique identifier for this object.",
                     "type": "string"

package/lib/witnesses.d.ts

@@ -1,4 +1,4 @@
-import { Certainty } from "./Assumption";
+import { Belief, Certainty } from "./Assumption";
 import { EditionView } from "./EditionView";
 export type WitnessBy = 'carriers' | 'statement';
 /** A copy that bears witness to a version, and how. */
@@ -9,6 +9,8 @@ export interface Witness {
     by: WitnessBy;
     /** How certainly a statement is held. Carriage through features is no statement and holds none. */
     certainty?: Certainty;
+    /** The belief a statement rests on, where it states one. */
+    belief?: Belief;
 }
 /**
  * The copies that bear witness to the version: those whose features carry
@@ -20,6 +22,13 @@ export interface Witness {
  * are not stated is witnessed by statement alone.
  */
 export declare const witnessesOf: (view: EditionView, versionId: string) => Witness[];
+/**
+ * The versions the copy bears witness to, each with how, in the order the
+ * edition lists its versions.
+ */
+export declare const versionsWitnessedBy: (view: EditionView, copyId: string) => (Witness & {
+    version: string;
+})[];
 export type CarriageProblem = {
     copy: string;
     version: string;

package/lib/witnesses.js

@@ -28,9 +28,19 @@ export const witnessesOf = (view, versionId) => {
         .filter(copy => !carrying.has(copy.id))
         .flatMap(copy => (copy.carries ?? [])
         .filter(statement => idOf(statement) === versionId)
-        .map((statement) => ({ copy: copy.id, by: 'statement', certainty: certaintyOf(statement) })));
+        .map((statement) => {
+        const belief = statement['@annotation']?.belief;
+        return { copy: copy.id, by: 'statement', certainty: certaintyOf(statement), ...(belief && { belief }) };
+    }));
     return [...byCarriers, ...byStatement];
 };
+/**
+ * The versions the copy bears witness to, each with how, in the order the
+ * edition lists its versions.
+ */
+export const versionsWitnessedBy = (view, copyId) => view.edition.versions.flatMap(version => witnessesOf(view, version.id)
+    .filter(witness => witness.copy === copyId)
+    .map(witness => ({ ...witness, version: version.id })));
 /**
  * Where a copy's statement that it carries a version cannot stand: one
  * made although the copy's features carry symbols, which say by

package/package.json

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