blend-kit 1.0.1

package/dist/helper/BasicHelper.js

@@ -0,0 +1,28 @@
+"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');
+    }
+    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 {
+        }
+    }
+}
+exports.default = BasicHelper;

package/dist/helper/CommonHelper.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonHelper = void 0;
+class CommonHelper {
+    static hyphenSepratedString(text) {
+        return text.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+        ;
+    }
+}
+exports.CommonHelper = CommonHelper;

package/dist/helper/DataHelper.js

@@ -0,0 +1,241 @@
+"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.basicProjectContent = JSON.parse(fileHelper_1.FileHelper.readFile(`${this.configPath}/basicConfig.json`) || "{}");
+    }
+    doDataOperations(basicFileContent) {
+        try {
+            this.basicFileContent = basicFileContent;
+            this.createDataSpec();
+            this.parseSpec();
+        }
+        catch (e) {
+        }
+    }
+    createDataSpec() {
+        this.basicProjectContent.sectionList.forEach(section => {
+            const sectionName = section.name.trim();
+            const sectionFolderPath = path_1.default.join(this.folderPath, 'spec', sectionName);
+            const dataFolderPath = path_1.default.join(sectionFolderPath, 'data');
+            section.dataModuleList.forEach(dataModule => {
+                const dataFilePath = path_1.default.join(dataFolderPath, `${dataModule}.data`);
+                if (!fileHelper_1.FileHelper.exists(dataFilePath)) {
+                    fileHelper_1.FileHelper.writeFile(dataFilePath, `module ${dataModule}`);
+                }
+                else {
+                }
+            });
+        });
+    }
+    parseSpec() {
+        let sectionDataObjList = [];
+        this.basicProjectContent.sectionList.forEach(section => {
+            const sectionName = section.name;
+            const sectionFolderPath = path_1.default.join(this.folderPath, 'spec', sectionName);
+            let mainDataObjList = [];
+            const dataFolderPath = path_1.default.join(sectionFolderPath, 'data');
+            section.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);
+                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(sectionDataObjList));
+    }
+    parseJSONAndGenerateFiles() {
+        try {
+            const sectionDataList = JSON.parse(fileHelper_1.FileHelper.readFile(`${this.configPath}/dataConfig.json`));
+            sectionDataList.forEach((sectionData) => __awaiter(this, void 0, void 0, function* () {
+                const sectionPath = path_1.default.join(this.folderPath, `module/${sectionData.name}`);
+                sectionData.sectionDataList.forEach((moduleData) => __awaiter(this, void 0, void 0, function* () {
+                    const dataPath = path_1.default.join(sectionPath, `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(): object {
+            return {
+    ${curItem.fields
+                            .map((field) => this.generateToJSONField(field))
+                            .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_1.FileHelper.writeFile(expressDataPath, finalCode);
+                            }
+                            // }
+                        });
+                        section.rnModuleList.forEach(rnModule => {
+                            // if (expressModule.includedDataModuleList.includes(moduleData.name)) {
+                            if (section.name == sectionData.name) {
+                                const rnDataPath = `${this.folderPath}/module/${section.name}/react-native/${rnModule.name}/src-gen/data/${moduleData.name}.ts`;
+                                fileHelper_1.FileHelper.writeFile(rnDataPath, finalCode);
+                            }
+                            // }
+                        });
+                        section.reactModuleList.forEach(reactModule => {
+                            // if (expressModule.includedDataModuleList.includes(moduleData.name)) {
+                            if (section.name == sectionData.name) {
+                                const reactDataPath = `${this.folderPath}/module/${section.name}/react/${reactModule.name}/src/src-gen/data/${moduleData.name}.ts`;
+                                fileHelper_1.FileHelper.writeFile(reactDataPath, 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) {
+        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,`;
+    }
+}
+exports.default = DataHelper;