@milaboratories/pl-drivers 1.11.58 → 1.11.60

package/dist/drivers/upload_task.d.ts

@@ -1,61 +1,63 @@
-import type { Watcher } from "@milaboratories/computable";
-import type * as sdk from "@milaboratories/pl-model-common";
-import type { MiLogger, Signer } from "@milaboratories/ts-helpers";
-import type { ClientProgress } from "../clients/progress";
-import type { ClientUpload } from "../clients/upload";
-import { BadRequestError, MTimeError, NoFileForUploading, UnexpectedEOF } from "../clients/upload";
-import type { ImportResourceSnapshot } from "./types";
-import { ImportFileHandleUploadData } from "./types";
+import { BadRequestError, ClientUpload, MTimeError, NoFileForUploading, UnexpectedEOF } from "../clients/upload.js";
+import { ClientProgress } from "../clients/progress.js";
+import { ImportFileHandleUploadData, ImportResourceSnapshot } from "./types.js";
+import { MiLogger, Signer } from "@milaboratories/ts-helpers";
+import { Watcher } from "@milaboratories/computable";
+import * as sdk from "@milaboratories/pl-model-common";
 import { ResourceInfo } from "@milaboratories/pl-tree";
+
+//#region src/drivers/upload_task.d.ts
 /** Holds all info needed to upload a file and a status of uploading
  * and indexing. Also, has a method to update a status of the progress.
  * And holds a change source. */
-export declare class UploadTask {
-    private readonly logger;
-    private readonly clientBlob;
-    private readonly clientProgress;
-    private readonly maxNConcurrentPartsUpload;
-    readonly res: ImportResourceSnapshot;
-    private readonly change;
-    private readonly counter;
-    private nMaxUploads;
-    private nPartsWithThisUploadSpeed;
-    private nPartsToIncreaseUpload;
-    /** If this is upload progress this field will be defined */
-    private uploadData?;
-    progress: sdk.ImportProgress;
-    /** If failed, then getting a progress is terminally failed. */
-    failed?: boolean;
-    /** True if the blob was existed.
-     * At this case, the task will show progress == 1.0. */
-    private alreadyExisted;
-    constructor(logger: MiLogger, clientBlob: ClientUpload, clientProgress: ClientProgress, maxNConcurrentPartsUpload: number, signer: Signer, res: ImportResourceSnapshot);
-    getProgress(w: Watcher, callerId: string): sdk.ImportProgress;
-    shouldScheduleUpload(): boolean;
-    /** Uploads a blob if it's not BlobIndex. */
-    uploadBlobTask(): Promise<void>;
-    updateStatus(): Promise<void>;
-    /** Set non-terminal error, that task can be retried. */
-    private setRetriableError;
-    /** Set a terminal error, the task will throw a error instead of a progress. */
-    private setTerminalError;
-    setDoneIfOutputSet(res: ImportResourceSnapshot): void;
-    private setDone;
-    incCounter(w: Watcher, callerId: string): void;
-    decCounter(callerId: string): boolean;
-    private isComputableDone;
+declare class UploadTask {
+  private readonly logger;
+  private readonly clientBlob;
+  private readonly clientProgress;
+  private readonly maxNConcurrentPartsUpload;
+  readonly res: ImportResourceSnapshot;
+  private readonly change;
+  private readonly counter;
+  private nMaxUploads;
+  private nPartsWithThisUploadSpeed;
+  private nPartsToIncreaseUpload;
+  /** If this is upload progress this field will be defined */
+  private uploadData?;
+  progress: sdk.ImportProgress;
+  /** If failed, then getting a progress is terminally failed. */
+  failed?: boolean;
+  /** True if the blob was existed.
+   * At this case, the task will show progress == 1.0. */
+  private alreadyExisted;
+  constructor(logger: MiLogger, clientBlob: ClientUpload, clientProgress: ClientProgress, maxNConcurrentPartsUpload: number, signer: Signer, res: ImportResourceSnapshot);
+  getProgress(w: Watcher, callerId: string): sdk.ImportProgress;
+  shouldScheduleUpload(): boolean;
+  /** Uploads a blob if it's not BlobIndex. */
+  uploadBlobTask(): Promise<void>;
+  updateStatus(): Promise<void>;
+  /** Set non-terminal error, that task can be retried. */
+  private setRetriableError;
+  /** Set a terminal error, the task will throw a error instead of a progress. */
+  private setTerminalError;
+  setDoneIfOutputSet(res: ImportResourceSnapshot): void;
+  private setDone;
+  incCounter(w: Watcher, callerId: string): void;
+  decCounter(callerId: string): boolean;
+  private isComputableDone;
 }
 /** Uploads a blob if it's not BlobIndex. */
-export declare function uploadBlob(logger: MiLogger, clientBlob: ClientUpload, res: ResourceInfo, uploadData: ImportFileHandleUploadData, isDoneFn: () => boolean, speed: {
-    nPartsWithThisUploadSpeed: number;
-    nPartsToIncreaseUpload: number;
-    currentSpeed: number;
-    maxSpeed: number;
+declare function uploadBlob(logger: MiLogger, clientBlob: ClientUpload, res: ResourceInfo, uploadData: ImportFileHandleUploadData, isDoneFn: () => boolean, speed: {
+  nPartsWithThisUploadSpeed: number;
+  nPartsToIncreaseUpload: number;
+  currentSpeed: number;
+  maxSpeed: number;
 }): Promise<void>;
 /** Returns true if we need to upload the blob that got from this progress. */
-export declare function isMyUpload(p: sdk.ImportProgress): boolean;
-export declare function isUpload(res: ResourceInfo): boolean;
-export declare function isSignMatch(signer: Signer, path: string, signature: string): boolean;
-export declare function isTerminalUploadError(e: any): boolean;
-export declare function nonRecoverableError(e: any): e is MTimeError | UnexpectedEOF | NoFileForUploading | BadRequestError;
+declare function isMyUpload(p: sdk.ImportProgress): boolean;
+declare function isUpload(res: ResourceInfo): boolean;
+declare function isSignMatch(signer: Signer, path: string, signature: string): boolean;
+declare function isTerminalUploadError(e: any): boolean;
+declare function nonRecoverableError(e: any): e is MTimeError | UnexpectedEOF | NoFileForUploading | BadRequestError;
+//#endregion
+export { UploadTask, isMyUpload, isSignMatch, isTerminalUploadError, isUpload, nonRecoverableError, uploadBlob };
 //# sourceMappingURL=upload_task.d.ts.map

package/dist/drivers/upload_task.js

@@ -1,296 +1,259 @@
-import { ChangeSource } from '@milaboratories/computable';
-import { resourceIdToString, isTimeoutError, stringifyWithResourceId } from '@milaboratories/pl-client';
-import { CallersCounter, asyncPool } from '@milaboratories/ts-helpers';
-import { MTimeError, UnexpectedEOF, NoFileForUploading, BadRequestError } from '../clients/upload.js';
-import { ImportFileHandleUploadData } from './types.js';
-import assert from 'node:assert';
+import { BadRequestError, MTimeError, NoFileForUploading, UnexpectedEOF } from "../clients/upload.js";
+import { ImportFileHandleUploadData } from "./types.js";
+import { isTimeoutError, resourceIdToString, stringifyWithResourceId } from "@milaboratories/pl-client";
+import { CallersCounter, asyncPool } from "@milaboratories/ts-helpers";
+import { ChangeSource } from "@milaboratories/computable";
+import assert from "node:assert";
 
+//#region src/drivers/upload_task.ts
 /** Holds all info needed to upload a file and a status of uploading
- * and indexing. Also, has a method to update a status of the progress.
- * And holds a change source. */
-class UploadTask {
-    logger;
-    clientBlob;
-    clientProgress;
-    maxNConcurrentPartsUpload;
-    res;
-    change = new ChangeSource();
-    counter = new CallersCounter();
-    nMaxUploads;
-    nPartsWithThisUploadSpeed = 0;
-    nPartsToIncreaseUpload = 10; // how many parts we have to wait to increase concurrency, 50 mb, 10 parts by 5 mb each.
-    /** If this is upload progress this field will be defined */
-    uploadData;
-    progress;
-    /** If failed, then getting a progress is terminally failed. */
-    failed;
-    /** True if the blob was existed.
-     * At this case, the task will show progress == 1.0. */
-    alreadyExisted = false;
-    constructor(logger, clientBlob, clientProgress, maxNConcurrentPartsUpload, signer, res) {
-        this.logger = logger;
-        this.clientBlob = clientBlob;
-        this.clientProgress = clientProgress;
-        this.maxNConcurrentPartsUpload = maxNConcurrentPartsUpload;
-        this.res = res;
-        this.nMaxUploads = this.maxNConcurrentPartsUpload;
-        const { uploadData, progress } = newProgress(res, signer);
-        this.uploadData = uploadData;
-        this.progress = progress;
-    }
-    getProgress(w, callerId) {
-        this.incCounter(w, callerId);
-        if (this.failed) {
-            this.logger.error(`Uploading terminally failed: ${this.progress.lastError}`);
-            throw new Error(this.progress.lastError);
-        }
-        return cloneProgress(this.progress);
-    }
-    shouldScheduleUpload() {
-        return isMyUpload(this.progress);
-    }
-    /** Uploads a blob if it's not BlobIndex. */
-    async uploadBlobTask() {
-        try {
-            await uploadBlob(this.logger, this.clientBlob, this.res, this.uploadData, this.isComputableDone.bind(this), {
-                nPartsWithThisUploadSpeed: this.nPartsWithThisUploadSpeed,
-                nPartsToIncreaseUpload: this.nPartsToIncreaseUpload,
-                currentSpeed: this.nMaxUploads,
-                maxSpeed: this.maxNConcurrentPartsUpload,
-            });
-            this.change.markChanged(`blob upload for ${resourceIdToString(this.res.id)} finished`);
-        }
-        catch (e) {
-            if (isTerminalUploadError(e)) {
-                this.logger.warn(`terminal error while uploading a blob: ${e}`);
-                this.change.markChanged(`blob upload for ${resourceIdToString(this.res.id)} aborted: ${e.code}`);
-                this.setDone(true);
-                return;
-            }
-            this.logger.error(`error while uploading a blob: ${e}`);
-            this.change.markChanged(`blob upload for ${resourceIdToString(this.res.id)} failed`);
-            if (nonRecoverableError(e)) {
-                this.setTerminalError(e);
-                return;
-            }
-            this.setRetriableError(e);
-            if (isHeadersTimeoutError(e)) {
-                // we probably have a slow internet, we need to slow things a bit.
-                this.nMaxUploads = decreaseConcurrency(this.logger, this.nMaxUploads, 1);
-            }
-            throw e;
-        }
-    }
-    async updateStatus() {
-        try {
-            // we do it with timeout in case we have slow internet.
-            const status = await this.clientProgress.getStatus(this.res, { timeout: 10000 });
-            const oldStatus = this.progress.status;
-            const newStatus = doneProgressIfExisted(this.alreadyExisted, protoToStatus(status));
-            this.progress.status = newStatus;
-            this.setDone(status.done);
-            if (status.done || this.progress.status.progress != oldStatus?.progress) {
-                this.change.markChanged(`upload status for ${resourceIdToString(this.res.id)} changed`);
-            }
-        }
-        catch (e) {
-            this.setRetriableError(e);
-            if (isTimeoutError(e)) {
-                this.logger.warn(`deadline exceeded while getting a status of BlobImport: ${e.message}`);
-                return;
-            }
-            if (isTerminalUploadError(e)) {
-                this.logger.warn(`terminal error while updating BlobImport status: ${e}, ${stringifyWithResourceId(this.res)}`);
-                this.change.markChanged(`upload status for ${resourceIdToString(this.res.id)} aborted: ${e.code}`);
-                this.setDone(true);
-                return;
-            }
-            this.logger.error(`retryable error while updating a status of BlobImport: ${e}`);
-            // It was a terminal error, but when a connection drops,
-            // this will stop the whole task, so we make it retryable.
-            // It was like that:
-            // this.change.markChanged();
-            // this.setTerminalError(e);
-        }
-    }
-    /** Set non-terminal error, that task can be retried. */
-    setRetriableError(e) {
-        this.progress.lastError = String(e);
-    }
-    /** Set a terminal error, the task will throw a error instead of a progress. */
-    setTerminalError(e) {
-        this.progress.lastError = String(e);
-        this.progress.done = false;
-        this.failed = true;
-    }
-    setDoneIfOutputSet(res) {
-        if (isImportResourceOutputSet(res)) {
-            this.setDone(true);
-            this.alreadyExisted = true;
-        }
-    }
-    setDone(done) {
-        this.progress.done = done;
-        if (done)
-            this.progress.lastError = undefined;
-    }
-    incCounter(w, callerId) {
-        this.change.attachWatcher(w);
-        this.counter.inc(callerId);
-    }
-    decCounter(callerId) {
-        return this.counter.dec(callerId);
-    }
-    isComputableDone() {
-        return this.counter.isZero();
-    }
-}
+* and indexing. Also, has a method to update a status of the progress.
+* And holds a change source. */
+var UploadTask = class {
+	change = new ChangeSource();
+	counter = new CallersCounter();
+	nMaxUploads;
+	nPartsWithThisUploadSpeed = 0;
+	nPartsToIncreaseUpload = 10;
+	/** If this is upload progress this field will be defined */
+	uploadData;
+	progress;
+	/** If failed, then getting a progress is terminally failed. */
+	failed;
+	/** True if the blob was existed.
+	* At this case, the task will show progress == 1.0. */
+	alreadyExisted = false;
+	constructor(logger, clientBlob, clientProgress, maxNConcurrentPartsUpload, signer, res) {
+		this.logger = logger;
+		this.clientBlob = clientBlob;
+		this.clientProgress = clientProgress;
+		this.maxNConcurrentPartsUpload = maxNConcurrentPartsUpload;
+		this.res = res;
+		this.nMaxUploads = this.maxNConcurrentPartsUpload;
+		const { uploadData, progress } = newProgress(res, signer);
+		this.uploadData = uploadData;
+		this.progress = progress;
+	}
+	getProgress(w, callerId) {
+		this.incCounter(w, callerId);
+		if (this.failed) {
+			this.logger.error(`Uploading terminally failed: ${this.progress.lastError}`);
+			throw new Error(this.progress.lastError);
+		}
+		return cloneProgress(this.progress);
+	}
+	shouldScheduleUpload() {
+		return isMyUpload(this.progress);
+	}
+	/** Uploads a blob if it's not BlobIndex. */
+	async uploadBlobTask() {
+		try {
+			await uploadBlob(this.logger, this.clientBlob, this.res, this.uploadData, this.isComputableDone.bind(this), {
+				nPartsWithThisUploadSpeed: this.nPartsWithThisUploadSpeed,
+				nPartsToIncreaseUpload: this.nPartsToIncreaseUpload,
+				currentSpeed: this.nMaxUploads,
+				maxSpeed: this.maxNConcurrentPartsUpload
+			});
+			this.change.markChanged(`blob upload for ${resourceIdToString(this.res.id)} finished`);
+		} catch (e) {
+			if (isTerminalUploadError(e)) {
+				this.logger.warn(`terminal error while uploading a blob: ${e}`);
+				this.change.markChanged(`blob upload for ${resourceIdToString(this.res.id)} aborted: ${e.code}`);
+				this.setDone(true);
+				return;
+			}
+			this.logger.error(`error while uploading a blob: ${e}`);
+			this.change.markChanged(`blob upload for ${resourceIdToString(this.res.id)} failed`);
+			if (nonRecoverableError(e)) {
+				this.setTerminalError(e);
+				return;
+			}
+			this.setRetriableError(e);
+			if (isHeadersTimeoutError(e)) this.nMaxUploads = decreaseConcurrency(this.logger, this.nMaxUploads, 1);
+			throw e;
+		}
+	}
+	async updateStatus() {
+		try {
+			const status = await this.clientProgress.getStatus(this.res, { timeout: 1e4 });
+			const oldStatus = this.progress.status;
+			const newStatus = doneProgressIfExisted(this.alreadyExisted, protoToStatus(status));
+			this.progress.status = newStatus;
+			this.setDone(status.done);
+			if (status.done || this.progress.status.progress != oldStatus?.progress) this.change.markChanged(`upload status for ${resourceIdToString(this.res.id)} changed`);
+		} catch (e) {
+			this.setRetriableError(e);
+			if (isTimeoutError(e)) {
+				this.logger.warn(`deadline exceeded while getting a status of BlobImport: ${e.message}`);
+				return;
+			}
+			if (isTerminalUploadError(e)) {
+				this.logger.warn(`terminal error while updating BlobImport status: ${e}, ${stringifyWithResourceId(this.res)}`);
+				this.change.markChanged(`upload status for ${resourceIdToString(this.res.id)} aborted: ${e.code}`);
+				this.setDone(true);
+				return;
+			}
+			this.logger.error(`retryable error while updating a status of BlobImport: ${e}`);
+		}
+	}
+	/** Set non-terminal error, that task can be retried. */
+	setRetriableError(e) {
+		this.progress.lastError = String(e);
+	}
+	/** Set a terminal error, the task will throw a error instead of a progress. */
+	setTerminalError(e) {
+		this.progress.lastError = String(e);
+		this.progress.done = false;
+		this.failed = true;
+	}
+	setDoneIfOutputSet(res) {
+		if (isImportResourceOutputSet(res)) {
+			this.setDone(true);
+			this.alreadyExisted = true;
+		}
+	}
+	setDone(done) {
+		this.progress.done = done;
+		if (done) this.progress.lastError = void 0;
+	}
+	incCounter(w, callerId) {
+		this.change.attachWatcher(w);
+		this.counter.inc(callerId);
+	}
+	decCounter(callerId) {
+		return this.counter.dec(callerId);
+	}
+	isComputableDone() {
+		return this.counter.isZero();
+	}
+};
 /** Uploads a blob if it's not BlobIndex. */
 async function uploadBlob(logger, clientBlob, res, uploadData, isDoneFn, speed) {
-    assert(isUpload(res), "the upload operation can be done only for BlobUploads");
-    const timeout = 10000; // 10 sec instead of standard 5 sec, things might be slow with a slow connection.
-    if (isDoneFn())
-        return;
-    const parts = await clientBlob.initUpload(res, { timeout });
-    logger.info(`started to upload blob ${res.id},` +
-        ` parts overall: ${parts.overall}, parts remained: ${parts.toUpload.length},` +
-        ` number of concurrent uploads: ${speed.currentSpeed}`);
-    const partUploadFn = (part) => async (controller) => {
-        if (isDoneFn())
-            return;
-        await clientBlob.partUpload(res, uploadData.localPath, BigInt(uploadData.modificationTime), part, parts.checksumAlgorithm, parts.checksumHeader, { timeout });
-        logger.info(`uploaded chunk ${part}/${parts.overall} of resource: ${res.id}`);
-        // if we had a network freeze, it will be increased slowly.
-        speed.nPartsWithThisUploadSpeed++;
-        if (speed.nPartsWithThisUploadSpeed >= speed.nPartsToIncreaseUpload) {
-            speed.nPartsWithThisUploadSpeed = 0;
-            speed.currentSpeed = increaseConcurrency(logger, speed.currentSpeed, speed.maxSpeed);
-            controller.setConcurrency(speed.currentSpeed);
-        }
-    };
-    await asyncPool(speed.currentSpeed, parts.toUpload.map(partUploadFn));
-    if (isDoneFn())
-        return;
-    await clientBlob.finalize(res, { timeout });
-    logger.info(`uploading of resource ${res.id} finished.`);
+	assert(isUpload(res), "the upload operation can be done only for BlobUploads");
+	const timeout = 1e4;
+	if (isDoneFn()) return;
+	const parts = await clientBlob.initUpload(res, { timeout });
+	logger.info(`started to upload blob ${res.id}, parts overall: ${parts.overall}, parts remained: ${parts.toUpload.length}, number of concurrent uploads: ${speed.currentSpeed}`);
+	const partUploadFn = (part) => async (controller) => {
+		if (isDoneFn()) return;
+		await clientBlob.partUpload(res, uploadData.localPath, BigInt(uploadData.modificationTime), part, parts.checksumAlgorithm, parts.checksumHeader, { timeout });
+		logger.info(`uploaded chunk ${part}/${parts.overall} of resource: ${res.id}`);
+		speed.nPartsWithThisUploadSpeed++;
+		if (speed.nPartsWithThisUploadSpeed >= speed.nPartsToIncreaseUpload) {
+			speed.nPartsWithThisUploadSpeed = 0;
+			speed.currentSpeed = increaseConcurrency(logger, speed.currentSpeed, speed.maxSpeed);
+			controller.setConcurrency(speed.currentSpeed);
+		}
+	};
+	await asyncPool(speed.currentSpeed, parts.toUpload.map(partUploadFn));
+	if (isDoneFn()) return;
+	await clientBlob.finalize(res, { timeout });
+	logger.info(`uploading of resource ${res.id} finished.`);
 }
 function newProgress(res, signer) {
-    let isUploadSignMatch;
-    let uploadData;
-    if (isUpload(res)) {
-        uploadData = ImportFileHandleUploadData.parse(res.data);
-        isUploadSignMatch = isSignMatch(signer, uploadData.localPath, uploadData.pathSignature);
-    }
-    return {
-        uploadData: uploadData,
-        progress: {
-            done: false,
-            status: undefined,
-            isUpload: isUpload(res),
-            isUploadSignMatch: isUploadSignMatch,
-            lastError: undefined,
-        },
-    };
+	let isUploadSignMatch;
+	let uploadData;
+	if (isUpload(res)) {
+		uploadData = ImportFileHandleUploadData.parse(res.data);
+		isUploadSignMatch = isSignMatch(signer, uploadData.localPath, uploadData.pathSignature);
+	}
+	return {
+		uploadData,
+		progress: {
+			done: false,
+			status: void 0,
+			isUpload: isUpload(res),
+			isUploadSignMatch,
+			lastError: void 0
+		}
+	};
 }
 /** Returns true if we need to upload the blob that got from this progress. */
 function isMyUpload(p) {
-    return p.isUpload && (p.isUploadSignMatch ?? false);
+	return p.isUpload && (p.isUploadSignMatch ?? false);
 }
 /** Creates a deep copy of progress,
- * since we do not want to pass a mutable object
- * to API, it led to bugs before.
- * We do not use '...' cloning syntax
- * for the compiler to fail here if we change API. */
+* since we do not want to pass a mutable object
+* to API, it led to bugs before.
+* We do not use '...' cloning syntax
+* for the compiler to fail here if we change API. */
 function cloneProgress(progress) {
-    ({
-        done: progress.done,
-        isUpload: progress.isUpload,
-        isUploadSignMatch: progress.isUploadSignMatch,
-        lastError: progress.lastError,
-    });
-    if (progress.status)
-        ({
-            progress: progress.status.progress,
-            bytesProcessed: progress.status.bytesProcessed,
-            bytesTotal: progress.status.bytesTotal,
-        });
-    return progress;
+	const cloned = {
+		done: progress.done,
+		isUpload: progress.isUpload,
+		isUploadSignMatch: progress.isUploadSignMatch,
+		lastError: progress.lastError
+	};
+	if (progress.status) cloned.status = {
+		progress: progress.status.progress,
+		bytesProcessed: progress.status.bytesProcessed,
+		bytesTotal: progress.status.bytesTotal
+	};
+	return progress;
 }
 function isImportResourceOutputSet(res) {
-    return "blob" in res.fields
-        ? res.fields.blob !== undefined
-        : res.fields.incarnation !== undefined;
+	return "blob" in res.fields ? res.fields.blob !== void 0 : res.fields.incarnation !== void 0;
 }
 function isUpload(res) {
-    return res.type.name.startsWith("BlobUpload");
+	return res.type.name.startsWith("BlobUpload");
 }
 function isSignMatch(signer, path, signature) {
-    try {
-        signer.verify(path, signature);
-        return true;
-    }
-    catch {
-        return false;
-    }
+	try {
+		signer.verify(path, signature);
+		return true;
+	} catch {
+		return false;
+	}
 }
 function protoToStatus(proto) {
-    return {
-        progress: proto.progress ?? 0,
-        bytesProcessed: Number(proto.bytesProcessed),
-        bytesTotal: Number(proto.bytesTotal),
-    };
+	return {
+		progress: proto.progress ?? 0,
+		bytesProcessed: Number(proto.bytesProcessed),
+		bytesTotal: Number(proto.bytesTotal)
+	};
 }
 /** Special hack: if we didn't even start to upload the blob
- * to backend because the result was already there,
- * the backend does show us a status that nothing were uploaded,
- * but we need to show the client that everything is OK.
- * Thus, here we set progress to be 1.0 and all bytes are become processed. */
+* to backend because the result was already there,
+* the backend does show us a status that nothing were uploaded,
+* but we need to show the client that everything is OK.
+* Thus, here we set progress to be 1.0 and all bytes are become processed. */
 function doneProgressIfExisted(alreadyExisted, status) {
-    if (alreadyExisted && status.bytesTotal != 0 && status.bytesProcessed == 0) {
-        return {
-            progress: 1.0,
-            bytesProcessed: Number(status.bytesTotal),
-            bytesTotal: Number(status.bytesTotal),
-        };
-    }
-    return status;
+	if (alreadyExisted && status.bytesTotal != 0 && status.bytesProcessed == 0) return {
+		progress: 1,
+		bytesProcessed: Number(status.bytesTotal),
+		bytesTotal: Number(status.bytesTotal)
+	};
+	return status;
 }
 function isTerminalUploadError(e) {
-    if (e?.name !== "RpcError")
-        return false;
-    switch (e.code) {
-        case "NOT_FOUND":
-        case "ABORTED":
-        case "ALREADY_EXISTS":
-            return true;
-        default:
-            return false;
-    }
+	if (e?.name !== "RpcError") return false;
+	switch (e.code) {
+		case "NOT_FOUND":
+		case "ABORTED":
+		case "ALREADY_EXISTS": return true;
+		default: return false;
+	}
 }
 function nonRecoverableError(e) {
-    return (e instanceof MTimeError ||
-        e instanceof UnexpectedEOF ||
-        e instanceof NoFileForUploading ||
-        e instanceof BadRequestError);
+	return e instanceof MTimeError || e instanceof UnexpectedEOF || e instanceof NoFileForUploading || e instanceof BadRequestError;
 }
 function isHeadersTimeoutError(e) {
-    return e?.message.includes(`UND_ERR_HEADERS_TIMEOUT`);
+	return e?.message.includes(`UND_ERR_HEADERS_TIMEOUT`);
 }
 /** It's called for every upload success so if everyone is succeeded, we'll double the concurrency. */
 function increaseConcurrency(logger, current, max) {
-    const newConcurrency = Math.min(current + 2, max);
-    if (newConcurrency != current)
-        logger.info(`uploadTask.increaseConcurrency: increased from ${current} to ${newConcurrency}`);
-    return newConcurrency;
+	const newConcurrency = Math.min(current + 2, max);
+	if (newConcurrency != current) logger.info(`uploadTask.increaseConcurrency: increased from ${current} to ${newConcurrency}`);
+	return newConcurrency;
 }
 /** When a error happens, this will half the concurrency level, so the next time
- * we'll try to upload blobs slower. */
+* we'll try to upload blobs slower. */
 function decreaseConcurrency(logger, current, min) {
-    const newConcurrency = Math.max(Math.round(current / 2), min);
-    if (newConcurrency != current)
-        logger.info(`uploadTask.decreaseConcurrency: decreased from ${current} to ${newConcurrency}`);
-    return newConcurrency;
+	const newConcurrency = Math.max(Math.round(current / 2), min);
+	if (newConcurrency != current) logger.info(`uploadTask.decreaseConcurrency: decreased from ${current} to ${newConcurrency}`);
+	return newConcurrency;
 }
 
+//#endregion
 export { UploadTask, isMyUpload, isSignMatch, isTerminalUploadError, isUpload, nonRecoverableError, uploadBlob };
-//# sourceMappingURL=upload_task.js.map
+//# sourceMappingURL=upload_task.js.map