@e-mc/file-manager 0.5.3 → 0.7.0

package/index.js

@@ -36,7 +36,7 @@ const CACHE_ETAG = {};
 const DISK = {
     ENABLED: false,
     EXPIRES: 0,
-    LIMIT: (0, types_1.formatSize)('1gb'),
+    LIMIT: (0, types_1.formatSize)("1gb" /* CACHE_SIZE.FILE_MANAGER_DISK_LIMIT */),
     INCLUDE: [],
     EXCLUDE: []
 };
@@ -46,8 +46,8 @@ const MEMORY = {
     SIZE: 0,
     TOTAL: 0,
     EXPIRES: 0,
-    LIMIT: (0, types_1.formatSize)('100mb'),
-    LIMIT_ALL: (0, types_1.formatSize)('512mb'),
+    LIMIT: (0, types_1.formatSize)("100mb" /* CACHE_SIZE.FILE_MANAGER_MEMORY_LIMIT */),
+    LIMIT_ALL: (0, types_1.formatSize)("512mb" /* CACHE_SIZE.FILE_MANAGER_MEMORY_LIMIT_ALL */),
     INCLUDE: [],
     EXCLUDE: [],
     PURGE: 0.25,
@@ -126,6 +126,76 @@ function resetAssets() {
     this.reset();
     FileManager.sanitizeAssets(this.assets);
 }
+function recurseDir(output, subDirs, options) {
+    const { ignore, sortBy, recursive } = options;
+    const items = fs.readdirSync(path.join(...subDirs), { withFileTypes: true })
+        .filter(item => item.name)
+        .sort((a, b) => {
+        if (sortBy > 0) {
+            if (a.isDirectory() && !b.isDirectory()) {
+                return sortBy & 1 /* READDIR_SORT.DIRECTORY */ ? -1 : 1;
+            }
+            if (!a.isDirectory() && b.isDirectory()) {
+                return sortBy & 1 /* READDIR_SORT.DIRECTORY */ ? 1 : -1;
+            }
+        }
+        return (a.name < b.name ? -1 : 1) * (2 /* READDIR_SORT.DESCENDING */ & 2 ? -1 : 1);
+    });
+    for (const item of items) {
+        if (!item.isDirectory()) {
+            const pathname = path.join(item.path, item.name);
+            if (!ignore.includes(pathname)) {
+                output.push(pathname);
+            }
+        }
+        else if (recursive) {
+            recurseDir(output, subDirs.concat(item.name), options);
+        }
+    }
+    return output;
+}
+function checkHash(data, fromBuffer, options) {
+    if (options) {
+        let algorithm, digest, value;
+        if ((0, types_1.isObject)(options)) {
+            ({ algorithm, digest, value } = options);
+        }
+        else {
+            value = options;
+        }
+        if ((0, types_1.isString)(value)) {
+            if (!fromBuffer) {
+                try {
+                    data = fs.readFileSync(data);
+                }
+                catch {
+                    return false;
+                }
+            }
+            return value === core_1.Host.asHash(data, { algorithm, digest });
+        }
+    }
+    return true;
+}
+function filterPaths(values, include, exclude) {
+    if (include) {
+        if ((0, types_1.isString)(include)) {
+            include = [include];
+        }
+        if ((0, types_1.isArray)(include)) {
+            return values.filter(value => core_1.Permission.match(value, include));
+        }
+    }
+    if (exclude) {
+        if ((0, types_1.isString)(exclude)) {
+            exclude = [exclude];
+        }
+        if ((0, types_1.isArray)(exclude)) {
+            return values.filter(value => !core_1.Permission.match(value, exclude));
+        }
+    }
+    return values;
+}
 function abortedHost() {
     if (this.finalizeState === 6 /* FINALIZE_STATE.ABORTED */) {
         this.restarting = false;
@@ -195,6 +265,8 @@ function collectErrors() {
 function rejectModule(err, type, hint) {
     this.writeFail(["Handled rejection" /* ERR_MESSAGE.HANDLED_REJECTION */, this.moduleName + (hint ? ': ' + hint : '')], err, type);
 }
+const checksumFile = (algorithm) => "checksum" /* HASH_OUTPUT.FILENAME */ + '.' + ((0, types_1.isString)(algorithm) ? algorithm.toLowerCase() : "sha256" /* HASH_OUTPUT.ALGORITHM */);
+const checksumError = (algorithm) => new Error("Invalid parameters" /* ERR_MESSAGE.PARAMETERS */ + ` (${algorithm || "sha256" /* HASH_OUTPUT.ALGORITHM */})`);
 const isFunction = (value) => typeof value === 'function';
 const ignoreAsset = (item, exists) => item.invalid || (0, types_1.hasBit)(item.flags, 1 /* ASSET_FLAG.IGNORE */ | (!exists ? 128 /* ASSET_FLAG.EXISTS */ : 0));
 class HttpDiskCache {
@@ -557,6 +629,146 @@ class FileManager extends core_1.Host {
         });
         return assets;
     }
+    static async writeChecksum(root, to, options) {
+        if ((0, types_1.isObject)(to)) {
+            options = to;
+            to = undefined;
+        }
+        else {
+            options || (options = {});
+        }
+        const { algorithm, digest, sortBy = 0, recursive = false, ignore = [], include, exclude, verbose = false, joinRoot } = options;
+        to || (to = checksumFile(algorithm));
+        let result = [];
+        try {
+            const filename = path.basename(to);
+            to = joinRoot ? path.join(root, to) : path.resolve(to);
+            recurseDir(result, [root], { ignore: [...ignore, to], sortBy, recursive });
+            const output = [];
+            for (const pathname of result = filterPaths(result, include, exclude)) {
+                if (recursive === 1 && path.basename(pathname) === filename) {
+                    continue;
+                }
+                const current = await this.readHash(pathname, { algorithm, digest }) + ' ' + (path.sep === '\\' ? pathname.replace(/\\/g, '/') : pathname).substring(root.length).replace(/^\//, '');
+                if (verbose) {
+                    process.stdout.write(current + '\n');
+                }
+                output.push(current);
+            }
+            if (output.length) {
+                fs.writeFileSync(to, output.join('\n'), 'utf-8');
+                options.outPath = to;
+            }
+            else {
+                if (this.isPath(to)) {
+                    fs.unlinkSync(to);
+                }
+                if (options.throwsEmpty) {
+                    throw checksumError(algorithm);
+                }
+            }
+        }
+        catch (err) {
+            if (options.throwsEmpty) {
+                throw err;
+            }
+            this.writeFail(["Unable to read directory" /* ERR_MESSAGE.READ_DIRECTORY */, root], err, 32 /* LOG_TYPE.FILE */);
+            return null;
+        }
+        return result;
+    }
+    static async verifyChecksum(root, from, options) {
+        if ((0, types_1.isObject)(from)) {
+            options = from;
+            from = undefined;
+        }
+        else {
+            options || (options = {});
+        }
+        const { algorithm, digest, sortBy = 0, recursive = false, ignore = [], include, exclude, verbose = true, joinRoot } = options;
+        const parent = recursive === 1 && typeof verbose !== 'number';
+        from || (from = checksumFile(algorithm));
+        let fail = [], missing = [];
+        try {
+            const filename = path.basename(from);
+            const files = [];
+            from = joinRoot ? path.join(root, filename) : path.resolve(from);
+            recurseDir(files, [root], { ignore: [...ignore, from], sortBy, recursive });
+            const items = fs.readFileSync(from, 'utf-8').split('\n').map(item => {
+                const index = item.indexOf(' ');
+                return [item.substring(0, index), path.join(root, item.substring(index + 1))];
+            });
+            const checked = include || exclude ? filterPaths(items.map(item => item[1]), include, exclude) : null;
+            let valid;
+            for (const [previous, pathname] of items) {
+                if (checked !== null && !checked.includes(pathname) || recursive === 1 && path.basename(pathname) === filename) {
+                    continue;
+                }
+                if (files.includes(pathname)) {
+                    const hash = await this.readHash(pathname, { algorithm, digest });
+                    if (hash !== previous) {
+                        fail.push(pathname);
+                    }
+                    else if (verbose) {
+                        process.stdout.write("+" /* SUMDIR_STATUS.PASS */ + ' ' + pathname + '\n');
+                    }
+                    valid = true;
+                }
+                else if (!ignore.includes(pathname)) {
+                    missing.push(pathname);
+                }
+            }
+            if (parent) {
+                const nested = files.filter(value => path.basename(value) === filename);
+                if (nested.length) {
+                    const current = items.map(item => item[1]);
+                    const tasks = nested.map(pathname => this.verifyChecksum(path.dirname(pathname), filename, { ...options, ignore: current, joinRoot: true, verbose: (verbose ? 1 : 0) }));
+                    await Promise.all(tasks).then(group => {
+                        for (const item of group) {
+                            if (item) {
+                                const [f, m] = item;
+                                if (f.length) {
+                                    fail.push(...f);
+                                }
+                                if (m.length) {
+                                    missing.push(...m);
+                                }
+                                valid = true;
+                            }
+                        }
+                    });
+                }
+            }
+            if (valid) {
+                options.outPath = from;
+            }
+            else if (options.throwsEmpty) {
+                throw checksumError(algorithm);
+            }
+        }
+        catch (err) {
+            if (options.throwsEmpty) {
+                throw err;
+            }
+            this.writeFail(["Unable to read directory" /* ERR_MESSAGE.READ_DIRECTORY */, root], err, 32 /* LOG_TYPE.FILE */);
+            return null;
+        }
+        if (parent) {
+            if (fail.length) {
+                fail = Array.from(new Set(fail));
+            }
+            if (missing.length) {
+                missing = Array.from(new Set(missing));
+            }
+        }
+        if (verbose === true) {
+            const max = Math.max(...fail.concat(missing).map(item => item.length));
+            const writeLog = (items, symbol) => items.forEach((value, index) => process.stdout.write(`${symbol} ${value.padEnd(max)} (${(index + 1).toString()})\n`));
+            writeLog(fail, "-" /* SUMDIR_STATUS.FAIL */);
+            writeLog(missing, "?" /* SUMDIR_STATUS.MISSING */);
+        }
+        return [fail, missing];
+    }
     static createFileThread(host, file) {
         return new FileThread(host, file, 0);
     }
@@ -2242,22 +2454,19 @@ class FileManager extends core_1.Host {
                 bundling[_l = file.uri] || (bundling[_l] = []);
                 if (bundleIndex > 0) {
                     items[bundleIndex - 1] = file;
-                    const url = file.url;
-                    if (file.fetchType === 1 /* FETCH_TYPE.HTTP */ && (cacheToDisk.has(url) || cacheToMemory.has(url))) {
-                        const parent = assets.find(item => item.bundleIndex === 0 && item.bundleId === bundleId);
-                        if (parent) {
-                            (parent.bundleQueue || (parent.bundleQueue = [])).push(new Promise(resolve => {
-                                this.Request.open(url, { method: 'HEAD', httpVersion: 1 })
-                                    .on('response', res => {
-                                    if (res.statusCode < 300 /* HTTP_STATUS.MULTIPLE_CHOICES */) {
-                                        applyHeaders(file, res.headers);
-                                    }
-                                    resolve(file);
-                                })
-                                    .on('error', () => resolve(file))
-                                    .on('timeout', () => resolve(file));
-                            }));
-                        }
+                    let url, parent;
+                    if (file.fetchType === 1 /* FETCH_TYPE.HTTP */ && (cacheToDisk.has(url = file.url) || cacheToMemory.has(url)) && (parent = assets.find(item => item.bundleIndex === 0 && item.bundleId === bundleId))) {
+                        (parent.bundleQueue || (parent.bundleQueue = [])).push(new Promise(resolve => {
+                            this.Request.open(url, { method: 'HEAD', httpVersion: 1 })
+                                .on('response', res => {
+                                if (res.statusCode < 300 /* HTTP_STATUS.MULTIPLE_CHOICES */) {
+                                    applyHeaders(file, res.headers);
+                                }
+                                resolve(file);
+                            })
+                                .on('error', () => resolve(file))
+                                .on('timeout', () => resolve(file));
+                        }));
                     }
                     return true;
                 }
@@ -2322,9 +2531,10 @@ class FileManager extends core_1.Host {
             completed[localUri] = file;
             if (!(0, types_1.isEmpty)(file.bundleId) && file.bundleIndex === 0) {
                 this.setAssetContent(file, this.getUTF8String(file, localUri));
+                const bundleQueue = file.bundleQueue;
                 let success = true, error, checkEtag = !file.trailingContent && hasEtag(file);
-                if (file.bundleQueue) {
-                    error = await Promise.all(file.bundleQueue).then(() => null).catch((err) => err);
+                if (bundleQueue) {
+                    error = await Promise.all(bundleQueue).then(() => null).catch((err) => err);
                     delete file.bundleQueue;
                 }
                 const items = appending[localUri];
@@ -2584,6 +2794,10 @@ class FileManager extends core_1.Host {
             return true;
         };
         const fileReceived = (item, localUri, err, fetched, binary) => {
+            if (item.checksum && !err && !checkHash(item.buffer || localUri, !!item.buffer, item.checksum)) {
+                err = (0, types_1.errorValue)("Checksum did not match" /* ERR_MESSAGE.FAILED_CHECKSUM */, item.uri);
+                this.filesToRemove.add(localUri);
+            }
             if (err) {
                 item.invalid = true;
                 this.completeAsyncTask(err, localUri);
@@ -2607,8 +2821,9 @@ class FileManager extends core_1.Host {
             if (item.invalid || (0, types_1.ignoreFlag)(item.flags)) {
                 continue;
             }
-            if (!item.filename) {
-                if (!(item.uri && core_1.Host.isFile(item.uri, 'torrent'))) {
+            let { filename, uri } = item;
+            if (!filename) {
+                if (!(uri && core_1.Host.isFile(uri, 'torrent'))) {
                     item.invalid = true;
                     continue;
                 }
@@ -2640,13 +2855,13 @@ class FileManager extends core_1.Host {
                     item.incremental = undefined;
                 }
             }
-            if (valid && item.filename) {
-                let uri = item.uri, cached;
+            if (valid && filename) {
                 const etag = (cacheEtag && type !== 'exists' || type === 'etag') && !!uri;
                 if (etag && imported.some(file => file.imported.includes(uri))) {
                     item.incremental = 'none';
                 }
                 else if (!(0, types_1.mainFlag)(item.flags)) {
+                    let cached;
                     const { bundleId, bundleIndex = -1 } = item;
                     const setBuffer = (target) => {
                         if (!etag && (uri = target.uri) && (cached = MEMORY.CACHE[uri])) {
@@ -2691,7 +2906,7 @@ class FileManager extends core_1.Host {
                         if (!cached) {
                             setBuffer(item);
                         }
-                        if (core_1.Host.isPath(localUri)) {
+                        if (core_1.Host.isPath(localUri) && (!item.checksumOutput || checkHash(localUri, false, item.checksumOutput))) {
                             item.flags |= 128 /* ASSET_FLAG.EXISTS */;
                             if (!etag || item.fetchType !== 1 /* FETCH_TYPE.HTTP */) {
                                 if (!(0, types_1.isEmpty)(bundleId) && bundleIndex === 0) {
@@ -2709,13 +2924,15 @@ class FileManager extends core_1.Host {
                         else if (cached) {
                             try {
                                 const buffer = cached[1];
-                                fs.writeFileSync(localUri, buffer);
-                                if (item.willChange && Buffer.isBuffer(buffer)) {
-                                    item.buffer = buffer;
+                                if (!item.checksum || checkHash(buffer, true, item.checksum)) {
+                                    fs.writeFileSync(localUri, buffer);
+                                    if (item.willChange && Buffer.isBuffer(buffer)) {
+                                        item.buffer = buffer;
+                                    }
+                                    this.performAsyncTask();
+                                    fileReceived(item, localUri, null, true);
+                                    continue;
                                 }
-                                this.performAsyncTask();
-                                fileReceived(item, localUri, null, true);
-                                continue;
                             }
                             catch {
                             }
@@ -2726,13 +2943,12 @@ class FileManager extends core_1.Host {
                     try {
                         const buffer = fs.readFileSync(localUri);
                         if (!etag) {
-                            (0, asset_1.setInitialValue)(item, false);
-                            item.initialValue.buffer = buffer;
+                            (0, asset_1.setInitialValue)(item, false).buffer = buffer;
                         }
                         else if (uri && CACHE_ETAG[uri]) {
-                            (0, asset_1.setInitialValue)(item, false);
-                            item.initialValue.buffer = buffer;
-                            item.initialValue.etag = CACHE_ETAG[uri];
+                            const initialValue = (0, asset_1.setInitialValue)(item, false);
+                            initialValue.buffer = buffer;
+                            initialValue.etag = CACHE_ETAG[uri];
                         }
                     }
                     catch {
@@ -2753,12 +2969,12 @@ class FileManager extends core_1.Host {
                 break;
             }
             const { pathname, localUri } = download;
-            let uri;
             if (item.content) {
                 if (!checkQueue(item, localUri, pathname, true)) {
-                    item.sourceUTF8 = item.content;
+                    const content = item.content;
+                    item.sourceUTF8 = content;
                     this.performAsyncTask();
-                    fs.writeFile(localUri, item.content, item.encoding || (item.encoding = 'utf-8'), err => fileReceived(item, localUri, err));
+                    fs.writeFile(localUri, content, item.encoding || (item.encoding = 'utf-8'), err => fileReceived(item, localUri, err));
                 }
             }
             else if (item.dataView) {
@@ -2779,18 +2995,22 @@ class FileManager extends core_1.Host {
                     fs.writeFile(localUri, item.base64, 'base64', err => fileReceived(item, localUri, err, false, true));
                 }
             }
-            else if (uri = item.uri) {
+            else {
+                const uri = item.uri;
+                if (!uri) {
+                    item.invalid = true;
+                    continue;
+                }
                 const checkDest = (src) => staging || !(0, lib_v4_1.hasSameStat)(src, localUri);
-                const type = item.fetchType;
+                const type = item.fetchType || 0 /* FETCH_TYPE.UNKNOWN */;
                 const bundleMain = !(0, types_1.isEmpty)(item.bundleId) && item.bundleIndex === 0;
-                let isHttp;
-                if ((isHttp = type === 1 /* FETCH_TYPE.HTTP */) || type === 2 /* FETCH_TYPE.UNIX_SOCKET */) {
-                    const url = item.url;
-                    const checkEtag = hasEtag(item);
+                const isHttp = type === 1 /* FETCH_TYPE.HTTP */;
+                if (isHttp || type === 2 /* FETCH_TYPE.UNIX_SOCKET */) {
+                    let checkEtag;
                     if ((0, types_1.isEmpty)(item.bundleId) && bundling[uri]) {
                         bundling[uri].push(item);
                     }
-                    else if (checkEtag || !checkQueue(item, localUri, pathname)) {
+                    else if ((checkEtag = hasEtag(item)) || !checkQueue(item, localUri, pathname)) {
                         if (!isHttp && !checkDest(uri)) {
                             fileReceived(item, localUri);
                         }
@@ -2804,6 +3024,7 @@ class FileManager extends core_1.Host {
                             if (!checkEtag) {
                                 downloading[uri] = [];
                             }
+                            const url = item.url;
                             let cacheDir, cacheBuffer, mainEtag, encoding = item.encoding, client = null;
                             if (isHttp) {
                                 cacheDir = cacheToDisk.has(url) && isCacheable(item);
@@ -3078,9 +3299,6 @@ class FileManager extends core_1.Host {
                     }
                 }
             }
-            else {
-                item.invalid = true;
-            }
         }
         this.cleared = true;
     }
@@ -3091,35 +3309,37 @@ class FileManager extends core_1.Host {
         }
         const tasks = [];
         for (const item of assets) {
-            if (image_1.default.isBinary(item.mimeType)) {
-                const localUri = item.localUri;
-                const files = [localUri];
-                if (item.transforms) {
-                    files.push(...item.transforms);
-                }
-                const format = item.mimeType.split('/').pop();
-                for (const file of files) {
-                    if (this.has(file)) {
-                        const output = item.compress.filter(({ condition }) => !condition || withinSizeRange(file, condition));
-                        if (output.length) {
-                            const found = output.filter(value => value.format === format);
-                            for (const config of found.length ? found : output) {
-                                const options = { ...config };
-                                options.timeout = this[kProcessTimeout].compress ?? PROCESS_TIMEOUT.compress;
-                                options.proxyUrl = (uri) => {
-                                    const proxy = this.Request.proxyOf(uri);
-                                    return proxy ? proxy.host.href : '';
-                                };
-                                tasks.push(compress.tryImage(item.buffer && files.length === 1 ? item.buffer : file, file, options)
-                                    .then(result => {
-                                    if (result instanceof Buffer && file === localUri) {
-                                        item.buffer = result;
-                                    }
-                                })
-                                    .catch(err => this.writeFail(["Unable to compress file" /* ERR_MESSAGE.COMPRESS_FILE */, path.basename(file)], err, { type: 8 /* LOG_TYPE.COMPRESS */, startTime: options.startTime })));
-                            }
+            const localUri = item.localUri;
+            if (!(localUri && image_1.default.isBinary(item.mimeType))) {
+                continue;
+            }
+            const files = [localUri];
+            if (item.transforms) {
+                files.push(...item.transforms);
+            }
+            const format = item.mimeType.split('/').pop();
+            for (const file of files) {
+                const output = item.compress.filter(({ condition }) => !condition || withinSizeRange(file, condition));
+                if (!(output.length && this.has(file))) {
+                    continue;
+                }
+                const found = output.filter(value => value.format === format);
+                for (const config of found.length ? found : output) {
+                    const options = {
+                        ...config,
+                        timeout: this[kProcessTimeout].compress ?? PROCESS_TIMEOUT.compress,
+                        proxyUrl: (uri) => {
+                            const proxy = this.Request.proxyOf(uri);
+                            return proxy ? proxy.host.href : '';
                         }
-                    }
+                    };
+                    tasks.push(compress.tryImage(item.buffer && files.length === 1 ? item.buffer : file, file, options)
+                        .then(result => {
+                        if (result instanceof Buffer && file === localUri) {
+                            item.buffer = result;
+                        }
+                    })
+                        .catch(err => this.writeFail(["Unable to compress file" /* ERR_MESSAGE.COMPRESS_FILE */, path.basename(file)], err, { type: 8 /* LOG_TYPE.COMPRESS */, startTime: options.startTime })));
                 }
             }
         }
@@ -3132,7 +3352,7 @@ class FileManager extends core_1.Host {
             if (constructor.finalize && instance.assets.length) {
                 await constructor.finalize.call(this, instance).catch(err => rejectModule.call(instance, err, 4 /* LOG_TYPE.PROCESS */));
                 if (this.aborted) {
-                    break;
+                    return;
                 }
             }
         }
@@ -3144,25 +3364,17 @@ class FileManager extends core_1.Host {
                 if (items.length) {
                     await (constructor.using || constructor.finalize).call(this, instance, items).catch(err => rejectModule.call(instance, err, 4 /* LOG_TYPE.PROCESS */));
                     if (this.aborted) {
-                        break;
+                        return;
                     }
                 }
             }
         }
     }
-    async finalizeCloud() {
-        if (this.Cloud) {
-            return cloud_1.default.finalize.call(this, this.Cloud).catch(err => rejectModule.call(this.Cloud, err, 64 /* LOG_TYPE.CLOUD */));
-        }
+    finalizeCloud() {
+        const cloud = this.Cloud;
+        return cloud ? cloud_1.default.finalize.call(this, cloud).catch(err => rejectModule.call(cloud, err, 64 /* LOG_TYPE.CLOUD */)) : Promise.resolve();
     }
     async finalizeCleanup() {
-        if (this.Compress) {
-            const tasks = [];
-            this.assets.forEach(item => item.compress && !ignoreAsset(item, true) && tasks.push(this.compressFile(item, false)));
-            if (tasks.length) {
-                await Promise.allSettled(tasks);
-            }
-        }
         if (this.emptyDir.size) {
             for (const value of Array.from(this.emptyDir).reverse()) {
                 try {
@@ -3236,11 +3448,54 @@ class FileManager extends core_1.Host {
             return Promise.reject((0, types_1.createAbortError)());
         }
         removeFiles();
+        for (const item of this.assets) {
+            if (item.checksumOutput && !ignoreAsset(item)) {
+                const localUri = item.localUri;
+                if (!checkHash(localUri, false, item.checksumOutput)) {
+                    item.invalid = true;
+                    filesToRemove.add(localUri);
+                    this.writeFail(["Invalid checksum" /* ERR_MESSAGE.CHECKSUM */, path.basename(localUri)], (0, types_1.errorValue)("Checksum did not match" /* ERR_MESSAGE.FAILED_CHECKSUM */, localUri), { type: 32 /* LOG_TYPE.FILE */, startTime });
+                }
+            }
+        }
+        removeFiles();
         await this.finalizeCloud().catch(err => rejectModule.call(this, err, 64 /* LOG_TYPE.CLOUD */));
         if (this.aborted) {
             return Promise.reject((0, types_1.createAbortError)());
         }
         removeFiles();
+        if (this.Compress) {
+            const tasks = [];
+            this.assets.forEach(item => item.compress && !ignoreAsset(item, true) && tasks.push(this.compressFile(item, false)));
+            if (tasks.length) {
+                await Promise.allSettled(tasks);
+            }
+        }
+        let checksum = this.config.checksum;
+        if (checksum) {
+            if (typeof checksum === 'boolean' || checksum === 1) {
+                checksum = { recursive: checksum };
+            }
+            else if ((0, types_1.isString)(checksum)) {
+                const items = checksum.split('.');
+                checksum = items.length > 1 ? { algorithm: items[items.length - 1], filename: checksum } : { algorithm: checksum };
+            }
+            if ((0, types_1.isPlainObject)(checksum)) {
+                const baseDirectory = this.baseDirectory;
+                checksum.joinRoot = true;
+                checksum.throwsEmpty = true;
+                const sumTime = LOG_TIMEELAPSED ? process.hrtime() : 0;
+                try {
+                    const files = (await FileManager.writeChecksum(baseDirectory, checksum.filename, checksum));
+                    if (sumTime) {
+                        this.writeTimeElapsed(checksum.algorithm || "sha256" /* HASH_OUTPUT.ALGORITHM */, [baseDirectory, files.length + (files.length === 1 ? ' file' : ' files')], sumTime, { ...core_1.Host.LOG_STYLE_WARN });
+                    }
+                }
+                catch (err) {
+                    this.writeFail(["Unable to read directory" /* ERR_MESSAGE.READ_DIRECTORY */, path.basename(baseDirectory)], err, { type: 32 /* LOG_TYPE.FILE */, startTime });
+                }
+            }
+        }
         await this.finalizeCleanup().catch(err => rejectModule.call(this, err, 1 /* LOG_TYPE.SYSTEM */));
         removeFiles();
         if (LOG_TIMEELAPSED) {
@@ -3248,7 +3503,7 @@ class FileManager extends core_1.Host {
             const errorCount = this.errorCount;
             const message = [];
             if (errorCount) {
-                message.push(`ERROR ${errorCount}`);
+                message.push('ERROR ' + errorCount); // eslint-disable-line @typescript-eslint/no-base-to-string
             }
             let [size, count] = h;
             if (count) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/file-manager",
-  "version": "0.5.3",
+  "version": "0.7.0",
   "description": "FileManager constructor for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,14 +20,14 @@
   "license": "BSD 3-Clause",
   "homepage": "https://github.com/anpham6/e-mc#readme",
   "dependencies": {
-    "@e-mc/cloud": "0.5.3",
-    "@e-mc/compress": "0.5.3",
-    "@e-mc/core": "0.5.3",
-    "@e-mc/document": "0.5.3",
-    "@e-mc/image": "0.5.3",
-    "@e-mc/request": "0.5.3",
-    "@e-mc/task": "0.5.3",
-    "@e-mc/types": "0.5.3",
-    "@e-mc/watch": "0.5.3"
+    "@e-mc/cloud": "0.7.0",
+    "@e-mc/compress": "0.7.0",
+    "@e-mc/core": "0.7.0",
+    "@e-mc/document": "0.7.0",
+    "@e-mc/image": "0.7.0",
+    "@e-mc/request": "0.7.0",
+    "@e-mc/task": "0.7.0",
+    "@e-mc/types": "0.7.0",
+    "@e-mc/watch": "0.7.0"
   }
 }