linked-rolls 0.57.0 → 0.59.0

package/lib/ops/features.js

@@ -0,0 +1,296 @@
+import { v4 } from "uuid";
+import { featuresByAct, featuresOf, statesNothing } from "../model/RollCopy.js";
+import { idOf } from "../model/Assumption.js";
+import { conditions as conditionsAllowed, featuresBorneBy, isPatch, withBorneFeatures } from "../model/Feature.js";
+import { mm } from "../model/Quantity.js";
+import { onCopy, onFeature, stateOf } from "./draft.js";
+import { without, mapped, pruned, replacing, isRecord } from "./immutable.js";
+import { renameReferences, forgetFeatures } from "./forget.js";
+/**
+ * Whether the feature's own kind allows a condition of this kind. The
+ * type narrowed to is the weaker statement, holding of a condition any
+ * kind of feature may be in.
+ */
+const allows = (feature, condition) => {
+    const allowed = conditionsAllowed[feature.type];
+    return allowed.includes(condition.conditionType);
+};
+/**
+ * States the condition of the feature, in place of any earlier
+ * statement. Throws where the kind of feature is in no such condition;
+ * `conditions` says which conditions each kind of feature may be in.
+ */
+export const stateFeatureCondition = (copyId, featureId, condition) => onFeature(copyId, featureId, feature => {
+    if (!allows(feature, condition)) {
+        throw new Error(`A ${feature.type} is in no '${condition.conditionType}' condition`);
+    }
+    feature.condition = condition;
+});
+/**
+ * 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 (!isPatch(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));
+/** The act with its features rewritten, or the very same one where the rewriting left them. */
+const rewritingAct = (rewrite) => (modification) => {
+    if (modification.type === 'Alteration')
+        return replacing(modification, 'produced', rewrite(modification.produced));
+    if (modification.type === 'Attachment')
+        return replacing(modification, 'added', rewrite(modification.added));
+    return modification;
+};
+/**
+ * Writes the rewriting onto the features of every act of the copy, and
+ * takes out an act it left with nothing to state.
+ */
+const rewriteFeatures = (copy, rewrite) => {
+    const state = stateOf(copy);
+    const produced = state.production?.produced;
+    if (produced && copy.production) {
+        const rewritten = rewrite(produced);
+        if (rewritten !== produced)
+            copy.production.produced = rewritten;
+    }
+    copy.modifications = pruned(state.modifications, rewritingAct(rewrite), statesNothing);
+};
+/** The features of the act that brought the named feature about, where that act produces features. */
+const producedBeside = (copy, featureId) => {
+    const names = (features) => features.some(feature => feature.id === featureId);
+    const punched = copy.production?.produced;
+    if (punched && names(punched))
+        return punched;
+    const act = copy.modifications.find(act => act.type === 'Alteration' && names(act.produced));
+    return act?.type === 'Alteration' ? act.produced : undefined;
+};
+/** The patches of the attachment that glued the named one on. */
+const gluedBeside = (copy, patchId) => {
+    const act = copy.modifications.find(act => act.type === 'Attachment' && act.added.some(patch => patch.id === patchId));
+    return act?.type === 'Attachment' ? act.added : undefined;
+};
+/** The list the copy states a new feature in, making the act it belongs to where there is none. */
+const actFor = (copy, patch, act) => {
+    const beside = act.beside !== undefined
+        ? (patch ? gluedBeside(copy, act.beside) : producedBeside(copy, act.beside))
+        : undefined;
+    if (beside)
+        return beside;
+    if (patch) {
+        const added = [];
+        copy.modifications.push({ type: 'Attachment', added, ...(act.purpose && { purpose: act.purpose }) });
+        return added;
+    }
+    if (act.punched) {
+        if (!copy.production)
+            copy.production = {};
+        if (!copy.production.produced)
+            copy.production.produced = [];
+        return copy.production.produced;
+    }
+    const produced = [];
+    copy.modifications.push({ type: 'Alteration', produced, ...(act.purpose && { purpose: act.purpose }) });
+    return produced;
+};
+/**
+ * States that the copy bears the feature, in the act that brought it
+ * about: a patch was glued on by an attachment, anything else was
+ * produced, by the punching or by a later act. Which act, `FeatureAct`
+ * says; a `beside` that names nothing the copy bears is passed over and
+ * the feature goes into an act of its own.
+ */
+export const addFeature = (copyId, feature, act = {}) => onCopy(copyId, copy => {
+    actFor(copy, isPatch(feature), act).push(feature);
+});
+/**
+ * States that the patch bears the feature. What a patch bears came onto
+ * the copy with the patch, so it belongs to no act of its own and
+ * states no place: it stands where the patch stands.
+ */
+export const addBorneFeature = (copyId, patchId, feature) => onCopy(copyId, copy => {
+    const patch = featuresOf(copy).flatMap(withBorneFeatures).find(borne => borne.id === patchId);
+    if (!patch || !isPatch(patch))
+        return;
+    if (!patch.features)
+        patch.features = [];
+    patch.features.push(feature);
+});
+/**
+ * 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. An act
+ * left having produced or added nothing goes as well.
+ */
+export const removeFeatures = (copyId, featureIds) => onCopy(copyId, (copy, draft) => {
+    const named = new Set(featureIds);
+    const features = featuresOf(stateOf(copy));
+    rewriteFeatures(copy, (stated) => withoutFeatures(stated, named));
+    forgetFeatures(draft, new Set(goneWith(features, named)));
+});
+/**
+ * Whether two records of the edition state the same, the identity of a
+ * statement left out: two transcriptions reading the same word say the
+ * same, whichever ids they were given.
+ */
+const sayTheSame = (a, b) => {
+    if (a === b)
+        return true;
+    if (!isRecord(a) || !isRecord(b) || Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const keys = new Set([...Object.keys(a), ...Object.keys(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 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 isPatch(feature) && feature.features
+        ? { ...rest, features: feature.features.map(borne => borne.id) }
+        : rest;
+};
+const conditionsOf = (features) => features.flatMap(feature => feature.condition ? [feature.condition] : []);
+/**
+ * What stands in the way of reading the features as one, or nothing
+ * where they may be merged. Features may be merged where they differ
+ * in nothing but their place along the roll, their depiction and the
+ * condition at most one of them states. How far apart they lie is not
+ * asked: whether a gap is a bridge of the perforator, a tear or two
+ * perforations of their own is the editor's reading.
+ */
+export const mergeObstacle = (features) => {
+    if (features.length < 2)
+        return 'fewer-than-two';
+    const [first, ...rest] = features;
+    if (rest.some(feature => feature.type !== first.type))
+        return 'different-types';
+    if (rest.some(feature => !sayTheSame(feature.vertical, first.vertical)))
+        return 'different-tracks';
+    if (rest.some(feature => !sayTheSame(nature(feature), nature(first))))
+        return 'unlike-features';
+    const conditions = conditionsOf(features);
+    if (conditions.some(condition => !sayTheSame(condition, conditions[0])))
+        return 'differing-conditions';
+    return undefined;
+};
+/** The acts of the copy that state any of the named features. */
+const actsHolding = (copy, named) => featuresByAct(copy).filter(features => features.some(feature => named.has(feature.id)));
+/**
+ * What stands in the way of reading the named features of the copy as
+ * one, which is the whole of what `mergeFeatures` asks: whether one act
+ * brought them all about, and what the features themselves say. An id
+ * the copy does not bear at a place of its own is passed over.
+ */
+const obstacleIn = (copy, featureIds) => {
+    const named = new Set(featureIds);
+    const acts = actsHolding(copy, named);
+    return acts.length > 1
+        ? 'different-acts'
+        : mergeObstacle((acts[0] ?? []).filter(feature => named.has(feature.id)));
+};
+/**
+ * What stands in the way of reading the features the ids name as one,
+ * as `mergeFeatures` will find it. `mergeObstacle` asks only what the
+ * features themselves say, which cannot reach `different-acts`: one
+ * feature is the work of one act, and where the features stand is the
+ * edition's business rather than theirs.
+ */
+export const mergeObstacleIn = (view, featureIds) => {
+    const copy = featureIds.map(id => view.copyOf(id)).find(copy => copy !== undefined);
+    return copy ? obstacleIn(copy, featureIds) : 'fewer-than-two';
+};
+/** The items with the replacement in the place of the first it stands for, the others dropped. */
+const standingFor = (items, stands, replacement) => {
+    const first = items.findIndex(stands);
+    if (first < 0)
+        return items;
+    return items.flatMap((item, i) => i === first ? [replacement] : stands(item) ? [] : [item]);
+};
+const spanning = (features) => ({
+    unit: 'mm',
+    from: mm(Math.min(...features.map(feature => feature.horizontal.from))),
+    to: mm(Math.max(...features.map(feature => feature.horizontal.to)))
+});
+/**
+ * The feature the merged ones give way to. It spans them all and is in
+ * every other respect the one of them that states a condition, the
+ * others being alike in all but their place. The depiction goes: a
+ * region of the scan showing one part depicts no more than that part.
+ */
+const mergedFrom = (features, id) => {
+    const stating = features.find(feature => feature.condition) ?? features[0];
+    const merged = { ...stating, id, horizontal: spanning(features) };
+    delete merged.depiction;
+    return merged;
+};
+/** The symbol carried by the merged feature where it named one of those it replaces, and naming it once. */
+const carriedByMerged = (replaced, mergedId) => (symbol) => {
+    const names = (carrier) => replaced.has(idOf(carrier));
+    const first = symbol.carriers.find(names);
+    if (!first)
+        return symbol;
+    return { ...symbol, carriers: standingFor(symbol.carriers, names, { ...first, id: mergedId }) };
+};
+/** Points the versions at the merged feature wherever they name one it replaces. */
+const carryOver = (draft, replaced, mergedId) => {
+    const recarry = carriedByMerged(replaced, mergedId);
+    const recarrying = (edit) => {
+        const insert = edit.insert && mapped(edit.insert, recarry);
+        return insert === edit.insert ? edit : { ...edit, insert };
+    };
+    const versions = stateOf(draft.versions);
+    draft.versions.forEach((version, i) => {
+        const edits = versions[i].edits;
+        if (edits)
+            version.edits = mapped(edits, recarrying);
+    });
+};
+/**
+ * Replaces the features of the copy with a single one covering them
+ * all, where a scan has split what the editor reads as one feature.
+ * The merged feature takes the place of the first it replaces and
+ * spans from the first to the last, any gap between them included.
+ * What the replaced features carried is carried by the merged one, and
+ * 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. Features of two different acts are not merged
+ * either: one feature is the work of one act.
+ *
+ * Throws where the features cannot stand for one; `mergeObstacle`
+ * says beforehand whether they can.
+ */
+export const mergeFeatures = (copyId, featureIds) => onCopy(copyId, (copy, draft) => {
+    const state = stateOf(copy);
+    const obstacle = obstacleIn(state, featureIds);
+    if (obstacle) {
+        throw new Error(`The features of copy ${copyId} cannot be merged: ${obstacle}`);
+    }
+    const named = new Set(featureIds);
+    const toMerge = (actsHolding(state, named)[0] ?? []).filter(feature => named.has(feature.id));
+    const replaced = new Set(toMerge.map(feature => feature.id));
+    const mergedId = v4();
+    rewriteFeatures(copy, (stated) => {
+        const stands = (feature) => replaced.has(feature.id);
+        return stated.some(stands) ? standingFor(stated, stands, mergedFrom(stated.filter(stands), mergedId)) : stated;
+    });
+    carryOver(draft, replaced, mergedId);
+    renameReferences(draft, ids => standingFor(ids, id => replaced.has(id), mergedId));
+});

package/lib/ops/forget.d.ts

@@ -0,0 +1,31 @@
+/** Striking features from the edition, and rewriting the ids by which the edition names them outside the versions. */
+import { Draft } from "immer";
+import { Edition } from "../model/Edition.js";
+import { AnySymbol } from "../model/Symbol.js";
+import { RollCopy } from "../model/RollCopy.js";
+import { Ids } from "./draft.js";
+/** The ids of every feature the copy bears, those a patch bears among them. */
+export declare const featureIdsOf: (copy: RollCopy) => Ids;
+/**
+ * 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.
+ */
+export declare const carriedOnlyOn: (features: Ids) => (symbol: AnySymbol) => boolean;
+/** The ids a statement names, as the rewriting leaves them. */
+type Rename = (ids: string[]) => string[];
+/**
+ * Rewrites the ids by which the edition names features and symbols
+ * outside the versions. A belief is annotatable anywhere, so the whole
+ * edition is read; what the rewriting leaves alone is left the very
+ * object it was.
+ */
+export declare const renameReferences: (draft: Draft<Edition>, rename: Rename) => void;
+/**
+ * Strikes the features from the edition: their carriers go, a symbol
+ * that had no other carrier goes with them, an edit left exchanging
+ * nothing goes as well, and so does every reference the versions, the
+ * modifications of the copies and the comprehensions made to what went.
+ */
+export declare const forgetFeatures: (draft: Draft<Edition>, features: Ids) => void;
+export {};

package/lib/ops/forget.js

@@ -0,0 +1,110 @@
+import { isCommand, placementRelations } from "../model/Symbol.js";
+import { editsOf } from "../model/Version.js";
+import { featuresOf, statesNothing } from "../model/RollCopy.js";
+import { idOf } from "../model/Assumption.js";
+import { withBorneFeatures } from "../model/Feature.js";
+import { stateOf, droppedIds, insertedIn, edited } from "./draft.js";
+import { without, mapped, pruned, replacing, deeply, writeInto } from "./immutable.js";
+/** The ids of every feature the copy bears, those a patch bears among them. */
+export const featureIdsOf = (copy) => new Set(featuresOf(copy).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,
+ * stands on its own.
+ */
+export const carriedOnlyOn = (features) => (symbol) => symbol.carriers.length > 0 && symbol.carriers.every(carrier => features.has(idOf(carrier)));
+const references = [...placementRelations, 'pairedWith'];
+/** The command without its references to the dropped symbols, or the very same one where it makes none. */
+const forgettingReferences = (command, dropped) => {
+    const stale = references.filter(relation => {
+        const reference = command[relation];
+        return reference !== undefined && dropped.has(idOf(reference));
+    });
+    if (stale.length === 0)
+        return command;
+    const kept = { ...command };
+    stale.forEach(relation => { delete kept[relation]; });
+    return kept;
+};
+/** The symbol without the features among its carriers, and without references to what went with them. */
+const forgettingCarriers = (features, dropped) => (symbol) => {
+    const carriers = without(symbol.carriers, carrier => features.has(idOf(carrier)));
+    const relieved = carriers === symbol.carriers ? symbol : { ...symbol, carriers };
+    return isCommand(relieved) ? forgettingReferences(relieved, dropped) : relieved;
+};
+/** The edit without the dropped symbols and the features, or the very same edit where it had none of them. */
+const forgettingFeatures = (features, dropped) => {
+    const forgetCarriers = forgettingCarriers(features, dropped);
+    return (edit) => {
+        const insert = edit.insert && mapped(without(edit.insert, symbol => dropped.has(symbol.id)), forgetCarriers);
+        const deleted = edit.delete && without(edit.delete, id => dropped.has(id));
+        if (insert === edit.insert && deleted === edit.delete)
+            return edit;
+        return { ...edit, ...(insert && { insert }), ...(deleted && { delete: deleted }) };
+    };
+};
+const isCopy = (record) => 'type' in record && record.type === 'RollCopy';
+const isBelief = (record) => 'type' in record && record.type === 'belief';
+const isComprehension = (reason) => reason.type === 'meaningComprehension';
+const comprehendsNothing = (reason) => isComprehension(reason) && reason.comprehends.length === 0;
+/**
+ * The modification with what it names rewritten, or the very same one
+ * where that leaves it as it was. Only a removal names anything by id:
+ * what an act produced or glued on it states itself.
+ */
+const renamingMembers = (rename) => (modification) => modification.type === 'Removal'
+    ? replacing(modification, 'removed', rename(modification.removed))
+    : modification;
+/** The reason with what a comprehension comprehends rewritten; any other reason names nothing of the kind. */
+const renamingComprehended = (rename) => (reason) => isComprehension(reason) ? replacing(reason, 'comprehends', rename(reason.comprehends)) : reason;
+/**
+ * The record with the ids it names rewritten: what a copy's removals
+ * removed, and what the comprehensions among a belief's reasons
+ * comprehend. A removal or a comprehension the rewriting emptied goes
+ * with what it named; one that named nothing before stays, as an edit
+ * that was empty before it does.
+ */
+const renaming = (rename) => (record) => {
+    if (isCopy(record)) {
+        return replacing(record, 'modifications', pruned(record.modifications, renamingMembers(rename), statesNothing));
+    }
+    if (isBelief(record)) {
+        return replacing(record, 'reasons', pruned(record.reasons, renamingComprehended(rename), comprehendsNothing));
+    }
+    return record;
+};
+/**
+ * Rewrites the ids by which the edition names features and symbols
+ * outside the versions. A belief is annotatable anywhere, so the whole
+ * edition is read; what the rewriting leaves alone is left the very
+ * object it was.
+ */
+export const renameReferences = (draft, rename) => {
+    const before = stateOf(draft);
+    const after = deeply(renaming(rename))(before);
+    if (after !== before)
+        writeInto(draft, before, after);
+};
+/**
+ * Strikes the features from the edition: their carriers go, a symbol
+ * that had no other carrier goes with them, an edit left exchanging
+ * nothing goes as well, and so does every reference the versions, the
+ * modifications of the copies and the comprehensions made to what went.
+ */
+export const forgetFeatures = (draft, features) => {
+    const versions = stateOf(draft.versions);
+    const dropped = new Set(insertedIn(versions).filter(carriedOnlyOn(features)).map(symbol => symbol.id));
+    const forget = forgettingFeatures(features, dropped);
+    const edits = versions.map(version => version.edits && edited(version.edits, forget));
+    const gone = new Set([
+        ...features,
+        ...dropped,
+        ...versions.flatMap((version, i) => droppedIds(editsOf(version), edits[i] ?? []))
+    ]);
+    renameReferences(draft, ids => without(ids, id => gone.has(id)));
+    draft.versions.forEach((version, i) => {
+        const stated = edits[i];
+        if (stated)
+            version.edits = stated;
+    });
+};

package/lib/ops/immutable.d.ts

@@ -0,0 +1,16 @@
+/** Rewritings that return the very object they were given wherever they change nothing, so that an immer draft is left untouched there. */
+/** The items that do not match, or the very same array when none does, so that a draft stays untouched. */
+export declare const without: <T>(items: T[], matches: (item: T) => boolean) => T[];
+/** The items each changed, or the very same array when the change left every one as it was. */
+export declare const mapped: <T>(items: T[], change: (item: T) => T) => T[];
+/** The items each changed, less those the change emptied; the very same array where it changed none. */
+export declare const pruned: <T>(items: T[], change: (item: T) => T, emptied: (item: T) => boolean) => T[];
+/** The record with the field replaced, or the very same record where that is what stood there. */
+export declare const replacing: <T extends object, K extends keyof T>(record: T, key: K, value: T[K]) => T;
+/** A record of the edition, as the walk over it sees one. */
+export type Node = Record<string, unknown>;
+export declare const isRecord: (value: unknown) => value is Node;
+/** The value with the change applied to every record within it and then to itself, innermost first. */
+export declare const deeply: (change: (record: object) => object) => (value: unknown) => unknown;
+/** Writes onto the draft what the rewriting changed, as deep as the change reaches. */
+export declare const writeInto: (draft: Node, before: Node, after: Node) => void;

package/lib/ops/immutable.js

@@ -0,0 +1,46 @@
+/** Rewritings that return the very object they were given wherever they change nothing, so that an immer draft is left untouched there. */
+/** The items that do not match, or the very same array when none does, so that a draft stays untouched. */
+export const without = (items, matches) => items.some(matches) ? items.filter(item => !matches(item)) : items;
+/** The items each changed, or the very same array when the change left every one as it was. */
+export const mapped = (items, change) => {
+    const changed = items.map(change);
+    return changed.every((item, i) => item === items[i]) ? items : changed;
+};
+/** The items each changed, less those the change emptied; the very same array where it changed none. */
+export const pruned = (items, change, emptied) => {
+    const changed = mapped(items, change);
+    return changed === items ? items : changed.filter((item, i) => item === items[i] || !emptied(item));
+};
+/** The record with the field replaced, or the very same record where that is what stood there. */
+export const replacing = (record, key, value) => record[key] === value ? record : { ...record, [key]: value };
+export const isRecord = (value) => typeof value === 'object' && value !== null;
+/** The record's values each changed, or the very same record where the change left every one as it was. */
+const withValues = (record, change) => {
+    const entries = Object.entries(record);
+    const changed = entries.map(([key, value]) => [key, change(value)]);
+    return changed.every(([, value], i) => value === entries[i][1]) ? record : Object.fromEntries(changed);
+};
+/** The value with the change applied to every record within it and then to itself, innermost first. */
+export const deeply = (change) => {
+    const changed = (value) => Array.isArray(value) ? mapped(value, changed)
+        : isRecord(value) ? change(withValues(value, changed))
+            : value;
+    return changed;
+};
+/** Whether the two stand alike, so that what differs within them can be written where it lies. */
+const alike = (before, after) => {
+    if (!isRecord(before) || !isRecord(after))
+        return false;
+    if (Array.isArray(before))
+        return Array.isArray(after) && before.length === after.length;
+    return !Array.isArray(after);
+};
+/** Writes onto the draft what the rewriting changed, as deep as the change reaches. */
+export const writeInto = (draft, before, after) => Object.entries(after).forEach(([key, value]) => {
+    if (value === before[key])
+        return;
+    if (alike(before[key], value))
+        writeInto(draft[key], before[key], value);
+    else
+        draft[key] = value;
+});

package/lib/ops/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The operations on an edition, each written onto an immer draft of it.
+ * They are grouped by what they change under `ops/`; this module names
+ * the ones the library offers.
+ */
+export type { EditionOp } from "./draft.js";
+export { createVersion, addCopy, alignCopy, unalignCopy, shortenCopy, unshortenCopy, stateSource, clearSource, nameCopy, stateCarriage, clearCarriage, addGeneralCondition, symbolsCarriedOnlyBy, removeCopy } from "./copies.js";
+export { stateFeatureCondition, addFeature, addBorneFeature, removeFeatures, mergeObstacle, mergeObstacleIn, mergeFeatures, type FeatureAct, type MergeObstacle } from "./features.js";
+export { detachVersion, removeVersion, removeSymbols, deriveVersion, stateDerivation, clearDerivation } from "./versions.js";
+export { connectVersions, collateSymbols, separateReadings } from "./collation.js";
+export { mergeEdits, splitEdit } from "./edits.js";
+export { placeCommand, unplaceCommand, pairCommands, unpairCommand } from "./commands.js";
+export { createBelief, clearBelief, setCertainty, addReason, removeReason } from "./beliefs.js";

package/lib/ops/index.js

@@ -0,0 +1,7 @@
+export { createVersion, addCopy, alignCopy, unalignCopy, shortenCopy, unshortenCopy, stateSource, clearSource, nameCopy, stateCarriage, clearCarriage, addGeneralCondition, symbolsCarriedOnlyBy, removeCopy } from "./copies.js";
+export { stateFeatureCondition, addFeature, addBorneFeature, removeFeatures, mergeObstacle, mergeObstacleIn, mergeFeatures } from "./features.js";
+export { detachVersion, removeVersion, removeSymbols, deriveVersion, stateDerivation, clearDerivation } from "./versions.js";
+export { connectVersions, collateSymbols, separateReadings } from "./collation.js";
+export { mergeEdits, splitEdit } from "./edits.js";
+export { placeCommand, unplaceCommand, pairCommands, unpairCommand } from "./commands.js";
+export { createBelief, clearBelief, setCertainty, addReason, removeReason } from "./beliefs.js";

package/lib/ops/versions.d.ts

@@ -0,0 +1,33 @@
+import { EditionView } from "../view/EditionView.js";
+import { Derivation, Version } from "../model/Version.js";
+import { Belief } from "../model/Assumption.js";
+import { EditionOp } from "./draft.js";
+/** The derivations the version states beside its principal one, less any naming the parent. */
+export declare const hypothesesBeside: (version: Readonly<Version>, parentId: string) => Derivation[];
+/**
+ * Makes the version stand on its own: what it inherited becomes its
+ * own insertions, and its derivations go, the hypotheses among them,
+ * with the motivations that belonged to them.
+ */
+export declare const detachVersion: (given: EditionView, versionId: string) => EditionOp;
+/**
+ * Takes the version out. Whatever read its text against it comes to
+ * stand on its own, a hypothesis that something derives from it goes,
+ * and so does a copy's statement that it carries the version.
+ */
+export declare const removeVersion: (given: 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;
+/**
+ * States that the version may also derive from the parent, beside what
+ * it derives from already: a hypothesis, such as a contamination, under
+ * the belief given. The text stays read against the principal derivation
+ * unless the belief holds this one more certain. A version derives from
+ * itself, twice from one parent, or from one of its own descendants in
+ * no statement.
+ */
+export declare const stateDerivation: (versionId: string, parentId: string, belief?: Belief) => EditionOp;
+/** Takes back the hypothesis that the version derives from the parent; the principal derivation goes with `detachVersion`. */
+export declare const clearDerivation: (versionId: string, parentId: string) => EditionOp;

package/lib/ops/versions.js

@@ -0,0 +1,95 @@
+import { v4 } from "uuid";
+import { derivesFrom, editsOf, principalDerivationOf } from "../model/Version.js";
+import { assignReference, idOf } from "../model/Assumption.js";
+import { onVersion, stateOf, insertion, dropInsertions, referenceHeld, withoutReferences, reading } from "./draft.js";
+import { without } from "./immutable.js";
+import { dropStatements } from "./copies.js";
+/** Whether the version's text is read against the parent, its principal derivation naming it. */
+const readsAgainst = (version, parentId) => {
+    const principal = principalDerivationOf(version);
+    return principal !== undefined && idOf(principal) === parentId;
+};
+/** The derivations the version states beside its principal one, less any naming the parent. */
+export const hypothesesBeside = (version, parentId) => {
+    const principal = principalDerivationOf(version);
+    return (version.basedOn ?? []).filter(derivation => derivation !== principal && idOf(derivation) !== parentId);
+};
+/** Takes out the derivations that match, and the list itself where none is left. */
+const dropDerivations = (version, matches) => {
+    const derivations = stateOf(version).basedOn;
+    if (!derivations?.some(matches))
+        return;
+    const kept = withoutReferences(derivations, matches);
+    if (kept)
+        version.basedOn = kept;
+    else
+        delete version.basedOn;
+};
+/**
+ * Makes the version stand on its own: what it inherited becomes its
+ * own insertions, and its derivations go, the hypotheses among them,
+ * with the motivations that belonged to them.
+ */
+export const detachVersion = (given, versionId) => reading(given, view => {
+    const edits = view.snapshot(versionId).map(insertion);
+    return onVersion(versionId, version => {
+        version.edits = edits;
+        delete version.basedOn;
+        version.motivations = [];
+    });
+});
+/**
+ * Takes the version out. Whatever read its text against it comes to
+ * stand on its own, a hypothesis that something derives from it goes,
+ * and so does a copy's statement that it carries the version.
+ */
+export const removeVersion = (given, versionId) => reading(given, view => {
+    const detachments = view.edition.versions
+        .filter(version => readsAgainst(version, versionId))
+        .map(version => detachVersion(view, version.id));
+    const namesIt = (reference) => idOf(reference) === versionId;
+    return draft => {
+        detachments.forEach(detach => detach(draft));
+        draft.versions.forEach(version => dropDerivations(version, namesIt));
+        draft.copies.forEach(copy => dropStatements(copy, namesIt));
+        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 = editsOf(version).filter(edit => chosen.has(edit.id));
+    if (version.edits)
+        version.edits = without(version.edits, edit => chosen.has(edit.id));
+    draft.versions.push({
+        id: v4(),
+        system: stateOf(version).system,
+        basedOn: [assignReference(versionId)],
+        edits: moved,
+        motivations: []
+    });
+});
+/**
+ * States that the version may also derive from the parent, beside what
+ * it derives from already: a hypothesis, such as a contamination, under
+ * the belief given. The text stays read against the principal derivation
+ * unless the belief holds this one more certain. A version derives from
+ * itself, twice from one parent, or from one of its own descendants in
+ * no statement.
+ */
+export const stateDerivation = (versionId, parentId, belief) => onVersion(versionId, (version, draft) => {
+    const derivations = stateOf(version).basedOn ?? [];
+    if (parentId === versionId || derivations.some(derivation => idOf(derivation) === parentId))
+        return;
+    if (derivesFrom(stateOf(draft.versions), parentId, versionId))
+        return;
+    version.basedOn = [...derivations, referenceHeld(parentId, belief)];
+});
+/** Takes back the hypothesis that the version derives from the parent; the principal derivation goes with `detachVersion`. */
+export const clearDerivation = (versionId, parentId) => onVersion(versionId, version => {
+    if (readsAgainst(stateOf(version), parentId))
+        return;
+    dropDerivations(version, derivation => idOf(derivation) === parentId);
+});