tnp-helpers 19.0.2 → 19.0.4

package/lib/helpers/for-backend/helpers-file-folders.backend.js

@@ -0,0 +1,896 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelpersFileFolders = void 0;
+const tnp_core_1 = require("tnp-core");
+const underscore = require("underscore");
+const glob = require("glob");
+const crypto = require("crypto");
+const index_1 = require("../../index");
+const tnp_config_1 = require("tnp-config");
+class HelpersFileFolders {
+    /**
+     * Calculate file or string checksum
+     */
+    checksum(absolutePathToFileOrContent, algorithm) {
+        const fileContent = tnp_core_1.path.isAbsolute(absolutePathToFileOrContent)
+            ? index_1.Helpers.readFile(absolutePathToFileOrContent)
+            : absolutePathToFileOrContent;
+        return crypto
+            .createHash(algorithm || 'md5')
+            .update(fileContent, 'utf8')
+            .digest('hex');
+    }
+    getValueFromJSON(filepath, lodashGetPath, defaultValue = void 0) {
+        if (!tnp_core_1.fse.existsSync(filepath)) {
+            return defaultValue;
+        }
+        const json = index_1.Helpers.readJson(filepath);
+        return tnp_core_1._.get(json, lodashGetPath, defaultValue);
+    }
+    getValueFromJSONC(filepath, lodashGetPath, defaultValue = void 0) {
+        if (!tnp_core_1.fse.existsSync(filepath)) {
+            return defaultValue;
+        }
+        const json = index_1.Helpers.readJson5(filepath);
+        return tnp_core_1._.get(json, lodashGetPath, defaultValue);
+    }
+    readValueFromJson(filepath, lodashGetPath, defaultValue = void 0) {
+        return index_1.Helpers.getValueFromJSON(filepath, lodashGetPath, defaultValue);
+    }
+    readValueFromJsonC(filepath, lodashGetPath, defaultValue = void 0) {
+        return index_1.Helpers.getValueFromJSONC(filepath, lodashGetPath, defaultValue);
+    }
+    setValueToJSON(filepath, lodashGetPath, value) {
+        if (!tnp_core_1.fse.existsSync(filepath)) {
+            index_1.Helpers.warn(`Recreating unexised json file: ${filepath}`);
+            index_1.Helpers.writeFile(filepath, '{}');
+        }
+        const json = index_1.Helpers.readJson(filepath);
+        tnp_core_1._.set(json, lodashGetPath, value);
+        index_1.Helpers.writeJson(filepath, json);
+    }
+    setValueToJSONC(filepath, lodashGetPath, value) {
+        if (!tnp_core_1.fse.existsSync(filepath)) {
+            index_1.Helpers.warn(`Recreating unexised json file: ${filepath}`);
+            index_1.Helpers.writeFile(filepath, '{}');
+        }
+        const json = index_1.Helpers.readJsonC(filepath);
+        tnp_core_1._.set(json, lodashGetPath, value);
+        index_1.Helpers.writeJsonC(filepath, json);
+    }
+    /**
+     * file size in bytes
+     */
+    size(filePath) {
+        if (!index_1.Helpers.exists(filePath) || index_1.Helpers.isFolder(filePath)) {
+            return null;
+        }
+        return tnp_core_1.fse.lstatSync(filePath).size;
+    }
+    pathFromLink(filePath) {
+        return tnp_core_1.fse.readlinkSync(filePath);
+    }
+    // renameFolder(from: string, to: string, cwd?: string) {
+    //   // const command = `mv  ${from}  ${to}`;
+    //   const command = `renamer --find  ${from}  --replace  ${to} *`;
+    //   Helpers.run(command, { cwd }).sync()
+    // }
+    /**
+     * @deprecated
+     */
+    renameFolder(from, to, cwd) {
+        index_1.Helpers.renameFiles(from, to, cwd);
+    }
+    /**
+     * @deprecated
+     */
+    renameFiles(from, to, cwd) {
+        try {
+            const directoryPath = cwd || '.';
+            // Read all files in the directory
+            const files = tnp_core_1.fse.readdirSync(directoryPath);
+            files.forEach(file => {
+                // Check if the file name includes the 'from' pattern
+                if (file.includes(from)) {
+                    const newFileName = file.replace(from, to);
+                    const currentPath = tnp_core_1.path.join(directoryPath, file);
+                    const newPath = tnp_core_1.path.join(directoryPath, newFileName);
+                    // Rename the file
+                    tnp_core_1.fse.renameSync(currentPath, newPath);
+                    console.log(`Renamed file from ${currentPath} to ${newPath}`);
+                }
+            });
+        }
+        catch (error) {
+            console.error(`Error renaming files from ${from} to ${to}:`, error);
+        }
+    }
+    getTempFolder() {
+        let tmp = '/tmp';
+        if (process.platform === 'darwin') {
+            tmp = '/private/tmp';
+        }
+        if (process.platform === 'win32') {
+            tmp = (0, tnp_core_1.crossPlatformPath)(tnp_core_1.path.join((0, tnp_core_1.crossPlatformPath)(tnp_core_1.os.homedir()), '/AppData/Local/Temp'));
+        }
+        if (!index_1.Helpers.exists(tmp)) {
+            index_1.Helpers.mkdirp(tmp);
+        }
+        return tmp;
+    }
+    // createMultiplatformLink(target: string, link: string) {
+    //   if (this.isPlainFileOrFolder(link)) {
+    //     link = path.join(process.cwd(), link);
+    //   }
+    //   let command: string;
+    //   if (os.platform() === 'win32') {
+    //     if (target.startsWith('./')) {
+    //       target = path.win32.normalize(path.join(process.cwd(), path.basename(target)))
+    //     } else {
+    //       if (target === '.' || target === './') {
+    //         target = path.win32.normalize(path.join(process.cwd(), path.basename(link)))
+    //       } else {
+    //         target = path.win32.normalize(path.join(target, path.basename(link)))
+    //       }
+    //     }
+    //     if (fse.existsSync(target)) {
+    //       fse.unlinkSync(target);
+    //     }
+    //     target = path.win32.normalize(target)
+    //     if (link === '.' || link === './') {
+    //       link = process.cwd()
+    //     }
+    //     link = path.win32.normalize(link);
+    //     // if (path.resolve(target) === path.resolve(link)) { // TODO
+    //     //   Helpers.warn(`[createMultiplatformLink][win32] Trying to link same location`);
+    //     //   return;
+    //     // }
+    //     command = "mklink \/D "
+    //       + target
+    //       + " "
+    //       + link
+    //       + " >nul 2>&1 "
+    //   } else {
+    //     if (target.startsWith('./')) {
+    //       target = target.replace(/^\.\//g, '');
+    //     }
+    //     if (link === '.' || link === './') {
+    //       link = process.cwd()
+    //     }
+    //     if (path.resolve(target) === path.resolve(link)) {
+    //       Helpers.warn(`[createMultiplatformLink] Trying to link same location`);
+    //       return;
+    //     }
+    //     command = `ln -sf "${link}" "${target}"`;
+    //   }
+    //   child_process.execSync(command);
+    // }
+    isPlainFileOrFolder(filePath) {
+        return /^([a-zA-Z]|\-|\_|\@|\#|\$|\!|\^|\&|\*|\(|\))+$/.test(filePath);
+    }
+    /**
+     * @deprecated
+     * use import (or modules only on backend)
+     */
+    requireUncached(module) {
+        delete require.cache[require.resolve(module)];
+        return require(module);
+    }
+    /**
+     * @deprecated
+     * use import (or modules only on backend)
+     *
+     * get default export object from  js file
+     * @param jsFilePath
+     */
+    require(jsFilePath) {
+        //#region @backendFunc
+        const orgPath = jsFilePath;
+        if (!tnp_core_1.fse.existsSync(jsFilePath)) {
+            jsFilePath = `${jsFilePath}.js`;
+        }
+        if (!tnp_core_1.fse.existsSync(jsFilePath)) {
+            index_1.Helpers.error(`Not able to find path: ${orgPath}`);
+        }
+        let fileContent = tnp_core_1.fse.readFileSync(jsFilePath).toLocaleString();
+        (() => {
+            const stringForRegex = `require\\(("|')\\.\\/([a-zA-Z0-9]|\\/|\\-|\\_|\\+|\\.)*("|')\\)`;
+            index_1.Helpers.log(`[taon-helpre][require][${jsFilePath}] stringForRegex: ${stringForRegex}`, 1);
+            fileContent = fileContent
+                .split('\n')
+                .map(line => {
+                const matches = line.match(new RegExp(stringForRegex));
+                if (matches !== null) {
+                    // console.log('matched', matches)
+                    const rep = tnp_core_1._.first(matches);
+                    if (rep) {
+                        const newFilename = (0, tnp_core_1.crossPlatformPath)([
+                            tnp_core_1.path.dirname(jsFilePath),
+                            rep.split('(')[1].replace(/("|'|\))/g, ''),
+                        ]);
+                        line = line.replace(rep, `require('${newFilename}')`);
+                    }
+                    // console.log(line)
+                }
+                // console.log('matched', matches)
+                return line;
+            })
+                .join('\n');
+        })();
+        (() => {
+            const stringForRegex = `require\\(("|')([a-zA-Z0-9]|\\/|\\-|\\_|\\+|\\.)*("|')\\)`;
+            index_1.Helpers.log(`[taon-helpre][require][${jsFilePath}] stringForRegex: ${stringForRegex}`, 1);
+            fileContent = fileContent
+                .split('\n')
+                .map(line => {
+                // console.log(`LINE: "${line}"`)
+                const matches = line.match(new RegExp(stringForRegex));
+                if (matches !== null) {
+                    // console.log('matched', matches)
+                    const rep = tnp_core_1._.first(matches);
+                    if (rep) {
+                        const relativePart = rep.split('(')[1].replace(/("|'|\))/g, '');
+                        // console.log(`RELATIVE PART: "${relativePart}"`)
+                        if (relativePart.search('/') !== -1 &&
+                            !relativePart.startsWith('/')) {
+                            const newFilename = (0, tnp_core_1.crossPlatformPath)([
+                                tnp_core_1.path.dirname(jsFilePath),
+                                'node_modules',
+                                relativePart,
+                            ]);
+                            line = line.replace(rep, `require('${newFilename}')`);
+                        }
+                    }
+                    // console.log(line)
+                }
+                // console.log('matched', matches)
+                return line;
+            })
+                .join('\n');
+        })();
+        return eval(fileContent);
+        //#endregion
+    }
+    tryRecreateDir(dirpath) {
+        try {
+            index_1.Helpers.mkdirp(dirpath);
+        }
+        catch (error) {
+            index_1.Helpers.log(`Trying to recreate directory: ${dirpath}`);
+            index_1.Helpers.sleep(1);
+            index_1.Helpers.mkdirp(dirpath);
+        }
+    }
+    /**
+     * @deprecated
+     */
+    tryCopyFrom(source, destination, options = {}) {
+        index_1.Helpers.log(`Trying to copy from: ${source} to ${destination}`);
+        destination = (0, tnp_core_1.crossPlatformPath)(destination);
+        source = (0, tnp_core_1.crossPlatformPath)(source);
+        if (source === destination) {
+            index_1.Helpers.warn('[taon-helpers] Probably error... trying to copy the same folder...');
+            return;
+        }
+        if (tnp_core_1.fse.existsSync(source) && !tnp_core_1.fse.lstatSync(source).isDirectory()) {
+            // Helpers.warn(`[tryCopyFrom] This source is not directory: ${source} to ${destination}`);
+            index_1.Helpers.copyFile(source, destination);
+            return;
+        }
+        if (tnp_core_1.fse.existsSync(destination.replace(/\/$/, ''))) {
+            const destMaybe = destination.replace(/\/$/, '');
+            const stats = tnp_core_1.fse.lstatSync(destMaybe);
+            const isNotDirectory = !stats.isDirectory();
+            const isSymbolicLink = stats.isSymbolicLink();
+            if (isNotDirectory || isSymbolicLink) {
+                tnp_core_1.rimraf.sync(destMaybe);
+            }
+        }
+        options = tnp_core_1._.merge({
+            overwrite: true,
+            recursive: true,
+        }, options);
+        if (process.platform === 'win32') {
+            // TODO QUICK_FIX
+            options['dereference'] = true;
+        }
+        try {
+            tnp_core_1.fse.copySync(source, destination, options);
+        }
+        catch (error) {
+            tnp_core_1.rimraf.sync(destination);
+            tnp_core_1.fse.copySync(source, destination, options);
+        }
+    }
+    // private deleteFolderRecursive = (pathToFolder) => {
+    //   if (fs.existsSync(pathToFolder)) {
+    //     fs.readdirSync(pathToFolder).forEach((file, index) => {
+    //       const curPath = path.join(pathToFolder, file);
+    //       if (fs.lstatSync(curPath).isDirectory()) { // recurse
+    //         this.deleteFolderRecursive(curPath);
+    //       } else { // delete file
+    //         fs.unlinkSync(curPath);
+    //       }
+    //     });
+    //     fs.rmdirSync(pathToFolder);
+    //   }
+    // };
+    move(from, to) {
+        if (!tnp_core_1.fse.existsSync(from)) {
+            index_1.Helpers.warn(`[move] File or folder doesnt not exists: ${from}`);
+            return;
+        }
+        if (!tnp_core_1.path.isAbsolute(from)) {
+            index_1.Helpers.warn(`[move] Source path is not absolute: ${from}`);
+            return;
+        }
+        if (!tnp_core_1.path.isAbsolute(to)) {
+            index_1.Helpers.warn(`[move] Destination path is not absolute: ${to}`);
+            return;
+        }
+        if (index_1.Helpers.isUnexistedLink(to)) {
+            index_1.Helpers.remove(to);
+        }
+        if (index_1.Helpers.isUnexistedLink(tnp_core_1.path.dirname(to))) {
+            index_1.Helpers.remove(tnp_core_1.path.dirname(to));
+        }
+        // if (!Helpers.exists(path.dirname(to))) {
+        //   if (Helpers.isUnexistedLink(path.dirname(to))) {
+        //     Helpers.remove(path.dirname(to));
+        //   } else  {
+        //     Helpers.remove(path.dirname(to));
+        //     Helpers.mkdirp(path.dirname(to));
+        //   }
+        // }
+        // if(Helpers.isSymlinkFileExitedOrUnexisted(to)) {
+        //   Helpers.error(`You are trying to move into symlink location:
+        //   from: ${from}
+        //   to: ${to}
+        //   `)
+        // }
+        while (true) {
+            try {
+                tnp_core_1.fse.moveSync(from, to, {
+                    overwrite: true,
+                });
+                break;
+            }
+            catch (error) {
+                if (global['tnpNonInteractive']) {
+                    console.log(error);
+                    index_1.Helpers.error(`[${tnp_config_1.config.frameworkName}-helpers] Not able to move files
+
+from: ${from}
+to: ${to}
+
+          `);
+                }
+                index_1.Helpers.info(`
+ Moving things:
+
+from: ${from}
+to: ${to}
+
+        `);
+                index_1.Helpers.pressKeyAndContinue('Press any to try again this action');
+            }
+        }
+    }
+    findChildren(location, createFn, options) {
+        const { allowAllNames } = options || {};
+        let folders = index_1.Helpers.values(tnp_config_1.config.folder);
+        folders = folders.filter(f => ![
+            tnp_config_1.config.folder.shared,
+            // TODO add something more here ?
+        ].includes(f));
+        const notAllowed = [
+            '.vscode',
+            'node_modules',
+            ...(allowAllNames
+                ? []
+                : [
+                    ...folders,
+                    'e2e',
+                    'tmp.*',
+                    'dist.*',
+                    'tests',
+                    'module',
+                    'browser',
+                    'bundle*',
+                    'components',
+                    '.git',
+                    'bin',
+                    'custom',
+                ]),
+        ]
+            .filter(f => {
+            return ![tnp_config_1.config.folder.external].includes(f) && tnp_core_1._.isString(f);
+        })
+            .map(s => new RegExp(`^${index_1.Helpers.escapeStringForRegEx(s)}$`));
+        const isDirectory = (source) => tnp_core_1.fse.lstatSync(source).isDirectory();
+        const getDirectories = (source) => tnp_core_1.fse
+            .readdirSync(source)
+            .map(name => tnp_core_1.path.join(source, name))
+            .filter(isDirectory);
+        let subdirectories = getDirectories(location).filter(f => {
+            const folderNam = tnp_core_1.path.basename(f);
+            const allowed = notAllowed.filter(p => p.test(folderNam)).length === 0;
+            return allowed;
+        });
+        // console.log(subdirectories)
+        return subdirectories
+            .map(dir => {
+            // console.log('child:', dir)
+            return createFn(dir);
+        })
+            .filter(c => !!c);
+    }
+    /**
+     * @deprecated
+     */
+    findChildrenNavi(location, createFn) {
+        if (!tnp_core_1.fse.existsSync(location)) {
+            return [];
+        }
+        const notAllowed = [
+            '.vscode',
+            'node_modules',
+            ...index_1.Helpers.values(tnp_config_1.config.folder),
+            'e2e',
+            'tmp.*',
+            'dist.*',
+            'tests',
+            'module',
+            'browser',
+            'bundle*',
+            'components',
+            '.git',
+            '.build',
+            'bin',
+            'custom',
+        ].map(s => new RegExp(s));
+        const isDirectory = source => tnp_core_1.fse.lstatSync(source).isDirectory();
+        const getDirectories = source => tnp_core_1.fse
+            .readdirSync(source)
+            .map(name => tnp_core_1.path.join(source, name))
+            .filter(isDirectory);
+        let subdirectories = getDirectories(location).filter(f => {
+            const folderName = tnp_core_1.path.basename(f);
+            if (/.*es\-.*/.test(folderName)) {
+                return true;
+            }
+            return notAllowed.filter(p => p.test(folderName)).length === 0;
+        });
+        return subdirectories
+            .map(dir => {
+            return createFn(dir);
+        })
+            .filter(c => !!c);
+    }
+    /**
+     * get all files from folder
+     * absolute paths
+     */
+    getRecrusiveFilesFrom(dir, ommitFolders = [], options) {
+        options = options ? options : {};
+        // const withNameOnly = options.withNameOnly;
+        let files = [];
+        const readedFilesAndFolders = tnp_core_1.fse.existsSync(dir)
+            ? tnp_core_1.fse.readdirSync(dir)
+            : [];
+        const readed = readedFilesAndFolders
+            .map(relativePathToFile => {
+            const fullPath = (0, tnp_core_1.crossPlatformPath)([dir, relativePathToFile]);
+            // console.log(`is direcotry ${fse.lstatSync(fullPath).isDirectory()} `, fullPath)
+            if (tnp_core_1.fse.lstatSync(fullPath).isDirectory()) {
+                if (ommitFolders.includes(tnp_core_1.path.basename(fullPath)) ||
+                    ommitFolders.includes(tnp_core_1.path.basename(tnp_core_1.path.dirname(fullPath)))) {
+                    // Helpers.log(`Omitting: ${fullPath}`)
+                }
+                else {
+                    index_1.Helpers.getRecrusiveFilesFrom(fullPath, ommitFolders, options).forEach(aa => files.push(aa));
+                }
+                return;
+            }
+            return fullPath;
+        })
+            .filter(f => !!f);
+        if (Array.isArray(readed)) {
+            readed.forEach(r => files.push(r));
+        }
+        return files;
+    }
+    checkIfNameAllowedForTaonProj(folderName) {
+        const notAllowed = [
+            '^.vscode$',
+            '^node_modules$',
+            ...index_1.Helpers.values(tnp_config_1.config.tempFolders).map(v => `^${v}$`),
+            '^e2e$',
+            '^tmp.*',
+            '^dist.*',
+            '^tests$',
+            '^module$',
+            '^browser',
+            'bundle*',
+            '^components$',
+            '.git',
+            '^bin$',
+            '^custom$',
+            '^linked-repos$',
+        ].map(s => new RegExp(s));
+        return notAllowed.filter(p => p.test(folderName)).length === 0;
+    }
+    getLinesFromFiles(filename, lineCount) {
+        return new Promise((resolve, reject) => {
+            let stream = tnp_core_1.fse.createReadStream(filename, {
+                flags: 'r',
+                encoding: 'utf-8',
+                fd: null,
+                mode: 438, // 0666 in Octal
+                // bufferSize: 64 * 1024 as any
+            });
+            let data = '';
+            let lines = [];
+            stream.on('data', function (moreData) {
+                data += moreData;
+                lines = data.split('\n');
+                // probably that last line is "corrupt" - halfway read - why > not >=
+                if (lines.length > lineCount + 1) {
+                    stream.destroy();
+                    lines = lines.slice(0, lineCount); // junk as above
+                    resolve(lines);
+                }
+            });
+            stream.on('error', function () {
+                reject(`Error reading ${filename}`);
+            });
+            stream.on('end', function () {
+                resolve(lines);
+            });
+        });
+    }
+    /**
+     * Get the most recent changes file in direcory
+     * @param dir absoulute path to file
+     */
+    getMostRecentFileName(dir) {
+        let files = index_1.Helpers.getRecrusiveFilesFrom(dir);
+        // use underscore for max()
+        return underscore.max(files, f => {
+            // TODO refactor to lodash
+            // console.log(f);
+            // ctime = creation time is used
+            // replace with mtime for modification time
+            // console.log( `${fse.statSync(f).mtimeMs} for ${f}`   )
+            return tnp_core_1.fse.statSync(f).mtimeMs;
+        });
+    }
+    getMostRecentFilesNames(dir) {
+        const allFiles = index_1.Helpers.getRecrusiveFilesFrom(dir);
+        const mrf = index_1.Helpers.getMostRecentFileName(dir);
+        const mfrMtime = tnp_core_1.fse.lstatSync(mrf).mtimeMs;
+        return allFiles.filter(f => {
+            const info = tnp_core_1.fse.lstatSync(f);
+            return info.mtimeMs === mfrMtime && !info.isDirectory();
+        });
+    }
+    removeExcept(fromPath, exceptFolderAndFiles) {
+        tnp_core_1.fse
+            .readdirSync(fromPath)
+            .filter(f => {
+            return !exceptFolderAndFiles.includes(f);
+        })
+            .map(f => tnp_core_1.path.join(fromPath, f))
+            .forEach(af => index_1.Helpers.removeFolderIfExists(af));
+        glob
+            .sync(`${fromPath}/*.*`)
+            .filter(f => {
+            return !exceptFolderAndFiles.includes(tnp_core_1.path.basename(f));
+        })
+            .forEach(af => index_1.Helpers.removeFileIfExists(af));
+    }
+    copy(sourceDir, destinationDir, options) {
+        index_1.Helpers.log(`Copying from:
+
+    ${sourceDir}
+    to
+    ${destinationDir}
+
+    `, 1);
+        index_1.Helpers.log(options, 1);
+        // sourceDir = sourceDir ? (sourceDir.replace(/\/$/, '')) : sourceDir;
+        // destinationDir = destinationDir ? (destinationDir.replace(/\/$/, '')) : destinationDir;
+        if (!tnp_core_1.fse.existsSync(sourceDir)) {
+            index_1.Helpers.warn(`[taon-helper][copy] Source dir doesnt exist: ${sourceDir} for destination: ${destinationDir}`);
+            return;
+        }
+        if (!tnp_core_1.fse.existsSync(tnp_core_1.path.dirname(destinationDir))) {
+            if (index_1.Helpers.isUnexistedLink(tnp_core_1.path.dirname(destinationDir))) {
+                index_1.Helpers.removeFileIfExists(tnp_core_1.path.dirname(destinationDir));
+            }
+            index_1.Helpers.mkdirp(tnp_core_1.path.dirname(destinationDir));
+        }
+        if (!options) {
+            options = {};
+        }
+        if (tnp_core_1._.isUndefined(options.overwrite)) {
+            options.overwrite = true;
+        }
+        if (tnp_core_1._.isUndefined(options.recursive)) {
+            options.recursive = true;
+        }
+        if (tnp_core_1._.isUndefined(options.useTempFolder)) {
+            options.useTempFolder = false;
+        }
+        if (options.copySymlinksAsFiles) {
+            options['dereference'] = true;
+        }
+        if (!options.omitFolders) {
+            options.omitFolders = [];
+        }
+        if (options.asSeparatedFilesSymlinkAsFile) {
+            options.asSeparatedFilesSymlinkAsFile = true;
+        }
+        // const [srcStat, destStat] = [
+        //   fse.existsSync(sourceDir) && fse.statSync(sourceDir),
+        //   fse.existsSync(destinationDir) && fse.statSync(destinationDir),
+        // ];
+        // if (destStat && destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev) {
+        //   Helpers.warn(`[taon-helper][copy] Same location stats.. Trying to copy same source and destination:
+        //   from: ${sourceDir}
+        //   to: ${destinationDir}
+        //   `);
+        //   return;
+        // }
+        if (tnp_core_1._.isArray(options.omitFolders) &&
+            options.omitFolders.length >= 1 &&
+            tnp_core_1._.isNil(options.filter) &&
+            tnp_core_1._.isString(options.omitFoldersBaseFolder) &&
+            tnp_core_1.path.isAbsolute(options.omitFoldersBaseFolder)) {
+            options.filter = index_1.Helpers.filterDontCopy(options.omitFolders, options.omitFoldersBaseFolder);
+        }
+        if (options.copySymlinksAsFilesDeleteUnexistedLinksFromSourceFirst) {
+            const files = index_1.Helpers.filesFrom(sourceDir, true, true);
+            for (let index = 0; index < files.length; index++) {
+                const file = files[index];
+                if (index_1.Helpers.isUnexistedLink(file)) {
+                    index_1.Helpers.remove(file, true);
+                }
+            }
+        }
+        if ((0, tnp_core_1.crossPlatformPath)(sourceDir) === (0, tnp_core_1.crossPlatformPath)(destinationDir) ||
+            (0, tnp_core_1.crossPlatformPath)(tnp_core_1.path.resolve(sourceDir)) ===
+                (0, tnp_core_1.crossPlatformPath)(tnp_core_1.path.resolve(destinationDir))) {
+            index_1.Helpers.warn(`[taon-helper][copy] Trying to copy same source and destination
+      from: ${sourceDir}
+      to: ${destinationDir}
+      `);
+        }
+        else {
+            // Helpers.warn('filter', _.isFunction(options.filter));
+            // Helpers.warn('sourceDir', sourceDir);
+            // Helpers.warn('destinationDir', destinationDir);
+            // Helpers.log(JSON.stringify(options))
+            // try {
+            if (options.useTempFolder) {
+                let tempDestination = `${tnp_core_1.os.platform() === 'darwin' ? '/private/tmp' : '/tmp'}/${tnp_core_1._.camelCase(destinationDir)}`;
+                index_1.Helpers.removeFolderIfExists(tempDestination);
+                tnp_core_1.fse.copySync(sourceDir, tempDestination, options);
+                tnp_core_1.fse.copySync(tempDestination, destinationDir, options);
+            }
+            else {
+                if ((0, tnp_core_1.crossPlatformPath)(sourceDir) ===
+                    (0, tnp_core_1.crossPlatformPath)(tnp_core_1.path.resolve(sourceDir)) &&
+                    index_1.Helpers.isExistedSymlink(sourceDir) &&
+                    !index_1.Helpers.exists(tnp_core_1.fse.readlinkSync(sourceDir))) {
+                    index_1.Helpers.warn(`[taon-helpers] Not copying empty link from: ${sourceDir}
+          `);
+                }
+                else {
+                    const copyFn = () => {
+                        try {
+                            if (options.asSeparatedFiles) {
+                                const copyRecFn = (cwdForFiles) => {
+                                    const files = index_1.Helpers.getRecrusiveFilesFrom(cwdForFiles, options.omitFolders);
+                                    for (let index = 0; index < files.length; index++) {
+                                        const from = files[index];
+                                        const to = from.replace(sourceDir, destinationDir);
+                                        if (index_1.Helpers.isFolder(from)) {
+                                            if (options.omitFolders.includes(tnp_core_1.path.basename(tnp_core_1.path.dirname(from))) ||
+                                                options.omitFolders.includes(tnp_core_1.path.basename(from))) {
+                                                continue;
+                                            }
+                                            else {
+                                                copyRecFn(from);
+                                            }
+                                        }
+                                        else {
+                                            const copyFileFn = () => {
+                                                if (!options.asSeparatedFilesSymlinkAsFile &&
+                                                    index_1.Helpers.isExistedSymlink(from)) {
+                                                    index_1.Helpers.createSymLink(from, to);
+                                                }
+                                                else {
+                                                    index_1.Helpers.copyFile(from, to);
+                                                }
+                                            };
+                                            if (options.asSeparatedFilesAllowNotCopied) {
+                                                try {
+                                                    copyFileFn();
+                                                }
+                                                catch (e) { }
+                                            }
+                                            else {
+                                                copyFileFn();
+                                            }
+                                        }
+                                    }
+                                };
+                                copyRecFn(sourceDir);
+                            }
+                            else {
+                                tnp_core_1.fse.copySync(sourceDir, destinationDir, options);
+                            }
+                        }
+                        catch (error) {
+                            const exitOnError = global['tnpNonInteractive'];
+                            index_1.Helpers.log(error);
+                            if (!options.dontAskOnError) {
+                                index_1.Helpers.error(`[taon-helper] Not able to copy folder:
+                from: ${(0, tnp_core_1.crossPlatformPath)(sourceDir)}
+                to: ${(0, tnp_core_1.crossPlatformPath)(destinationDir)}
+                options: ${tnp_core_1.json5.stringify(options)}
+                error: ${error?.message}
+                `, !exitOnError);
+                                index_1.Helpers.pressKeyAndContinue(`Press any key to repeat copy action...`);
+                            }
+                            copyFn();
+                        }
+                    };
+                    if (process.platform === 'win32') {
+                        while (true) {
+                            try {
+                                copyFn();
+                                break;
+                            }
+                            catch (error) {
+                                index_1.Helpers.warn(`WARNING not able to copy .. trying again`);
+                                index_1.Helpers.sleep(1);
+                                continue;
+                            }
+                        }
+                    }
+                    else {
+                        copyFn();
+                    }
+                }
+            }
+            // } catch (error) {
+            //   console.trace(error);
+            //   process.exit(0)
+            // }
+        }
+    }
+    filterDontCopy(basePathFoldersTosSkip, projectOrBasepath) {
+        return (src, dest) => {
+            // console.log('src', src)
+            src = (0, tnp_core_1.crossPlatformPath)(src);
+            const baseFolder = tnp_core_1._.first((0, tnp_core_1.crossPlatformPath)(src)
+                .replace((0, tnp_core_1.crossPlatformPath)(projectOrBasepath), '')
+                .replace(/^\//, '')
+                .split('/'));
+            // console.log('baseFolder', baseFolder)
+            if (!baseFolder || baseFolder.trim() === '') {
+                return true;
+            }
+            const isAllowed = tnp_core_1._.isUndefined(basePathFoldersTosSkip.find(f => baseFolder.startsWith((0, tnp_core_1.crossPlatformPath)(f))));
+            // console.log('isAllowed', isAllowed)
+            return isAllowed;
+        };
+    }
+    filterOnlyCopy(basePathFoldersOnlyToInclude, projectOrBasepath) {
+        return (src, dest) => {
+            src = (0, tnp_core_1.crossPlatformPath)(src);
+            const baseFolder = tnp_core_1._.first((0, tnp_core_1.crossPlatformPath)(src)
+                .replace((0, tnp_core_1.crossPlatformPath)(projectOrBasepath), '')
+                .replace(/^\//, '')
+                .split('/'));
+            if (!baseFolder || baseFolder.trim() === '') {
+                return true;
+            }
+            const isAllowed = !tnp_core_1._.isUndefined(basePathFoldersOnlyToInclude.find(f => baseFolder.startsWith((0, tnp_core_1.crossPlatformPath)(f))));
+            return isAllowed;
+        };
+    }
+    copyFile(sourcePath, destinationPath, options) {
+        if (tnp_core_1._.isUndefined(options)) {
+            options = {};
+        }
+        if (tnp_core_1._.isUndefined(options.debugMode)) {
+            options.debugMode = false;
+        }
+        if (tnp_core_1._.isUndefined(options.debugMode)) {
+            options.fast = true;
+        }
+        if (tnp_core_1._.isUndefined(options.dontCopySameContent)) {
+            options.dontCopySameContent = true;
+        }
+        const { debugMode, fast, transformTextFn, dontCopySameContent } = options;
+        if (tnp_core_1._.isFunction(transformTextFn) && fast) {
+            index_1.Helpers.error(`[taon-helpers][copyFile] You cannot use  transformTextFn in fast mode`);
+        }
+        if (!tnp_core_1.fse.existsSync(sourcePath)) {
+            index_1.Helpers.logWarn(`[taon-helpers][copyFile] No able to find source of ${sourcePath}`);
+            return false;
+        }
+        if (tnp_core_1.fse.lstatSync(sourcePath).isDirectory()) {
+            index_1.Helpers.warn(`[taon-helpers][copyFile] Trying to copy directory as file: ${sourcePath}`, false);
+            return false;
+        }
+        if (sourcePath === destinationPath) {
+            index_1.Helpers.warn(`[taon-helpers][copyFile] Trying to copy same file ${sourcePath}`);
+            return false;
+        }
+        let destDirPath = tnp_core_1.path.dirname(destinationPath);
+        if (index_1.Helpers.isFolder(destinationPath)) {
+            index_1.Helpers.removeFolderIfExists(destinationPath);
+        }
+        if (!index_1.Helpers.isSymlinkFileExitedOrUnexisted(destDirPath) &&
+            !tnp_core_1.fse.existsSync(destDirPath)) {
+            index_1.Helpers.mkdirp(destDirPath);
+        }
+        //#region it is good code
+        if (index_1.Helpers.isExistedSymlink(destDirPath)) {
+            destDirPath = tnp_core_1.fse.realpathSync(destDirPath);
+            const newDestinationPath = (0, tnp_core_1.crossPlatformPath)(tnp_core_1.path.join(destDirPath, tnp_core_1.path.basename(destinationPath)));
+            if (index_1.Helpers.isFolder(newDestinationPath)) {
+                index_1.Helpers.removeFolderIfExists(newDestinationPath);
+            }
+            destinationPath = newDestinationPath;
+        }
+        //#endregion
+        if (dontCopySameContent && tnp_core_1.fse.existsSync(destinationPath)) {
+            const destinationContent = index_1.Helpers.readFile(destinationPath);
+            const sourceContent = index_1.Helpers.readFile(sourcePath).toString();
+            if (destinationContent === sourceContent) {
+                // @REMEMBER uncomment if any problem
+                // Helpers.log(`Destination has the same content as source: ${path.basename(sourcePath)}`);
+                return false;
+            }
+        }
+        debugMode &&
+            index_1.Helpers.log(`path.extname(sourcePath) ${tnp_core_1.path.extname(sourcePath)}`);
+        if (fast || !tnp_config_1.extAllowedToReplace.includes(tnp_core_1.path.extname(sourcePath))) {
+            tnp_core_1.fse.copyFileSync(sourcePath, destinationPath);
+        }
+        else {
+            let sourceData = index_1.Helpers.readFile(sourcePath).toString();
+            if (tnp_core_1._.isFunction(transformTextFn)) {
+                sourceData = transformTextFn(sourceData);
+            }
+            debugMode &&
+                index_1.Helpers.log(`
+      [taon-helpers][copyFile] Write to: ${destinationPath} file:
+============================================================================================
+${sourceData}
+============================================================================================
+        `);
+            index_1.Helpers.writeFile(destinationPath, sourceData);
+        }
+        return true;
+    }
+    /**
+     * get real absolute path
+     */
+    resolve(fileOrFolderPath) {
+        if (fileOrFolderPath.startsWith('~')) {
+            fileOrFolderPath = (0, tnp_core_1.crossPlatformPath)([
+                tnp_core_1.os.homedir(),
+                fileOrFolderPath.replace(`~/`, ''),
+            ]);
+        }
+        return (0, tnp_core_1.crossPlatformPath)(tnp_core_1.path.resolve(fileOrFolderPath));
+    }
+}
+exports.HelpersFileFolders = HelpersFileFolders;
+//# sourceMappingURL=helpers-file-folders.backend.js.map