@datatruck/cli 0.27.0 → 0.29.0

package/utils/DataFormat.js

@@ -3,21 +3,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataFormat = void 0;
+exports.DataFormat = exports.dataFormats = void 0;
 const AppError_1 = require("../Error/AppError");
-const cli_table3_1 = __importDefault(require("cli-table3"));
+const stream_1 = require("./stream");
+const tty_table_1 = __importDefault(require("tty-table"));
 const util_1 = require("util");
+exports.dataFormats = [
+    "json",
+    "list",
+    "pjson",
+    "table",
+    "yaml",
+    "custom",
+    "tpl",
+];
 const customPrefix = "custom=";
 const tplPrefix = "tpl=";
 class DataFormat {
     options;
+    streams;
     constructor(options) {
         this.options = options;
+        this.streams = (0, stream_1.createStreams)(options.streams);
+    }
+    getJson() {
+        return this.options.json;
     }
     formatToJson() {
-        return JSON.stringify(this.options.json
-            ? this.options.items.map(this.options.json)
-            : this.options.items);
+        return JSON.stringify(this.getJson());
     }
     formatToPrettyJson() {
         return (0, util_1.formatWithOptions)({
@@ -27,23 +40,32 @@ class DataFormat {
             maxStringLength: Infinity,
             breakLength: Infinity,
             compact: false,
-        }, this.options.items);
+        }, this.getJson());
     }
     formatToYaml() {
-        return require("yaml").stringify(this.options.items);
+        return require("yaml").stringify(this.getJson());
     }
     formatToTable() {
-        const table = new cli_table3_1.default({
-            head: this.options.table.labels,
-        });
-        for (const item of this.options.items)
-            table.push(this.options.table.handler(item));
-        return table.toString();
+        if (!this.options.table)
+            throw new Error(`Unsupported format: table`);
+        const table = (0, tty_table_1.default)(this.options.table.headers, this.options.table.rows(), {});
+        return table.render();
+    }
+    formatToList() {
+        if (!this.options.list)
+            throw new Error(`Unsupported format: list`);
+        return this.options.list().join("\n");
+    }
+    log(format, options) {
+        this.streams.stdout.write(`${this.format(format, options)}\n`);
     }
     format(format, options) {
         if (format === "table") {
             return this.formatToTable();
         }
+        else if (format === "list") {
+            return this.formatToList();
+        }
         else if (format === "json") {
             return this.formatToJson();
         }
@@ -55,7 +77,7 @@ class DataFormat {
         }
         else if (format.startsWith(customPrefix)) {
             const code = format.slice(customPrefix.length);
-            return runCustomCode(this.options.items, code);
+            return runCustomCode(this.getJson(), code);
         }
         else if (format.startsWith(tplPrefix)) {
             const name = format.slice(tplPrefix.length);

package/utils/cli.d.ts

@@ -1,15 +1,10 @@
 /// <reference types="node" />
-export declare function clearLastLine(): void;
-export declare const spinnerChars: string[];
 export declare const showCursorCommand = "\u001B[?25h";
-export declare const clearCommand = "\r\u001B[K";
-export declare const hideCursorCommand = "\u001B[?25l";
-export declare function renderSpinner(counter: number): string;
 export declare function renderProgressBar(progress: number, size?: number, subprogress?: number): string;
-export declare function logVars(data: Record<string, any>): void;
 export declare function logExec(command: string, argv?: string[], env?: NodeJS.ProcessEnv, logToStderr?: boolean): void;
-export declare function resultColumn(error: Error | null | string, state?: "started" | "ended"): "❌" | " ? " | "✅";
-export declare function errorColumn(error: Error | null | string, verbose: number): string;
+export declare function renderResult(error: Error | null | string | boolean | undefined, color?: boolean): string;
+export declare function renderError(error: Error | null | string | undefined, verbose?: number): string;
+export declare function renderObject(object: Record<string, any>): string;
 export type OptionsType<T1, T2 extends {
     [K in keyof T1]: unknown;
 }> = {
@@ -24,5 +19,4 @@ export type OptionsType<T1, T2 extends {
 export declare function parseOptions<T1, T2 extends {
     [K in keyof T1]: unknown;
 }>(object: T1, options: OptionsType<T1, T2>): T2;
-export declare function truncate(text: string, limit: number): [string, boolean];
 export declare function confirm(message: string): Promise<unknown>;

package/utils/cli.js

@@ -3,23 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.confirm = exports.truncate = exports.parseOptions = exports.errorColumn = exports.resultColumn = exports.logExec = exports.logVars = exports.renderProgressBar = exports.renderSpinner = exports.hideCursorCommand = exports.clearCommand = exports.showCursorCommand = exports.spinnerChars = exports.clearLastLine = void 0;
+exports.confirm = exports.parseOptions = exports.renderObject = exports.renderError = exports.renderResult = exports.logExec = exports.renderProgressBar = exports.showCursorCommand = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const chalk_2 = require("chalk");
 const readline_1 = require("readline");
-function clearLastLine() {
-    process.stdout.moveCursor(0, -1);
-    process.stdout.clearLine(1);
-}
-exports.clearLastLine = clearLastLine;
-exports.spinnerChars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 exports.showCursorCommand = "\u001B[?25h";
-exports.clearCommand = "\r\x1b[K";
-exports.hideCursorCommand = "\x1B[?25l";
-function renderSpinner(counter) {
-    return exports.spinnerChars[counter % (exports.spinnerChars.length - 1)];
-}
-exports.renderSpinner = renderSpinner;
 function renderProgressBar(progress, size = 10, subprogress) {
     if (progress > 100)
         throw new Error(`Invalid progress value: ${progress}`);
@@ -45,18 +33,6 @@ function renderProgressBar(progress, size = 10, subprogress) {
     return (0, chalk_2.cyan)(result);
 }
 exports.renderProgressBar = renderProgressBar;
-function logVars(data) {
-    let first = true;
-    for (const key in data) {
-        if (first) {
-            console.info();
-            first = false;
-        }
-        const value = data[key];
-        console.info(`${chalk_1.default.cyan(key)}${chalk_1.default.grey(":")} ${chalk_1.default.white(value ?? "")}`);
-    }
-}
-exports.logVars = logVars;
 function logExec(command, argv = [], env, logToStderr) {
     const envText = env
         ? Object.keys(env)
@@ -72,11 +48,17 @@ function logExec(command, argv = [], env, logToStderr) {
         : console.info(text);
 }
 exports.logExec = logExec;
-function resultColumn(error, state) {
-    return error ? "❌" : state === "started" ? " ? " : "✅";
+function renderResult(error, color = true) {
+    return error
+        ? color
+            ? chalk_1.default.red("Χ")
+            : "Χ"
+        : color
+            ? chalk_1.default.green("✓")
+            : "✓";
 }
-exports.resultColumn = resultColumn;
-function errorColumn(error, verbose) {
+exports.renderResult = renderResult;
+function renderError(error, verbose) {
     let message = null;
     if (typeof error === "string") {
         message = error;
@@ -92,7 +74,14 @@ function errorColumn(error, verbose) {
     }
     return chalk_1.default.red(message.trim());
 }
-exports.errorColumn = errorColumn;
+exports.renderError = renderError;
+function renderObject(object) {
+    const values = [];
+    for (const key in object)
+        values.push(`${key}: ${(0, chalk_2.grey)(object[key])}`);
+    return values.join(` `);
+}
+exports.renderObject = renderObject;
 function parseOptions(object, options) {
     const result = {};
     for (const key in options) {
@@ -107,31 +96,6 @@ function parseOptions(object, options) {
     return result;
 }
 exports.parseOptions = parseOptions;
-function truncate(text, limit) {
-    let inColor = false;
-    let visibleLength = 0;
-    if (limit >= text.length)
-        return [text, false];
-    for (let index = 0; index < text.length; ++index) {
-        const c = text[index];
-        if (c === "\x1B") {
-            inColor = true;
-        }
-        else if (inColor) {
-            if (c === "m") {
-                inColor = false;
-            }
-        }
-        else {
-            visibleLength++;
-        }
-        if (visibleLength === limit) {
-            return [text.slice(0, index) + (inColor ? `\x1B[39m` : ""), true];
-        }
-    }
-    return [text, false];
-}
-exports.truncate = truncate;
 function confirm(message) {
     const rl = (0, readline_1.createInterface)({
         input: process.stdin,

package/utils/crypto.d.ts

@@ -0,0 +1 @@
+export declare function calcFileHash(path: string, algorithm: string): Promise<string>;

package/utils/crypto.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calcFileHash = void 0;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+function calcFileHash(path, algorithm) {
+    return new Promise((resolve, reject) => {
+        const hash = (0, crypto_1.createHash)(algorithm);
+        (0, fs_1.createReadStream)(path)
+            .on("error", reject)
+            .on("data", (chunk) => hash.update(chunk))
+            .on("end", () => resolve(hash.digest("hex")));
+    });
+}
+exports.calcFileHash = calcFileHash;

package/utils/datatruck/client.d.ts

@@ -1,3 +1,4 @@
+import { DiskStats } from "../fs";
 import { AbstractFs, FsOptions } from "../virtual-fs";
 export declare class RemoteFs extends AbstractFs {
     readonly options: FsOptions;
@@ -15,6 +16,7 @@ export declare class RemoteFs extends AbstractFs {
     ensureEmptyDir(path: string): Promise<void>;
     writeFile(path: string, contents: string): Promise<void>;
     rmAll(path: string): Promise<void>;
+    fetchDiskStats(path: string): Promise<DiskStats>;
     upload(source: string, target: string): Promise<void>;
     download(source: string, target: string, timeout?: number): Promise<void>;
 }

package/utils/datatruck/client.js

@@ -65,6 +65,9 @@ class RemoteFs extends virtual_fs_1.AbstractFs {
     async rmAll(path) {
         await this.fetchJson("rmAll", [path]);
     }
+    async fetchDiskStats(path) {
+        return await this.fetchJson("fetchDiskStats", [path]);
+    }
     async upload(source, target) {
         await (0, http_1.uploadFile)(`${this.url}/upload`, source, {
             headers: this.headers,

package/utils/datatruck/config.d.ts

@@ -2,6 +2,8 @@ import { ConfigType } from "../../Config/Config";
 import type { PackageConfigType } from "../../Config/PackageConfig";
 import { RepositoryConfigEnabledActionType, RepositoryConfigType } from "../../Config/RepositoryConfig";
 export declare function findRepositoryOrFail(config: ConfigType, repositoryName: string): RepositoryConfigType;
+export declare function findPackageOrFail(config: ConfigType, packageName: string): PackageConfigType;
+export declare function ensureSameRepositoryType(a: RepositoryConfigType, b: RepositoryConfigType): void;
 export declare function filterRepository(repository: RepositoryConfigType, action?: RepositoryConfigEnabledActionType): boolean;
 export declare function filterPackages(config: ConfigType, options: {
     packageNames?: string[];

package/utils/datatruck/config.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.params = exports.dbNameParams = exports.pkgRestorePathParams = exports.pkgExcludeParams = exports.pkgIncludeParams = exports.pkgPathParams = exports.resolvePackages = exports.resolvePackage = exports.resolveDatabaseName = exports.resolvePackagePath = exports.filterPackages = exports.filterRepository = exports.findRepositoryOrFail = void 0;
+exports.params = exports.dbNameParams = exports.pkgRestorePathParams = exports.pkgExcludeParams = exports.pkgIncludeParams = exports.pkgPathParams = exports.resolvePackages = exports.resolvePackage = exports.resolveDatabaseName = exports.resolvePackagePath = exports.filterPackages = exports.filterRepository = exports.ensureSameRepositoryType = exports.findPackageOrFail = exports.findRepositoryOrFail = void 0;
 const AppError_1 = require("../../Error/AppError");
-const fs_1 = require("../fs");
 const string_1 = require("../string");
+const temp_1 = require("../temp");
 const micromatch_1 = require("micromatch");
 function findRepositoryOrFail(config, repositoryName) {
     const repo = config.repositories.find((v) => v.name === repositoryName);
@@ -12,6 +12,21 @@ function findRepositoryOrFail(config, repositoryName) {
     return repo;
 }
 exports.findRepositoryOrFail = findRepositoryOrFail;
+function findPackageOrFail(config, packageName) {
+    const pkg = config.packages.find((v) => v.name === packageName);
+    if (!pkg)
+        throw new AppError_1.AppError(`Package '${packageName}' not found`);
+    return pkg;
+}
+exports.findPackageOrFail = findPackageOrFail;
+function ensureSameRepositoryType(a, b) {
+    if (a.type !== b.type) {
+        const names = [a.name, b.name].join(" and ");
+        const types = [a.type, b.type].join(" != ");
+        throw new Error(`Incompatible repository types between ${names} (${types})`);
+    }
+}
+exports.ensureSameRepositoryType = ensureSameRepositoryType;
 function filterRepository(repository, action) {
     const enabled = repository.enabled ?? true;
     if (typeof enabled === "boolean")
@@ -50,7 +65,7 @@ function resolvePackagePath(value, params) {
     return (0, string_1.render)(value, {
         ...params,
         ...{
-            temp: (0, fs_1.tmpDir)("pkg"),
+            temp: (0, temp_1.tmpDir)("pkg"),
         },
     });
 }

package/utils/datatruck/paths.d.ts

@@ -1,21 +1,17 @@
 import { PackageConfigType } from "../../Config/PackageConfig";
-import { SnapshotType } from "../../Repository/RepositoryAbstract";
+import { PreSnapshot } from "../../Repository/RepositoryAbstract";
 import { Step } from "../steps";
 export type ParsePathsOptions = {
     cwd?: string;
     verbose?: boolean;
     vars?: Record<string, any>;
-};
-export declare function parsePaths(values: (string | Step)[], options: {
-    cwd?: string;
-    verbose?: boolean;
-    vars?: Record<string, any>;
     tempDir?: () => Promise<string>;
-}): Promise<string[]>;
+};
+export declare function parsePaths(values: (string | Step)[], options: ParsePathsOptions): Promise<string[]>;
 export type BackupPathsOptions = {
     package: PackageConfigType;
-    snapshot: SnapshotType;
-    targetPath: string;
+    snapshot: PreSnapshot;
+    path: string;
     verbose?: boolean;
 };
 export declare function parseBackupPaths(paths: (string | Step)[], options: BackupPathsOptions): Promise<string[]>;

package/utils/datatruck/paths.js

@@ -21,13 +21,13 @@ async function parsePaths(values, options) {
 exports.parsePaths = parsePaths;
 async function parseBackupPaths(paths, options) {
     return parsePaths(paths, {
-        cwd: options.targetPath,
+        cwd: options.path,
         verbose: options.verbose,
         vars: {
             dtt: {
                 package: options.package,
                 snapshot: options.snapshot,
-                targetPath: options.targetPath,
+                path: options.path,
             },
         },
     });

package/utils/datatruck/snapshot.d.ts

@@ -1,4 +1,7 @@
 import { SnapshotGroupByType } from "../../Action/SnapshotsAction";
-import { SnapshotResultType } from "../../Repository/RepositoryAbstract";
+import { Snapshot } from "../../Repository/RepositoryAbstract";
 import { FilterByLastOptionsType } from "../date";
-export declare function groupAndFilter<TSnapshot extends SnapshotResultType>(snapshots: TSnapshot[], groupByKey?: SnapshotGroupByType[], filter?: FilterByLastOptionsType | ((groupedSnapshots: TSnapshot[]) => FilterByLastOptionsType), reasons?: Record<number, string[]>): TSnapshot[];
+export declare function groupAndFilter<TSnapshot extends Snapshot>(snapshots: TSnapshot[], groupKeys?: SnapshotGroupByType[], inFilter?: FilterByLastOptionsType | ((group: TSnapshot[]) => FilterByLastOptionsType | string)): {
+    item: TSnapshot;
+    reasons: string[];
+}[];

package/utils/datatruck/snapshot.js

@@ -3,29 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.groupAndFilter = void 0;
 const date_1 = require("../date");
 const object_1 = require("../object");
-function groupAndFilter(snapshots, groupByKey, filter, reasons) {
-    const grouped = groupByKey?.length
-        ? (0, object_1.groupBy)(snapshots, groupByKey)
+function groupAndFilter(snapshots, groupKeys, inFilter) {
+    const groups = groupKeys?.length
+        ? (0, object_1.groupBy)(snapshots, groupKeys)
         : { "": snapshots };
-    const result = [];
-    for (const key in grouped) {
-        if (filter) {
-            const groupReasons = reasons
-                ? {}
-                : undefined;
-            result.push(...(0, date_1.filterByLast)(grouped[key], typeof filter === "function" ? filter(grouped[key]) : filter, groupReasons));
-            if (groupReasons && reasons) {
-                for (const groupItemIndex in groupReasons) {
-                    const snapshot = grouped[key][groupItemIndex];
-                    const snapshotIndex = snapshots.indexOf(snapshot);
-                    reasons[snapshotIndex] = groupReasons[groupItemIndex];
-                }
-            }
-        }
-        else {
-            result.push(...grouped[key]);
-        }
+    const keep = [];
+    for (const key in groups) {
+        const filter = typeof inFilter === "function" ? inFilter(groups[key]) : inFilter || {};
+        keep.push(...(typeof filter === "string"
+            ? groups[key].map((item) => ({ item, reasons: [filter] }))
+            : (0, date_1.filterByLast)(groups[key], filter)));
     }
-    return snapshots.filter((snapshot) => result.includes(snapshot));
+    return snapshots
+        .map((snapshot) => keep.find((v) => v.item === snapshot))
+        .filter((v) => !!v);
 }
 exports.groupAndFilter = groupAndFilter;

package/utils/date.d.ts

@@ -7,10 +7,27 @@ export type FilterByLastOptionsType = {
     lastMonthly?: number;
     lastYearly?: number;
 };
+export type KeepObject = {
+    keepLast?: number;
+    keepMinutely?: number;
+    keepHourly?: number;
+    keepDaily?: number;
+    keepWeekly?: number;
+    keepMonthly?: number;
+    keepYearly?: number;
+};
+export declare function createFilterByLastOptions(keep: KeepObject): FilterByLastOptionsType;
 export declare function filterByLast<TItem extends {
     date: string;
-}>(items: TItem[], options: FilterByLastOptionsType, reasons?: Record<number, string[]>): TItem[];
-export declare function createChron(): {
-    start: () => number;
-    elapsed: (formatted?: boolean) => string | number;
+}>(items: TItem[], options: FilterByLastOptionsType): {
+    item: TItem;
+    reasons: string[];
+}[];
+export type Timer = {
+    reset: (min?: number) => boolean;
+    check: (min: number) => boolean;
+    elapsed: () => number;
+    stop: () => void;
 };
+export declare function createTimer(): Timer;
+export declare function duration(ms: number): string;

package/utils/date.js

@@ -3,14 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createChron = exports.filterByLast = void 0;
-const string_1 = require("./string");
+exports.duration = exports.createTimer = exports.filterByLast = exports.createFilterByLastOptions = void 0;
 const dayjs_1 = __importDefault(require("dayjs"));
 const advancedFormat_1 = __importDefault(require("dayjs/plugin/advancedFormat"));
+const customParseFormat_1 = __importDefault(require("dayjs/plugin/customParseFormat"));
+const duration_1 = __importDefault(require("dayjs/plugin/duration"));
 const isoWeek_1 = __importDefault(require("dayjs/plugin/isoWeek"));
 dayjs_1.default.extend(isoWeek_1.default);
 dayjs_1.default.extend(advancedFormat_1.default);
-function filterByLast(items, options, reasons) {
+dayjs_1.default.extend(duration_1.default);
+dayjs_1.default.extend(customParseFormat_1.default);
+function createFilterByLastOptions(keep) {
+    return {
+        last: keep.keepLast,
+        lastMinutely: keep.keepMinutely,
+        lastHourly: keep.keepHourly,
+        lastDaily: keep.keepDaily,
+        lastMonthly: keep.keepMonthly,
+        lastWeekly: keep.keepWeekly,
+        lastYearly: keep.keepYearly,
+    };
+}
+exports.createFilterByLastOptions = createFilterByLastOptions;
+function filterByLast(items, options) {
     const filters = {
         last: { handler: (_, i) => i.toString(), value: options.last },
         lastMinutely: {
@@ -43,13 +58,13 @@ function filterByLast(items, options, reasons) {
         }
     }
     if (!someFilter)
-        return items;
+        return items.map((item) => ({ item, reasons: ["no-filter"] }));
+    const reasons = new Map();
     const validItems = items
         .slice(0)
         .sort((a, b) => b.date.localeCompare(a.date))
         .filter((item, index) => {
         const date = (0, dayjs_1.default)(item.date);
-        const itemIndex = items.indexOf(item);
         let success = false;
         for (const key in filters) {
             const object = filters[key];
@@ -57,12 +72,7 @@ function filterByLast(items, options, reasons) {
                 const value = object.handler(date, index);
                 if (value != object.last) {
                     success = true;
-                    if (reasons) {
-                        if (!reasons[itemIndex])
-                            reasons[itemIndex] = [];
-                        if (!reasons[itemIndex].includes(key))
-                            reasons[itemIndex].push(key);
-                    }
+                    reasons.set(item, (reasons.get(item) || new Set()).add(key));
                     object.last = value;
                     object.value--;
                 }
@@ -70,21 +80,33 @@ function filterByLast(items, options, reasons) {
         }
         return success;
     });
-    return items.filter((item) => validItems.includes(item));
+    return items
+        .filter((item) => validItems.includes(item))
+        .map((item) => ({
+        item,
+        reasons: [...(reasons.get(item) || [])],
+    }));
 }
 exports.filterByLast = filterByLast;
-function createChron() {
-    let startTime;
-    return {
-        start: () => (startTime = Date.now()),
-        elapsed: (formatted) => {
-            if (!startTime)
-                throw new Error(`Chron was not started`);
-            const seconds = (Date.now() - startTime) / 1000;
-            if (formatted)
-                return (0, string_1.formatSeconds)(seconds);
-            return seconds;
+function createTimer() {
+    let startTime = Date.now();
+    let endTime;
+    const timer = {
+        elapsed: () => (endTime || Date.now()) - startTime,
+        check: (ms) => timer.elapsed() > ms,
+        stop: () => (endTime = Date.now()),
+        reset: (min) => {
+            if (typeof min === "number" && !timer.check(min))
+                return false;
+            startTime = Date.now();
+            endTime = undefined;
+            return true;
         },
     };
+    return timer;
+}
+exports.createTimer = createTimer;
+function duration(ms) {
+    return dayjs_1.default.duration(ms, "ms").format("HH:mm:ss");
 }
-exports.createChron = createChron;
+exports.duration = duration;

package/utils/fs.d.ts

@@ -11,6 +11,8 @@ export declare function isEmptyDir(path: string): Promise<boolean>;
 export declare function isLocalDir(path: string): boolean;
 export declare function mkdirIfNotExists(path: string): Promise<string>;
 export declare function ensureEmptyDir(path: string): Promise<void>;
+export declare function ensureSingleFile(path: string): Promise<string>;
+export declare function ensureExistsDir(path: string): Promise<void>;
 export declare function safeStat(path: string): Promise<Stats | undefined>;
 export declare function existsDir(path: string): Promise<boolean>;
 export declare function existsFile(path: string): Promise<boolean>;
@@ -23,13 +25,7 @@ export declare function parsePackageFile(): {
     description: string;
 };
 export declare function findFile(sourcePath: string, baseName: string, extensions: string[], errorMessage?: string): Promise<string>;
-export declare function parentTmpDir(): string;
-export declare function sessionTmpDir(): string;
-export declare function isTmpDir(path: string): boolean;
-export declare function rmTmpDir(input: string | string[]): Promise<void>;
-export declare function tmpDir(prefix: string, id?: string): string;
 export declare function fastFolderSizeAsync(path: string): Promise<number>;
-export declare function mkTmpDir(prefix: string, id?: string): Promise<string>;
 export declare function readPartialFile(path: string, positions: [number, number?]): Promise<string>;
 export declare function readDir(path: string, optional?: boolean): Promise<string[]>;
 export declare function forEachFile(dirPath: string, cb: (path: string, dir: boolean) => void, includeDir?: boolean): Promise<void>;
@@ -60,7 +56,7 @@ export declare function cpy(options: {
         path: string;
         basePath: string;
     };
-    targetPath: string;
+    outPath: string;
     /**
      * @default 1
      */
@@ -91,20 +87,20 @@ type ProgressObject = {
     disposed: boolean;
     total: number;
     current: number;
-    update: (description: string, path?: string, increment?: boolean) => Promise<void>;
+    update: (description: string, path?: string, increment?: boolean) => void;
 };
 export declare function createProgress(options: {
-    onProgress: (data: Progress) => Promise<void>;
+    onProgress: (data: Progress) => void;
 }): ProgressObject;
 export declare function createFileScanner(options: {
     glob: Options & {
         include: string[];
     };
-    onProgress: (data: Progress) => Promise<void>;
+    onProgress: (data: Progress) => void;
 }): Promise<ProgressObject & {
     progress: ProgressObject["update"];
     start: (cb?: (entry: Required<Entry>) => any) => Promise<void>;
-    end: () => Promise<void>;
+    end: () => void;
 }>;
 type StreamItem = {
     key: string;
@@ -128,4 +124,13 @@ export declare function countFileLines(path: string): Promise<number>;
 export declare function fetchData<T>(input: T, onPath?: (input: Exclude<T, string>) => string | undefined): Promise<string | null>;
 export declare function safeRename(oldPath: string, newPath: string): Promise<void>;
 export declare function tryRm(path: string): Promise<void>;
+export declare function initEmptyDir(path: string | undefined): Promise<string>;
+export type DiskStats = {
+    total: number;
+    free: number;
+};
+export declare function fetchDiskStats(path: string): Promise<DiskStats>;
+export declare function checkFreeDiskSpace(stat: DiskStats, inSize: string | number): Promise<void>;
+export declare function ensureFreeDiskSpace(input: string[] | DiskStats, inSize: number | string): Promise<void>;
+export declare function groupFiles(inFiles: string[], suffixes?: string[], gzSuffix?: string): [string[], Record<string, string>];
 export {};