@nu-art/build-and-install 0.400.3 → 0.400.5

package/v3/core/FileSystemUtils.js

@@ -1,151 +0,0 @@
-import { promises as _fs } from 'fs';
-import { resolve } from 'path';
-import { BadImplementationException, exists } from '@nu-art/ts-common';
-async function isFile(path) {
-    return (await _fs.stat(path)).isFile();
-}
-async function isFolder(path) {
-    return (await _fs.stat(path)).isDirectory();
-}
-async function assertFile(path) {
-    if (!(await isFile(path)))
-        throw new BadImplementationException(`Expected file but found directory or non-file: ${path}`);
-}
-async function assertFolder(path) {
-    if (!(await isFolder(path)))
-        throw new BadImplementationException(`Expected folder but found file or non-directory: ${path}`);
-}
-async function fileExists(path) {
-    try {
-        await _fs.access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function assertExists(path, mustExist, type) {
-    const doesExist = await fileExists(path);
-    if (!doesExist) {
-        if (mustExist)
-            throw new BadImplementationException(`${type} does not exist: ${path}`);
-        return false;
-    }
-    return true;
-}
-const escapeRegExp = (string) => string.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
-export const DEFAULT_TEMPLATE_PATTERN = new RegExp(`\{\{(\\S*?)\}\}`);
-export const DEFAULT_OLD_TEMPLATE_PATTERN = new RegExp(`(?<!\\\\)\\$([a-zA-Z]\\w{2,})`);
-export const FileSystemUtils = {
-    file: {
-        exists: async (pathToFile) => {
-            return await fileExists(pathToFile);
-        },
-        delete: async (pathToFile, mustExist = false) => {
-            if (!await assertExists(pathToFile, mustExist, 'File'))
-                return;
-            await assertFile(pathToFile);
-            return _fs.rm(pathToFile);
-        },
-        write: async (pathToFile, content) => {
-            await FileSystemUtils.folder.create(resolve(pathToFile, '..'));
-            return _fs.writeFile(pathToFile, content, 'utf-8');
-        },
-        read: async (pathToFile) => {
-            await assertFile(pathToFile);
-            return _fs.readFile(pathToFile, 'utf-8');
-        },
-        copy: async (sourcePath, targetPath) => {
-            await assertExists(targetPath, false, 'File');
-            await assertFile(sourcePath);
-            await FileSystemUtils.folder.create(resolve(targetPath, '..'));
-            return _fs.copyFile(sourcePath, targetPath);
-        },
-        template: {
-            read: async (pathToFile, params, pattern = DEFAULT_TEMPLATE_PATTERN) => {
-                const content = await FileSystemUtils.file.read(pathToFile);
-                return FileSystemUtils.file.template.transform(content, params, pattern);
-            },
-            transform: (input, params, pattern = DEFAULT_TEMPLATE_PATTERN) => {
-                let match;
-                while (match = input.match(pattern)) {
-                    const value = params[match[1]];
-                    if (!exists(value))
-                        throw new BadImplementationException(`Missing template param: ${match[1]}`);
-                    const fullMatchRegex = new RegExp(escapeRegExp(match[0]), 'g');
-                    input = input.replace(fullMatchRegex, value);
-                }
-                return input;
-            },
-            write: async (pathToFile, content, params, pattern = DEFAULT_TEMPLATE_PATTERN) => {
-                const transformedContent = FileSystemUtils.file.template.transform(content, params, pattern);
-                return FileSystemUtils.file.write(pathToFile, transformedContent);
-            },
-            copy: async (sourcePath, targetPath, params, pattern = DEFAULT_TEMPLATE_PATTERN) => {
-                const content = await FileSystemUtils.file.read(sourcePath);
-                const transformedContent = FileSystemUtils.file.template.transform(content, params, pattern);
-                return FileSystemUtils.file.write(targetPath, transformedContent);
-            }
-        },
-    },
-    folder: {
-        delete: async (pathToFolder, mustExist = false) => {
-            if (!await assertExists(pathToFolder, mustExist, 'Folder'))
-                return;
-            await assertFolder(pathToFolder);
-            return _fs.rm(pathToFolder, { recursive: true, force: true });
-        },
-        empty: async (pathToFolder, mustExist = true) => {
-            if (!await assertExists(pathToFolder, mustExist, 'Folder'))
-                return;
-            await assertFolder(pathToFolder);
-            const entries = await _fs.readdir(pathToFolder);
-            await Promise.all(entries.map(entry => _fs.rm(resolve(pathToFolder, entry), { recursive: true, force: true })));
-        },
-        create: async (pathToFolder) => {
-            if (await fileExists(pathToFolder))
-                return assertFolder(pathToFolder);
-            return _fs.mkdir(pathToFolder, { recursive: true });
-        },
-        list: Object.assign(async (pathToFolder) => {
-            return await _fs.readdir(pathToFolder);
-        }, {
-            forEach: Object.assign(async (pathToFolder, callback) => {
-                const entries = await _fs.readdir(pathToFolder);
-                for (const entry of entries)
-                    await callback(resolve(pathToFolder, entry));
-            }, {
-                file: async (pathToFolder, callback) => {
-                    await FileSystemUtils.folder.list.forEach(pathToFolder, async (entry) => {
-                        if (!await isFile(entry))
-                            return;
-                        await callback(entry);
-                    });
-                },
-                folder: async (pathToFolder, callback) => {
-                    await FileSystemUtils.folder.list.forEach(pathToFolder, async (entry) => {
-                        if (!await isFolder(entry))
-                            return;
-                        await callback(entry);
-                    });
-                }
-            })
-        })
-    },
-    symlink: {
-        create: async (targetPath, linkPath) => {
-            return _fs.symlink(targetPath, linkPath);
-        },
-        delete: async (pathToLink, mustExist = false) => {
-            if (!await assertExists(pathToLink, mustExist, 'Symlink'))
-                return;
-            const stat = await _fs.lstat(pathToLink);
-            if (!stat.isSymbolicLink())
-                throw new BadImplementationException(`Expected symlink but found something else: ${pathToLink}`);
-            return _fs.unlink(pathToLink);
-        },
-        read: async (pathToLink) => {
-            return _fs.readlink(pathToLink);
-        }
-    }
-};