linked-rolls 0.57.0 → 0.59.0

package/lib/editionOps.d.ts

@@ -1,260 +0,0 @@
-import { Draft } from "immer";
-import { EditionView, Path } from "./EditionView.js";
-import { Edition } from "./Edition.js";
-import { AnySymbol, PlacementRelation } from "./Symbol.js";
-import { CollationTolerance } from "./Collation.js";
-import { Edit } from "./Edit.js";
-import { GeneralRollCondition, ModificationPurpose, RollCopy, ScaleReading, Shift } from "./RollCopy.js";
-import { FeatureSource } from "./FeatureSource.js";
-import { AnyArgumentation, Belief, Certainty, ObjectAssumption } from "./Assumption.js";
-import { FeatureConditionAssignment, FeatureOrPatch, NestedFeature } from "./Feature.js";
-import { Millimeters } from "./Quantity.js";
-/**
- * A change to an edition, written onto an immer draft of it. One
- * operation is one undo step, so an operation that has to read the
- * edition first takes an `EditionView` of the state it will be
- * applied to and does all its writing in the one function it returns.
- */
-export type EditionOp = (draft: Draft<Edition>) => void;
-/**
- * Puts the copy into the edition with a version of its own, which
- * inserts every symbol the copy's own tracker bar reads on it. The
- * version is a reading in that system's words, so it is coded for the
- * system the copy was cut for.
- */
-export declare const createVersion: (copy: RollCopy) => EditionOp;
-/**
- * Puts the copy into the edition without a version of its own, as for a
- * copy whose features are not read into symbols: one known only from a
- * recording states instead which versions it carries.
- */
-export declare const addCopy: (copy: RollCopy) => EditionOp;
-/**
- * Shifts and then scales the copy's features into line with another
- * copy's, and puts the scale down to what the reading says: the paper,
- * or the speed the copy was cut for.
- */
-export declare const alignCopy: (copyId: string, shift: Shift, scale: number, reading?: ScaleReading) => EditionOp;
-/**
- * Puts the copy's features back where they were measured. A paper
- * stretch read off the alignment goes with it; a speed stated stays,
- * being a fact about the copy.
- */
-export declare const unalignCopy: (copyId: string) => EditionOp;
-/**
- * Takes the extension a pneumatic reader adds off the ends of the
- * copy's chains of holes, and records how much was taken, so that their lengths
- * can be compared with a scanned copy's at all.
- */
-export declare const shortenCopy: (copyId: string, extension: Millimeters, leaving?: ReadonlySet<string>) => EditionOp;
-/** Puts the reader's extension back on the copy's chains of holes. */
-export declare const unshortenCopy: (copyId: string) => EditionOp;
-/** States what the copy's features were read from, in place of any earlier statement. */
-export declare const stateSource: (copyId: string, source: FeatureSource) => EditionOp;
-/** Takes back the statement, leaving the copy silent about its source again. */
-export declare const clearSource: (copyId: string) => EditionOp;
-/** Gives the copy the siglum it is referred to by, or takes it away where the siglum given is blank. */
-export declare const nameCopy: (copyId: string, siglum: string) => EditionOp;
-/**
- * States that the copy carries the version, under the belief given. It
- * is meant for a copy whose features are not read into symbols, such as
- * one known only from a recording, and `carriageProblems` reports it
- * where features carry symbols already. A second statement about one
- * version is none.
- */
-export declare const stateCarriage: (copyId: string, versionId: string, belief?: Belief) => EditionOp;
-/** Takes back the copy's statement that it carries the version. */
-export declare const clearCarriage: (copyId: string, versionId: string) => EditionOp;
-/**
- * Adds a general condition to the copy, beside whatever is stated of it
- * already. The other condition a copy may be in, a paper stretch, is
- * read off an alignment and stated by `alignCopy`.
- */
-export declare const addGeneralCondition: (copyId: string, condition: ObjectAssumption<GeneralRollCondition>) => EditionOp;
-/**
- * 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 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[];
-/**
- * The act a feature an editor states belongs to: the punching of the
- * copy, the act that brought another feature about, or, where neither
- * is said, an act of its own for the purpose given. A patch is never
- * punched, being glued on, so `punched` says nothing of one.
- */
-export interface FeatureAct {
-    /** The copy came from its punching with it, which is where a reading of a scan puts every chain of holes. */
-    punched?: boolean;
-    /** The act that brought this feature about brought the new one about as well. */
-    beside?: string;
-    /** What the act was for, where a new one is made for the feature. */
-    purpose?: ModificationPurpose;
-}
-/**
- * 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 declare const addFeature: (copyId: string, feature: FeatureOrPatch, act?: FeatureAct) => EditionOp;
-/**
- * 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 declare const addBorneFeature: (copyId: string, patchId: string, feature: NestedFeature) => EditionOp;
-/**
- * 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 declare const removeFeatures: (copyId: string, featureIds: readonly string[]) => EditionOp;
-/**
- * Takes the copy out of the edition together with the symbols only it
- * carries, and with every reference the versions and the argumentations
- * made to those symbols.
- */
-export declare const removeCopy: (copyId: string) => EditionOp;
-/** Why several features cannot be replaced by one. */
-export type MergeObstacle = 'fewer-than-two' | 'different-types' | 'different-tracks' | 'differing-conditions' | 'unlike-features' | 'different-acts';
-/**
- * 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 declare const mergeObstacle: (features: readonly FeatureOrPatch[]) => MergeObstacle | undefined;
-/**
- * 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 declare const mergeObstacleIn: (view: EditionView, featureIds: readonly string[]) => MergeObstacle | undefined;
-/**
- * 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 declare const mergeFeatures: (copyId: string, featureIds: readonly string[]) => EditionOp;
-/**
- * Bases the child on the parent. A symbol of the child that collates
- * with one the parent hands down adds its carriers to that symbol; the
- * rest become the child's insertions, and what the parent hands down
- * and the child lacks becomes its deletions. The derivation states the
- * tolerance it was collated at and becomes the principal one; the
- * hypotheses the child stated beside its former one stay.
- *
- * The edits the child already stated are rewritten only as far as a
- * collation wrote them (`isCollationsOwn`). An editor's reading of the
- * difference between the two texts stays, and the symbols it speaks for
- * are left out of the collation, so that connecting the two again
- * neither doubles them nor silently drops what somebody established by
- * hand. An equivalence is the collation's own, since it is drawn from
- * the two systems' vocabularies rather than read off the paper, but one
- * drawn again over the very same symbols is kept as it stands, with its
- * identifier and whatever was written on it.
- *
- * The child's own text is what it shows less what the parent hands
- * down, so that connecting two versions already connected collates the
- * child's symbols and not the parent's with themselves.
- */
-export declare const connectVersions: (view: EditionView, childId: string, parentId: string, tolerance?: ObjectAssumption<CollationTolerance>) => EditionOp;
-/**
- * Folds the version's own symbols into those it inherits and collates
- * with: the carriers pass over, and the insertions go. Collates at the
- * tolerance of the derivation, where the caller names none.
- */
-export declare const collateSymbols: (view: EditionView, versionId: string, symbolIds: readonly string[], tolerance?: CollationTolerance) => EditionOp;
-/**
- * Takes the named copies' reading of a symbol back out of the symbol it
- * was collated into: their carriers pass to a new symbol of the
- * version's own, the remaining copies keep the symbol they had, and the
- * version states the exchange.
- *
- * This is the inverse of the hand-over a collation makes, and it is
- * what lets a derivation be collated a second time. A collated symbol
- * is one symbol carrying every copy that reads it, so nothing else
- * takes the two readings apart again, and without that a tolerance
- * arrived at after the fact could never be applied.
- *
- * The copies named are one **side** of the derivation, the same side a
- * window is measured over, and `sidesOf` is what says which they are.
- * Naming one copy of a side that has several does not separate that
- * side: what stays behind is the rest of it, mixed with the other
- * side's copies, and a collation then compares one copy against that
- * mixture rather than the two texts against each other.
- *
- * Symbols the named copies alone carry are already the version's own
- * and are passed over, so a reading somebody has separated by hand
- * keeps its identifier and the edit that speaks for it. Named symbols
- * narrow the act to those; naming none separates the whole reading.
- */
-export declare const separateReadings: (view: EditionView, versionId: string, copies: ReadonlySet<string>, symbolIds?: readonly string[]) => EditionOp;
-/**
- * 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: (view: 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: (view: 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, or twice from one parent, 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;
-/**
- * Replaces the edits with a single one carrying all their insertions
- * and deletions, classified by a guess at what the exchange does.
- */
-export declare const mergeEdits: (view: EditionView, versionId: string, toMerge: readonly Edit[]) => EditionOp;
-/** Replaces the edit with one edit per inserted and one per deleted symbol. */
-export declare const splitEdit: (versionId: string, toSplit: Edit) => EditionOp;
-/** States how the follower is placed relative to the reference, in place of any earlier statement. */
-export declare const placeCommand: (view: EditionView, followerId: string, referenceId: string, relation: PlacementRelation) => EditionOp;
-export declare const unplaceCommand: (view: EditionView, followerId: string) => EditionOp;
-/** The pair is stated on `statingId` only, as the format asks. */
-export declare const pairCommands: (view: EditionView, statingId: string, partnerId: string) => EditionOp;
-export declare const unpairCommand: (view: EditionView, statingId: string) => EditionOp;
-/** Annotates the assumption at the path with a belief held true, for reasons to be added. */
-export declare const createBelief: (path: Path) => EditionOp;
-export declare const clearBelief: (path: Path) => EditionOp;
-export declare const setCertainty: (path: Path, certainty: Certainty) => EditionOp;
-export declare const addReason: (path: Path, reason: AnyArgumentation) => EditionOp;
-export declare const removeReason: (path: Path, index: number) => EditionOp;