linked-rolls 0.63.0 → 0.64.0

package/lib/view/EditionView.d.ts

@@ -1,103 +0,0 @@
-import { Edition } from "../model/Edition.js";
-import { FeatureOrPatch, HorizontalSpan, NestedFeature } from "../model/Feature.js";
-import { AnySymbol } from "../model/Symbol.js";
-import { Version } from "../model/Version.js";
-import { Modification, ProductionEvent, RollCopy } from "../model/RollCopy.js";
-import { Millimeters } from "../model/Quantity.js";
-export type Path = (string | number)[];
-export declare const getAt: <T>(path: Path, obj: unknown) => T | undefined;
-export declare class EditionView {
-    readonly edition: Edition;
-    /**
-     * Map from id to its path within the edition
-     */
-    private readonly paths;
-    /**
-     * Map from id to paths where it is referenced
-     */
-    private readonly links;
-    /** Built when a copy is first asked for, the walk not recording it. */
-    private copiesByFeature?;
-    /**
-     * One index for each kind of entity, built from where the edition
-     * holds it. The index an entity is found in says what it is, so a
-     * lookup needs neither a type discriminator nor a cast.
-     */
-    private readonly versionsById;
-    private readonly copiesById;
-    private readonly symbolsById;
-    private featuresById?;
-    constructor(edition: Edition);
-    /** What stands at the path, or null where nothing does. A zero or an empty string stands there as well. */
-    atPath<T>(path: Path): T | null;
-    /**
-     * Walks the edition and records where each id stands and where it is
-     * referenced. The constructor does this; a second call starts afresh
-     * rather than recording every reference twice.
-     */
-    indexObjects(): void;
-    version(id: string): Readonly<Version> | undefined;
-    copy(id: string): Readonly<RollCopy> | undefined;
-    symbol(id: string): Readonly<AnySymbol> | undefined;
-    /** The symbols under the ids, leaving out an id that names none. */
-    symbols(ids: readonly string[]): Readonly<AnySymbol>[];
-    /** A feature or a patch on any copy, one a patch bears included. */
-    feature(id: string): Readonly<NestedFeature> | undefined;
-    /** The features and patches under the ids, leaving out an id that names none. */
-    features(ids: readonly string[]): Readonly<NestedFeature>[];
-    getPath(anyId: string): Path | undefined;
-    linksTo(anyId: string): Path[];
-    /**
-     * Calls back on the version and its ancestors along the principal
-     * line. A stemma that loops back on itself is walked once round, so
-     * that an edition in that state can still be read and repaired.
-     */
-    travelUp(versionId: string, callback: (version: Readonly<Version>) => void): void;
-    /** The version and its ancestors along the principal line, from the version up to the root. */
-    lineageOf(versionId: string): Readonly<Version>[];
-    carriersOf(symbol: AnySymbol): Readonly<NestedFeature>[];
-    /** The carriers that state a place of their own, which a feature on a patch does not. */
-    placedCarriersOf(symbol: AnySymbol): Readonly<FeatureOrPatch>[];
-    /** The copy a feature sits on, a patch and everything it bears included. */
-    copyOf(featureId: string): Readonly<RollCopy> | undefined;
-    /**
-     * The act a copy states a feature in: the production event that
-     * punched it, or the modification that brought it about. A feature
-     * a patch bears came onto the copy with the patch, so the act is
-     * the one that glued the patch on. Two features stand in one act
-     * where this returns the very same object, which is what
-     * `mergeFeatures` asks before it reads them as one.
-     */
-    actOf(featureId: string): Readonly<ProductionEvent | Modification> | undefined;
-    /** The version the given one's text is read against, by its principal derivation. */
-    predecessorOf(versionId: string): Readonly<Version> | undefined;
-    /**
-     * Where along the roll the symbol lies, as its carriers put it, or
-     * nothing for a symbol no copy carries.
-     *
-     * Only the place is measured. Which track the symbol sits on is not
-     * a measurement but a question for a tracker bar, since a note of
-     * one pitch sits on exactly one position of a given bar: ask
-     * `bar.positionOf`. The carriers cannot answer it, because a copy
-     * cut for another system numbers its tracks differently, and one
-     * symbol may be carried by copies of both — averaging a red carrier
-     * on track 47 with a green one on 45 would give 46, a legal
-     * position a semitone away on either bar.
-     */
-    placeOf(symbol: AnySymbol): Readonly<HorizontalSpan> | undefined;
-    /** Where the symbol begins, as the mean onset of its carriers, or nothing for a symbol without a place. */
-    onsetOf(symbol: AnySymbol): Millimeters | undefined;
-    /** The symbols by onset, those without a place first; symbols at one place keep their order. */
-    private inOrderOfPlace;
-    /**
-     * The symbols the version shows: what it and its ancestors insert,
-     * each version's deletions striking what it or its ancestors inserted.
-     */
-    snapshot(versionId: string): readonly Readonly<AnySymbol>[];
-    /**
-     * Assigns a generation (depth) to every node.
-     */
-    withGenerations(): Array<Version & {
-        generation: number;
-    }>;
-}

package/lib/view/EditionView.js

@@ -1,329 +0,0 @@
-import { isPlaced, withBorneFeatures } from "../model/Feature.js";
-import { deletedBy, insertedBy, principalDerivationOf } from "../model/Version.js";
-import { featuresMadeBy, featuresOf } from "../model/RollCopy.js";
-import { idOf, idsOf } from "../model/Assumption.js";
-import { mean } from "../model/Quantity.js";
-export const getAt = (path, obj) => {
-    let node = obj;
-    for (const key of path) {
-        if (node == null)
-            return undefined;
-        node = node[key];
-    }
-    return node;
-};
-/** Keys under which an object names others by id, singly or in a list. */
-const referenceKeys = ['delete', 'comprehends', 'motivation', 'premises', 'used'];
-const byIdIn = (entities) => new Map(entities.map(entity => [entity.id, entity]));
-const isObject = (v) => v !== null && typeof v === "object";
-/** What a reference may state besides the id: a belief about it, and the tolerance a derivation was collated at. */
-const referenceOwnKeys = new Set(['id', '@annotation', 'collationTolerance']);
-/** An object that names another by its id and says nothing of its own beyond that. */
-const isReferenceOnly = (keys) => keys.every(key => referenceOwnKeys.has(key));
-const pathOf = (trail) => {
-    const path = [];
-    for (let link = trail; link !== null; link = link.up)
-        path.push(link.key);
-    return path.reverse();
-};
-export class EditionView {
-    constructor(edition) {
-        Object.defineProperty(this, "edition", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /**
-         * Map from id to its path within the edition
-         */
-        Object.defineProperty(this, "paths", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        /**
-         * Map from id to paths where it is referenced
-         */
-        Object.defineProperty(this, "links", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        /** Built when a copy is first asked for, the walk not recording it. */
-        Object.defineProperty(this, "copiesByFeature", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /**
-         * One index for each kind of entity, built from where the edition
-         * holds it. The index an entity is found in says what it is, so a
-         * lookup needs neither a type discriminator nor a cast.
-         */
-        Object.defineProperty(this, "versionsById", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "copiesById", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "symbolsById", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "featuresById", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.edition = edition;
-        this.versionsById = byIdIn(edition.versions);
-        this.copiesById = byIdIn(edition.copies);
-        this.symbolsById = byIdIn(edition.versions.flatMap(insertedBy));
-        this.indexObjects();
-    }
-    /** What stands at the path, or null where nothing does. A zero or an empty string stands there as well. */
-    atPath(path) {
-        return getAt(path, this.edition) ?? null;
-    }
-    /**
-     * Walks the edition and records where each id stands and where it is
-     * referenced. The constructor does this; a second call starts afresh
-     * rather than recording every reference twice.
-     */
-    indexObjects() {
-        this.paths.clear();
-        this.links.clear();
-        const visited = new WeakSet();
-        const link = (id, trail) => {
-            const trails = this.links.get(id);
-            if (trails)
-                trails.push(trail);
-            else
-                this.links.set(id, [trail]);
-        };
-        const index = (record, keys, trail) => {
-            if (typeof record.id !== "string")
-                return;
-            if (isReferenceOnly(keys))
-                link(record.id, { key: 'id', up: trail });
-            else if (!this.paths.has(record.id)) {
-                this.paths.set(record.id, trail);
-            }
-        };
-        const linkReferences = (record, trail) => referenceKeys.forEach(key => {
-            const ref = record[key];
-            if (typeof ref === "string")
-                link(ref, { key, up: trail });
-            else if (Array.isArray(ref))
-                ref.forEach((r, i) => {
-                    if (typeof r === "string")
-                        link(r, { key: i, up: { key, up: trail } });
-                });
-        });
-        const traverse = (node, trail) => {
-            if (!isObject(node) || visited.has(node))
-                return;
-            visited.add(node);
-            if (Array.isArray(node)) {
-                node.forEach((item, i) => traverse(item, { key: i, up: trail }));
-                return;
-            }
-            const record = node;
-            const keys = Object.keys(record);
-            index(record, keys, trail);
-            linkReferences(record, trail);
-            keys.forEach(key => traverse(record[key], { key, up: trail }));
-        };
-        traverse(this.edition, null);
-    }
-    version(id) {
-        return this.versionsById.get(id);
-    }
-    copy(id) {
-        return this.copiesById.get(id);
-    }
-    symbol(id) {
-        return this.symbolsById.get(id);
-    }
-    /** The symbols under the ids, leaving out an id that names none. */
-    symbols(ids) {
-        return ids.flatMap(id => this.symbol(id) ?? []);
-    }
-    /** A feature or a patch on any copy, one a patch bears included. */
-    feature(id) {
-        this.featuresById ?? (this.featuresById = byIdIn(this.edition.copies.flatMap(copy => featuresOf(copy).flatMap(withBorneFeatures))));
-        return this.featuresById.get(id);
-    }
-    /** The features and patches under the ids, leaving out an id that names none. */
-    features(ids) {
-        return ids.flatMap(id => this.feature(id) ?? []);
-    }
-    getPath(anyId) {
-        const trail = this.paths.get(anyId);
-        return trail === undefined ? undefined : pathOf(trail);
-    }
-    linksTo(anyId) {
-        return (this.links.get(anyId) ?? []).map(pathOf);
-    }
-    /**
-     * Calls back on the version and its ancestors along the principal
-     * line. A stemma that loops back on itself is walked once round, so
-     * that an edition in that state can still be read and repaired.
-     */
-    travelUp(versionId, callback) {
-        const visited = new Set();
-        let v = this.version(versionId);
-        while (v && !visited.has(v.id)) {
-            visited.add(v.id);
-            callback(v);
-            const principal = principalDerivationOf(v);
-            v = principal && this.version(idOf(principal));
-        }
-    }
-    /** The version and its ancestors along the principal line, from the version up to the root. */
-    lineageOf(versionId) {
-        const lineage = [];
-        this.travelUp(versionId, version => lineage.push(version));
-        return lineage;
-    }
-    carriersOf(symbol) {
-        return this.features(idsOf(symbol.carriers));
-    }
-    /** The carriers that state a place of their own, which a feature on a patch does not. */
-    placedCarriersOf(symbol) {
-        return this.carriersOf(symbol).filter(isPlaced);
-    }
-    /** The copy a feature sits on, a patch and everything it bears included. */
-    copyOf(featureId) {
-        if (!this.copiesByFeature) {
-            this.copiesByFeature = new Map(this.edition.copies.flatMap(copy => featuresOf(copy)
-                .flatMap(withBorneFeatures)
-                .map(feature => [feature.id, copy])));
-        }
-        return this.copiesByFeature.get(featureId);
-    }
-    /**
-     * The act a copy states a feature in: the production event that
-     * punched it, or the modification that brought it about. A feature
-     * a patch bears came onto the copy with the patch, so the act is
-     * the one that glued the patch on. Two features stand in one act
-     * where this returns the very same object, which is what
-     * `mergeFeatures` asks before it reads them as one.
-     */
-    actOf(featureId) {
-        const copy = this.copyOf(featureId);
-        if (!copy)
-            return undefined;
-        const states = (features) => features.flatMap(withBorneFeatures).some(feature => feature.id === featureId);
-        if (states(copy.production?.produced ?? []))
-            return copy.production;
-        return copy.modifications.find(act => states(featuresMadeBy(act)));
-    }
-    /** The version the given one's text is read against, by its principal derivation. */
-    predecessorOf(versionId) {
-        const v = this.version(versionId);
-        const principal = v && principalDerivationOf(v);
-        return principal && this.version(idOf(principal));
-    }
-    /**
-     * Where along the roll the symbol lies, as its carriers put it, or
-     * nothing for a symbol no copy carries.
-     *
-     * Only the place is measured. Which track the symbol sits on is not
-     * a measurement but a question for a tracker bar, since a note of
-     * one pitch sits on exactly one position of a given bar: ask
-     * `bar.positionOf`. The carriers cannot answer it, because a copy
-     * cut for another system numbers its tracks differently, and one
-     * symbol may be carried by copies of both — averaging a red carrier
-     * on track 47 with a green one on 45 would give 46, a legal
-     * position a semitone away on either bar.
-     */
-    placeOf(symbol) {
-        const carriers = this.placedCarriersOf(symbol);
-        if (carriers.length === 0)
-            return;
-        return {
-            unit: 'mm',
-            from: mean(carriers.map(carrier => carrier.horizontal.from)),
-            to: mean(carriers.map(carrier => carrier.horizontal.to))
-        };
-    }
-    /** Where the symbol begins, as the mean onset of its carriers, or nothing for a symbol without a place. */
-    onsetOf(symbol) {
-        return this.placeOf(symbol)?.from;
-    }
-    /** The symbols by onset, those without a place first; symbols at one place keep their order. */
-    inOrderOfPlace(symbols) {
-        return symbols
-            .map(symbol => ({ symbol, at: this.onsetOf(symbol) || 0 }))
-            .sort((a, b) => a.at - b.at)
-            .map(({ symbol }) => symbol);
-    }
-    /**
-     * The symbols the version shows: what it and its ancestors insert,
-     * each version's deletions striking what it or its ancestors inserted.
-     */
-    snapshot(versionId) {
-        const deleted = new Set();
-        const symbols = this.lineageOf(versionId).flatMap(version => {
-            deletedBy(version).forEach(id => deleted.add(id));
-            return insertedBy(version).filter(symbol => !deleted.has(symbol.id));
-        });
-        return this.inOrderOfPlace(symbols);
-    }
-    /**
-     * Assigns a generation (depth) to every node.
-     */
-    withGenerations() {
-        const memo = new Map();
-        const inStack = new Set();
-        const computeGeneration = (id) => {
-            if (memo.has(id))
-                return memo.get(id);
-            if (inStack.has(id)) {
-                throw new Error(`Cycle detected involving node '${id}'. Check parentId links.`);
-            }
-            const node = this.version(id);
-            if (!node) {
-                memo.set(id, 0);
-                return 0;
-            }
-            inStack.add(id);
-            let gen;
-            const principal = principalDerivationOf(node);
-            const basedOn = principal && idOf(principal);
-            if (basedOn === undefined) {
-                gen = 0; // root
-            }
-            else if (!this.version(basedOn)) {
-                // Orphaned parent reference — treat boundary as root
-                gen = 0;
-            }
-            else {
-                gen = 1 + computeGeneration(basedOn);
-            }
-            inStack.delete(id);
-            memo.set(id, gen);
-            return gen;
-        };
-        // Compute for all nodes (order doesn’t matter)
-        const withGen = this.edition.versions.map(n => ({
-            ...n,
-            generation: computeGeneration(n.id),
-        }));
-        return withGen;
-    }
-}