smoosic 1.0.11 → 1.0.14

package/src/smo/data/measure.ts

@@ -64,6 +64,7 @@ export interface MeasureTick {
  */
 export interface ISmoBeamGroup {
   notes: SmoNote[],
+  secondaryBeamBreaks: number[],
   voice: number,
   attrs: SmoAttrs
 }
@@ -1246,6 +1247,19 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
     return max;
   }
 
+  /**
+   * For pasting, paste into the target measure if the voice exists, else paste into
+   * voice 0
+   * @param voiceIndex 
+   * @returns 
+   */
+  getTicksFromThisOrAnyVoice(voiceIndex: number): number {
+    if (this.voices.length > voiceIndex) {
+      return this.getTicksFromVoice(voiceIndex);
+    } else {
+      return this.getTicksFromVoice(0);
+    }
+  }
   /**
    * Count the number of ticks in a specific voice
    * @param voiceIndex 

package/src/smo/data/noteModifiers.ts

@@ -349,7 +349,7 @@ function isSmoMicrotoneParamsSer(params: Partial<SmoMicrotoneParamsSer>): params
  * @category SmoObject
 */
 export class SmoMicrotone extends SmoNoteModifierBase {
-  tone: string;
+  tone: string = 'flat75sz';
   pitchIndex: number = 0;
 
   // This is how VexFlow notates them
@@ -385,10 +385,12 @@ export class SmoMicrotone extends SmoNoteModifierBase {
   get toVex(): string {
     return SmoMicrotone.smoToVex[this.tone];
   }
-  static readonly defaults: SmoMicrotoneParams = {
-    ctor: 'SmoMicrotone',
-    tone: 'flat25sz',
-    pitch: 0
+  static get defaults(): SmoMicrotoneParams  {
+    return JSON.parse(JSON.stringify({
+      ctor: 'SmoMicrotone',
+      tone: 'flat25sz',
+      pitch: 0
+    }));
   }
   static get parameterArray() {
     const rv: string[] = [];
@@ -409,8 +411,8 @@ export class SmoMicrotone extends SmoNoteModifierBase {
   }
   constructor(parameters: SmoMicrotoneParams) {
     super(parameters.ctor);
-    this.pitchIndex = parameters.pitch;
-    this.tone = parameters.tone;
+    smoSerialize.serializedMerge(SmoMicrotone.parameterArray, SmoMicrotone.defaults, this);
+    smoSerialize.serializedMerge(SmoMicrotone.parameterArray, parameters, this);
   }
 }
 
@@ -1020,7 +1022,49 @@ export class SmoLyric extends SmoNoteModifierBase {
     }
   }
 }
+/**
+ * Used to create a {@link SmoBarline}
+ * @category SmoObject
+ */
+
+export interface SmoNoteBarParams {
+  barline: number
+}
+
+export interface SmoNoteBarParamsSer extends SmoNoteBarParams {
+  ctor: string,
+  barline: number
+}
 
+export class SmoNoteBar extends SmoNoteModifierBase {
+  barline: number = SmoNoteBar.defaults.barline;
+  static get defaults(): SmoNoteBarParams {
+    return { barline: SmoNoteBar.barlines.noBar }
+  }
+  static get parameterArray() {
+    return ['barline'];
+  }
+  static readonly barlines: Record<string, number> = {
+    singleBar: 0,
+    doubleBar: 1,
+    endBar: 2,
+    startRepeat: 3,
+    endRepeat: 4,
+    noBar: 5
+  }
+  constructor(parameters: SmoNoteBarParams) {
+    super('SmoNoteBar');
+    smoSerialize.serializedMerge(SmoNoteBar.parameterArray, SmoNoteBar.defaults, this);
+    smoSerialize.serializedMerge(SmoLyric.parameterArray, parameters, this);
+  }
+  serialize(): SmoNoteBarParamsSer {
+    const parameters: Partial<SmoNoteBarParamsSer> = {};
+    smoSerialize.serializedMergeNonDefault(SmoNoteBar.defaults,
+      SmoNoteBar.parameterArray, this, parameters);
+    parameters.ctor = 'SmoNoteBar';
+    return parameters as SmoNoteBarParamsSer;
+  }
+}
 /**
  * The persisted bits of {@link SmoDynamicTextParams}
  * @category serialization
@@ -1203,6 +1247,7 @@ export const noteModifierDynamicCtorInit = () => {
   SmoDynamicCtor['SmoGraceNote'] = (params: GraceNoteParams) => new SmoGraceNote(params);
   SmoDynamicCtor['SmoArticulation'] = (params: SmoArticulationParameters) => new SmoArticulation(params);
   SmoDynamicCtor['SmoLyric'] = (params: SmoLyricParams) => new SmoLyric(params);
+  SmoDynamicCtor['SmoNoteBar'] = (params: SmoNoteBarParams) => new SmoNoteBar(params);
   SmoDynamicCtor['SmoDynamicText'] = (params: SmoDynamicTextParams) => new SmoDynamicText(params);
   SmoDynamicCtor['SmoTabNote'] = (params: SmoTabNoteParams) => new SmoTabNote(params);
   SmoDynamicCtor['SmoClefChange'] = (params: SmoClefChangeParams) => new SmoClefChange(params);

package/src/smo/data/scoreModifiers.ts

@@ -124,9 +124,10 @@ export interface SmoScoreInfo {
 }
 
 
-export type SmoScorePreferenceBool = 'autoPlay' | 'autoAdvance' | 'showPiano' | 'hideEmptyLines' | 'transposingScore';
+export type SmoScorePreferenceBool = 'autoPlay' | 'autoAdvance' | 'showPiano' | 'hideEmptyLines' | 'transposingScore' | 'autoScrollPlayback';
 export type SmoScorePreferenceNumber = 'defaultDupleDuration' | 'defaultTripleDuration';
-export const SmoScorePreferenceBools: SmoScorePreferenceBool[] = ['autoPlay', 'autoAdvance', 'showPiano', 'hideEmptyLines', 'transposingScore'];
+export const SmoScorePreferenceBools: SmoScorePreferenceBool[] = ['autoPlay', 'autoAdvance', 'showPiano', 'hideEmptyLines', 
+  'transposingScore', 'autoScrollPlayback'];
 export const SmoScorePreferenceNumbers: SmoScorePreferenceNumber[] = ['defaultDupleDuration', 'defaultTripleDuration'];
 /**
  * Global score/program behavior preferences, see below for parameters
@@ -135,6 +136,7 @@ export const SmoScorePreferenceNumbers: SmoScorePreferenceNumber[] = ['defaultDu
 export interface SmoScorePreferencesParams {
   autoPlay: boolean;
   autoAdvance: boolean;
+  autoScrollPlayback: boolean;
   defaultDupleDuration: number;
   defaultTripleDuration: number;
   showPiano: boolean;
@@ -159,6 +161,7 @@ export class SmoScorePreferences {
   defaultTripleDuration: number = 6144;
   showPiano: boolean = false;
   hideEmptyLines: boolean = false;
+  autoScrollPlayback: boolean = true;
   transposingScore: boolean = false;
   static get defaults(): SmoScorePreferencesParams {
     return {
@@ -166,19 +169,24 @@ export class SmoScorePreferences {
       autoAdvance: true,
       defaultDupleDuration: 4096,
       defaultTripleDuration: 6144,
+      autoScrollPlayback: true,
       showPiano: false,
       hideEmptyLines: false,
       transposingScore: false
     };
   }
   constructor(params: SmoScorePreferencesParams) {
-    if (params) {
+    if (params) {      
       SmoScorePreferenceBools.forEach((bb) => {
         this[bb] = params[bb];
       });
       SmoScorePreferenceNumbers.forEach((nn) => {
         this[nn] = params[nn];
       });
+      // legacy, added later
+      if (typeof(params.autoScrollPlayback) === 'undefined') {
+        this.autoScrollPlayback = true;
+      }
     }
   }
   serialize(): SmoScorePreferencesParams {

package/src/smo/data/staffModifiers.ts

@@ -46,6 +46,12 @@ export abstract class StaffModifierBase implements SmoModifierBase {
     const rv = SmoDynamicCtor[params.ctor](params);
     return rv;
   }
+  static cloneWithId(o: StaffModifierBase) {
+    const ser = o.serializeWithId();
+    const des = StaffModifierBase.deserialize(ser);
+    des.attrs = JSON.parse(JSON.stringify(o.attrs));
+    return des;
+  }
   serializeWithId() {
     const ser = this.serialize();
     ser.attrs = JSON.parse(JSON.stringify(this.attrs));
@@ -866,8 +872,8 @@ export class SmoTie extends StaffModifierBase {
   invert: boolean = false;
   cp1: number = 8;
   cp2: number = 12;
-  first_x_shift: number = 0;
-  last_x_shift: number = 0;
+  first_x_shift: number = -5;
+  last_x_shift: number = 5;
   y_shift: number = 7;
   tie_spacing: number = 0;
   lines: TieLine[] = [];
@@ -879,8 +885,8 @@ export class SmoTie extends StaffModifierBase {
       cp1: 8,
       cp2: 12,
       y_shift: 7,
-      first_x_shift: 0,
-      last_x_shift: 0,
+      first_x_shift: -5,
+      last_x_shift: 5,
       lines: [],
       startSelector: SmoSelector.default,
       endSelector: SmoSelector.default

package/src/smo/data/systemStaff.ts

@@ -777,17 +777,35 @@ export class SmoSystemStaff implements SmoObjectParams {
    */
   syncStaffModifiers(measureIndex: number, ostaff: SmoSystemStaff) {
     const mods: StaffModifierBase[] = [];
+    // remove any modifiers in the stored score that aren't in the view score
     this.modifiers.forEach((modifier) => {
       if (modifier.startSelector.measure !== measureIndex) {
         mods.push(modifier);
       } else {
         const omod = ostaff.modifiers.find((mm) => mm.attrs.id === modifier.attrs.id);
         if (omod) {
-          mods.push(modifier);
+          mods.push(omod);
         }
       }
     });
     this.modifiers = mods;
+    const measureSelectors = ostaff.modifiers.filter((mm) => mm.startSelector.measure === measureIndex);
+    // Add any new modifiers from a copy operation
+    measureSelectors.forEach((modifier) => {
+      const dup = this.modifiers.find((mm) => 
+        mm.startSelector.measure === modifier.startSelector.measure &&
+        mm.endSelector.measure === modifier.endSelector.measure &&
+        mm.ctor === modifier.ctor);
+      if (dup ?? null === null) {
+        const ser = StaffModifierBase.cloneWithId(modifier);
+        const des = StaffModifierBase.deserialize(ser);
+        des.attrs = JSON.parse(JSON.stringify(ser.attrs));
+        des.startSelector.staff = this.staffId;
+        des.endSelector.staff = this.staffId;
+        this.modifiers.push(des);
+      }
+    });
+
   }
   // ### deleteMeasure
   // delete the measure, and any staff modifiers that start/end there.

package/src/smo/data/tuplet.ts

@@ -144,6 +144,23 @@ export class SmoTupletTree {
     }
   }
 
+  /**
+   * Determines whether two notes are part of the same tuplet.
+   * @param noteOne
+   * @param noteTwo
+   */
+  static areNotesPartOfTheSameTuplet(noteOne: SmoNote, noteTwo: SmoNote): boolean {
+    if (noteOne.tupletId === noteTwo.tupletId) {
+      return true;
+    }
+
+    return false;
+  }
+
+  static areTupletsBothNull(noteOne: SmoNote, noteTwo: SmoNote): boolean {
+    return (noteOne.tupletId ?? null) === null && (noteTwo.tupletId ?? null) === null;
+  }
+
   serialize(): SmoTupletTreeParamsSer {
     const params = {
       ctor: 'SmoTupletTree',

package/src/smo/mxml/xmlHelpers.ts

@@ -114,7 +114,14 @@ export class XmlHelpers {
   // smo infers the stem type from the duration, but other applications don't
   static closestStemType(ticks: number) {
     const nticks = SmoMusic.closestDurationTickLtEq(ticks);
-    return XmlHelpers.ticksToNoteTypeMap[nticks];
+    // closestBeamDuration returns the rounded-up beam length for dotted rhythm and tuplets, 
+    // we want the actual stem that's used so cut it in 1/2
+    const beamDuration = SmoMusic.closestBeamDuration(nticks);
+    if (beamDuration.ticks === nticks) {
+      return XmlHelpers.ticksToNoteTypeMap[beamDuration.ticks];
+    } else {
+      return XmlHelpers.ticksToNoteTypeMap[beamDuration.ticks / 2];
+    }
   }
   static get beamStates(): Record<string, number> {
     return {

package/src/smo/xform/beamers.ts

@@ -6,12 +6,14 @@ import { SmoAttrs, getId } from '../data/common';
 import { SmoMeasure, ISmoBeamGroup } from '../data/measure';
 import { TickMap } from './tickMap';
 import { smoSerialize } from '../../common/serializationHelpers';
+import {SmoTuplet, SmoTupletTree} from "../data/tuplet";
 
 /**
  * @category SmoTransform
  */
 export interface SmoBeamGroupParams {
   notes: SmoNote[],
+  secondaryBeamBreaks: number[];
   voice: number
 }
 
@@ -21,12 +23,14 @@ export interface SmoBeamGroupParams {
  */
 export class SmoBeamGroup implements ISmoBeamGroup {
   notes: SmoNote[];
+  secondaryBeamBreaks: number[];
   attrs: SmoAttrs;
   voice: number = 0;
   constructor(params: SmoBeamGroupParams) {
     let i = 0;
     this.voice = params.voice;
     this.notes = params.notes;
+    this.secondaryBeamBreaks = params.secondaryBeamBreaks;
     smoSerialize.vexMerge(this, params);
 
     this.attrs = {
@@ -65,6 +69,7 @@ export class SmoBeamer {
   beamBeats: number;
   skipNext: number;
   currentGroup: SmoNote[];
+  secondaryBeamBreaks: number[];
   constructor(measure: SmoMeasure, voice: number) {
     this.measure = measure;
     this._removeVoiceBeam(measure, voice);
@@ -78,6 +83,7 @@ export class SmoBeamer {
     }
     this.skipNext = 0;
     this.currentGroup = [];
+    this.secondaryBeamBreaks = [];
   }
 
   get beamGroups() {
@@ -101,6 +107,7 @@ export class SmoBeamer {
     if (nrCount.length > 1) {
       this.measure.beamGroups.push(new SmoBeamGroup({
         notes: this.currentGroup,
+        secondaryBeamBreaks: this.secondaryBeamBreaks,
         voice
       }));
     }
@@ -108,6 +115,7 @@ export class SmoBeamer {
 
   _advanceGroup() {
     this.currentGroup = [];
+    this.secondaryBeamBreaks = [];
     this.duration = 0;
   }
 
@@ -151,40 +159,33 @@ export class SmoBeamer {
       return;
     }
 
+    if (this.currentGroup.length > 0) {
+      const areTupletsBothNull = SmoTupletTree.areTupletsBothNull(tickmap.notes[index - 1], tickmap.notes[index]);
+      const areNotesPartOfTheSameTuplet = SmoTupletTree.areNotesPartOfTheSameTuplet(tickmap.notes[index - 1], tickmap.notes[index]);
+
+      if (!areTupletsBothNull && !areNotesPartOfTheSameTuplet) {
+        this.secondaryBeamBreaks.push(this.currentGroup.length - 1);
+      }
+    }
+
     // beam tuplets
-    // if (note.isTuplet) {
-    //   const tuplet = this.measure.getTupletForNote(note);
-    //   // The underlying notes must have been deleted.
-    //   if (!tuplet) {
-    //     return;
-    //   }
-
-    //   const first = tuplet.getFirstNote();
-    //   if (!first) {
-    //     return;
-    //   }
-
-    //   const ult = tuplet.getLastNote();
-    //   if (!ult) {
-    //     return;
-    //   }
-
-    //   if (first.endBeam) {
-    //     this._advanceGroup();
-    //     return;
-    //   }
-
-    //   // is this beamable length-wise
-    //   if (note.noteType === 'n' && note.stemTicks < 4096) {
-    //     this.currentGroup.push(note);
-    //   }
-    //   // Ultimate note in tuplet
-    //   if (ult.attrs.id === note.attrs.id && !this._isRemainingTicksBeamable(tickmap, index)) {
-    //     this._completeGroup(tickmap.voice);
-    //     this._advanceGroup();
-    //   }
-    //   return;
-    // }
+    if (note.isTuplet) {
+      const tupletTree = SmoTupletTree.getTupletTreeForNoteIndex(this.measure.tupletTrees, tickmap.voice, index);
+      if (!tupletTree) {
+        return;
+      }
+
+      // is this beamable length-wise
+      if (note.noteType === 'n' && note.stemTicks < 4096) {
+        this.currentGroup.push(note);
+      }
+      // Ultimate note in tuplet
+      if (tupletTree.endIndex == index && !this._isRemainingTicksBeamable(tickmap, index)) {
+        this._completeGroup(tickmap.voice);
+        this._advanceGroup();
+      }
+      return;
+    }
 
     // don't beam > 1/4 note in 4/4 time.  Don't beam rests.
     if (note.stemTicks >= 4096 || (note.isRest() && this.currentGroup.length === 0)) {
@@ -193,33 +194,32 @@ export class SmoBeamer {
       return;
     }
 
-    //if areTupletElementsDifferent(noteOne, noteTwo)
-    //this._completeGroup(tickmap.voice);
-    //this._advanceGroup();
-    if (index > 0 && !SmoBeamer.areTupletElementsTheSame(tickmap.notes[index - 1], tickmap.notes[index])) {
+    this.currentGroup.push(note);
+
+    if (note.endBeam) {
       this._completeGroup(tickmap.voice);
       this._advanceGroup();
     }
-
-    this.currentGroup.push(note);
-    if (note.endBeam) {
+    if (index == tickmap.notes.length - 1) {
+      //Last note in the voice. We are closing the beam with whatever has been put there
       this._completeGroup(tickmap.voice);
       this._advanceGroup();
+      return;
     }
+
     if (this.measure.timeSignature.actualBeats % 4 === 0) {
-        if (this.duration < 8192 && this.allEighth()) {
-          return;
-        } else if (this.duration === 8192) {
-          this._completeGroup(tickmap.voice);
-          this._advanceGroup();
-        }
+      if (this.duration < 8192 && this.allEighth()) {
+        return;
+      } else if (this.duration === 8192) {
+        this._completeGroup(tickmap.voice);
+        this._advanceGroup();
+      }
     }
     // If we are aligned to a beat on the measure, and we are in common time
-    if (this.currentGroup.length > 1 && this.measure.timeSignature.beatDuration === 4 &&
-      this.measureDuration % 4096 === 0) {
-      this._completeGroup(tickmap.voice);
-      this._advanceGroup();
-      return;
+    if (this.currentGroup.length > 1 && this.measure.timeSignature.beatDuration === 4 && this.measureDuration % 4096 === 0) {
+        this._completeGroup(tickmap.voice);
+        this._advanceGroup();
+        return;
     }
     if (this.duration === this.beamBeats) {
       this._completeGroup(tickmap.voice);
@@ -232,19 +232,4 @@ export class SmoBeamer {
       this._advanceGroup();
     }
   }
-
-  public static areTupletElementsTheSame(noteOne: SmoNote, noteTwo: SmoNote): boolean {
-    if (typeof(noteOne.tupletId) === 'undefined' && typeof(noteTwo.tupletId) === 'undefined') {
-      return true;
-    }
-    if (noteOne.tupletId === null && noteTwo.tupletId === null) {
-      return true;
-    }
-    if (noteOne.isTuplet && noteTwo.isTuplet && noteOne.tupletId == noteTwo.tupletId) {
-      return true;
-    }
-
-    return false;
-  }
-
 }

package/src/smo/xform/copypaste.ts

@@ -105,8 +105,16 @@ export class PasteBuffer {
   _populateSelectArray(selections: SmoSelection[]) {
     let selector: SmoSelector = SmoSelector.default;
     this.modifiers = [];
+    let maxSelector = selections[0].selector;
+    let minSelector = selections[0].selector;
     selections.forEach((selection) => {
       selector = JSON.parse(JSON.stringify(selection.selector));
+      if (SmoSelector.gt(selector, maxSelector)) {
+        maxSelector = selector;
+      }
+      if (SmoSelector.lt(selector, minSelector)) {
+        minSelector = selector;
+      }
       const mod: StaffModifierBase[] = selection.staff.getModifiersAt(selector);
       if (mod.length) {
         mod.forEach((modifier: StaffModifierBase) => {

package/src/smo/xform/selections.ts

@@ -73,7 +73,10 @@ export class SmoSelector {
     (sel1.measure === sel2.measure && sel1.tick > sel2.tick);
   }
 
-  // ## return true if sel1 > sel2.
+  
+  /**
+   * return true if sel1 > sel2
+   */
   static gt(sel1: SmoSelector, sel2: SmoSelector): boolean {
     // Note: voice is not considered b/c it's more of a vertical component
     // Note further: sometimes we need to consider voice
@@ -90,13 +93,22 @@ export class SmoSelector {
     return !(SmoSelector.eq(sel1, sel2));
   }
 
+  /**
+   * return true if sel1 < sel2
+   */
   static lt(sel1: SmoSelector, sel2: SmoSelector): boolean {
     return SmoSelector.gt(sel2, sel1);
   }
 
+  /**
+   * return true if sel1 >= sel2
+   */
   static gteq(sel1: SmoSelector, sel2: SmoSelector): boolean {
     return SmoSelector.gt(sel1, sel2) || SmoSelector.eq(sel1, sel2);
   }
+  /**
+   * return true if sel1 <= sel2
+   */
   static lteq(sel1: SmoSelector, sel2: SmoSelector): boolean {
     return SmoSelector.lt(sel1, sel2) || SmoSelector.eq(sel1, sel2);
   }

package/src/smo/xform/tickDuration.ts

@@ -220,53 +220,91 @@ export class SmoStretchNoteActor extends TickIteratorBase {
     this.notes = this.measure.voices[this.voice].notes;
 
     const originalNote: SmoNote = this.notes[this.startIndex];
-    let newTicks: Ticks = { numerator: this.newStemTicks, denominator: 1, remainder: 0 };
     const multiplier = originalNote.tickCount / originalNote.stemTicks;
-    if (originalNote.isTuplet) {
-      const numerator = this.newStemTicks * multiplier;
-      newTicks = { numerator: Math.floor(numerator), denominator: 1, remainder: numerator % 1 };
-    } 
+
+    const newTicks = this.calculateNewTicks(originalNote, multiplier);
 
     const replacingNote = SmoNote.cloneWithDuration(originalNote, newTicks, this.newStemTicks);
 
+    const {stemTicksUsed, crossedTupletBoundary} = this.determineNotesToDelete(originalNote);
+
+    // if crossing a tuplet boundary, abort stretching
+    if (crossedTupletBoundary) {
+      this.numberOfNotesToDelete = 0;
+    } else {
+      this.prepareNotesToInsert(originalNote, replacingNote, stemTicksUsed, multiplier);
+    }
+  }
+
+  private calculateNewTicks(originalNote: SmoNote, multiplier: number): Ticks {
+    if (originalNote.isTuplet) {
+      const numerator = this.newStemTicks * multiplier
+      return { numerator: Math.floor(numerator), denominator: 1, remainder: numerator % 1};
+    } else {
+      return { numerator: this.newStemTicks, denominator: 1, remainder: 0};
+    }
+  }
+
+  private determineNotesToDelete(originalNote: SmoNote) {
+    let crossedTupletBoundary = false;
     let stemTicksUsed = originalNote.stemTicks;
+
     for (let i = this.startIndex + 1; i < this.notes.length; ++i) {
-      const nnote = this.notes[i];
-      //in case notes are part of the tuplet they need to belong to the same tuplet
-      //this check is only temporarely here, it should never come to this
-      if (nnote.isTuplet && !this.areNotesInSameTuplet(originalNote, nnote)) {
+      const nextNote = this.notes[i];
+
+      const areTupletsBothNull = SmoTupletTree.areTupletsBothNull(originalNote, nextNote);
+      const areNotesPartOfTheSmeTuplet = SmoTupletTree.areNotesPartOfTheSameTuplet(originalNote, nextNote);
+
+      if (!areTupletsBothNull && !areNotesPartOfTheSmeTuplet) {
+        crossedTupletBoundary = true;
         break;
       }
-      stemTicksUsed += nnote.stemTicks;
+
+      stemTicksUsed += nextNote.stemTicks;
       ++this.numberOfNotesToDelete;
+
       if (stemTicksUsed >= this.newStemTicks) {
         break;
       }
     }
-    const remainingAmount = stemTicksUsed - this.newStemTicks;
-    if (remainingAmount >= 0) {
+
+    return {stemTicksUsed, crossedTupletBoundary};
+  }
+
+  private prepareNotesToInsert(
+      originalNote: SmoNote,
+      replacingNote: SmoNote,
+      stemTicksUsed: number,
+      multiplier: number
+  ) {
+    const remainingTicks = stemTicksUsed - this.newStemTicks;
+
+    if (remainingTicks >= 0) {
       this.notesToInsert.push(replacingNote);
-      const lmap = SmoMusic.gcdMap(remainingAmount);
-      lmap.forEach((stemTick) => {
+
+      const tickMap = SmoMusic.gcdMap(remainingTicks);
+      tickMap.forEach((stemTick) => {
         const numerator = stemTick * multiplier;
-        const nnote = SmoNote.cloneWithDuration(originalNote, {numerator: Math.floor(numerator), denominator: 1, remainder: numerator % 1}, stemTick)
-        this.notesToInsert.push(nnote);
+        const newNote = SmoNote.cloneWithDuration(originalNote, {numerator: Math.floor(numerator), denominator: 1, remainder: numerator % 1}, stemTick)
+        this.notesToInsert.push(newNote);
       });
+
+      // Adjust tuplet indexes due to note insertion/deletion
       const noteCountDiff = (this.notesToInsert.length - this.numberOfNotesToDelete) - 1;
       SmoTupletTree.adjustTupletIndexes(this.measure.tupletTrees, this.voice, this.startIndex, noteCountDiff);
 
       //accumulate all remainders in the first note
-      let remainder: number = 0;
+      let totalRemainder: number = 0;
       this.notesToInsert.forEach((note: SmoNote) => {
         if (note.ticks.remainder > 0) {
-          remainder += note.ticks.remainder;
+          totalRemainder += note.ticks.remainder;
           note.ticks.remainder = 0;
         }
       });
-      this.notesToInsert[0].ticks.numerator += Math.round(remainder);
-
+      this.notesToInsert[0].ticks.numerator += Math.round(totalRemainder);
     }
   }
+
   static apply(params: SmoStretchNoteParams) {
     const actor = new SmoStretchNoteActor(params);
     SmoTickIterator.iterateOverTicks(actor.measure, actor, actor.voice);
@@ -280,13 +318,6 @@ export class SmoStretchNoteActor extends TickIteratorBase {
     } 
     return null;
   }
-
-  private areNotesInSameTuplet(noteOne: SmoNote, noteTwo: SmoNote): boolean {
-    if (noteOne.isTuplet && noteTwo.isTuplet && noteOne.tupletId == noteTwo.tupletId) {
-      return true;
-    }
-    return false;
-  }
 }