linked-rolls 0.16.0 → 0.17.0

package/lib/Feature.d.ts

@@ -173,7 +173,7 @@ export interface GluedOn extends RollFeature<'GluedOn', typeof conditions.GluedO
      * Nested features do not need to be positioned explicitly.
      * @see crm:P56 bears feature
      */
-    features?: PartialBy<AnyFeature, 'horizontal' | 'vertical'>[];
+    features?: NestedFeature[];
 }
 /**
  * The union of all physical feature types that can appear on a roll:
@@ -181,4 +181,14 @@ export interface GluedOn extends RollFeature<'GluedOn', typeof conditions.GluedO
  * and glued-on patches (paper, tape).
  */
 export type AnyFeature = Hole | Writing | Mark | GluedOn;
+/**
+ * A feature borne by another feature. It states no place of its own,
+ * the feature bearing it standing in one.
+ */
+export type NestedFeature = PartialBy<AnyFeature, 'horizontal' | 'vertical'>;
 export declare const isRollFeature: (obj: object) => obj is AnyFeature;
+export declare const isGluedOn: <T extends NestedFeature>(feature: T) => feature is T & GluedOn;
+/** The features a feature bears: a patch those stated as parts of it, any other feature none. */
+export declare const featuresBorneBy: (feature: NestedFeature) => NestedFeature[];
+/** The feature together with everything it bears, as deep as a patch on a patch goes. */
+export declare const withBorneFeatures: (feature: NestedFeature) => NestedFeature[];

package/lib/Feature.js

@@ -9,3 +9,8 @@ export const writingMethods = ['Print', 'Handwriting', 'Stamp'];
 export const isRollFeature = (obj) => {
     return 'type' in obj && featureTypes.includes(obj.type);
 };
+export const isGluedOn = (feature) => feature.type === 'GluedOn';
+/** The features a feature bears: a patch those stated as parts of it, any other feature none. */
+export const featuresBorneBy = (feature) => isGluedOn(feature) ? feature.features ?? [] : [];
+/** The feature together with everything it bears, as deep as a patch on a patch goes. */
+export const withBorneFeatures = (feature) => [feature, ...featuresBorneBy(feature).flatMap(withBorneFeatures)];

package/lib/editionOps.d.ts

@@ -50,7 +50,12 @@ export declare const addGeneralCondition: (copyId: string, condition: ObjectAssu
 export declare const stateFeatureCondition: (copyId: string, featureId: string, condition: FeatureConditionAssignment) => 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. */
+/**
+ * Takes the features off the copy, and out of the versions with what
+ * only they carried. A feature may be named wherever the copy bears it:
+ * a patch goes with everything glued onto it, and a feature of a patch
+ * may be taken back on its own, the patch staying where it is.
+ */
 export declare const removeFeatures: (copyId: string, featureIds: readonly string[]) => EditionOp;
 /**
  * Takes the copy out of the edition together with the symbols only it
@@ -78,6 +83,11 @@ export declare const mergeObstacle: (features: readonly AnyFeature[]) => MergeOb
  * whatever else named them, a modification or a comprehension, names
  * the merged one in their stead.
  *
+ * Only the features the copy bears itself are merged. A feature of a
+ * patch states no place along the roll of its own, so there is nothing
+ * for a merge to span, and an id naming one is passed over as an id the
+ * copy does not bear is.
+ *
  * Throws where the features cannot stand for one; `mergeObstacle`
  * says beforehand whether they can.
  */

package/lib/editionOps.js

@@ -7,7 +7,7 @@ import { collationToleranceOf, insertedBy } from "./Version";
 import { asSymbols } from "./RollCopy";
 import { applyShift, applyScale, revertShift, revertScale } from "./alignment";
 import { assignReference, idOf } from "./Assumption";
-import { conditions as conditionsAllowed } from "./Feature";
+import { conditions as conditionsAllowed, featuresBorneBy, isGluedOn, withBorneFeatures } from "./Feature";
 import { distance, mm, subtract } from "./Quantity";
 const noChange = () => undefined;
 const onCopy = (copyId, op) => draft => {
@@ -147,7 +147,8 @@ export const stateFeatureCondition = (copyId, featureId, condition) => onFeature
     }
     feature.condition = condition;
 });
-const featureIdsOf = (copy) => new Set(copy.features.map(feature => feature.id));
+/** The ids of every feature the copy bears, those a patch bears among them. */
+const featureIdsOf = (copy) => new Set(copy.features.flatMap(withBorneFeatures).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,
@@ -282,11 +283,33 @@ const forgetFeatures = (draft, features) => {
         version.edits = edits[i];
     });
 };
-/** Takes the features off the copy, and out of the versions with what only they carried. */
+/**
+ * The ids of the features named and of everything they bear: a feature
+ * of a patch stands nowhere once the patch is gone.
+ */
+const goneWith = (features, named) => features.flatMap(feature => named.has(feature.id)
+    ? withBorneFeatures(feature).map(borne => borne.id)
+    : goneWith(featuresBorneBy(feature), named));
+/** The feature with the named ones gone from what it bears, or the very same one where it bears none of them. */
+const withoutBorne = (feature, named) => {
+    if (!isGluedOn(feature) || !feature.features)
+        return feature;
+    const borne = withoutFeatures(feature.features, named);
+    return borne === feature.features ? feature : { ...feature, features: borne };
+};
+/** The features without those named, wherever they lie, and without whatever those bore. */
+const withoutFeatures = (features, named) => mapped(without(features, feature => named.has(feature.id)), feature => withoutBorne(feature, named));
+/**
+ * Takes the features off the copy, and out of the versions with what
+ * only they carried. A feature may be named wherever the copy bears it:
+ * a patch goes with everything glued onto it, and a feature of a patch
+ * may be taken back on its own, the patch staying where it is.
+ */
 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);
+    const named = new Set(featureIds);
+    const features = stateOf(copy.features);
+    copy.features = withoutFeatures(features, named);
+    forgetFeatures(draft, new Set(goneWith(features, named)));
 });
 /**
  * Takes the copy out of the edition together with the symbols only it
@@ -311,10 +334,17 @@ const sayTheSame = (a, b) => {
     keys.delete('id');
     return [...keys].every(key => sayTheSame(a[key], b[key]));
 };
-/** What a feature states beyond its identity, its place along the roll, its depiction and its condition. */
+/**
+ * What a feature states beyond its identity, its place along the roll,
+ * its depiction and its condition. What a patch bears counts by
+ * identity: two patches bear the same only where they bear the very
+ * same features, so that no merge takes a feature of a patch away.
+ */
 const nature = (feature) => {
     const { id, horizontal, depiction, condition, ...rest } = feature;
-    return rest;
+    return isGluedOn(feature) && feature.features
+        ? { ...rest, features: feature.features.map(borne => borne.id) }
+        : rest;
 };
 const conditionsOf = (features) => features.flatMap(feature => feature.condition ? [feature.condition] : []);
 /**
@@ -393,20 +423,25 @@ const carryOver = (draft, replaced, mergedId) => {
  * whatever else named them, a modification or a comprehension, names
  * the merged one in their stead.
  *
+ * Only the features the copy bears itself are merged. A feature of a
+ * patch states no place along the roll of its own, so there is nothing
+ * for a merge to span, and an id naming one is passed over as an id the
+ * copy does not bear is.
+ *
  * Throws where the features cannot stand for one; `mergeObstacle`
  * says beforehand whether they can.
  */
 export const mergeFeatures = (copyId, featureIds) => onCopy(copyId, (copy, draft) => {
-    const replaced = new Set(featureIds);
-    const isReplaced = (feature) => replaced.has(feature.id);
+    const named = new Set(featureIds);
     const features = stateOf(copy.features);
-    const toMerge = features.filter(isReplaced);
+    const toMerge = features.filter(feature => named.has(feature.id));
     const obstacle = mergeObstacle(toMerge);
     if (obstacle) {
         throw new Error(`The features of copy ${copyId} cannot be merged: ${obstacle}`);
     }
+    const replaced = new Set(toMerge.map(feature => feature.id));
     const merged = mergedFrom(toMerge);
-    copy.features = standingFor(features, isReplaced, merged);
+    copy.features = standingFor(features, feature => replaced.has(feature.id), merged);
     carryOver(draft, replaced, merged.id);
     renameReferences(draft, ids => standingFor(ids, id => replaced.has(id), merged.id));
 });

package/lib/schema.json

@@ -626,7 +626,7 @@
                 "features": {
                     "description": "A glued-on feature itself may carry other features. Nested features do not need to be positioned explicitly. [ontology: crm:P56 bears feature]",
                     "items": {
-                        "$ref": "#/definitions/PartialBy%3CAnyFeature%2C(%22horizontal%22%7C%22vertical%22)%3E"
+                        "$ref": "#/definitions/NestedFeature"
                     },
                     "type": "array"
                 },
@@ -1049,6 +1049,10 @@
             ],
             "type": "object"
         },
+        "NestedFeature": {
+            "$ref": "#/definitions/PartialBy%3CAnyFeature%2C(%22horizontal%22%7C%22vertical%22)%3E",
+            "description": "A feature borne by another feature. It states no place of its own, the feature bearing it standing in one."
+        },
         "Note": {
             "description": "A note symbol, representing a single pitched musical event on the roll. The pitch is encoded via the tracker bar position (track number). [ontology: reo:Note]",
             "properties": {

package/package.json

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