linked-rolls 0.55.0 → 0.57.0

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 => {
@@ -90,7 +90,6 @@ export const createVersion = (copy) => draft => {
     const bar = barOf(copy);
     draft.copies.push(copy);
     draft.versions.push({
-        type: 'Version',
         id: v4(),
         system: systemOf(bar),
         edits: asSymbols(featuresOf(copy), bar).map(insertion),
@@ -369,7 +368,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 +442,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 +451,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 +501,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;
 };
@@ -707,7 +706,7 @@ const byExchange = (edits) => new Map(edits.map(edit => [exchangeKey((edit.inser
  * child's symbols and not the parent's with themselves.
  */
 export const connectVersions = (view, childId, parentId, tolerance = defaultCollationTolerance) => {
-    const child = view.get(childId);
+    const child = view.version(childId);
     const stated = child ? editsOf(child) : [];
     const established = stated.filter(edit => !isCollationsOwn(edit));
     const spokenFor = spokenForBy(established);
@@ -732,7 +731,7 @@ export const connectVersions = (view, childId, parentId, tolerance = defaultColl
      * apart would make the apparatus a list of unexplained losses beside
      * a list of unexplained gains.
      */
-    const substituted = differ(child, view.get(parentId))
+    const substituted = differ(child, view.version(parentId))
         ? substitutionsBetween(own.filter(symbol => !collated.has(symbol.id)), inherited.filter(symbol => !matched.has(symbol.id)), locate, tolerance)
         : [];
     const paired = new Set(substituted.flatMap(({ replaced, by }) => [...by, ...replaced].map(symbol => symbol.id)));
@@ -773,7 +772,7 @@ export const connectVersions = (view, childId, parentId, tolerance = defaultColl
  * tolerance of the derivation, where the caller names none.
  */
 export const collateSymbols = (view, versionId, symbolIds, tolerance) => {
-    const version = view.get(versionId);
+    const version = view.version(versionId);
     const principal = version && principalDerivationOf(version);
     if (!version || !principal)
         return noChange;
@@ -843,7 +842,7 @@ const sharedWith = (view, symbol, copies) => {
  * narrow the act to those; naming none separates the whole reading.
  */
 export const separateReadings = (view, versionId, copies, symbolIds) => {
-    const version = view.get(versionId);
+    const version = view.version(versionId);
     if (!version)
         return noChange;
     const chosen = symbolIds && new Set(symbolIds);
@@ -911,7 +910,6 @@ export const deriveVersion = (versionId, editIds) => onVersion(versionId, (versi
     if (version.edits)
         version.edits = without(version.edits, edit => chosen.has(edit.id));
     draft.versions.push({
-        type: 'Version',
         id: v4(),
         system: stateOf(version).system,
         basedOn: [assignReference(versionId)],
@@ -970,10 +968,10 @@ const replacementType = (view, inserted, deleted) => {
  */
 const guessEditType = (view, versionId, edit) => {
     const inserts = edit.insert ?? [];
-    const deletes = view.getAll(edit.delete ?? []);
+    const deletes = view.symbols(edit.delete ?? []);
     const inserted = expressionTypesOf(inserts);
     const deleted = expressionTypesOf(deletes);
-    const bar = trackerBarOf(view.get(versionId)?.system);
+    const bar = trackerBarOf(view.version(versionId)?.system);
     const parentBar = trackerBarOf(view.predecessorOf(versionId)?.system);
     /**
      * Where the version is coded for another system than its parent, an

package/lib/importJsonLd.js

@@ -18,12 +18,7 @@ const fromJsonLdValue = (value) => {
         return fromJsonLdEntity(value);
     return value;
 };
-/**
- * A node without what the export derived from it. A copy bears the
- * features its acts brought about, and the graph has to be told so.
- * In the edition the act that made a feature is the one place it
- * stands.
- */
+/** A node without what the export derived from it: what an act changed follows from where the act stands. */
 const asStated = (json) => Object.keys(json).some(key => derivedKeys.has(key))
     ? Object.fromEntries(Object.entries(json).filter(([key]) => !derivedKeys.has(key)))
     : json;

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'))
@@ -147,7 +156,6 @@ const withPerforator = (node) => {
             perforator: {
                 ...perforator,
                 condition: {
-                    '@type': 'ConditionState',
                     conditionType: 'setting',
                     ...perforator.condition,
                     punchDiameter: diameter
@@ -187,6 +195,22 @@ const withoutPattern = (node) => {
     const { pattern: _moved, ...rest } = node;
     return rest;
 };
+/** A version and a condition state once stated their class, which the key they stand under entails. */
+const withoutEntailedType = (node) => {
+    if (node['@type'] !== 'Version' && node['@type'] !== 'ConditionState')
+        return node;
+    const { '@type': _entailed, ...rest } = node;
+    return rest;
+};
+/** An export once stated what a copy or a patch bears, which a reasoner now derives from the acts. */
+const withoutBearings = (node) => {
+    if (!Object.hasOwn(node, 'bears') && !Object.hasOwn(node, 'composedOf'))
+        return node;
+    if (node['@type'] !== 'RollCopy' && node['@type'] !== 'Patch')
+        return node;
+    const { bears: _bears, composedOf: _composedOf, ...rest } = node;
+    return rest;
+};
 /** A derivation written as a single one, before a version could name several. */
 const isSingleDerivation = (basedOn) => basedOn !== null && typeof basedOn === 'object' && !Array.isArray(basedOn);
 const withDerivationList = (node) => isSingleDerivation(node.basedOn) ? { ...node, basedOn: [node.basedOn] } : node;
@@ -195,8 +219,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 +235,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,9 +326,9 @@ 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]
+    withoutFeatureKind, withBorneFeaturesNamed, withFeaturesInActs, withDriveOfStaggering, withoutPattern, withoutBearings, withoutEntailedType]
     .reduce((result, step) => step(result), node);
 /** The items each walked, or the very same list where the walk changed none. */
 const walked = (items) => {
@@ -382,6 +405,13 @@ const onOwnBar = (copy, rollSystem) => {
  * roll that named no system was a T-100 roll, and the text a copy's
  * production gave for it is kept as the system's name.
  */
+/** An export once stated the class of the edition, which R17i was created by entails. */
+const withoutEditionType = (edition) => {
+    if (edition['@type'] !== 'Edition')
+        return edition;
+    const { '@type': _entailed, ...rest } = edition;
+    return rest;
+};
 const withSystems = (edition) => {
     if (!edition.roll || !namesSystemOnTheRoll(edition))
         return edition;
@@ -453,14 +483,16 @@ const referenceOf = (statement) => {
         }
     };
 };
-/** The document with each quoted reference back on the node that makes it, a node being what has a type. */
+/** Whether the object states anything beside its id, which a reference to a node does not. */
+const isNode = (value) => typeof value['@id'] === 'string' && Object.keys(value).some(key => key !== '@id' && key !== '@annotation');
+/** The document with each quoted reference back on the node that makes it. */
 const withReferencesOn = (value, bySubject) => {
     if (Array.isArray(value))
         return value.map(item => withReferencesOn(item, bySubject));
     if (!value || typeof value !== 'object')
         return value;
     const walked = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, withReferencesOn(child, bySubject)]));
-    const references = typeof value['@id'] === 'string' && value['@type'] !== undefined
+    const references = isNode(value)
         ? bySubject.get(value['@id']) ?? []
         : [];
     return references.reduce((node, { key, listed, reference }) => ({ ...node, [key]: listed ? [...(node[key] ?? []), reference] : reference }), walked);
@@ -482,5 +514,5 @@ const withQuotedStatementsInPlace = (edition) => {
     const bySubject = Map.groupBy(statements.map(referenceOf), ({ subject }) => subject);
     return withReferencesOn({ ...rest, ...(others.length > 0 && { '@included': others }) }, bySubject);
 };
-const editionSteps = [withQuotedStatementsInPlace, withSystems, withEditors, withDerivationTolerance];
+const editionSteps = [withoutEditionType, withQuotedStatementsInPlace, withSystems, withEditors, withDerivationTolerance];
 export const migrate = (edition) => walk(editionSteps.reduce((result, step) => step(result), edition));

package/lib/readers/stanfordAton.js

@@ -164,7 +164,6 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
                     type: 'Perforator',
                     id: `perforator_${v4()}`,
                     condition: {
-                        type: 'ConditionState',
                         conditionType: 'setting',
                         punchDiameter: { value: punchDiameter, unit: 'mm' }
                     }

package/lib/scatter.js

@@ -37,7 +37,7 @@ const sitsOn = (view, copies) => (feature) => {
 export const readingsOf = (view, symbols, copies) => {
     const tested = sitsOn(view, copies);
     return symbols.flatMap((symbol) => {
-        const carriers = view.carriersOf(symbol);
+        const carriers = view.placedCarriersOf(symbol);
         const here = carriers.filter(tested);
         const there = carriers.filter(carrier => !tested(carrier));
         if (here.length === 0 || there.length === 0)
@@ -220,12 +220,12 @@ const copiesBearing = (view, symbols) => {
  * stopped saying and an editor has to.
  */
 export const sidesOf = (view, versionId) => {
-    const version = view.get(versionId);
+    const version = view.version(versionId);
     if (!version)
         return undefined;
     return {
         child: copiesBearing(view, insertedBy(version)),
-        parent: copiesBearing(view, view.getAll(deletedBy(version)))
+        parent: copiesBearing(view, view.symbols(deletedBy(version)))
     };
 };
 const inMillimetres = (value) => `${value.toFixed(2)} mm`;