linked-rolls 0.28.0 → 0.30.0

package/lib/RollCopy.d.ts

@@ -274,8 +274,10 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
      */
     conditions: RollConditionAssignment[];
     /**
-     * A short siglum to identify the copy, e.g. "W1" or "S2". A copy
-     * without one is named by its keeper.
+     * A short siglum to identify the copy, e.g. "St1" or "Wi1": letters
+     * for the collection the copy was read in, and a number counting the
+     * copies of the roll held there. A copy without one is named by its
+     * keeper.
      * @see reo:siglum
      */
     siglum?: string;

package/lib/Version.d.ts

@@ -4,22 +4,6 @@ import { ActorAssignment, Belief, Certainty, DateAssignment, ReferenceAssumption
 import { CollationTolerance } from "./Collation";
 import { AnySymbol } from "./Symbol";
 import { WithId, WithNote, WithType } from "./utils";
-export declare const versionTypes: readonly [
-/**
- * The roll is in a state where it is (possibly) used as
- * the master roll for several new reproductions.
- */
-'edition', 
-/**
- * A version that exists only on one specific copy of a roll.
- */
-'unicum'];
-/**
- * The type of a version. An 'edition' version may serve as the
- * master for several roll copies; a 'unicum' version exists only
- * on one specific copy.
- */
-export type VersionType = typeof versionTypes[number];
 /**
  * A motivation provides a reason or rationale for an editorial change.
  * Motivations are defined at the version level and referenced by edits.
@@ -82,7 +66,11 @@ export interface VersionCreation {
  */
 export interface Version extends WithId, WithType<'Version'> {
     /**
-     * A short siglum to identify the version, e.g. "A", "B1", "B2_rev", etc.
+     * A short siglum to identify the version, e.g. "A" or "B2". A siglum
+     * is given once and not changed: its letter names the line the version
+     * was first recognised in, its number counts the versions admitted to
+     * that line. Where later work places the version elsewhere in the
+     * stemma, `basedOn` changes and the siglum stays.
      * @see reo:siglum
      */
     siglum: string;
@@ -96,13 +84,6 @@ export interface Version extends WithId, WithType<'Version'> {
      * @see crm:P2 has type
      */
     system: Concept;
-    /**
-     * Whether the version served as a master for reproductions
-     * or exists on one copy only. Left out where that is not known,
-     * as for a version only a secondary witness hints at.
-     * @see crm:P2 has type
-     */
-    versionType?: VersionType;
     /**
      * The versions this one is held to derive from, each under the
      * belief it rests on. The text is read against the principal one

package/lib/Version.js

@@ -1,16 +1,5 @@
 import { certainties, certaintyOf, idOf } from "./Assumption";
 import { defaultCollationTolerance } from "./Collation";
-export const versionTypes = [
-    /**
-     * The roll is in a state where it is (possibly) used as
-     * the master roll for several new reproductions.
-     */
-    'edition',
-    /**
-     * A version that exists only on one specific copy of a roll.
-     */
-    'unicum'
-];
 /** The tolerance the derivation was collated at, or the default where it states none. */
 export const collationToleranceOf = (derivation) => derivation.collationTolerance ?? defaultCollationTolerance;
 /** The edits the version states, none where it leaves its text unstated. */

package/lib/editionOps.js

@@ -83,7 +83,6 @@ export const createVersion = (siglum, copy) => draft => {
         id: v4(),
         siglum,
         system: systemOf(bar),
-        versionType: 'edition',
         edits: asSymbols(copy.features, bar).map(insertion),
         motivations: []
     });
@@ -638,6 +637,19 @@ export const removeVersion = (view, versionId) => {
 };
 /** Takes the symbols out of the version's own insertions, and the edits that had nothing else. */
 export const removeSymbols = (versionId, symbolIds) => onVersion(versionId, version => dropInsertions(version, new Set(symbolIds)));
+/**
+ * The siglum for a version derived from this one: the line the siglum
+ * names, and the next number free in it. A number already given stays
+ * given, whatever the stemma does later.
+ */
+const nextInLine = (versions, siglum) => {
+    const [line] = siglum.match(/^\D*/) ?? [siglum];
+    const numbers = versions.flatMap(other => {
+        const match = other.siglum.match(/^(\D*)(\d*)$/);
+        return match && match[1] === line ? [Number(match[2] || 1)] : [];
+    });
+    return `${line}${Math.max(1, ...numbers) + 1}`;
+};
 /** Moves the edits into a new version based on this one. */
 export const deriveVersion = (versionId, editIds) => onVersion(versionId, (version, draft) => {
     const chosen = new Set(editIds);
@@ -647,9 +659,8 @@ export const deriveVersion = (versionId, editIds) => onVersion(versionId, (versi
     draft.versions.push({
         type: 'Version',
         id: v4(),
-        siglum: `${version.siglum}_derived`,
+        siglum: nextInLine(draft.versions, version.siglum),
         system: stateOf(version).system,
-        versionType: 'unicum',
         basedOn: [assignReference(versionId)],
         edits: moved,
         motivations: []

package/lib/migrate.js

@@ -3,8 +3,7 @@ import { rollConditions } from "./RollCopy";
 import { systemIdIn, systemOf, translationBetween } from "./TrackerBar";
 import { trackerBars } from "./systems";
 import { welteT100 } from "./systems/welteT100/bar";
-import { versionTypes } from "./Version";
-const versionTypeValues = new Set(versionTypes);
+const retiredVersionTypes = new Set(['edition', 'unicum']);
 const conditionTypeValues = new Set([...rollConditions, ...Object.values(conditions).flat()]);
 const renamedKeys = {
     productionEvent: 'production',
@@ -17,14 +16,21 @@ const withRenamedKeys = (node) => Object.keys(node).some(key => Object.hasOwn(re
     ? Object.fromEntries(Object.entries(node).map(([key, value]) => [renamedKeys[key] ?? key, value]))
     : node;
 const withTypology = (node) => {
-    if (versionTypeValues.has(node['@type'])) {
-        return { ...node, '@type': 'Version', versionType: node['@type'] };
+    if (retiredVersionTypes.has(node['@type'])) {
+        return { ...node, '@type': 'Version' };
     }
     if (conditionTypeValues.has(node['@type'])) {
         return { ...node, '@type': 'ConditionState', conditionType: node['@type'] };
     }
     return node;
 };
+/** A version once stated whether it served as a master or stood on one copy. */
+const withoutVersionType = (node) => {
+    if (!Object.hasOwn(node, 'versionType'))
+        return node;
+    const { versionType: _retired, ...rest } = node;
+    return rest;
+};
 const withReferences = (node) => referenceKeys.reduce((result, key) => {
     const reference = result[key];
     if (reference && typeof reference === 'object' && '@value' in reference) {
@@ -88,7 +94,7 @@ const withoutEmptyKeeper = (node) => {
     const { keeper: _unnamed, ...rest } = node;
     return rest;
 };
-const migrateNode = (node) => [withRenamedKeys, withTypology, withReferences, withKeeper, withoutEmptyKeeper, withProductionNodes, withScale,
+const migrateNode = (node) => [withRenamedKeys, withTypology, withoutVersionType, withReferences, withKeeper, withoutEmptyKeeper, withProductionNodes, withScale,
     withDerivationList, withReadingKind]
     .reduce((result, step) => step(result), node);
 /** The items each walked, or the very same list where the walk changed none. */

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', 'type-not-stated', 'witnessed-by-statement-only'];
+export declare const versionReservationTypes: readonly ['text-not-stated', 'witnessed-by-statement-only'];
 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,17 +102,12 @@ const checks = [
 export const reservationsAbout = (copy) => checks.flatMap(check => check(copy) ?? []);
 export const versionReservationTypes = [
     'text-not-stated',
-    'type-not-stated',
     'witnessed-by-statement-only'
 ];
 const textStated = (_view, version) => version.edits ? undefined : {
     type: 'text-not-stated',
     note: 'The version does not state its edits, so it reads as the version it derives from.'
 };
-const typeStated = (_view, version) => version.versionType ? undefined : {
-    type: 'type-not-stated',
-    note: 'The version does not say whether it served as a master for several copies or exists on one only.'
-};
 const witnessedByFeatures = (view, version) => {
     const witnesses = witnessesOf(view, version.id);
     return witnesses.length > 0 && witnesses.every(({ by }) => by === 'statement') ? {
@@ -120,6 +115,6 @@ 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, typeStated, witnessedByFeatures];
+const versionChecks = [textStated, witnessedByFeatures];
 /** 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/lib/schema.json

@@ -2271,7 +2271,7 @@
                     "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.",
+                    "description": "A short siglum to identify the copy, e.g. \"St1\" or \"Wi1\": letters for the collection the copy was read in, and a number counting the copies of the roll held there. A copy without one is named by its keeper.",
                     "type": "string",
                     "ontology": "reo:siglum"
                 },
@@ -2446,7 +2446,7 @@
                     "type": "array"
                 },
                 "siglum": {
-                    "description": "A short siglum to identify the version, e.g. \"A\", \"B1\", \"B2_rev\", etc.",
+                    "description": "A short siglum to identify the version, e.g. \"A\" or \"B2\". A siglum is given once and not changed: its letter names the line the version was first recognised in, its number counts the versions admitted to that line. Where later work places the version elsewhere in the stemma, `basedOn` changes and the siglum stays.",
                     "type": "string",
                     "ontology": "reo:siglum"
                 },
@@ -2455,11 +2455,6 @@
                     "description": "The reproducing system this version is coded for. One roll was often issued for several of them, and a version is a reading in one system's words: its expression types are that system's vocabulary and its notes sit on that bar's positions. A system the type vocabulary knows carries the IRI of its concept as `id`, from which the export takes the system's own context.",
                     "ontology": "crm:P2 has type"
                 },
-                "versionType": {
-                    "$ref": "#/definitions/VersionType",
-                    "description": "Whether the version served as a master for reproductions or exists on one copy only. Left out where that is not known, as for a version only a secondary witness hints at.",
-                    "ontology": "crm:P2 has type"
-                },
                 "@id": {
                     "description": "A unique identifier for this object.",
                     "type": "string"
@@ -2503,14 +2498,6 @@
             "type": "object",
             "ontology": "lrmoo:F28 Expression Creation"
         },
-        "VersionType": {
-            "description": "The type of a version. An 'edition' version may serve as the master for several roll copies; a 'unicum' version exists only on one specific copy.",
-            "enum": [
-                "edition",
-                "unicum"
-            ],
-            "type": "string"
-        },
         "VerticalSpan": {
             "description": "Describes the vertical extent of a feature on the roll, measured in track numbers. Track numbers correspond to positions on the tracker bar.",
             "properties": {

package/lib/spec/context.json

@@ -249,11 +249,6 @@
             "@context": { "@vocab": "https://w3id.org/reo/type/" }
         },
         "siglum": "reo:siglum",
-        "versionType": {
-            "@id": "crm:P2_has_type",
-            "@type": "@vocab",
-            "@context": { "@vocab": "https://w3id.org/reo/type/" }
-        },
         "basedOn": "lrmoo:R76_is_derivative_of",
         "edits": "reo:involvedEdit",
         "motivations": "@included",

package/package.json

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