scaffoldrite 2.0.4 → 2.0.6

package/dist/parser.js

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseStructure = parseStructure;
-const constraints_1 = require("./constraints");
-// No restrictions on file/folder name characters
-const VALID_NAME_REGEX = /.+/;
-function validateName(name, line) {
-    if (name === "__root__") {
-        throw new Error(`[Line ${line}] Reserved name "__root__" is not allowed`);
-    }
-    // Only validate that name is not empty
-    if (!VALID_NAME_REGEX.test(name)) {
-        throw new Error(`[Line ${line}] Name cannot be empty`);
-    }
-}
-function parseStructure(input) {
-    const lines = input.split("\n");
-    const root = { type: "folder", name: "__root__", children: [] };
-    const stack = [root];
-    let constraints = [];
-    let inConstraints = false;
-    let braceDepth = 0;
-    for (let i = 0; i < lines.length; i++) {
-        const lineNumber = i + 1;
-        const raw = lines[i];
-        const line = raw.trim();
-        const codeLine = line.split("//")[0].trim();
-        if (codeLine.length === 0)
-            continue;
-        if (line.length === 0)
-            continue;
-        // Start constraints block
-        if (line === "constraints {") {
-            inConstraints = true;
-            braceDepth = 1;
-            continue;
-        }
-        // If we are inside constraints block
-        if (inConstraints) {
-            if (line.includes("{"))
-                braceDepth++;
-            if (line.includes("}"))
-                braceDepth--;
-            // If braceDepth becomes 0, constraints ended
-            if (braceDepth === 0) {
-                inConstraints = false;
-                continue;
-            }
-            constraints.push(line);
-            continue;
-        }
-        // Folder logic
-        if (line.startsWith("folder ")) {
-            const match = raw.match(/^\s*folder\s+(.+?)\s*\{\s*$/);
-            if (!match) {
-                throw new Error(`[Line ${lineNumber}] Invalid folder syntax: "${line}"`);
-            }
-            const name = match[1];
-            validateName(name, lineNumber);
-            const parent = stack[stack.length - 1];
-            if (parent.children.some(c => c.type === "folder" && c.name === name)) {
-                throw new Error(`[Line ${lineNumber}] Duplicate folder name "${name}" in the same scope`);
-            }
-            const folder = { type: "folder", name, children: [] };
-            parent.children.push(folder);
-            stack.push(folder);
-            continue;
-        }
-        // File logic
-        if (line.startsWith("file ")) {
-            const match = raw.match(/^\s*file\s+(.+?)\s*$/);
-            if (!match) {
-                throw new Error(`[Line ${lineNumber}] Invalid file syntax: "${line}"`);
-            }
-            const name = match[1];
-            validateName(name, lineNumber);
-            const parent = stack[stack.length - 1];
-            if (parent.children.some(c => c.type === "file" && c.name === name)) {
-                throw new Error(`[Line ${lineNumber}] Duplicate file name "${name}" in the same scope`);
-            }
-            const file = { type: "file", name };
-            parent.children.push(file);
-            continue;
-        }
-        // Close folder
-        if (line === "}") {
-            if (stack.length === 1) {
-                throw new Error(`[Line ${lineNumber}] Unexpected "}"`);
-            }
-            stack.pop();
-            continue;
-        }
-        throw new Error(`[Line ${lineNumber}] Unknown statement: "${line}"`);
-    }
-    if (stack.length !== 1) {
-        throw new Error(`Unclosed folder block`);
-    }
-    return {
-        root,
-        constraints: (0, constraints_1.parseConstraints)(constraints.join("\n")),
-        rawConstraints: constraints
-    };
-}

package/dist/progress.js

@@ -1,63 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createProgressBar = createProgressBar;
-const cli_progress_1 = __importDefault(require("cli-progress"));
-const chalk_1 = __importDefault(require("chalk"));
-function createProgressBar() {
-    const bar = new cli_progress_1.default.SingleBar({
-        format: `${chalk_1.default.hex('#4cc9f0')("{bar}")} ` +
-            `${chalk_1.default.hex('#00b4d8').bold("{percentage}%")} ` +
-            `${chalk_1.default.hex('#4cc9f0')("|")} ` +
-            `${chalk_1.default.hex('#f8f9fa')("{value}")}${chalk_1.default.hex('#adb5bd')("/{total}")} ` +
-            `${chalk_1.default.hex('#4cc9f0')("|")} ` +
-            `${chalk_1.default.hex('#ffd166').bold("{type}")} ` +
-            `${chalk_1.default.hex('#8d99ae').italic("{path}")}`,
-        barCompleteChar: '█',
-        barIncompleteChar: '░',
-        hideCursor: true,
-        clearOnComplete: false,
-        stopOnComplete: true,
-        barGlue: `${chalk_1.default.hex('#1a1a2e').bold('[')}${chalk_1.default.hex('#1a1a2e').bold(']')}`,
-        barsize: 40,
-    }, cli_progress_1.default.Presets.shades_classic);
-    let totalOps = 0;
-    let startTime = Date.now();
-    return {
-        start(total) {
-            totalOps = total;
-            startTime = Date.now();
-            bar.start(total, 0, {
-                type: "",
-                path: "",
-                percentage: 0
-            });
-        },
-        update(e) {
-            const percentage = Math.floor((e.count / totalOps) * 100);
-            // Dynamically update format based on progress
-            if (percentage === 100) {
-                const elapsedSeconds = Math.round((Date.now() - startTime) / 1000);
-                bar.update(e.count, {
-                    type: "COMPLETE",
-                    path: `Finished in ${elapsedSeconds}s`,
-                    percentage: percentage,
-                });
-                // Use a different format for completion
-                bar.setTotal(totalOps);
-            }
-            else {
-                bar.update(e.count, {
-                    type: e.type.toUpperCase(),
-                    path: e.path,
-                    percentage: percentage,
-                });
-            }
-        },
-        stop() {
-            bar.stop();
-        },
-    };
-}

package/dist/structure.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findNode = findNode;
-exports.addNode = addNode;
-exports.deleteNode = deleteNode;
-exports.renameNode = renameNode;
-function findNode(root, pathStr) {
-    const parts = pathStr.split("/").filter(Boolean);
-    let current = root;
-    for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        const child = current.children.find(c => c.name === part);
-        if (!child)
-            return null;
-        if (i === parts.length - 1)
-            return child;
-        if (child.type !== "folder")
-            return null;
-        current = child;
-    }
-    return null;
-}
-function addNode(root, pathStr, type, options = {}) {
-    const parts = pathStr.split("/").filter(Boolean);
-    const name = parts.pop();
-    if (!name) {
-        throw new Error("Invalid path: path is empty. Example: src/components/Button.ts");
-    }
-    let current = root;
-    for (const part of parts) {
-        let child = current.children.find(c => c.name === part && c.type === "folder");
-        if (!child) {
-            child = { type: "folder", name: part, children: [] };
-            current.children.push(child);
-        }
-        current = child;
-    }
-    const exists = current.children.some(c => c.name === name);
-    if (exists) {
-        if (options.ifNotExists)
-            return; // do nothing
-        if (!options.force) {
-            throw new Error(`Cannot create ${type}: '${pathStr}' already exists in the structure.sr file`);
-        }
-        // force = true -> replace existing node
-        const idx = current.children.findIndex(c => c.name === name);
-        current.children.splice(idx, 1);
-    }
-    const newNode = type === "folder"
-        ? { type: "folder", name, children: [] }
-        : { type: "file", name };
-    current.children.push(newNode);
-    return current;
-}
-function deleteNode(root, pathStr) {
-    const parts = pathStr.split("/").filter(Boolean);
-    const name = parts.pop();
-    if (!name) {
-        throw new Error("Invalid path: path is empty. Example: src/components/Button.ts");
-    }
-    let current = root;
-    for (const part of parts) {
-        const child = current.children.find(c => c.name === part && c.type === "folder");
-        if (!child) {
-            throw new Error(`Path not found: '${parts.join("/")}' does not exist in the structure.`);
-        }
-        current = child;
-    }
-    const index = current.children.findIndex(c => c.name === name);
-    if (index === -1) {
-        throw new Error(`Node not found: '${pathStr}' does not exist in the structure.`);
-    }
-    current.children.splice(index, 1);
-}
-function renameNode(root, pathStr, newName) {
-    const node = findNode(root, pathStr);
-    if (!node) {
-        throw new Error(`Node not found: '${pathStr}' does not exist.`);
-    }
-    if (!newName || newName.trim().length === 0) {
-        throw new Error("Invalid new name: name cannot be empty.");
-    }
-    node.name = newName;
-}

package/dist/utils/historyhelpers.js

@@ -1 +0,0 @@
-"use strict";

package/dist/validateFS.js

@@ -1,74 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateFS = validateFS;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const index_1 = require("./utils/index");
-function validateFS(root, dir, options = {}) {
-    const { ignoreList = [], allowExtra = false, allowExtraPaths = [], currentPath = "", } = options;
-    if (!fs_1.default.existsSync(dir)) {
-        throw new Error(`Folder does not exist: ${dir}\n` +
-            `Expected folder according to structure.sr at: ${currentPath || "root"}`);
-    }
-    const actualItems = fs_1.default.readdirSync(dir);
-    // Check missing items in filesystem
-    for (const child of root.children) {
-        if ((0, index_1.isIgnored)(child.name, ignoreList))
-            continue;
-        const expectedPath = path_1.default.join(dir, child.name);
-        const expectedSrPath = path_1.default.join(currentPath, child.name);
-        if (!fs_1.default.existsSync(expectedPath)) {
-            const allowedExplicitly = allowExtraPaths.some((p) => {
-                const normalized = path_1.default.normalize(p);
-                return (expectedSrPath === normalized ||
-                    expectedSrPath.endsWith(normalized));
-            });
-            if (allowExtra || allowedExplicitly)
-                continue;
-            throw new Error(`Missing in filesystem: ${expectedPath}\n` +
-                `Expected according to structure.sr at: ${expectedSrPath}`);
-        }
-        if (child.type === "folder") {
-            if (!fs_1.default.statSync(expectedPath).isDirectory()) {
-                throw new Error(`Expected folder but found file: ${expectedPath}\n` +
-                    `structure.sr expects a folder at: ${expectedSrPath}`);
-            }
-            validateFS(child, expectedPath, {
-                ignoreList,
-                allowExtra,
-                allowExtraPaths,
-                currentPath: expectedSrPath,
-            });
-        }
-        else {
-            if (!fs_1.default.statSync(expectedPath).isFile()) {
-                throw new Error(`Expected file but found folder: ${expectedPath}\n` +
-                    `structure.sr expects a file at: ${expectedSrPath}`);
-            }
-        }
-    }
-    // Check extra items in filesystem not in .sr
-    for (const item of actualItems) {
-        if ((0, index_1.isIgnored)(item, ignoreList))
-            continue;
-        const existsInSr = root.children.some((c) => c.name === item);
-        if (!existsInSr) {
-            const extraPath = path_1.default.join(dir, item);
-            const allowedExplicitly = allowExtraPaths.some((p) => {
-                const normalized = path_1.default.normalize(p);
-                const extraRel = path_1.default.relative(dir, extraPath);
-                const extraBasename = path_1.default.basename(extraPath);
-                return (extraBasename === normalized ||
-                    extraRel === normalized ||
-                    extraRel.endsWith(normalized));
-            });
-            if (allowExtra || allowedExplicitly)
-                continue;
-            throw new Error(`Extra file/folder found in filesystem: ${extraPath}\n` +
-                `Not defined in structure.sr at: ${currentPath || "root"}`);
-        }
-    }
-}

package/dist/validator.js

@@ -1,249 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateConstraints = validateConstraints;
-function normalizePath(path) {
-    if (!path || path.trim() === "")
-        return "__root__";
-    return path.trim().replace(/^\/+/, "").replace(/\/+$/, "");
-}
-function findNodeByPath(root, path) {
-    const normalizedPath = normalizePath(path);
-    const parts = normalizedPath.split("/").filter(Boolean);
-    let current = root;
-    if (parts[0] === root.name) {
-        parts.shift();
-    }
-    for (const part of parts) {
-        if (current.type !== "folder")
-            return null;
-        const next = current.children.find((c) => c.name === part);
-        if (!next)
-            return null;
-        current = next;
-    }
-    return current;
-}
-function countFiles(folder) {
-    return folder.children.filter((c) => c.type === "file").length;
-}
-function countFolders(folder) {
-    return folder.children.filter((c) => c.type === "folder").length;
-}
-function countFilesRecursive(folder, ext) {
-    let count = 0;
-    for (const child of folder.children) {
-        if (child.type === "file") {
-            if (!ext || child.name.endsWith(ext))
-                count++;
-        }
-        if (child.type === "folder")
-            count += countFilesRecursive(child, ext);
-    }
-    return count;
-}
-function countFoldersRecursive(folder) {
-    let count = 0;
-    for (const child of folder.children) {
-        if (child.type === "folder")
-            count++;
-        if (child.type === "folder")
-            count += countFoldersRecursive(child);
-    }
-    return count;
-}
-function maxDepth(folder, current = 0) {
-    let depth = current;
-    for (const child of folder.children) {
-        if (child.type === "folder") {
-            depth = Math.max(depth, maxDepth(child, current + 1));
-        }
-    }
-    return depth;
-}
-function getFoldersByScope(root, path, scope) {
-    const folder = findNodeByPath(root, path);
-    if (!folder || folder.type !== "folder")
-        return [];
-    const folders = [];
-    if (scope === "*") {
-        for (const child of folder.children) {
-            if (child.type === "folder")
-                folders.push(child);
-        }
-    }
-    if (scope === "**") {
-        function traverse(f) {
-            for (const child of f.children) {
-                if (child.type === "folder") {
-                    folders.push(child);
-                    traverse(child);
-                }
-            }
-        }
-        traverse(folder);
-    }
-    return folders;
-}
-function formatConstraintError(message, hint) {
-    return `Constraint failed:\n  ${message}${hint ? `\nHint: ${hint}` : ""}`;
-}
-function validateConstraints(root, constraints) {
-    for (const c of constraints) {
-        if ((c.type !== "eachFolderMustContain" &&
-            c.type !== "eachFolderMustContainFile" &&
-            c.type !== "eachFolderMustContainFolder" &&
-            c.type !== "eachFolderMustHaveExt") &&
-            (!c.path || c.path.trim() === "")) {
-            throw new Error(formatConstraintError(`Path missing for constraint type "${c.type}"`, `Add a valid path like: constraints { ${c.type} src/index.ts }`));
-        }
-        if (c.type === "require") {
-            const node = findNodeByPath(root, c.path);
-            if (!node) {
-                throw new Error(formatConstraintError(`Required path not found: ${c.path}`, `Add this path to your structure.sr or remove this constraint`));
-            }
-        }
-        if (c.type === "forbid") {
-            const node = findNodeByPath(root, c.path);
-            if (node) {
-                throw new Error(formatConstraintError(`Forbidden path exists: ${c.path}`, `Remove this path from your structure.sr or delete this constraint`));
-            }
-        }
-        if (c.type === "maxFiles") {
-            const folder = findNodeByPath(root, c.path);
-            if (!folder || folder.type !== "folder")
-                continue;
-            const fileCount = countFiles(folder);
-            if (fileCount > c.value)
-                throw new Error(formatConstraintError(`${c.path} has ${fileCount} files (max allowed ${c.value})`, `Remove extra files or increase maxFiles`));
-        }
-        if (c.type === "maxFilesRecursive") {
-            const folder = findNodeByPath(root, c.path);
-            if (!folder || folder.type !== "folder")
-                continue;
-            const fileCount = countFilesRecursive(folder);
-            if (fileCount > c.value)
-                throw new Error(formatConstraintError(`${c.path} has ${fileCount} files recursively (max allowed ${c.value})`, `Remove extra files or increase maxFilesRecursive`));
-        }
-        if (c.type === "maxFilesByExt") {
-            const folder = findNodeByPath(root, c.path);
-            if (!folder || folder.type !== "folder")
-                continue;
-            const fileCount = folder.children
-                .filter((x) => x.type === "file")
-                .filter((f) => f.name.endsWith(c.ext)).length;
-            if (fileCount > c.value)
-                throw new Error(formatConstraintError(`${c.path} has ${fileCount} files with extension "${c.ext}" (max allowed ${c.value})`, `Remove extra ${c.ext} files or increase maxFilesByExt`));
-        }
-        if (c.type === "maxFilesByExtRecursive") {
-            const folder = findNodeByPath(root, c.path);
-            if (!folder || folder.type !== "folder")
-                continue;
-            const extCount = countFilesRecursive(folder, c.ext);
-            if (extCount > c.value)
-                throw new Error(formatConstraintError(`${c.path} has ${extCount} files with extension "${c.ext}" recursively (max allowed ${c.value})`, `Remove extra ${c.ext} files or increase maxFilesByExtRecursive`));
-        }
-        if (c.type === "maxFolders") {
-            const folder = findNodeByPath(root, c.path);
-            if (!folder || folder.type !== "folder")
-                continue;
-            const folderCount = countFolders(folder);
-            if (folderCount > c.value)
-                throw new Error(formatConstraintError(`${c.path} has ${folderCount} folders (max allowed ${c.value})`, `Remove extra folders or increase maxFolders`));
-        }
-        if (c.type === "maxFoldersRecursive") {
-            const folder = findNodeByPath(root, c.path);
-            if (!folder || folder.type !== "folder")
-                continue;
-            const folderCount = countFoldersRecursive(folder);
-            if (folderCount > c.value)
-                throw new Error(formatConstraintError(`${c.path} has ${folderCount} folders recursively (max allowed ${c.value})`, `Remove extra folders or increase maxFoldersRecursive`));
-        }
-        if (c.type === "minFiles") {
-            const folder = findNodeByPath(root, c.path);
-            if (!folder || folder.type !== "folder")
-                continue;
-            const fileCount = countFiles(folder);
-            if (fileCount < c.value)
-                throw new Error(formatConstraintError(`${c.path} has ${fileCount} files (min required ${c.value})`, `Add more files to this folder`));
-        }
-        if (c.type === "minFolders") {
-            const folder = findNodeByPath(root, c.path);
-            if (!folder || folder.type !== "folder")
-                continue;
-            const folderCount = countFolders(folder);
-            if (folderCount < c.value)
-                throw new Error(formatConstraintError(`${c.path} has ${folderCount} folders (min required ${c.value})`, `Add more folders to this path`));
-        }
-        if (c.type === "mustContain") {
-            const folder = findNodeByPath(root, c.path);
-            if (!folder || folder.type !== "folder")
-                continue;
-            const exists = folder.children.some((x) => x.name === c.value);
-            if (!exists)
-                throw new Error(formatConstraintError(`${c.path} must contain "${c.value}"`, `Add ${c.value} inside ${c.path}`));
-        }
-        if (c.type === "fileNameRegex") {
-            const folder = findNodeByPath(root, c.path);
-            if (!folder || folder.type !== "folder")
-                continue;
-            const regex = new RegExp(c.regex);
-            for (const child of folder.children) {
-                if (child.type === "file" && !regex.test(child.name)) {
-                    throw new Error(formatConstraintError(`${child.name} in ${c.path} does not match regex "${c.regex}"`, `Rename the file or update the regex constraint`));
-                }
-            }
-        }
-        if (c.type === "maxDepth") {
-            const folder = findNodeByPath(root, c.path);
-            if (!folder || folder.type !== "folder")
-                continue;
-            const depth = maxDepth(folder);
-            if (depth > c.value)
-                throw new Error(formatConstraintError(`${c.path} exceeds max depth of ${c.value} (current depth ${depth})`, `Remove nested folders or increase maxDepth`));
-        }
-        if (c.type === "mustHaveFile") {
-            const folder = findNodeByPath(root, c.path);
-            if (!folder || folder.type !== "folder")
-                continue;
-            const exists = folder.children.some((x) => x.type === "file" && x.name === c.value);
-            if (!exists)
-                throw new Error(formatConstraintError(`${c.path} must have file "${c.value}"`, `Add ${c.value} inside ${c.path}`));
-        }
-        if (c.type === "eachFolderMustContain") {
-            const folders = getFoldersByScope(root, c.path, c.scope);
-            for (const folder of folders) {
-                const exists = folder.children.some((x) => x.name === c.value);
-                if (!exists) {
-                    throw new Error(formatConstraintError(`${folder.name} must contain "${c.value}"`, `Add ${c.value} to ${folder.name}`));
-                }
-            }
-        }
-        if (c.type === "eachFolderMustContainFile") {
-            const folders = getFoldersByScope(root, c.path, c.scope);
-            for (const folder of folders) {
-                const exists = folder.children.some((x) => x.type === "file" && x.name === c.value);
-                if (!exists) {
-                    throw new Error(formatConstraintError(`${folder.name} must contain file "${c.value}"`, `Add ${c.value} inside ${folder.name}`));
-                }
-            }
-        }
-        if (c.type === "eachFolderMustContainFolder") {
-            const folders = getFoldersByScope(root, c.path, c.scope);
-            for (const folder of folders) {
-                const exists = folder.children.some((x) => x.type === "folder" && x.name === c.value);
-                if (!exists) {
-                    throw new Error(formatConstraintError(`${folder.name} must contain folder "${c.value}"`, `Add folder ${c.value} inside ${folder.name}`));
-                }
-            }
-        }
-        if (c.type === "eachFolderMustHaveExt") {
-            const folders = getFoldersByScope(root, c.path, c.scope);
-            for (const folder of folders) {
-                const exists = folder.children.some((x) => x.type === "file" && x.name.endsWith(c.ext));
-                if (!exists) {
-                    throw new Error(formatConstraintError(`${folder.name} must contain a file with extension "${c.ext}"`, `Add a ${c.ext} file inside ${folder.name}`));
-                }
-            }
-        }
-    }
-}

package/dist/visitor.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.visit = visit;
-async function visit(node, visitor, currentPath = "") {
-    const isVirtualRoot = node.name === "__root__";
-    const nodePath = isVirtualRoot
-        ? currentPath
-        : currentPath
-            ? `${currentPath}/${node.name}`
-            : node.name;
-    if (!isVirtualRoot) {
-        await visitor.folder?.(node, nodePath);
-    }
-    for (const child of node.children) {
-        if (child.type === "folder") {
-            await visit(child, visitor, nodePath);
-        }
-        else {
-            await visitor.file?.(child, `${nodePath}/${child.name}`);
-        }
-    }
-}