@mtkruto/node 0.67.2 → 0.68.0

package/script/client/2_file_manager.js

@@ -15,25 +15,24 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _FileManager_instances, _a, _FileManager_c, _FileManager_Lupload, _FileManager_UPLOAD_MAX_CHUNK_SIZE, _FileManager_DOWNLOAD_MAX_CHUNK_SIZE, _FileManager_BIG_FILE_THRESHOLD, _FileManager_uploadStream, _FileManager_uploadBuffer, _FileManager_uploadPart, _FileManager_handleError, _FileManager_getFileContents, _FileManager_CUSTOM_EMOJI_TTL;
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileManager = void 0;
 /**
@@ -63,39 +62,58 @@ const _2_tl_js_1 = require("../2_tl.js");
 const _3_transport_js_1 = require("../3_transport.js");
 const _3_types_js_1 = require("../3_types.js");
 const _4_constants_js_1 = require("../4_constants.js");
+const _4_errors_js_1 = require("../4_errors.js");
 const _0_utilities_js_1 = require("./0_utilities.js");
 class FileManager {
+    #c;
+    #Lupload;
+    static #UPLOAD_MAX_CHUNK_SIZE = 512 * _1_utilities_js_1.kilobyte;
+    static #DOWNLOAD_MAX_CHUNK_SIZE = 1 * _1_utilities_js_1.megabyte;
+    static #BIG_FILE_THRESHOLD = 10 * _1_utilities_js_1.megabyte;
     constructor(c) {
-        _FileManager_instances.add(this);
-        _FileManager_c.set(this, void 0);
-        _FileManager_Lupload.set(this, void 0);
-        __classPrivateFieldSet(this, _FileManager_c, c, "f");
+        this.#c = c;
         const L = (0, _1_utilities_js_1.getLogger)("FileManager").client(c.id);
-        __classPrivateFieldSet(this, _FileManager_Lupload, L.branch("upload"), "f");
+        this.#Lupload = L.branch("upload");
+    }
+    #progressIds = new Set();
+    getProgressId() {
+        let id;
+        do {
+            id = (0, _1_utilities_js_1.getRandomId)();
+        } while (id === 0n || this.#progressIds.has(id));
+        this.#progressIds.add(id);
+        return Promise.resolve(String(id));
     }
     async upload(file, params, checkName, allowStream = true) {
-        let { size, name, contents } = await __classPrivateFieldGet(_a, _a, "m", _FileManager_getFileContents).call(_a, file, params, allowStream);
+        if (params?.progressId !== undefined && !this.#progressIds.has(BigInt(params.progressId))) {
+            throw new _0_errors_js_1.InputError("Invalid progressId.");
+        }
+        if (params?.progressId !== undefined) {
+            this.#progressIds.delete(BigInt(params.progressId));
+        }
+        let { size, name, contents } = await _a.#getFileContents(file, params, allowStream);
         if (checkName) {
             name = checkName(name);
         }
         if (size == 0 || size < -1) {
             throw new _0_errors_js_1.InputError("Invalid file size.");
         }
-        const poolSize = await __classPrivateFieldGet(this, _FileManager_c, "f").getUploadPoolSize();
-        const chunkSize = params?.chunkSize ?? __classPrivateFieldGet(_a, _a, "f", _FileManager_UPLOAD_MAX_CHUNK_SIZE);
-        _a.validateChunkSize(chunkSize, __classPrivateFieldGet(_a, _a, "f", _FileManager_UPLOAD_MAX_CHUNK_SIZE));
-        const fileId = (0, _1_utilities_js_1.getRandomId)();
-        const isBig = contents instanceof Uint8Array ? contents.length > __classPrivateFieldGet(_a, _a, "f", _FileManager_BIG_FILE_THRESHOLD) : true;
+        const poolSize = await this.#c.getUploadPoolSize();
+        const chunkSize = params?.chunkSize ?? _a.#UPLOAD_MAX_CHUNK_SIZE;
+        _a.validateChunkSize(chunkSize, _a.#UPLOAD_MAX_CHUNK_SIZE);
+        const mustTrackProgress = params?.progressId !== undefined;
+        const fileId = params?.progressId !== undefined ? BigInt(params.progressId) : (0, _1_utilities_js_1.getRandomId)();
+        const isBig = contents instanceof Uint8Array ? contents.length > _a.#BIG_FILE_THRESHOLD : true;
         const whatIsUploaded = contents instanceof Uint8Array ? (isBig ? "big file" : "file") + " of size " + size : "stream";
-        __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug("uploading " + whatIsUploaded + " with chunk size of " + chunkSize + " and pool size of " + poolSize + " and file ID of " + fileId);
+        this.#Lupload.debug("uploading " + whatIsUploaded + " with chunk size of " + chunkSize + " and pool size of " + poolSize + " and file ID of " + fileId);
         let result;
         if (contents instanceof Uint8Array) {
-            result = await __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_uploadBuffer).call(this, contents, fileId, chunkSize, poolSize, params?.signal);
+            result = await this.#uploadBuffer(contents, fileId, mustTrackProgress, chunkSize, poolSize, params?.signal);
         }
         else {
-            result = await __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_uploadStream).call(this, contents, fileId, chunkSize, poolSize, params?.signal);
+            result = await this.#uploadStream(contents, fileId, mustTrackProgress, chunkSize, poolSize, params?.signal);
         }
-        __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] uploaded ` + result.parts + " part(s)");
+        this.#Lupload.debug(`[${fileId}] uploaded ` + result.parts + " part(s)");
         if (result.small) {
             return { _: "inputFile", id: fileId, name, parts: result.parts, md5_checksum: "" };
         }
@@ -103,20 +121,222 @@ class FileManager {
             return { _: "inputFileBig", id: fileId, name, parts: result.parts };
         }
     }
+    async #uploadStream(stream, fileId, mustTrackProgress, chunkSize, poolSize, signal) {
+        let part;
+        let promises = new Array();
+        let ms = 0.05;
+        let uploaded = 0;
+        for await (part of (0, _1_utilities_js_1.iterateReadableStream)(stream.pipeThrough(new _1_utilities_js_1.PartStream(chunkSize)))) {
+            if (!part.small && part.part > 0) {
+                await (0, _0_deps_js_1.delay)(ms);
+                ms = Math.max(ms * .8, 0.003);
+            }
+            promises.push(this.#uploadPart(fileId, part.totalParts, !part.small, part.part, part.bytes, signal).then(() => {
+                if (mustTrackProgress) {
+                    uploaded += part.bytes.length;
+                    this.#c.handleUpdate({
+                        uploadProgress: {
+                            id: String(fileId),
+                            uploaded,
+                            total: 0,
+                        },
+                    });
+                }
+            }));
+            if (promises.length == poolSize * _0_utilities_js_1.UPLOAD_REQUEST_PER_CONNECTION) {
+                await Promise.all(promises);
+                promises = [];
+            }
+        }
+        await Promise.all(promises);
+        return { small: part.small, parts: part.totalParts };
+    }
+    async #uploadBuffer(buffer, fileId, mustTrackProgress, chunkSize, poolSize, signal) {
+        const isBig = buffer.byteLength > _a.#BIG_FILE_THRESHOLD;
+        const partCount = Math.ceil(buffer.byteLength / chunkSize);
+        let promises = new Array();
+        let started = false;
+        let ms = 0.05;
+        let uploaded = 0;
+        main: for (let part = 0; part < partCount;) {
+            for (let i = 0; i < poolSize; ++i) {
+                for (let i = 0; i < _0_utilities_js_1.UPLOAD_REQUEST_PER_CONNECTION; ++i) {
+                    const start = part * chunkSize;
+                    const end = start + chunkSize;
+                    const bytes = buffer.subarray(start, end);
+                    if (!bytes.length) {
+                        break main;
+                    }
+                    if (!started) {
+                        started = true;
+                    }
+                    else if (isBig && part > 0) {
+                        await (0, _0_deps_js_1.delay)(ms);
+                        ms = Math.max(ms * .8, 0.003);
+                    }
+                    promises.push(this.#uploadPart(fileId, partCount, isBig, part++, bytes, signal).then(() => {
+                        if (mustTrackProgress) {
+                            uploaded += bytes.length;
+                            this.#c.handleUpdate({
+                                uploadProgress: {
+                                    id: String(fileId),
+                                    uploaded,
+                                    total: buffer.length,
+                                },
+                            });
+                        }
+                    }));
+                    if (promises.length == poolSize * _0_utilities_js_1.UPLOAD_REQUEST_PER_CONNECTION) {
+                        await Promise.all(promises);
+                        promises = [];
+                    }
+                }
+            }
+            await Promise.all(promises);
+            promises = [];
+        }
+        await Promise.all(promises);
+        return { small: !isBig, parts: partCount };
+    }
+    async #uploadPart(fileId, partCount, isBig, index, bytes, signal) {
+        let retryIn = 1;
+        let errorCount = 0;
+        while (true) {
+            try {
+                signal?.throwIfAborted();
+                this.#Lupload.debug(`[${fileId}] uploading part ` + (index + 1));
+                if (isBig) {
+                    await this.#c.invoke({ _: "upload.saveBigFilePart", file_id: fileId, file_part: index, bytes: bytes, file_total_parts: partCount }, { type: "upload" });
+                }
+                else {
+                    await this.#c.invoke({ _: "upload.saveFilePart", file_id: fileId, bytes: bytes, file_part: index }, { type: "upload" });
+                }
+                this.#Lupload.debug(`[${fileId}] uploaded part ` + (index + 1));
+                break;
+            }
+            catch (err) {
+                signal?.throwIfAborted();
+                this.#Lupload.debug(`[${fileId}] failed to upload part ` + (index + 1));
+                ++errorCount;
+                if (errorCount > 20) {
+                    retryIn = 0;
+                    errorCount = 20;
+                }
+                await this.#handleError(err, retryIn, `[${fileId}-${index + 1}]`);
+                retryIn += 2;
+                if (retryIn > 11) {
+                    retryIn = 11;
+                }
+            }
+        }
+    }
+    async #handleError(err, retryIn, logPrefix) {
+        if (retryIn > 0) {
+            this.#Lupload.warning(`${logPrefix} retrying in ${retryIn} seconds`);
+            await (0, _0_deps_js_1.delay)(retryIn * _0_deps_js_1.SECOND);
+        }
+        else {
+            throw err;
+        }
+    }
+    static async #getFileContents(source, params, allowStream) {
+        let name = params?.fileName?.trim() || "file";
+        let contents;
+        let size = -1;
+        if (source instanceof Uint8Array) {
+            contents = source;
+            size = source.byteLength;
+        }
+        else if (source instanceof ReadableStream) {
+            if (!allowStream) {
+                throw new _0_errors_js_1.InputError("Streamed upload not allowed.");
+            }
+            contents = source;
+        }
+        else if (typeof source === "object" && source != null && (Symbol.iterator in source || Symbol.asyncIterator in source)) {
+            if (!allowStream) {
+                throw new _0_errors_js_1.InputError("Streamed upload not allowed.");
+            }
+            contents = new ReadableStream({
+                pull: Symbol.asyncIterator in source
+                    ? async (controller) => {
+                        const { value, done } = await source.next();
+                        done ? controller.close() : controller.enqueue(value);
+                    }
+                    : (controller) => {
+                        const { value, done } = source.next();
+                        done ? controller.close() : controller.enqueue(value);
+                    },
+            });
+        }
+        else {
+            let url;
+            try {
+                url = new URL(source).toString();
+            }
+            catch {
+                let path_;
+                if (typeof source === "string") {
+                    if ((0, _0_deps_js_1.isAbsolute)(source)) {
+                        path_ = source;
+                    }
+                    else {
+                        // @ts-ignore: lib
+                        path_ = join(dntShim.Deno.cwd(), source);
+                    }
+                    url = (0, _0_deps_js_1.toFileUrl)(path_).toString();
+                    name = (0, _0_deps_js_1.basename)(path_);
+                }
+                else {
+                    (0, _0_deps_js_1.unreachable)();
+                }
+            }
+            const response = await fetch(url);
+            if (response.body == null) {
+                throw new _0_errors_js_1.InputError("Invalid response");
+            }
+            if (name == "file") {
+                const contentType = response.headers.get("content-type")?.split(";")[0].trim();
+                if (contentType) {
+                    name += (0, _0_deps_js_1.extension)(contentType);
+                }
+                else {
+                    const maybeFileName = new URL(response.url).pathname.split("/")
+                        .filter((v) => v)
+                        .slice(-1)[0]
+                        .trim();
+                    if (maybeFileName) {
+                        name += (0, _0_deps_js_1.extension)((0, _0_deps_js_1.extname)(maybeFileName));
+                    }
+                }
+            }
+            const contentLength = Number(response.headers.get("content-length"));
+            if (!isNaN(contentLength)) {
+                size = contentLength;
+            }
+            if (allowStream) {
+                contents = response.body;
+            }
+            else {
+                contents = new Uint8Array(await response.arrayBuffer());
+            }
+        }
+        return { size: params?.fileSize ? params.fileSize : size, name, contents };
+    }
     async *downloadInner(location, dcId, params) {
         const signal = params?.signal;
         signal?.throwIfAborted();
         const id = "id" in location ? location.id : "photo_id" in location ? location.photo_id : null;
-        if (id != null && __classPrivateFieldGet(this, _FileManager_c, "f").storage.supportsFiles) {
-            const file = await __classPrivateFieldGet(this, _FileManager_c, "f").storage.getFile(id);
+        if (id != null && this.#c.storage.supportsFiles) {
+            const file = await this.#c.storage.getFile(id);
             const partOffset = file == null ? 0 : params?.offset ? Math.ceil(10 / file[1]) - 1 : 0;
             if (file != null && file[0] > 0) {
-                yield* __classPrivateFieldGet(this, _FileManager_c, "f").storage.iterFileParts(id, file[0], partOffset, signal);
+                yield* this.#c.storage.iterFileParts(id, file[0], partOffset, signal);
                 return;
             }
         }
-        const chunkSize = params?.chunkSize ?? __classPrivateFieldGet(_a, _a, "f", _FileManager_DOWNLOAD_MAX_CHUNK_SIZE);
-        _a.validateChunkSize(chunkSize, __classPrivateFieldGet(_a, _a, "f", _FileManager_DOWNLOAD_MAX_CHUNK_SIZE));
+        const chunkSize = params?.chunkSize ?? _a.#DOWNLOAD_MAX_CHUNK_SIZE;
+        _a.validateChunkSize(chunkSize, _a.#DOWNLOAD_MAX_CHUNK_SIZE);
         if (params?.offset !== undefined) {
             _a.validateOffset(params.offset);
         }
@@ -131,18 +351,18 @@ class FileManager {
             let retryIn = 1;
             let errorCount = 0;
             try {
-                const file = await __classPrivateFieldGet(this, _FileManager_c, "f").invoke({ _: "upload.getFile", location, offset, limit }, { dc, type: "download" });
+                const file = await this.#c.invoke({ _: "upload.getFile", location, offset, limit }, { dc, type: "download" });
                 signal?.throwIfAborted();
                 if (_2_tl_js_1.Api.is("upload.file", file)) {
                     yield file.bytes;
                     if (id != null) {
-                        await __classPrivateFieldGet(this, _FileManager_c, "f").storage.saveFilePart(id, part, file.bytes);
+                        await this.#c.storage.saveFilePart(id, part, file.bytes);
                         signal?.throwIfAborted();
                     }
                     ++part;
                     if (file.bytes.length < limit) {
                         if (id != null) {
-                            await __classPrivateFieldGet(this, _FileManager_c, "f").storage.setFilePartCount(id, part + 1, chunkSize);
+                            await this.#c.storage.setFilePartCount(id, part + 1, chunkSize);
                             signal?.throwIfAborted();
                         }
                         break;
@@ -166,7 +386,7 @@ class FileManager {
                     retryIn = 0;
                     errorCount = 0;
                 }
-                await __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_handleError).call(this, err, retryIn, `[${id}-${part + 1}]`);
+                await this.#handleError(err, retryIn, `[${id}-${part + 1}]`);
                 signal?.throwIfAborted();
                 retryIn += 2;
                 if (retryIn > 11) {
@@ -209,7 +429,7 @@ class FileManager {
                         (0, _0_deps_js_1.unreachable)();
                     }
                     const big = fileId_.location.source.type == _3_types_js_1.PhotoSourceType.ChatPhotoBig;
-                    const peer = await __classPrivateFieldGet(this, _FileManager_c, "f").getInputPeer(Number(fileId_.location.source.chatId));
+                    const peer = await this.#c.getInputPeer(Number(fileId_.location.source.chatId));
                     const location = { _: "inputPeerPhotoFileLocation", big: big ? true : undefined, peer, photo_id: fileId_.location.id };
                     yield* this.downloadInner(location, fileId_.dcId, params);
                     break;
@@ -253,17 +473,28 @@ class FileManager {
         }
     }
     async getStickerSetName(inputStickerSet, hash = 0) {
-        const maybeStickerSetName = await __classPrivateFieldGet(this, _FileManager_c, "f").messageStorage.getStickerSetName(inputStickerSet.id, inputStickerSet.access_hash);
+        const maybeStickerSetName = await this.#c.messageStorage.getStickerSetName(inputStickerSet.id, inputStickerSet.access_hash);
         if (maybeStickerSetName != null && Date.now() - maybeStickerSetName[1].getTime() < _4_constants_js_1.STICKER_SET_NAME_TTL) {
             return maybeStickerSetName[0];
         }
         else {
-            const stickerSet = await __classPrivateFieldGet(this, _FileManager_c, "f").invoke({ _: "messages.getStickerSet", stickerset: inputStickerSet, hash });
-            const name = _2_tl_js_1.Api.as("messages.stickerSet", stickerSet).set.short_name;
-            await __classPrivateFieldGet(this, _FileManager_c, "f").messageStorage.updateStickerSetName(inputStickerSet.id, inputStickerSet.access_hash, name);
-            return name;
+            try {
+                const stickerSet = await this.#c.invoke({ _: "messages.getStickerSet", stickerset: inputStickerSet, hash });
+                const name = _2_tl_js_1.Api.as("messages.stickerSet", stickerSet).set.short_name;
+                await this.#c.messageStorage.updateStickerSetName(inputStickerSet.id, inputStickerSet.access_hash, name);
+                return name;
+            }
+            catch (err) {
+                if (err instanceof _4_errors_js_1.StickersetInvalid) {
+                    return undefined;
+                }
+                else {
+                    throw err;
+                }
+            }
         }
     }
+    static #CUSTOM_EMOJI_TTL = 30 * _0_deps_js_1.MINUTE;
     async getCustomEmojiStickers(id) {
         id = Array.isArray(id) ? id : [id];
         if (!id.length) {
@@ -272,8 +503,8 @@ class FileManager {
         const stickers = new Array();
         let shouldFetch = false;
         for (const id_ of id) {
-            const maybeDocument = await __classPrivateFieldGet(this, _FileManager_c, "f").messageStorage.getCustomEmojiDocument(BigInt(id_));
-            if (maybeDocument != null && Date.now() - maybeDocument[1].getTime() <= __classPrivateFieldGet(_a, _a, "f", _FileManager_CUSTOM_EMOJI_TTL)) {
+            const maybeDocument = await this.#c.messageStorage.getCustomEmojiDocument(BigInt(id_));
+            if (maybeDocument != null && Date.now() - maybeDocument[1].getTime() <= _a.#CUSTOM_EMOJI_TTL) {
                 const document_ = maybeDocument[0];
                 const fileId_ = {
                     type: _3_types_js_1.FileType.Document,
@@ -294,9 +525,9 @@ class FileManager {
         if (!shouldFetch) {
             return stickers;
         }
-        const documents_ = (await __classPrivateFieldGet(this, _FileManager_c, "f").invoke({ _: "messages.getCustomEmojiDocuments", document_id: id.map(BigInt) })).map((v) => _2_tl_js_1.Api.as("document", v));
+        const documents_ = (await this.#c.invoke({ _: "messages.getCustomEmojiDocuments", document_id: id.map(BigInt) })).map((v) => _2_tl_js_1.Api.as("document", v));
         for (const [i, document_] of documents_.entries()) {
-            await __classPrivateFieldGet(this, _FileManager_c, "f").messageStorage.setCustomEmojiDocument(document_.id, document_);
+            await this.#c.messageStorage.setCustomEmojiDocument(document_.id, document_);
             const fileId_ = {
                 type: _3_types_js_1.FileType.Document,
                 dcId: document_.dc_id,
@@ -312,181 +543,4 @@ class FileManager {
     }
 }
 exports.FileManager = FileManager;
-_a = FileManager, _FileManager_c = new WeakMap(), _FileManager_Lupload = new WeakMap(), _FileManager_instances = new WeakSet(), _FileManager_uploadStream = async function _FileManager_uploadStream(stream, fileId, chunkSize, poolSize, signal) {
-    let part;
-    let promises = new Array();
-    let ms = 0.05;
-    for await (part of (0, _1_utilities_js_1.iterateReadableStream)(stream.pipeThrough(new _1_utilities_js_1.PartStream(chunkSize)))) {
-        if (!part.small && part.part > 0) {
-            await (0, _0_deps_js_1.delay)(ms);
-            ms = Math.max(ms * .8, 0.003);
-        }
-        promises.push(__classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_uploadPart).call(this, fileId, part.totalParts, !part.small, part.part, part.bytes, signal));
-        if (promises.length == poolSize * _0_utilities_js_1.UPLOAD_REQUEST_PER_CONNECTION) {
-            await Promise.all(promises);
-            promises = [];
-        }
-    }
-    await Promise.all(promises);
-    return { small: part.small, parts: part.totalParts };
-}, _FileManager_uploadBuffer = async function _FileManager_uploadBuffer(buffer, fileId, chunkSize, poolSize, signal) {
-    const isBig = buffer.byteLength > __classPrivateFieldGet(_a, _a, "f", _FileManager_BIG_FILE_THRESHOLD);
-    const partCount = Math.ceil(buffer.byteLength / chunkSize);
-    let promises = new Array();
-    let started = false;
-    let ms = 0.05;
-    main: for (let part = 0; part < partCount;) {
-        for (let i = 0; i < poolSize; ++i) {
-            for (let i = 0; i < _0_utilities_js_1.UPLOAD_REQUEST_PER_CONNECTION; ++i) {
-                const start = part * chunkSize;
-                const end = start + chunkSize;
-                const bytes = buffer.subarray(start, end);
-                if (!bytes.length) {
-                    break main;
-                }
-                if (!started) {
-                    started = true;
-                }
-                else if (isBig && part > 0) {
-                    await (0, _0_deps_js_1.delay)(ms);
-                    ms = Math.max(ms * .8, 0.003);
-                }
-                promises.push(__classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_uploadPart).call(this, fileId, partCount, isBig, part++, bytes, signal));
-                if (promises.length == poolSize * _0_utilities_js_1.UPLOAD_REQUEST_PER_CONNECTION) {
-                    await Promise.all(promises);
-                    promises = [];
-                }
-            }
-        }
-        await Promise.all(promises);
-        promises = [];
-    }
-    await Promise.all(promises);
-    return { small: !isBig, parts: partCount };
-}, _FileManager_uploadPart = async function _FileManager_uploadPart(fileId, partCount, isBig, index, bytes, signal) {
-    let retryIn = 1;
-    let errorCount = 0;
-    while (true) {
-        try {
-            signal?.throwIfAborted();
-            __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] uploading part ` + (index + 1));
-            if (isBig) {
-                await __classPrivateFieldGet(this, _FileManager_c, "f").invoke({ _: "upload.saveBigFilePart", file_id: fileId, file_part: index, bytes: bytes, file_total_parts: partCount }, { type: "upload" });
-            }
-            else {
-                await __classPrivateFieldGet(this, _FileManager_c, "f").invoke({ _: "upload.saveFilePart", file_id: fileId, bytes: bytes, file_part: index }, { type: "upload" });
-            }
-            __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] uploaded part ` + (index + 1));
-            break;
-        }
-        catch (err) {
-            signal?.throwIfAborted();
-            __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] failed to upload part ` + (index + 1));
-            ++errorCount;
-            if (errorCount > 20) {
-                retryIn = 0;
-                errorCount = 20;
-            }
-            await __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_handleError).call(this, err, retryIn, `[${fileId}-${index + 1}]`);
-            retryIn += 2;
-            if (retryIn > 11) {
-                retryIn = 11;
-            }
-        }
-    }
-}, _FileManager_handleError = async function _FileManager_handleError(err, retryIn, logPrefix) {
-    if (retryIn > 0) {
-        __classPrivateFieldGet(this, _FileManager_Lupload, "f").warning(`${logPrefix} retrying in ${retryIn} seconds`);
-        await (0, _0_deps_js_1.delay)(retryIn * _0_deps_js_1.SECOND);
-    }
-    else {
-        throw err;
-    }
-}, _FileManager_getFileContents = async function _FileManager_getFileContents(source, params, allowStream) {
-    let name = params?.fileName?.trim() || "file";
-    let contents;
-    let size = -1;
-    if (source instanceof Uint8Array) {
-        contents = source;
-        size = source.byteLength;
-    }
-    else if (source instanceof ReadableStream) {
-        if (!allowStream) {
-            throw new _0_errors_js_1.InputError("Streamed upload not allowed.");
-        }
-        contents = source;
-    }
-    else if (typeof source === "object" && source != null && (Symbol.iterator in source || Symbol.asyncIterator in source)) {
-        if (!allowStream) {
-            throw new _0_errors_js_1.InputError("Streamed upload not allowed.");
-        }
-        contents = new ReadableStream({
-            pull: Symbol.asyncIterator in source
-                ? async (controller) => {
-                    const { value, done } = await source.next();
-                    done ? controller.close() : controller.enqueue(value);
-                }
-                : (controller) => {
-                    const { value, done } = source.next();
-                    done ? controller.close() : controller.enqueue(value);
-                },
-        });
-    }
-    else {
-        let url;
-        try {
-            url = new URL(source).toString();
-        }
-        catch {
-            let path_;
-            if (typeof source === "string") {
-                if ((0, _0_deps_js_1.isAbsolute)(source)) {
-                    path_ = source;
-                }
-                else {
-                    // @ts-ignore: lib
-                    path_ = join(dntShim.Deno.cwd(), source);
-                }
-                url = (0, _0_deps_js_1.toFileUrl)(path_).toString();
-                name = (0, _0_deps_js_1.basename)(path_);
-            }
-            else {
-                (0, _0_deps_js_1.unreachable)();
-            }
-        }
-        const response = await fetch(url);
-        if (response.body == null) {
-            throw new _0_errors_js_1.InputError("Invalid response");
-        }
-        if (name == "file") {
-            const contentType = response.headers.get("content-type")?.split(";")[0].trim();
-            if (contentType) {
-                name += (0, _0_deps_js_1.extension)(contentType);
-            }
-            else {
-                const maybeFileName = new URL(response.url).pathname.split("/")
-                    .filter((v) => v)
-                    .slice(-1)[0]
-                    .trim();
-                if (maybeFileName) {
-                    name += (0, _0_deps_js_1.extension)((0, _0_deps_js_1.extname)(maybeFileName));
-                }
-            }
-        }
-        const contentLength = Number(response.headers.get("content-length"));
-        if (!isNaN(contentLength)) {
-            size = contentLength;
-        }
-        if (allowStream) {
-            contents = response.body;
-        }
-        else {
-            contents = new Uint8Array(await response.arrayBuffer());
-        }
-    }
-    return { size: params?.fileSize ? params.fileSize : size, name, contents };
-};
-_FileManager_UPLOAD_MAX_CHUNK_SIZE = { value: 512 * _1_utilities_js_1.kilobyte };
-_FileManager_DOWNLOAD_MAX_CHUNK_SIZE = { value: 1 * _1_utilities_js_1.megabyte };
-_FileManager_BIG_FILE_THRESHOLD = { value: 10 * _1_utilities_js_1.megabyte };
-_FileManager_CUSTOM_EMOJI_TTL = { value: 30 * _0_deps_js_1.MINUTE };
+_a = FileManager;

package/script/client/2_file_manager_test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"2_file_manager_test.d.ts","sourceRoot":"","sources":["../../src/client/2_file_manager_test.ts"],"names":[],"mappings":""}
+{"version":3,"file":"2_file_manager_test.d.ts","sourceRoot":"","sources":["../../src/client/2_file_manager_test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,2BAA2B,CAAC"}