linked-rolls 0.4.0 → 0.4.1

package/lib/Plan.d.ts

@@ -1,6 +1,7 @@
 import { Draft } from "immer";
 import { EditionView } from "./EditionView";
 import { Edition } from "./Edition";
+import { AnySymbol } from "./Symbol";
 import { CollationTolerance } from "./Collation";
 import { Edit } from "./Edit";
 import { RollCopy } from "./RollCopy";
@@ -175,6 +176,13 @@ export declare class RemoveFeature extends BasePlan {
     constructor(copyID: string, featureIDs: string[]);
     build(): EditionOp[];
 }
+/** The symbols of the versions that no other copy carries. */
+export declare const symbolsCarriedOnlyBy: (edition: Edition, copyId: string) => AnySymbol[];
+/**
+ * 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;
 export declare class MergeEdits extends BasePlan {
     private versionId;
     private toMerge;

package/lib/Plan.js

@@ -1,4 +1,5 @@
 import { getAt } from "./EditionView";
+import { isPerforation, placementRelations } from "./Symbol";
 import { v4 } from "uuid";
 import { asSymbols } from "./RollCopy";
 import { assignReference, idOf } from "./Assumption";
@@ -378,6 +379,60 @@ export class RemoveFeature extends BasePlan {
         ];
     }
 }
+const featureIdsOf = (copy) => new Set(copy.features.map(feature => feature.id));
+const insertedIn = (versions) => versions.flatMap(version => version.edits).flatMap(edit => edit.insert ?? []);
+/**
+ * A symbol every carrier of which lies on the copy loses its evidence
+ * with the copy. 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 forgetFeatures = (symbol, features, dropped) => {
+    symbol.carriers = symbol.carriers.filter(carrier => !features.has(idOf(carrier)));
+    if (isPerforation(symbol))
+        forgetPerforations(symbol, dropped);
+};
+const forgetCopy = (edit, features, dropped) => {
+    if (edit.insert) {
+        edit.insert = edit.insert.filter(symbol => !dropped.has(symbol.id));
+        edit.insert.forEach(symbol => forgetFeatures(symbol, features, dropped));
+    }
+    if (edit.delete) {
+        edit.delete = edit.delete.filter(id => !dropped.has(id));
+    }
+};
+const isEmpty = (edit) => !edit.insert?.length && !edit.delete?.length;
+/** Drops the edits the removal has emptied and leaves those that were empty before alone. */
+const forgetCopyIn = (version, features, dropped) => {
+    const emptyBefore = new Set(version.edits.filter(isEmpty).map(edit => edit.id));
+    version.edits.forEach(edit => forgetCopy(edit, features, dropped));
+    version.edits = version.edits.filter(edit => !isEmpty(edit) || emptyBefore.has(edit.id));
+};
+/**
+ * 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) => draft => {
+    const copy = draft.copies.find(c => c.id === copyId);
+    if (!copy)
+        return;
+    const features = featureIdsOf(copy);
+    const dropped = new Set(insertedIn(draft.versions).filter(carriedOnlyOn(features)).map(symbol => symbol.id));
+    draft.copies = draft.copies.filter(c => c.id !== copyId);
+    draft.versions.forEach(version => forgetCopyIn(version, features, dropped));
+};
 export class MergeEdits extends BasePlan {
     constructor(versionId, toMerge) {
         super();

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: AnySymbol) => symbol is Note | Expression;
 /**
  * A perforation is a symbol that is typically encoded as a single punched
  * hole or a group of punched holes in the physical carrier.

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.type !== 'text';
 export const placementRelations = ['alignedWith', 'before', 'after'];
 /**
  * The statements placing a perforation relative to others, alignment

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-5670-6034-src_Symbol.ts-0-6242400334313,\"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-5670-6034-src_Symbol.ts-0-6242400334313%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.4.1",
   "description": "Digital editions of piano rolls: import, collation, editorial assumptions, JSON-LD export, and emulation through a reproducing system",
   "license": "MIT",
   "repository": {