linked-rolls 0.75.0 → 0.76.0

package/lib/ops/edits.js

@@ -1,5 +1,6 @@
 /** Merging and splitting the edits of a version. */
 import { v4 } from "uuid";
+import { motivationProposedFor, musicalChange, technicalChange } from "../model/Edit.js";
 import { editsOf } from "../model/Version.js";
 import { keyOf } from "../systems/TrackerBar.js";
 import { trackerBarOf } from "../systems/index.js";
@@ -16,7 +17,7 @@ const lengthOf = (span) => subtract(span.to, span.from);
 /** How far apart two onsets may lie for the one symbol to count as a replacement of the other. */
 const REPLACEMENT_TOLERANCE = mm(5);
 /** Shorten or prolong, where the inserted symbol starts about where the deleted one did. */
-const replacementType = (edition, inserted, deleted) => {
+const replacementShape = (edition, inserted, deleted) => {
     const after = placeOf(edition, inserted);
     const before = placeOf(edition, deleted);
     if (!after || !before || distance(after.from, before.from) >= REPLACEMENT_TOLERANCE)
@@ -26,12 +27,14 @@ const replacementType = (edition, inserted, deleted) => {
 /** 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, 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.
+ * A guess at the shape of an edit, from the symbols it exchanges and
+ * from the systems the version and the one it is based on are coded
+ * for, or nothing where it takes no shape the guess knows. It looks at
+ * the edit alone: a single expression deleted is taken for a redundancy
+ * removed, which `proposeEdits` checks against the text.
+ * @category Lookups
  */
-const guessEditType = (edition, versionId, edit) => {
+export const shapeOf = (edition, versionId, edit) => {
     const inserts = edit.insert ?? [];
     const deletes = symbolsIn(edition, edit.delete ?? []);
     const inserted = expressionTypesOf(inserts);
@@ -45,8 +48,7 @@ const guessEditType = (edition, versionId, edit) => {
      * SforzandoForte says the same thing in the other system's words, and
      * a red command the green bar cannot read struck, or a green hold put
      * in where the red had no word for it, belongs to the same act. That
-     * is a recoding. Calling it a corrected error would say the editor
-     * made a mistake. Only an insertion spelling the bar's own accent
+     * is a recoding. Only an insertion spelling the bar's own accent
      * reads more narrowly, as the accent it spells.
      */
     const transferred = bar && parentBar && bar.id !== parentBar.id;
@@ -62,45 +64,51 @@ const guessEditType = (edition, versionId, edit) => {
     if (inserted.length === 0 && deleted.length === 1)
         return 'remove-redundancy';
     if (inserts.length === 1 && deletes.length === 1) {
-        return replacementType(edition, inserts[0], deletes[0]) ?? (sameKind(inserts[0], deletes[0]) ? 'shift' : undefined);
+        return replacementShape(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, 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.
+ * and deletions. It keeps the first motivation of the editor's that any
+ * of them states, and where none does, it has the one its shape calls
+ * for (`motivationProposedFor`), so that a merge says it is a musical
+ * or a technical change, unless the version derives from none. A
+ * grouping that says no more is the program's by rule
+ * (`isCollationsOwn`), until the editor says why it was made.
  * @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 { motivation: _first, ...first } = toMerge[0];
     const merged = {
         ...first,
-        ...(annotation?.belief && { '@annotation': annotation }),
         id: v4(),
         insert: toMerge.flatMap(edit => edit.insert ?? []),
         delete: toMerge.flatMap(edit => edit.delete ?? [])
     };
-    const editType = guessEditType(edition, versionId, merged);
-    if (editType)
-        merged.editType = editType;
+    const editors = toMerge.find(edit => edit.motivation !== undefined && edit.motivation !== musicalChange && edit.motivation !== technicalChange);
+    if (editors)
+        merged.motivation = editors.motivation;
+    else if (predecessorOf(edition, versionId))
+        merged.motivation = motivationProposedFor(shapeOf(edition, versionId, merged));
     const mergedIds = new Set(toMerge.map(edit => edit.id));
     return onVersion(versionId, version => {
         version.edits = [...editsOf(version).filter(edit => !mergedIds.has(edit.id)), merged];
     });
 });
 /**
- * Replaces the edit with one edit per inserted and one per deleted symbol.
+ * Replaces the edit with one edit per inserted and one per deleted
+ * symbol. Each part keeps the motivation of the edit, since splitting
+ * an edit does not change why it was made.
  * @category Operations
  */
 export const splitEdit = (versionId, toSplit) => {
+    const kept = toSplit.motivation === undefined ? {} : { motivation: toSplit.motivation };
     const parts = [
-        ...(toSplit.insert ?? []).map(insertion),
-        ...(toSplit.delete ?? []).map(deletion)
+        ...(toSplit.insert ?? []).map(symbol => ({ ...insertion(symbol), ...kept })),
+        ...(toSplit.delete ?? []).map(id => ({ ...deletion(id), ...kept }))
     ];
     return onVersion(versionId, version => {
         version.edits = [...editsOf(version).filter(edit => edit.id !== toSplit.id), ...parts];

package/lib/ops/index.d.ts

@@ -8,6 +8,6 @@ export { createVersion, addCopy, alignmentFor, alignCopy, alignCopies, chooseRef
 export { stateFeatureCondition, addFeature, addBorneFeature, removeFeatures, mergeObstacle, mergeObstacleIn, mergeFeatures, type FeatureAct, type MergeObstacle } from "./features.js";
 export { detachVersion, removeVersion, removeSymbols, deriveVersion, stateDerivation, clearDerivation } from "./versions.js";
 export { connectVersions, collateSymbols, separateReadings } from "./collation.js";
-export { mergeEdits, splitEdit } from "./edits.js";
+export { mergeEdits, splitEdit, shapeOf } from "./edits.js";
 export { placeCommand, unplaceCommand, pairCommands, unpairCommand } from "./commands.js";
 export { createBelief, clearBelief, setCertainty, addReason, removeReason } from "./beliefs.js";

package/lib/ops/index.js

@@ -8,6 +8,6 @@ export { createVersion, addCopy, alignmentFor, alignCopy, alignCopies, chooseRef
 export { stateFeatureCondition, addFeature, addBorneFeature, removeFeatures, mergeObstacle, mergeObstacleIn, mergeFeatures } from "./features.js";
 export { detachVersion, removeVersion, removeSymbols, deriveVersion, stateDerivation, clearDerivation } from "./versions.js";
 export { connectVersions, collateSymbols, separateReadings } from "./collation.js";
-export { mergeEdits, splitEdit } from "./edits.js";
+export { mergeEdits, splitEdit, shapeOf } from "./edits.js";
 export { placeCommand, unplaceCommand, pairCommands, unpairCommand } from "./commands.js";
 export { createBelief, clearBelief, setCertainty, addReason, removeReason } from "./beliefs.js";

package/lib/ops/versions.d.ts

@@ -5,8 +5,9 @@ import { EditionOp } from "./draft.js";
 export declare const hypothesesBeside: (version: Readonly<Version>, parentId: string) => Derivation[];
 /**
  * Makes the version stand on its own: what it inherited becomes its
- * own insertions, and its derivations go, the hypotheses among them,
- * with the motivations that belonged to them.
+ * own insertions, and its derivations go, the hypotheses among them.
+ * Its edits now state its text rather than a change, and say nothing of
+ * why they were made.
  * @category Operations
  */
 export declare const detachVersion: (versionId: string) => EditionOp;

package/lib/ops/versions.js

@@ -28,8 +28,9 @@ const dropDerivations = (version, matches) => {
 };
 /**
  * Makes the version stand on its own: what it inherited becomes its
- * own insertions, and its derivations go, the hypotheses among them,
- * with the motivations that belonged to them.
+ * own insertions, and its derivations go, the hypotheses among them.
+ * Its edits now state its text rather than a change, and say nothing of
+ * why they were made.
  * @category Operations
  */
 export const detachVersion = (versionId) => reading(edition => {
@@ -37,7 +38,6 @@ export const detachVersion = (versionId) => reading(edition => {
     return onVersion(versionId, version => {
         version.edits = edits;
         delete version.basedOn;
-        version.motivations = [];
     });
 });
 /**
@@ -76,8 +76,7 @@ export const deriveVersion = (versionId, editIds) => onVersion(versionId, (versi
         id: v4(),
         system: stateOf(version).system,
         basedOn: [assignReference(versionId)],
-        edits: moved,
-        motivations: []
+        edits: moved
     });
 });
 /**