linked-rolls 0.74.0 → 0.75.0

package/lib/model/Version.js

@@ -1,5 +1,25 @@
-import { certainties, certaintyOf, idOf } from "./Assumption.js";
+import { beliefIn, certainties, certaintyOf, idOf } from "./Assumption.js";
 import { defaultCollationTolerance } from "../collation/Collation.js";
+/**
+ * The motivation of an edit that puts right what the version it derives
+ * from got wrong: a perforation put in the wrong place, struck or left
+ * out. Whether a change corrects an error is not read off its shape, as
+ * its type is, but is a reason for it, and so the editor's to give.
+ * The edit types held it once, and a document written then is read with
+ * this motivation in place of that type.
+ * @category Versions and stemma
+ */
+export const correctedError = 'corrected-error';
+/**
+ * The version's statement of what the motivation of a corrected error
+ * means, to stand in its `motivations`.
+ * @category Versions and stemma
+ */
+export const correctedErrorMotivation = {
+    type: 'motivation',
+    id: correctedError,
+    note: 'Puts right an error of the version it derives from.'
+};
 /**
  * The tolerance the derivation was collated at, or the default where it states none.
  * @category Collation and alignment
@@ -22,12 +42,21 @@ export const insertedBy = (version) => editsOf(version).flatMap(edit => edit.ins
 export const deletedBy = (version) => editsOf(version).flatMap(edit => edit.delete ?? []);
 /**
  * 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.
+ * certainty its derivation is held with and the belief it rests on. Given
+ * the edition, a derivation that belongs to a proposition set, as an
+ * adopted stemma's do, is read with the belief of the set, and names it
+ * (`propositionSet`); without it, only a belief of its own is read.
  * @category Versions and stemma
  */
-export const derivationsOf = (version) => (version.basedOn ?? []).map(derivation => {
-    const belief = derivation['@annotation']?.belief;
-    return { parent: idOf(derivation), certainty: certaintyOf(derivation), ...(belief && { belief }) };
+export const derivationsOf = (version, edition = {}) => (version.basedOn ?? []).map(derivation => {
+    const belief = beliefIn(edition, derivation);
+    const set = derivation['@annotation']?.belief === undefined ? derivation['@annotation']?.id : undefined;
+    return {
+        parent: idOf(derivation),
+        certainty: belief?.certainty ?? 'true',
+        ...(belief && { belief }),
+        ...(set !== undefined && { propositionSet: set })
+    };
 });
 const rankOf = (derivation) => certainties.indexOf(certaintyOf(derivation));
 /**

package/lib/ops/edits.d.ts

@@ -2,7 +2,9 @@ import { Edit } from "../model/Edit.js";
 import { EditionOp } from "./draft.js";
 /**
  * Replaces the edits with a single one carrying all their insertions
- * and deletions, classified by a guess at what the exchange does.
+ * and deletions, classified by a guess at what the exchange does, where
+ * its shape says. The edit is the editor's: it belongs to no proposition
+ * set a program's run concluded, as one of those merged may have.
  * @category Operations
  */
 export declare const mergeEdits: (versionId: string, toMerge: readonly Edit[]) => EditionOp;

package/lib/ops/edits.js

@@ -1,6 +1,7 @@
 /** Merging and splitting the edits of a version. */
 import { v4 } from "uuid";
 import { editsOf } from "../model/Version.js";
+import { keyOf } from "../systems/TrackerBar.js";
 import { trackerBarOf } from "../systems/index.js";
 import { distance, mm, subtract } from "../model/Quantity.js";
 import { noChange, onVersion, insertion, deletion, reading } from "./draft.js";
@@ -22,9 +23,13 @@ const replacementType = (edition, inserted, deleted) => {
         return undefined;
     return lengthOf(after) < lengthOf(before) ? 'shorten' : 'prolong';
 };
+/** Whether the two symbols say the same thing, as a perforation put elsewhere does. */
+const sameKind = (a, b) => a.type !== 'text' && b.type !== 'text' && keyOf(a) === keyOf(b);
 /**
  * A guess at what an edit does, from the symbols it exchanges and from
- * the systems the version and the one it is based on are coded for.
+ * the systems the version and the one it is based on are coded for, or
+ * nothing where its shape does not say. Whether it corrects an error is
+ * not guessed: that is a motivation, the editor's to give.
  */
 const guessEditType = (edition, versionId, edit) => {
     const inserts = edit.insert ?? [];
@@ -56,25 +61,33 @@ const guessEditType = (edition, versionId, edit) => {
         return 'shift';
     if (inserted.length === 0 && deleted.length === 1)
         return 'remove-redundancy';
-    if (inserts.length === 1 && deletes.length === 1)
-        return replacementType(edition, inserts[0], deletes[0]) ?? 'correct-error';
-    return 'correct-error';
+    if (inserts.length === 1 && deletes.length === 1) {
+        return replacementType(edition, inserts[0], deletes[0]) ?? (sameKind(inserts[0], deletes[0]) ? 'shift' : undefined);
+    }
+    return undefined;
 };
 /**
  * Replaces the edits with a single one carrying all their insertions
- * and deletions, classified by a guess at what the exchange does.
+ * and deletions, classified by a guess at what the exchange does, where
+ * its shape says. The edit is the editor's: it belongs to no proposition
+ * set a program's run concluded, as one of those merged may have.
  * @category Operations
  */
 export const mergeEdits = (versionId, toMerge) => reading(edition => {
     if (toMerge.length === 0)
         return noChange;
+    // The edit is the editor's grouping, whatever set of a program's the first one belonged to.
+    const { editType: _guessed, '@annotation': annotation, ...first } = toMerge[0];
     const merged = {
-        ...toMerge[0],
+        ...first,
+        ...(annotation?.belief && { '@annotation': annotation }),
         id: v4(),
         insert: toMerge.flatMap(edit => edit.insert ?? []),
         delete: toMerge.flatMap(edit => edit.delete ?? [])
     };
-    merged.editType = guessEditType(edition, versionId, merged);
+    const editType = guessEditType(edition, versionId, merged);
+    if (editType)
+        merged.editType = editType;
     const mergedIds = new Set(toMerge.map(edit => edit.id));
     return onVersion(versionId, version => {
         version.edits = [...editsOf(version).filter(edit => !mergedIds.has(edit.id)), merged];