notations 0.0.48 → 0.0.51

package/lib/esm/beats.js

@@ -1,46 +1,11 @@
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import * as TSU from "@panyam/tsutils";
-import { Group, Space } from "./";
-import { FlatAtom, WindowIterator } from "./iterators";
-var ZERO = TSU.Num.Fraction.ZERO;
-var ONE = TSU.Num.Fraction.ONE;
-var Beat = (function () {
-    function Beat(index, role, offset, duration, barIndex, beatIndex, instance, prevBeat, nextBeat) {
+import { AtomType, Group, Space } from "./";
+import { WindowIterator } from "./iterators";
+import { GridModel, GridCell, ColAlign, GridLayoutGroup } from "./grids";
+const ZERO = TSU.Num.Fraction.ZERO;
+const ONE = TSU.Num.Fraction.ONE;
+export class Beat {
+    constructor(index, role, offset, duration, barIndex, beatIndex, instance, prevBeat, nextBeat) {
         this.index = index;
         this.role = role;
         this.offset = offset;
@@ -50,12 +15,10 @@ var Beat = (function () {
         this.instance = instance;
         this.prevBeat = prevBeat;
         this.nextBeat = nextBeat;
-        this.layoutLine = -1;
-        this.layoutColumn = -1;
         this.uuid = Beat.idCounter++;
         this.atomIsPlaceholder = false;
     }
-    Beat.prototype.debugValue = function () {
+    debugValue() {
         return {
             index: this.index,
             role: this.role.name,
@@ -66,29 +29,17 @@ var Beat = (function () {
             instance: this.instance,
             atom: this.atom.debugValue(),
         };
-    };
-    Object.defineProperty(Beat.prototype, "endOffset", {
-        get: function () {
-            return this.offset.plus(this.duration);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Beat.prototype, "filled", {
-        get: function () {
-            return this.remaining.isZero;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Beat.prototype, "remaining", {
-        get: function () {
-            return this.atom ? this.duration.minus(this.atom.duration, true) : this.duration;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Beat.prototype.add = function (atom) {
+    }
+    get endOffset() {
+        return this.offset.plus(this.duration);
+    }
+    get filled() {
+        return this.remaining.isZero;
+    }
+    get remaining() {
+        return this.atom ? this.duration.minus(this.atom.duration, true) : this.duration;
+    }
+    add(atom) {
         if (this.remaining.cmp(atom.duration) < 0) {
             return false;
         }
@@ -103,353 +54,78 @@ var Beat = (function () {
             this.atom.addAtoms(true, atom);
         }
         return true;
-    };
-    Beat.prototype.ensureUniformSpaces = function (atoms, slotsPerBeat) {
-        if (slotsPerBeat === void 0) { slotsPerBeat = 1; }
-        var lcm = 1;
-        var gcd = 0;
-        atoms.forEach(function (a, index) {
-            a.duration = a.duration.factorized;
-            var currDen = a.duration.den;
-            if (currDen != 1) {
-                lcm *= currDen;
-                if (gcd == 0) {
-                    gcd = a.duration.den;
-                }
-                else {
-                    gcd = TSU.Num.gcdof(gcd, currDen);
-                    lcm /= gcd;
-                }
-            }
-        });
-        var baseDur = new TSU.Num.Fraction(1, lcm);
-        var currOffset = this.offset;
-        for (var i = 0; i < atoms.length;) {
-            var fa = atoms[i];
-            var numSpaces = lcm == 1 ? fa.duration.num - 1 : lcm / fa.duration.den - 1;
-            fa.duration = baseDur;
-            currOffset = currOffset.plus(baseDur);
-            i++;
-            for (var j = 0; j < numSpaces; j++, i++) {
-                var space = new Space(baseDur);
-                space.isContinuation = true;
-                atoms.splice(i, 0, new FlatAtom(space));
-                atoms.splice(i, 0, new FlatAtom(space));
-                currOffset = currOffset.plus(baseDur);
-            }
-        }
-    };
-    Beat.idCounter = 0;
-    return Beat;
-}());
-export { Beat };
-var BeatLayout = (function () {
-    function BeatLayout(layoutParams) {
-        this.layoutParams = layoutParams;
-        this.bcolNextList = new Map();
-        this.beatColumns = new Map();
-        this.startingColumns = [];
-        this.columnForBeat = new Map();
-        this.DEBUG = false;
-        this.roleSpacing = 10;
-        this.rowSpacing = 15;
     }
-    BeatLayout.prototype.getBeatColumn = function (offset, duration) {
-        var e_1, _a;
-        var key = BeatLayout.keyFor(offset, duration);
-        var bcol = this.beatColumns.get(key) || null;
-        if (!bcol) {
-            bcol = new BeatColumn(offset, duration);
-            this.beatColumns.set(key, bcol);
-            if (bcol.offset.isZero) {
-                this.startingColumns.push(bcol);
+    get preMarkers() {
+        const out = [];
+        let curr = this.atom;
+        while (curr != null) {
+            for (const marker of curr.markersBefore || []) {
+                out.push(marker);
             }
-            else {
-                var endOffset = offset.plus(duration);
-                try {
-                    for (var _b = __values(this.beatColumns.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var other = _c.value;
-                        if (other.offset.plus(other.duration).equals(offset)) {
-                            this.addSuccessor(other, bcol);
-                        }
-                        else if (other.offset.equals(endOffset)) {
-                            this.addSuccessor(bcol, other);
-                        }
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-            }
-        }
-        return bcol;
-    };
-    BeatLayout.keyFor = function (offset, duration) {
-        return offset.factorized.toString() + ":" + duration.factorized.toString();
-    };
-    BeatLayout.prototype.addSuccessor = function (prev, next) {
-        TSU.assert(prev.offset.plus(prev.duration).equals(next.offset), "BeatColumns are not adjacent to each other");
-        var prevKey = BeatLayout.keyFor(prev.offset, prev.duration);
-        var nextKey = BeatLayout.keyFor(next.offset, next.duration);
-        var nextset = this.bcolNextList.get(prevKey) || null;
-        if (!nextset) {
-            nextset = new Set();
-            this.bcolNextList.set(prevKey, nextset);
-        }
-        nextset.add(nextKey);
-    };
-    BeatLayout.prototype.addBeat = function (beat) {
-        var lp = this.layoutParams;
-        var _a = __read(lp.getBeatLocation(beat), 3), layoutLine = _a[0], layoutColumn = _a[1], rowOffset = _a[2];
-        var bcol = this.getBeatColumn(rowOffset, beat.duration);
-        bcol.add(beat);
-        this.columnForBeat.set(beat.uuid, bcol);
-        beat.layoutLine = layoutLine;
-        beat.layoutColumn = layoutColumn;
-        return bcol;
-    };
-    BeatLayout.prototype.neighborsOf = function (beatColumn) {
-        var e_2, _a;
-        var out = [];
-        var endOffset = beatColumn.offset.plus(beatColumn.duration);
-        try {
-            for (var _b = __values(this.beatColumns.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var other = _c.value;
-                if (endOffset.equals(other.offset)) {
-                    out.push(other);
-                }
+            if (curr.type == AtomType.GROUP) {
+                curr = curr.atoms.first;
             }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            else {
+                curr = null;
             }
-            finally { if (e_2) throw e_2.error; }
         }
         return out;
-    };
-    BeatLayout.prototype.evalColumnSizes = function (beatViewDelegate) {
-        var e_3, _a, e_4, _b;
-        var queue = __spreadArray([], __read(this.startingColumns), false);
-        var xForOffsets = {};
-        while (queue.length > 0) {
-            var nextQueue = [];
-            try {
-                for (var queue_1 = (e_3 = void 0, __values(queue)), queue_1_1 = queue_1.next(); !queue_1_1.done; queue_1_1 = queue_1.next()) {
-                    var bcol = queue_1_1.value;
-                    var offset = bcol.offset.factorized;
-                    var colWidth = bcol.evalMaxWidth(beatViewDelegate);
-                    var currX = 0;
-                    if (!bcol.offset.isZero) {
-                        TSU.assert(offset.toString() in xForOffsets, "Cannot find x for given offset");
-                        currX = xForOffsets[offset.toString()];
-                    }
-                    bcol.setX(currX, beatViewDelegate);
-                    var endOffset = offset.plus(bcol.duration, true);
-                    xForOffsets[endOffset.toString()] = Math.max(xForOffsets[endOffset.toString()] || 0, currX + colWidth + bcol.paddingLeft + bcol.paddingRight);
-                    try {
-                        for (var _c = (e_4 = void 0, __values(this.beatColumns.values())), _d = _c.next(); !_d.done; _d = _c.next()) {
-                            var other = _d.value;
-                            if (endOffset.equals(other.offset)) {
-                                nextQueue.push(other);
-                            }
-                        }
-                    }
-                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                    finally {
-                        try {
-                            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
-                        }
-                        finally { if (e_4) throw e_4.error; }
-                    }
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (queue_1_1 && !queue_1_1.done && (_a = queue_1.return)) _a.call(queue_1);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-            queue = nextQueue;
-        }
-    };
-    BeatLayout.prototype.layoutBeatsForLine = function (line, allRoleBeats, beatViewDelegate) {
-        var lp = this.layoutParams;
-        var currBeats = line.roles.map(function (l, index) { return allRoleBeats[index][0]; });
-        var currY = this.roleSpacing;
-        var numDone = 0;
-        do {
-            numDone = 0;
-            for (var currRole = 0; currRole < currBeats.length; currRole++) {
-                var currBeat = currBeats[currRole];
-                if (currBeat) {
-                    var temp = currBeat;
-                    var numBeatsInRow = lp.lineBreaks[currBeat.layoutLine];
-                    var maxHeight = 0;
-                    var currX = 15;
-                    for (var i = currBeat.layoutColumn; i < numBeatsInRow && currBeat; i++, currBeat = currBeat.nextBeat, numDone++) {
-                        var beatView = beatViewDelegate.viewForBeat(currBeat);
-                        beatView.y = currY;
-                        if (this.DEBUG) {
-                            beatView.x = currX;
-                            beatView.refreshLayout();
-                            currX += beatView.width;
-                        }
-                        maxHeight = Math.max(maxHeight, beatView.minSize.height);
-                    }
-                    currBeat = temp;
-                    for (var i = currBeat.layoutColumn; i < numBeatsInRow && currBeat; i++, currBeat = currBeat.nextBeat, numDone++) {
-                        var beatView = beatViewDelegate.viewForBeat(currBeat);
-                        beatView.height = maxHeight;
-                    }
-                    currY += maxHeight;
-                    currY += this.roleSpacing;
-                }
-                currBeats[currRole] = currBeat;
-            }
-            currY += this.rowSpacing;
-        } while (numDone > 0);
-    };
-    return BeatLayout;
-}());
-export { BeatLayout };
-var BeatRow = (function () {
-    function BeatRow(layoutLine, rowIndex) {
-        this.layoutLine = layoutLine;
-        this.rowIndex = rowIndex;
-        this._y = 0;
-        this._maxHeight = 0;
-        this.needsLayout = false;
-        this.rowSpacing = 5;
-        this.beats = [];
-    }
-    Object.defineProperty(BeatRow.prototype, "y", {
-        get: function () {
-            return this._y;
-        },
-        set: function (val) {
-            this._y = val;
-            this.needsLayout = true;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    BeatRow.prototype.add = function (beat) {
-        this.beats.push(beat);
-        this.needsLayout = true;
-    };
-    return BeatRow;
-}());
-export { BeatRow };
-var BeatColumn = (function () {
-    function BeatColumn(offset, duration) {
-        this.offset = offset;
-        this.duration = duration;
-        this._x = 0;
-        this._maxWidth = 0;
-        this.needsLayout = false;
-        this.atomSpacing = 5;
-        this.paddingLeft = 15;
-        this.paddingRight = 15;
-        this.beats = [];
-        offset = offset.factorized;
-        duration = duration.factorized;
     }
-    Object.defineProperty(BeatColumn.prototype, "x", {
-        get: function () {
-            return this._x;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    BeatColumn.prototype.setX = function (val, beatViewDelegate) {
-        var e_5, _a;
-        this._x = val;
-        try {
-            for (var _b = __values(this.beats), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var beat = _c.value;
-                var beatView = beatViewDelegate.viewForBeat(beat);
-                beatView.x = val + this.paddingLeft;
-                beatView.width = this._maxWidth;
+    get postMarkers() {
+        const out = [];
+        let curr = this.atom;
+        while (curr != null) {
+            out.splice(0, 0, ...(curr.markersAfter || []));
+            if (curr.type == AtomType.GROUP) {
+                curr = curr.atoms.last;
             }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_5) throw e_5.error; }
-        }
-    };
-    Object.defineProperty(BeatColumn.prototype, "maxWidth", {
-        get: function () {
-            return this._maxWidth + this.paddingLeft + this.paddingRight;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    BeatColumn.prototype.setPadding = function (left, right) {
-        if (left >= 0) {
-            this.paddingLeft = left;
-        }
-        if (right >= 0) {
-            this.paddingRight = right;
-        }
-    };
-    BeatColumn.prototype.evalMaxWidth = function (beatViewDelegate) {
-        var e_6, _a;
-        this._maxWidth = 0;
-        try {
-            for (var _b = __values(this.beats), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var beat = _c.value;
-                var beatView = beatViewDelegate.viewForBeat(beat);
-                var minSize = beatView.minSize;
-                if (minSize.width > this._maxWidth) {
-                    this._maxWidth = minSize.width;
-                }
-            }
-        }
-        catch (e_6_1) { e_6 = { error: e_6_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            else {
+                curr = null;
             }
-            finally { if (e_6) throw e_6.error; }
         }
-        return this._maxWidth;
-    };
-    BeatColumn.prototype.add = function (beat) {
-        this.beats.push(beat);
-        this.needsLayout = true;
-    };
-    return BeatColumn;
-}());
-export { BeatColumn };
-var BeatsBuilder = (function () {
-    function BeatsBuilder(role, layoutParams, startOffset) {
-        if (startOffset === void 0) { startOffset = ZERO; }
+        return out;
+    }
+}
+Beat.idCounter = 0;
+export class BeatsBuilder {
+    constructor(role, layoutParams, startOffset = ZERO, ...atoms) {
         this.role = role;
         this.layoutParams = layoutParams;
         this.startOffset = startOffset;
         this.beats = [];
-        var _a = __read(layoutParams.cycle.getPosition(startOffset), 4), _b = __read(_a[1], 3), bar = _b[0], beat = _b[1], instance = _b[2], beatOffset = _a[2], index = _a[3];
+        const [, [bar, beat, instance], beatOffset, index] = layoutParams.cycle.getPosition(startOffset);
         this.cycleIter = layoutParams.cycle.iterateBeats(bar, beat, instance);
         this.windowIter = new WindowIterator();
         this.beatOffset = beatOffset;
         this.startIndex = index;
+        this.addAtoms(...atoms);
+    }
+    addAtoms(...atoms) {
+        this.windowIter.push(...atoms);
+        while (this.windowIter.hasMore) {
+            let currBeat = this.beats[this.beats.length - 1];
+            if (this.beats.length == 0 || currBeat.filled) {
+                currBeat = this.addBeat();
+            }
+            const [remAtoms, filled] = this.windowIter.get(currBeat.remaining);
+            TSU.assert(remAtoms.length > 0, "Atleast one element should have been available here");
+            for (const atom of remAtoms) {
+                TSU.assert(currBeat.add(atom), "Should return true as we are already using a duration iterator here");
+                if (this.onAtomAdded)
+                    this.onAtomAdded(atom, currBeat);
+            }
+            if (currBeat.filled) {
+                if (this.onBeatFilled)
+                    this.onBeatFilled(currBeat);
+            }
+        }
     }
-    BeatsBuilder.prototype.addBeat = function () {
-        var numBeats = this.beats.length;
-        var lastBeat = numBeats == 0 ? null : this.beats[numBeats - 1];
-        var nextCP = this.cycleIter.next().value;
-        var apb = this.layoutParams.beatDuration;
-        var newBeat = new Beat(lastBeat == null ? this.startIndex : lastBeat.index + 1, this.role, lastBeat == null ? this.startOffset.minus(this.beatOffset).timesNum(apb, true) : lastBeat.endOffset, nextCP[1].timesNum(apb), nextCP[0][0], nextCP[0][1], nextCP[0][2], lastBeat, null);
+    addBeat() {
+        const numBeats = this.beats.length;
+        const lastBeat = numBeats == 0 ? null : this.beats[numBeats - 1];
+        const nextCP = this.cycleIter.next().value;
+        const apb = this.layoutParams.beatDuration;
+        const newBeat = new Beat(lastBeat == null ? this.startIndex : lastBeat.index + 1, this.role, lastBeat == null ? this.startOffset.minus(this.beatOffset).timesNum(apb, true) : lastBeat.endOffset, nextCP[1].timesNum(apb), nextCP[0][0], nextCP[0][1], nextCP[0][2], lastBeat, null);
         if (lastBeat == null && this.beatOffset.isGT(ZERO)) {
             newBeat.add(new Space(this.beatOffset.timesNum(apb)));
         }
@@ -459,43 +135,155 @@ var BeatsBuilder = (function () {
         if (this.onBeatAdded)
             this.onBeatAdded(newBeat);
         return newBeat;
-    };
-    BeatsBuilder.prototype.addAtoms = function () {
-        var _a, e_7, _b;
-        var atoms = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            atoms[_i] = arguments[_i];
+    }
+}
+export class BeatColumn extends ColAlign {
+    constructor(offset, endOffset, markerType) {
+        super();
+        this.offset = offset;
+        this.endOffset = endOffset;
+        this.markerType = markerType;
+        this.atomSpacing = 5;
+        offset = offset.factorized;
+        endOffset = endOffset.factorized;
+        this.key = BeatColumn.keyFor(offset, endOffset, markerType);
+    }
+    static keyFor(offset, endOffset, markerType = 0) {
+        offset = offset.factorized;
+        endOffset = endOffset.factorized;
+        if (markerType < 0) {
+            return ":" + offset.toString();
         }
-        (_a = this.windowIter).push.apply(_a, __spreadArray([], __read(atoms), false));
-        while (this.windowIter.hasMore) {
-            var currBeat = this.beats[this.beats.length - 1];
-            if (this.beats.length == 0 || currBeat.filled) {
-                currBeat = this.addBeat();
-            }
-            var _c = __read(this.windowIter.get(currBeat.remaining), 2), remAtoms = _c[0], filled = _c[1];
-            TSU.assert(remAtoms.length > 0, "Atleast one element should have been available here");
-            try {
-                for (var remAtoms_1 = (e_7 = void 0, __values(remAtoms)), remAtoms_1_1 = remAtoms_1.next(); !remAtoms_1_1.done; remAtoms_1_1 = remAtoms_1.next()) {
-                    var atom = remAtoms_1_1.value;
-                    TSU.assert(currBeat.add(atom), "Should return true as we are already using a duration iterator here");
-                    if (this.onAtomAdded)
-                        this.onAtomAdded(atom, currBeat);
-                }
-            }
-            catch (e_7_1) { e_7 = { error: e_7_1 }; }
-            finally {
-                try {
-                    if (remAtoms_1_1 && !remAtoms_1_1.done && (_b = remAtoms_1.return)) _b.call(remAtoms_1);
+        else if (markerType > 0) {
+            return endOffset.toString() + ":";
+        }
+        else {
+            return offset.toString() + ":" + endOffset.toString();
+        }
+    }
+}
+export class BeatColDAG {
+    constructor(layoutGroup) {
+        this.layoutGroup = layoutGroup;
+        this.beatColumns = new Map();
+    }
+    getBeatColumn(offset, endOffset, markerType = 0) {
+        const [bcol, newcreated] = this.ensureBeatColumn(offset, endOffset, markerType);
+        if (newcreated) {
+            if (markerType == 0) {
+                const [prevcol] = this.ensureBeatColumn(offset, endOffset, -1);
+                const [nextcol] = this.ensureBeatColumn(offset, endOffset, 1);
+                prevcol.addSuccessor(bcol);
+                bcol.addSuccessor(nextcol);
+                for (const other of this.beatColumns.values()) {
+                    if (other.markerType == -1 && endOffset.equals(other.offset)) {
+                        nextcol.addSuccessor(other);
+                    }
+                    else if (other.markerType == 1 && other.endOffset.equals(offset)) {
+                        other.addSuccessor(prevcol);
+                    }
                 }
-                finally { if (e_7) throw e_7.error; }
             }
-            if (currBeat.filled) {
-                if (this.onBeatFilled)
-                    this.onBeatFilled(currBeat);
+        }
+        return bcol;
+    }
+    ensureBeatColumn(offset, endOffset, markerType = 0) {
+        const key = BeatColumn.keyFor(offset, endOffset, markerType);
+        let bcol = this.beatColumns.get(key) || null;
+        const newcreated = bcol == null;
+        if (!bcol) {
+            bcol = new BeatColumn(offset, endOffset, markerType);
+            this.beatColumns.set(key, bcol);
+        }
+        return [bcol, newcreated];
+    }
+}
+export class GlobalBeatLayout {
+    constructor() {
+        this.gridModelsForLine = new Map();
+        this.roleBeatsForLine = new Map();
+        this.beatColDAGsByLP = new Map();
+        this.gridLayoutGroup = new GridLayoutGroup();
+    }
+    getGridModelForLine(lineid) {
+        let out = this.gridModelsForLine.get(lineid) || null;
+        if (!out) {
+            out = new GridModel();
+            this.gridLayoutGroup.addGridModel(out);
+            this.gridModelsForLine.set(lineid, out);
+        }
+        return out;
+    }
+    beatColDAGForLP(lpid) {
+        let out = this.beatColDAGsByLP.get(lpid) || null;
+        if (!out) {
+            out = new BeatColDAG(this.gridLayoutGroup);
+            this.beatColDAGsByLP.set(lpid, out);
+        }
+        return out;
+    }
+    addLine(line) {
+        var _a, _b;
+        const gridModel = this.getGridModelForLine(line.uuid);
+        (_a = gridModel.eventHub) === null || _a === void 0 ? void 0 : _a.startBatchMode();
+        this.lineToRoleBeats(line, gridModel);
+        (_b = gridModel.eventHub) === null || _b === void 0 ? void 0 : _b.commitBatch();
+    }
+    lineToRoleBeats(line, gridModel) {
+        const lp = line.layoutParams;
+        const roleBeats = [];
+        this.roleBeatsForLine.set(line.uuid, roleBeats);
+        const lineOffset = line.offset.divbyNum(lp.beatDuration);
+        for (const role of line.roles) {
+            const bb = new BeatsBuilder(role, lp, lineOffset, ...role.atoms);
+            roleBeats.push(bb.beats);
+            for (const beat of bb.beats) {
+                this.addBeat(beat, gridModel);
             }
         }
-    };
-    return BeatsBuilder;
-}());
-export { BeatsBuilder };
+        return roleBeats;
+    }
+    addBeat(beat, gridModel) {
+        const line = beat.role.line;
+        const lp = line.layoutParams;
+        const beatColDAG = this.beatColDAGForLP(lp.uuid);
+        const [layoutLine, layoutColumn, rowOffset] = lp.getBeatLocation(beat);
+        const colEnd = rowOffset.plus(beat.duration, true);
+        const bcol = beatColDAG.getBeatColumn(rowOffset, colEnd, 0);
+        const roleIndex = beat.role.line.indexOfRole(beat.role.name);
+        const realRow = line.roles.length * (layoutLine + Math.floor(beat.index / lp.totalBeats)) + roleIndex;
+        const realCol = 1 + layoutColumn * 3;
+        const preMarkers = beat.preMarkers;
+        if (preMarkers.length > 0) {
+            const val = {
+                beat: beat,
+                markers: preMarkers,
+            };
+            const precol = beatColDAG.getBeatColumn(rowOffset, colEnd, -1);
+            gridModel.setValue(realRow, realCol - 1, val, (gridRow, col) => {
+                const cell = new GridCell(gridRow, col);
+                cell.colAlign = precol;
+                return cell;
+            });
+        }
+        const postMarkers = beat.postMarkers;
+        if (postMarkers.length > 0) {
+            const val = {
+                beat: beat,
+                markers: postMarkers,
+            };
+            const postcol = beatColDAG.getBeatColumn(rowOffset, colEnd, 1);
+            gridModel.setValue(realRow, realCol + 1, val, (gridRow, col) => {
+                const cell = new GridCell(gridRow, col);
+                cell.colAlign = postcol;
+                return cell;
+            });
+        }
+        return gridModel.setValue(realRow, realCol, beat, (gridRow, col) => {
+            const cell = new GridCell(gridRow, col);
+            cell.colAlign = bcol;
+            return cell;
+        });
+    }
+}
 //# sourceMappingURL=beats.js.map