blend-r 1.1.6

package/dist/helper/BasicHelper.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fileHelper_1 = require("./fileHelper");
+const path_1 = __importDefault(require("path"));
+const BlendBasicGrammarHelper_1 = __importDefault(require("./grammarHelper/BlendBasicGrammarHelper"));
+class BasicHelper {
+    constructor() {
+        this.folderPath = path_1.default.join(process.cwd());
+        this.folderName = path_1.default.basename(this.folderPath);
+        this.basicFilePath = path_1.default.join(this.folderPath, `${this.folderName}.basic`);
+        this.configPath = path_1.default.join(this.folderPath, '.basicConfig');
+        this.specPath = path_1.default.join(this.folderPath, 'spec');
+    }
+    parseSpec(spec) {
+        const blendbasic = new BlendBasicGrammarHelper_1.default();
+        const basicParsedJSON = blendbasic.parseBlendBasic(spec);
+        if (basicParsedJSON.valid) {
+            basicParsedJSON.basicJson.name = this.folderName;
+            fileHelper_1.FileHelper.ensureDir(this.configPath);
+            fileHelper_1.FileHelper.writeFile(`${this.configPath}/basicConfig.json`, JSON.stringify(basicParsedJSON.basicJson));
+        }
+        else {
+        }
+    }
+    createRequiredFile(spec) {
+        const blendbasic = new BlendBasicGrammarHelper_1.default();
+        const basicParsedJSON = blendbasic.parseBlendBasic(spec);
+        if (basicParsedJSON.valid) {
+            basicParsedJSON.basicJson.dataModuleList.map(item => {
+                fileHelper_1.FileHelper.createFile(`${this.specPath}/data/${item}.data`, `module ${item}`);
+            });
+            basicParsedJSON.basicJson.apiModuleList.map(item => {
+                fileHelper_1.FileHelper.createFile(`${this.specPath}/api/${item}.api`, `module ${item}`);
+            });
+        }
+        else {
+        }
+    }
+}
+exports.default = BasicHelper;

package/dist/helper/DataHelper.js

@@ -0,0 +1,231 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fileHelper_1 = require("./fileHelper");
+const BlendDataGrammarHelper_1 = __importDefault(require("./grammarHelper/BlendDataGrammarHelper"));
+const basicDataTypes = ["string", "object", "boolean", "number", "any"];
+class DataHelper {
+    constructor() {
+        this.folderPath = path_1.default.join(process.cwd());
+        this.folderName = path_1.default.basename(this.folderPath);
+        this.basicFilePath = path_1.default.join(this.folderPath, `${this.folderName}.basic`);
+        this.configPath = path_1.default.join(this.folderPath, '.basicConfig');
+        this.specPath = path_1.default.join(this.folderPath, 'spec');
+    }
+    parseSpec() {
+        const basicFile = JSON.parse(fileHelper_1.FileHelper.readFile(`${this.configPath}/basicConfig.json`));
+        let mainDataObjList = [];
+        const dataFolderPath = path_1.default.join(this.folderPath, 'spec/data');
+        basicFile.dataModuleList.forEach(module => {
+            const filePath = path_1.default.join(dataFolderPath, `${module}.data`);
+            const specCode = fileHelper_1.FileHelper.readFile(filePath);
+            const json = new BlendDataGrammarHelper_1.default().parseBlendData(specCode);
+            console.log(json, "json");
+            if (!json.valid) {
+                throw new Error("Error while parsing the syntax");
+            }
+            const moduleDataObject = json.moduleDataObject;
+            mainDataObjList.push(moduleDataObject);
+        });
+        // sectionDataObjList.push({
+        //     name: sectionName,
+        //     sectionDataList: mainDataObjList
+        // });
+        fileHelper_1.FileHelper.writeFile(`${this.configPath}/dataConfig.json`, JSON.stringify(mainDataObjList));
+    }
+    parseJSONAndGenerateFiles() {
+        try {
+            const moduleDataList = JSON.parse(fileHelper_1.FileHelper.readFile(`${this.configPath}/dataConfig.json`));
+            moduleDataList.forEach((moduleData) => __awaiter(this, void 0, void 0, function* () {
+                const dataPath = path_1.default.join(this.folderPath, `src-gen/data/${moduleData.name}.ts`);
+                const imports = new Set(); // Collect unique imports
+                // Generate class definitions
+                const classesCode = moduleData.dataList
+                    .map((curItem) => {
+                    // Collect imports for fields with types like "Module->ClassName"
+                    curItem.fields.forEach((field) => {
+                        const typeParts = field.type.split("->");
+                        if (typeParts.length === 2) {
+                            const [module, typeName] = typeParts;
+                            const baseTypeName = typeName.endsWith("[]") ? typeName.slice(0, -2) : typeName;
+                            imports.add(`import { ${baseTypeName} } from './${module}';`);
+                        }
+                    });
+                    // Generate the class code
+                    return `
+    export class ${curItem.name} {
+        constructor(
+    ${curItem.fields
+                        .map((field) => `        public ${field.name}: ${this.resolveType(field.type)}${!field.required ? '|undefined' : ''} = ${this.getDefaultValue(field, moduleData)},`)
+                        .join('\n')}
+        ) {}
+    
+        static fromJSON(jsonObj: any): ${curItem.name} {
+            return new ${curItem.name}(
+    ${curItem.fields
+                        .map((field) => this.generateFromJSONField(field))
+                        .join(',\n')}
+            );
+        }
+    
+        public toJSON(): any {
+            return {
+    ${curItem.fields
+                        .map((field) => this.generateToJSONField(field, moduleData))
+                        .join('\n')}
+            };
+        }
+    }
+
+
+export interface I_${curItem.name} {
+${curItem.fields
+                        .map((field) => `        ${field.name}: ${this.resolveType(field.type)}${field.required ? '|undefined' : ''},`)
+                        .join('\n')}
+}
+                        `;
+                })
+                    .join('\n');
+                // Combine imports and class definitions
+                const finalCode = `
+    ${Array.from(imports).join('\n')}
+    
+    ${classesCode}
+    `;
+                fileHelper_1.FileHelper.writeFile(dataPath, finalCode);
+                // this.basicProjectContent.sectionList.forEach(section => {
+                //     section.expressModuleList.forEach(expressModule => {
+                //         // if (expressModule.includedDataModuleList.includes(moduleData.name)) {
+                //         if(section.name==sectionData.name) {
+                //             const expressDataPath = `${this.folderPath}/module/${section.name}/express/${section.name}-api/src-gen/data/${expressModule.name}/${moduleData.name}.ts`
+                //             FileHelper.writeFile(expressDataPath, finalCode);
+                //         }
+                //         // }
+                //     });
+                // })
+            }));
+        }
+        catch (e) {
+        }
+    }
+    resolveType(type) {
+        const typeParts = type.split("->");
+        const baseType = typeParts.length === 2 ? typeParts[1] : type;
+        return baseType.endsWith("[]") ? `${baseType.slice(0, -2)}[]` : baseType; // Handle array types
+    }
+    getDefaultValue(field, curItem) {
+        const typeParts = field.type.split("->");
+        const baseType = typeParts.length === 2 ? typeParts[1] : field.type;
+        if (baseType.endsWith("[]")) {
+            return "[]"; // Default value for arrays
+        }
+        if (typeParts.length === 2) {
+            const [, typeName] = typeParts;
+            const baseTypeName = typeName.endsWith("[]") ? typeName.slice(0, -2) : typeName;
+            return `new ${baseTypeName}()`; // Instantiate the imported class
+        }
+        if (!basicDataTypes.includes(field.type)) {
+            const currentFieldType = curItem.dataList.find(item => item.name == field.type);
+            if (!currentFieldType) {
+                throw new Error(`unable to find out ${currentFieldType}`);
+            }
+            else {
+                if (field.required) {
+                    return `new ${currentFieldType.name}()`;
+                }
+                else {
+                    return undefined;
+                }
+            }
+        }
+        else {
+            switch (field.type) {
+                case "string":
+                    return field.required ? "''" : "undefined";
+                case "object":
+                    return field.required ? "{}" : "undefined";
+                case "boolean":
+                    return field.required ? "false" : "undefined";
+                case "number":
+                    return field.required ? "0" : "undefined";
+                default:
+                    return "null";
+            }
+        }
+    }
+    generateFromJSONField(field) {
+        const typeParts = field.type.split("->");
+        const baseType = typeParts.length === 2 ? typeParts[1] : field.type;
+        if (baseType.endsWith("[]")) {
+            const elementType = baseType.slice(0, -2);
+            if (["string", "number", "boolean"].includes(elementType)) {
+                return `            jsonObj.${field.name} ?? []`;
+            }
+            return `            (jsonObj.${field.name} != null) ? jsonObj.${field.name}.map((item: any) => ${elementType}.fromJSON(item)) : []`;
+        }
+        if (typeParts.length === 2) {
+            const [, typeName] = typeParts;
+            const baseTypeName = typeName.endsWith("[]") ? typeName.slice(0, -2) : typeName;
+            return `            (jsonObj.${field.name} != null) ? ${baseTypeName}.fromJSON(jsonObj.${field.name}) : new ${baseTypeName}()`;
+        }
+        if (!basicDataTypes.includes(baseType)) {
+            const baseTypeName = baseType.endsWith("[]") ? baseType.slice(0, -2) : baseType;
+            return `            (jsonObj.${field.name} != null) ? ${baseTypeName}.fromJSON(jsonObj.${field.name}) : new ${baseTypeName}()`;
+        }
+        return `            (jsonObj.${field.name} !== null) ? jsonObj?.${field.name} : undefined`;
+    }
+    // generateToJSONField(field: IDataField): string {
+    //     const typeParts = field.type.split("->");
+    //     const baseType = typeParts.length === 2 ? typeParts[1] : field.type;
+    //     if (baseType.endsWith("[]")) {
+    //         const elementType = baseType.slice(0, -2);
+    //         if (["string", "number", "boolean"].includes(elementType)) {
+    //             return `            ${field.name}: this.${field.name} ?? [],`;
+    //         }
+    //         return `            ${field.name}: (this.${field.name} != null) ? this.${field.name}.map((x) => x.toJSON()) : [],`;
+    //     }
+    //     return `            ${field.name}: this.${field.name} != null ? this.${field.name} : undefined,`;
+    // }
+    generateToJSONField(field, curItem) {
+        // const typeParts = field.type.split("->");
+        // const baseType = typeParts.length === 2 ? typeParts[1] : field.type;
+        // if (baseType.endsWith("[]")) {
+        //     const elementType = baseType.slice(0, -2);
+        //     if (["string", "number", "boolean"].includes(elementType)) {
+        //         return `            ${field.name}: this.${field.name} ?? [],`;
+        //     }
+        //     return `            ${field.name}: (this.${field.name} != null) ? this.${field.name}.map((x) => x.toJson()) : [],`;
+        // }
+        // return `            ${field.name}: this.${field.name} != null ? this.${field.name} : undefined,`;
+        const typeParts = field.type.split("->");
+        const baseType = typeParts.length === 2 ? typeParts[1] : field.type;
+        if (baseType.endsWith("[]")) {
+            const elementType = baseType.slice(0, -2);
+            if (["string", "number", "boolean", "object", "any"].includes(elementType)) {
+                return `            ${field.name}: this.${field.name} ?? [],`;
+            }
+            return `            ${field.name}: (this.${field.name} != null) ? this.${field.name}.map((x) => x.toJSON()) : [],`;
+        }
+        else {
+            if (["string", "number", "boolean", "object", "any"].includes(baseType)) {
+                return `${field.name}: this.${field.name} != null ? this.${field.name} : ${this.getDefaultValue(field, curItem)},`;
+            }
+            else {
+                return `            ${field.name}: this.${field.name} != null ? this.${field.name}.toJSON() : ${this.getDefaultValue(field, curItem)}.toJSON(),`;
+            }
+        }
+    }
+}
+exports.default = DataHelper;

package/dist/helper/FrontEndHelper.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fileHelper_1 = require("./fileHelper");
+class FrontEndHelper {
+    constructor() {
+        this.folderPath = path_1.default.join(process.cwd());
+        this.folderName = path_1.default.basename(this.folderPath);
+        this.basicFilePath = path_1.default.join(this.folderPath, `${this.folderName}.basic`);
+        this.configPath = path_1.default.join(this.folderPath, '.basicConfig');
+        this.specPath = path_1.default.join(this.folderPath, 'spec');
+    }
+    buildFrontEnd() {
+        this.generateFrontEndScreen();
+        this.buildLayouts();
+        this.generateComponents();
+    }
+    generateFrontEndScreen() {
+        const basicFile = JSON.parse(fileHelper_1.FileHelper.readFile(`${this.configPath}/basicConfig.json`));
+        basicFile.frontend.screenList.map(screen => {
+            const screenPath = `${this.folderPath}/src/view/${screen.path}/${screen.name}/`;
+            const screenCode = this.generateScreenCode(screen);
+            fileHelper_1.FileHelper.createFile(`${screenPath}${screen.name}View.tsx`, screenCode);
+            fileHelper_1.FileHelper.createFile(`${screenPath}${screen.name}Style.css`, `
+            `);
+            fileHelper_1.FileHelper.ensureDir(`${screenPath}/components`);
+        });
+    }
+    // createTestCaseCode() {
+    // }
+    generateComponents() {
+        const basicFile = JSON.parse(fileHelper_1.FileHelper.readFile(`${this.configPath}/basicConfig.json`));
+        basicFile.frontend.componentList.map(component => {
+            const screenPath = `${this.folderPath}/src/components/${component.path}/${component.name}/`;
+            const screenCode = this.generateScreenCode(component);
+            fileHelper_1.FileHelper.createFile(`${screenPath}${component.name}Comp.tsx`, screenCode);
+            fileHelper_1.FileHelper.createFile(`${screenPath}${component.name}Style.ts`, `
+            import { StyleSheet } from 'react-native';
+            const styles = StyleSheet.create({})
+            export default styles;
+            `);
+        });
+    }
+    generateScreenCode(screen) {
+        return `
+        import "./${screen.name}Style.css"
+        const ${screen.name} = () => {
+        return(
+            <div>
+            ${screen.name}
+            </div>
+        )
+        }
+        
+        export default ${screen.name};
+        `;
+    }
+    buildLayouts() {
+        const basicFile = JSON.parse(fileHelper_1.FileHelper.readFile(`${this.configPath}/basicConfig.json`));
+        const lo = {
+            name: "BlendGenerated",
+            route: "/",
+            children: basicFile.frontend.layout,
+        };
+        const routerCode = this.generateRouterCode(lo, basicFile);
+        fileHelper_1.FileHelper.writeFile(`${this.folderPath}/src-gen/router/blend-router.tsx`, routerCode);
+        this.traverseChildrenAndCreateLayout(lo, basicFile.frontend);
+        const routerConstant = this.generateRouterConstant(basicFile.frontend.layout);
+        fileHelper_1.FileHelper.createFile(`${this.folderPath}/src/layout/${lo.name}Layout.tsx`, `
+${this.generateLayoutCode(lo)}
+`);
+        fileHelper_1.FileHelper.writeFile(`${this.folderPath}/src-gen/router/routerConstant.ts`, `
+    ${routerConstant}
+    `);
+        // })
+    }
+    traverseChildrenAndCreateLayout(lo, frontEnd) {
+        lo.children.forEach(loChild => {
+            if (loChild.children) {
+                fileHelper_1.FileHelper.createFile(`${this.folderPath}/src/layout/${loChild.name}Layout.tsx`, `
+${this.generateLayoutCode(loChild)}
+`);
+                this.traverseChildrenAndCreateLayout(loChild, frontEnd);
+            }
+        });
+    }
+    findScreenPath(screenList, screenName) {
+        const index = screenList.findIndex(screen => screen.name === screenName);
+        if (screenList[index]) {
+            return `${screenList[index].path}`;
+        }
+        else {
+            // alert(`${screenName} not found`)
+        }
+    }
+    generateRouterConstant(children) {
+        let path = '';
+        const routeObj = generateRouterConstantObj(children);
+        function generateRouterConstantObj(children) {
+            return children.reduce((acc, child, index) => {
+                if (child.children) {
+                    path = child.route && child.route != "" && child.route != "/" ? path + "/" + child.route : path;
+                    acc[child.name] = generateRouterConstantObj(child.children);
+                    console.log(child.name, index, children.length, "Path With layout After");
+                    if (index == children.length - 1) {
+                        path = path.split("/").slice(0, -1).join('_').toString();
+                        // const pathNumToBeRemoved = child.route.split("/").length;
+                        // path = path.split("/").slice(0,-pathNumToBeRemoved).join('/').toString();
+                    }
+                }
+                else {
+                    path = child.route && child.route != "" && child.route != "/" ? path + "/" + child.route : path;
+                    acc[child.name] = path;
+                    console.log(path, "Path Without layout");
+                    const pathNumToBeRemoved = child.route.split("/").length;
+                    console.log(pathNumToBeRemoved, index, children.length, "pathNumToBeRemoved..............");
+                    path = path.split("/").slice(0, -pathNumToBeRemoved).join('_').toString();
+                    if (index == children.length - 1) {
+                        path = path.split("/").slice(0, -1).join('_').toString();
+                        // const pathNumToBeRemoved = child.route.split("/").length;
+                        // path = path.split("/").slice(0,-pathNumToBeRemoved).join('/').toString();
+                    }
+                }
+                return acc;
+            }, {});
+        }
+        return `export const RouterConstant = ${JSON.stringify(routeObj)}`;
+    }
+    generateLayoutCode(lo) {
+        return (`
+import { Outlet } from "react-router-dom"
+const ${lo.name}Layout = () => {
+        return (
+        <div>
+            ${lo.name}Layout
+            <Outlet />
+        </div>
+        )
+}
+
+export default ${lo.name}Layout;
+`);
+    }
+    generateFlattenedArray(children) {
+        let uniqueElements = [];
+        let flatenedArray = [];
+        generateFlattenedArrayFun(children);
+        function generateFlattenedArrayFun(children) {
+            return children.forEach((child) => {
+                flatenedArray.push(child);
+                if (child.children) {
+                    generateFlattenedArrayFun(child.children);
+                }
+                else {
+                    if (!uniqueElements.includes(child.element)) {
+                        uniqueElements.push(child.element);
+                    }
+                    else {
+                        flatenedArray.pop();
+                    }
+                }
+            });
+        }
+        return flatenedArray;
+    }
+    generateRouterCode(mainLayout, basicFile) {
+        const defaultImportCode = `
+        import { createBrowserRouter } from 'react-router-dom';\n
+        import React from 'react';\n
+        import BlendGeneratedLayout from '../../src/layout/BlendGeneratedLayout';
+        `;
+        console.log([mainLayout], JSON.stringify([mainLayout]), "Main layout///////////////");
+        const routerJsonCode = `const router = createBrowserRouter([${this.generateLayoutRouterJSONCode([mainLayout])}])\nexport default router;`;
+        const routerConstant = this.generateRouterConstant([mainLayout]);
+        console.log(this.generateFlattenedArray(mainLayout.children), "this.generateFlattenedArray(mainLayout.children)");
+        const importCode = `${this.generateFlattenedArray(mainLayout.children).reduce((acc, item) => {
+            const importCode = `   ${item.children ? `
+                    import ${item.name}Layout from '../../src/layout/${item.name}Layout';\n
+                    ` : `
+                    import ${item.element} from '../../src/view/${this.findScreenPath(basicFile.frontend.screenList, ((item === null || item === void 0 ? void 0 : item.element) || ""))}/${item.element}/${item.element}View';\n
+                    `}`;
+            acc = acc + importCode;
+            return acc;
+        }, "")}`;
+        return importCode + defaultImportCode + routerJsonCode + '\n' + routerConstant;
+    }
+    generateLayoutRouterJSONCode(layoutList) {
+        return layoutList.reduce((acc, layout) => {
+            acc = acc + `{element: ${layout.children ? `<${layout.name}Layout/>,` : `<${layout.element} />,`}
+            path: "${layout.route}",
+            ${layout.children ? `children: [${this.generateLayoutRouterJSONCode(layout.children)}],` : ``}
+            },
+            `;
+            return acc;
+        }, '');
+    }
+}
+exports.default = FrontEndHelper;

package/dist/helper/fileHelper.js

@@ -0,0 +1,127 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileHelper = void 0;
+// fileHelper.ts
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+class FileHelper {
+    // Ensure a directory exists, create it if it doesn't
+    static ensureDir(folderPath) {
+        try {
+            fs_extra_1.default.ensureDirSync(folderPath);
+        }
+        catch (error) {
+            console.error(`Error ensuring directory: ${error.message}`);
+            throw error;
+        }
+    }
+    static writeFile(filePath, content) {
+        try {
+            // Ensure the folder exists
+            const folderPath = path_1.default.dirname(filePath);
+            this.ensureDir(folderPath);
+            // Write the file
+            fs_extra_1.default.writeFileSync(filePath, content);
+        }
+        catch (error) {
+            console.error(`Error writing file at ${filePath}: ${error.message}`);
+            throw error;
+        }
+    }
+    static createFile(filePath, content) {
+        try {
+            // Ensure the folder exists
+            const folderPath = path_1.default.dirname(filePath);
+            this.ensureDir(folderPath);
+            if (!fs_extra_1.default.existsSync(filePath)) {
+                fs_extra_1.default.writeFileSync(filePath, content);
+            }
+            // Write the file
+        }
+        catch (error) {
+            console.error(`Error writing file at ${filePath}: ${error.message}`);
+            throw error;
+        }
+    }
+    // Read content from a file
+    static readFile(filePath) {
+        try {
+            return fs_extra_1.default.readFileSync(filePath, 'utf-8');
+        }
+        catch (error) {
+            console.error(`Error reading file at ${filePath}: ${error.message}`);
+            throw error;
+        }
+    }
+    // Write a JSON object to a file, ensuring the folder exists
+    static writeJson(filePath, jsonContent) {
+        try {
+            // Ensure the folder exists
+            const folderPath = path_1.default.dirname(filePath);
+            this.ensureDir(folderPath);
+            // Write the JSON file
+            fs_extra_1.default.writeJsonSync(filePath, jsonContent, { spaces: 2 });
+        }
+        catch (error) {
+            console.error(`Error writing JSON to ${filePath}: ${error.message}`);
+            throw error;
+        }
+    }
+    // Check if a file or directory exists
+    static exists(filePath) {
+        try {
+            return fs_extra_1.default.existsSync(filePath);
+        }
+        catch (error) {
+            console.error(`Error checking existence of ${filePath}: ${error.message}`);
+            throw error;
+        }
+    }
+    // Copy a file from source to destination, ensuring the destination folder exists
+    static copyFile(srcPath, destPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Ensure the destination folder exists
+                yield fs_extra_1.default.ensureDir(path_1.default.dirname(destPath));
+                // Copy the file
+                yield fs_extra_1.default.copyFile(srcPath, destPath);
+                console.log(`File copied from ${srcPath} to ${destPath}`);
+            }
+            catch (error) {
+                console.error(`Error copying file from ${srcPath} to ${destPath}: ${error.message}`);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Copies an entire folder from source to destination, including its contents.
+     * @param srcFolder The path to the source folder.
+     * @param destFolder The path to the destination folder.
+     */
+    static copyFolder(srcFolder, destFolder) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Copy the folder recursively
+                yield fs_extra_1.default.copy(srcFolder, destFolder, { overwrite: true });
+                console.log(`Folder copied from ${srcFolder} to ${destFolder}`);
+            }
+            catch (error) {
+                console.error(`Error copying folder from ${srcFolder} to ${destFolder}: ${error.message}`);
+                throw error;
+            }
+        });
+    }
+}
+exports.FileHelper = FileHelper;