speechrecorderng 3.6.0 → 3.8.0

package/esm2022/lib/net/uploader.mjs

@@ -0,0 +1,367 @@
+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;
+    }
+    sizeInQueue() {
+        return this._sizeQueued - 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 {
+    get serverPersistable() {
+        return this._serverPersistable;
+    }
+    constructor(blob, url, _serverPersistable = null) {
+        this._serverPersistable = _serverPersistable;
+        this.onDone = null;
+        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;
+    }
+    done() {
+        this.status = UploadStatus.DONE;
+        //console.debug("Single upload done.");
+        if (this._serverPersistable) {
+            this._serverPersistable.serverPersisted = true;
+            //console.debug("Single upload set server persisted: "+this.serverPersistable);
+        }
+        else {
+            //console.debug("Server persistable not set.");
+        }
+        if (this.onDone) {
+            this.onDone(this);
+        }
+    }
+}
+export class UploadHolder {
+    constructor() {
+        this.onUploadSet = null;
+        this._upload = null;
+    }
+    get upload() {
+        return this._upload;
+    }
+    set upload(value) {
+        this._upload = value;
+        if (this._upload && this.onUploadSet) {
+            this.onUploadSet(this._upload);
+        }
+    }
+}
+export class UploadSet {
+    constructor() {
+        this.uploads = new Array();
+        this._complete = false;
+        this._onDone = null;
+    }
+    add(upload) {
+        if (this._complete) {
+            throw new Error('Cannot add upload to upload set. Upload set already complete.');
+        }
+        if (upload instanceof UploadHolder) {
+            upload.onUploadSet = (upl) => {
+                upl.onDone = () => {
+                    this.checkUploadStates();
+                };
+                this.checkUploadStates();
+            };
+        }
+        this.uploads.push(upload);
+    }
+    complete() {
+        // Mark set as complete
+        this._complete = true;
+        // add listeners to each upload
+        for (let upl of this.uploads) {
+            if (upl instanceof Upload) {
+                upl.onDone = (upl) => {
+                    this.checkUploadStates();
+                };
+            }
+            else if (upl instanceof UploadHolder) {
+                if (upl.upload) {
+                    upl.upload.onDone = (upl) => {
+                        this.checkUploadStates();
+                    };
+                }
+            }
+        }
+        // check immediately if already done
+        this.checkUploadStates();
+    }
+    set onDone(value) {
+        this._onDone = value;
+        this.checkUploadStates();
+    }
+    checkUploadStates() {
+        //console.debug("Check upload state...")
+        if (this._complete) {
+            if (this._onDone) {
+                for (let upl of this.uploads) {
+                    if (upl instanceof Upload) {
+                        if (UploadStatus.DONE !== upl.status) {
+                            // At least this upload is not yet done
+                            // Do nothing
+                            //console.debug("Check upload state: Upload not done.")
+                            return;
+                        }
+                    }
+                    else if (upl instanceof UploadHolder) {
+                        if (upl.upload) {
+                            if (UploadStatus.DONE !== upl.upload.status) {
+                                // At least this upload is not yet done
+                                // Do nothing
+                                //console.debug("Check upload state: Upload (holder) not done.")
+                                return;
+                            }
+                        }
+                        else {
+                            // The actual upload is not yet set
+                            //console.debug("Check upload state: Upload (holder): upload not yet set.")
+                            return;
+                        }
+                    }
+                }
+                // set is complete and all upload parts are done, call done callback
+                //console.debug("Check upload state: All done.")
+                this._onDone(this);
+            }
+        }
+    }
+}
+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 UTF-8 to get upload size
+                    si += this.te.encode().length;
+                }
+            });
+        }
+        return si;
+    }
+    uploadDone(ul) {
+        ul.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({
+            next: (data) => {
+                uploadedUpload = ul;
+                //console.debug('Next method called for upload: '+uploadedUpload)
+            },
+            error: (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);
+            }, complete: () => {
+                //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 expired. 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":"AAEI,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAExC,qBAAqB;AACrB,MAAM,CAAN,IAAY,YAAsE;AAAlF,WAAY,YAAY;IAAE,+CAAQ,CAAA;IAAE,yDAAa,CAAA;IAAG,iDAAS,CAAA;IAAE,+CAAQ,CAAA;IAAE,8CAAQ,CAAA;AAAA,CAAC,EAAtE,YAAY,KAAZ,YAAY,QAA0D;AAElF,wBAAwB;AACxB,4FAA4F;AAC5F,MAAM,CAAN,IAAY,cAA+E;AAA3F,WAAY,cAAc;IAAG,mDAAQ,CAAA;IAAE,6DAAa,CAAA;IAAE,qEAAiB,CAAA;IAAC,mDAAQ,CAAA;IAAE,kDAAQ,CAAA;AAAA,CAAC,EAA/E,cAAc,KAAd,cAAc,QAAiE;AAE3F,MAAM,OAAO,yBAAyB;IAMlC,YAAY,UAAkB,EAAE,QAAgB,EAAE,MAAsB;QACpE,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;QAC9B,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IAC1B,CAAC;IAED,IAAI,UAAU;QACV,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAED,IAAI,QAAQ;QACR,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED,WAAW;QACT,OAAO,IAAI,CAAC,WAAW,GAAC,IAAI,CAAC,SAAS,CAAC;IACzC,CAAC;IAED,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,UAAU;QACN,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC;IAChD,CAAC;IAED,WAAW;QACP,IAAI,IAAI,CAAC,WAAW,IAAI,CAAC,EAAE;YACvB,gCAAgC;YAChC,OAAO,GAAG,CAAC;SACd;QACD,IAAI,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,GAAG,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC;QAClE,oGAAoG;QACpG,OAAO,OAAO,CAAC;IACnB,CAAC;CAEJ;AAED,MAAM,OAAO,MAAM;IAEjB,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IAQC,YAAY,IAAkB,EAAE,GAAU,EAAS,qBAA0C,IAAI;QAA9C,uBAAkB,GAAlB,kBAAkB,CAA4B;QAFjG,WAAM,GAAgC,IAAI,CAAC;QAgCtC,aAAQ,GAAG,GAAY,EAAE;YAC9B,IAAI,CAAC,GAAC,mBAAmB,IAAI,CAAC,MAAM,UAAU,IAAI,CAAC,IAAI,EAAE,CAAC;YAC1D,IAAG,IAAI,CAAC,KAAK,YAAY,IAAI,EAAC;gBAC1B,CAAC,GAAC,CAAC,GAAC,WAAW,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;aACpC;iBAAK,IAAG,IAAI,CAAC,KAAK,YAAa,QAAQ,EAAC;gBACtC,kCAAkC;aACpC;YACD,OAAO,CAAC,CAAC;QACX,CAAC,CAAA;QArCK,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAChB,IAAI,CAAC,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC;IACpC,CAAC;IAED,IAAI,GAAG;QACH,OAAO,IAAI,CAAC,IAAI,CAAC;IACrB,CAAC;IAED,IAAI,IAAI;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAED,IAAI;QACA,IAAI,CAAC,MAAM,GAAC,YAAY,CAAC,IAAI,CAAC;QAC9B,uCAAuC;QACvC,IAAG,IAAI,CAAC,kBAAkB,EAAE;YAC1B,IAAI,CAAC,kBAAkB,CAAC,eAAe,GAAG,IAAI,CAAC;YAC/C,+EAA+E;SAChF;aAAI;YACH,+CAA+C;SAChD;QACD,IAAG,IAAI,CAAC,MAAM,EAAC;YACb,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;SACnB;IACL,CAAC;CAaJ;AAED,MAAM,OAAO,YAAY;IAAzB;QAEE,gBAAW,GAA8B,IAAI,CAAC;QAYtC,YAAO,GAAa,IAAI,CAAC;IACnC,CAAC;IAXC,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,IAAI,MAAM,CAAC,KAAoB;QAC7B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAG,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,WAAW,EAAC;YAClC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SAChC;IACH,CAAC;CAEF;AAED,MAAM,OAAO,SAAS;IAAtB;QAEU,YAAO,GAA6B,IAAI,KAAK,EAAuB,CAAC;QACrE,cAAS,GAAC,KAAK,CAAC;QAEhB,YAAO,GAAoC,IAAI,CAAC;IAgF1D,CAAC;IA9EC,GAAG,CAAC,MAA0B;QAC5B,IAAG,IAAI,CAAC,SAAS,EAAE;YACjB,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAA;SACjF;QACD,IAAG,MAAM,YAAY,YAAY,EAAC;YAChC,MAAM,CAAC,WAAW,GAAC,CAAC,GAAG,EAAC,EAAE;gBACxB,GAAG,CAAC,MAAM,GAAC,GAAE,EAAE;oBACb,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC3B,CAAC,CAAA;gBACD,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,CAAC,CAAA;SACF;QACD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAE5B,CAAC;IAED,QAAQ;QACN,uBAAuB;QACvB,IAAI,CAAC,SAAS,GAAC,IAAI,CAAC;QAEpB,+BAA+B;QAC/B,KAAI,IAAI,GAAG,IAAI,IAAI,CAAC,OAAO,EAAC;YAC1B,IAAG,GAAG,YAAY,MAAM,EAAE;gBACxB,GAAG,CAAC,MAAM,GAAG,CAAC,GAAW,EAAE,EAAE;oBAC3B,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC3B,CAAC,CAAA;aACF;iBAAK,IAAG,GAAG,YAAY,YAAY,EAAC;gBACnC,IAAG,GAAG,CAAC,MAAM,EAAC;oBACZ,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,GAAW,EAAE,EAAE;wBAClC,IAAI,CAAC,iBAAiB,EAAE,CAAC;oBAC3B,CAAC,CAAA;iBACF;aACF;SACF;QAED,oCAAoC;QACpC,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED,IAAI,MAAM,CAAC,KAA8C;QACvD,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAEO,iBAAiB;QACvB,wCAAwC;QACxC,IAAG,IAAI,CAAC,SAAS,EAAC;YAEhB,IAAG,IAAI,CAAC,OAAO,EAAE;gBACf,KAAI,IAAI,GAAG,IAAI,IAAI,CAAC,OAAO,EAAC;oBAC1B,IAAG,GAAG,YAAY,MAAM,EAAE;wBACxB,IAAI,YAAY,CAAC,IAAI,KAAK,GAAG,CAAC,MAAM,EAAE;4BACpC,uCAAuC;4BACvC,aAAa;4BACb,uDAAuD;4BACvD,OAAO;yBACR;qBACF;yBAAK,IAAG,GAAG,YAAY,YAAY,EAAC;wBACnC,IAAG,GAAG,CAAC,MAAM,EAAC;4BACZ,IAAI,YAAY,CAAC,IAAI,KAAK,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE;gCAC3C,uCAAuC;gCACvC,aAAa;gCACb,gEAAgE;gCAChE,OAAO;6BACR;yBACF;6BAAI;4BACH,mCAAmC;4BACnC,2EAA2E;4BAC3E,OAAO;yBACR;qBACF;iBACF;gBACD,oEAAoE;gBACpE,gDAAgD;gBAChD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;aACpB;SACF;IACH,CAAC;CACF;AAMD,MAAM,OAAO,QAAQ;IAkBjB,YAAoB,IAAgB,EAAU,kBAA2B,KAAK;QAA1D,SAAI,GAAJ,IAAI,CAAY;QAAU,oBAAe,GAAf,eAAe,CAAiB;QAjB9E,qBAAgB,GAAG,MAAM,CAAC,CAAC,gBAAgB;QAC3C,wBAAmB,GAAG,IAAI,CAAC,CAAE,gBAAgB;QAE7C,gBAAW,GAAW,KAAK,CAAC,CAAC,kBAAkB;QAC/C,gBAAW,GAAW,CAAC,CAAC;QACxB,uBAAuB;QACf,WAAM,GAAmB,cAAc,CAAC,IAAI,CAAC;QAErD,aAAQ,GAAqD,IAAI,CAAC;QAC1D,gBAAW,GAAW,CAAC,CAAC;QACxB,cAAS,GAAW,CAAC,CAAC;QAEtB,sBAAiB,GAAG,KAAK,CAAC;QAC1B,iBAAY,GAAkB,IAAI,CAAC;QAEnC,OAAE,GAAa,IAAI,WAAW,EAAE,CAAC;QAGrC,IAAI,CAAC,GAAG,GAAG,IAAI,KAAK,EAAU,CAAC;IACnC,CAAC;IAEO,QAAQ,CAAC,EAAgB;QAC7B,IAAI,EAAE,GAAC,CAAC,CAAC;QACT,IAAG,EAAE,YAAY,IAAI,EAAC;YAClB,EAAE,GAAC,EAAE,CAAC,IAAI,CAAC;SACd;aAAK,IAAG,EAAE,YAAa,QAAQ,EAAC;YAC7B,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,EAAC,CAAC,EAAC,EAAE;gBACd,IAAG,CAAC,YAAY,IAAI,EAAC;oBACjB,EAAE,IAAE,CAAC,CAAC,IAAI,CAAC;iBACd;qBAAK,IAAG,OAAO,CAAC,KAAI,QAAQ,EAAC;oBAC1B,qCAAqC;oBACrC,EAAE,IAAG,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC;iBAChC;YACL,CAAC,CAAC,CAAA;SACL;QACD,OAAO,EAAE,CAAC;IACd,CAAC;IAEQ,UAAU,CAAC,EAAS;QAEzB,EAAE,CAAC,IAAI,EAAE,CAAC;QAEV,2BAA2B;QAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACtC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE;gBACpB,gBAAgB;gBAChB,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBACtB,IAAI,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;gBACpC,IAAI,CAAC,SAAS,IAAI,MAAM,CAAC;gBACzB,MAAM;aACT;SACJ;QACD,yBAAyB;QACzB,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC;QAClC,WAAW;QACX,IAAI,CAAC,OAAO,EAAE,CAAC;IACnB,CAAC;IAEO,WAAW,CAAC,EAAS;QAEzB,EAAE,CAAC,MAAM,GAAG,YAAY,CAAC,SAAS,CAAC;QACnC,IAAI,cAAc,CAAC,GAAG,KAAK,IAAI,CAAC,MAAM,EAAE;YACpC,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC,aAAa,CAAC;SAC9C;aAAM;YACH,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC,SAAS,CAAC;SAC1C;QAED,IAAI,KAAK,GAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,kBAAkB,GAAC,KAAK,GAAC,IAAI,CAAC,mBAAmB,GAAC,IAAI,CAAC;QAC3D,IAAI,QAAQ,GAAQ,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,GAAC,kBAAkB,CAAC,CAAA;QACxE,iDAAiD;QAEnD,IAAI,cAAc,GAAa,IAAI,CAAC;QAClC,mCAAmC;QACnC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,EAAC,EAAE,CAAC,IAAI,EAAC,EAAC,eAAe,EAAC,IAAI,CAAC,eAAe,EAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CACnG;YACI,IAAI,EAAE,CAAC,IAAI,EAAC,EAAE;gBAEV,cAAc,GAAG,EAAE,CAAC;gBACpB,iEAAiE;YACrE,CAAC;YACC,KAAK,EAAC,CAAC,GAAsB,EAAE,EAAE;gBAC/B,IAAI,GAAG,CAAC,KAAK,YAAY,KAAK,EAAE;oBAC5B,kEAAkE;oBAClE,OAAO,CAAC,KAAK,CAAC,wBAAwB,EAAE,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;iBAC9D;qBAAM;oBACH,sDAAsD;oBACtD,6DAA6D;oBAC7D,OAAO,CAAC,KAAK,CAAC,sCAAsC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;iBACrE;gBACD,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,CAAA;YACzB,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE;gBACd,gDAAgD;gBAChD,IAAI,cAAc,EAAE;oBAChB,IAAI,IAAI,CAAC,WAAW,GAAG,CAAC,EAAE;wBACtB,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;4BACnB,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;wBACxB,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;qBACxB;yBAAM;wBACH,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAAA;qBAClC;iBACJ;qBAAM;oBACH,OAAO,CAAC,KAAK,CAAC,0DAA0D,CAAC,CAAA;iBAC5E;YACL,CAAC;SACJ,CAAC,CAAC;IACX,CAAC;IAEO,YAAY,CAAC,EAAS;QAC1B,0CAA0C;QAC1C,EAAE,CAAC,MAAM,GAAC,YAAY,CAAC,GAAG,CAAA;QAC1B,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC;QAEjC,IAAI,EAAE,GAAG,IAAI,yBAAyB,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACtF,IAAI,IAAI,CAAC,QAAQ,EAAE;YACf,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;SACrB;QAED,kBAAkB;QAClB,IAAI,CAAC,YAAY,GAAC,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;YACrC,IAAI,CAAC,iBAAiB,GAAC,KAAK,CAAC;YAC7B,qEAAqE;YACrE,IAAI,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAErB,IAAI,CAAC,iBAAiB,GAAC,IAAI,CAAC;QAC5B,wEAAwE;IAC5E,CAAC;IAEK,OAAO;QACb,2BAA2B;QAC3B,IAAG,IAAI,CAAC,iBAAiB,EAAC;YACtB,IAAG,IAAI,CAAC,YAAY,EAAE;gBAClB,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;aACzC;YACH,IAAI,CAAC,iBAAiB,GAAC,KAAK,CAAA;YAC5B,uCAAuC;SACxC;QAED,IAAI,GAAG,GAAkB,IAAI,CAAC;QAE9B,gDAAgD;QAEhD,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC;QACxB,+CAA+C;QAE/C,IAAI,CAAC,GAAC,CAAC,IAAI,cAAc,CAAC,SAAS,IAAI,IAAI,CAAC,MAAM,IAAI,cAAc,CAAC,aAAa,IAAI,IAAI,CAAC,MAAM,EAAE;YAEjG,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;gBAC1B,IAAI,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBACrB,gDAAgD;gBAChD,IAAI,EAAE,CAAC,MAAM,KAAK,YAAY,CAAC,IAAI,EAAE;oBACnC,0CAA0C;oBAC1C,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;oBACrB,GAAG,GAAG,EAAE,CAAC;oBACT,MAAM;iBACP;aACF;YACD,IAAI,CAAC,GAAG,EAAE;gBACR,qCAAqC;gBACrC,qBAAqB;gBACrB,4EAA4E;gBAC5E,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;oBAC1B,IAAI,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;oBACrB,gDAAgD;oBAChD,IAAI,EAAE,CAAC,MAAM,KAAK,YAAY,CAAC,GAAG,EAAE;wBAClC,gDAAgD;wBAChD,+CAA+C;wBAC/C,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;wBACrB,GAAG,GAAG,EAAE,CAAC;wBACT,MAAM;qBACP;iBACF;aACF;SACF;QACD,IAAG,CAAC,IAAE,CAAC,EAAC;YACN,+BAA+B;YAC/B,IAAI,CAAC,MAAM,GAAC,cAAc,CAAC,IAAI,CAAA;SAChC;QACD,IAAI,EAAE,GAAG,IAAI,yBAAyB,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACtF,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;SACnB;IACH,CAAC;IAEC,WAAW,CAAC,EAAU;QAClB,IAAI,EAAE,EAAE;YACJ,IAAI,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;YACpC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAClB,IAAI,CAAC,WAAW,IAAI,MAAM,CAAC;YAC3B,IAAI,CAAC,OAAO,EAAE,CAAC;SAClB;IACL,CAAC;CACJ","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 readonly _sizeQueued:number;\r\n        private readonly _sizeDone:number;\r\n        private readonly _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        sizeInQueue(){\r\n          return this._sizeQueued-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      get serverPersistable(): ServerPersistable | null {\r\n        return this._serverPersistable;\r\n      }\r\n\r\n        private readonly _data:Blob|FormData;\r\n        private readonly _url:string;\r\n\r\n        status: UploadStatus;\r\n        onDone:((upload:Upload)=>void) | null=null;\r\n\r\n        constructor(blob:Blob|FormData, url:string,private _serverPersistable:ServerPersistable|null=null) {\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        done(){\r\n            this.status=UploadStatus.DONE;\r\n            //console.debug(\"Single upload done.\");\r\n            if(this._serverPersistable) {\r\n              this._serverPersistable.serverPersisted = true;\r\n              //console.debug(\"Single upload set server persisted: \"+this.serverPersistable);\r\n            }else{\r\n              //console.debug(\"Server persistable not set.\");\r\n            }\r\n            if(this.onDone){\r\n              this.onDone(this);\r\n            }\r\n        }\r\n\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 UploadHolder{\r\n\r\n      onUploadSet:((upload:Upload)=>void)|null=null;\r\n\r\n      get upload(): Upload | null {\r\n        return this._upload;\r\n      }\r\n\r\n      set upload(value: Upload | null) {\r\n        this._upload = value;\r\n        if(this._upload && this.onUploadSet){\r\n          this.onUploadSet(this._upload);\r\n        }\r\n      }\r\n      private _upload:Upload|null=null;\r\n    }\r\n\r\n    export class UploadSet{\r\n\r\n      private uploads: Array<Upload|UploadHolder>=new Array<Upload|UploadHolder>();\r\n      private _complete=false;\r\n\r\n      private _onDone:((uploadSet:UploadSet)=>void)|null=null;\r\n\r\n      add(upload:Upload|UploadHolder){\r\n        if(this._complete) {\r\n          throw new Error('Cannot add upload to upload set. Upload set already complete.')\r\n        }\r\n        if(upload instanceof UploadHolder){\r\n          upload.onUploadSet=(upl)=>{\r\n            upl.onDone=()=>{\r\n              this.checkUploadStates();\r\n            }\r\n            this.checkUploadStates();\r\n          }\r\n        }\r\n        this.uploads.push(upload);\r\n\r\n      }\r\n\r\n      complete(){\r\n        // Mark set as complete\r\n        this._complete=true;\r\n\r\n        // add listeners to each upload\r\n        for(let upl of this.uploads){\r\n          if(upl instanceof Upload) {\r\n            upl.onDone = (upl: Upload) => {\r\n              this.checkUploadStates();\r\n            }\r\n          }else if(upl instanceof UploadHolder){\r\n            if(upl.upload){\r\n              upl.upload.onDone = (upl: Upload) => {\r\n                this.checkUploadStates();\r\n              }\r\n            }\r\n          }\r\n        }\r\n\r\n        // check immediately if already done\r\n        this.checkUploadStates();\r\n      }\r\n\r\n      set onDone(value: ((uploadSet: UploadSet) => void) | null) {\r\n        this._onDone = value;\r\n        this.checkUploadStates();\r\n      }\r\n\r\n      private checkUploadStates(){\r\n        //console.debug(\"Check upload state...\")\r\n        if(this._complete){\r\n\r\n          if(this._onDone) {\r\n            for(let upl of this.uploads){\r\n              if(upl instanceof Upload) {\r\n                if (UploadStatus.DONE !== upl.status) {\r\n                  // At least this upload is not yet done\r\n                  // Do nothing\r\n                  //console.debug(\"Check upload state: Upload not done.\")\r\n                  return;\r\n                }\r\n              }else if(upl instanceof UploadHolder){\r\n                if(upl.upload){\r\n                  if (UploadStatus.DONE !== upl.upload.status) {\r\n                    // At least this upload is not yet done\r\n                    // Do nothing\r\n                    //console.debug(\"Check upload state: Upload (holder) not done.\")\r\n                    return;\r\n                  }\r\n                }else{\r\n                  // The actual upload is not yet set\r\n                  //console.debug(\"Check upload state: Upload (holder): upload not yet set.\")\r\n                  return;\r\n                }\r\n              }\r\n            }\r\n            // set is complete and all upload parts are done, call done callback\r\n            //console.debug(\"Check upload state: All done.\")\r\n            this._onDone(this);\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    export interface ServerPersistable{\r\n        serverPersisted:boolean;\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 readonly 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 UTF-8 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.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                {\r\n                    next: (data)=>\r\n                    {\r\n                        uploadedUpload = ul;\r\n                        //console.debug('Next method called for upload: '+uploadedUpload)\r\n                    }\r\n                    , error:(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                    }, complete: () => {\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\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 expired. 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/{esm2020 → esm2022}/lib/recorder_component.mjs

@@ -1,65 +1,65 @@
-import { SprDb } from "./db/inddb";
-import { Observable } from "rxjs";
-import { PersistentAudioStorageTarget } from "./audio/inddb_audio_buffer";
-export class RecorderComponent {
-    constructor(uploader) {
-        this.uploader = uploader;
-        this.dataSaved = true;
-        this._persistentAudioStorageTarget = null;
-    }
-    printStorageInfos() {
-        // Safari seems not to support the estimate function.
-        if (navigator.storage && navigator.storage.estimate instanceof Function) {
-            navigator.storage.estimate().then((se) => {
-                console.info("Estimated storage usage: " + se.usage + ", quota: " + se.quota);
-            }).catch((err) => "Could not get get storage infos: " + err.message);
-        }
-        else {
-            console.info("User agent does not support storage manager estimate function.");
-        }
-    }
-    prepare(persistentAudioStorage = false) {
-        if (persistentAudioStorage) {
-            this.printStorageInfos();
-        }
-        return new Observable(subscriber => {
-            if (persistentAudioStorage) {
-                SprDb.prepare().subscribe({
-                    next: (db) => {
-                        this._persistentAudioStorageTarget = new PersistentAudioStorageTarget(db, SprDb.RECORDING_FILE_CACHE_OBJECT_STORE_NAME);
-                        //let delCnt=0;
-                        this._persistentAudioStorageTarget.deleteAll().subscribe({
-                            next: () => {
-                                //delCnt++;
-                                subscriber.next();
-                            },
-                            complete: () => {
-                                //console.info('Storage info after deletion of all ('+delCnt+') entries:');
-                                console.info('Persistent audio storage object store cleared.');
-                                this.printStorageInfos();
-                                subscriber.complete();
-                            },
-                            error: (err) => {
-                                subscriber.error(err);
-                            }
-                        });
-                        window.addEventListener('beforeunload', (e) => {
-                            if (this._persistentAudioStorageTarget) {
-                                // Delete on page leave. Di not register callbacks to prevent page leave blocking
-                                this._persistentAudioStorageTarget.deleteAll().subscribe();
-                            }
-                        });
-                    },
-                    error: (err) => {
-                        subscriber.error(err);
-                    }
-                });
-            }
-            else {
-                subscriber.next();
-                subscriber.complete();
-            }
-        });
-    }
-}
+import { SprDb } from "./db/inddb";
+import { Observable } from "rxjs";
+import { PersistentAudioStorageTarget } from "./audio/inddb_audio_buffer";
+export class RecorderComponent {
+    constructor(uploader) {
+        this.uploader = uploader;
+        this.dataSaved = true;
+        this._persistentAudioStorageTarget = null;
+    }
+    printStorageInfos() {
+        // Safari seems not to support the estimate function.
+        if (navigator.storage && navigator.storage.estimate instanceof Function) {
+            navigator.storage.estimate().then((se) => {
+                console.info("Estimated storage usage: " + se.usage + ", quota: " + se.quota);
+            }).catch((err) => "Could not get get storage infos: " + err.message);
+        }
+        else {
+            console.info("User agent does not support storage manager estimate function.");
+        }
+    }
+    prepare(persistentAudioStorage = false) {
+        if (persistentAudioStorage) {
+            this.printStorageInfos();
+        }
+        return new Observable(subscriber => {
+            if (persistentAudioStorage) {
+                SprDb.prepare().subscribe({
+                    next: (db) => {
+                        this._persistentAudioStorageTarget = new PersistentAudioStorageTarget(db, SprDb.RECORDING_FILE_CACHE_OBJECT_STORE_NAME);
+                        //let delCnt=0;
+                        this._persistentAudioStorageTarget.deleteAll().subscribe({
+                            next: () => {
+                                //delCnt++;
+                                subscriber.next();
+                            },
+                            complete: () => {
+                                //console.info('Storage info after deletion of all ('+delCnt+') entries:');
+                                console.info('Persistent audio storage object store cleared.');
+                                this.printStorageInfos();
+                                subscriber.complete();
+                            },
+                            error: (err) => {
+                                subscriber.error(err);
+                            }
+                        });
+                        window.addEventListener('beforeunload', (e) => {
+                            if (this._persistentAudioStorageTarget) {
+                                // Delete on page leave. Di not register callbacks to prevent page leave blocking
+                                this._persistentAudioStorageTarget.deleteAll().subscribe();
+                            }
+                        });
+                    },
+                    error: (err) => {
+                        subscriber.error(err);
+                    }
+                });
+            }
+            else {
+                subscriber.next();
+                subscriber.complete();
+            }
+        });
+    }
+}
 //# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/speechrecorder/project/project.mjs

@@ -0,0 +1,49 @@
+export var ConstraintType;
+(function (ConstraintType) {
+    ConstraintType["Exact"] = "EXACT";
+    ConstraintType["Ideal"] = "IDEAL";
+})(ConstraintType || (ConstraintType = {}));
+;
+export var Platform;
+(function (Platform) {
+    Platform["Linux"] = "LINUX";
+    Platform["macOS"] = "MACOS";
+    Platform["Windows"] = "WINDOWS";
+    Platform["Android"] = "ANDROID";
+})(Platform || (Platform = {}));
+export var BrowserBase;
+(function (BrowserBase) {
+    BrowserBase["Chromium"] = "CHROMIUM";
+})(BrowserBase || (BrowserBase = {}));
+;
+export var Browser;
+(function (Browser) {
+    Browser["Firefox"] = "FIREFOX";
+    Browser["Chromium"] = "CHROMIUM";
+    Browser["Chrome"] = "CHROME";
+    Browser["Edge"] = "EDGE";
+    Browser["Opera"] = "OPERA";
+})(Browser || (Browser = {}));
+export var AudioStorageType;
+(function (AudioStorageType) {
+    AudioStorageType["MEM_ENTIRE"] = "MEM_ENTIRE";
+    AudioStorageType["MEM_CHUNKED"] = "MEM_CHUNKED";
+    AudioStorageType["DB_CHUNKED"] = "DB_CHUNKED";
+    AudioStorageType["NET_CHUNKED"] = "NET_CHUNKED";
+    AudioStorageType["MEM_ENTIRE_AUTO_NET_CHUNKED"] = "MEM_ENTIRE_AUTO_NET_CHUNKED";
+    AudioStorageType["MEM_CHUNKED_AUTO_NET_CHUNKED"] = "MEM_CHUNKED_AUTO_NET_CHUNKED";
+})(AudioStorageType || (AudioStorageType = {}));
+export class ProjectUtil {
+    static { this.DEFAULT_AUDIO_CHANNEL_COUNT = 2; }
+    static audioChannelCount(project) {
+        let chs = ProjectUtil.DEFAULT_AUDIO_CHANNEL_COUNT;
+        if (project.mediaCaptureFormat) {
+            chs = project.mediaCaptureFormat.audioChannelCount;
+        }
+        else if (project.audioFormat) {
+            chs = project.audioFormat.channels;
+        }
+        return chs;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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