@loaders.gl/tile-converter 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/lib/utils/compress-util.js

@@ -1,179 +1,257 @@
-import { createGzip } from 'zlib';
-import { join } from 'path';
-import { promises as fs, createReadStream, createWriteStream } from 'fs';
-import archiver from 'archiver';
-import { removeFile } from './file-utils';
-import { ChildProcessProxy } from '@loaders.gl/worker-utils';
-import JSZip from 'jszip';
-import { MD5Hash } from '@loaders.gl/crypto';
-import crypt from 'crypt';
-import { getAbsoluteFilePath } from './file-utils';
-export function compressFileWithGzip(pathFile) {
-  const compressedPathFile = "".concat(pathFile, ".gz");
-  const gzip = createGzip();
-  const input = createReadStream(pathFile);
-  const output = createWriteStream(compressedPathFile);
-  return new Promise((resolve, reject) => {
-    input.on('end', () => {
-      console.log("".concat(compressedPathFile, " compressed and saved."));
-      resolve(compressedPathFile);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addFileToZip = exports.generateHash128FromZip = exports.compressWithChildProcess = exports.compressFilesWithZip = exports.compressFileWithGzip = void 0;
+const zlib_1 = require("zlib");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const archiver_1 = __importDefault(require("archiver"));
+const file_utils_1 = require("./file-utils");
+const worker_utils_1 = require("@loaders.gl/worker-utils");
+const jszip_1 = __importDefault(require("jszip"));
+const crypto_1 = require("@loaders.gl/crypto");
+const crypt_1 = __importDefault(require("crypt"));
+const file_utils_2 = require("./file-utils");
+/**
+ * Compress file to gzip file
+ *
+ * @param pathFile - the path to the file
+ * @return the path to the gzip file
+ */
+function compressFileWithGzip(pathFile) {
+    const compressedPathFile = `${pathFile}.gz`;
+    const gzip = (0, zlib_1.createGzip)();
+    const input = (0, fs_1.createReadStream)(pathFile);
+    const output = (0, fs_1.createWriteStream)(compressedPathFile);
+    return new Promise((resolve, reject) => {
+        input.on('end', () => {
+            console.log(`${compressedPathFile} compressed and saved.`); // eslint-disable-line no-undef,no-console
+            resolve(compressedPathFile);
+        });
+        input.on('error', (error) => {
+            console.log(`${compressedPathFile}: compression error!`); // eslint-disable-line no-undef,no-console
+            reject(error);
+        });
+        input.pipe(gzip).pipe(output);
     });
-    input.on('error', error => {
-      console.log("".concat(compressedPathFile, ": compression error!"));
-      reject(error);
-    });
-    input.pipe(gzip).pipe(output);
-  });
 }
-export async function compressFilesWithZip(fileMap, outputFile, level = 0) {
-  try {
-    await removeFile(outputFile);
-  } catch (e) {}
-
-  const output = createWriteStream(outputFile);
-  const archive = archiver('zip', {
-    zlib: {
-      level
+exports.compressFileWithGzip = compressFileWithGzip;
+/**
+ * Compress files from map into slpk file
+ *
+ * @param fileMap - map with file paths (key: output path, value: input path)
+ * @param outputFile - output slpk file
+ * @param level - compression level
+ */
+async function compressFilesWithZip(fileMap, outputFile, level = 0) {
+    // Before creating a new file, we need to delete the old file
+    try {
+        await (0, file_utils_1.removeFile)(outputFile);
     }
-  });
-  return new Promise(async (resolve, reject) => {
-    output.on('close', function () {
-      console.log("".concat(outputFile, " saved."));
-      console.log("".concat(archive.pointer(), " total bytes"));
-      resolve(null);
-    });
-    output.on('end', function () {
-      console.log('Data has been drained');
-      resolve(null);
-    });
-    archive.on('warning', function (err) {
-      console.log(err);
-      reject(err);
+    catch (e) {
+        // Do nothing if old file doesn't exist
+    }
+    const output = (0, fs_1.createWriteStream)(outputFile);
+    const archive = (0, archiver_1.default)('zip', {
+        zlib: { level } // Sets the compression level.
     });
-    archive.on('error', function (err) {
-      reject(err);
+    return new Promise(async (resolve, reject) => {
+        // listen for all archive data to be writte
+        // 'close' event is fired only when a file descriptor is involved
+        output.on('close', function () {
+            console.log(`${outputFile} saved.`); // eslint-disable-line no-undef,no-console
+            console.log(`${archive.pointer()} total bytes`); // eslint-disable-line no-undef,no-console
+            resolve(null);
+        });
+        // This event is fired when the data source is drained no matter what was the data source.
+        // It is not part of this library but rather from the NodeJS Stream API.
+        // @see: https://nodejs.org/api/stream.html#stream_event_end
+        output.on('end', function () {
+            console.log('Data has been drained'); // eslint-disable-line no-undef,no-console
+            resolve(null);
+        });
+        // good practice to catch warnings (ie stat failures and other non-blocking errors)
+        archive.on('warning', function (err) {
+            console.log(err); // eslint-disable-line no-undef,no-console
+            reject(err);
+        });
+        // good practice to catch this error explicitly
+        archive.on('error', function (err) {
+            reject(err);
+        });
+        // pipe archive data to the file
+        archive.pipe(output);
+        for (const subFileName in fileMap) {
+            const subFileData = fileMap[subFileName];
+            await appendFileToArchive(archive, subFileName, subFileData);
+        }
+        // finalize the archive (ie we are done appending files but streams have to finish yet)
+        archive.finalize();
     });
-    archive.pipe(output);
-
-    for (const subFileName in fileMap) {
-      const subFileData = fileMap[subFileName];
-      await appendFileToArchive(archive, subFileName, subFileData);
-    }
-
-    archive.finalize();
-  });
 }
-export async function compressWithChildProcess() {
-  if (process.platform === 'win32') {
-    await compressWithChildProcessWindows(...arguments);
-  } else {
-    await compressWithChildProcessUnix(...arguments);
-  }
+exports.compressFilesWithZip = compressFilesWithZip;
+/**
+ * Compress files using external tool 'zip'/'7z'
+ *
+ * @param inputFolder - folder to archive - for cwd option
+ * @param outputFile - output slpk file
+ * @param level - compression level
+ * @param inputFiles - input files path to pass to the executable as option
+ * @param sevenZipExe - path to 7z.exe executable
+ */
+async function compressWithChildProcess(inputFolder, outputFile, level, inputFiles, sevenZipExe) {
+    // eslint-disable-next-line no-undef
+    if (process.platform === 'win32') {
+        await compressWithChildProcessWindows(inputFolder, outputFile, level, inputFiles, sevenZipExe);
+    }
+    else {
+        await compressWithChildProcessUnix(inputFolder, outputFile, level, inputFiles);
+    }
 }
-
+exports.compressWithChildProcess = compressWithChildProcess;
+/**
+ * Compress files using external linux tool 'zip'
+ *
+ * @param inputFolder - folder to archive - for cwd option
+ * @param outputFile - output slpk file
+ * @param level - compression level
+ * @param inputFiles - input files path to pass to the executable as option
+ */
 async function compressWithChildProcessUnix(inputFolder, outputFile, level = 0, inputFiles = '.') {
-  const fullOutputFile = getAbsoluteFilePath(outputFile);
-  const args = ["-".concat(level), '-r', fullOutputFile, inputFiles];
-  const childProcess = new ChildProcessProxy();
-  await childProcess.start({
-    command: 'zip',
-    arguments: args,
-    spawn: {
-      cwd: inputFolder
-    },
-    wait: 0
-  });
-}
-
-async function compressWithChildProcessWindows(inputFolder, outputFile, level = 0, inputFiles = join('.', '*'), sevenZipExe) {
-  if (inputFiles[0] === '@') {
-    inputFiles = "*".concat(inputFiles.substr(1));
-  }
-
-  const fullOutputFile = getAbsoluteFilePath(outputFile);
-  const args = ['a', '-tzip', "-mx=".concat(level), fullOutputFile, inputFiles];
-  const childProcess = new ChildProcessProxy();
-  await childProcess.start({
-    command: sevenZipExe,
-    arguments: args,
-    spawn: {
-      cwd: "".concat(inputFolder)
-    },
-    wait: 0
-  });
+    const fullOutputFile = (0, file_utils_2.getAbsoluteFilePath)(outputFile);
+    const args = [`-${level}`, '-r', fullOutputFile, inputFiles];
+    const childProcess = new worker_utils_1.ChildProcessProxy();
+    await childProcess.start({
+        command: 'zip',
+        arguments: args,
+        spawn: {
+            cwd: inputFolder
+        },
+        wait: 0
+    });
 }
-
-export async function generateHash128FromZip(inputZipFile, outputFile) {
-  const input = await fs.readFile(inputZipFile);
-  const zip = await JSZip.loadAsync(input);
-  const hashTable = [];
-  const zipFiles = zip.files;
-
-  for (const relativePath in zipFiles) {
-    const zipEntry = zipFiles[relativePath];
-    const _data = '_data';
-    const content = zipEntry[_data].compressedContent;
-    if (zipEntry.dir) continue;
-    const hash = await new MD5Hash().hash(Buffer.from(relativePath.toLowerCase()));
-    hashTable.push({
-      key: atob(hash),
-      value: content.byteOffset
+/**
+ * Compress files using windows external tool '7z'
+ *
+ * @param inputFolder - folder to archive - for cwd option
+ * @param outputFile - output slpk file
+ * @param level - compression level
+ * @param inputFiles - input files path to pass to the executable as option
+ * @param sevenZipExe - path to 7z.exe executable
+ */
+async function compressWithChildProcessWindows(inputFolder, outputFile, level = 0, inputFiles = (0, path_1.join)('.', '*'), sevenZipExe) {
+    // Workaround for @listfile issue. In 7z.exe @-leading files are handled as listfiles
+    // https://sevenzip.osdn.jp/chm/cmdline/syntax.htm
+    if (inputFiles[0] === '@') {
+        inputFiles = `*${inputFiles.substr(1)}`;
+    }
+    const fullOutputFile = (0, file_utils_2.getAbsoluteFilePath)(outputFile);
+    const args = ['a', '-tzip', `-mx=${level}`, fullOutputFile, inputFiles];
+    const childProcess = new worker_utils_1.ChildProcessProxy();
+    await childProcess.start({
+        command: sevenZipExe,
+        arguments: args,
+        spawn: {
+            cwd: `${inputFolder}`
+        },
+        wait: 0
     });
-  }
-
-  hashTable.sort((prev, next) => {
-    if (prev.key === next.key) {
-      return prev.value < next.value ? -1 : 1;
+}
+/**
+ * Generate hash file from zip archive
+ * https://github.com/Esri/i3s-spec/blob/master/docs/1.7/slpk_hashtable.cmn.md
+ *
+ * @param inputZipFile
+ * @param outputFile
+ */
+async function generateHash128FromZip(inputZipFile, outputFile) {
+    const input = await fs_1.promises.readFile(inputZipFile);
+    const zip = await jszip_1.default.loadAsync(input);
+    const hashTable = [];
+    const zipFiles = zip.files;
+    for (const relativePath in zipFiles) {
+        const zipEntry = zipFiles[relativePath];
+        // Had to use a workaround because the correct string is getting the wrong data
+        // const content = await zipEntry.async('nodebuffer');
+        // _data isn't described in the interface, so lint thought it was wrong
+        const _data = '_data';
+        const content = zipEntry[_data].compressedContent;
+        if (zipEntry.dir)
+            continue; // eslint-disable-line no-continue
+        // eslint-disable-next-line no-undef
+        const hash = await new crypto_1.MD5Hash().hash(Buffer.from(relativePath.toLowerCase()));
+        // eslint-disable-next-line no-undef
+        hashTable.push({ key: atob(hash), value: content.byteOffset });
     }
-
-    return prev.key < next.key ? -1 : 1;
-  });
-  const output = createWriteStream(outputFile);
-  return new Promise((resolve, reject) => {
-    output.on('close', function () {
-      console.log("".concat(outputFile, " generated and saved"));
-      resolve(null);
+    hashTable.sort((prev, next) => {
+        if (prev.key === next.key) {
+            return prev.value < next.value ? -1 : 1;
+        }
+        return prev.key < next.key ? -1 : 1;
     });
-    output.on('error', function (err) {
-      console.log(err);
-      reject(err);
+    const output = (0, fs_1.createWriteStream)(outputFile);
+    return new Promise((resolve, reject) => {
+        output.on('close', function () {
+            console.log(`${outputFile} generated and saved`); // eslint-disable-line
+            resolve(null);
+        });
+        output.on('error', function (err) {
+            console.log(err); // eslint-disable-line
+            reject(err);
+        });
+        for (const key in hashTable) {
+            const item = hashTable[key];
+            const value = longToByteArray(item.value);
+            // TODO: perhaps you need to wait for the 'drain' event if the write returns 'false'
+            // eslint-disable-next-line no-undef
+            output.write(Buffer.from(crypt_1.default.hexToBytes(item.key).concat(value)));
+        }
+        output.close();
     });
-
-    for (const key in hashTable) {
-      const item = hashTable[key];
-
-      const value = _longToByteArray(item.value);
-
-      output.write(Buffer.from(crypt.hexToBytes(item.key).concat(value)));
-    }
-
-    output.close();
-  });
 }
-
-function _longToByteArray(long) {
-  const buffer = new ArrayBuffer(8);
-  const longNum = new Float64Array(buffer);
-  longNum[0] = long;
-  return Array.from(new Uint8Array(buffer)).reverse();
+exports.generateHash128FromZip = generateHash128FromZip;
+/**
+ * Encode 64 bit value to byte array
+ *
+ * @param long - stringified number
+ * @returns
+ */
+function longToByteArray(long) {
+    const buffer = new ArrayBuffer(8); // JS numbers are 8 bytes long, or 64 bits
+    const longNum = new Float64Array(buffer); // so equivalent to Float64
+    longNum[0] = parseInt(long);
+    return Array.from(new Uint8Array(buffer)).reverse(); // reverse to get little endian
 }
-
-export async function addFileToZip(inputFolder, fileName, zipFile, sevenZipExe) {
-  await compressWithChildProcess(inputFolder, zipFile, 0, fileName, sevenZipExe);
-  console.log("".concat(fileName, " added to ").concat(zipFile, "."));
+/**
+ * Add file to zip archive
+ *
+ * @param inputFile
+ * @param fileName
+ * @param zipFile
+ * @param sevenZipExe
+ */
+async function addFileToZip(inputFolder, fileName, zipFile, sevenZipExe) {
+    await compressWithChildProcess(inputFolder, zipFile, 0, fileName, sevenZipExe);
+    console.log(`${fileName} added to ${zipFile}.`); // eslint-disable-line
 }
-
+exports.addFileToZip = addFileToZip;
+/**
+ *
+ * @param archive zip archive instance
+ * @param subFileName file path inside archive
+ * @param subFileData source file path
+ * @returns
+ */
 function appendFileToArchive(archive, subFileName, subFileData) {
-  return new Promise(resolve => {
-    const fileStream = createReadStream(subFileData);
-    console.log("Compression start: ".concat(subFileName));
-    fileStream.on('close', () => {
-      console.log("Compression finish: ".concat(subFileName));
-      resolve(null);
-    });
-    archive.append(fileStream, {
-      name: subFileName
+    return new Promise((resolve) => {
+        const fileStream = (0, fs_1.createReadStream)(subFileData);
+        console.log(`Compression start: ${subFileName}`); // eslint-disable-line no-undef,no-console
+        fileStream.on('close', () => {
+            console.log(`Compression finish: ${subFileName}`); // eslint-disable-line no-undef,no-console
+            resolve(null);
+        });
+        archive.append(fileStream, { name: subFileName });
     });
-  });
 }
-//# sourceMappingURL=compress-util.js.map

package/dist/lib/utils/file-utils.d.ts

@@ -5,8 +5,7 @@
  * @param data - file content
  * @param fileName - name of output file (default: index.json)
  */
-export function writeFile(path: string, data: string | Uint8Array | ArrayBuffer, fileName?: string);
-
+export declare function writeFile(path: string, data: string | Uint8Array | ArrayBuffer | Promise<ArrayBuffer>, fileName?: string): Promise<string>;
 /**
  * Write a file with data and name fileName to path - specific one for further packaging into slpk
  *
@@ -14,30 +13,39 @@ export function writeFile(path: string, data: string | Uint8Array | ArrayBuffer,
  * @param data - file content
  * @param fileName - name of output file (default: index.json)
  * @param compress - if need to compress file with gzip (default: true)
+ * @param compressList - if set - the file should be added to this list and compressed in the end of conversion
  */
-export function writeFileForSlpk(
-  path: string,
-  data: string | Uint8Array | ArrayBuffer,
-  fileName?: string,
-  compress?: boolean
-);
-
+export declare function writeFileForSlpk(path: string, data: string | Uint8Array | ArrayBuffer | Promise<ArrayBuffer>, fileName?: string, compress?: boolean, compressList?: string[] | null): Promise<string | null>;
+/**
+ * Open json file
+ * @param path - path to the file
+ * @param fileName - file name
+ * @returns object
+ */
+export declare function openJson(path: string, fileName: string): Promise<{
+    [key: string]: any;
+}>;
+/**
+ * Check if the file exists
+ * @param fileName - full name of file
+ * @returns true if file exists, otherwise - false
+ */
+export declare function isFileExists(fileName: string): Promise<boolean>;
 /**
  * Remove dir with path
  *
  * @param path
  */
-export function removeDir(path: string): Promise<void>;
-
+export declare function removeDir(path: string): Promise<void>;
 /**
  * Remove file with path
  *
  * @param path
  */
-export function removeFile(path: string): Promise<void>;
-
+export declare function removeFile(path: string): Promise<void>;
 /**
  * Generates absolute file path
  * @param filePath
  */
-export function getAbsoluteFilePath(filePath: string): string;
+export declare function getAbsoluteFilePath(filePath: string): string;
+//# sourceMappingURL=file-utils.d.ts.map

package/dist/lib/utils/file-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/file-utils.ts"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,EAC9D,QAAQ,GAAE,MAAqB,GAC9B,OAAO,CAAC,MAAM,CAAC,CAkBjB;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,EAC9D,QAAQ,GAAE,MAAqB,EAC/B,QAAQ,GAAE,OAAc,EACxB,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,GAC7B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkBxB;AAED;;;;;GAKG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,CAAC,CAoB5F;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOrE;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,iBAErC;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,iBAEtC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,UAEnD"}

package/dist/lib/utils/file-utils.js

@@ -1,41 +1,138 @@
-import { promises as fs } from 'fs';
-import { isAbsolute, join } from 'path';
-import { compressFileWithGzip } from './compress-util';
-export async function writeFile(path, data, fileName = 'index.json') {
-  await fs.mkdir(path, {
-    recursive: true
-  });
-  const pathFile = join(path, fileName);
-
-  try {
-    await fs.writeFile(pathFile, data);
-  } catch (err) {
-    throw err;
-  }
-
-  console.log("".concat(pathFile, " saved."));
-  return pathFile;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAbsoluteFilePath = exports.removeFile = exports.removeDir = exports.isFileExists = exports.openJson = exports.writeFileForSlpk = exports.writeFile = void 0;
+const core_1 = require("@loaders.gl/core");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const compress_util_1 = require("./compress-util");
+/**
+ * Write a file with data and name fileName to path
+ *
+ * @param path - output path
+ * @param data - file content
+ * @param fileName - name of output file (default: index.json)
+ */
+async function writeFile(path, data, fileName = 'index.json') {
+    let toWriteData;
+    if (data instanceof Promise) {
+        toWriteData = new Uint8Array(await data);
+    }
+    else if (data instanceof ArrayBuffer) {
+        toWriteData = new Uint8Array(data);
+    }
+    else {
+        toWriteData = data;
+    }
+    await fs_1.promises.mkdir(path, { recursive: true });
+    const pathFile = (0, path_1.join)(path, fileName);
+    try {
+        await fs_1.promises.writeFile(pathFile, toWriteData);
+    }
+    catch (err) {
+        throw err;
+    }
+    console.log(`${pathFile} saved.`); // eslint-disable-line
+    return pathFile;
 }
-export async function writeFileForSlpk(path, data, fileName = 'index.json', compress = true) {
-  const pathFile = await writeFile(path, data, fileName);
-
-  if (compress) {
-    const pathGzFile = await compressFileWithGzip(pathFile);
-    await removeFile(pathFile);
-    return pathGzFile;
-  }
-
-  return pathFile;
+exports.writeFile = writeFile;
+/**
+ * Write a file with data and name fileName to path - specific one for further packaging into slpk
+ *
+ * @param path - output path
+ * @param data - file content
+ * @param fileName - name of output file (default: index.json)
+ * @param compress - if need to compress file with gzip (default: true)
+ * @param compressList - if set - the file should be added to this list and compressed in the end of conversion
+ */
+async function writeFileForSlpk(path, data, fileName = 'index.json', compress = true, compressList) {
+    const pathFile = await writeFile(path, data, fileName);
+    if (compress) {
+        if (compressList) {
+            if (!compressList.includes(pathFile)) {
+                compressList.push(pathFile);
+                return `${pathFile}.gz`;
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            const pathGzFile = await (0, compress_util_1.compressFileWithGzip)(pathFile);
+            // After compression, we don't need an uncompressed file
+            await removeFile(pathFile);
+            return pathGzFile;
+        }
+    }
+    return pathFile;
 }
-export function removeDir(path) {
-  return fs.rmdir(path, {
-    recursive: true
-  });
+exports.writeFileForSlpk = writeFileForSlpk;
+/**
+ * Open json file
+ * @param path - path to the file
+ * @param fileName - file name
+ * @returns object
+ */
+async function openJson(path, fileName) {
+    return new Promise((resolve, reject) => {
+        let count = 0;
+        console.log(`load ${path}/${fileName}.`); // eslint-disable-line
+        const intervalId = setInterval(() => {
+            const pathFile = (0, path_1.join)(path, fileName);
+            (0, core_1.load)(pathFile, loader_utils_1.JSONLoader)
+                .then((result) => {
+                clearInterval(intervalId);
+                resolve(result);
+            })
+                .catch(() => {
+                count++;
+                if (count > 100) {
+                    clearInterval(intervalId);
+                    reject(new Error(`Cannon load ${path}/${fileName}.`));
+                }
+            });
+        }, 200);
+    });
 }
-export function removeFile(path) {
-  return fs.unlink(path);
+exports.openJson = openJson;
+/**
+ * Check if the file exists
+ * @param fileName - full name of file
+ * @returns true if file exists, otherwise - false
+ */
+async function isFileExists(fileName) {
+    try {
+        await fs_1.promises.stat(fileName);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
-export function getAbsoluteFilePath(filePath) {
-  return isAbsolute(filePath) ? filePath : join(process.cwd(), filePath);
+exports.isFileExists = isFileExists;
+/**
+ * Remove dir with path
+ *
+ * @param path
+ */
+function removeDir(path) {
+    return fs_1.promises.rmdir(path, { recursive: true });
 }
-//# sourceMappingURL=file-utils.js.map
+exports.removeDir = removeDir;
+/**
+ * Remove file with path
+ *
+ * @param path
+ */
+function removeFile(path) {
+    return fs_1.promises.unlink(path);
+}
+exports.removeFile = removeFile;
+/**
+ * Generates absolute file path
+ * @param filePath
+ */
+function getAbsoluteFilePath(filePath) {
+    return (0, path_1.isAbsolute)(filePath) ? filePath : (0, path_1.join)(process.cwd(), filePath);
+}
+exports.getAbsoluteFilePath = getAbsoluteFilePath;