@pitifulhawk/flash-up/dist/utils/file-system.js

Interactive project scaffolder for modern web applications

import * as fs from 'fs/promises';
import * as path from 'path';
export async function pathExists(targetPath) {
    try {
        await fs.access(targetPath);
        return true;
    }
    catch {
        return false;
    }
}
export async function isDirectory(targetPath) {
    try {
        const stats = await fs.stat(targetPath);
        return stats.isDirectory();
    }
    catch {
        return false;
    }
}
export async function isDirectoryEmpty(dirPath) {
    try {
        const files = await fs.readdir(dirPath);
        return files.length === 0;
    }
    catch {
        return false;
    }
}
export async function createDirectory(dirPath) {
    try {
        await fs.mkdir(dirPath, { recursive: true });
        return {
            success: true,
            path: dirPath,
        };
    }
    catch (error) {
        return {
            success: false,
            error: error.message,
            path: dirPath,
        };
    }
}
export async function copyFile(sourcePath, destPath, overwrite = false) {
    try {
        if (!overwrite && await pathExists(destPath)) {
            return {
                success: false,
                error: 'Destination file already exists',
                path: destPath,
            };
        }
        const destDir = path.dirname(destPath);
        await fs.mkdir(destDir, { recursive: true });
        await fs.copyFile(sourcePath, destPath);
        return {
            success: true,
            path: destPath,
        };
    }
    catch (error) {
        return {
            success: false,
            error: error.message,
            path: destPath,
        };
    }
}
export async function readTextFile(filePath) {
    try {
        return await fs.readFile(filePath, 'utf-8');
    }
    catch {
        return null;
    }
}
export async function writeTextFile(filePath, content) {
    try {
        const dir = path.dirname(filePath);
        await fs.mkdir(dir, { recursive: true });
        await fs.writeFile(filePath, content, 'utf-8');
        return {
            success: true,
            path: filePath,
        };
    }
    catch (error) {
        return {
            success: false,
            error: error.message,
            path: filePath,
        };
    }
}
export async function readJsonFile(filePath) {
    try {
        const content = await fs.readFile(filePath, 'utf-8');
        return JSON.parse(content);
    }
    catch {
        return null;
    }
}
export async function writeJsonFile(filePath, data, indent = 2) {
    try {
        const content = JSON.stringify(data, null, indent);
        return await writeTextFile(filePath, content);
    }
    catch (error) {
        return {
            success: false,
            error: error.message,
            path: filePath,
        };
    }
}
export function getAbsolutePath(relativePath, basePath) {
    return path.resolve(basePath || process.cwd(), relativePath);
}
export function isPathSafe(targetPath, basePath) {
    const resolvedTarget = path.resolve(basePath, targetPath);
    const resolvedBase = path.resolve(basePath);
    return resolvedTarget.startsWith(resolvedBase);
}
//# sourceMappingURL=file-system.js.map