filesops/dist/utils.js

Advanced file operations library with search, type detection, size calculation, and permission utilities

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getFileInfo = getFileInfo;
exports.findByTypeAndSize = findByTypeAndSize;
exports.getDiskUsage = getDiskUsage;
exports.findFilesToCleanup = findFilesToCleanup;
exports.checkDirectoryAccess = checkDirectoryAccess;
exports.findDuplicatesBySize = findDuplicatesBySize;
exports.getFileSystemOverview = getFileSystemOverview;
exports.batchFileInfo = batchFileInfo;
const search_1 = require("./search");
const fileType_1 = require("./fileType");
const size_1 = require("./size");
const permissions_1 = require("./permissions");
/**
 * Convenience functions that combine multiple utilities
 */
/**
 * Get comprehensive file information including type, size, and permissions
 */
async function getFileInfo(filePath) {
    const exists = await permissions_1.PermissionChecker.canAccess(filePath);
    if (!exists) {
        throw new Error(`File not found or not accessible: ${filePath}`);
    }
    const [type, size, permissions] = await Promise.all([
        fileType_1.FileTypeDetector.detectFromContent(filePath),
        size_1.SizeCalculator.getFileSize(filePath),
        permissions_1.PermissionChecker.getPermissions(filePath),
    ]);
    return {
        path: filePath,
        name: filePath.split(/[/\\]/).pop() || '',
        type,
        size,
        permissions,
        exists,
    };
}
/**
 * Find files by type and size criteria
 */
async function findByTypeAndSize(searchPath, fileType, minSize, maxSize) {
    const extensions = fileType_1.FileTypeDetector.getExtensionsByCategory(fileType);
    const options = {
        extensions,
        minSize,
        maxSize,
    };
    const result = await search_1.FileSearch.search(searchPath, options);
    return result.files;
}
/**
 * Get disk usage summary for a directory
 */
async function getDiskUsage(dirPath, includeHidden = false) {
    const [stats, largestFiles] = await Promise.all([
        size_1.SizeCalculator.getDirectoryStats(dirPath, includeHidden),
        size_1.SizeCalculator.findLargestFiles(dirPath, 10, includeHidden),
    ]);
    return {
        ...stats,
        largestFiles,
    };
}
/**
 * Clean up files based on criteria (age, size, type)
 */
async function findFilesToCleanup(searchPath, options = {}) {
    const searchOptions = {
        modifiedBefore: options.olderThan,
        minSize: options.largerThan,
        extensions: options.extensions,
        includeHidden: options.includeHidden,
    };
    const result = await search_1.FileSearch.search(searchPath, searchOptions);
    return result.files.sort((a, b) => b.size - a.size);
}
/**
 * Check if directory structure is readable/writable
 */
async function checkDirectoryAccess(dirPath) {
    const [readable, writable, executable, permissions] = await Promise.all([
        permissions_1.PermissionChecker.canRead(dirPath),
        permissions_1.PermissionChecker.canWrite(dirPath),
        permissions_1.PermissionChecker.canExecute(dirPath),
        permissions_1.PermissionChecker.getPermissions(dirPath),
    ]);
    const canCreateFiles = await permissions_1.PermissionChecker.isDirectoryWritable(dirPath);
    return {
        readable,
        writable,
        executable,
        canCreateFiles,
        permissions,
    };
}
/**
 * Find duplicate files by size and optionally by content hash
 */
async function findDuplicatesBySize(searchPath) {
    const result = await search_1.FileSearch.search(searchPath);
    const sizeGroups = new Map();
    for (const file of result.files) {
        if (!sizeGroups.has(file.size)) {
            sizeGroups.set(file.size, []);
        }
        sizeGroups.get(file.size).push(file);
    }
    return Array.from(sizeGroups.entries())
        .filter(([, files]) => files.length > 1)
        .map(([size, files]) => ({ size, files }))
        .sort((a, b) => b.size - a.size);
}
/**
 * Get file system overview for a path
 */
async function getFileSystemOverview(searchPath) {
    const [searchResult, directoryStats, permissions] = await Promise.all([
        search_1.FileSearch.search(searchPath, { maxDepth: 2 }),
        size_1.SizeCalculator.getDirectoryStats(searchPath),
        permissions_1.PermissionChecker.getPermissions(searchPath),
    ]);
    // Group files by type
    const filesByType = new Map();
    for (const file of searchResult.files) {
        const type = fileType_1.FileTypeDetector.detectFromPath(file.path);
        if (!filesByType.has(type.category)) {
            filesByType.set(type.category, []);
        }
        filesByType.get(type.category).push(file);
    }
    return {
        overview: {
            totalFiles: searchResult.totalFiles,
            totalDirectories: searchResult.totalDirectories,
            totalSize: directoryStats.totalSize,
        },
        filesByType: Array.from(filesByType.entries()).map(([type, files]) => ({
            type,
            count: files.length,
            totalSize: size_1.SizeCalculator.getSizeInfo(files.reduce((sum, f) => sum + f.size, 0)),
        })),
        permissions,
        largestFiles: directoryStats.largestFiles,
    };
}
/**
 * Batch operations for multiple files
 */
async function batchFileInfo(filePaths) {
    const results = await Promise.allSettled(filePaths.map(async (filePath) => {
        const info = await getFileInfo(filePath);
        return { filePath, info };
    }));
    return {
        successful: results
            .filter((result) => result.status === 'fulfilled')
            .map(result => result.value),
        failed: results
            .filter((result) => result.status === 'rejected')
            .map((result, index) => ({
            filePath: filePaths[index],
            error: result.reason?.message || 'Unknown error',
        })),
    };
}
//# sourceMappingURL=utils.js.map