definition-generator-framework 1.13.0 → 2.0.0-rc0

package/dist/framework/framework.data.js

@@ -1,17 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.FrameworkData = void 0;
-const _3_config_1 = require('../pipeline/3-config');
-class FrameworkData {
-  static {
-    this.definitionNames = new Set([_3_config_1.ConfigDefinitionName]);
-  }
-  static {
-    this.modules = [];
-  }
-  static {
-    this.interfaces = '';
-  }
-}
-exports.FrameworkData = FrameworkData;
-//# sourceMappingURL=framework.data.js.map

package/dist/framework/framework.js

@@ -1,51 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.DefinitionModule =
-  exports.DefinitionModuleDecorator =
-  exports.SingleDefinitionComponent =
-  exports.DefinitionComponent =
-  exports.DefinitionComponentDecorator =
-    void 0;
-const kernel_1 = require('./kernel');
-const definition_store_1 = require('./definition-store');
-function DefinitionComponentDecorator(meta) {
-  return function (ComponentClass) {
-    definition_store_1.FrameworkData.definitionNames.add(meta.definitionName);
-    ComponentClass.$meta = {
-      definitionName: meta.definitionName,
-      keyName: meta.keyName,
-      singleton: meta.singleton,
-      validationSchema: meta.validationSchema
-    };
-  };
-}
-exports.DefinitionComponentDecorator = DefinitionComponentDecorator;
-class DefinitionComponent {
-  static getSchema() {
-    return this.$meta.validationSchema;
-  }
-}
-exports.DefinitionComponent = DefinitionComponent;
-class SingleDefinitionComponent {
-  static getSchema() {
-    return this.$meta.validationSchema;
-  }
-}
-exports.SingleDefinitionComponent = SingleDefinitionComponent;
-let ModuleIsRegistered = false;
-function DefinitionModuleDecorator(meta) {
-  return function (ModuleClass) {
-    if (ModuleIsRegistered) {
-      console.error('There can be only one definition module!');
-    } else {
-      ModuleIsRegistered = true;
-      definition_store_1.FrameworkData.modules.push(...meta.modules);
-      definition_store_1.FrameworkData.interfaces = meta.interfaces;
-      kernel_1.Kernel.process();
-    }
-  };
-}
-exports.DefinitionModuleDecorator = DefinitionModuleDecorator;
-class DefinitionModule {}
-exports.DefinitionModule = DefinitionModule;
-//# sourceMappingURL=framework.js.map

package/dist/framework/framework.model.d.ts

@@ -1,32 +0,0 @@
-export interface FileSystem {
-  existsSync: (path: string) => boolean;
-}
-export interface FileInfo {
-  path: string;
-  content: string;
-}
-export interface LocationInFile {
-  readonly path: string;
-  readonly line: number;
-}
-export interface ErrorLog {
-  readonly description: string;
-  readonly location: LocationInFile;
-}
-export interface Config {
-  projectRoot: string;
-}
-export type RawData = undefined | string | ParsedStructure[] | Record<string, ParsedStructure>;
-export interface ParsedStructure {
-  readonly rawData: RawData;
-  readonly line: number;
-}
-export interface RawDefinition {
-  readonly componentName: string;
-  readonly parsedStructure: ParsedStructure;
-  readonly location: LocationInFile;
-}
-export interface Output {
-  addFile: (fileInfo: FileInfo) => void;
-  addError: (errorLog: ErrorLog) => void;
-}

package/dist/framework/framework.model.js

@@ -1,3 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-//# sourceMappingURL=framework.model.js.map

package/dist/framework/index-file-generator/index-file-generator.d.ts

@@ -1,10 +0,0 @@
-export declare class IndexFileGenerator {
-    private static premadeInterfaces;
-    static addPremadeInterface(value: string): void;
-    static generateIndexFile(pretext: string, outputIndexFile: string): void;
-    private static generateIndexFileBuildMode;
-    private static generateIndexFileDevMode;
-    private static generateExportsContent;
-    private static generateInterfacesContent;
-    private static getInterfacesFromFile;
-}

package/dist/framework/index-file-generator/index-file-generator.js

@@ -1,118 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexFileGenerator = void 0;
-const fs = __importStar(require("fs"));
-const glob = __importStar(require("glob"));
-const helpers_lib_1 = require("helpers-lib");
-const context_1 = require("../context");
-const START_COMMAND = '// ---- INDEX OUTPUT ----';
-const END_COMMAND = '// ---- END ----';
-class IndexFileGenerator {
-    static { this.premadeInterfaces = []; }
-    static addPremadeInterface(value) {
-        this.premadeInterfaces.push(value);
-    }
-    static generateIndexFile(pretext, outputIndexFile) {
-        if (context_1.Context.config.compilerModulesPath) {
-            this.generateIndexFileDevMode(pretext);
-        }
-        else {
-            this.generateIndexFileBuildMode(outputIndexFile);
-        }
-    }
-    static generateIndexFileBuildMode(outputIndexFile) {
-        context_1.Context.output.push({
-            path: '/index.ts',
-            content: outputIndexFile
-        });
-    }
-    static async generateIndexFileDevMode(pretext) {
-        let fileUrls = glob.sync(`${context_1.Context.config.compilerModulesPath}/**/*.ts`).map(filePath => filePath.replace(/\\/g, '/'));
-        if (fileUrls.length === 0) {
-            helpers_lib_1.ConsoleHelper.log(`No typescript file found to generate index.ts file.`, 'red');
-        }
-        let exportsContent = this.generateExportsContent();
-        let interfacesContent = this.generateInterfacesContent(fileUrls);
-        if (interfacesContent !== undefined) {
-            let output = `${pretext}\n${exportsContent}\n\n${interfacesContent}`;
-            context_1.Context.output.push({
-                path: '/index.ts',
-                content: output
-            });
-            fs.writeFileSync(`${context_1.Context.compilerExecutionPath}/output-index-file.ts`, `// AUTO GENERATED - CHANGES WILL BE REPLACED\nexport const OutputIndexFile = \`${output}\`;\n`);
-            helpers_lib_1.ConsoleHelper.log(`Index content 'output-index-file.ts' is generated.`, 'green');
-        }
-    }
-    static generateExportsContent() {
-        return context_1.Context.exports
-            .map(exportItem => `export { ${exportItem.variableName} } from '.${exportItem.path.substring(0, exportItem.path.lastIndexOf('.'))}';`)
-            .join('\n');
-    }
-    static generateInterfacesContent(fileUrls) {
-        let errorCount = 0;
-        let outputs = [];
-        fileUrls.forEach(fileUrl => {
-            let fileName = fileUrl.substring(fileUrl.lastIndexOf('/') + 1, fileUrl.lastIndexOf('.'));
-            let fileContent = fs.readFileSync(fileUrl, 'utf-8');
-            try {
-                let output = this.getInterfacesFromFile(fileName, fileContent);
-                if (output) {
-                    outputs.push(output);
-                }
-            }
-            catch (error) {
-                errorCount++;
-                helpers_lib_1.ConsoleHelper.log(`Error parsing file: ${fileUrl}, error: '${error.message}'`, 'red');
-            }
-        });
-        let output = `//-------------------------- DEFINITIONS --------------------------\n`;
-        if (this.premadeInterfaces.length > 0) {
-            output += '// ---- premade ----';
-            output += this.premadeInterfaces.join('\n');
-            output += '\n\n';
-        }
-        output += outputs.join('\n');
-        return errorCount === 0 ? output : undefined;
-    }
-    static getInterfacesFromFile(fileName, fileContent) {
-        let index = fileContent.indexOf(START_COMMAND);
-        let definitionsFound = index !== -1;
-        let contents = [];
-        while (index !== -1) {
-            let endIndex = fileContent.indexOf(END_COMMAND, index);
-            if (endIndex === -1) {
-                throw new Error(`No end command found.`);
-            }
-            contents.push(fileContent.substring(fileContent.indexOf('\n', index + START_COMMAND.length) + 1, endIndex));
-            index = fileContent.indexOf(START_COMMAND, endIndex);
-        }
-        if (definitionsFound) {
-            return `// ---- ${fileName} ----\n${contents.join('\n')}`;
-        }
-    }
-}
-exports.IndexFileGenerator = IndexFileGenerator;
-//# sourceMappingURL=index-file-generator.js.map

package/dist/framework/interfaces.d.ts

@@ -1,46 +0,0 @@
-export interface FileSystem {
-    existsSync: (path: string) => boolean;
-}
-export interface FileInfo {
-    path: string;
-    content: string;
-}
-export interface AddFileOptions {
-    path: string;
-    variableName: string;
-    variable: any;
-    preText?: string | string[];
-    variableType?: string;
-    replaceMap?: {
-        target: string;
-        replace: string;
-    }[];
-    assetUrl?: string;
-}
-export interface LocationInFile {
-    readonly path: string;
-    readonly line: number;
-}
-export interface ErrorLog {
-    readonly description: string;
-    readonly location: LocationInFile;
-}
-export interface Config {
-    projectRoot: string;
-    compilerModulesPath: string;
-}
-export type RawData = undefined | string | ParsedStructure[] | Record<string, ParsedStructure>;
-export interface ParsedStructure {
-    readonly rawData: RawData;
-    readonly line: number;
-}
-export interface RawDefinition {
-    readonly componentName: string;
-    readonly parsedStructure: ParsedStructure;
-    readonly location: LocationInFile;
-}
-export interface Output {
-    addFile: (request: AddFileOptions) => Promise<void>;
-    addError: (errorLog: ErrorLog) => void;
-    convertLocationInFileToLink: (location: LocationInFile) => string;
-}

package/dist/framework/interfaces.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=interfaces.js.map

package/dist/framework/kernel.d.ts

@@ -1,12 +0,0 @@
-import { DefinitionComponentClassType } from '../decorators/definition-component';
-export declare class Kernel {
-    static process(components: DefinitionComponentClassType<any>[], indexFilePretext: string, outputIndexFile: string): Promise<void>;
-    private static readFiles;
-    private static writeFiles;
-    private static cleanPath;
-    private static removeEmptyFolders;
-    private static generateOutputFiles;
-    private static iterateOnKeyNames;
-    private static registerDefinitions;
-    private static getOutputFiles;
-}

package/dist/framework/kernel.js

@@ -1,308 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Kernel = void 0;
-const fs = __importStar(require("fs"));
-const glob = __importStar(require("glob"));
-const helpers_lib_1 = require("helpers-lib");
-const path = __importStar(require("path"));
-const custom_validator_helper_1 = require("../helpers/validator/custom-validator-helper/custom-validator.helper");
-const validator_1 = require("../helpers/validator/validator");
-const _3_config_1 = require("../pipeline/3-config");
-const raw_data_parser_1 = require("../pipeline/raw-data-parser");
-const context_1 = require("./context");
-const definition_store_1 = require("./definition-store");
-const index_file_generator_1 = require("./file-generators/index-file-generator");
-const KeyValueRegex = /^[a-z]+([a-zA-Z0-9]+)*$/;
-const HeavySeperator = '======================================================';
-const LightSeperator = '------------------------------------------------------';
-const LocationFileToLink = (location) => location.path.replace(context_1.Context.compilerExecutionPath + '/', '') + ':' + location.line;
-class Kernel {
-    static async process(components, indexFilePretext, outputIndexFile) {
-        let componentNameToComponentMap = new Map();
-        componentNameToComponentMap.set(_3_config_1.ConfigDefinitionComponentName, _3_config_1.Config);
-        components.forEach(component => {
-            let componentName = component.$meta.componentName;
-            if (componentNameToComponentMap.has(componentName)) {
-                throw new Error(`Component name "${componentName}" is used more than once.`);
-            }
-            componentNameToComponentMap.set(componentName, component);
-        });
-        definition_store_1.DefinitionStore['setComponents'](componentNameToComponentMap);
-        helpers_lib_1.ConsoleHelper.log('Compilation is in progress.', 'white');
-        this.readFiles();
-        let outputFiles = await this.generateOutputFiles(components, indexFilePretext, outputIndexFile);
-        this.writeFiles(outputFiles, context_1.Context.outputPath);
-    }
-    static readFiles() {
-        context_1.Context.compilerExecutionPath = path.resolve('./').replace(/\\/g, '/');
-        context_1.Context.outputPath = `${context_1.Context.compilerExecutionPath}/.asset-build`;
-        context_1.Context.files = glob
-            .sync(`${context_1.Context.compilerExecutionPath}/**/*.md`)
-            .map(filePath => filePath.replace(/\\/g, '/'))
-            .map(filePath => {
-            let content = fs.readFileSync(filePath).toString();
-            let fileInfo = { path: filePath, content };
-            return fileInfo;
-        });
-    }
-    static writeFiles(outputFiles, outputPath) {
-        let filesInOutputFolder = new Set();
-        glob
-            .sync(`${context_1.Context.outputPath}/**/*`, { nodir: true })
-            .map(filePath => filePath.replace(/\\/g, '/'))
-            .forEach(filePath => {
-            filesInOutputFolder.add(filePath);
-        });
-        outputFiles.forEach(outputFile => {
-            outputFile.path = outputPath + outputFile.path;
-            filesInOutputFolder.delete(outputFile.path);
-        });
-        if (context_1.Context.successful) {
-            helpers_lib_1.ConsoleHelper.log(HeavySeperator, 'gray');
-            helpers_lib_1.ConsoleHelper.log(`Changes:`, 'gray');
-            helpers_lib_1.ConsoleHelper.newLine();
-        }
-        let erasedFileCount = 0;
-        if (context_1.Context.successful) {
-            filesInOutputFolder.forEach(filePath => {
-                erasedFileCount++;
-                console.info(`${helpers_lib_1.ConsoleHelper.red}Erasing file:${helpers_lib_1.ConsoleHelper.gray} "${this.cleanPath(filePath)}"${helpers_lib_1.ConsoleHelper.default}`);
-                fs.unlinkSync(filePath);
-            });
-        }
-        let modifiedFileCount = 0;
-        let createdFileCount = 0;
-        outputFiles.forEach(outputFile => {
-            let folderPath = outputFile.path.substring(0, outputFile.path.lastIndexOf('/'));
-            fs.mkdirSync(folderPath, { recursive: true });
-            let exists = fs.existsSync(outputFile.path);
-            let content = exists ? fs.readFileSync(outputFile.path).toString() : '';
-            if (content !== outputFile.content) {
-                if (exists) {
-                    modifiedFileCount++;
-                    console.info(`${helpers_lib_1.ConsoleHelper.blue}Modifying file:${helpers_lib_1.ConsoleHelper.gray} "${this.cleanPath(outputFile.path)}"${helpers_lib_1.ConsoleHelper.default}`);
-                }
-                else {
-                    createdFileCount++;
-                    console.info(`${helpers_lib_1.ConsoleHelper.cyan}Creating file:${helpers_lib_1.ConsoleHelper.gray} "${this.cleanPath(outputFile.path)}"${helpers_lib_1.ConsoleHelper.default}`);
-                }
-                fs.writeFileSync(outputFile.path, outputFile.content);
-            }
-        });
-        this.removeEmptyFolders(outputPath);
-        if (createdFileCount + modifiedFileCount + erasedFileCount > 0) {
-            helpers_lib_1.ConsoleHelper.newLine();
-        }
-        helpers_lib_1.ConsoleHelper.log(`Created file count: ${createdFileCount}`, 'gray');
-        helpers_lib_1.ConsoleHelper.log(`Modified file count: ${modifiedFileCount}`, 'gray');
-        helpers_lib_1.ConsoleHelper.log(`Erased file count: ${erasedFileCount}`, 'gray');
-        helpers_lib_1.ConsoleHelper.log(HeavySeperator, 'gray');
-        if (context_1.Context.successful) {
-            helpers_lib_1.ConsoleHelper.log(`Compilation is completed successfuly!`, 'green');
-        }
-        else {
-            helpers_lib_1.ConsoleHelper.log(`Compilation encountered errors!`, 'red');
-        }
-    }
-    static cleanPath(path) {
-        let startPathsFrom = context_1.Context.compilerExecutionPath.length;
-        return path.substring(startPathsFrom); // .replace(/\//g, '\\');
-    }
-    static removeEmptyFolders(dir) {
-        let files = fs.readdirSync(dir);
-        let isEmpty = true;
-        for (let file of files) {
-            let fullPath = path.join(dir, file);
-            if (fs.statSync(fullPath).isDirectory()) {
-                let isSubDirEmpty = this.removeEmptyFolders(fullPath);
-                if (isSubDirEmpty) {
-                    fs.rmdirSync(fullPath);
-                    console.info(`${helpers_lib_1.ConsoleHelper.red}Erasing folder:${helpers_lib_1.ConsoleHelper.gray} "${fullPath.substring(dir.length).replace(/\\/g, '/')}"${helpers_lib_1.ConsoleHelper.default}`);
-                }
-                else {
-                    isEmpty = false;
-                }
-            }
-            else {
-                isEmpty = false;
-            }
-        }
-        return isEmpty;
-    }
-    static async generateOutputFiles(modules, indexFilePretext, outputIndexFile) {
-        raw_data_parser_1.RawDataParser.process();
-        context_1.Context.flushErrorLogs();
-        let preparedItems = modules.map(ModuleClass => {
-            let meta = ModuleClass.$meta;
-            context_1.Context.componentInProgressData = {
-                meta,
-                idToReferencesMap: new Map()
-            };
-            let output = {
-                addFile: (request) => context_1.Context.addFile(request),
-                addError: (errorLog) => context_1.Context.addErrorLog(errorLog),
-                convertLocationInFileToLink: (location) => LocationFileToLink(location)
-            };
-            this.iterateOnKeyNames(meta.keyName, meta.componentName, ModuleClass);
-            let definitionToProcess;
-            if (meta.singleton) {
-                let validatedItem = validator_1.Validator.validateAndConvertSingular(meta.componentName, meta.validationSchema);
-                if (validatedItem) {
-                    definitionToProcess = validatedItem.definition;
-                    definition_store_1.DefinitionStore['setRawDefinition'](ModuleClass, validatedItem.definition, validatedItem.rawDefinition);
-                    definition_store_1.DefinitionStore['setSingletonDefinition'](ModuleClass, definitionToProcess);
-                }
-            }
-            else {
-                let validatedItems = validator_1.Validator.validateAndConvert(meta.componentName, meta.validationSchema);
-                // Remove the definitions if there are lazy references that has been invalid
-                if (context_1.Context.componentInProgressData.idToReferencesMap.size > 0) {
-                    let keyName = meta.keyName;
-                    if (!keyName) {
-                        throw new Error('Unexpected Error: KeyName should be defined for lazy references.');
-                    }
-                    let idToReferencesMap = context_1.Context.componentInProgressData.idToReferencesMap;
-                    let runTheLoop = true;
-                    while (runTheLoop) {
-                        let validatedItemCount = validatedItems.length;
-                        let validatedItemIds = new Set(validatedItems.map(validatedItem => validatedItem.definition[keyName]));
-                        validatedItems = validatedItems.filter(validatedItem => {
-                            let id = validatedItem.definition[keyName];
-                            if (idToReferencesMap.has(id)) {
-                                let references = idToReferencesMap.get(id);
-                                let isValid = true;
-                                references.forEach(reference => validatedItemIds.has(reference) || (isValid = false));
-                                return isValid;
-                            }
-                            return true;
-                        });
-                        runTheLoop = validatedItemCount !== validatedItems.length;
-                    }
-                }
-                validatedItems.forEach(item => {
-                    definition_store_1.DefinitionStore['setRawDefinition'](ModuleClass, item.definition, item.rawDefinition);
-                });
-                definitionToProcess = validatedItems.map(validatedItem => validatedItem.definition);
-                this.registerDefinitions(definitionToProcess, meta.keyName, ModuleClass);
-            }
-            context_1.Context.flushErrorLogs();
-            context_1.Context.componentInProgressData = undefined;
-            return {
-                definitionToProcess,
-                output,
-                ModuleClass
-            };
-        });
-        for (let preparedItem of preparedItems) {
-            if (preparedItem.definitionToProcess) {
-                let module = new preparedItem.ModuleClass();
-                let keyName = preparedItem.ModuleClass.$meta.keyName;
-                if (keyName) {
-                    index_file_generator_1.IndexFileGenerator.addIdType(preparedItem.ModuleClass.$meta.pascalCaseComponentName, preparedItem.definitionToProcess.map((definition) => definition[keyName]));
-                }
-                await module.process(preparedItem.definitionToProcess, preparedItem.output);
-            }
-        }
-        context_1.Context.flushErrorLogs(); // Still there might be some errors that customly added
-        custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
-        if (context_1.Context.successful) {
-            await index_file_generator_1.IndexFileGenerator.generateFile(indexFilePretext, outputIndexFile);
-        }
-        return this.getOutputFiles();
-    }
-    static iterateOnKeyNames(keyName, componentName, ModuleClass) {
-        let rawDefinitions = validator_1.Validator.getRawDefinitions(componentName);
-        if (keyName) {
-            rawDefinitions.forEach(rawDefinition => {
-                let rootRawData = rawDefinition.parsedStructure.rawData;
-                if (!helpers_lib_1.Comparator.isObject(rootRawData) || helpers_lib_1.Comparator.isArray(rootRawData)) {
-                    context_1.Context.addErrorLog({
-                        description: `KeyName shold not be used with a content which is not an object, keyName: "${keyName}" in "${componentName}"`,
-                        location: { line: rawDefinition.parsedStructure.line, path: rawDefinition.location.path }
-                    });
-                }
-                else {
-                    let keyValue = rootRawData[keyName]?.rawData;
-                    if (!helpers_lib_1.Comparator.isString(keyValue)) {
-                        // Do nothing, joi validation will log the errors
-                    }
-                    else if (KeyValueRegex.test(keyValue) === false) {
-                        context_1.Context.addErrorLog({
-                            description: `KeyValue should be a valid key, keyValue: "${keyValue}"`,
-                            location: { line: rootRawData[keyName].line, path: rawDefinition.location.path }
-                        });
-                    }
-                    else if (definition_store_1.DefinitionStore['isRawDefinitionExists'](ModuleClass, keyValue)) {
-                        context_1.Context.addErrorLog({
-                            description: `Definition with key "${keyValue}" already exists`,
-                            location: { line: rootRawData[keyName].line, path: rawDefinition.location.path }
-                        });
-                    }
-                    else {
-                        definition_store_1.DefinitionStore['setRawDefinitionByKey'](ModuleClass, keyValue, rawDefinition);
-                    }
-                }
-            });
-        }
-    }
-    static registerDefinitions(definitions, keyName, ModuleClass) {
-        if (keyName) {
-            definitions.forEach((definition) => {
-                let definitionName = definition[keyName];
-                definition_store_1.DefinitionStore['setDefinition'](ModuleClass, definitionName, definition);
-            });
-        }
-    }
-    static getOutputFiles() {
-        if (context_1.Context.successful) {
-            return context_1.Context.output;
-        }
-        else {
-            helpers_lib_1.ConsoleHelper.newLine();
-            helpers_lib_1.ConsoleHelper.log(`ERROR LOGS:`, 'red');
-            helpers_lib_1.ConsoleHelper.log(HeavySeperator, 'gray');
-            context_1.Context.errorLogs.forEach((log, index) => {
-                if (index > 0) {
-                    helpers_lib_1.ConsoleHelper.log(LightSeperator, 'gray');
-                }
-                helpers_lib_1.ConsoleHelper.log(`Error:`, 'red');
-                console.info(`${helpers_lib_1.ConsoleHelper.white}Details:${helpers_lib_1.ConsoleHelper.green} ${log.description}`);
-                console.info(`${helpers_lib_1.ConsoleHelper.white}Location:${helpers_lib_1.ConsoleHelper.green} ${LocationFileToLink(log.location)}`);
-            });
-            helpers_lib_1.ConsoleHelper.log(HeavySeperator, 'gray');
-            return [
-                {
-                    path: '/error-logs.md',
-                    content: context_1.Context.errorLogs
-                        .map(errorLog => `${errorLog.description}\r\nPath: '${errorLog.location.path}', Line: '${errorLog.location.line}'\r\n`)
-                        .join('\r\n')
-                }
-            ];
-        }
-    }
-}
-exports.Kernel = Kernel;
-//# sourceMappingURL=kernel.js.map

package/dist/helpers/common-functions/common-functions.d.ts

@@ -1,10 +0,0 @@
-declare class CommonFunctionsClass {
-    decorateDefinitionName(name: string, componentName: string): string;
-    kebabCaseToCamelCase(string: string): string;
-    lowerCaseFirstLetter(string: string): string;
-    upperCaseFirstLetter(string: string): string;
-    removeWhiteSpace(row: string): string;
-    removeComments(row: string): string;
-}
-export declare const CommonFunctions: CommonFunctionsClass;
-export {};

package/dist/helpers/common-functions/common-functions.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommonFunctions = void 0;
-class CommonFunctionsClass {
-    decorateDefinitionName(name, componentName) {
-        return `${this.kebabCaseToCamelCase(componentName)}${this.upperCaseFirstLetter(name)}`;
-    }
-    kebabCaseToCamelCase(string) {
-        return string.toLowerCase().replace(/-./g, x => x[1].toUpperCase());
-    }
-    lowerCaseFirstLetter(string) {
-        return string.charAt(0).toLowerCase() + string.slice(1);
-    }
-    upperCaseFirstLetter(string) {
-        return string.charAt(0).toUpperCase() + string.slice(1);
-    }
-    removeWhiteSpace(row) {
-        return row
-            .replace(/\r?\n|\r/g, '')
-            .replace(/\/\/.*$/gm, '')
-            .trim()
-            .replace(/ {2,}/g, ' ');
-    }
-    removeComments(row) {
-        return row.replace(/\/\/.*$/gm, '').trimEnd();
-    }
-}
-exports.CommonFunctions = new CommonFunctionsClass();
-//# sourceMappingURL=common-functions.js.map

package/dist/helpers/common-functions/common-functions.spec.d.ts

@@ -1 +0,0 @@
-export {};