comparison src/app/app.component.ts @ 350:524f5cd75737

Split AnalysisItem out into individual types for root audio items and features. This is messy as is, these need revising and should perhaps be actual concrete types with methods.

 import {FeatureExtractionService} from './services/feature-extraction/feature-extraction.service';
 import {ExtractorOutputInfo} from './feature-extraction-menu/feature-extraction-menu.component';
 import {DomSanitizer} from '@angular/platform-browser';
 import {MdIconRegistry} from '@angular/material';
 import {Subscription} from 'rxjs/Subscription';
-import {AnalysisItem} from './analysis-item/analysis-item.component';
+import {
+  AnalysisItem, isRootAudioItem,
+  Item, PendingAnalysisItem, PendingRootAudioItem, RootAudioItem
+} from './analysis-item/analysis-item.component';
 import {OnSeekHandler} from './playhead/PlayHeadHelpers';
 
 class PersistentStack<T> {
   private stack: T[];
   private history: T[][];

 export class AppComponent implements OnDestroy {
   audioBuffer: AudioBuffer; // TODO consider revising
   canExtract: boolean;
   private onAudioDataSubscription: Subscription;
   private onProgressUpdated: Subscription;
-  private analyses: PersistentStack<AnalysisItem>; // TODO some immutable state container describing entire session
+  private analyses: PersistentStack<Item>; // TODO some immutable state container describing entire session
   private nRecordings: number; // TODO user control for naming a recording
   private countingId: number; // TODO improve uniquely identifying items
-  private rootAudioUri: string;
+  private rootAudioItem: RootAudioItem;
   private onSeek: OnSeekHandler;
 
   constructor(private audioService: AudioPlayerService,
               private featureService: FeatureExtractionService,
               private iconRegistry: MdIconRegistry,

         if (wasError) {
           this.analyses.shift();
           this.canExtract = false;
         } else {
           this.audioBuffer = (resource as AudioResource).samples;
+          this.rootAudioItem.audioData = this.audioBuffer;
           if (this.audioBuffer) {
             this.canExtract = true;
             const currentRootIndex = this.analyses.findIndex(val => {
-              return val.rootAudioUri === this.rootAudioUri && val.isRoot;
+              return isRootAudioItem(val) && val.uri === this.rootAudioItem.uri;
             });
             if (currentRootIndex !== -1) {
               this.analyses.set(
                 currentRootIndex,
                 Object.assign(

   }
 
   onFileOpened(file: File | Blob) {
     this.canExtract = false;
     const url = this.audioService.loadAudio(file);
-    this.rootAudioUri = url; // TODO this isn't going to work to id previously loaded files
-
     // TODO is it safe to assume it is a recording?
     const title = (file instanceof File) ?
       (file as File).name : `Recording ${this.nRecordings++}`;
 
     if (this.analyses.filter(item => item.title === title).length > 0) {

       // in a suitable way in the actual event of a duplicate file
       console.warn('There is already a notebook based on this audio file.');
       return;
     }
 
-    // TODO re-ordering of items for display
-    // , one alternative is a Angular Pipe / Filter for use in the Template
-    this.analyses.unshift({
-      rootAudioUri: url,
+    const pending = {
+      uri: url,
       hasSharedTimeline: true,
-      extractorKey: 'not:real',
-      isRoot: true,
       title: title,
       description: new Date().toLocaleString(),
       id: `${++this.countingId}`
-    });
+    } as PendingRootAudioItem;
+    this.rootAudioItem = pending as RootAudioItem; // TODO this is silly
+
+    // TODO re-ordering of items for display
+    // , one alternative is a Angular Pipe / Filter for use in the Template
+    this.analyses.unshift(pending);
   }
 
   extractFeatures(outputInfo: ExtractorOutputInfo): void {
     if (!this.canExtract || !outputInfo) {
       return;
     }
 
     this.canExtract = false;
 
-    this.analyses.unshift({
-      rootAudioUri: this.rootAudioUri,
+    const placeholderCard: PendingAnalysisItem = {
+      parent: this.rootAudioItem,
       hasSharedTimeline: true,
       extractorKey: outputInfo.combinedKey,
-      isRoot: false,
       title: outputInfo.name,
       description: outputInfo.outputId,
       id: `${++this.countingId}`,
       progress: 0
-    });
+    };
+    this.analyses.unshift(placeholderCard);
 
     this.featureService.extract(`${this.countingId}`, {
       audioData: [...Array(this.audioBuffer.numberOfChannels).keys()]
         .map(i => this.audioBuffer.getChannelData(i)),
       audioFormat: {