smoosic 1.0.37 → 1.0.39

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'

package/src/smo/data/score.ts

@@ -9,7 +9,7 @@ import { Clef, SvgDimensions } from './common';
 import { SmoMeasure, SmoMeasureParams, ColumnMappedParams, SmoMeasureParamsSer } from './measure';
 import { SmoNoteModifierBase } from './noteModifiers';
 import {
-  SmoTempoText, SmoMeasureFormat, SmoMeasureModifierBase, TimeSignature, TimeSignatureParameters,
+  SmoTempo, SmoMeasureFormat, SmoMeasureModifierBase, SmoTimeSignature, TimeSignatureParameters,
   SmoMeasureFormatParamsSer
 } from './measureModifiers';
 import { StaffModifierBase, SmoInstrument } from './staffModifiers';
@@ -153,8 +153,8 @@ export function isEmptyTextBlock(params: Partial<SmoTextGroupParamsSer>): params
  */
 export interface ColumnParamsMapType {
   keySignature: Record<number, string>,
-  tempo: Record<number, SmoTempoText>,
-  timeSignature: Record<number, TimeSignature>,
+  tempo: Record<number, SmoTempo>,
+  timeSignature: Record<number, SmoTimeSignature>,
   renumberingMap: Record<number, number>
 }
 
@@ -351,8 +351,8 @@ export class SmoScore {
    */
   serializeColumnMapped(func: (measure: SmoMeasure) => ColumnMappedParams) {
     const keySignature: Record<number, string> = {};
-    const tempo: Record<number, SmoTempoText> = {};
-    const timeSignature: Record<number, TimeSignature> = {};
+    const tempo: Record<number, SmoTempo> = {};
+    const timeSignature: Record<number, SmoTimeSignature> = {};
     const renumberingMap: Record<number, number> = {};
     let previous: ColumnMappedParams | null = null;
     this.staves[0].measures.forEach((measure) => {
@@ -381,11 +381,11 @@ export class SmoScore {
           previous!.keySignature = current.keySignature;
           keySignature[ix] = current.keySignature;
         }
-        if (!(TimeSignature.equal(current.timeSignature, previous!.timeSignature))) {
+        if (!(SmoTimeSignature.equal(current.timeSignature, previous!.timeSignature))) {
           previous!.timeSignature = current.timeSignature;
           timeSignature[ix] = current.timeSignature;
         }
-        if (!(SmoTempoText.eq(current.tempo, previous!.tempo))) {
+        if (!(SmoTempo.eq(current.tempo, previous!.tempo))) {
           previous!.tempo = current.tempo;
           tempo[ix] = current.tempo;
         }
@@ -393,7 +393,45 @@ export class SmoScore {
     });
     return { keySignature, tempo, timeSignature, renumberingMap };
   }
-
+  static fixLegacyColumnMappedCtor(scoreObj: any){
+    if (!scoreObj.columnAttributeMap) {
+      return;
+    }
+    if (!scoreObj.columnAttributeMap.tempo) {
+      return;
+    }
+    const tempoKeys = Object.keys(scoreObj.columnAttributeMap.tempo);
+    tempoKeys.forEach((key) => {
+      const t = scoreObj.columnAttributeMap.tempo[key];
+      t.ctor = 'SmoTempo';
+    });
+    const tsKeys = Object.keys(scoreObj.columnAttributeMap.timeSignature);
+    tsKeys.forEach((key) => {
+      const val = scoreObj.columnAttributeMap.timeSignature[key];
+      // Very legacy time signature format was just a string like 4/4, 3/8 etc.
+      if (typeof(val) === 'string') {
+        const nums = val.split('/');
+        const num = parseInt(nums[0], 10);
+        const denom = parseInt(nums[1], 10);
+        scoreObj.columnAttributeMap.timeSignature[key] = { times: [{ actualBeats: num, beatDuration: denom }], ctor: 'SmoTimeSignature' };
+      } else {
+        const ts =  val;      
+        ts.ctor = 'SmoTimeSignature';
+        // map legacy time signature format to compound time signature format
+        let beatDuration = 4;
+        if (ts.beatDuration && !isNaN(ts.beatDuration)) {
+          beatDuration = ts.beatDuration;
+        }
+        if (ts.actualBeats && !isNaN(ts.actualBeats)) {        
+          ts.times = [{ actualBeats: ts.actualBeats, beatDuration }];
+        }
+        // Default will have nothing serialized
+        if (!ts.times) {
+          ts.times = [{ actualBeats: 4, beatDuration: 4 }];
+        }
+      }
+    });
+  }
   /**
    * Column-mapped attributes stay the same in each measure until
    * changed, like key-signatures.  We don't store each measure value to
@@ -407,6 +445,7 @@ export class SmoScore {
     if (!scoreObj.columnAttributeMap) {
       return;
     }
+    SmoScore.fixLegacyColumnMappedCtor(scoreObj);
     const attrs = Object.keys(scoreObj.columnAttributeMap);
     scoreObj.staves.forEach((staff: any) => {
       const attrIxMap: any = {};
@@ -429,12 +468,12 @@ export class SmoScore {
           }
           // legacy timeSignature format was just a string 2/4, 3/8 etc.
           if (attr === 'timeSignature') {
-            const ts = new TimeSignature(TimeSignature.defaults);
+            const ts = new SmoTimeSignature(SmoTimeSignature.defaults);
             if (typeof (curValue) === 'string') {
               ts.timeSignature = curValue;
               measure[attr] = ts;
             } else {
-              measure[attr] = TimeSignature.createFromPartial(curValue);
+              measure[attr] = SmoTimeSignature.createFromPartial(curValue);
             }
           } else {
             measure[attr] = curValue;
@@ -878,7 +917,7 @@ export class SmoScore {
     if (measureIndex > 0) {
       const measure = this.staves[0].measures[measureIndex];
       const prev = this.staves[0].measures[measureIndex - 1];
-      if (!start && !TimeSignature.equal(measure.timeSignature, prev.timeSignature)) {
+      if (!start && !SmoTimeSignature.equal(measure.timeSignature, prev.timeSignature)) {
         return false;
       }
       if (!start && measure.keySignature !== prev.keySignature) {

package/src/smo/data/systemStaff.ts

@@ -9,7 +9,7 @@ import { SmoObjectParams, SmoAttrs, MeasureNumber, getId,
    Pitch, ElementLike } from './common';
 import { SmoMusic } from './music';
 import { SmoMeasure, SmoMeasureParamsSer } from './measure';
-import { SmoMeasureFormat, SmoRehearsalMark, SmoRehearsalMarkParams, SmoTempoTextParams, SmoVolta, SmoBarline } from './measureModifiers';
+import { SmoMeasureFormat, SmoRehearsalMark, SmoRehearsalMarkParams, SmoTempoParams, SmoVolta, SmoBarline } from './measureModifiers';
 import { SmoInstrumentParams, StaffModifierBase, SmoInstrument, SmoInstrumentMeasure, SmoInstrumentStringParams, SmoInstrumentNumParams, 
   SmoTie, SmoStaffTextBracket, SmoStaffTextBracketParamsSer, 
   StaffModifierBaseSer, SmoTabStave, SmoStaffHairpin, TieLine,
@@ -851,7 +851,7 @@ export class SmoSystemStaff implements SmoObjectParams {
     this.measures[index].resetTempo();
   }
 
-  addTempo(tempo: SmoTempoTextParams, index: number) {
+  addTempo(tempo: SmoTempoParams, index: number) {
     this.measures[index].setTempo(tempo);
   }
 

package/src/smo/midi/midiToSmo.ts

@@ -7,7 +7,7 @@
 import { SmoToMidi } from "./smoToMidi";
 import { Clef, Pitch } from "../data/common";
 import { SmoMeasure } from "../data/measure";
-import { SmoTempoText, TimeSignature } from "../data/measureModifiers";
+import { SmoTempo, SmoTimeSignature } from "../data/measureModifiers";
 import { SmoMusic } from "../data/music";
 import { SmoNote } from "../data/note";
 import { SmoScore } from "../data/score";
@@ -18,7 +18,7 @@ import {SmoTuplet, SmoTupletTree} from "../data/tuplet";
 import { SmoOperation } from "../xform/operations";
 
 export type MidiEventType = 'text' | 'copyrightNotice' | 'trackName' | 'instrumentName' | 'lyrics' | 'marker' |
-  'cuePoint' | 'channelPrefix' | 'portPrefix' | 'endOfTrack' | 'setTempo' | 'smpteOffset' | 'timeSignature' | 'keySignature' |
+  'cuePoint' | 'channelPrefix' | 'portPrefix' | 'endOfTrack' | 'setTempo' | 'smpteOffset' | 'SmoTimeSignature' | 'keySignature' |
   'sequencerSpecific' | 'unknownMeta' |
   'noteOff' | 'noteOn' | 'noteAftertouch' | 'controller' | 'programChange' | 'channelAftertouch' | 'pitchBend';
 
@@ -46,8 +46,8 @@ export interface MidiTrackEvent {
  */
 export interface RunningMetadata {
   keySignature: string,
-  timeSignature: TimeSignature,
-  tempo: SmoTempoText
+  timeSignature: SmoTimeSignature,
+  tempo: SmoTempo
 }
 /**
  * @category serialization
@@ -75,8 +75,8 @@ export interface EventSmoData {
   tupletInfo: MidiTupletInfo | null,
   isRest: boolean,
   isTied: boolean,
-  timeSignature: TimeSignature,
-  tempo: SmoTempoText,
+  timeSignature: SmoTimeSignature,
+  tempo: SmoTempo,
   keySignature: string,
   measure: number,
   tick: number
@@ -100,8 +100,8 @@ export function getValueForTick<T>(arg: Record<number, T>, tick: number) {
  * @category serialization
  */
 export class MidiToSmo {
-  timeSignatureMap: Record<number, TimeSignature> = {};
-  tempoMap: Record<number, SmoTempoText> = {};
+  SmoTimeSignatureMap: Record<number, SmoTimeSignature> = {};
+  tempoMap: Record<number, SmoTempo> = {};
   keySignatureMap: Record<number, string> = {};
   tieMap: Record<number, number[]> = {};
   timeDivision: number = 480;
@@ -153,8 +153,8 @@ export class MidiToSmo {
   constructor(midi: any, quantizeDuration: number) {
     this.midi = midi;
     // console.log(JSON.stringify(midi, null, ''));
-    this.timeSignatureMap[0] = new TimeSignature(TimeSignature.defaults);
-    this.tempoMap[0] = new SmoTempoText(SmoTempoText.defaults);
+    this.SmoTimeSignatureMap[0] = new SmoTimeSignature(SmoTimeSignature.defaults);
+    this.tempoMap[0] = new SmoTempo(SmoTempo.defaults);
     this.keySignatureMap[0] = 'c';
     this.timeDivision = midi.header.ticksPerBeat;
     this.quantizeTicks = quantizeDuration;
@@ -175,11 +175,11 @@ export class MidiToSmo {
    * @param ticks 
    * @returns 
    */
-  getTimeSignature(ticks: number): TimeSignature {
-    if (this.timeSignatureMap[ticks]) {
-      return this.timeSignatureMap[ticks];
+  getSmoTimeSignature(ticks: number): SmoTimeSignature {
+    if (this.SmoTimeSignatureMap[ticks]) {
+      return this.SmoTimeSignatureMap[ticks];
     }
-    return getValueForTick(this.timeSignatureMap, ticks);
+    return getValueForTick(this.SmoTimeSignatureMap, ticks);
   }
   /**
    * @internal
@@ -199,7 +199,7 @@ export class MidiToSmo {
    */
   getMetadata(ticks: number) {
     return { tempo: this.getTempo(ticks), 
-      timeSignature: this.getTimeSignature(ticks), keySignature: this.getKeySignature(ticks).toLowerCase() };
+      timeSignature: this.getSmoTimeSignature(ticks), keySignature: this.getKeySignature(ticks).toLowerCase() };
   }
   /**
    * We process 3 types of metadata at present:  time signature, tempo and keysignature.
@@ -209,22 +209,21 @@ export class MidiToSmo {
   handleMetadata(trackEvent: MidiTrackEvent, ticks: number) {
     if (trackEvent.meta) {
       const mtype = trackEvent.type;
-      if (mtype === 'timeSignature') {
+      if (mtype === 'SmoTimeSignature') {
         /**
          * whenever we get a time signature event, recompute ticks per measure
          */
         const numerator = trackEvent.numerator!;
         const denominator = trackEvent.denominator!;
-        const tsDef = TimeSignature.defaults;
-        tsDef.actualBeats = numerator;
-        tsDef.beatDuration = denominator;
-        const ts = new TimeSignature(tsDef);
-        this.timeSignatureMap[ticks] = ts;
+        const tsDef = SmoTimeSignature.defaults;
+        tsDef.times.push({actualBeats: numerator, beatDuration:denominator});
+        const ts = new SmoTimeSignature(tsDef);
+        this.SmoTimeSignatureMap[ticks] = ts;
       } else if (mtype === 'setTempo') {
         const bpm = 60 / (trackEvent.microsecondsPerBeat! / 1000000);
-        const tempoDef = SmoTempoText.defaults;
+        const tempoDef = SmoTempo.defaults;
         tempoDef.bpm = bpm;
-        this.tempoMap[ticks] = new SmoTempoText(tempoDef);
+        this.tempoMap[ticks] = new SmoTempo(tempoDef);
       } else if (mtype === 'keySignature') {
         const mdata = trackEvent.key!;
         if (mdata === 0) {
@@ -255,8 +254,8 @@ export class MidiToSmo {
    */
   createNewEvent(metadata: RunningMetadata): EventSmoData {
     return {
-      pitches: [], durationTicks: 0, tupletInfo: null, isRest: false, timeSignature: new TimeSignature(metadata.timeSignature),
-      tempo: new SmoTempoText(metadata.tempo), keySignature: metadata.keySignature, measure: 0, tick: 0, isTied: false
+      pitches: [], durationTicks: 0, tupletInfo: null, isRest: false, timeSignature: new SmoTimeSignature(metadata.timeSignature),
+      tempo: new SmoTempo(metadata.tempo), keySignature: metadata.keySignature, measure: 0, tick: 0, isTied: false
     };
   }
   /**
@@ -264,8 +263,8 @@ export class MidiToSmo {
    */
   static copyEvent(o: EventSmoData): EventSmoData {
     const pitches = JSON.parse(JSON.stringify(o.pitches));
-    const timeSignature = new TimeSignature(o.timeSignature);
-    const tempo = new SmoTempoText(o.tempo);
+    const timeSignature = new SmoTimeSignature(o.timeSignature);
+    const tempo = new SmoTempo(o.tempo);
     return ({
       pitches, durationTicks: o.durationTicks, tupletInfo: o.tupletInfo, isRest: o.isRest, timeSignature, tempo, keySignature: o.keySignature,
       measure: o.measure, tick: o.tick, isTied: o.isTied
@@ -298,8 +297,8 @@ export class MidiToSmo {
       if (measure === null || ev.measure > measureIndex) {
         const measureDefs = SmoMeasure.defaults;
         measureDefs.keySignature = ev.keySignature;
-        measureDefs.timeSignature = new TimeSignature(ev.timeSignature);
-        measureDefs.tempo = new SmoTempoText(ev.tempo);
+        measureDefs.timeSignature = new SmoTimeSignature(ev.timeSignature);
+        measureDefs.tempo = new SmoTempo(ev.tempo);
         measure = new SmoMeasure(measureDefs);
         measure.voices.push({ notes: [] });
         measureIndex = ev.measure;

package/src/smo/midi/smoToMidi.ts

@@ -5,7 +5,7 @@
  * @module /smo/midi/smoToMidi
  */
 import { SmoMusic } from '../data/music';
-import { TimeSignature, SmoTempoText } from '../data/measureModifiers';
+import { SmoTimeSignature, SmoTempo } from '../data/measureModifiers';
 import { ScoreRoadMapBuilder } from '../xform/roadmap';
 import { SmoScore } from '../data/score';
 import { PopulateAudioData } from '../xform/updateAudio';
@@ -67,8 +67,8 @@ import Writer from 'midi-writer-js';
 export interface MidiTrackHash {
   track: any,
   lastMeasure: number,
-  timeSignature?: TimeSignature,
-  tempo?: SmoTempoText,
+  timeSignature?: SmoTimeSignature,
+  tempo?: SmoTempo,
   keySignature?: string
 }
 function stavesToSkip(score: SmoScore): number[] {