linked-rolls 0.55.0 → 0.56.0

package/lib/Feature.d.ts

@@ -53,12 +53,12 @@ export interface VerticalSpan {
      */
     to?: Track;
 }
-export declare const featureTypes: readonly ['HoleChain', 'Writing', 'Mark', 'GluedOn'];
+export declare const featureTypes: readonly ['HoleChain', 'Writing', 'Mark', 'Patch'];
 export type FeatureType = typeof featureTypes[number];
 export declare const isFeatureType: (value: unknown) => value is FeatureType;
 /**
  * A feature on the roll, e.g. a perforation, a writing, a mark or a
- * glued-on patch, defined by its horizontal and vertical position and
+ * patch, defined by its horizontal and vertical position and
  * extent. Each kind of feature is a class of its own, which its type
  * names.
  */
@@ -89,7 +89,7 @@ export declare const conditions: {
     readonly HoleChain: readonly ["partially-torn", "missing-perforation"];
     readonly Writing: readonly ["illegible"];
     readonly Mark: readonly ["faded"];
-    readonly GluedOn: readonly ["detaching", "ripped"];
+    readonly Patch: readonly ["detaching", "ripped"];
 };
 /** The kinds of condition a feature may be in, whichever kind of feature it is. */
 export type FeatureConditionType = typeof conditions[FeatureType][number];
@@ -191,15 +191,14 @@ export interface Writing extends Trace<'Writing'> {
 export interface Mark extends Trace<'Mark'> {
 }
 /**
- * A piece of material (paper or tape) glued onto the roll surface.
- * Glued-on features are typically used to cover perforations (for corrections)
- * or to reinforce damaged areas. They may themselves carry other features
- * such as writings or additional holes.
- * @see reo:GluedOn
+ * A piece of paper or tape glued onto the roll: a label naming it, a
+ * strip covering perforations, or a patch reinforcing a tear. A patch
+ * may itself carry other features, such as writings or holes.
+ * @see reo:Patch
  */
-export interface GluedOn extends RollFeature<'GluedOn', typeof conditions.GluedOn[number]>, OnAFace {
+export interface Patch extends RollFeature<'Patch', typeof conditions.Patch[number]>, OnAFace {
     /**
-     * The material of the glued-on feature.
+     * What the patch is made of.
      * @see crm:P45 consists of
      */
     material: 'paper' | 'tape';
@@ -211,8 +210,8 @@ export interface GluedOn extends RollFeature<'GluedOn', typeof conditions.GluedO
      */
     rotation?: Measure<'deg'>;
     /**
-     * A glued-on feature itself may carry other features.
-     * Nested features do not need to be positioned explicitly.
+     * The features the patch itself carries. They need not be
+     * positioned explicitly.
      * @see crm:P46 is composed of
      */
     features?: NestedFeature[];
@@ -225,10 +224,10 @@ export interface GluedOn extends RollFeature<'GluedOn', typeof conditions.GluedO
 export type AnyFeature = HoleChain | Writing | Mark;
 /**
  * Anything found at a place of its own on the roll: a feature or a
- * glued-on patch. E24 Physical Human-Made Thing is the class both fall
- * under, E22 and E25 being its subclasses.
+ * patch. E24 Physical Human-Made Thing is the class both fall under,
+ * E22 and E25 being its subclasses.
  */
-export type FeatureOrPatch = AnyFeature | GluedOn;
+export type FeatureOrPatch = AnyFeature | Patch;
 /**
  * A feature without the place it would state of its own. The union is
  * distributed over, so that each kind of feature keeps its own keys.
@@ -240,7 +239,7 @@ type Unplaced<T> = T extends FeatureOrPatch ? PartialBy<T, 'horizontal' | 'verti
  */
 export type NestedFeature = Unplaced<FeatureOrPatch>;
 export declare const isRollFeature: (obj: object) => obj is FeatureOrPatch;
-export declare const isGluedOn: <T extends NestedFeature>(feature: T) => feature is T & GluedOn;
+export declare const isPatch: <T extends NestedFeature>(feature: T) => feature is T & Patch;
 /** 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. */

package/lib/Feature.js

@@ -1,18 +1,18 @@
-export const featureTypes = ['HoleChain', 'Writing', 'Mark', 'GluedOn'];
+export const featureTypes = ['HoleChain', 'Writing', 'Mark', 'Patch'];
 export const isFeatureType = (value) => featureTypes.includes(value);
 export const conditions = {
     HoleChain: ['partially-torn', 'missing-perforation'],
     Writing: ['illegible'],
     Mark: ['faded'],
-    GluedOn: ['detaching', 'ripped']
+    Patch: ['detaching', 'ripped']
 };
 export const techniques = ['print', 'handwriting', 'stamp'];
 export const media = ['ink', 'pencil', 'crayon'];
 export const isRollFeature = (obj) => {
     return 'type' in obj && isFeatureType(obj.type);
 };
-export const isGluedOn = (feature) => feature.type === 'GluedOn';
+export const isPatch = (feature) => feature.type === 'Patch';
 /** 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 ?? [] : [];
+export const featuresBorneBy = (feature) => isPatch(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/RollCopy.d.ts

@@ -2,7 +2,7 @@ import { ConditionState } from "./ConditionState.js";
 import { AnySymbol } from "./Symbol.js";
 import { TrackerBar } from "./TrackerBar.js";
 import { TrackCalibration } from "./TrackCalibration.js";
-import { AnyFeature, FeatureOrPatch, GluedOn } from "./Feature.js";
+import { AnyFeature, FeatureOrPatch, Patch } from "./Feature.js";
 import { ActorAssignment, DateAssignment, ObjectAssumption, ReferenceAssumption } from "./Assumption.js";
 import { WithId, WithType } from "./utils.js";
 import { Agent, Concept } from "./Agent.js";
@@ -161,7 +161,7 @@ export type Modification = Partial<{
      * The patches glued onto the copy, each with whatever it bears.
      * @see crm:P111 added
      */
-    added: GluedOn[];
+    added: Patch[];
     /**
      * @see crm:P21 had general purpose
      */

package/lib/asJsonLd.js

@@ -73,7 +73,7 @@ const madeOn = (copy) => [
     ...nodesIn(copy.production?.produced),
     ...nodesIn(copy.modifications).flatMap(act => [...nodesIn(act.produced), ...nodesIn(act.added)])
 ];
-const referencing = (nodes, patches) => nodes.filter(node => (node['@type'] === 'GluedOn') === patches && typeof node['@id'] === 'string')
+const referencing = (nodes, patches) => nodes.filter(node => (node['@type'] === 'Patch') === patches && typeof node['@id'] === 'string')
     .map(node => ({ '@id': node['@id'] }));
 const featuresAmong = (nodes) => referencing(nodes, false);
 const patchesAmong = (nodes) => referencing(nodes, true);
@@ -112,7 +112,7 @@ const withBearings = (value) => {
             ...stating('composedOf', patchesAmong(made))
         };
     }
-    if (node['@type'] === 'GluedOn')
+    if (node['@type'] === 'Patch')
         return { ...node, ...stating('bears', featuresAmong(nodesIn(node.features))) };
     return node;
 };

package/lib/editionOps.js

@@ -10,7 +10,7 @@ import { substitutionsBetween } from "./substitution.js";
 import { trackerBarOf } from "./systems/index.js";
 import { applyShift, applyScale, revertShift, revertScale, revertShortening, shortenChains } from "./alignment.js";
 import { assignReference, idOf } from "./Assumption.js";
-import { conditions as conditionsAllowed, featuresBorneBy, isGluedOn, withBorneFeatures } from "./Feature.js";
+import { conditions as conditionsAllowed, featuresBorneBy, isPatch, withBorneFeatures } from "./Feature.js";
 import { distance, mm, subtract } from "./Quantity.js";
 const noChange = () => undefined;
 const onCopy = (copyId, op) => draft => {
@@ -369,7 +369,7 @@ const goneWith = (features, named) => features.flatMap(feature => named.has(feat
     : 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)
+    if (!isPatch(feature) || !feature.features)
         return feature;
     const borne = withoutFeatures(feature.features, named);
     return borne === feature.features ? feature : { ...feature, features: borne };
@@ -443,7 +443,7 @@ const actFor = (copy, patch, act) => {
  * the feature goes into an act of its own.
  */
 export const addFeature = (copyId, feature, act = {}) => onCopy(copyId, copy => {
-    actFor(copy, isGluedOn(feature), act).push(feature);
+    actFor(copy, isPatch(feature), act).push(feature);
 });
 /**
  * States that the patch bears the feature. What a patch bears came onto
@@ -452,7 +452,7 @@ export const addFeature = (copyId, feature, act = {}) => onCopy(copyId, copy =>
  */
 export const addBorneFeature = (copyId, patchId, feature) => onCopy(copyId, copy => {
     const patch = featuresOf(copy).flatMap(withBorneFeatures).find(borne => borne.id === patchId);
-    if (!patch || !isGluedOn(patch))
+    if (!patch || !isPatch(patch))
         return;
     if (!patch.features)
         patch.features = [];
@@ -502,7 +502,7 @@ const sayTheSame = (a, b) => {
  */
 const nature = (feature) => {
     const { id, horizontal, depiction, condition, ...rest } = feature;
-    return isGluedOn(feature) && feature.features
+    return isPatch(feature) && feature.features
         ? { ...rest, features: feature.features.map(borne => borne.id) }
         : rest;
 };

package/lib/migrate.js

@@ -11,6 +11,14 @@ const renamedKeys = {
     annotates: 'depiction',
     classification: 'editType'
 };
+/**
+ * Classes of feature renamed since: a chain of holes was named after a
+ * single hole, and a patch after the act that glued it on.
+ */
+const renamedTypes = {
+    Hole: 'HoleChain',
+    GluedOn: 'Patch'
+};
 const referenceKeys = ['alignedWith', 'pairedWith', 'basedOn'];
 /**
  * The five type terms that were capitalised while the rest of the
@@ -33,8 +41,9 @@ const withTypology = (node) => {
     }
     return node;
 };
-/** A chain of holes written while its class was named after a single hole. */
-const withHoleChainType = (node) => node['@type'] === 'Hole' ? { ...node, '@type': 'HoleChain' } : node;
+const withRenamedType = (node) => Object.hasOwn(renamedTypes, node['@type']) ? { ...node, '@type': renamedTypes[node['@type']] } : node;
+/** Whether the feature is of the class under either name, since a node is migrated before its children are. */
+const isOfType = (type) => (feature) => feature?.['@type'] === type || renamedTypes[feature?.['@type']] === type;
 /** A version once stated whether it served as a master or stood on one copy. */
 const withoutVersionType = (node) => {
     if (!Object.hasOwn(node, 'versionType'))
@@ -195,8 +204,7 @@ const featuresOf = (copy) => [
     ...(Array.isArray(copy.features) ? copy.features : []),
     ...(Array.isArray(copy.production?.produced) ? copy.production.produced : [])
 ];
-/** A chain of holes under either name, since a node is migrated before its children are. */
-const isHoleChain = (feature) => feature?.['@type'] === 'HoleChain' || feature?.['@type'] === 'Hole';
+const isHoleChain = isOfType('HoleChain');
 /**
  * A copy read on a roll reader was stated as a recording before a sound
  * recording could be one. A sound recording gives no holes, so a recording
@@ -212,7 +220,7 @@ const withoutFeatureKind = (node) => {
     const { kind: _typed, ...rest } = node;
     return rest;
 };
-const isPatch = (feature) => feature?.['@type'] === 'GluedOn';
+const isPatch = isOfType('Patch');
 /**
  * A feature a patch bears was sometimes written without an id, and what
  * has no id can be referred to from nowhere: neither by a reading of it
@@ -303,7 +311,7 @@ const withTimeSpanDates = (node) => {
     const { '@value': within, '@type': _typed, ...rest } = node;
     return { ...rest, within };
 };
-const migrateNode = (node) => [withRenamedKeys, withTypology, withHoleChainType, withoutVersionType, withoutVersionSiglum, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
+const migrateNode = (node) => [withRenamedKeys, withTypology, withRenamedType, withoutVersionType, withoutVersionSiglum, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
     withPerforator, withProductionNodes, withTypedPerforator, withScale, withDerivationList, withReadingKind, withTimeSpanDates,
     withoutFeatureKind, withBorneFeaturesNamed, withFeaturesInActs, withDriveOfStaggering, withoutPattern]
     .reduce((result, step) => step(result), node);

package/lib/schema.json

@@ -793,97 +793,6 @@
             "type": "object",
             "ontology": "crm:E7 Activity"
         },
-        "GluedOn": {
-            "description": "A piece of material (paper or tape) glued onto the roll surface. Glued-on features are typically used to cover perforations (for corrections) or to reinforce damaged areas. They may themselves carry other features such as writings or additional holes.",
-            "properties": {
-                "condition": {
-                    "$ref": "#/definitions/ObjectAssumption%3CConditionState%3C(%22detaching%22%7C%22ripped%22)%3E%3E",
-                    "description": "This can be used e.g. to indicate a perforation which is torn out or in any other way damaged.",
-                    "ontology": "crm:P44 has condition"
-                },
-                "depiction": {
-                    "description": "IIIF region pointing to a depiction of this feature in the scan.",
-                    "type": "string",
-                    "ontology": "crm:P138i has representation"
-                },
-                "features": {
-                    "description": "A glued-on feature itself may carry other features. Nested features do not need to be positioned explicitly.",
-                    "items": {
-                        "$ref": "#/definitions/NestedFeature"
-                    },
-                    "type": "array",
-                    "ontology": "crm:P46 is composed of"
-                },
-                "horizontal": {
-                    "$ref": "#/definitions/HorizontalSpan",
-                    "description": "Horizontal span of the feature on the roll.",
-                    "ontology": "crm:P43 has dimension"
-                },
-                "material": {
-                    "description": "The material of the glued-on feature.",
-                    "enum": [
-                        "paper",
-                        "tape"
-                    ],
-                    "type": "string",
-                    "ontology": "crm:P45 consists of"
-                },
-                "rotation": {
-                    "$ref": "#/definitions/Measure%3C%22deg%22%3E",
-                    "description": "How far the patch was stuck on askew. At zero its edges stand square to the roll, and the angle turns them towards the end of it, as a writing's reading direction turns.",
-                    "ontology": "reo:rotation"
-                },
-                "side": {
-                    "description": "The face of the roll it lies on: the side that faces the reader as the roll plays, or the back of it.",
-                    "enum": [
-                        "recto",
-                        "verso"
-                    ],
-                    "type": "string",
-                    "ontology": "reo:side"
-                },
-                "vertical": {
-                    "$ref": "#/definitions/VerticalSpan",
-                    "description": "Vertical span of the feature on the roll.",
-                    "ontology": "crm:P43 has dimension"
-                },
-                "@id": {
-                    "description": "A unique identifier for this object.",
-                    "type": "string"
-                },
-                "@type": {
-                    "const": "GluedOn",
-                    "description": "The type discriminator for this object.",
-                    "type": "string",
-                    "ontology": "rdf:type"
-                },
-                "bears": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "@id": {
-                                "type": "string"
-                            }
-                        },
-                        "required": [
-                            "@id"
-                        ]
-                    },
-                    "description": "The features the patch bears. Derived on export.",
-                    "ontology": "crm:P56 bears feature"
-                }
-            },
-            "required": [
-                "horizontal",
-                "@id",
-                "material",
-                "@type",
-                "vertical"
-            ],
-            "type": "object",
-            "ontology": "reo:GluedOn"
-        },
         "HoleChain": {
             "description": "A chain of holes punched along the roll, which the tracker bar reads as it passes. The perforator cuts a held note or function as a row of punches with bridges of paper left between them, so most perforations are chains; one without a bridge is a chain of a single hole. The holes are the chain's parts and are not stated one by one. A punched chain is a human-made feature: CRM counts \"the information encoding features on mechanical or digital carriers\" among the features purposely created by human activity.",
             "properties": {
@@ -1254,7 +1163,7 @@
                         "added": {
                             "description": "The patches glued onto the copy, each with whatever it bears.",
                             "items": {
-                                "$ref": "#/definitions/GluedOn"
+                                "$ref": "#/definitions/Patch"
                             },
                             "type": "array",
                             "ontology": "crm:P111 added"
@@ -1608,7 +1517,7 @@
                             "ontology": "crm:P138i has representation"
                         },
                         "features": {
-                            "description": "A glued-on feature itself may carry other features. Nested features do not need to be positioned explicitly.",
+                            "description": "The features the patch itself carries. They need not be positioned explicitly.",
                             "items": {
                                 "$ref": "#/definitions/NestedFeature"
                             },
@@ -1621,7 +1530,7 @@
                             "ontology": "crm:P43 has dimension"
                         },
                         "material": {
-                            "description": "The material of the glued-on feature.",
+                            "description": "What the patch is made of.",
                             "enum": [
                                 "paper",
                                 "tape"
@@ -1653,7 +1562,7 @@
                             "type": "string"
                         },
                         "@type": {
-                            "const": "GluedOn",
+                            "const": "Patch",
                             "description": "The type discriminator for this object.",
                             "type": "string",
                             "ontology": "rdf:type"
@@ -2678,6 +2587,97 @@
             ],
             "type": "object"
         },
+        "Patch": {
+            "description": "A piece of paper or tape glued onto the roll: a label naming it, a strip covering perforations, or a patch reinforcing a tear. A patch may itself carry other features, such as writings or holes.",
+            "properties": {
+                "condition": {
+                    "$ref": "#/definitions/ObjectAssumption%3CConditionState%3C(%22detaching%22%7C%22ripped%22)%3E%3E",
+                    "description": "This can be used e.g. to indicate a perforation which is torn out or in any other way damaged.",
+                    "ontology": "crm:P44 has condition"
+                },
+                "depiction": {
+                    "description": "IIIF region pointing to a depiction of this feature in the scan.",
+                    "type": "string",
+                    "ontology": "crm:P138i has representation"
+                },
+                "features": {
+                    "description": "The features the patch itself carries. They need not be positioned explicitly.",
+                    "items": {
+                        "$ref": "#/definitions/NestedFeature"
+                    },
+                    "type": "array",
+                    "ontology": "crm:P46 is composed of"
+                },
+                "horizontal": {
+                    "$ref": "#/definitions/HorizontalSpan",
+                    "description": "Horizontal span of the feature on the roll.",
+                    "ontology": "crm:P43 has dimension"
+                },
+                "material": {
+                    "description": "What the patch is made of.",
+                    "enum": [
+                        "paper",
+                        "tape"
+                    ],
+                    "type": "string",
+                    "ontology": "crm:P45 consists of"
+                },
+                "rotation": {
+                    "$ref": "#/definitions/Measure%3C%22deg%22%3E",
+                    "description": "How far the patch was stuck on askew. At zero its edges stand square to the roll, and the angle turns them towards the end of it, as a writing's reading direction turns.",
+                    "ontology": "reo:rotation"
+                },
+                "side": {
+                    "description": "The face of the roll it lies on: the side that faces the reader as the roll plays, or the back of it.",
+                    "enum": [
+                        "recto",
+                        "verso"
+                    ],
+                    "type": "string",
+                    "ontology": "reo:side"
+                },
+                "vertical": {
+                    "$ref": "#/definitions/VerticalSpan",
+                    "description": "Vertical span of the feature on the roll.",
+                    "ontology": "crm:P43 has dimension"
+                },
+                "@id": {
+                    "description": "A unique identifier for this object.",
+                    "type": "string"
+                },
+                "@type": {
+                    "const": "Patch",
+                    "description": "The type discriminator for this object.",
+                    "type": "string",
+                    "ontology": "rdf:type"
+                },
+                "bears": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "@id": {
+                                "type": "string"
+                            }
+                        },
+                        "required": [
+                            "@id"
+                        ]
+                    },
+                    "description": "The features the patch bears. Derived on export.",
+                    "ontology": "crm:P56 bears feature"
+                }
+            },
+            "required": [
+                "horizontal",
+                "@id",
+                "material",
+                "@type",
+                "vertical"
+            ],
+            "type": "object",
+            "ontology": "reo:Patch"
+        },
         "Perforator": {
             "description": "The machine that punched the copy. It stands for this production alone. Whether it is the one another copy was punched on is left to a statement of identity made about it elsewhere, which its id allows.",
             "properties": {

package/lib/spec/context.json

@@ -17,7 +17,7 @@
         "HoleChain": "reo:HoleChain",
         "Mark": "reo:Mark",
         "Writing": "reo:Writing",
-        "GluedOn": "reo:GluedOn",
+        "Patch": "reo:Patch",
         "Attachment": "crm:E79_Part_Addition",
         "Removal": "crm:E80_Part_Removal",
         "Alteration": "crm:E12_Production",

package/package.json

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