@datatruck/cli 0.13.1 → 0.16.0

package/Task/MysqlDumpTask.js

@@ -70,7 +70,7 @@ class MysqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
         table_name
 	`);
     }
-    async onExportTables(tableNames, output) {
+    async onExportTables(tableNames, output, onProgress) {
         const stream = (0, fs_1.createWriteStream)(output);
         await Promise.all([
             new Promise((resolve, reject) => {
@@ -83,7 +83,10 @@ class MysqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
                 "--skip-add-drop-table=false",
                 ...tableNames,
             ], null, {
-                pipe: { stream: stream },
+                pipe: {
+                    stream,
+                    onWriteProgress: onProgress,
+                },
                 log: {
                     exec: this.verbose,
                     stderr: this.verbose,

package/Task/PostgresqlDumpTask.d.ts

@@ -9,7 +9,9 @@ export declare class PostgresqlDumpTask extends SqlDumpTaskAbstract<PostgresqlDu
     onCreateDatabase(database: TargetDatabaseType): Promise<void>;
     onExecQuery(query: string): Promise<import("../util/process-util").ExecResultType>;
     onFetchTableNames(database: string): Promise<string[]>;
-    onExportTables(tableNames: string[], output: string): Promise<void>;
+    onExportTables(tableNames: string[], output: string, onProgress: (progress: {
+        totalBytes: number;
+    }) => void): Promise<void>;
     onExportStoredPrograms(): Promise<void>;
     onImport(path: string, database: string): Promise<void>;
 }

package/Task/PostgresqlDumpTask.js

@@ -73,7 +73,7 @@ class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
         CONCAT(table_schema, '.', table_name)
 	  `);
     }
-    async onExportTables(tableNames, output) {
+    async onExportTables(tableNames, output, onProgress) {
         const stream = (0, fs_1.createWriteStream)(output);
         await Promise.all([
             new Promise((resolve, reject) => {
@@ -84,7 +84,7 @@ class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
                 ...(await this.buildConnectionArgs()),
                 ...(tableNames?.flatMap((v) => ["-t", v]) ?? []),
             ], null, {
-                pipe: { stream: stream },
+                pipe: { stream, onWriteProgress: onProgress },
                 stderr: {
                     toExitCode: true,
                 },

package/Task/SqlDumpTaskAbstract.d.ts

@@ -29,7 +29,9 @@ export declare abstract class SqlDumpTaskAbstract<TConfig extends SqlDumpTaskCon
     abstract onDatabaseIsEmpty(databaseName: string): Promise<boolean>;
     abstract onFetchTableNames(database: string): Promise<string[]>;
     abstract onExecQuery(query: string): ReturnType<typeof exec>;
-    abstract onExportTables(tableNames: string[], output: string): Promise<void>;
+    abstract onExportTables(tableNames: string[], output: string, onProgress: (data: {
+        totalBytes: number;
+    }) => void): Promise<void>;
     abstract onExportStoredPrograms(output: string): Promise<void>;
     abstract onImport(path: string, database: string): Promise<void>;
     onBackup(data: BackupDataType): Promise<void>;

package/Task/SqlDumpTaskAbstract.js

@@ -118,24 +118,61 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
             await (0, promises_1.mkdir)(outputPath, { recursive: true });
         if (!this.config.oneFileByTable) {
             const outPath = (0, path_1.join)(outputPath, serializeSqlFile({ database: this.config.database }));
-            await this.onExportTables(tableNames, outPath);
+            data.onProgress({
+                relative: {
+                    description: "Exporting",
+                },
+            });
+            await this.onExportTables(tableNames, outPath, async (progress) => {
+                await data.onProgress({
+                    absolute: {
+                        description: "Exporting in single file",
+                        current: progress.totalBytes,
+                        format: "size",
+                    },
+                });
+            });
         }
         else {
             let current = 0;
             for (const tableName of tableNames) {
-                data.onProgress({
-                    total: tableNames.length,
-                    current: current,
-                    percent: (0, math_util_1.progressPercent)(tableNames.length, current),
-                    step: tableName,
+                await data.onProgress({
+                    relative: {
+                        description: "Exporting",
+                        payload: tableName,
+                    },
+                    absolute: {
+                        total: tableNames.length,
+                        current: current,
+                        percent: (0, math_util_1.progressPercent)(tableNames.length, current),
+                    },
                 });
-                current++;
                 const outPath = (0, path_1.join)(outputPath, serializeSqlFile({ table: tableName }));
-                await this.onExportTables([tableName], outPath);
+                await this.onExportTables([tableName], outPath, async (progress) => {
+                    await data.onProgress({
+                        relative: {
+                            description: "Exporting",
+                            payload: tableName,
+                            current: progress.totalBytes,
+                            format: "size",
+                        },
+                        absolute: {
+                            total: tableNames.length,
+                            current: current,
+                            percent: (0, math_util_1.progressPercent)(tableNames.length, current),
+                        },
+                    });
+                });
+                current++;
             }
         }
         if (this.config.storedPrograms) {
             const outPath = (0, path_1.join)(outputPath, "stored-programs.sql");
+            data.onProgress({
+                relative: {
+                    description: "Exporting storaged programs",
+                },
+            });
             await this.onExportStoredPrograms(outPath);
         }
     }
@@ -184,13 +221,18 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
         for (const item of items) {
             const path = (0, path_1.join)(restorePath, item.fileName);
             data.onProgress({
-                total: items.length,
-                current: current,
-                percent: (0, math_util_1.progressPercent)(items.length, current),
-                step: item.fileName,
+                relative: {
+                    description: "Importing",
+                    payload: item.fileName,
+                },
+                absolute: {
+                    total: items.length,
+                    current: current,
+                    percent: (0, math_util_1.progressPercent)(items.length, current),
+                },
             });
-            current++;
             await this.onImport(path, database.name);
+            current++;
         }
     }
 }

package/Task/TaskAbstract.d.ts

@@ -2,22 +2,16 @@ import { BackupActionOptionsType } from "../Action/BackupAction";
 import { RestoreActionOptionsType } from "../Action/RestoreAction";
 import { PackageConfigType } from "../Config/PackageConfig";
 import { SnapshotType } from "../Repository/RepositoryAbstract";
-export declare type ProgressDataType = {
-    total?: number;
-    current?: number;
-    percent?: number;
-    step?: string;
-    stepPercent?: number;
-};
+import { Progress } from "../util/progress";
 export declare type BackupDataType = {
-    onProgress: (data: ProgressDataType) => Promise<void>;
+    onProgress: (data: Progress) => Promise<void>;
     options: BackupActionOptionsType;
     package: PackageConfigType;
     targetPath: string | undefined;
     snapshot: SnapshotType;
 };
 export declare type RestoreDataType = {
-    onProgress: (data: ProgressDataType) => Promise<void>;
+    onProgress: (data: Progress) => Promise<void>;
     options: RestoreActionOptionsType;
     package: PackageConfigType;
     targetPath: string | undefined;

package/cli.js

@@ -81,7 +81,7 @@ program.usage("dtt");
 program.option("-v,--verbose", "Verbose", (_, previous) => previous + 1, 0);
 program.option("-c,--config <path>", "Config path", process.env["DATATRUCK_CONFIG"] ?? (cwd.endsWith(path_1.sep) ? cwd : `${cwd}${path_1.sep}`));
 program.option("--progress <value>", "Progress type (auto, plain, tty)", "auto");
-program.option("--progress-interval <ms>", "Progress interval");
+program.option("--progress-interval <ms>", "Progress interval", Number, 1000);
 program.option("-o,--output-format <format>", "Output format (json, pjson, yaml, table, custom=$, tpl=name)", "table");
 makeCommand(CommandFactory_1.CommandEnum.config).alias("c");
 makeCommand(CommandFactory_1.CommandEnum.init).alias("i");

package/config.schema.json

@@ -475,6 +475,9 @@
                       "include"
                     ],
                     "properties": {
+                      "name": {
+                        "type": "string"
+                      },
                       "include": {
                         "$ref": "#/definitions/stringlist-util"
                       },

package/migrations/001-initial.sql

@@ -11,11 +11,7 @@ CREATE TABLE "backup_session" (
 	"endDate"	TEXT,
 	"state"	TEXT,
 	"error"	TEXT,
-	"progressCurrent" INTEGER,
-	"progressTotal" INTEGER,
-	"progressPercent" INTEGER,
-	"progressStep" TEXT,
-	"progressStepPercent" INTEGER,
+	"progress" TEXT,
 
 	"snapshotId"	TEXT NOT NULL,
 	"packageName"	TEXT NOT NULL,
@@ -32,11 +28,7 @@ CREATE TABLE "backup_session_task" (
 	"endDate"	TEXT,
 	"state"	TEXT,
 	"error"	TEXT,
-	"progressCurrent" INTEGER,
-	"progressTotal" INTEGER,
-	"progressPercent" INTEGER,
-	"progressStep" TEXT,
-	"progressStepPercent" INTEGER,
+	"progress" TEXT,
 
 	"sessionId"	INTEGER NOT NULL,
 	"taskName"	TEXT NOT NULL
@@ -51,11 +43,7 @@ CREATE TABLE "backup_session_repository" (
 	"endDate"	TEXT,
 	"state"	TEXT,
 	"error"	TEXT,
-	"progressCurrent" INTEGER,
-	"progressTotal" INTEGER,
-	"progressPercent" INTEGER,
-	"progressStep" TEXT,
-	"progressStepPercent" INTEGER,
+	"progress" TEXT,
 
 	"sessionId"	INTEGER NOT NULL,
 	"repositoryName"	TEXT NOT NULL,
@@ -71,11 +59,7 @@ CREATE TABLE "restore_session" (
 	"endDate"	TEXT,
 	"state"	TEXT,
 	"error"	TEXT,
-	"progressCurrent" INTEGER,
-	"progressTotal" INTEGER,
-	"progressPercent" INTEGER,
-	"progressStep" TEXT,
-	"progressStepPercent" INTEGER,
+	"progress" TEXT,
 
 	"snapshotId"	TEXT NOT NULL,
 	"packageName"	TEXT NOT NULL -- ,
@@ -91,11 +75,7 @@ CREATE TABLE "restore_session_task" (
 	"endDate"	TEXT,
 	"state"	TEXT,
 	"error"	TEXT,
-	"progressCurrent" INTEGER,
-	"progressTotal" INTEGER,
-	"progressPercent" INTEGER,
-	"progressStep" TEXT,
-	"progressStepPercent" INTEGER,
+	"progress" TEXT,
 
 	"sessionId"	INTEGER NOT NULL,
 	"taskName"	TEXT NOT NULL
@@ -110,11 +90,7 @@ CREATE TABLE "restore_session_repository" (
 	"endDate"	TEXT,
 	"state"	TEXT,
 	"error"	TEXT,
-	"progressCurrent" INTEGER,
-	"progressTotal" INTEGER,
-	"progressPercent" INTEGER,
-	"progressStep" TEXT,
-	"progressStepPercent" INTEGER,
+	"progress" TEXT,
 
 	"sessionId"	INTEGER NOT NULL,
 	"repositoryName"	TEXT NOT NULL,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datatruck/cli",
-  "version": "0.13.1",
+  "version": "0.16.0",
   "dependencies": {
     "ajv": "^8.11.0",
     "async": "^3.2.4",

package/util/cli-util.d.ts

@@ -5,7 +5,7 @@ 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): 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"): "❌" | " ? " | "✅";

package/util/cli-util.js

@@ -20,12 +20,27 @@ function renderSpinner(counter) {
     return exports.spinnerChars[counter % (exports.spinnerChars.length - 1)];
 }
 exports.renderSpinner = renderSpinner;
-function renderProgressBar(progress, size = 10) {
+function renderProgressBar(progress, size = 10, subprogress) {
     const completeChar = "\u2588";
     const incompleteChar = "\u2591";
     const completedSize = Math.round((progress * size) / 100);
     const restSize = Math.max(size - completedSize, 0);
-    return completeChar.repeat(completedSize) + incompleteChar.repeat(restSize);
+    let result = completeChar.repeat(completedSize) + incompleteChar.repeat(restSize);
+    if (typeof subprogress === "number") {
+        const subprogressChar = Math.round((subprogress * size) / 100);
+        if (subprogressChar === size) {
+            result =
+                result.slice(0, subprogressChar - 1) +
+                    chalk_1.default.white(result[Math.max(0, subprogressChar - 1)]);
+        }
+        else {
+            result =
+                result.slice(0, subprogressChar) +
+                    chalk_1.default.white(result[Math.max(0, subprogressChar - 1)]) +
+                    result.slice(subprogressChar + 1);
+        }
+    }
+    return (0, chalk_2.cyan)(result);
 }
 exports.renderProgressBar = renderProgressBar;
 function logVars(data) {

package/util/fs-util.d.ts

@@ -1,9 +1,20 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { Stats } from "fs";
+/// <reference types="node" />
+import { Dirent, Stats } from "fs";
+import { WriteStream } from "fs";
 import { Interface } from "readline";
 export declare const isWSLSystem: boolean;
+export declare function isEmptyDir(path: string): Promise<boolean>;
+declare type EntryObject = {
+    name: string;
+    path: string;
+    dirent: Dirent;
+    stats: Stats;
+};
+export declare function applyPermissions(baseDir: string, permissionsPath: string): Promise<void>;
+export declare function pathIterator(stream: AsyncIterable<string | Buffer>): AsyncIterable<EntryObject>;
 export declare function isLocalDir(path: string): boolean;
 export declare function isDirEmpty(path: string): Promise<boolean>;
 export declare function mkdirIfNotExists(path: string): Promise<string>;
@@ -28,7 +39,7 @@ export declare function mkTmpDir(prefix: string, id?: string): Promise<string>;
 export declare function readPartialFile(path: string, positions: [number, number?]): Promise<string>;
 export declare function checkFile(path: string): Promise<boolean>;
 export declare function checkDir(path: string): Promise<boolean>;
-export declare function readDir(path: string): 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>;
 /**
  * @experimental
@@ -37,24 +48,7 @@ export declare function fastglobToGitIgnore(patterns: string[], baseDir: string)
 export declare function writeGitIgnoreList(options: {
     paths: NodeJS.ReadableStream | string[];
 }): Promise<string>;
-export declare function writePathLists(options: {
-    paths: NodeJS.ReadableStream | string[];
-    packs?: {
-        include: string[];
-        exclude?: string[];
-        multiple?: boolean;
-    }[];
-}): Promise<{
-    path: string;
-    includedPackPaths: string[];
-    excludedPackPaths: string[];
-    total: {
-        all: number;
-        path: number;
-        packsPaths: number[];
-        multipleStats: Record<string, number>;
-    };
-}>;
+export declare function waitForClose(stream: WriteStream): Promise<WriteStream>;
 export declare function copyFileWithStreams(source: string, target: string): Promise<unknown>;
 export declare function updateFileStats(path: string, fileInfo: Stats): Promise<void>;
 export declare function isNotFoundError(error: unknown): boolean;
@@ -79,6 +73,11 @@ export declare function cpy(options: {
      */
     concurrency?: number;
     skipNotFoundError?: boolean;
+    onProgress?: (data: {
+        current: number;
+        path?: string;
+        type?: "start" | "end";
+    }) => Promise<boolean | void>;
     onPath?: (data: {
         isDir: boolean;
         entryPath: string;
@@ -90,4 +89,9 @@ export declare function cpy(options: {
             dirs: number;
         };
     }) => Promise<boolean | void>;
-}): Promise<void>;
+}): Promise<{
+    paths: number;
+    files: number;
+    dirs: number;
+}>;
+export {};

package/util/fs-util.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cpy = exports.isNotFoundError = exports.updateFileStats = exports.copyFileWithStreams = exports.writePathLists = exports.writeGitIgnoreList = exports.fastglobToGitIgnore = exports.forEachFile = exports.readDir = exports.checkDir = exports.checkFile = exports.readPartialFile = exports.mkTmpDir = exports.fastFolderSizeAsync = exports.tmpDir = exports.sessionTmpDir = exports.parentTmpDir = exports.existsFile = exports.findFile = exports.parsePackageFile = exports.parseFile = exports.parseFileExtensions = exports.readdirIfExists = exports.writeJSONFile = exports.existsDir = exports.ensureEmptyDir = exports.mkdirIfNotExists = exports.isDirEmpty = exports.isLocalDir = exports.isWSLSystem = void 0;
+exports.cpy = exports.isNotFoundError = exports.updateFileStats = exports.copyFileWithStreams = exports.waitForClose = exports.writeGitIgnoreList = exports.fastglobToGitIgnore = exports.forEachFile = exports.readDir = exports.checkDir = exports.checkFile = exports.readPartialFile = exports.mkTmpDir = exports.fastFolderSizeAsync = exports.tmpDir = exports.sessionTmpDir = exports.parentTmpDir = exports.existsFile = exports.findFile = exports.parsePackageFile = exports.parseFile = exports.parseFileExtensions = exports.readdirIfExists = exports.writeJSONFile = exports.existsDir = exports.ensureEmptyDir = exports.mkdirIfNotExists = exports.isDirEmpty = exports.isLocalDir = exports.pathIterator = exports.applyPermissions = exports.isEmptyDir = exports.isWSLSystem = void 0;
 const globalData_1 = __importDefault(require("../globalData"));
 const path_util_1 = require("./path-util");
 const async_1 = require("async");
@@ -13,13 +13,49 @@ const fast_glob_1 = __importDefault(require("fast-glob"));
 const fs_1 = require("fs");
 const fs_2 = require("fs");
 const promises_1 = require("fs/promises");
-const micromatch_1 = require("micromatch");
 const os_1 = require("os");
 const path_1 = require("path");
 const path_2 = require("path");
 const readline_1 = require("readline");
 const util_1 = require("util");
 exports.isWSLSystem = (0, os_1.release)().includes("microsoft-standard-WSL");
+async function isEmptyDir(path) {
+    const iterator = await (0, promises_1.opendir)(path);
+    let done = false;
+    try {
+        const next = await iterator[Symbol.asyncIterator]().next();
+        done = !!next.done;
+        return done;
+    }
+    finally {
+        if (!done) {
+            await iterator.close();
+        }
+    }
+}
+exports.isEmptyDir = isEmptyDir;
+async function applyPermissions(baseDir, permissionsPath) {
+    const singleReader = (0, readline_1.createInterface)({
+        input: (0, fs_1.createReadStream)(permissionsPath),
+    });
+    for await (const line of singleReader) {
+        const [rpath, rawUid, rawGui, rawMode] = line.split(":");
+        const path = (0, path_1.join)(baseDir, rpath);
+        if (!path.startsWith(baseDir)) {
+            throw new Error(`Entry path is out of the base dir: (${path}, ${baseDir})`);
+        }
+        const uid = Number(rawUid);
+        const guid = Number(rawGui);
+        await (0, promises_1.chown)(path, uid, guid);
+        const mode = Number(rawMode);
+        await (0, promises_1.chmod)(path, mode);
+    }
+}
+exports.applyPermissions = applyPermissions;
+function pathIterator(stream) {
+    return stream;
+}
+exports.pathIterator = pathIterator;
 function isLocalDir(path) {
     return /^[\/\.]|([A-Z]:)/i.test(path);
 }
@@ -59,9 +95,7 @@ async function writeJSONFile(path, json) {
 }
 exports.writeJSONFile = writeJSONFile;
 async function readdirIfExists(path) {
-    if (!(await existsDir(path)))
-        return [];
-    return await readDir(path);
+    return await readDir(path, true);
 }
 exports.readdirIfExists = readdirIfExists;
 exports.parseFileExtensions = ["json", "js", "ts", "yaml", "yml"];
@@ -128,7 +162,7 @@ function sessionTmpDir() {
 exports.sessionTmpDir = sessionTmpDir;
 function tmpDir(prefix, id) {
     if (!id)
-        id = (0, crypto_1.randomBytes)(8).toString("hex");
+        id = (0, crypto_1.randomUUID)().slice(0, 8);
     return (0, path_1.join)(sessionTmpDir(), `${prefix}-${id}`);
 }
 exports.tmpDir = tmpDir;
@@ -187,13 +221,15 @@ async function checkDir(path) {
     }
 }
 exports.checkDir = checkDir;
-async function readDir(path) {
+async function readDir(path, optional) {
     try {
         return await (0, promises_1.readdir)(path);
     }
     catch (anyError) {
         const nodeError = anyError;
         if (nodeError.code === "ENOENT") {
+            if (optional)
+                return [];
             const error = new Error(nodeError.message);
             error.code = nodeError.code;
             error.errno = nodeError.errno;
@@ -262,93 +298,14 @@ async function writeGitIgnoreList(options) {
     return path;
 }
 exports.writeGitIgnoreList = writeGitIgnoreList;
-async function writePathLists(options) {
-    const tempDir = await mkTmpDir("path-lists");
-    const includedPaths = [];
-    const excludedPaths = [];
-    const included = [];
-    const excluded = [];
-    const multipleStats = {};
-    const total = new Array((options.packs?.length || 0) + 1).fill(0);
-    await Promise.all([
-        ...new Array((options.packs?.length || 0) + 1).fill(null).map((_, index) => new Promise((resolve, reject) => {
-            const path = (0, path_1.join)(tempDir, `${index}-included.txt`);
-            const stream = (0, fs_2.createWriteStream)(path);
-            includedPaths.push(path);
-            included.push(stream);
-            stream.on("close", resolve);
-            stream.on("error", reject);
-        })),
-        ...new Array(options.packs?.length || 0).fill(null).map((_, index) => new Promise((resolve, reject) => {
-            const path = (0, path_1.join)(tempDir, `${index}-excluded.txt`);
-            const stream = (0, fs_2.createWriteStream)(path);
-            excludedPaths.push(path);
-            excluded.push(stream);
-            stream.on("close", resolve);
-            stream.on("error", reject);
-        })),
-        new Promise(async (resolve) => {
-            const packDirectories = [];
-            for await (const value of options.paths) {
-                const entry = value.toString();
-                const isDir = entry.endsWith("/");
-                const matchEntry = isDir ? entry.slice(0, -1) : entry;
-                let packIndex = 1;
-                let matches = false;
-                for (const pack of options.packs || []) {
-                    if ((0, micromatch_1.isMatch)(matchEntry, pack.include) &&
-                        (!pack.exclude || !(0, micromatch_1.isMatch)(matchEntry, pack.exclude))) {
-                        if (isDir)
-                            packDirectories.push([packIndex - 1, entry]);
-                        included[packIndex].write(`${entry}\n`);
-                        if (!isDir)
-                            total[packIndex]++;
-                        matches = true;
-                        break;
-                    }
-                    packIndex++;
-                }
-                if (!matches) {
-                    const packDir = packDirectories.find(([, p]) => entry.startsWith(p));
-                    if (packDir) {
-                        const [i, v] = packDir;
-                        const multipleExclude = options.packs?.[i].exclude;
-                        if (multipleExclude && (0, micromatch_1.isMatch)(matchEntry, multipleExclude)) {
-                            included[0].write(`${entry}\n`);
-                            excluded[i].write(`${entry}\n`);
-                        }
-                        else {
-                            if (!multipleStats[v])
-                                multipleStats[v] = 0;
-                            multipleStats[v]++;
-                        }
-                    }
-                    else {
-                        included[0].write(`${entry}\n`);
-                    }
-                    if (!isDir)
-                        total[0]++;
-                }
-            }
-            for (const stream of [...included, ...excluded]) {
-                stream.end();
-            }
-            resolve();
-        }),
-    ]);
-    return {
-        path: includedPaths[0],
-        includedPackPaths: includedPaths.slice(1),
-        excludedPackPaths: excludedPaths,
-        total: {
-            all: total.reduce((p, v) => p + v, 0),
-            path: total[0],
-            packsPaths: total.slice(1),
-            multipleStats,
-        },
-    };
+async function waitForClose(stream) {
+    return new Promise(async (resolve, reject) => {
+        stream.on("close", resolve);
+        stream.on("error", reject);
+        return stream;
+    });
 }
-exports.writePathLists = writePathLists;
+exports.waitForClose = waitForClose;
 async function copyFileWithStreams(source, target) {
     const r = (0, fs_1.createReadStream)(source);
     const w = (0, fs_2.createWriteStream)(target);
@@ -391,6 +348,7 @@ async function cpy(options) {
         }
     };
     const task = async (rawEntryPath, basePath) => {
+        [rawEntryPath] = rawEntryPath.split(":");
         const isDir = rawEntryPath.endsWith("/");
         const entryPath = (0, path_1.normalize)(rawEntryPath);
         const entrySourcePath = (0, path_1.resolve)((0, path_1.join)(basePath, rawEntryPath));
@@ -411,6 +369,10 @@ async function cpy(options) {
         else {
             const dir = (0, path_1.dirname)(entryTargetPath);
             await makeRecursiveDir(dir);
+            await options.onProgress?.({
+                current: stats.files,
+                path: entryPath,
+            });
             stats.files++;
             // https://github.com/nodejs/node/issues/44261
             if (exports.isWSLSystem) {
@@ -471,5 +433,10 @@ async function cpy(options) {
             },
         });
     }
+    await options.onProgress?.({
+        current: stats.files,
+        type: "end",
+    });
+    return stats;
 }
 exports.cpy = cpy;

package/util/math-util.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.progressPercent = void 0;
 function progressPercent(total, current) {
+    if (total === 0 && current === 0)
+        return 0;
     return Number(((current / total) * 100).toFixed(2));
 }
 exports.progressPercent = progressPercent;

package/util/process-util.d.ts

@@ -14,6 +14,9 @@ export interface ExecSettingsInterface {
     exec?: boolean;
     pipe?: {
         stream: WriteStream | ReadStream;
+        onWriteProgress?: (data: {
+            totalBytes: number;
+        }) => void;
         onReadProgress?: (data: {
             totalBytes: number;
             currentBytes: number;
@@ -24,6 +27,7 @@ export interface ExecSettingsInterface {
     onSpawn?: (p: ChildProcess) => void;
     stdout?: {
         save?: boolean;
+        parseLines?: boolean;
         onData?: (data: string) => void;
     };
     stderr?: {