blend-kit 1.0.1

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;

package/dist/helper/grammarHelper/BlendApiGrammarHelper.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const antlr4ts_1 = require("antlr4ts");
+const BlendApiLexer_1 = require("../../parser/blendApi/src/grammar/BlendApiLexer");
+const BlendApiParser_1 = require("../../parser/blendApi/src/grammar/BlendApiParser");
+class BlendApiGrammarHelper {
+    parseBlendApi(code) {
+        const inputStream = antlr4ts_1.CharStreams.fromString(code);
+        const lexer = new BlendApiLexer_1.BlendApiLexer(inputStream);
+        const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
+        const parser = new BlendApiParser_1.BlendApiParser(tokenStream);
+        const mainModule = parser.program();
+        const json = {
+            name: mainModule.moduleDefinition().CAPITAL_IDENTIFIER().text,
+            apiSectionList: mainModule.sectionDefinition().map(item => {
+                const apiSection = {
+                    name: item.CAPITAL_IDENTIFIER().text, apiList: item.apiDefinition().map(api => {
+                        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+                        const apiSpec = {
+                            input: {},
+                            output: {},
+                            name: api.IDENTIFIER().text,
+                            type: api.HTTP_METHOD().text,
+                            directOutput: ((_b = (_a = api.outputDefinition()) === null || _a === void 0 ? void 0 : _a.directOutputDefenition()) === null || _b === void 0 ? void 0 : _b.type()) ? {
+                                required: !((_d = (_c = api.outputDefinition()) === null || _c === void 0 ? void 0 : _c.directOutputDefenition()) === null || _d === void 0 ? void 0 : _d.type().text.includes("?")),
+                                name: (_g = (_f = (_e = api.outputDefinition()) === null || _e === void 0 ? void 0 : _e.directOutputDefenition()) === null || _f === void 0 ? void 0 : _f.type().text) === null || _g === void 0 ? void 0 : _g.replace("?", ""),
+                            } : {},
+                            authenticated: ((_h = api === null || api === void 0 ? void 0 : api.authenticated()) === null || _h === void 0 ? void 0 : _h.text) == "authenticated"
+                        };
+                        (_k = (_j = api.inputDefinition()) === null || _j === void 0 ? void 0 : _j.field()) === null || _k === void 0 ? void 0 : _k.forEach(field => {
+                            var _a;
+                            apiSpec.input[field.IDENTIFIER().text] = { type: (_a = field.type().text) === null || _a === void 0 ? void 0 : _a.replace("?", ""), required: !(field === null || field === void 0 ? void 0 : field.type().text.includes("?")) };
+                        });
+                        (_m = (_l = api.outputDefinition()) === null || _l === void 0 ? void 0 : _l.field()) === null || _m === void 0 ? void 0 : _m.forEach(field => {
+                            var _a;
+                            apiSpec.output[field.IDENTIFIER().text] = { type: (_a = field.type().text) === null || _a === void 0 ? void 0 : _a.replace("?", ""), required: !(field === null || field === void 0 ? void 0 : field.type().text.includes("?")) };
+                        });
+                        return apiSpec;
+                    })
+                };
+                return apiSection;
+            }),
+            includedDataModuleList: []
+        };
+        return { isValid: parser.numberOfSyntaxErrors === 0, json };
+    }
+}
+exports.default = BlendApiGrammarHelper;

package/dist/helper/grammarHelper/BlendBasicGrammarHelper.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const antlr4ts_1 = require("antlr4ts");
+const BlendBasicLexer_1 = require("../../parser/blendbasic/src/grammar/BlendBasicLexer");
+const BlendBasicParser_1 = require("../../parser/blendbasic/src/grammar/BlendBasicParser");
+const AbstractParseTreeVisitor_1 = require("antlr4ts/tree/AbstractParseTreeVisitor");
+class BlendBasicGrammarHelper extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
+    defaultResult() {
+        return {}; // Avoid errors if visitChildren returns nothing
+    }
+    parseBlendBasic(code) {
+        const inputStream = antlr4ts_1.CharStreams.fromString(code);
+        const lexer = new BlendBasicLexer_1.BlendBasicLexer(inputStream);
+        const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
+        const parser = new BlendBasicParser_1.BlendBasicParser(tokenStream);
+        const sectionsList = parser.sections(); // Assuming the root rule is "program" that contains multiple sections
+        const sections = sectionsList.section().map(section => this.visitSection(section));
+        const basicJson = {
+            name: "BlendBasicConfig",
+            description: "Basic config for swing",
+            createdAt: new Date().toISOString(),
+            sectionList: sections
+        };
+        return { valid: parser.numberOfSyntaxErrors === 0, basicJson };
+    }
+    visitSection(ctx) {
+        const sectionName = ctx.IDENTIFIER().text;
+        // Lists for categorized modules
+        const dataModuleList = [];
+        const expressModuleList = [];
+        const rnModuleList = [];
+        const mongoModuleList = [];
+        const reactModuleList = [];
+        ctx.module().forEach(mod => {
+            const resultList = this.visitModule(mod);
+            console.log(resultList, "resultList");
+            if (!resultList)
+                return;
+            resultList.map(result => {
+                if (result.type === "data-module") {
+                    dataModuleList.push(result.name);
+                }
+                else if (result.type === "express-module") {
+                    expressModuleList.push({ name: result.name });
+                }
+                else if (result.type === "rn-module") {
+                    rnModuleList.push({ name: result.name });
+                }
+                else if (result.type === "mongo-module") {
+                    mongoModuleList.push({ name: result.name });
+                }
+                else if (result.type === "react-module") {
+                    reactModuleList.push({ name: result.name });
+                }
+            });
+        });
+        return {
+            name: sectionName,
+            dataModuleList,
+            expressModuleList,
+            rnModuleList,
+            mongoModuleList,
+            reactModuleList
+        };
+    }
+    visitModule(ctx) {
+        var _a;
+        // Handle multiple identifiers
+        const moduleType = (_a = ctx.children) === null || _a === void 0 ? void 0 : _a[0].text; // First token is the type (e.g., data-module)
+        console.log(moduleType, "moduleType");
+        if (ctx.dataModule())
+            return this.visitDataModule(ctx.dataModule());
+        if (ctx.expressModule())
+            return this.visitExpressModule(ctx.expressModule());
+        if (ctx.rnModule())
+            return this.visitRnModule(ctx.rnModule());
+        if (ctx.mongoModule())
+            return this.visitMongoModule(ctx.mongoModule());
+        if (ctx.reactModule())
+            return this.visitReactModule(ctx.reactModule());
+    }
+    visitDataModule(ctx) {
+        return ctx.IDENTIFIER().map(id => ({ type: "data-module", name: id.text }));
+    }
+    visitExpressModule(ctx) {
+        return ctx.IDENTIFIER().map(id => ({ type: "express-module", name: id.text }));
+    }
+    visitRnModule(ctx) {
+        return ctx.IDENTIFIER().map(id => ({ type: "rn-module", name: id.text }));
+    }
+    visitMongoModule(ctx) {
+        return ctx.IDENTIFIER().map(id => ({ type: "mongo-module", name: id.text }));
+    }
+    visitReactModule(ctx) {
+        return ctx.IDENTIFIER().map(id => ({ type: "react-module", name: id.text }));
+    }
+}
+exports.default = BlendBasicGrammarHelper;

package/dist/helper/grammarHelper/BlendDataGrammarHelper.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const antlr4ts_1 = require("antlr4ts");
+const BlendDataLexer_1 = require("../../parser/blendData/src/grammar/BlendDataLexer");
+const BlendDataParser_1 = require("../../parser/blendData/src/grammar/BlendDataParser");
+class BlendDataGrammarHelper {
+    parseBlendData(code) {
+        const inputStream = antlr4ts_1.CharStreams.fromString(code);
+        const lexer = new BlendDataLexer_1.BlendDataLexer(inputStream);
+        const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
+        const parser = new BlendDataParser_1.BlendDataParser(tokenStream);
+        const mainSection = parser.program(); // Assuming the root rule is "program" that contains multiple sections
+        const dataDefenitionList = mainSection.dataDefinition();
+        let hasError = false;
+        const dataSet = new Set();
+        const moduleDataObject = {
+            name: mainSection.moduleDefinition().CAPITAL_IDENTIFIER().text,
+            dataList: dataDefenitionList.map((dataDefinition) => {
+                const dataName = dataDefinition.CAPITAL_IDENTIFIER().text;
+                if (dataSet.has(dataName)) {
+                    hasError = true;
+                    console.log(`Duplicate Data ${dataName} found`);
+                }
+                dataSet.add(dataDefinition.CAPITAL_IDENTIFIER().text);
+                const fieldSet = new Set();
+                return {
+                    name: dataDefinition.CAPITAL_IDENTIFIER().text,
+                    fields: dataDefinition.field().map((field) => {
+                        const fieldName = field.IDENTIFIER().text;
+                        if (fieldSet.has(fieldName)) {
+                            hasError = true;
+                            console.log(`Field Data ${fieldName} found in ${dataName}`);
+                        }
+                        fieldSet.add(fieldName);
+                        return {
+                            name: fieldName,
+                            requred: !field.type().text.includes("?"),
+                            type: field.type().text.replace("?", ""),
+                        };
+                    })
+                };
+            })
+        };
+        return { valid: parser.numberOfSyntaxErrors === 0 && !hasError, moduleDataObject };
+    }
+}
+exports.default = BlendDataGrammarHelper;

package/dist/helper/grammarHelper/BlendMDPGrammarHelper.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const antlr4ts_1 = require("antlr4ts");
+const AbstractParseTreeVisitor_1 = require("antlr4ts/tree/AbstractParseTreeVisitor");
+const BlendMDPLexer_1 = require("../../parser/blendMDP/src/grammar/BlendMDPLexer");
+const BlendMDPParser_1 = require("../../parser/blendMDP/src/grammar/BlendMDPParser");
+class BlendMDPGrammarHelper extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
+    defaultResult() {
+        return {}; // Avoid errors if visitChildren returns nothing
+    }
+    parseBlendMDP(code) {
+        const inputStream = antlr4ts_1.CharStreams.fromString(code);
+        const lexer = new BlendMDPLexer_1.BlendMDPLexer(inputStream);
+        const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
+        const parser = new BlendMDPParser_1.BlendMDPParser(tokenStream);
+        const program = parser.program();
+        const mdpJson = {
+            name: program.moduleDefinition().CAPITAL_IDENTIFIER().text,
+            propsList: program.propsDefinition().propsBodyDefinition().map(propsBody => {
+                return {
+                    name: propsBody.IDENTIFIER().text,
+                    type: propsBody.CAPITAL_IDENTIFIER().text
+                };
+            })
+        };
+        return { valid: parser.numberOfSyntaxErrors === 0, mdpJson };
+    }
+}
+exports.default = BlendMDPGrammarHelper;

package/dist/helper/grammarHelper/BlendMongoGrammarHelper.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const antlr4ts_1 = require("antlr4ts");
+const BlendMongoLexer_1 = require("../../parser/blendMongo/src/grammar/BlendMongoLexer");
+const BlendMongoParser_1 = require("../../parser/blendMongo/src/grammar/BlendMongoParser");
+class BlendMongoGrammarHelper {
+    parseBlendMongo(code) {
+        const inputStream = antlr4ts_1.CharStreams.fromString(code);
+        const lexer = new BlendMongoLexer_1.BlendMongoLexer(inputStream);
+        const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
+        const parser = new BlendMongoParser_1.BlendMongoParser(tokenStream);
+        const program = parser.program();
+        const moduleDefinition = program.moduleDefinition();
+        const collectionDefinitionList = program.collectionDefinition();
+        const json = {
+            dbName: moduleDefinition.CAPITAL_IDENTIFIER().text,
+            collectionList: collectionDefinitionList.map(collectionDefinition => {
+                var _a;
+                const propertyFields = collectionDefinition.property().map(property => {
+                    var _a, _b, _c, _d, _e, _f;
+                    return {
+                        name: property.IDENTIFIER().text,
+                        type: property.type().text,
+                        unique: ((_a = property.propertyChars()) === null || _a === void 0 ? void 0 : _a.mongoChars()) ? ((_c = (_b = property.propertyChars()) === null || _b === void 0 ? void 0 : _b.mongoChars()) === null || _c === void 0 ? void 0 : _c.findIndex(item => item.text === "unique")) != -1 : undefined,
+                        index: ((_d = property.propertyChars()) === null || _d === void 0 ? void 0 : _d.mongoChars()) ? ((_f = (_e = property.propertyChars()) === null || _e === void 0 ? void 0 : _e.mongoChars()) === null || _f === void 0 ? void 0 : _f.findIndex(item => item.text === "index")) != -1 : undefined,
+                        // ref: collectionDefinition.reference()?collectionDefinition.reference()?.CAPITAL_IDENTIFIER().text:undefined,
+                    };
+                });
+                const referenceFields = (_a = collectionDefinition.reference()) === null || _a === void 0 ? void 0 : _a.map(reference => {
+                    var _a, _b, _c, _d, _e, _f;
+                    return {
+                        name: reference.IDENTIFIER().text,
+                        type: 'Types.ObjectId',
+                        unique: ((_a = reference.propertyChars()) === null || _a === void 0 ? void 0 : _a.mongoChars()) ? ((_c = (_b = reference.propertyChars()) === null || _b === void 0 ? void 0 : _b.mongoChars()) === null || _c === void 0 ? void 0 : _c.findIndex(item => item.text === "unique")) != -1 : undefined,
+                        index: ((_d = reference.propertyChars()) === null || _d === void 0 ? void 0 : _d.mongoChars()) ? ((_f = (_e = reference.propertyChars()) === null || _e === void 0 ? void 0 : _e.mongoChars()) === null || _f === void 0 ? void 0 : _f.findIndex(item => item.text === "index")) != -1 : undefined,
+                        ref: reference === null || reference === void 0 ? void 0 : reference.CAPITAL_IDENTIFIER().text,
+                    };
+                });
+                return {
+                    name: collectionDefinition.CAPITAL_IDENTIFIER().text,
+                    fields: [...propertyFields, ...referenceFields]
+                };
+            })
+        };
+        return {
+            isValid: parser.numberOfSyntaxErrors > 0,
+            json: json
+        };
+    }
+}
+exports.default = BlendMongoGrammarHelper;

package/dist/helper/grammarHelper/BlendRNGrammarHelper.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const antlr4ts_1 = require("antlr4ts");
+const BlendRNLexer_1 = require("../../parser/blendRN/src/grammar/BlendRNLexer");
+const BlendRNParser_1 = require("../../parser/blendRN/src/grammar/BlendRNParser");
+class BlendRNGrammarHelper {
+    parseBlendRN(code) {
+        const inputStream = antlr4ts_1.CharStreams.fromString(code);
+        const lexer = new BlendRNLexer_1.BlendRNLexer(inputStream);
+        const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
+        const parser = new BlendRNParser_1.BlendRNParser(tokenStream);
+        const program = parser.program();
+        let screenList = [];
+        let componentList = [];
+        program.screenDefenition().forEach(screen => {
+            screen.CAPITAL_IDENTIFIER().forEach(screenName => {
+                screenList.push({ name: screenName.text, path: screen.PATH_IDENTIFIER().text.replace(/"/g, '') });
+            });
+        });
+        program.componentDefenition().forEach(component => {
+            component.CAPITAL_IDENTIFIER().forEach(componentName => {
+                componentList.push({ name: componentName.text, path: component.PATH_IDENTIFIER().text.replace(/"/g, '') });
+            });
+        });
+        const layout = parseAndCreateLayoutAndScreen(program);
+        function parseAndCreateLayoutAndScreen(prgrm) {
+            return prgrm.layoutDefinition().map(layout => {
+                const layoutList = parseAndCreateLayoutAndScreen(layout);
+                const pageList = layout.pageDefinition().map(page => {
+                    return {
+                        name: page.CAPITAL_IDENTIFIER()[0].text,
+                        route: page.PATH_IDENTIFIER().text.replace(/"/g, ''),
+                        element: page.CAPITAL_IDENTIFIER()[1].text
+                    };
+                });
+                return {
+                    name: layout.CAPITAL_IDENTIFIER().text,
+                    route: layout.PATH_IDENTIFIER().text.replace(/"/g, ''),
+                    children: [...layoutList, ...pageList],
+                    type: layout.LAYOUT_TYPE().text
+                };
+            });
+        }
+        const json = {
+            componentList,
+            screenList,
+            layout,
+            name: program.moduleDefinition().CAPITAL_IDENTIFIER().text
+        };
+        return {
+            valid: parser.numberOfSyntaxErrors == 0,
+            json
+        };
+    }
+}
+exports.default = BlendRNGrammarHelper;

package/dist/helper/grammarHelper/BlendReactGrammarHelper.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const antlr4ts_1 = require("antlr4ts");
+const BlendReactLexer_1 = require("../../parser/blendReact/src/grammar/BlendReactLexer");
+const BlendReactParser_1 = require("../../parser/blendReact/src/grammar/BlendReactParser");
+class BlendReactGrammarHelper {
+    parseBlendReact(code) {
+        const inputStream = antlr4ts_1.CharStreams.fromString(code);
+        const lexer = new BlendReactLexer_1.BlendReactLexer(inputStream);
+        const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
+        const parser = new BlendReactParser_1.BlendReactParser(tokenStream);
+        const program = parser.program();
+        let screenList = [];
+        let componentList = [];
+        program.screenDefenition().forEach(screen => {
+            screen.CAPITAL_IDENTIFIER().forEach(screenName => {
+                screenList.push({ name: screenName.text, path: screen.PATH_IDENTIFIER().text.replace(/"/g, '') });
+            });
+        });
+        program.componentDefenition().forEach(screen => {
+            screen.CAPITAL_IDENTIFIER().forEach(screenName => {
+                componentList.push({ name: screenName.text, path: screen.PATH_IDENTIFIER().text.replace(/"/g, '') });
+            });
+        });
+        const layout = parseAndCreateLayoutAndScreen(program);
+        function parseAndCreateLayoutAndScreen(prgrm) {
+            return prgrm.layoutDefinition().map(layout => {
+                const layoutList = parseAndCreateLayoutAndScreen(layout);
+                const pageList = layout.pageDefinition().map(page => {
+                    return {
+                        name: page.CAPITAL_IDENTIFIER()[0].text,
+                        route: page.PATH_IDENTIFIER().text.replace(/"/g, ''),
+                        element: page.CAPITAL_IDENTIFIER()[1].text
+                    };
+                });
+                return {
+                    name: layout.CAPITAL_IDENTIFIER().text,
+                    route: layout.PATH_IDENTIFIER().text.replace(/"/g, ''),
+                    children: [...layoutList, ...pageList],
+                };
+            });
+        }
+        const json = {
+            componentList,
+            screenList,
+            layout,
+            name: program.moduleDefinition().CAPITAL_IDENTIFIER().text.toLocaleLowerCase()
+        };
+        return {
+            valid: parser.numberOfSyntaxErrors == 0,
+            json
+        };
+    }
+}
+exports.default = BlendReactGrammarHelper;

package/dist/helper/grammarHelper/GrammarErrorHelper.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class GrammarErrorHelper {
+    static validateSyntax(parser) {
+        const syntaxErrors = [];
+        parser.removeErrorListeners();
+        parser.addErrorListener({
+            syntaxError: (recognizer, offendingSymbol, line, charPositionInLine, msg, e) => {
+                syntaxErrors.push(`Line ${line}:${charPositionInLine} - ${msg}`);
+            }
+        });
+        console.log(syntaxErrors, "syntaxErrors");
+        return syntaxErrors;
+    }
+}
+exports.default = GrammarErrorHelper;