structure-validation/dist/domain/entities/FileInfo.js

A Node.js CLI tool for validating codebase folder and file structure using a clean declarative configuration. Part of the guardz ecosystem for comprehensive TypeScript development.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.FileInfo = void 0;
const path_1 = __importDefault(require("path"));
/**
 * FileInfo entity representing a file in the codebase
 */
class FileInfo {
    constructor(filePath, basePath) {
        this.path = filePath;
        this.relativePath = path_1.default.relative(basePath, filePath);
        this.folder = this.extractFolder();
        this.filename = path_1.default.basename(filePath);
    }
    /**
     * Extract the folder name from the relative path
     */
    extractFolder() {
        const dirname = path_1.default.dirname(this.relativePath);
        return dirname === '.' ? 'root' : dirname;
    }
    /**
     * Check if the file matches any of the given patterns
     */
    matchesPatterns(patterns, folderName) {
        return patterns.some(pattern => this.matchesPattern(pattern, folderName));
    }
    /**
     * Check if the file matches a specific pattern
     */
    matchesPattern(pattern, folderName) {
        // Convert glob pattern to regex
        const regexPattern = this.globToRegex(pattern, folderName);
        return regexPattern.test(this.filename);
    }
    /**
     * Convert glob pattern to regex, supporting {variable} placeholder for folder name
     */
    globToRegex(pattern, folderName) {
        let processedPattern = pattern;
        // Replace {variable} placeholder with folder name if provided
        // This supports any variable name like {a}, {b}, {folderName}, etc.
        if (folderName && pattern.includes('{')) {
            processedPattern = pattern.replace(/\{[^}]+\}/g, folderName);
        }
        const escaped = processedPattern
            .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
            .replace(/\\\*/g, '.*')
            .replace(/\\\?/g, '.');
        return new RegExp(`^${escaped}$`);
    }
    /**
     * Get the best matching folder suggestion based on filename patterns
     */
    getSuggestedFolder(rules) {
        for (const rule of rules) {
            // For variable placeholder rules (e.g., {a}, {b}, {folderName}, etc.), 
            // we need to pass the actual folder name to replace the placeholder in patterns
            const folderName = rule.folder.match(/^\{[^}]+\}$/) ? this.folder : rule.folder;
            if (this.matchesPatterns(rule.patterns, folderName)) {
                // Return a user-friendly folder name instead of raw patterns
                if (rule.folder.includes('**')) {
                    // Extract the folder name from patterns like **/components/**
                    const match = rule.folder.match(/\*\*\/([^\/]+)\/\*\*/);
                    if (match && match[1]) {
                        return match[1]; // Return just 'components' instead of '**/components/**'
                    }
                }
                return rule.folder;
            }
        }
        return null;
    }
}
exports.FileInfo = FileInfo;
//# sourceMappingURL=FileInfo.js.map