@srikanthsai27/afrisure-blockly-expression 1.0.0

package/fesm2022/srikanthsai27-afrisure-blockly-expression.mjs

@@ -0,0 +1,1275 @@
+import * as i0 from '@angular/core';
+import { Injectable, Input, Component, EventEmitter, Output, Inject, NgModule } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as Blockly from 'blockly/core';
+import 'blockly/blocks';
+import { javascriptGenerator, Order } from 'blockly/javascript';
+import * as En from 'blockly/msg/en';
+import { ContinuousMetrics, ContinuousFlyout } from '@blockly/continuous-toolbox';
+import '@blockly/toolbox-search';
+import * as i2$1 from '@angular/material/dialog';
+import { MAT_DIALOG_DATA, MatDialogModule } from '@angular/material/dialog';
+import { ZoomToFitControl } from '@blockly/zoom-to-fit';
+import { CommonModule } from '@angular/common';
+import * as i3 from '@angular/material/button';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import * as i4 from '@ngx-translate/core';
+import { TranslateModule } from '@ngx-translate/core';
+import * as i1 from '@angular/material/card';
+import { MatCardModule } from '@angular/material/card';
+import * as i2 from '@angular/material/divider';
+import { MatDividerModule } from '@angular/material/divider';
+import { MatAutocompleteModule } from '@angular/material/autocomplete';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { MatRadioModule } from '@angular/material/radio';
+import { MatSelectModule } from '@angular/material/select';
+import { MatSliderModule } from '@angular/material/slider';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatSidenavModule } from '@angular/material/sidenav';
+import { MatToolbarModule } from '@angular/material/toolbar';
+import { MatExpansionModule } from '@angular/material/expansion';
+import { MatGridListModule } from '@angular/material/grid-list';
+import { MatListModule } from '@angular/material/list';
+import { MatStepperModule } from '@angular/material/stepper';
+import { MatTabsModule } from '@angular/material/tabs';
+import { MatTreeModule } from '@angular/material/tree';
+import { MatButtonToggleModule } from '@angular/material/button-toggle';
+import { MatBadgeModule } from '@angular/material/badge';
+import { MatChipsModule } from '@angular/material/chips';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { MatRippleModule } from '@angular/material/core';
+import { MatBottomSheetModule } from '@angular/material/bottom-sheet';
+import { MatSnackBarModule } from '@angular/material/snack-bar';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { MatPaginatorModule } from '@angular/material/paginator';
+import { MatSortModule } from '@angular/material/sort';
+import { MatTableModule } from '@angular/material/table';
+import { MatDatetimepickerModule, MatNativeDatetimeModule } from '@mat-datetimepicker/core';
+import { MatMomentDatetimeModule } from '@mat-datetimepicker/moment';
+
+class LoaderService {
+    constructor() {
+        this._loading$ = new Subject();
+        this.loading$ = this._loading$.asObservable();
+        this._loadingCnt$ = new Subject();
+        this.loadingCnt$ = this._loadingCnt$.asObservable();
+        this._excelLoadingCnt$ = new Subject();
+        this.excelLoadingCnt$ = this._excelLoadingCnt$.asObservable();
+    }
+    show() {
+        this._loading$.next(true);
+    }
+    hide() {
+        this._loading$.next(false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: LoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: LoaderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: LoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class PopUpTemplate {
+    constructor() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: PopUpTemplate, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.12", type: PopUpTemplate, isStandalone: true, selector: "app-pop-up-template", inputs: { isTitle: "isTitle" }, ngImport: i0, template: "<mat-card class=\"container-fluid  shadow-none \">\r\n    <div class=\"p-16 pt-4\">\r\n        <div class=\"d-flex align-items-center justify-content-between\">\r\n\r\n            <mat-card-title><ng-content select=\"[Ctitle]\"></ng-content></mat-card-title>\r\n\r\n            <ng-content select=\"[closeButton]\"></ng-content>\r\n        </div>\r\n\r\n    </div>\r\n\r\n    <mat-divider></mat-divider>\r\n\r\n\r\n\r\n    <ng-content select=\"[output]\"></ng-content>\r\n</mat-card>", styles: [""], dependencies: [{ kind: "ngmodule", type: MatCardModule }, { kind: "component", type: i1.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i1.MatCardTitle, selector: "mat-card-title, [mat-card-title], [matCardTitle]" }, { kind: "ngmodule", type: MatDividerModule }, { kind: "component", type: i2.MatDivider, selector: "mat-divider", inputs: ["vertical", "inset"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: PopUpTemplate, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-pop-up-template', standalone: true, imports: [MatCardModule, MatDividerModule], template: "<mat-card class=\"container-fluid  shadow-none \">\r\n    <div class=\"p-16 pt-4\">\r\n        <div class=\"d-flex align-items-center justify-content-between\">\r\n\r\n            <mat-card-title><ng-content select=\"[Ctitle]\"></ng-content></mat-card-title>\r\n\r\n            <ng-content select=\"[closeButton]\"></ng-content>\r\n        </div>\r\n\r\n    </div>\r\n\r\n    <mat-divider></mat-divider>\r\n\r\n\r\n\r\n    <ng-content select=\"[output]\"></ng-content>\r\n</mat-card>" }]
+        }], ctorParameters: () => [], propDecorators: { isTitle: [{
+                type: Input
+            }] } });
+
+class BlocklyExpression {
+    constructor(loader, dialogRef, data) {
+        this.loader = loader;
+        this.dialogRef = dialogRef;
+        this.data = data;
+        this.variableList = [];
+        this.errorMessage = '';
+        this.exportedExpression = '';
+        this.generatedCode = '';
+        this.code = '';
+        this.lookupList = [];
+        this.workspace = null;
+        this.InputBlockyExpression = [];
+        this.outputResponse = new EventEmitter();
+        this.maxCountList = this.createMaxCountList(100);
+    }
+    ngOnInit() {
+        console.log(this.data.InputBlockyExpression.lookup);
+        this.loader.show();
+        console.log(this.InputBlockyExpression);
+        this.variableList = this.InputBlockyExpression.lookup || [];
+    }
+    createMaxCountList(maxCount) {
+        let maxCountList = [];
+        for (let i = 2; i <= maxCount; i++) {
+            maxCountList.push([i.toString(), i.toString()]);
+        }
+        return maxCountList;
+    }
+    generateExpressionFromBlocklyJson(jsonString) {
+        const workspaceState = JSON.parse(jsonString);
+        const blocks = workspaceState?.blocks?.blocks;
+        const blockMap = new Map();
+        blocks.forEach((block) => addBlocksToMap(block));
+        function addBlocksToMap(block) {
+            blockMap.set(block.id, block);
+            Object.values(block.inputs || {}).forEach((input) => {
+                if (input.block) {
+                    addBlocksToMap(input.block);
+                }
+            });
+        }
+        function processBlock(blockId) {
+            const block = blockMap.get(blockId);
+            if (!block) {
+                return '';
+            }
+            switch (block.type) {
+                case 'math_addition':
+                case 'math_subtraction':
+                case 'math_division':
+                case 'math_max':
+                case 'math_min':
+                case 'math_multiplication':
+                    return processOperationBlock(block);
+                case 'variables_get_dynamic':
+                    return block.fields.VAR.id;
+                case 'example_number':
+                    return block.fields.FIELDNAME ? block.fields.FIELDNAME : '0';
+                case 'example_string':
+                    return `'${block.fields.FIELDNAME}'`;
+                case 'controls_if':
+                    return processIfBlock(block);
+                case 'controls_ifelse':
+                    return processIfElseBlock(block);
+                case 'logic_compare':
+                    return processLogicCompareBlock(block);
+                case 'logic_boolean':
+                    return processLogicBooleanBlock(block);
+                case 'variables_set_dynamic':
+                    return processVariablesSetBlock(block);
+                default:
+                    return '';
+            }
+        }
+        function processLogicBooleanBlock(block) {
+            return block.fields.BOOL === 'TRUE' ? 'true' : 'false';
+        }
+        function processIfBlock(block) {
+            let code = '';
+            const elseifCount = block.extraState ? block.extraState.elseIfCount : 0;
+            const hasElse = block.extraState ? block.extraState.hasElse : false;
+            // Process IF condition
+            if (block?.inputs != null) {
+                const ifCondition = processBlock(block?.inputs['IF0'].block?.id);
+                const ifStatement = processBlock(block?.inputs['DO0'].block?.id);
+                code += `if (${ifCondition}) { ${ifStatement} }`;
+                // Process ELSE-IF conditions
+                for (let i = 1; i <= elseifCount; i++) {
+                    const elseifCondition = processBlock(block?.inputs[`IF${i}`].block?.id);
+                    const elseifStatement = processBlock(block?.inputs[`DO${i}`].block?.id);
+                    code += ` else if (${elseifCondition}) { ${elseifStatement} }`;
+                }
+                // Process ELSE condition
+                if (hasElse) {
+                    const elseStatement = processBlock(block?.inputs['ELSE'].block?.id);
+                    code += ` else { ${elseStatement} }`;
+                }
+            }
+            return code;
+        }
+        function processIfElseBlock(block) {
+            const condition = getBlockInputValue(block, 'IF0');
+            const doBranch = getBlockStatementValue(block, 'DO0');
+            const elseBranch = getBlockStatementValue(block, 'ELSE');
+            return `if (${condition}) { ${doBranch} } else { ${elseBranch} }`;
+        }
+        function processLogicCompareBlock(block) {
+            const operandA = processBlock(block.inputs['A'].block.id);
+            const operandB = processBlock(block.inputs['B'].block.id);
+            let operatorSymbol;
+            switch (block.fields.OP) {
+                case 'EQ':
+                    operatorSymbol = '==';
+                    break;
+                case 'NEQ':
+                    operatorSymbol = '!=';
+                    break;
+                case 'LT':
+                    operatorSymbol = '<';
+                    break;
+                case 'LTE':
+                    operatorSymbol = '<=';
+                    break;
+                case 'GT':
+                    operatorSymbol = '>';
+                    break;
+                case 'GTE':
+                    operatorSymbol = '>=';
+                    break;
+                default:
+                    operatorSymbol = '=='; // Default case or throw an error
+            }
+            return `${operandA} ${operatorSymbol} ${operandB}`;
+        }
+        function processVariablesSetBlock(block) {
+            // Process the variables set block, for example:
+            const variableName = block.fields.VAR.id; // Adjust based on your Blockly setup
+            const value = processBlock(block.inputs['VALUE'].block.id);
+            return `${variableName} = ${value}`;
+        }
+        function getBlockInputValue(block, inputName) {
+            if (block?.inputs[inputName]?.block) {
+                return processBlock(block.inputs[inputName].block.id);
+            }
+            return '';
+        }
+        function getBlockStatementValue(block, statementName) {
+            // Check if the block has statements and the specific statement
+            if (block?.statements[statementName]) {
+                const statementBlockId = block?.statements[statementName]?.block?.id;
+                if (statementBlockId) {
+                    return processBlock(statementBlockId);
+                }
+            }
+            return '';
+        }
+        function processStatementInput(block, statementName) {
+            if (block?.inputs[statementName]?.block) {
+                return processBlock(block.inputs[statementName].block.id);
+            }
+            return '';
+        }
+        function processOperationBlock(block) {
+            const numFields = parseInt(block.fields.NUM_FIELDS) || 2; // Default to 2 if not specified
+            let operationSymbol = '';
+            let operationFunction = '';
+            switch (block.type) {
+                case 'math_addition':
+                    operationSymbol = ' + ';
+                    break;
+                case 'math_subtraction':
+                    operationSymbol = ' - ';
+                    break;
+                case 'math_division':
+                    operationSymbol = ' / ';
+                    break;
+                case 'math_max':
+                    operationFunction = 'Math.max';
+                    break;
+                case 'math_min': // Handling math_min operation
+                    operationFunction = 'Math.min';
+                    break;
+                case 'math_multiplication':
+                    operationSymbol = ' * ';
+                    break;
+            }
+            let inputValues = [];
+            for (let i = 0; i < numFields; i++) {
+                const inputName = getInputName(block.type, i);
+                if (block?.inputs != null) {
+                    const value = block?.inputs[inputName]?.block
+                        ? processBlock(block?.inputs[inputName].block.id)
+                        : '0';
+                    inputValues.push(value);
+                }
+            }
+            if (operationFunction) {
+                return `${operationFunction}(${inputValues.join(', ')})`;
+            }
+            else {
+                return `(${inputValues.join(operationSymbol)})`;
+            }
+        }
+        function getInputName(blockType, index) {
+            const prefixMap = {
+                math_addition: 'ADD',
+                math_subtraction: 'SUB',
+                math_division: 'DIV',
+                math_max: 'NUM',
+                math_min: 'NUM',
+                math_multiplication: 'MUL',
+            };
+            return `${prefixMap[blockType] || 'INPUT'}${index}`;
+        }
+        if (blocks.length > 0) {
+            return processBlock(blocks[0].id);
+        }
+        return '';
+    }
+    ExtractWorkspace() {
+        const state = Blockly.serialization.workspaces.save(this.workspace);
+        const stateStrJSON = JSON.stringify(state);
+        const code = javascriptGenerator.workspaceToCode(this.workspace);
+        const lines = code.split('\n');
+        if (lines.length > 2) {
+            lines.splice(0, 2);
+        }
+        this.code = lines.join('\n');
+        this.exportedExpression = this.generateExpressionFromBlocklyJson(stateStrJSON);
+    }
+    LoadBlockExpression() {
+        const tempJSON = this.blockExpressionJSON.loadexpression;
+        // dont remove this code this is for parameter validation 
+        // if (tempJSON) {
+        //   let parseTempJSON = tempJSON ? JSON.parse(tempJSON) : []
+        //   let variables = parseTempJSON?.variables ?? [];
+        //   let lookup = this.data.InputBlockyExpression.lookup ?? []
+        //   let missingVariables = variables.filter(variable =>
+        //     !lookup.some(lookupItem => lookupItem.id === variable.id)
+        //   );
+        //   console.log(missingVariables)
+        //   if (missingVariables.length > 0) {
+        //     let missingDetailsArray = missingVariables.map(variable => ({ id: variable.id, name: variable.name }));
+        //     console.log(missingDetailsArray);
+        //     const dialogRef = this.dialog.open(MatDialogComponent, {
+        //       panelClass: ['dialog-responsive'],
+        //       width: '60vw',
+        //       disableClose: true,
+        //       data: {
+        //         yesOrNoPopupBlockly: true, errorMessage: missingDetailsArray
+        //       }
+        //     });
+        //     dialogRef.afterClosed().subscribe((res) => {
+        //       if (!res) {
+        //         // Blockly.serialization.workspaces.load(JSON.parse(tempJSON), this.workspace);
+        //       } else {
+        //         this.goBack()
+        //       }
+        //     });
+        //   } else {
+        //     Blockly.serialization.workspaces.load(JSON.parse(tempJSON), this.workspace);
+        //   }
+        // }
+        if (tempJSON) {
+            let parseVal = JSON.parse(tempJSON);
+            // this condition for while edit already send parmeters if not there in new parameter list that will remove here changes by gowtham 
+            let parseValD = parseVal?.variables?.filter(item => this.variableList.some(main => main.id === item.id));
+            parseVal['variables'] = parseValD;
+            Blockly.serialization.workspaces.load(parseVal, this.workspace);
+        }
+    }
+    ngAfterViewInit() {
+        window['maxCountList'] = this.maxCountList;
+        Blockly.setLocale(En);
+        this.DefineBlocklyCustomBlocks();
+        this.DefineBlocklyCustomJavascript();
+        const toolboxCategories = {
+            kind: 'categoryToolbox',
+            contents: [
+                {
+                    'kind': 'search',
+                    'name': 'Search',
+                    'contents': [],
+                },
+                /* {
+                  "kind": "category",
+                  "name": "Control",
+                  "contents": [
+                    {
+                      "kind": "block",
+                      "type": "controls_if"
+                    },
+                  ]
+                }, */
+                {
+                    kind: 'category',
+                    name: 'Logical',
+                    contents: [
+                        {
+                            kind: 'block',
+                            type: 'controls_if',
+                        },
+                        {
+                            kind: 'block',
+                            type: 'logic_compare',
+                        },
+                        {
+                            kind: 'block',
+                            type: 'logic_operation',
+                        },
+                        {
+                            kind: 'block',
+                            type: 'logic_boolean',
+                        },
+                        {
+                            kind: 'block',
+                            type: 'return_statement',
+                        },
+                        {
+                            kind: 'block',
+                            type: 'math_arithmetic',
+                        },
+                        {
+                            kind: 'block',
+                            type: 'math_number',
+                        },
+                        {
+                            kind: 'block',
+                            type: 'math_single',
+                        },
+                        {
+                            kind: 'block',
+                            type: 'math_constant',
+                        },
+                        {
+                            kind: 'block',
+                            type: 'math_number_property',
+                        },
+                        {
+                            kind: 'block',
+                            type: 'math_change',
+                        },
+                        {
+                            kind: 'block',
+                            type: 'math_round',
+                        },
+                        {
+                            kind: 'block',
+                            type: 'math_on_list',
+                        },
+                        {
+                            kind: 'block',
+                            type: 'math_arithmetic_multiple',
+                        },
+                    ],
+                },
+                {
+                    kind: 'category',
+                    name: 'Math',
+                    contents: [
+                        {
+                            kind: 'block',
+                            name: 'Math.Addition',
+                            type: 'math_addition',
+                        },
+                        {
+                            kind: 'block',
+                            name: 'Math.Subtraction',
+                            type: 'math_subtraction',
+                        },
+                        {
+                            kind: 'block',
+                            name: 'Math.Multiplication',
+                            type: 'math_multiplication',
+                        },
+                        {
+                            kind: 'block',
+                            name: 'Math.Division',
+                            type: 'math_division',
+                        },
+                        {
+                            kind: 'block',
+                            name: 'Math.Max',
+                            type: 'math_max',
+                        },
+                        {
+                            kind: 'block',
+                            name: 'Math.Min',
+                            type: 'math_min',
+                        },
+                    ],
+                },
+                {
+                    kind: 'category',
+                    name: 'Value',
+                    contents: [
+                        {
+                            kind: 'block',
+                            name: 'example_number',
+                            type: 'example_number',
+                        },
+                        {
+                            kind: 'block',
+                            name: 'example_string',
+                            type: 'example_string',
+                        },
+                    ],
+                },
+                /* {
+                  "kind": "category",
+                  "name": "Variables",
+                  "custom": "VARIABLE"
+                }, */
+                {
+                    kind: 'category',
+                    name: 'LookUps',
+                    custom: 'VARIABLE_DYNAMIC',
+                },
+                {
+                    kind: 'category',
+                    name: 'Functions',
+                    custom: 'PROCEDURE',
+                },
+                // {
+                //   'kind': 'search',
+                //   'name': 'Search',
+                //   'contents': [],
+                // }
+            ],
+        };
+        this.workspace = Blockly.inject('blocklyDiv', {
+            plugins: {
+                // toolbox: ContinuousToolbox,
+                flyoutsVerticalToolbox: ContinuousFlyout,
+                metricsManager: ContinuousMetrics
+            },
+            toolbox: toolboxCategories,
+            zoom: {
+                controls: true,
+            },
+        });
+        // Initialize plugin.
+        const zoomToFit = new ZoomToFitControl(this.workspace);
+        zoomToFit.init();
+        this.loader.show();
+        setTimeout(() => {
+            this.InputBlockyExpression = this.data.InputBlockyExpression || [];
+            this.variableList = this.InputBlockyExpression.lookup || [];
+            this.blockExpressionJSON = this.InputBlockyExpression.blockExpressionJSON || [];
+            this.createVariables();
+            this.LoadBlockExpression();
+            this.loader.hide();
+        });
+        this.createLookupVariables();
+    }
+    DefineBlocklyCustomBlocks() {
+        Blockly.Blocks['math_add_container'] = {
+            init: function () {
+                this.appendDummyInput().appendField('add numbers');
+                this.appendStatementInput('STACK');
+                this.setColour(230);
+                this.contextMenu = false;
+            },
+        };
+        Blockly.Blocks['math_addition'] = {
+            init: function () {
+                const maxCountList = window['maxCountList'] || [['2', '2']];
+                this.appendDummyInput().appendField('Add');
+                // Dropdown to choose the number of addition inputs
+                this.appendDummyInput().appendField(new Blockly.FieldDropdown(maxCountList, this.updateFields_.bind(this)), 'NUM_FIELDS');
+                // Initial addition fields
+                this.appendValueInput('ADD0').setCheck('Number');
+                this.appendValueInput('ADD1').setCheck('Number');
+                this.setInputsInline(true);
+                this.setOutput(true, 'Number');
+                this.setColour(230);
+                this.itemCount_ = 2;
+            },
+            // Function to update the number of input fields
+            updateFields_: function (newValue) {
+                let newCount = parseInt(newValue);
+                while (this.itemCount_ < newCount) {
+                    this.appendValueInput('ADD' + this.itemCount_).setCheck('Number');
+                    this.itemCount_++;
+                }
+                while (this.itemCount_ > newCount) {
+                    this.removeInput('ADD' + (this.itemCount_ - 1));
+                    this.itemCount_--;
+                }
+            },
+            mutationToDom: function () {
+                let container = Blockly.utils.xml.createElement('mutation');
+                container.setAttribute('items', this.itemCount_);
+                return container;
+            },
+            domToMutation: function (xmlElement) {
+                this.itemCount_ = parseInt(xmlElement.getAttribute('items'), 10);
+                this.updateShape_();
+            },
+            decompose: function (workspace) {
+                let containerBlock = workspace.newBlock('math_add_container');
+                containerBlock.initSvg();
+                let connection = containerBlock.getInput('STACK').connection;
+                for (let i = 0; i < this.itemCount_; i++) {
+                    let itemBlock = workspace.newBlock('math_add_item');
+                    itemBlock.initSvg();
+                    connection.connect(itemBlock.previousConnection);
+                    connection = itemBlock.nextConnection;
+                }
+                return containerBlock;
+            },
+            compose: function (containerBlock) {
+                let itemBlock = containerBlock.getInputTargetBlock('STACK');
+                // Count number of inputs.
+                let connections = [];
+                while (itemBlock) {
+                    connections.push(itemBlock.valueConnection_);
+                    itemBlock = itemBlock?.nextConnection?.targetBlock();
+                }
+                // Disconnect any children that don't belong.
+                for (let i = 0; i < this.itemCount_; i++) {
+                    let connection = this.getInput('ADD' + i).connection.targetConnection;
+                    if (connection && connections.indexOf(connection) === -1) {
+                        connection.disconnect();
+                    }
+                }
+                this.itemCount_ = connections.length;
+                this.updateShape_();
+                // Reconnect any child blocks.
+                for (let i = 0; i < this.itemCount_; i++) {
+                    connections[i].reconnect(this, 'ADD' + i);
+                }
+            },
+            saveConnections: function (containerBlock) {
+                let itemBlock = containerBlock.getInputTargetBlock('STACK');
+                let i = 0;
+                while (itemBlock) {
+                    let input = this.getInput('ADD' + i);
+                    itemBlock.valueConnection_ = input?.connection?.targetConnection;
+                    i++;
+                    itemBlock = itemBlock?.nextConnection?.targetBlock();
+                }
+            },
+            updateShape_: function () {
+                // Adjust inputs.
+                // for (let i = 0; i < this.itemCount_; i++) {
+                //   if (!this.getInput('ADD' + i)) {
+                //     this.appendValueInput('ADD' + i).setCheck('Number');
+                //   }
+                // }
+                // // Remove deleted inputs.
+                // while (this.getInput('ADD' + i)) {
+                //   this.removeInput('ADD' + i);
+                //   i++;
+                // }
+                for (let i = 0; i < this.itemCount_; i++) {
+                    if (!this.getInput('ADD' + i)) {
+                        this.appendValueInput('ADD' + i).setCheck('Number');
+                    }
+                }
+                // Remove deleted inputs.
+                let j = this.itemCount_;
+                while (this.getInput('ADD' + j)) {
+                    this.removeInput('ADD' + j);
+                    j++;
+                }
+            },
+        };
+        Blockly.Blocks['math_subtraction'] = {
+            init: function () {
+                const maxCountList = window['maxCountList'] || [['2', '2']];
+                this.appendDummyInput().appendField('Subtract');
+                this.appendDummyInput().appendField(new Blockly.FieldDropdown(maxCountList, this.updateFields_.bind(this)), 'NUM_FIELDS');
+                this.appendValueInput('SUB0').setCheck('Number');
+                this.appendValueInput('SUB1').setCheck('Number');
+                this.setInputsInline(true);
+                this.setOutput(true, 'Number');
+                this.setColour(230);
+                this.itemCount_ = 2;
+            },
+            updateFields_: function (newValue) {
+                let newCount = parseInt(newValue);
+                while (this.itemCount_ < newCount) {
+                    this.appendValueInput('SUB' + this.itemCount_).setCheck('Number');
+                    this.itemCount_++;
+                }
+                while (this.itemCount_ > newCount) {
+                    this.removeInput('SUB' + (this.itemCount_ - 1));
+                    this.itemCount_--;
+                }
+            },
+        };
+        Blockly.Blocks['math_multiplication'] = {
+            init: function () {
+                const maxCountList = window['maxCountList'] || [['2', '2']];
+                this.appendDummyInput().appendField('Multiply');
+                this.appendDummyInput().appendField(new Blockly.FieldDropdown(maxCountList, this.updateFields_.bind(this)), 'NUM_FIELDS');
+                this.appendValueInput('MUL0').setCheck('Number');
+                this.appendValueInput('MUL1').setCheck('Number');
+                this.setInputsInline(true);
+                this.setOutput(true, 'Number');
+                this.setColour(230);
+                this.itemCount_ = 2;
+            },
+            updateFields_: function (newValue) {
+                let newCount = parseInt(newValue);
+                while (this.itemCount_ < newCount) {
+                    this.appendValueInput('MUL' + this.itemCount_).setCheck('Number');
+                    this.itemCount_++;
+                }
+                while (this.itemCount_ > newCount) {
+                    this.removeInput('MUL' + (this.itemCount_ - 1));
+                    this.itemCount_--;
+                }
+            },
+        };
+        Blockly.Blocks['math_max'] = {
+            init: function () {
+                const maxCountList = window['maxCountList'] || [['2', '2']];
+                this.appendDummyInput().appendField('Max');
+                this.appendDummyInput().appendField(new Blockly.FieldDropdown(maxCountList, this.updateFields_.bind(this)), 'NUM_FIELDS');
+                this.appendValueInput('NUM0').setCheck('Number');
+                this.appendValueInput('NUM1').setCheck('Number');
+                this.setInputsInline(true);
+                this.setOutput(true, 'Number');
+                this.setColour(230);
+                this.itemCount_ = 2;
+            },
+            updateFields_: function (newValue) {
+                let newCount = parseInt(newValue);
+                while (this.itemCount_ < newCount) {
+                    this.appendValueInput('NUM' + this.itemCount_).setCheck('Number');
+                    this.itemCount_++;
+                }
+                while (this.itemCount_ > newCount) {
+                    this.removeInput('NUM' + (this.itemCount_ - 1));
+                    this.itemCount_--;
+                }
+            },
+        };
+        Blockly.Blocks['math_min'] = {
+            init: function () {
+                const maxCountList = window['maxCountList'] || [['2', '2']];
+                this.appendDummyInput().appendField('Min');
+                this.appendDummyInput().appendField(new Blockly.FieldDropdown(maxCountList, this.updateFields_.bind(this)), 'NUM_FIELDS');
+                this.appendValueInput('NUM0').setCheck('Number');
+                this.appendValueInput('NUM1').setCheck('Number');
+                this.setInputsInline(true);
+                this.setOutput(true, 'Number');
+                this.setColour(230);
+                this.itemCount_ = 2;
+            },
+            updateFields_: function (newValue) {
+                let newCount = parseInt(newValue);
+                while (this.itemCount_ < newCount) {
+                    this.appendValueInput('NUM' + this.itemCount_).setCheck('Number');
+                    this.itemCount_++;
+                }
+                while (this.itemCount_ > newCount) {
+                    this.removeInput('NUM' + (this.itemCount_ - 1));
+                    this.itemCount_--;
+                }
+            },
+        };
+        Blockly.Blocks['math_division'] = {
+            init: function () {
+                this.appendDummyInput().appendField('Divide');
+                // Access the global variable or service
+                const maxCountList = window['maxCountList'] || [['2', '2']];
+                this.appendDummyInput().appendField(new Blockly.FieldDropdown(maxCountList, this.updateFields_.bind(this)), 'NUM_FIELDS');
+                this.appendValueInput('DIV0').setCheck('Number');
+                this.appendValueInput('DIV1').setCheck('Number');
+                this.setInputsInline(true);
+                this.setOutput(true, 'Number');
+                this.setColour(230);
+                this.itemCount_ = 2;
+            },
+            updateFields_: function (newValue) {
+                let newCount = parseInt(newValue);
+                while (this.itemCount_ < newCount) {
+                    this.appendValueInput('DIV' + this.itemCount_).setCheck('Number');
+                    this.itemCount_++;
+                }
+                while (this.itemCount_ > newCount) {
+                    this.removeInput('DIV' + (this.itemCount_ - 1));
+                    this.itemCount_--;
+                }
+            },
+        };
+        Blockly.Blocks['example_number'] = {
+            init: function () {
+                this.appendDummyInput()
+                    .appendField('number:')
+                    .appendField(new Blockly.FieldNumber(100, 0, 999999999999, 0.0000000000001), 'FIELDNAME');
+                this.setOutput(true, 'Number');
+                this.setTooltip('Tooltip text.');
+            },
+        };
+        Blockly.Blocks['example_string'] = {
+            init: function () {
+                this.appendDummyInput()
+                    .appendField('string:')
+                    .appendField(new Blockly.FieldTextInput('name'), 'FIELDNAME');
+                this.setOutput(true, 'String');
+                this.setTooltip('Tooltip text.');
+            },
+        };
+        Blockly.Blocks['string_length'] = {
+            init: function () {
+                this.appendValueInput('VALUE')
+                    .setCheck('String')
+                    .appendField('length of');
+                this.setOutput(true, 'Number');
+                this.setColour(160);
+                this.setTooltip('Returns number of letters in the provided text.');
+                this.setHelpUrl('http://www.w3schools.com/jsref/jsref_length_string.asp');
+            },
+        };
+        Blockly.Blocks['string_length2'] = {
+            init: function () {
+                this.jsonInit({
+                    message0: 'length of %1',
+                    args0: [
+                        {
+                            type: 'input_value',
+                            name: 'VALUE',
+                            check: 'String',
+                        },
+                    ],
+                    output: 'Number',
+                    colour: 160,
+                    tooltip: 'Returns number of letters in the provided text.',
+                    helpUrl: 'http://www.w3schools.com/jsref/jsref_length_string.asp',
+                });
+            },
+        };
+        Blockly.Blocks['return_statement'] = {
+            init: function () {
+                this.appendValueInput('VALUE')
+                    .setCheck(null) // You can specify a specific type or leave it as null for any type.
+                    .appendField('return');
+                this.setPreviousStatement(true, null);
+                this.setColour(230);
+                this.setTooltip('Returns a value from a function');
+                this.setHelpUrl(''); // URL to further documentation if necessary
+            },
+        };
+        Blockly.Blocks['math_arithmetic_multiple'] = {
+            init: function () {
+                this.appendValueInput('NUM0').setCheck('Number');
+                this.appendValueInput('NUM1').setCheck('Number');
+                this.setOutput(true, 'Number');
+                this.setColour(230);
+                this.setTooltip('');
+                this.setHelpUrl('');
+                this.itemCount_ = 2;
+                this.updateShape_();
+            },
+            mutationToDom: function () {
+                let container = Blockly.utils.xml.createElement('mutation');
+                container.setAttribute('items', this.itemCount_);
+                return container;
+            },
+            domToMutation: function (xmlElement) {
+                this.itemCount_ = parseInt(xmlElement.getAttribute('items'), 10);
+                this.updateShape_();
+            },
+            decompose: function (workspace) {
+                let containerBlock = workspace.newBlock('math_arithmetic_container');
+                containerBlock.initSvg();
+                let connection = containerBlock.getInput('STACK').connection;
+                for (let i = 0; i < this.itemCount_; i++) {
+                    let itemBlock = workspace.newBlock('math_arithmetic_input');
+                    itemBlock.initSvg();
+                    connection.connect(itemBlock.previousConnection);
+                    connection = itemBlock.nextConnection;
+                }
+                return containerBlock;
+            },
+            compose: function (containerBlock) {
+                let itemBlock = containerBlock.getInputTargetBlock('STACK');
+                // Collect connections
+                let connections = [];
+                while (itemBlock && !itemBlock.isInsertionMarker()) {
+                    connections.push(itemBlock.valueConnection_);
+                    itemBlock = itemBlock?.nextConnection?.targetBlock();
+                }
+                // Disconnect any children that don't belong
+                for (let i = 0; i < this.itemCount_; i++) {
+                    const connection = this.getInput('NUM' + i).connection.targetConnection;
+                    if (connection && connections.indexOf(connection) === -1) {
+                        connection.disconnect();
+                    }
+                }
+                this.itemCount_ = connections.length;
+                this.updateShape_();
+                // Reconnect valid child blocks
+                for (let i = 0; i < this.itemCount_; i++) {
+                    if (connections[i]) {
+                        connections[i].reconnect(this, 'NUM' + i);
+                    }
+                }
+            },
+            saveConnections: function (containerBlock) {
+                let itemBlock = containerBlock.getInputTargetBlock('STACK');
+                let i = 0;
+                while (itemBlock) {
+                    let input = this.getInput('NUM' + i);
+                    itemBlock.valueConnection_ = input?.connection?.targetConnection;
+                    i++;
+                    itemBlock = itemBlock?.nextConnection?.targetBlock();
+                }
+            },
+            updateShape_: function () {
+                // Add missing value inputs.
+                for (let i = 0; i < this.itemCount_; i++) {
+                    if (!this.getInput('NUM' + i)) {
+                        this.appendValueInput('NUM' + i).setCheck('Number');
+                    }
+                }
+                // Remove any extra inputs.
+                let j = this.itemCount_;
+                while (this.getInput('NUM' + j)) {
+                    this.removeInput('NUM' + j);
+                    j++;
+                }
+            },
+        };
+        Blockly.Blocks['math_arithmetic_container'] = {
+            init: function () {
+                this.appendDummyInput().appendField('add numbers');
+                this.appendStatementInput('STACK');
+                this.setColour(230);
+                this.setTooltip('');
+                this.contextMenu = false;
+            },
+        };
+        Blockly.Blocks['math_arithmetic_input'] = {
+            init: function () {
+                this.appendDummyInput().appendField('number');
+                this.setPreviousStatement(true);
+                this.setNextStatement(true);
+                this.setColour(230);
+                this.setTooltip('');
+                this.contextMenu = false;
+            },
+        };
+    }
+    DefineBlocklyCustomJavascript() {
+        javascriptGenerator.forBlock['math_addition'] = function (block, generator) {
+            const fieldCount = parseInt(block.getFieldValue('NUM_FIELDS'), 10);
+            let values = [];
+            for (let i = 0; i < fieldCount; i++) {
+                const value = generator.valueToCode(block, 'ADD' + i, Order.ATOMIC) || '0';
+                values.push(value);
+            }
+            const code = values.join(' + ');
+            return ['(' + code + ')', Order.NONE];
+        };
+        javascriptGenerator.forBlock['math_subtraction'] = function (block, generator) {
+            const fieldCount = parseInt(block.getFieldValue('NUM_FIELDS'), 10);
+            let values = [];
+            for (let i = 0; i < fieldCount; i++) {
+                const value = generator.valueToCode(block, 'SUB' + i, Order.ATOMIC) || '0';
+                values.push(value);
+            }
+            const code = values.join(' - ');
+            return ['(' + code + ')', Order.NONE];
+        };
+        javascriptGenerator.forBlock['math_max'] = function (block, generator) {
+            const fieldCount = parseInt(block.getFieldValue('NUM_FIELDS'), 10);
+            let values = [];
+            for (let i = 0; i < fieldCount; i++) {
+                const value = generator.valueToCode(block, 'NUM' + i, Order.ATOMIC) || '0';
+                values.push(value);
+            }
+            const code = 'Math.max(' + values.join(', ') + ')';
+            return [code, Order.NONE];
+        };
+        javascriptGenerator.forBlock['math_min'] = function (block, generator) {
+            const fieldCount = parseInt(block.getFieldValue('NUM_FIELDS'), 10);
+            let values = [];
+            for (let i = 0; i < fieldCount; i++) {
+                const value = generator.valueToCode(block, 'NUM' + i, Order.ATOMIC) || '0';
+                values.push(value);
+            }
+            const code = 'Math.min(' + values.join(', ') + ')';
+            return [code, Order.NONE];
+        };
+        javascriptGenerator.forBlock['math_division'] = function (block, generator) {
+            const fieldCount = parseInt(block.getFieldValue('NUM_FIELDS'), 10);
+            let values = [];
+            for (let i = 0; i < fieldCount; i++) {
+                const value = generator.valueToCode(block, 'DIV' + i, Order.ATOMIC) || '0';
+                values.push(value);
+            }
+            const code = values.join(' / ');
+            return ['(' + code + ')', Order.NONE];
+        };
+        javascriptGenerator.forBlock['math_multiplication'] = function (block, generator) {
+            const fieldCount = parseInt(block.getFieldValue('NUM_FIELDS'), 10);
+            let values = [];
+            for (let i = 0; i < fieldCount; i++) {
+                const value = generator.valueToCode(block, 'MUL' + i, Order.ATOMIC) || '1';
+                values.push(value);
+            }
+            const code = values.join(' * ');
+            return ['(' + code + ')', Order.NONE];
+        };
+        javascriptGenerator.forBlock['variables_get_dynamic'] = function (block, generator) {
+            let variableId = block.getFieldValue('VAR');
+            let code = `${variableId}`;
+            return [code, Order.ATOMIC];
+        };
+        javascriptGenerator.forBlock['example_number'] = function (block, generator) {
+            let variableId = block.getFieldValue('FIELDNAME');
+            let code = `${variableId}`;
+            return [code, Order.ATOMIC];
+        };
+        javascriptGenerator.forBlock['example_string'] = function (block, generator) {
+            let variableId = block.getFieldValue('FIELDNAME');
+            let code = `'${variableId}'`;
+            return [code, Order.ATOMIC];
+        };
+        javascriptGenerator.forBlock['return_statement'] = function (block, generator) {
+            let value = generator.valueToCode(block, 'VALUE', Order.NONE) || '';
+            return 'return ' + value + ';\n';
+        };
+        javascriptGenerator.forBlock['math_arithmetic_multiple'] = function (block, generator) {
+            let code = [];
+            for (let n = 0; n < block.itemCount_; n++) {
+                code[n] = generator.valueToCode(block, 'NUM' + n, Order.NONE) || '0';
+            }
+            return [code, Order.ATOMIC];
+        };
+    }
+    createVariables() {
+        this.loader.show();
+        this.variableList?.forEach((variableObj) => {
+            // let varialbleName = variableObj.title? variableObj.name :variableObj.name
+            // setTimeout(() => {
+            setTimeout(() => {
+                this.workspace?.createVariable(variableObj?.name, variableObj?.type, variableObj?.id);
+            }, 1);
+            // });
+        });
+        this.loader.hide();
+    }
+    createLookupVariables() {
+        this.lookupList.forEach((variableObj) => {
+            this.workspace?.createVariable(variableObj?.name, variableObj?.type, variableObj?.id);
+        });
+    }
+    goBack() {
+        this.workspace.dispose();
+        this.dialogRef.close(false);
+    }
+    extractVarIds(blocks, varIds = []) {
+        for (const block of blocks) {
+            // Check if the block has a VAR field and push the id if it exists
+            if (block?.fields?.VAR?.id) {
+                varIds.push(block.fields.VAR.id);
+            }
+            // Recursively process all inputs if they exist
+            if (block.inputs) {
+                for (const key in block.inputs) {
+                    if (block.inputs[key].block) {
+                        this.extractVarIds([block.inputs[key].block], varIds);
+                    }
+                }
+            }
+            // If the block is an array, recursively process it
+            if (Array.isArray(block)) {
+                this.extractVarIds(block, varIds);
+            }
+        }
+        return varIds;
+    }
+    submit() {
+        const state = Blockly.serialization.workspaces.save(this.workspace);
+        let result = this.extractVarIds(state.blocks.blocks);
+        let filteredVariable = state?.variables?.filter(item => result?.includes(item.id));
+        let finalVal = {
+            variables: filteredVariable,
+            blocks: state.blocks
+        };
+        const stateStrJSON = JSON.stringify(finalVal);
+        const code = javascriptGenerator.workspaceToCode(this.workspace);
+        const lines = code.split('\n');
+        if (lines.length > 2) {
+            lines.splice(0, 2);
+        }
+        // Join the remaining lines to form the modified code
+        const modifiedCode = lines.filter(item => item !== "").join("");
+        // Assign the modified code to generatedCode
+        this.generatedCode = modifiedCode;
+        const savedState = JSON.parse(stateStrJSON);
+        const blocks = savedState?.blocks?.blocks;
+        this.errorMessage = '';
+        if (Array.isArray(blocks) && blocks?.length != 0) {
+            this.loader.show();
+            this.exportedExpression = this.generateExpressionFromBlocklyJson(stateStrJSON);
+            let val = {
+                expression: this.generatedCode,
+                javascriptCode: this.generatedCode,
+                loadexpression: stateStrJSON,
+            };
+            this.loader.hide();
+            this.outputResponse.emit(val);
+            if (val) {
+                this.receiveOutputResponse(val);
+            }
+            this.workspace.dispose();
+        }
+        else {
+            this.loader.hide();
+            this.errorMessage = 'Please drag and drop the blocks, there is no expression to add.';
+        }
+    }
+    receiveOutputResponse(response) {
+        this.outputResponse.emit(response);
+        this.dialogRef.close(response);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: BlocklyExpression, deps: [{ token: LoaderService }, { token: i2$1.MatDialogRef }, { token: MAT_DIALOG_DATA }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.12", type: BlocklyExpression, isStandalone: true, selector: "app-blockly-expression", outputs: { outputResponse: "outputResponse" }, ngImport: i0, template: "<app-pop-up-template>\r\n\r\n    <h5 Ctitle>\r\n        {{'Expression Logic' | translate}}\r\n    </h5>\r\n    <div class=\"ps-1\" closeButton>\r\n        <button mat-icon-button (click)=\"goBack()\" class=\"d-flex justify-content-center\">\r\n            <span class=\"iconify  f-s-24 \" data-icon=\"mdi:close\"></span>\r\n        </button>\r\n    </div>\r\n    <ng-content output>\r\n\r\n\r\n        <div id=\"blocklyDiv\" style=\"height: 66vh; width: 100%;\"></div>\r\n\r\n        <div class=\"col-12 text-center\">\r\n            <button mat-button (click)=\"ExtractWorkspace()\"\r\n                class=\"mt-1  btnreset\">{{'Export_Expression'|translate}}&nbsp;<i class=\"fa fa-eye\"></i></button>\r\n            <div>\r\n                @if(code){\r\n                <h5>{{'Expression'|translate}}:</h5>\r\n                <div>{{code}}</div>\r\n                }\r\n            </div>\r\n            <div>\r\n                @if(errorMessage){\r\n                <span class=\"text-danger\">{{errorMessage}}</span>\r\n                }\r\n\r\n                <div class=\"col-12 text-center mt-4 \">\r\n                    <button mat-button class=\"btnreset\" type=\"button\" (click)=\"goBack()\">\r\n                        {{'Close' | translate}}&nbsp;<em class=\"fa fa-times-circle\"></em>\r\n                    </button> &nbsp;\r\n                    <button mat-button class=\"btnc\" type=\"button\" (click)=\"submit()\">\r\n                        {{'next' | translate}}&nbsp;<em class=\"fa fa-arrow-right\"></em>\r\n                    </button>\r\n\r\n                </div>\r\n            </div>\r\n        </div>\r\n\r\n    </ng-content>\r\n</app-pop-up-template>", styles: ["::ng-deep .blocklyDropDownDiv{position:fixed!important}::ng-deep .blocklyWidgetDiv{position:fixed!important}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i3.MatButton, selector: "    button[matButton], a[matButton], button[mat-button], button[mat-raised-button],    button[mat-flat-button], button[mat-stroked-button], a[mat-button], a[mat-raised-button],    a[mat-flat-button], a[mat-stroked-button]  ", inputs: ["matButton"], exportAs: ["matButton", "matAnchor"] }, { kind: "component", type: i3.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "ngmodule", type: MatDialogModule }, { kind: "ngmodule", type: TranslateModule }, { kind: "component", type: PopUpTemplate, selector: "app-pop-up-template", inputs: ["isTitle"] }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: BlocklyExpression, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-blockly-expression', standalone: true, imports: [
+                        CommonModule,
+                        MatButtonModule,
+                        MatIconModule,
+                        MatDialogModule,
+                        TranslateModule,
+                        PopUpTemplate
+                    ], template: "<app-pop-up-template>\r\n\r\n    <h5 Ctitle>\r\n        {{'Expression Logic' | translate}}\r\n    </h5>\r\n    <div class=\"ps-1\" closeButton>\r\n        <button mat-icon-button (click)=\"goBack()\" class=\"d-flex justify-content-center\">\r\n            <span class=\"iconify  f-s-24 \" data-icon=\"mdi:close\"></span>\r\n        </button>\r\n    </div>\r\n    <ng-content output>\r\n\r\n\r\n        <div id=\"blocklyDiv\" style=\"height: 66vh; width: 100%;\"></div>\r\n\r\n        <div class=\"col-12 text-center\">\r\n            <button mat-button (click)=\"ExtractWorkspace()\"\r\n                class=\"mt-1  btnreset\">{{'Export_Expression'|translate}}&nbsp;<i class=\"fa fa-eye\"></i></button>\r\n            <div>\r\n                @if(code){\r\n                <h5>{{'Expression'|translate}}:</h5>\r\n                <div>{{code}}</div>\r\n                }\r\n            </div>\r\n            <div>\r\n                @if(errorMessage){\r\n                <span class=\"text-danger\">{{errorMessage}}</span>\r\n                }\r\n\r\n                <div class=\"col-12 text-center mt-4 \">\r\n                    <button mat-button class=\"btnreset\" type=\"button\" (click)=\"goBack()\">\r\n                        {{'Close' | translate}}&nbsp;<em class=\"fa fa-times-circle\"></em>\r\n                    </button> &nbsp;\r\n                    <button mat-button class=\"btnc\" type=\"button\" (click)=\"submit()\">\r\n                        {{'next' | translate}}&nbsp;<em class=\"fa fa-arrow-right\"></em>\r\n                    </button>\r\n\r\n                </div>\r\n            </div>\r\n        </div>\r\n\r\n    </ng-content>\r\n</app-pop-up-template>", styles: ["::ng-deep .blocklyDropDownDiv{position:fixed!important}::ng-deep .blocklyWidgetDiv{position:fixed!important}\n"] }]
+        }], ctorParameters: () => [{ type: LoaderService }, { type: i2$1.MatDialogRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }], propDecorators: { outputResponse: [{
+                type: Output
+            }] } });
+
+class MaterialModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: MaterialModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: MaterialModule, exports: [MatAutocompleteModule,
+            MatCheckboxModule,
+            MatDatepickerModule,
+            MatFormFieldModule,
+            MatInputModule,
+            MatRadioModule,
+            MatSelectModule,
+            MatSliderModule,
+            MatSlideToggleModule,
+            MatMenuModule,
+            MatSidenavModule,
+            MatToolbarModule,
+            MatCardModule,
+            MatDividerModule,
+            MatExpansionModule,
+            MatGridListModule,
+            MatListModule,
+            MatStepperModule,
+            MatTabsModule,
+            MatTreeModule,
+            MatButtonModule,
+            MatButtonToggleModule,
+            MatBadgeModule,
+            MatChipsModule,
+            MatIconModule,
+            MatProgressSpinnerModule,
+            MatProgressBarModule,
+            MatRippleModule,
+            MatBottomSheetModule,
+            MatDialogModule,
+            MatSnackBarModule,
+            MatTooltipModule,
+            MatPaginatorModule,
+            MatSortModule,
+            MatTableModule,
+            MatTooltipModule,
+            MatMomentDatetimeModule,
+            MatDatetimepickerModule,
+            MatNativeDatetimeModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: MaterialModule, imports: [MatAutocompleteModule,
+            MatCheckboxModule,
+            MatDatepickerModule,
+            MatFormFieldModule,
+            MatInputModule,
+            MatRadioModule,
+            MatSelectModule,
+            MatSliderModule,
+            MatSlideToggleModule,
+            MatMenuModule,
+            MatSidenavModule,
+            MatToolbarModule,
+            MatCardModule,
+            MatDividerModule,
+            MatExpansionModule,
+            MatGridListModule,
+            MatListModule,
+            MatStepperModule,
+            MatTabsModule,
+            MatTreeModule,
+            MatButtonModule,
+            MatButtonToggleModule,
+            MatBadgeModule,
+            MatChipsModule,
+            MatIconModule,
+            MatProgressSpinnerModule,
+            MatProgressBarModule,
+            MatRippleModule,
+            MatBottomSheetModule,
+            MatDialogModule,
+            MatSnackBarModule,
+            MatTooltipModule,
+            MatPaginatorModule,
+            MatSortModule,
+            MatTableModule,
+            MatTooltipModule,
+            MatMomentDatetimeModule,
+            MatDatetimepickerModule,
+            MatNativeDatetimeModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: MaterialModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    exports: [
+                        MatAutocompleteModule,
+                        MatCheckboxModule,
+                        MatDatepickerModule,
+                        MatFormFieldModule,
+                        MatInputModule,
+                        MatRadioModule,
+                        MatSelectModule,
+                        MatSliderModule,
+                        MatSlideToggleModule,
+                        MatMenuModule,
+                        MatSidenavModule,
+                        MatToolbarModule,
+                        MatCardModule,
+                        MatDividerModule,
+                        MatExpansionModule,
+                        MatGridListModule,
+                        MatListModule,
+                        MatStepperModule,
+                        MatTabsModule,
+                        MatTreeModule,
+                        MatButtonModule,
+                        MatButtonToggleModule,
+                        MatBadgeModule,
+                        MatChipsModule,
+                        MatIconModule,
+                        MatProgressSpinnerModule,
+                        MatProgressBarModule,
+                        MatRippleModule,
+                        MatBottomSheetModule,
+                        MatDialogModule,
+                        MatSnackBarModule,
+                        MatTooltipModule,
+                        MatPaginatorModule,
+                        MatSortModule,
+                        MatTableModule,
+                        MatTooltipModule,
+                        MatMomentDatetimeModule,
+                        MatDatetimepickerModule,
+                        MatNativeDatetimeModule
+                    ],
+                }]
+        }] });
+
+/*
+ * Public API Surface of afrisure-blockly-expression
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BlocklyExpression, LoaderService, MaterialModule, PopUpTemplate };
+//# sourceMappingURL=srikanthsai27-afrisure-blockly-expression.mjs.map