speechrecorderng 2.21.4 → 2.22.0

package/esm2020/lib/net/uploader.mjs

@@ -0,0 +1,246 @@
+import { timeout } from 'rxjs/operators';
+// state of an upload
+export var UploadStatus;
+(function (UploadStatus) {
+    UploadStatus[UploadStatus["IDLE"] = 1] = "IDLE";
+    UploadStatus[UploadStatus["UPLOADING"] = 2] = "UPLOADING";
+    UploadStatus[UploadStatus["ABORT"] = 3] = "ABORT";
+    UploadStatus[UploadStatus["DONE"] = 0] = "DONE";
+    UploadStatus[UploadStatus["ERR"] = -1] = "ERR";
+})(UploadStatus || (UploadStatus = {}));
+// state of the uploader
+// TRY_UPLOADING is uploading state after an error (for example if disconnected from server)
+export var UploaderStatus;
+(function (UploaderStatus) {
+    UploaderStatus[UploaderStatus["DONE"] = 0] = "DONE";
+    UploaderStatus[UploaderStatus["UPLOADING"] = 1] = "UPLOADING";
+    UploaderStatus[UploaderStatus["TRY_UPLOADING"] = 2] = "TRY_UPLOADING";
+    UploaderStatus[UploaderStatus["NEXT"] = 3] = "NEXT";
+    UploaderStatus[UploaderStatus["ERR"] = -1] = "ERR";
+})(UploaderStatus || (UploaderStatus = {}));
+export class UploaderStatusChangeEvent {
+    constructor(sizeQueued, sizeDone, status) {
+        this._sizeQueued = sizeQueued;
+        this._sizeDone = sizeDone;
+        this._status = status;
+    }
+    get sizeQueued() {
+        return this._sizeQueued;
+    }
+    get sizeDone() {
+        return this._sizeDone;
+    }
+    get status() {
+        return this._status;
+    }
+    uploadDone() {
+        return (this._sizeDone >= this._sizeQueued);
+    }
+    percentDone() {
+        if (this._sizeQueued == 0) {
+            // no data queued, we are "done"
+            return 100;
+        }
+        let percent = Math.floor(this._sizeDone * 100 / this._sizeQueued);
+        //console.log("Upload status: queued: "+this._sizeQueued+", done: "+this._sizeDone+", "+percent+"%")
+        return percent;
+    }
+}
+export class Upload {
+    constructor(blob, url) {
+        this.toString = () => {
+            let s = `Upload: Status: ${this.status}, URL: ${this._url}`;
+            if (this._data instanceof Blob) {
+                s = s + `, Size: ${this._data.size}`;
+            }
+            else if (this._data instanceof FormData) {
+                // TODO (iterate through parts ??)
+            }
+            return s;
+        };
+        this._data = blob;
+        this._url = url;
+        this.status = UploadStatus.IDLE;
+    }
+    get url() {
+        return this._url;
+    }
+    get data() {
+        return this._data;
+    }
+}
+export class Uploader {
+    constructor(http, withCredentials = false) {
+        this.http = http;
+        this.withCredentials = withCredentials;
+        this.POST_MIN_TIMEOUT = 120000; // 2min plus ...
+        this.POST_TIMEOUT_PER_KB = 1000; // ... 1s per kB
+        this.RETRY_DELAY = 30000; // retry every 30s
+        this.DEBUG_DELAY = 0;
+        //DEBUG_DELAY:number=0;
+        this.status = UploaderStatus.DONE;
+        this.listener = null;
+        this._sizeQueued = 0;
+        this._sizeDone = 0;
+        this.retryTimerRunning = false;
+        this.retryTimerId = null;
+        this.te = new TextEncoder();
+        this.que = new Array();
+    }
+    dataSize(dt) {
+        let si = 0;
+        if (dt instanceof Blob) {
+            si = dt.size;
+        }
+        else if (dt instanceof FormData) {
+            dt.forEach((v, k) => {
+                if (v instanceof File) {
+                    si += v.size;
+                }
+                else if (typeof v === 'string') {
+                    // encode to UT-f8 to get upload size
+                    si += this.te.encode().length;
+                }
+            });
+        }
+        return si;
+    }
+    uploadDone(ul) {
+        ul.status = UploadStatus.DONE;
+        // remove upload from queue
+        for (let i = 0; i < this.que.length; i++) {
+            if (this.que[i] === ul) {
+                // found, remove
+                this.que.splice(i, 1);
+                let ulSize = this.dataSize(ul.data);
+                this._sizeDone += ulSize;
+                break;
+            }
+        }
+        // set to done for now...
+        this.status = UploaderStatus.NEXT;
+        // continue
+        this.process();
+    }
+    startUpload(ul) {
+        ul.status = UploadStatus.UPLOADING;
+        if (UploaderStatus.ERR === this.status) {
+            this.status = UploaderStatus.TRY_UPLOADING;
+        }
+        else {
+            this.status = UploaderStatus.UPLOADING;
+        }
+        let dSize = this.dataSize(ul.data);
+        let timeoutForDataSize = dSize * this.POST_TIMEOUT_PER_KB / 1000;
+        let timeoVal = Math.round(this.POST_MIN_TIMEOUT + timeoutForDataSize);
+        // pipe(timeout()) is not the same as xhr.timeout
+        let uploadedUpload = null;
+        //console.debug("Post upload: "+ul)
+        this.http.post(ul.url, ul.data, { withCredentials: this.withCredentials }).pipe(timeout(timeoVal)).subscribe(data => {
+            uploadedUpload = ul;
+            //console.debug('Next method called for upload: '+uploadedUpload)
+        }, (err) => {
+            if (err.error instanceof Error) {
+                // A client-side or network error occurred. Handle it accordingly.
+                console.error('Upload error occurred:', err.error.message);
+            }
+            else {
+                // The backend returned an unsuccessful response code.
+                // The response body may contain clues as to what went wrong,
+                console.error(`Upload error: Server returned code ${err.status}`);
+            }
+            this.processError(ul);
+        }, () => {
+            //console.debug('Upload complete method called')
+            if (uploadedUpload) {
+                if (this.DEBUG_DELAY > 0) {
+                    window.setTimeout(() => {
+                        this.uploadDone(ul);
+                    }, this.DEBUG_DELAY);
+                }
+                else {
+                    this.uploadDone(uploadedUpload);
+                }
+            }
+            else {
+                console.error('Upload post complete, but upload not set in next method!');
+            }
+        });
+    }
+    processError(ul) {
+        //console.debug("Process upload error...")
+        ul.status = UploadStatus.ERR;
+        this.status = UploaderStatus.ERR;
+        let ue = new UploaderStatusChangeEvent(this._sizeQueued, this._sizeDone, this.status);
+        if (this.listener) {
+            this.listener(ue);
+        }
+        // set retry timer
+        this.retryTimerId = window.setTimeout(() => {
+            this.retryTimerRunning = false;
+            //console.debug("Upload retry timer exprired. Continue processing...")
+            this.process();
+        }, this.RETRY_DELAY);
+        this.retryTimerRunning = true;
+        //console.debug("Started upload retry timer "+this.RETRY_DELAY+"ms ...")
+    }
+    process() {
+        // clear retry timer if set
+        if (this.retryTimerRunning) {
+            if (this.retryTimerId) {
+                window.clearTimeout(this.retryTimerId);
+            }
+            this.retryTimerRunning = false;
+            //console.debug("Cleared retry timer.")
+        }
+        let pul = null;
+        //console.debug("Uploader status: "+this.status)
+        let s = this.que.length;
+        //console.debug(s+" uploads are in the queue.")
+        if (s > 0 && UploaderStatus.UPLOADING != this.status && UploaderStatus.TRY_UPLOADING != this.status) {
+            for (let i = 0; i < s; i++) {
+                let ul = this.que[i];
+                //console.log("Upload "+ul+" status:"+ul.status)
+                if (ul.status === UploadStatus.IDLE) {
+                    //console.log("Upload "+ul+" startUpload")
+                    this.startUpload(ul);
+                    pul = ul;
+                    break;
+                }
+            }
+            if (!pul) {
+                //console.log("Check ERR uploads...")
+                // now failed uploads
+                //console.debug("No regular upload found. Looking for error state uploads.")
+                for (let i = 0; i < s; i++) {
+                    let ul = this.que[i];
+                    //console.log("Upload "+ul+" status:"+ul.status)
+                    if (ul.status === UploadStatus.ERR) {
+                        //console.log("Upload (ERR) "+ul+" startUpload")
+                        //console.debug("Start error state upload "+ul)
+                        this.startUpload(ul);
+                        pul = ul;
+                        break;
+                    }
+                }
+            }
+        }
+        if (s == 0) {
+            //console.debug("Upload done.")
+            this.status = UploaderStatus.DONE;
+        }
+        let ue = new UploaderStatusChangeEvent(this._sizeQueued, this._sizeDone, this.status);
+        if (this.listener) {
+            this.listener(ue);
+        }
+    }
+    queueUpload(ul) {
+        if (ul) {
+            let ulSize = this.dataSize(ul.data);
+            this.que.push(ul);
+            this._sizeQueued += ulSize;
+            this.process();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"uploader.js","sourceRoot":"","sources":["../../../../../projects/speechrecorderng/src/lib/net/uploader.ts"],"names":[],"mappings":"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","sourcesContent":["\r\n    import {HttpClient, HttpErrorResponse} from \"@angular/common/http\";\r\n    import { timeout } from 'rxjs/operators'\r\n\r\n    // state of an upload\r\n    export enum UploadStatus {IDLE = 1, UPLOADING = 2,  ABORT = 3, DONE = 0, ERR = -1}\r\n\r\n    // state of the uploader\r\n    // TRY_UPLOADING is uploading state after an error (for example if disconnected from server)\r\n    export enum UploaderStatus { DONE = 0, UPLOADING = 1, TRY_UPLOADING = 2,NEXT = 3, ERR = -1}\r\n\r\n    export class UploaderStatusChangeEvent {\r\n        private _sizeQueued:number;\r\n        private _sizeDone:number;\r\n        private _status: UploaderStatus;\r\n\r\n\r\n        constructor(sizeQueued: number, sizeDone: number, status: UploaderStatus) {\r\n            this._sizeQueued = sizeQueued;\r\n            this._sizeDone = sizeDone;\r\n            this._status = status;\r\n        }\r\n\r\n        get sizeQueued():number {\r\n            return this._sizeQueued;\r\n        }\r\n\r\n        get sizeDone():number {\r\n            return this._sizeDone;\r\n        }\r\n\r\n        get status(): UploaderStatus {\r\n            return this._status;\r\n        }\r\n\r\n        uploadDone(): boolean {\r\n            return (this._sizeDone >= this._sizeQueued);\r\n        }\r\n\r\n        percentDone(): number {\r\n            if (this._sizeQueued == 0) {\r\n                // no data queued, we are \"done\"\r\n                return 100;\r\n            }\r\n            let percent = Math.floor(this._sizeDone * 100 / this._sizeQueued);\r\n            //console.log(\"Upload status: queued: \"+this._sizeQueued+\", done: \"+this._sizeDone+\", \"+percent+\"%\")\r\n            return percent;\r\n        }\r\n\r\n    }\r\n\r\n    export class Upload {\r\n\r\n        private _data:Blob|FormData;\r\n        private _url:string;\r\n        status: UploadStatus;\r\n\r\n        constructor(blob:Blob|FormData, url:string) {\r\n            this._data = blob;\r\n            this._url = url;\r\n            this.status = UploadStatus.IDLE;\r\n        }\r\n\r\n        get url():string {\r\n            return this._url;\r\n        }\r\n\r\n        get data():Blob|FormData {\r\n            return this._data;\r\n        }\r\n\r\n      public toString = () : string => {\r\n        let s=`Upload: Status: ${this.status}, URL: ${this._url}`;\r\n        if(this._data instanceof Blob){\r\n            s=s+`, Size: ${this._data.size}`;\r\n        }else if(this._data instanceof  FormData){\r\n           // TODO (iterate through parts ??)\r\n        }\r\n        return s;\r\n      }\r\n    }\r\n\r\n    export class Uploader {\r\n        POST_MIN_TIMEOUT = 120000; // 2min plus ...\r\n        POST_TIMEOUT_PER_KB = 1000;  // ... 1s per kB\r\n\r\n        RETRY_DELAY: number = 30000; // retry every 30s\r\n        DEBUG_DELAY: number = 0;\r\n        //DEBUG_DELAY:number=0;\r\n        private status: UploaderStatus = UploaderStatus.DONE;\r\n        private que: Array<Upload>;\r\n        listener: ((ue: UploaderStatusChangeEvent) => void) | null = null;\r\n        private _sizeQueued: number = 0;\r\n        private _sizeDone: number = 0;\r\n\r\n        private retryTimerRunning = false;\r\n        private retryTimerId: number | null = null;\r\n\r\n        private te:TextEncoder=new TextEncoder();\r\n\r\n        constructor(private http: HttpClient, private withCredentials: boolean = false) {\r\n            this.que = new Array<Upload>();\r\n        }\r\n\r\n        private dataSize(dt:Blob|FormData){\r\n            let si=0;\r\n            if(dt instanceof Blob){\r\n                si=dt.size;\r\n            }else if(dt instanceof  FormData){\r\n                dt.forEach((v,k)=>{\r\n                    if(v instanceof File){\r\n                        si+=v.size;\r\n                    }else if(typeof v ==='string'){\r\n                        // encode to UT-f8 to get upload size\r\n                        si+= this.te.encode().length;\r\n                    }\r\n                })\r\n            }\r\n            return si;\r\n        }\r\n\r\n        private  uploadDone(ul:Upload) {\r\n\r\n            ul.status = UploadStatus.DONE;\r\n\r\n            // remove upload from queue\r\n            for (let i = 0; i < this.que.length; i++) {\r\n                if (this.que[i] === ul) {\r\n                    // found, remove\r\n                    this.que.splice(i, 1);\r\n                    let ulSize = this.dataSize(ul.data);\r\n                    this._sizeDone += ulSize;\r\n                    break;\r\n                }\r\n            }\r\n            // set to done for now...\r\n            this.status = UploaderStatus.NEXT;\r\n            // continue\r\n            this.process();\r\n        }\r\n\r\n        private startUpload(ul:Upload) {\r\n\r\n            ul.status = UploadStatus.UPLOADING;\r\n            if (UploaderStatus.ERR === this.status) {\r\n                this.status = UploaderStatus.TRY_UPLOADING;\r\n            } else {\r\n                this.status = UploaderStatus.UPLOADING;\r\n            }\r\n\r\n            let dSize=this.dataSize(ul.data);\r\n            let timeoutForDataSize=dSize*this.POST_TIMEOUT_PER_KB/1000;\r\n            let timeoVal:number=Math.round(this.POST_MIN_TIMEOUT+timeoutForDataSize)\r\n            // pipe(timeout()) is not the same as xhr.timeout\r\n\r\n          let uploadedUpload:Upload|null=null;\r\n            //console.debug(\"Post upload: \"+ul)\r\n          this.http.post(ul.url,ul.data,{withCredentials:this.withCredentials}).pipe(timeout(timeoVal)).subscribe(\r\n            data => {\r\n              uploadedUpload = ul;\r\n              //console.debug('Next method called for upload: '+uploadedUpload)\r\n            },(err: HttpErrorResponse) => {\r\n              if (err.error instanceof Error) {\r\n                // A client-side or network error occurred. Handle it accordingly.\r\n                console.error('Upload error occurred:', err.error.message);\r\n              } else {\r\n                // The backend returned an unsuccessful response code.\r\n                // The response body may contain clues as to what went wrong,\r\n                console.error(`Upload error: Server returned code ${err.status}`);\r\n              }\r\n              this.processError(ul)\r\n            },()=>{\r\n              //console.debug('Upload complete method called')\r\n              if(uploadedUpload) {\r\n                if (this.DEBUG_DELAY>0) {\r\n                  window.setTimeout(() => {\r\n                    this.uploadDone(ul);\r\n                  }, this.DEBUG_DELAY);\r\n                } else {\r\n                  this.uploadDone(uploadedUpload)\r\n                }\r\n              }else{\r\n                console.error('Upload post complete, but upload not set in next method!')\r\n              }\r\n            });\r\n        }\r\n\r\n        private processError(ul:Upload) {\r\n            //console.debug(\"Process upload error...\")\r\n            ul.status=UploadStatus.ERR\r\n            this.status = UploaderStatus.ERR;\r\n\r\n            let ue = new UploaderStatusChangeEvent(this._sizeQueued, this._sizeDone, this.status);\r\n            if (this.listener) {\r\n                this.listener(ue);\r\n            }\r\n\r\n            // set retry timer\r\n            this.retryTimerId=window.setTimeout(() => {\r\n                this.retryTimerRunning=false;\r\n                //console.debug(\"Upload retry timer exprired. Continue processing...\")\r\n                this.process();\r\n            }, this.RETRY_DELAY);\r\n\r\n            this.retryTimerRunning=true;\r\n            //console.debug(\"Started upload retry timer \"+this.RETRY_DELAY+\"ms ...\")\r\n        }\r\n\r\n      private process() {\r\n        // clear retry timer if set\r\n        if(this.retryTimerRunning){\r\n            if(this.retryTimerId) {\r\n                window.clearTimeout(this.retryTimerId)\r\n            }\r\n          this.retryTimerRunning=false\r\n          //console.debug(\"Cleared retry timer.\")\r\n        }\r\n\r\n        let pul: Upload | null = null;\r\n\r\n        //console.debug(\"Uploader status: \"+this.status)\r\n\r\n        let s = this.que.length;\r\n        //console.debug(s+\" uploads are in the queue.\")\r\n\r\n        if (s>0 && UploaderStatus.UPLOADING != this.status && UploaderStatus.TRY_UPLOADING != this.status) {\r\n\r\n          for (let i = 0; i < s; i++) {\r\n            let ul = this.que[i];\r\n            //console.log(\"Upload \"+ul+\" status:\"+ul.status)\r\n            if (ul.status === UploadStatus.IDLE) {\r\n              //console.log(\"Upload \"+ul+\" startUpload\")\r\n              this.startUpload(ul);\r\n              pul = ul;\r\n              break;\r\n            }\r\n          }\r\n          if (!pul) {\r\n            //console.log(\"Check ERR uploads...\")\r\n            // now failed uploads\r\n            //console.debug(\"No regular upload found. Looking for error state uploads.\")\r\n            for (let i = 0; i < s; i++) {\r\n              let ul = this.que[i];\r\n              //console.log(\"Upload \"+ul+\" status:\"+ul.status)\r\n              if (ul.status === UploadStatus.ERR) {\r\n                //console.log(\"Upload (ERR) \"+ul+\" startUpload\")\r\n                //console.debug(\"Start error state upload \"+ul)\r\n                this.startUpload(ul);\r\n                pul = ul;\r\n                break;\r\n              }\r\n            }\r\n          }\r\n        }\r\n        if(s==0){\r\n          //console.debug(\"Upload done.\")\r\n          this.status=UploaderStatus.DONE\r\n        }\r\n        let ue = new UploaderStatusChangeEvent(this._sizeQueued, this._sizeDone, this.status);\r\n        if (this.listener) {\r\n          this.listener(ue);\r\n        }\r\n      }\r\n\r\n        queueUpload(ul: Upload) {\r\n            if (ul) {\r\n                let ulSize = this.dataSize(ul.data);\r\n                this.que.push(ul);\r\n                this._sizeQueued += ulSize;\r\n                this.process();\r\n            }\r\n        }\r\n    }\r\n\r\n\r\n"]}

package/{esm2015/lib/speechrecorder/project/project.service.js → esm2020/lib/speechrecorder/project/project.service.mjs}

@@ -53,12 +53,12 @@ export class ProjectService {
     }
 }
 ProjectService.PROJECT_API_CTX = 'project';
-ProjectService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: ProjectService, deps: [{ token: i1.HttpClient }, { token: i2.PlatformLocation }, { token: SPEECHRECORDER_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
-ProjectService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: ProjectService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: ProjectService, decorators: [{
+ProjectService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ProjectService, deps: [{ token: i1.HttpClient }, { token: i2.PlatformLocation }, { token: SPEECHRECORDER_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+ProjectService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ProjectService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ProjectService, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.PlatformLocation }, { type: i3.SpeechRecorderConfig, decorators: [{
                     type: Inject,
                     args: [SPEECHRECORDER_CONFIG]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvamVjdC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc3BlZWNocmVjb3JkZXJuZy9zcmMvbGliL3NwZWVjaHJlY29yZGVyL3Byb2plY3QvcHJvamVjdC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsT0FBTyxFQUFDLE1BQU0sRUFBRSxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFakQsT0FBTyxFQUFDLE9BQU8sRUFBRSxxQkFBcUIsRUFBdUIsTUFBTSxrQkFBa0IsQ0FBQztBQUV0RixPQUFPLEVBQUMsSUFBSSxFQUFDLE1BQU0sbUJBQW1CLENBQUM7Ozs7O0FBT3ZDLE1BQU0sT0FBTyxjQUFjO0lBS3pCLFlBQW9CLElBQWUsRUFBUyxnQkFBaUMsRUFBd0MsTUFBNEI7UUFBN0gsU0FBSSxHQUFKLElBQUksQ0FBVztRQUFTLHFCQUFnQixHQUFoQixnQkFBZ0IsQ0FBaUI7UUFBd0MsV0FBTSxHQUFOLE1BQU0sQ0FBc0I7UUFGekksb0JBQWUsR0FBUyxLQUFLLENBQUM7UUFJcEMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxhQUFhLEdBQUMsZ0JBQWdCLENBQUMsa0JBQWtCLEVBQUUsQ0FBQyxDQUFDO1FBRWpFLElBQUksV0FBVyxHQUFHLEVBQUUsQ0FBQTtRQUVwQixJQUFHLE1BQU0sSUFBSSxNQUFNLENBQUMsV0FBVyxFQUFFO1lBQy9CLFdBQVcsR0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDO1NBQ2hDO1FBQ0QsSUFBRyxXQUFXLEtBQUssRUFBRSxFQUFDO1lBQ3BCLFdBQVcsR0FBQyxXQUFXLEdBQUMsR0FBRyxDQUFBO1NBQzVCO1FBQ0QsSUFBRyxNQUFNLElBQUUsSUFBSSxJQUFJLE1BQU0sQ0FBQyxlQUFlLElBQUUsSUFBSSxFQUFDO1lBQzlDLElBQUksQ0FBQyxlQUFlLEdBQUMsTUFBTSxDQUFDLGVBQWUsQ0FBQztTQUM3QztRQUVELElBQUksQ0FBQyxhQUFhLEdBQUcsV0FBVyxHQUFHLGNBQWMsQ0FBQyxlQUFlLENBQUM7SUFFcEUsQ0FBQztJQUVPLHFDQUFxQyxDQUFDLEdBQVU7UUFDdEQsSUFBSSxNQUFNLEdBQUMsR0FBRyxDQUFDO1FBQ2YsSUFBSSxJQUFJLENBQUMsTUFBTSxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxLQUFLLE9BQU8sQ0FBQyxLQUFLLEVBQUU7WUFDeEQsMkJBQTJCO1lBQzNCLDJFQUEyRTtZQUMzRSxNQUFNLEdBQUcsTUFBTSxHQUFHLG9CQUFvQixHQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztTQUN4RDtRQUNELE9BQU8sTUFBTSxDQUFBO0lBQ2YsQ0FBQztJQUVELFVBQVUsQ0FBQyxFQUFTO1FBQ2xCLElBQUksUUFBUSxHQUFDLGtCQUFrQixDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBQ3BDLE9BQU8sSUFBSSxDQUFDLHFDQUFxQyxDQUFDLElBQUksQ0FBQyxhQUFhLEdBQUcsR0FBRyxHQUFHLFFBQVEsQ0FBQyxDQUFDO0lBQ3pGLENBQUM7SUFFRCxrQkFBa0IsQ0FBQyxTQUFpQixFQUFDLGVBQXNCO1FBQ3pELElBQUksUUFBUSxHQUFDLGtCQUFrQixDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQzNDLDhGQUE4RjtRQUM5Riw0RkFBNEY7UUFDNUYsSUFBSSxhQUFhLEdBQUMsU0FBUyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQzdDLE9BQU8sSUFBSSxDQUFDLGFBQWEsR0FBRyxHQUFHLEdBQUcsUUFBUSxHQUFFLEdBQUcsR0FBQyxhQUFhLENBQUM7SUFDaEUsQ0FBQztJQUVELGlCQUFpQixDQUFDLEVBQVM7UUFDekIsSUFBSSxNQUFNLEdBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUM5QixPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFVLE1BQU0sRUFBQyxFQUFDLGVBQWUsRUFBRSxJQUFJLENBQUMsZUFBZSxFQUFDLENBQUMsQ0FBQTtJQUMvRSxDQUFDOztBQWxEcUIsOEJBQWUsR0FBQyxTQUFTLENBQUE7NEdBRHJDLGNBQWMsNEVBSzZELHFCQUFxQjtnSEFMaEcsY0FBYzs0RkFBZCxjQUFjO2tCQUQxQixVQUFVOzswQkFNc0UsTUFBTTsyQkFBQyxxQkFBcUIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQ3JlYXRlZCBieSBrbGF1c2ogb24gMTcuMDYuMjAxNy5cclxuICovXHJcbmltcG9ydCB7SW5qZWN0LCBJbmplY3RhYmxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHtIdHRwQ2xpZW50fSBmcm9tIFwiQGFuZ3VsYXIvY29tbW9uL2h0dHBcIjtcclxuaW1wb3J0IHtBcGlUeXBlLCBTUEVFQ0hSRUNPUkRFUl9DT05GSUcsIFNwZWVjaFJlY29yZGVyQ29uZmlnfSBmcm9tIFwiLi4vLi4vc3ByLmNvbmZpZ1wiO1xyXG5pbXBvcnQge1Byb2plY3R9IGZyb20gXCIuL3Byb2plY3RcIjtcclxuaW1wb3J0IHtVVUlEfSBmcm9tIFwiLi4vLi4vdXRpbHMvdXRpbHNcIjtcclxuaW1wb3J0IHtPYnNlcnZhYmxlfSBmcm9tIFwicnhqc1wiO1xyXG5pbXBvcnQge1BsYXRmb3JtTG9jYXRpb259IGZyb20gXCJAYW5ndWxhci9jb21tb25cIjtcclxuXHJcblxyXG5cclxuQEluamVjdGFibGUoKVxyXG5leHBvcnQgY2xhc3MgUHJvamVjdFNlcnZpY2Uge1xyXG4gIHB1YmxpYyBzdGF0aWMgcmVhZG9ubHkgUFJPSkVDVF9BUElfQ1RYPSdwcm9qZWN0J1xyXG4gIHByaXZhdGUgcHJvamVjdEN0eFVybDpzdHJpbmc7XHJcbiAgcHJpdmF0ZSB3aXRoQ3JlZGVudGlhbHM6Ym9vbGVhbj1mYWxzZTtcclxuXHJcbiAgY29uc3RydWN0b3IocHJpdmF0ZSBodHRwOkh0dHBDbGllbnQscHJpdmF0ZSBwbGF0Zm9ybUxvYWN0aW9uOlBsYXRmb3JtTG9jYXRpb24sQEluamVjdChTUEVFQ0hSRUNPUkRFUl9DT05GSUcpIHByaXZhdGUgY29uZmlnPzpTcGVlY2hSZWNvcmRlckNvbmZpZykge1xyXG5cclxuICAgIGNvbnNvbGUubG9nKFwiQmFzZSBIcmVmOiBcIitwbGF0Zm9ybUxvYWN0aW9uLmdldEJhc2VIcmVmRnJvbURPTSgpKTtcclxuXHJcbiAgICBsZXQgYXBpRW5kUG9pbnQgPSAnJ1xyXG5cclxuICAgIGlmKGNvbmZpZyAmJiBjb25maWcuYXBpRW5kUG9pbnQpIHtcclxuICAgICAgYXBpRW5kUG9pbnQ9Y29uZmlnLmFwaUVuZFBvaW50O1xyXG4gICAgfVxyXG4gICAgaWYoYXBpRW5kUG9pbnQgIT09ICcnKXtcclxuICAgICAgYXBpRW5kUG9pbnQ9YXBpRW5kUG9pbnQrJy8nXHJcbiAgICB9XHJcbiAgICBpZihjb25maWchPW51bGwgJiYgY29uZmlnLndpdGhDcmVkZW50aWFscyE9bnVsbCl7XHJcbiAgICAgIHRoaXMud2l0aENyZWRlbnRpYWxzPWNvbmZpZy53aXRoQ3JlZGVudGlhbHM7XHJcbiAgICB9XHJcblxyXG4gICAgdGhpcy5wcm9qZWN0Q3R4VXJsID0gYXBpRW5kUG9pbnQgKyBQcm9qZWN0U2VydmljZS5QUk9KRUNUX0FQSV9DVFg7XHJcblxyXG4gIH1cclxuXHJcbiAgcHJpdmF0ZSBhcHBlbmRSZXF1ZXN0VVVJREZvckRldmVsb3BtZW50U2VydmVyKHVybDpzdHJpbmcpOnN0cmluZ3tcclxuICAgIGxldCByZXNVcmw9dXJsO1xyXG4gICAgaWYgKHRoaXMuY29uZmlnICYmIHRoaXMuY29uZmlnLmFwaVR5cGUgPT09IEFwaVR5cGUuRklMRVMpIHtcclxuICAgICAgLy8gZm9yIGRldmVsb3BtZW50IGFuZCBkZW1vXHJcbiAgICAgIC8vIGFwcGVuZCBVVUlEIHRvIG1ha2UgcmVxdWVzdCBVUkwgdW5pcXVlIHRvIGF2b2lkIGxvY2FsaG9zdCBzZXJ2ZXIgY2FjaGluZ1xyXG4gICAgICByZXNVcmwgPSByZXNVcmwgKyAnLmpzb24/cmVxdWVzdFVVSUQ9JytVVUlELmdlbmVyYXRlKCk7XHJcbiAgICB9XHJcbiAgICByZXR1cm4gcmVzVXJsXHJcbiAgfVxyXG5cclxuICBwcm9qZWN0VXJsKGlkOnN0cmluZyk6c3RyaW5ne1xyXG4gICAgbGV0IGVuY1ByaklkPWVuY29kZVVSSUNvbXBvbmVudChpZCk7XHJcbiAgICByZXR1cm4gdGhpcy5hcHBlbmRSZXF1ZXN0VVVJREZvckRldmVsb3BtZW50U2VydmVyKHRoaXMucHJvamVjdEN0eFVybCArICcvJyArIGVuY1ByaklkKTtcclxuICB9XHJcblxyXG4gIHByb2plY3RSZXNvdXJjZVVybChwcm9qZWN0SWQ6IHN0cmluZyxyZWxSZXNvdXJjZVBhdGg6c3RyaW5nKTpzdHJpbmd7XHJcbiAgICBsZXQgZW5jUHJqSWQ9ZW5jb2RlVVJJQ29tcG9uZW50KHByb2plY3RJZCk7XHJcbiAgICAvLyBVc2UgZW5jb2RlVVJJIGhlcmUgc2luY2UgdGhlIHJlbGF0aWNlIHJlc291cmNlIHBhdGggZnJvbSByZWNvcmRpbmcgc2NyaXB0cyBpcyBhbHJlYWR5IGEgVVJJXHJcbiAgICAvLyBlbmNvZGVVUklDb21wb25lbnQgZnVuY3Rpb24gd291bGQgZW5jb2RlIHRoZSBzbGFzaGVzIGFuZCBmZXRjaGluZyB0aGUgcmVzb3VyY2Ugd291bGQgZmFpbFxyXG4gICAgbGV0IGVuY1JlbFJlc1BhdGg9ZW5jb2RlVVJJKHJlbFJlc291cmNlUGF0aCk7XHJcbiAgICByZXR1cm4gdGhpcy5wcm9qZWN0Q3R4VXJsICsgJy8nICsgZW5jUHJqSWQgKycvJytlbmNSZWxSZXNQYXRoO1xyXG4gIH1cclxuXHJcbiAgcHJvamVjdE9ic2VydmFibGUoaWQ6c3RyaW5nKTpPYnNlcnZhYmxlPFByb2plY3Q+e1xyXG4gICAgbGV0IHByalVybD10aGlzLnByb2plY3RVcmwoaWQpO1xyXG4gICAgIHJldHVybiB0aGlzLmh0dHAuZ2V0PFByb2plY3Q+KHByalVybCx7d2l0aENyZWRlbnRpYWxzOiB0aGlzLndpdGhDcmVkZW50aWFsc30pXHJcbiAgIH1cclxuXHJcbn1cclxuXHJcblxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/speechrecorder/recording.mjs

@@ -0,0 +1,54 @@
+import { UUID } from '../utils/utils';
+export class RecordingFileDescriptorImpl {
+    constructor() { }
+}
+export class RecordingFile {
+    constructor(uuid, sessionId, audioBuffer) {
+        this.recordingFileId = null;
+        this.uuid = null;
+        this.date = null;
+        this._dateAsDateObj = null;
+        this.startedDate = null;
+        this.audioBuffer = null;
+        this.session = null;
+        this.frames = null;
+        this.editSampleRate = null;
+        this.editStartFrame = null;
+        this.editEndFrame = null;
+        this.session = sessionId;
+        this.audioBuffer = audioBuffer;
+        this.uuid = uuid;
+    }
+    filenameString() {
+        let fns = '';
+        if (this.session) {
+            fns += this.session;
+            fns += '_';
+        }
+        fns += this.uuid;
+        return fns;
+    }
+}
+export class SprRecordingFile extends RecordingFile {
+    constructor(sessionId, itemcode, version, audioBuffer) {
+        super(UUID.generate(), sessionId, audioBuffer);
+        this.session = sessionId;
+        this.itemCode = itemcode;
+        this.version = version;
+        this.audioBuffer = audioBuffer;
+    }
+    filenameString() {
+        let fns = '';
+        if (this.session) {
+            fns += this.session;
+            fns += '_';
+        }
+        if (this.itemCode) {
+            fns += this.itemCode;
+            fns += '_';
+        }
+        fns += this.uuid;
+        return fns;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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