smoosic 1.0.36 → 1.0.38

package/src/smo/data/measure.ts

@@ -12,9 +12,9 @@
 import { smoSerialize } from '../../common/serializationHelpers';
 import { SmoMusic } from './music';
 import {
-  SmoBarline, SmoMeasureModifierBase, SmoRepeatSymbol, SmoTempoText, SmoMeasureFormat,
-  SmoVolta, SmoRehearsalMarkParams, SmoRehearsalMark, SmoTempoTextParams, TimeSignature,
-  TimeSignatureParametersSer, SmoMeasureFormatParamsSer, SmoTempoTextParamsSer
+  SmoBarline, SmoMeasureModifierBase, SmoRepeatSymbol, SmoTempo, SmoMeasureFormat,
+  SmoVolta, SmoRehearsalMarkParams, SmoRehearsalMark, SmoTempoParams, SmoTimeSignature,
+  TimeSignatureParametersSer, SmoMeasureFormatParamsSer, SmoTempoParamsSer
 } from './measureModifiers';
 import { SmoNote, NoteType, SmoNoteParamsSer } from './note';
 import { SmoTuplet, SmoTupletParamsSer, SmoTupletParams, SmoTupletTreeParamsSer, SmoTupletTree } from './tuplet';
@@ -148,7 +148,7 @@ export const SmoMeasureStringParams: SmoMeasureStringParam[] = ['keySignature'];
  * @category SmoObject
  */
 export interface SmoMeasureParams {
-  timeSignature: TimeSignature,
+  timeSignature: SmoTimeSignature,
   keySignature: string,
   tupletTrees: SmoTupletTree[],
   transposeIndex: number,
@@ -158,7 +158,7 @@ export interface SmoMeasureParams {
   clef: Clef,
   voices: SmoVoice[],
   activeVoice: number,
-  tempo: SmoTempoText,
+  tempo: SmoTempo,
   format: SmoMeasureFormat | null,
   modifiers: SmoMeasureModifierBase[],
   repeatSymbol: boolean,
@@ -218,7 +218,7 @@ export interface SmoMeasureParamsSer {
   /**
    * tempo at this point
    */
-  tempo: SmoTempoTextParamsSer
+  tempo: SmoTempoParamsSer
 
 }
 
@@ -244,8 +244,8 @@ function isSmoMeasureParamsSer(params: Partial<SmoMeasureParamsSer>):params is S
  * @category SmoObject
  */
 export class SmoMeasure implements SmoMeasureParams, TickMappable {
-  static get timeSignatureDefault(): TimeSignature {
-    return new TimeSignature(TimeSignature.defaults);
+  static get timeSignatureDefault(): SmoTimeSignature {
+    return new SmoTimeSignature(SmoTimeSignature.defaults);
   }
   static defaultDupleDuration: number = 4096;
   static defaultTripleDuration: number = 2048 * 3;
@@ -268,7 +268,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
     voices: [],
     format: new SmoMeasureFormat(SmoMeasureFormat.defaults),
     activeVoice: 0,
-    tempo: new SmoTempoText(SmoTempoText.defaults),
+    tempo: new SmoTempo(SmoTempo.defaults),
     repeatSymbol: false,
     repeatCount: 0  
   }
@@ -281,7 +281,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
   static get defaults(): SmoMeasureParams {
     const proto: any = JSON.parse(JSON.stringify(SmoMeasure._defaults));
     proto.format = new SmoMeasureFormat(SmoMeasureFormat.defaults);
-    proto.tempo = new SmoTempoText(SmoTempoText.defaults);
+    proto.tempo = new SmoTempo(SmoTempo.defaults);
     proto.modifiers.push(new SmoBarline({
       position: SmoBarline.positions.start,
       barline: SmoBarline.barlines.singleBar
@@ -294,11 +294,11 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
   }
   // @ignore
   static convertLegacyTimeSignature(ts: string) {
-    const rv = new TimeSignature(TimeSignature.defaults);
+    const rv = new SmoTimeSignature(SmoTimeSignature.defaults);
     rv.timeSignature = ts;
     return rv;
   }
-  timeSignature: TimeSignature = SmoMeasure.timeSignatureDefault;
+  timeSignature: SmoTimeSignature = SmoMeasure.timeSignatureDefault;
   /**
    * Overrides display of actual time signature, in the case of
    * pick-up notes where the actual and displayed durations are different
@@ -329,7 +329,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
    * the active voice in the editor, if there are multiple voices
    *  */
   activeVoice: number = 0;
-  tempo: SmoTempoText;
+  tempo: SmoTempo;
   beamGroups: ISmoBeamGroup[] = [];
   lines: number = 5;
   /**
@@ -351,7 +351,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
    * @param params
    */
   constructor(params: SmoMeasureParams) {
-    this.tempo = new SmoTempoText(SmoTempoText.defaults);
+    this.tempo = new SmoTempo(SmoTempo.defaults);
     this.svg = {
       staffWidth: 0,
       unjustifiedWidth: 0,
@@ -392,7 +392,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
     this.repeatSymbol = params.repeatSymbol;
     this.measureNumber = JSON.parse(JSON.stringify(params.measureNumber));
     if (params.tempo) {
-      this.tempo = new SmoTempoText(params.tempo);
+      this.tempo = new SmoTempo(params.tempo);
     }
     // Handle legacy time signature format
     if (params.timeSignature) {
@@ -400,7 +400,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
       if (typeof (tsAny) === 'string') {
         this.timeSignature = SmoMeasure.convertLegacyTimeSignature(tsAny);
       } else {
-        this.timeSignature = TimeSignature.createFromPartial(tsAny);
+        this.timeSignature = SmoTimeSignature.createFromPartial(tsAny);
       }
     }
     this.voices = params.voices ? params.voices : [];
@@ -454,7 +454,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
   // Return true if the time signatures are the same, for display purposes (e.g. if a time sig change
   // is required)
   */
-  static timeSigEqual(o1: TimeSignature, o2: TimeSignature) {
+  static timeSigEqual(o1: SmoTimeSignature, o2: SmoTimeSignature) {
     return o1.timeSignature === o2.timeSignature && o1.useSymbol === o2.useSymbol;
   }
   /**
@@ -568,7 +568,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
       } else if (modifier.ctor === 'SmoBarline' && (modifier as SmoBarline).position === SmoBarline.positions.end
         && (modifier as SmoBarline).barline === SmoBarline.barlines.singleBar) {
         ser = false;
-      } else if (modifier.ctor === 'SmoTempoText') {
+      } else if (modifier.ctor === 'SmoTempo') {
         // we don't save tempo text as a modifier anymore
         ser = false;
       } else if ((modifier as SmoRepeatSymbol).ctor === 'SmoRepeatSymbol' && (modifier as SmoRepeatSymbol).position === SmoRepeatSymbol.positions.start
@@ -639,9 +639,9 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
 
     // explode column-mapped
     if (jsonObj.tempo) {
-      params.tempo = SmoTempoText.deserialize(jsonObj.tempo);
+      params.tempo = SmoTempo.deserialize(jsonObj.tempo);
     } else {
-      params.tempo = new SmoTempoText(SmoTempoText.defaults);
+      params.tempo = new SmoTempo(SmoTempo.defaults);
     }
 
     // timeSignatureString is now part of timeSignature.  upconvert old scores
@@ -654,13 +654,14 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
       if (timeSignatureString.length) {
         jsonObj.timeSignature.displayString = timeSignatureString;  
       }
-      params.timeSignature = TimeSignature.deserialize(jsonObj.timeSignature);
+      jsonObj.timeSignature.ctor = 'SmoTimeSignature';
+      params.timeSignature = SmoTimeSignature.deserialize(jsonObj.timeSignature);
     } else {
-      const tparams = TimeSignature.defaults;
+      const tparams = SmoTimeSignature.defaults;
       if (timeSignatureString.length) {
         tparams.displayString = timeSignatureString;
       }
-      params.timeSignature = new TimeSignature(tparams);
+      params.timeSignature = new SmoTimeSignature(tparams);
     }
     params.keySignature = jsonObj.keySignature ?? 'C';
     params.voices = voices;
@@ -725,12 +726,12 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
     const measure = new SmoMeasure(params);
     // Handle migration for measure-mapped parameters
     measure.modifiers.forEach((mod) => {
-      if (mod.ctor === 'SmoTempoText') {
-        measure.tempo = (mod as SmoTempoText);
+      if (mod.ctor === 'SmoTempo') {
+        measure.tempo = (mod as SmoTempo);
       }
     });
     if (!measure.tempo) {
-      measure.tempo = new SmoTempoText(SmoTempoText.defaults);
+      measure.tempo = new SmoTempo(SmoTempo.defaults);
     }
 
 
@@ -747,8 +748,8 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
     // Ordinarily, the key/tempo/time is mapped to the stave, but since we are pasting measure-by
     // measure here, we want to preserve it.
     clonedMeasure.keySignature = measure.keySignature;
-    clonedMeasure.timeSignature = new TimeSignature(measure.timeSignature);
-    clonedMeasure.tempo = new SmoTempoText(measure.tempo);
+    clonedMeasure.timeSignature = new SmoTimeSignature(measure.timeSignature);
+    clonedMeasure.tempo = new SmoTempo(measure.tempo);
     return clonedMeasure;
   }
   hasNonRestNotes(): boolean {
@@ -834,7 +835,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
   static get emptyMeasureNoteType(): NoteType {
     return SmoMeasure._emptyMeasureNoteType;
   }
-  static timeSignatureNotes(timeSignature: TimeSignature, clef: Clef) {
+  static timeSignatureNotes(timeSignature: SmoTimeSignature, clef: Clef) {
     const pitch = SmoMeasure.defaultPitchForClef[clef];
     const maxTicks = SmoMusic.timeSignatureToTicks(timeSignature.timeSignature);
     const noteTick = 8192 / (timeSignature.beatDuration / 2);
@@ -869,7 +870,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
    * @returns 
    */
   static getDefaultNotes(params: SmoMeasureParams): SmoNote[] {
-    return SmoMeasure.timeSignatureNotes(new TimeSignature(params.timeSignature), params.clef);
+    return SmoMeasure.timeSignatureNotes(new SmoTimeSignature(params.timeSignature), params.clef);
   }
 
   /**
@@ -888,7 +889,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
     smoSerialize.serializedMerge(SmoMeasure.defaultAttributes, params, obj);
     // Don't copy column-formatting options to new measure in new column
     smoSerialize.serializedMerge(SmoMeasure.formattingOptions, SmoMeasure.defaults, obj);
-    obj.timeSignature = new TimeSignature(params.timeSignature);
+    obj.timeSignature = new SmoTimeSignature(params.timeSignature);
     // The measure expects to get concert KS in constructor and adjust for instrument.  So do the
     // opposite.
     obj.keySignature = SmoMusic.vexKeySigWithOffset(obj.keySignature, -1 * obj.transposeIndex);
@@ -1019,7 +1020,6 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
       }
     }
     const voices: SmoVoice[] = [];
-    const tuplets: SmoTuplet[] = [];
     for (var i = 0; i < this.voices.length; ++i) {
       const voice = this.voices[i];
       const newNotes: SmoNote[] = [];
@@ -1529,18 +1529,18 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
     return this.modifiers.filter((mm) => type === mm.attrs.type);
   }
 
-  setTempo(params: SmoTempoTextParams) {
-    this.tempo = new SmoTempoText(params);
+  setTempo(params: SmoTempoParams) {
+    this.tempo = new SmoTempo(params);
   }
   /**
-   * Set measure tempo to the default {@link SmoTempoText}
+   * Set measure tempo to the default {@link SmoTempo}
    */
   resetTempo() {
-    this.tempo = new SmoTempoText(SmoTempoText.defaults);
+    this.tempo = new SmoTempo(SmoTempo.defaults);
   }
   getTempo() {
     if (typeof (this.tempo) === 'undefined') {
-      this.tempo = new SmoTempoText(SmoTempoText.defaults);
+      this.tempo = new SmoTempo(SmoTempo.defaults);
     }
     return this.tempo;
   }

package/src/smo/data/measureModifiers.ts

@@ -668,10 +668,10 @@ export type SmoTempoBooleanAttribute = 'display';
 
 export type SmoTempoMode = 'duration' | 'text' | 'custom';
 /**
- * constructor parameters for {@link SmoTempoText}
+ * constructor parameters for {@link SmoTempo}
  * @category SmoObject
  */
-export interface SmoTempoTextParams {
+export interface SmoTempoParams {
   /**
    * text (e.g. Allegro) or bpm
    */
@@ -705,7 +705,7 @@ export interface SmoTempoTextParams {
  * serialized tempo parameters
  * @category serialization
  */
-export interface SmoTempoTextParamsSer extends SmoTempoTextParams {
+export interface SmoTempoParamsSer extends SmoTempoParams {
   ctor: string;
 }
 /**
@@ -719,7 +719,7 @@ export interface VexTempoTextParams {
  * Information about both playback tempo and how the tempo is notated.
  * @category SmoObject
  */
-export class SmoTempoText extends SmoMeasureModifierBase implements SmoTempoTextParams {
+export class SmoTempo extends SmoMeasureModifierBase implements SmoTempoParams {
   static get tempoModes(): Record<string, SmoTempoMode> {
     return {
       durationMode: 'duration',
@@ -751,12 +751,12 @@ export class SmoTempoText extends SmoMeasureModifierBase implements SmoTempoText
   /**
    * create defaults for tempo initialization
    */
-  static get defaults(): SmoTempoTextParams {
+  static get defaults(): SmoTempoParams {
     return JSON.parse(JSON.stringify({
-      tempoMode: SmoTempoText.tempoModes.durationMode,
+      tempoMode: SmoTempo.tempoModes.durationMode,
       bpm: 120,
       beatDuration: 4096,
-      tempoText: SmoTempoText.tempoTexts.allegro,
+      tempoText: SmoTempo.tempoTexts.allegro,
       yOffset: 0,
       display: false,
       customText: ''
@@ -765,7 +765,7 @@ export class SmoTempoText extends SmoMeasureModifierBase implements SmoTempoText
   static get attributes() {
     return ['tempoMode', 'bpm', 'display', 'beatDuration', 'tempoText', 'yOffset', 'customText'];
   }
-  tempoMode: SmoTempoMode = SmoTempoText.tempoModes.durationMode
+  tempoMode: SmoTempoMode = SmoTempo.tempoModes.durationMode
   bpm: number = 120;
   beatDuration: number = 4096;
   tempoText: string = 'Allegro';
@@ -784,14 +784,14 @@ export class SmoTempoText extends SmoMeasureModifierBase implements SmoTempoText
    * @param t2 
    * @returns 
    */
-  static eq(t1: SmoTempoText, t2: SmoTempoText) {
+  static eq(t1: SmoTempo, t2: SmoTempo) {
     if (t1.tempoMode !== t2.tempoMode) {
       return false;
     }
-    if (t1.tempoMode === SmoTempoText.tempoModes.durationMode) {
+    if (t1.tempoMode === SmoTempo.tempoModes.durationMode) {
       return t1.bpm === t2.bpm && t1.beatDuration === t2.beatDuration;
     }
-    if (t1.tempoMode === SmoTempoText.tempoModes.textMode) {
+    if (t1.tempoMode === SmoTempo.tempoModes.textMode) {
       return t1.tempoText === t2.tempoText;
     } else {
       return t1.bpm === t2.bpm && t1.beatDuration === t2.beatDuration &&
@@ -801,22 +801,22 @@ export class SmoTempoText extends SmoMeasureModifierBase implements SmoTempoText
 
   static get bpmFromText(): Record<string, number> {
     const rv: any = {};
-    rv[SmoTempoText.tempoTexts.larghissimo] = 24;
-    rv[SmoTempoText.tempoTexts.grave] = 40;
-    rv[SmoTempoText.tempoTexts.lento] = 45;
-    rv[SmoTempoText.tempoTexts.largo] = 40;
-    rv[SmoTempoText.tempoTexts.larghetto] = 60;
-    rv[SmoTempoText.tempoTexts.adagio] = 72;
-    rv[SmoTempoText.tempoTexts.adagietto] = 72;
-    rv[SmoTempoText.tempoTexts.andante_moderato] = 72;
-    rv[SmoTempoText.tempoTexts.andante] = 84;
-    rv[SmoTempoText.tempoTexts.andantino] = 92;
-    rv[SmoTempoText.tempoTexts.moderator] = 96;
-    rv[SmoTempoText.tempoTexts.allegretto] = 96;
-    rv[SmoTempoText.tempoTexts.allegro] = 120;
-    rv[SmoTempoText.tempoTexts.vivace] = 144;
-    rv[SmoTempoText.tempoTexts.presto] = 168;
-    rv[SmoTempoText.tempoTexts.prestissimo] = 240;
+    rv[SmoTempo.tempoTexts.larghissimo] = 24;
+    rv[SmoTempo.tempoTexts.grave] = 40;
+    rv[SmoTempo.tempoTexts.lento] = 45;
+    rv[SmoTempo.tempoTexts.largo] = 40;
+    rv[SmoTempo.tempoTexts.larghetto] = 60;
+    rv[SmoTempo.tempoTexts.adagio] = 72;
+    rv[SmoTempo.tempoTexts.adagietto] = 72;
+    rv[SmoTempo.tempoTexts.andante_moderato] = 72;
+    rv[SmoTempo.tempoTexts.andante] = 84;
+    rv[SmoTempo.tempoTexts.andantino] = 92;
+    rv[SmoTempo.tempoTexts.moderator] = 96;
+    rv[SmoTempo.tempoTexts.allegretto] = 96;
+    rv[SmoTempo.tempoTexts.allegro] = 120;
+    rv[SmoTempo.tempoTexts.vivace] = 144;
+    rv[SmoTempo.tempoTexts.presto] = 168;
+    rv[SmoTempo.tempoTexts.prestissimo] = 240;
 
     return rv as Record<string, number>;
   }
@@ -832,29 +832,32 @@ export class SmoTempoText extends SmoMeasureModifierBase implements SmoTempoText
     return rv;
   }
   toVexTempo(): VexTempoTextParams {
-    if (this.tempoMode === SmoTempoText.tempoModes.durationMode ||
-      this.tempoMode === SmoTempoText.tempoModes.customMode) {
+    if (this.tempoMode === SmoTempo.tempoModes.durationMode ||
+      this.tempoMode === SmoTempo.tempoModes.customMode) {
       return this._toVexDurationTempo();
     }
     return this._toVexTextTempo();
   }
-  serialize(): SmoTempoTextParamsSer {
-    var params: Partial<SmoTempoTextParamsSer> = {};
-    smoSerialize.serializedMergeNonDefault(SmoTempoText.defaults, SmoTempoText.attributes, this, params);
-    params.ctor = 'SmoTempoText';
-    return params as SmoTempoTextParamsSer;
+  serialize(): SmoTempoParamsSer {
+    var params: Partial<SmoTempoParamsSer> = {};
+    smoSerialize.serializedMergeNonDefault(SmoTempo.defaults, SmoTempo.attributes, this, params);
+    params.ctor = 'SmoTempo';
+    return params as SmoTempoParamsSer;
   }
-  constructor(parameters: SmoTempoTextParams | null) {
-    super('SmoTempoText');
+  constructor(parameters: SmoTempoParams | null) {
+    super('SmoTempo');
     let pobj: any = parameters;
     if (typeof (pobj) === 'undefined' || pobj === null) {
       pobj = {};
     }
-    smoSerialize.serializedMerge(SmoTempoText.attributes, SmoTempoText.defaults, this);
-    smoSerialize.serializedMerge(SmoTempoText.attributes, pobj, this);
+    smoSerialize.serializedMerge(SmoTempo.attributes, SmoTempo.defaults, this);
+    smoSerialize.serializedMerge(SmoTempo.attributes, pobj, this);
   }
 }
-
+export interface TimeSignatureTime {
+  actualBeats: number,
+  beatDuration: number
+}
 /**
  * Constructor parameters for a time signature
  * @category SmoObject
@@ -863,14 +866,7 @@ export interface TimeSignatureParameters  {
   /**
    * numerator
    */
-  actualBeats: number,
-  /**
-   * denominator, always power of 2
-   */
-  beatDuration: number,
-  /**
-   * indicates cut time/common time
-   */
+  times: TimeSignatureTime[],
   useSymbol: boolean,
   /**
    * display, else just affects measure lengths.
@@ -879,7 +875,7 @@ export interface TimeSignatureParameters  {
   /**
    * for pickups, display the non-pickup value
    */
-  displayString: string
+  displayString: string,
 }
 
 /**
@@ -897,54 +893,93 @@ export interface TimeSignatureParametersSer extends TimeSignatureParameters {
  * about the display of the time signature.
  * @category SmoObject
  */
-export class TimeSignature extends SmoMeasureModifierBase {
+export class SmoTimeSignature extends SmoMeasureModifierBase {
   static get defaults(): TimeSignatureParameters {
     return {
-      actualBeats: 4,
-      beatDuration: 4,
+      times: [{ actualBeats: 4, beatDuration: 4 }],
       useSymbol: false,
       display: true,
-      displayString: ''
+      displayString: '',
     };
   }
-  static equal(ts1: TimeSignature, ts2: TimeSignature): boolean {
-    return (ts1.actualBeats === ts2.actualBeats && ts1.beatDuration === ts2.beatDuration);
+  ticksFromTimeSignature() {
+    let max = 0;
+    for (let i = 0; i < this.times.length; i++) {
+      const bt = 4096 * (4/this.times[i].beatDuration);
+      max = Math.max(max, bt * this.times[i].actualBeats);
+    }
+    return max;
+  }
+  static equal(ts1: SmoTimeSignature, ts2: SmoTimeSignature): boolean {
+    // legacy hack, this can be called before the constructor is called, since these classes used to 
+    // just be strings.  So create the objects.
+    const ts1obj = SmoTimeSignature.createFromPartial(ts1);
+    const ts2obj = SmoTimeSignature.createFromPartial(ts2);
+    if (ts1obj.times.length !== ts2obj.times.length) {
+      return false;
+    }
+    for (let i = 0; i < ts1obj.times.length; i++) {
+      if (ts1obj.times[i].actualBeats !== ts2obj.times[i].actualBeats ||
+        ts1obj.times[i].beatDuration !== ts2obj.times[i].beatDuration) {
+        return false;
+      }
+    }
+    return true;
   }
   static createFromPartial(value: Partial<TimeSignatureParameters>) {
-    const params = TimeSignature.defaults;
-    smoSerialize.serializedMerge(TimeSignature.parameters, value, params);
-    return new TimeSignature(params);
+    const params = SmoTimeSignature.defaults;
+    smoSerialize.serializedMerge(SmoTimeSignature.parameters, value, params);
+    return new SmoTimeSignature(params);
   }
   // timeSignature: string = '4/4';
-  actualBeats: number = 4;
-  beatDuration: number = 4;
+  times: TimeSignatureTime[] = [{ actualBeats: 4, beatDuration: 4 }];
   useSymbol: boolean = false;
   display: boolean = true;
   displayString: string = '';
+  index: number = 0;
+  get beatDuration() {
+    return this.times[this.index].beatDuration;
+  }
+  get actualBeats() {    return this.times[this.index].actualBeats;
+  }
   get timeSignature() {
-    return this.actualBeats.toString() + '/' + this.beatDuration.toString();
+    let str: string[] = [];
+    this.times.forEach((time) => {
+      str.push(`${time.actualBeats}/${time.beatDuration}+`);
+    });
+    return str.join('+');
   }
   static get parameters() {
-    return ['actualBeats', 'beatDuration', 'useSymbol', 'display', 'displayString'];
+    return ['times', 'useSymbol', 'display', 'displayString'];
   }
   static get boolParameters() {
     return [];
   }
   set timeSignature(value: string) {
-    const ar = value.split('/');
-    this.actualBeats = parseInt(ar[0], 10);
-    this.beatDuration = parseInt(ar[1], 10);
+    const timeStrings = value.split('+');
+    this.times = [];
+    for (let i = 0; i < timeStrings.length; i++) {
+      const ar = timeStrings[i].split('/');
+      if (ar.length !== 2) {
+        throw new Error('invalid time signature string');
+      }
+      const actualBeats = parseInt(ar[0], 10);
+      const beatDuration = parseInt(ar[1], 10);
+      this.times.push({ actualBeats, beatDuration });
+    }
   }
   serialize(): TimeSignatureParametersSer {
     const rv: Partial<TimeSignatureParametersSer> = {};
-    smoSerialize.serializedMergeNonDefault(TimeSignature.defaults, TimeSignature.parameters, this, rv);
-    rv.ctor = 'TimeSignature';
+    smoSerialize.serializedMergeNonDefault(SmoTimeSignature.defaults, SmoTimeSignature.parameters, this, rv);
+    rv.ctor = 'SmoTimeSignature';
     return rv as TimeSignatureParametersSer;
   }
   constructor(params: TimeSignatureParameters) {
-    super('TimeSignature');
-    this.actualBeats = params.actualBeats;
-    this.beatDuration = params.beatDuration;
+    super('SmoTimeSignature');
+    if (!params.times || !params.times.length) {
+      params.times = SmoTimeSignature.defaults.times;
+    }
+    this.times = JSON.parse(JSON.stringify(params.times));
     this.useSymbol = params.useSymbol;
     this.display = params.display;
     this.displayString = params.displayString;
@@ -957,6 +992,6 @@ export const measureModifierDynamicCtorInit = () => {
   SmoDynamicCtor['SmoVolta'] = (params: SmoVoltaParams) => new SmoVolta(params);
   SmoDynamicCtor['SmoMeasureText'] = (params: SmoMeasureTextParams) => new SmoMeasureText(params);
   SmoDynamicCtor['SmoRehearsalMark'] = (params: SmoRehearsalMarkParams) => new SmoRehearsalMark(params);
-  SmoDynamicCtor['SmoTempoText'] = (params: SmoTempoTextParams) => new SmoTempoText(params);
-  SmoDynamicCtor['TimeSignature'] = (params: TimeSignatureParameters) => new TimeSignature(params);
+  SmoDynamicCtor['SmoTempo'] = (params: SmoTempoParams) => new SmoTempo(params);
+  SmoDynamicCtor['SmoTimeSignature'] = (params: TimeSignatureParameters) => new SmoTimeSignature(params);
 }

package/src/smo/data/note.ts

@@ -312,7 +312,10 @@ export class SmoNote implements Transposable {
     if ((params as any).tuplet) {
       this.tupletId = (params as any).tuplet.id;
     }
-
+    // For imported notes, stem ticks is only different for tuplets
+    if (!this.isTuplet) {
+      this.stemTicks = this.tickCount;
+    }
     this.attrs = {
       id: getId().toString(),
       type: 'SmoNote'