linked-rolls 0.4.0 → 0.5.0

package/lib/RollCopy.d.ts

@@ -51,6 +51,10 @@ export interface Shift {
 }
 export declare const applyShift: (shift: Shift, copy: RollCopy) => void;
 export declare const applyStretch: (paperStretch: ObjectAssumption<PaperStretch>, copy: RollCopy) => void;
+/** Takes the shift off the copy's features again, as far as one was applied. */
+export declare const revertShift: (copy: RollCopy) => void;
+/** Takes the stretch off the copy's features again, as far as one was applied. */
+export declare const revertStretch: (copy: RollCopy) => void;
 /**
  * A date value wrapped as an assumption, so that the date
  * can be annotated with a belief about its certainty and source.

package/lib/RollCopy.js

@@ -39,6 +39,39 @@ export const applyStretch = (paperStretch, copy) => {
     copy.ops = [...copy.ops, 'stretched'];
     copy.conditions.push(paperStretch);
 };
+/** Takes the shift off the copy's features again, as far as one was applied. */
+export const revertShift = (copy) => {
+    const shift = copy.measurements.shift;
+    if (!copy.ops.includes('shifted') || !shift)
+        return;
+    copy.features.forEach(feature => {
+        feature.horizontal.from -= shift.horizontal;
+        if (feature.horizontal.to) {
+            feature.horizontal.to -= shift.horizontal;
+        }
+        feature.vertical.from -= shift.vertical;
+        if (feature.vertical.to) {
+            feature.vertical.to -= shift.vertical;
+        }
+    });
+    copy.ops = copy.ops.filter(op => op !== 'shifted');
+    delete copy.measurements.shift;
+};
+const isPaperStretch = (condition) => condition.conditionType === 'paper-stretch';
+/** Takes the stretch off the copy's features again, as far as one was applied. */
+export const revertStretch = (copy) => {
+    const stretch = copy.conditions.find(isPaperStretch);
+    if (!copy.ops.includes('stretched') || !stretch)
+        return;
+    copy.features.forEach(feature => {
+        feature.horizontal.from /= stretch.factor;
+        if (feature.horizontal.to) {
+            feature.horizontal.to /= stretch.factor;
+        }
+    });
+    copy.ops = copy.ops.filter(op => op !== 'stretched');
+    copy.conditions = copy.conditions.filter(condition => !isPaperStretch(condition));
+};
 /**
  * Reads the features of a copy as the tracker bar would read them.
  * Holes on a position the bar does not read carry no symbol and are

package/lib/Symbol.d.ts

@@ -19,6 +19,7 @@ export interface Symbol<T extends string> extends WithId {
     carriers: ReferenceAssumption[];
 }
 export declare const isSymbol: (object: any) => object is AnySymbol;
+export declare const isPerforation: (symbol: object | undefined) => symbol is AnyPerforation;
 /**
  * A perforation is a symbol that is typically encoded as a single punched
  * hole or a group of punched holes in the physical carrier.
@@ -141,4 +142,5 @@ export interface Text extends Symbol<'text'> {
  * Notes and expressions are perforations; texts are carried by writings.
  */
 export type AnySymbol = Note | Expression | Text;
+export type AnyPerforation = Note | Expression;
 export {};

package/lib/Symbol.js

@@ -3,6 +3,7 @@ export const isSymbol = (object) => {
     return ('type' in object
         && (object.type === 'note' || object.type === 'expression' || object.type === 'text'));
 };
+export const isPerforation = (symbol) => symbol !== undefined && 'type' in symbol && (symbol.type === 'note' || symbol.type === 'expression');
 export const placementRelations = ['alignedWith', 'before', 'after'];
 /**
  * The statements placing a perforation relative to others, alignment

package/lib/editionOps.d.ts

@@ -0,0 +1,76 @@
+import { Draft } from "immer";
+import { EditionView, Path } from "./EditionView";
+import { Edition } from "./Edition";
+import { AnySymbol, PlacementRelation } from "./Symbol";
+import { CollationTolerance } from "./Collation";
+import { Edit } from "./Edit";
+import { PaperStretch, RollCopy, Shift } from "./RollCopy";
+import { AnyArgumentation, Certainty, ObjectAssumption } from "./Assumption";
+/**
+ * A change to an edition, written onto an immer draft of it. One
+ * operation is one undo step, so an operation that has to read the
+ * edition first takes an `EditionView` of the state it will be
+ * applied to and does all its writing in the one function it returns.
+ */
+export type EditionOp = (draft: Draft<Edition>) => void;
+/**
+ * Puts the copy into the edition with a version of its own, which
+ * inserts every symbol the tracker bar reads on the copy.
+ */
+export declare const createVersion: (siglum: string, copy: RollCopy) => EditionOp;
+/** Shifts and then stretches the copy's features into line with another copy's. */
+export declare const alignCopy: (copyId: string, shift: Shift, stretch: ObjectAssumption<PaperStretch>) => EditionOp;
+/** Puts the copy's features back where they were measured. */
+export declare const unalignCopy: (copyId: string) => EditionOp;
+/** The symbols of the versions that no other copy carries. */
+export declare const symbolsCarriedOnlyBy: (edition: Edition, copyId: string) => AnySymbol[];
+/** Takes the features off the copy, and out of the versions with what only they carried. */
+export declare const removeFeatures: (copyId: string, featureIds: readonly string[]) => EditionOp;
+/**
+ * Takes the copy out of the edition together with the symbols only it
+ * carries, and with every reference the versions made to those symbols.
+ */
+export declare const removeCopy: (copyId: string) => EditionOp;
+/**
+ * Bases the child on the parent. A symbol of the child that collates
+ * with one the parent hands down adds its carriers to that symbol; the
+ * rest become the child's insertions, and what the parent hands down
+ * and the child lacks becomes its deletions.
+ */
+export declare const connectVersions: (view: EditionView, childId: string, parentId: string, tolerance?: CollationTolerance) => EditionOp;
+/**
+ * Folds the version's own symbols into those it inherits and collates
+ * with: the carriers pass over, and the insertions go.
+ */
+export declare const collateSymbols: (view: EditionView, versionId: string, symbolIds: readonly string[], tolerance?: CollationTolerance) => EditionOp;
+/**
+ * Makes the version stand on its own: what it inherited becomes its
+ * own insertions, and the link to the version it was based on goes,
+ * with the motivations that belonged to that derivation.
+ */
+export declare const detachVersion: (view: EditionView, versionId: string) => EditionOp;
+/** Takes the version out; whatever was based on it comes to stand on its own. */
+export declare const removeVersion: (view: EditionView, versionId: string) => EditionOp;
+/** Takes the symbols out of the version's own insertions, and the edits that had nothing else. */
+export declare const removeSymbols: (versionId: string, symbolIds: readonly string[]) => EditionOp;
+/** Moves the edits into a new version based on this one. */
+export declare const deriveVersion: (versionId: string, editIds: readonly string[]) => EditionOp;
+/**
+ * Replaces the edits with a single one carrying all their insertions
+ * and deletions, classified by a guess at what the exchange does.
+ */
+export declare const mergeEdits: (view: EditionView, versionId: string, toMerge: readonly Edit[]) => EditionOp;
+/** Replaces the edit with one edit per inserted and one per deleted symbol. */
+export declare const splitEdit: (versionId: string, toSplit: Edit) => EditionOp;
+/** States how the follower is placed relative to the reference, in place of any earlier statement. */
+export declare const placePerforation: (view: EditionView, followerId: string, referenceId: string, relation: PlacementRelation) => EditionOp;
+export declare const unplacePerforation: (view: EditionView, followerId: string) => EditionOp;
+/** The pair is stated on `statingId` only, as the format asks. */
+export declare const pairPerforations: (view: EditionView, statingId: string, partnerId: string) => EditionOp;
+export declare const unpairPerforation: (view: EditionView, statingId: string) => EditionOp;
+/** Annotates the assumption at the path with a belief held true, for reasons to be added. */
+export declare const createBelief: (path: Path) => EditionOp;
+export declare const clearBelief: (path: Path) => EditionOp;
+export declare const setCertainty: (path: Path, certainty: Certainty) => EditionOp;
+export declare const addReason: (path: Path, reason: AnyArgumentation) => EditionOp;
+export declare const removeReason: (path: Path, index: number) => EditionOp;

package/lib/editionOps.js

@@ -0,0 +1,315 @@
+import { v4 } from "uuid";
+import { getAt } from "./EditionView";
+import { isPerforation, placementRelations } from "./Symbol";
+import { applyShift, applyStretch, asSymbols, revertShift, revertStretch } from "./RollCopy";
+import { assignReference, idOf } from "./Assumption";
+const noChange = () => undefined;
+const onCopy = (copyId, op) => draft => {
+    const copy = draft.copies.find(c => c.id === copyId);
+    if (copy)
+        op(copy, draft);
+};
+const onVersion = (versionId, op) => draft => {
+    const version = draft.versions.find(v => v.id === versionId);
+    if (version)
+        op(version, draft);
+};
+/** The items that do not match, or the very same array when none does, so that a draft stays untouched. */
+const without = (items, matches) => items.some(matches) ? items.filter(item => !matches(item)) : items;
+const defaultTolerance = { toleranceStart: 5, toleranceEnd: 5 };
+const insertion = (symbol) => ({ type: 'edit', id: v4(), insert: [symbol] });
+const deletion = (symbolId) => ({ type: 'edit', id: v4(), delete: [symbolId] });
+const isEmpty = (edit) => !edit.insert?.length && !edit.delete?.length;
+const insertedIn = (versions) => versions.flatMap(version => version.edits).flatMap(edit => edit.insert ?? []);
+/** Runs the change over the version's edits and drops those it emptied, leaving edits that were empty before alone. */
+const editing = (version, change) => {
+    const emptyBefore = new Set(version.edits.filter(isEmpty).map(edit => edit.id));
+    version.edits.forEach(change);
+    version.edits = without(version.edits, edit => isEmpty(edit) && !emptyBefore.has(edit.id));
+};
+/** Takes the symbols out of the version's own insertions. */
+const dropInsertions = (version, symbolIds) => editing(version, edit => {
+    if (edit.insert)
+        edit.insert = without(edit.insert, symbol => symbolIds.has(symbol.id));
+});
+/**
+ * Puts the copy into the edition with a version of its own, which
+ * inserts every symbol the tracker bar reads on the copy.
+ */
+export const createVersion = (siglum, copy) => draft => {
+    draft.copies.push(copy);
+    draft.versions.push({
+        type: 'Version',
+        id: v4(),
+        siglum,
+        versionType: 'edition',
+        edits: asSymbols(copy.features).map(insertion),
+        motivations: []
+    });
+};
+/** Shifts and then stretches the copy's features into line with another copy's. */
+export const alignCopy = (copyId, shift, stretch) => onCopy(copyId, copy => {
+    applyShift(shift, copy);
+    applyStretch(stretch, copy);
+});
+/** Puts the copy's features back where they were measured. */
+export const unalignCopy = (copyId) => onCopy(copyId, copy => {
+    revertStretch(copy);
+    revertShift(copy);
+});
+const featureIdsOf = (copy) => new Set(copy.features.map(feature => feature.id));
+/**
+ * A symbol every carrier of which lies among the features loses its
+ * evidence with them. A symbol without carriers, such as a label,
+ * stands on its own.
+ */
+const carriedOnlyOn = (features) => (symbol) => symbol.carriers.length > 0 && symbol.carriers.every(carrier => features.has(idOf(carrier)));
+/** The symbols of the versions that no other copy carries. */
+export const symbolsCarriedOnlyBy = (edition, copyId) => {
+    const copy = edition.copies.find(c => c.id === copyId);
+    return copy ? insertedIn(edition.versions).filter(carriedOnlyOn(featureIdsOf(copy))) : [];
+};
+const references = [...placementRelations, 'pairedWith'];
+const forgetPerforations = (perforation, dropped) => references
+    .filter(relation => {
+    const reference = perforation[relation];
+    return reference && dropped.has(idOf(reference));
+})
+    .forEach(relation => { delete perforation[relation]; });
+const forgetCarriers = (symbol, features, dropped) => {
+    symbol.carriers = without(symbol.carriers, carrier => features.has(idOf(carrier)));
+    if (isPerforation(symbol))
+        forgetPerforations(symbol, dropped);
+};
+const forgetFeaturesInEdit = (edit, features, dropped) => {
+    if (edit.insert) {
+        edit.insert = without(edit.insert, symbol => dropped.has(symbol.id));
+        edit.insert.forEach(symbol => forgetCarriers(symbol, features, dropped));
+    }
+    if (edit.delete) {
+        edit.delete = without(edit.delete, id => dropped.has(id));
+    }
+};
+/**
+ * Strikes the features from the versions: their carriers go, a symbol
+ * that had no other carrier goes with them, and so does every
+ * reference the versions made to such a symbol.
+ */
+const forgetFeatures = (draft, features) => {
+    const dropped = new Set(insertedIn(draft.versions).filter(carriedOnlyOn(features)).map(symbol => symbol.id));
+    draft.versions.forEach(version => editing(version, edit => forgetFeaturesInEdit(edit, features, dropped)));
+};
+/** Takes the features off the copy, and out of the versions with what only they carried. */
+export const removeFeatures = (copyId, featureIds) => onCopy(copyId, (copy, draft) => {
+    const features = new Set(featureIds);
+    copy.features = without(copy.features, feature => features.has(feature.id));
+    forgetFeatures(draft, features);
+});
+/**
+ * Takes the copy out of the edition together with the symbols only it
+ * carries, and with every reference the versions made to those symbols.
+ */
+export const removeCopy = (copyId) => onCopy(copyId, (copy, draft) => {
+    forgetFeatures(draft, featureIdsOf(copy));
+    draft.copies = draft.copies.filter(c => c.id !== copyId);
+});
+/** Each of the version's own symbols with every inherited symbol it collates with. */
+const collationsOf = (view, own, inherited, tolerance) => own.flatMap(symbol => inherited
+    .filter(candidate => view.isCollatable(symbol, candidate, tolerance))
+    .map(counterpart => ({ symbol, counterpart })));
+/** The carriers of each collated symbol pass to its counterpart. */
+const handOverCarriers = (view, draft, collations) => collations.forEach(({ symbol, counterpart }) => {
+    const path = view.getPath(counterpart.id);
+    const target = path && getAt(path, draft);
+    target?.carriers.push(...symbol.carriers);
+});
+/**
+ * Bases the child on the parent. A symbol of the child that collates
+ * with one the parent hands down adds its carriers to that symbol; the
+ * rest become the child's insertions, and what the parent hands down
+ * and the child lacks becomes its deletions.
+ */
+export const connectVersions = (view, childId, parentId, tolerance = defaultTolerance) => {
+    const inherited = view.snapshot(parentId);
+    const own = view.snapshot(childId);
+    const collations = collationsOf(view, own, inherited, tolerance);
+    const collated = new Set(collations.map(({ symbol }) => symbol.id));
+    const matched = new Set(collations.map(({ counterpart }) => counterpart.id));
+    const edits = [
+        ...own.filter(symbol => !collated.has(symbol.id)).map(insertion),
+        ...inherited.filter(symbol => !matched.has(symbol.id)).map(symbol => deletion(symbol.id))
+    ];
+    return onVersion(childId, (child, draft) => {
+        handOverCarriers(view, draft, collations);
+        child.edits = edits;
+        child.basedOn = assignReference(parentId);
+    });
+};
+/**
+ * Folds the version's own symbols into those it inherits and collates
+ * with: the carriers pass over, and the insertions go.
+ */
+export const collateSymbols = (view, versionId, symbolIds, tolerance = defaultTolerance) => {
+    const version = view.get(versionId);
+    if (!version?.basedOn)
+        return noChange;
+    const chosen = new Set(symbolIds);
+    const own = insertedIn([version]).filter(symbol => chosen.has(symbol.id));
+    const collations = collationsOf(view, own, view.snapshot(idOf(version.basedOn)), tolerance);
+    const collated = new Set(collations.map(({ symbol }) => symbol.id));
+    return onVersion(versionId, (version, draft) => {
+        handOverCarriers(view, draft, collations);
+        dropInsertions(version, collated);
+    });
+};
+/**
+ * Makes the version stand on its own: what it inherited becomes its
+ * own insertions, and the link to the version it was based on goes,
+ * with the motivations that belonged to that derivation.
+ */
+export const detachVersion = (view, versionId) => {
+    const edits = view.snapshot(versionId).map(insertion);
+    return onVersion(versionId, version => {
+        version.edits = edits;
+        delete version.basedOn;
+        version.motivations = [];
+    });
+};
+/** Takes the version out; whatever was based on it comes to stand on its own. */
+export const removeVersion = (view, versionId) => {
+    const detachments = view.edition.versions
+        .filter(version => version.basedOn && idOf(version.basedOn) === versionId)
+        .map(version => detachVersion(view, version.id));
+    return draft => {
+        detachments.forEach(detach => detach(draft));
+        draft.versions = without(draft.versions, version => version.id === 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)));
+/** 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);
+    const moved = version.edits.filter(edit => chosen.has(edit.id));
+    version.edits = without(version.edits, edit => chosen.has(edit.id));
+    draft.versions.push({
+        type: 'Version',
+        id: v4(),
+        siglum: `${version.siglum}_derived`,
+        versionType: 'unicum',
+        basedOn: assignReference(versionId),
+        edits: moved,
+        motivations: []
+    });
+});
+const sameSequence = (a, b) => a.length === b.length && a.every((value, i) => value === b[i]);
+const expressionTypesOf = (symbols) => symbols.filter((symbol) => symbol.type === 'expression').map(symbol => symbol.expressionType);
+const accents = [['SlowCrescendoOn', 'SlowCrescendoOff'], ['ForzandoOn', 'ForzandoOff']];
+const lengthOf = (span) => span.to - span.from;
+/** Shorten or prolong, where the inserted symbol starts about where the deleted one did. */
+const replacementType = (view, inserted, deleted) => {
+    const after = view.dimensionOf(inserted)?.horizontal;
+    const before = view.dimensionOf(deleted)?.horizontal;
+    if (!after || !before || Math.abs(after.from - before.from) >= 5)
+        return undefined;
+    return lengthOf(after) < lengthOf(before) ? 'shorten' : 'prolong';
+};
+/** A guess at what an edit does, from the symbols it exchanges. */
+const guessEditType = (view, edit) => {
+    const inserts = edit.insert ?? [];
+    const deletes = view.getAll(edit.delete ?? []);
+    const inserted = expressionTypesOf(inserts);
+    const deleted = expressionTypesOf(deletes);
+    if (deleted.length === 0 && accents.some(accent => sameSequence(inserted, accent)))
+        return 'additional-accent';
+    if (inserted.length > 1 && sameSequence(inserted, deleted))
+        return 'shift';
+    if (inserted.length === 0 && deleted.length === 1)
+        return 'remove-redundancy';
+    if (inserts.length === 1 && deletes.length === 1)
+        return replacementType(view, inserts[0], deletes[0]) ?? 'correct-error';
+    return 'correct-error';
+};
+/**
+ * Replaces the edits with a single one carrying all their insertions
+ * and deletions, classified by a guess at what the exchange does.
+ */
+export const mergeEdits = (view, versionId, toMerge) => {
+    if (toMerge.length === 0)
+        return noChange;
+    const merged = {
+        ...toMerge[0],
+        id: v4(),
+        insert: toMerge.flatMap(edit => edit.insert ?? []),
+        delete: toMerge.flatMap(edit => edit.delete ?? [])
+    };
+    merged.editType = guessEditType(view, merged);
+    const mergedIds = new Set(toMerge.map(edit => edit.id));
+    return onVersion(versionId, version => {
+        version.edits = [...version.edits.filter(edit => !mergedIds.has(edit.id)), merged];
+    });
+};
+/** Replaces the edit with one edit per inserted and one per deleted symbol. */
+export const splitEdit = (versionId, toSplit) => {
+    const parts = [
+        ...(toSplit.insert ?? []).map(insertion),
+        ...(toSplit.delete ?? []).map(deletion)
+    ];
+    return onVersion(versionId, version => {
+        version.edits = [...version.edits.filter(edit => edit.id !== toSplit.id), ...parts];
+    });
+};
+/**
+ * Runs the change on the perforation the view locates by id, in whichever
+ * version inserted it. A statement made there holds in every version
+ * that carries the perforation.
+ */
+const onPerforation = (view, id, op) => draft => {
+    const path = view.getPath(id);
+    const symbol = path && getAt(path, draft);
+    if (isPerforation(symbol))
+        op(symbol);
+};
+const clearPlacement = (perforation) => placementRelations.forEach(relation => { delete perforation[relation]; });
+/** States how the follower is placed relative to the reference, in place of any earlier statement. */
+export const placePerforation = (view, followerId, referenceId, relation) => onPerforation(view, followerId, perforation => {
+    clearPlacement(perforation);
+    perforation[relation] = assignReference(referenceId);
+});
+export const unplacePerforation = (view, followerId) => onPerforation(view, followerId, clearPlacement);
+/** The pair is stated on `statingId` only, as the format asks. */
+export const pairPerforations = (view, statingId, partnerId) => onPerforation(view, statingId, perforation => {
+    perforation.pairedWith = assignReference(partnerId);
+});
+export const unpairPerforation = (view, statingId) => onPerforation(view, statingId, perforation => {
+    delete perforation.pairedWith;
+});
+const onAssumptionAt = (path, op) => draft => {
+    const assumption = getAt(path, draft);
+    if (assumption)
+        op(assumption);
+};
+const onBeliefAt = (path, op) => onAssumptionAt(path, assumption => {
+    const belief = assumption['@annotation']?.belief;
+    if (belief)
+        op(belief);
+});
+/** Annotates the assumption at the path with a belief held true, for reasons to be added. */
+export const createBelief = (path) => onAssumptionAt(path, assumption => {
+    assumption['@annotation'] = {
+        id: v4(),
+        belief: { type: 'belief', id: v4(), certainty: 'true', reasons: [] }
+    };
+});
+export const clearBelief = (path) => onAssumptionAt(path, assumption => {
+    delete assumption['@annotation'];
+});
+export const setCertainty = (path, certainty) => onBeliefAt(path, belief => {
+    belief.certainty = certainty;
+});
+export const addReason = (path, reason) => onBeliefAt(path, belief => {
+    belief.reasons.push(reason);
+});
+export const removeReason = (path, index) => onBeliefAt(path, belief => {
+    belief.reasons.splice(index, 1);
+});

package/lib/index.d.ts

@@ -16,6 +16,6 @@ export * from './TrackerBar';
 export * from './TrackCalibration';
 export * from './alignFeatures';
 export * from './EditionView';
-export * from './Plan';
+export * from './editionOps';
 export * from './validate';
 export * from './utils';

package/lib/index.js

@@ -16,6 +16,6 @@ export * from './TrackerBar';
 export * from './TrackCalibration';
 export * from './alignFeatures';
 export * from './EditionView';
-export * from './Plan';
+export * from './editionOps';
 export * from './validate';
 export * from './utils';

package/lib/schema.json

@@ -1189,7 +1189,7 @@
             ],
             "type": "object"
         },
-        "ObjectAssumption<alias-731470504-73739-73887-731470504-0-217694<def-interface-src_Symbol.ts-5565-5929-src_Symbol.ts-0-6137400334313,\"carriers\">>": {
+        "ObjectAssumption<alias-731470504-73739-73887-731470504-0-217694<def-interface-src_Symbol.ts-5758-6122-src_Symbol.ts-0-6378400334313,\"carriers\">>": {
             "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain.",
             "properties": {
                 "@annotation": {
@@ -1760,7 +1760,7 @@
                     "description": "The method by which this writing was produced (e.g. through print, handwriting, or stamping). [ontology: crm:P2 has type]"
                 },
                 "transcription": {
-                    "$ref": "#/definitions/ObjectAssumption%3Calias-731470504-73739-73887-731470504-0-217694%3Cdef-interface-src_Symbol.ts-5565-5929-src_Symbol.ts-0-6137400334313%2C%22carriers%22%3E%3E",
+                    "$ref": "#/definitions/ObjectAssumption%3Calias-731470504-73739-73887-731470504-0-217694%3Cdef-interface-src_Symbol.ts-5758-6122-src_Symbol.ts-0-6378400334313%2C%22carriers%22%3E%3E",
                     "description": "A transcription of the text content of the writing. This is an object assumption so that the transcription can be annotated with a belief about its correctness. [ontology: crm:P128 carries]"
                 },
                 "vertical": {

package/lib/validate.js

@@ -1,7 +1,7 @@
 import Ajv from "ajv";
 import * as schema from "./schema.json";
 import { idOf } from "./Assumption";
-import { pairsAmong, placementsOf } from "./Symbol";
+import { isPerforation, pairsAmong, placementsOf } from "./Symbol";
 const ajv = new Ajv({
     strict: false,
     formats: {
@@ -15,7 +15,6 @@ const missingReference = {
     before: 'before-reference-missing',
     after: 'after-reference-missing'
 };
-const isPerforation = (symbol) => symbol.type !== 'text';
 const problemsIn = (version, perforations) => {
     const ids = new Set(perforations.map(p => p.id));
     const report = (symbol, problem) => ({ version, symbol, problem });

package/package.json

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

package/lib/Plan.d.ts

@@ -1,190 +0,0 @@
-import { Draft } from "immer";
-import { EditionView } from "./EditionView";
-import { Edition } from "./Edition";
-import { CollationTolerance } from "./Collation";
-import { Edit } from "./Edit";
-import { RollCopy } from "./RollCopy";
-export type EditionOp = (d: Draft<Edition>) => void;
-export interface Plan {
-    build(): EditionOp[];
-    setView: (view: EditionView) => void;
-}
-export declare const isPlan: (obj: any) => obj is Plan;
-export declare abstract class BasePlan implements Plan {
-    protected view: EditionView | null;
-    setView: (view: EditionView) => void;
-    abstract build(): EditionOp[];
-}
-/**
- * Walks through the versions. If it finds a symbol that is still
- * part of the tradition (i.e. it is included in the current snapshot)
- * and is equivalent with the given symbol, it will add the feature
- * carrying the symbol to the collated symbol. Otherwise, the
- * given symbol will be added to the current version's insertions.
- *
- * All symbols of the tradition that are not included in the given
- * symbols are considered to be deleted.
- *
- * @param creation
- * @param symbols
- * @returns
- */
-export declare class ConnectVersions extends BasePlan {
-    private childId;
-    private parentId;
-    private tolerance;
-    constructor(childId: string, parentId: string, tolerance?: CollationTolerance);
-    build(): EditionOp[];
-}
-/**
- * Walks through the versions. If it finds a symbol that is still
- * part of the tradition (i.e. it is included in the current snapshot)
- * and is equivalent with the given symbol, it will add the feature
- * carrying the symbol to the collated symbol. Otherwise, the
- * given symbol will be added to the current version's insertions.
- *
- * All symbols of the tradition that are not included in the given
- * symbols are considered to be deleted.
- *
- * @param creation
- * @param symbols
- * @returns
- */
-export declare class CreateVersion extends BasePlan {
-    private siglum;
-    private copy;
-    constructor(siglum: string, copy: RollCopy);
-    build(): EditionOp[];
-}
-/**
- * Creates a new version based on the given version
- * calculating the effect of a cover on existing symbols.
- 
-export class CoverPerforation extends BasePlan {
-    constructor(
-        private copyId: string,
-        private versionId: string,
-        private coverDimension: { horizontal: HorizontalSpan, vertical: VerticalSpan },
-        private material: string | undefined = undefined,
-    ) {
-        super()
-    }
-
-    build(): EditionOp[] {
-        const view = this.view
-        if (!view) return []
-
-        return [
-            (draft: Draft<Edition>): void => {
-                const version = draft.versions.find(v => v.id === this.versionId)
-                const copy = draft.copies.find(c => c.id === this.copyId)
-                if (!version || !copy) return
-
-                // find perforations in the snapshot that
-                // overlap with the cover
-                const overlappingSymbols =
-                    view.snapshot(this.versionId)
-                        .filter(symbol => {
-                            const dimension = view.dimensionOf(symbol)
-                            if (!dimension) return false
-
-                            return (
-                                (symbol.type === 'note' || symbol.type === 'expression') &&
-                                overlaps(dimension, this.coverDimension)
-                            )
-                        })
-
-                if (!overlappingSymbols.length) return undefined
-
-                const deepClone = JSON.parse(JSON.stringify(overlappingSymbols)) as AnySymbol[]
-
-                for (const symbol of deepClone) {
-                    //symbol.id = v4();
-                    const dimension = structuredClone(view.dimensionOf(symbol))
-                    if (!dimension) continue
-
-                    // check if the cover partially covers the beginning
-                    if (dimension.horizontal.from >= this.coverDimension.horizontal.from &&
-                        dimension.horizontal.from <= this.coverDimension.horizontal.to
-                    ) {
-                        dimension.horizontal.from = this.coverDimension.horizontal.to
-                    }
-
-                    // check if the cover partially covers the ending
-                    if (dimension.horizontal.to >= this.coverDimension.horizontal.from &&
-                        dimension.horizontal.to <= this.coverDimension.horizontal.to
-                    ) {
-                        dimension.horizontal.to = this.coverDimension.horizontal.from
-                    }
-
-                    const newFeature: RollFeature = {
-                        ...dimension,
-                        id: v4(),
-                    }
-
-                    copy.features.push(newFeature)
-                    symbol.id = `symbol-${v4().slice(0, 8)}`
-                    symbol.carriers = [assignReference(newFeature.id)]
-                }
-
-                const coverId = `cover-${v4().slice(0, 8)}`
-                copy.features.push({
-                    ...this.coverDimension,
-                    id: coverId,
-                })
-
-                const edit: Edit = {
-                    type: 'edit',
-                    id: v4(),
-                    delete: overlappingSymbols.map(s => s.id),
-                    insert: deepClone,
-                    intentionOf: [{
-                        type: 'cover',
-                        id: v4(),
-                        note: this.material,
-                        carriers: [assignReference(coverId)],
-                    }]
-                }
-
-                draft.versions.push({
-                    edits: [edit],
-                    id: v4(),
-                    basedOn: assignReference(version.id),
-                    siglum: version.siglum + ' rev',
-                    type: 'authorised-revision',
-                    motivations: [
-                        {
-                            type: 'motivation',
-                            note: 'Stanzfehler korrigiert',
-                            id: v4(),
-                        }
-                    ],
-                })
-            }]
-    }
-}
-    */
-export declare class DetachVersion extends BasePlan {
-    private versionId;
-    constructor(versionId: string);
-    build(): EditionOp[];
-}
-export declare class RemoveFeature extends BasePlan {
-    private copyID;
-    private featureIDs;
-    constructor(copyID: string, featureIDs: string[]);
-    build(): EditionOp[];
-}
-export declare class MergeEdits extends BasePlan {
-    private versionId;
-    private toMerge;
-    constructor(versionId: string, toMerge: Edit[]);
-    private guessMotivation;
-    build(): EditionOp[];
-}
-export declare class SplitEdit extends BasePlan {
-    private versionId;
-    private toSplit;
-    constructor(versionId: string, toSplit: Edit);
-    build(): EditionOp[];
-}

package/lib/Plan.js

@@ -1,556 +0,0 @@
-import { getAt } from "./EditionView";
-import { v4 } from "uuid";
-import { asSymbols } from "./RollCopy";
-import { assignReference, idOf } from "./Assumption";
-export const isPlan = (obj) => {
-    return obj && typeof obj.build === 'function' && typeof obj.setView === 'function';
-};
-export class BasePlan {
-    constructor() {
-        Object.defineProperty(this, "view", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "setView", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (view) => {
-                this.view = view;
-            }
-        });
-    }
-}
-/**
- * Walks through the versions. If it finds a symbol that is still
- * part of the tradition (i.e. it is included in the current snapshot)
- * and is equivalent with the given symbol, it will add the feature
- * carrying the symbol to the collated symbol. Otherwise, the
- * given symbol will be added to the current version's insertions.
- *
- * All symbols of the tradition that are not included in the given
- * symbols are considered to be deleted.
- *
- * @param creation
- * @param symbols
- * @returns
- */
-export class ConnectVersions extends BasePlan {
-    constructor(childId, parentId, tolerance = {
-        toleranceEnd: 5,
-        toleranceStart: 5
-    }) {
-        super();
-        Object.defineProperty(this, "childId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: childId
-        });
-        Object.defineProperty(this, "parentId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: parentId
-        });
-        Object.defineProperty(this, "tolerance", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: tolerance
-        });
-    }
-    build() {
-        if (!this.view)
-            return [];
-        const view = this.view;
-        const result = [];
-        const parentSnapshot = view.snapshot(this.parentId);
-        const childSnapshot = view.snapshot(this.childId);
-        const treatedSymbols = [];
-        // can the symbol be collated with any of the
-        // symbols of the tradition, i.e. the ones 
-        // included in the current snapshot?
-        const insertions = [...childSnapshot];
-        for (const symbol of childSnapshot) {
-            parentSnapshot
-                .filter(toCompare => view.isCollatable(symbol, toCompare, this.tolerance))
-                .forEach(parentSymbol => {
-                result.push(draft => {
-                    const symbolPath = view.getPath(parentSymbol.id);
-                    if (!symbolPath)
-                        return;
-                    const correspSymbol = getAt(symbolPath, draft);
-                    if (!correspSymbol)
-                        return;
-                    correspSymbol.carriers.push(...symbol.carriers);
-                });
-                insertions.splice(insertions.indexOf(symbol), 1);
-                treatedSymbols.push(parentSymbol);
-            });
-        }
-        const edits = insertions.map((symbol) => {
-            return {
-                type: 'edit',
-                id: v4(),
-                insert: [symbol],
-                delete: [],
-            };
-        });
-        const deletions = parentSnapshot.filter(sym => {
-            return !treatedSymbols.includes(sym);
-        });
-        for (const symbol of deletions) {
-            edits.push({
-                type: 'edit',
-                id: v4(),
-                insert: [],
-                delete: [symbol.id],
-            });
-        }
-        result.push(draft => {
-            const v = draft.versions.find(v => v.id === this.childId);
-            if (!v)
-                return;
-            v.edits = edits;
-            v.basedOn = assignReference(this.parentId);
-        });
-        return result;
-    }
-}
-/**
- * Walks through the versions. If it finds a symbol that is still
- * part of the tradition (i.e. it is included in the current snapshot)
- * and is equivalent with the given symbol, it will add the feature
- * carrying the symbol to the collated symbol. Otherwise, the
- * given symbol will be added to the current version's insertions.
- *
- * All symbols of the tradition that are not included in the given
- * symbols are considered to be deleted.
- *
- * @param creation
- * @param symbols
- * @returns
- */
-export class CreateVersion extends BasePlan {
-    constructor(siglum, copy) {
-        super();
-        Object.defineProperty(this, "siglum", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: siglum
-        });
-        Object.defineProperty(this, "copy", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: copy
-        });
-    }
-    build() {
-        const view = this.view;
-        if (!view)
-            return [];
-        const result = [];
-        result.push(draft => {
-            draft.copies.push(this.copy);
-            const newVersion = {
-                type: 'Version',
-                siglum: this.siglum,
-                id: v4(),
-                edits: asSymbols(this.copy.features).map((symbol) => {
-                    return {
-                        type: 'edit',
-                        id: v4(),
-                        insert: [symbol],
-                        delete: [],
-                    };
-                }),
-                versionType: 'edition',
-                motivations: []
-            };
-            draft.versions.push(newVersion);
-        });
-        return result;
-    }
-}
-/**
- * Creates a new version based on the given version
- * calculating the effect of a cover on existing symbols.
- 
-export class CoverPerforation extends BasePlan {
-    constructor(
-        private copyId: string,
-        private versionId: string,
-        private coverDimension: { horizontal: HorizontalSpan, vertical: VerticalSpan },
-        private material: string | undefined = undefined,
-    ) {
-        super()
-    }
-
-    build(): EditionOp[] {
-        const view = this.view
-        if (!view) return []
-
-        return [
-            (draft: Draft<Edition>): void => {
-                const version = draft.versions.find(v => v.id === this.versionId)
-                const copy = draft.copies.find(c => c.id === this.copyId)
-                if (!version || !copy) return
-
-                // find perforations in the snapshot that
-                // overlap with the cover
-                const overlappingSymbols =
-                    view.snapshot(this.versionId)
-                        .filter(symbol => {
-                            const dimension = view.dimensionOf(symbol)
-                            if (!dimension) return false
-
-                            return (
-                                (symbol.type === 'note' || symbol.type === 'expression') &&
-                                overlaps(dimension, this.coverDimension)
-                            )
-                        })
-
-                if (!overlappingSymbols.length) return undefined
-
-                const deepClone = JSON.parse(JSON.stringify(overlappingSymbols)) as AnySymbol[]
-
-                for (const symbol of deepClone) {
-                    //symbol.id = v4();
-                    const dimension = structuredClone(view.dimensionOf(symbol))
-                    if (!dimension) continue
-
-                    // check if the cover partially covers the beginning
-                    if (dimension.horizontal.from >= this.coverDimension.horizontal.from &&
-                        dimension.horizontal.from <= this.coverDimension.horizontal.to
-                    ) {
-                        dimension.horizontal.from = this.coverDimension.horizontal.to
-                    }
-
-                    // check if the cover partially covers the ending
-                    if (dimension.horizontal.to >= this.coverDimension.horizontal.from &&
-                        dimension.horizontal.to <= this.coverDimension.horizontal.to
-                    ) {
-                        dimension.horizontal.to = this.coverDimension.horizontal.from
-                    }
-
-                    const newFeature: RollFeature = {
-                        ...dimension,
-                        id: v4(),
-                    }
-
-                    copy.features.push(newFeature)
-                    symbol.id = `symbol-${v4().slice(0, 8)}`
-                    symbol.carriers = [assignReference(newFeature.id)]
-                }
-
-                const coverId = `cover-${v4().slice(0, 8)}`
-                copy.features.push({
-                    ...this.coverDimension,
-                    id: coverId,
-                })
-
-                const edit: Edit = {
-                    type: 'edit',
-                    id: v4(),
-                    delete: overlappingSymbols.map(s => s.id),
-                    insert: deepClone,
-                    intentionOf: [{
-                        type: 'cover',
-                        id: v4(),
-                        note: this.material,
-                        carriers: [assignReference(coverId)],
-                    }]
-                }
-
-                draft.versions.push({
-                    edits: [edit],
-                    id: v4(),
-                    basedOn: assignReference(version.id),
-                    siglum: version.siglum + ' rev',
-                    type: 'authorised-revision',
-                    motivations: [
-                        {
-                            type: 'motivation',
-                            note: 'Stanzfehler korrigiert',
-                            id: v4(),
-                        }
-                    ],
-                })
-            }]
-    }
-}
-    */
-export class DetachVersion extends BasePlan {
-    constructor(versionId) {
-        super();
-        Object.defineProperty(this, "versionId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: versionId
-        });
-    }
-    build() {
-        if (!this.view)
-            return [];
-        const snapshot = this.view.snapshot(this.versionId);
-        const newEdits = snapshot.map((symbol) => ({
-            type: 'edit',
-            id: v4(),
-            insert: [symbol],
-            delete: [],
-        }));
-        return [draft => {
-                const v = draft.versions.find(ver => ver.id === this.versionId);
-                if (!v)
-                    return;
-                v.edits = newEdits;
-                delete v.basedOn;
-                v.motivations = [];
-            }];
-    }
-}
-export class RemoveFeature extends BasePlan {
-    constructor(copyID, featureIDs) {
-        super();
-        Object.defineProperty(this, "copyID", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: copyID
-        });
-        Object.defineProperty(this, "featureIDs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: featureIDs
-        });
-    }
-    build() {
-        const view = this.view;
-        if (!view)
-            return [];
-        return [
-            (draft) => {
-                const copy = draft.copies.find(c => c.id === this.copyID);
-                if (!copy)
-                    return;
-                copy.features = copy.features.filter(f => !this.featureIDs.includes(f.id));
-                this.featureIDs.forEach(featureId => {
-                    // expect a path of format:
-                    // ['versions', index, 'edits', index, 'insert', index, 'carriers', index, 'id']
-                    const carrierPath = view.linksTo(featureId).at(0);
-                    if (!carrierPath)
-                        return;
-                    // expect to find the parent symbol at:
-                    // ['versions', index, 'edits', index, 'insert', index]
-                    const symbol = getAt(carrierPath.slice(0, 6), draft);
-                    if (!symbol)
-                        return;
-                    symbol.carriers = symbol.carriers.filter(c => idOf(c) !== featureId);
-                    // if the symbol has no more carriers, remove it
-                    if (symbol.carriers.length === 0) {
-                        // expect to find the parent edit at:
-                        // ['versions', index, 'edits', index]
-                        const inserts = getAt(carrierPath.slice(0, 5), draft);
-                        if (!inserts)
-                            return;
-                        inserts.splice(inserts.findIndex(s => s.id === symbol.id), 1);
-                        if (inserts.length === 0) {
-                            const edit = getAt(carrierPath.slice(0, 4), draft);
-                            if (!edit)
-                                return;
-                            if (!edit.insert?.length && !edit.delete?.length) {
-                                const edits = getAt(carrierPath.slice(0, 3), draft);
-                                if (!edits)
-                                    return;
-                                edits.splice(edits.findIndex(e => e.id === edit.id), 1);
-                            }
-                        }
-                    }
-                });
-            }
-        ];
-    }
-}
-export class MergeEdits extends BasePlan {
-    constructor(versionId, toMerge) {
-        super();
-        Object.defineProperty(this, "versionId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: versionId
-        });
-        Object.defineProperty(this, "toMerge", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: toMerge
-        });
-    }
-    guessMotivation(edit) {
-        const view = this.view;
-        if (!view)
-            return 'correct-error';
-        const inserts = (edit.insert || []);
-        const deletes = view.getAll(edit.delete ?? []);
-        const types = [
-            inserts.filter(e => e.type === 'expression').map(e => e.expressionType),
-            deletes.filter(e => e.type === 'expression').map(e => e.expressionType)
-        ];
-        if (arraysIdentical(types, [['SlowCrescendoOn', 'SlowCrescendoOff'], []])) {
-            return 'additional-accent';
-        }
-        else if (arraysIdentical(types, [['ForzandoOn', 'ForzandoOff'], []])) {
-            // TODO: check if the inserts are very close
-            // and return 'short-dynamic-differentation'
-            return 'additional-accent';
-        }
-        else if (types.every(t => t.length > 1) && arraysIdentical(types[0], types[1])) {
-            return 'shift';
-        }
-        else if (types[0].length === 0 && types[1].length === 1) {
-            return 'remove-redundancy';
-        }
-        if (inserts.length === 1 && deletes.length === 1) {
-            const insertDim = view.dimensionOf(inserts[0])?.horizontal;
-            const deleteDim = view.dimensionOf(deletes[0])?.horizontal;
-            if (!insertDim || !deleteDim) {
-                return 'correct-error';
-            }
-            if (Math.abs(insertDim.from - deleteDim.from) < 5) {
-                const insertLength = Math.abs(insertDim.to - insertDim.from);
-                const deleteLength = Math.abs(deleteDim.to - deleteDim.from);
-                if (insertLength < deleteLength) {
-                    return 'shorten';
-                }
-                else {
-                    return 'prolong';
-                }
-            }
-        }
-        return 'correct-error';
-    }
-    build() {
-        const view = this.view;
-        if (!view)
-            return [];
-        const result = structuredClone(this.toMerge[0]);
-        this.toMerge
-            .slice(1)
-            .forEach(edit => {
-            if (result.insert) {
-                result.insert.push(...(edit.insert || []));
-            }
-            else {
-                result.insert = edit.insert;
-            }
-            if (result.delete) {
-                result.delete.push(...(edit.delete || []));
-            }
-            else {
-                result.delete = edit.delete;
-            }
-        });
-        const edit = {
-            ...result,
-            id: v4(),
-            motivation: this.guessMotivation(result),
-        };
-        return ([draft => {
-                const version = draft.versions.find(v => v.id === this.versionId);
-                if (!version)
-                    return;
-                // remove all edits that were merged
-                for (const e of this.toMerge) {
-                    const index = version.edits.findIndex(ve => ve.id === e.id);
-                    if (index !== -1)
-                        version.edits.splice(index, 1);
-                }
-                version.edits.push(edit);
-            }]);
-    }
-}
-export class SplitEdit extends BasePlan {
-    constructor(versionId, toSplit) {
-        super();
-        Object.defineProperty(this, "versionId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: versionId
-        });
-        Object.defineProperty(this, "toSplit", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: toSplit
-        });
-    }
-    build() {
-        const view = this.view;
-        if (!view)
-            return [];
-        const result = [];
-        for (const insert of this.toSplit.insert ?? []) {
-            result.push({
-                type: 'edit',
-                id: v4(),
-                insert: [insert]
-            });
-        }
-        for (const remove of this.toSplit.delete ?? []) {
-            result.push({
-                type: 'edit',
-                id: v4(),
-                delete: [remove]
-            });
-        }
-        return ([draft => {
-                const version = draft.versions.find(v => v.id === this.versionId);
-                if (!version)
-                    return;
-                // remove the edit that is split
-                const index = version.edits.findIndex(ve => ve.id === this.toSplit.id);
-                if (index !== -1)
-                    version.edits.splice(index, 1);
-                version.edits.push(...result);
-            }]);
-    }
-}
-/*
-type LazyDimension = Partial<{ from: number, to: number }>;
-
-type LazyArea = {
-    horizontal: LazyDimension;
-    vertical: LazyDimension;
-}
-
-const overlaps = (a: LazyArea, b: LazyArea): boolean => {
-    const overlapsDimension = (a: LazyDimension, b: LazyDimension): boolean =>
-        (a.from ?? 0) < (b.to ?? Infinity) && (b.from ?? 0) < (a.to ?? Infinity);
-
-    // console.log('do the dimensions overlap?', a, b)
-
-    return overlapsDimension(a.horizontal, b.horizontal);
-}
-    */
-const arraysIdentical = (a, b) => {
-    let i = a.length;
-    if (i != b.length)
-        return false;
-    while (i--) {
-        if (Array.isArray(a[i]) && Array.isArray(b[i])) {
-            return arraysIdentical(a[i], b[i]);
-        }
-        if (a[i] !== b[i])
-            return false;
-    }
-    return true;
-};