@pepperi-addons/ngx-composite-lib 0.4.2-beta.69 → 0.4.2-beta.70

package/esm2020/layout-builder/layout-builder-internal.service.mjs

@@ -0,0 +1,655 @@
+import { Injectable } from "@angular/core";
+import { coerceNumberProperty } from "@angular/cdk/coercion";
+import { moveItemInArray } from "@angular/cdk/drag-drop";
+import { PepGuid, PepScreenSizeType } from "@pepperi-addons/ngx-lib";
+import { BehaviorSubject } from 'rxjs';
+import { distinctUntilChanged, filter } from 'rxjs/operators';
+import { PepDialogData } from "@pepperi-addons/ngx-lib/dialog";
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "@pepperi-addons/ngx-lib/dialog";
+export class LayoutBuilderInternalService {
+    constructor(translate, dialogService) {
+        this.translate = translate;
+        this.dialogService = dialogService;
+        this._defaultSectionTitle = '';
+        this._blocksLimitNumber = 0;
+        this._editorsBreadCrumb = Array();
+        this._editMode = false;
+        this._editableState = false;
+        // This subject is for the screen size change events.
+        this._screenSizeSubject = new BehaviorSubject(PepScreenSizeType.XL);
+        // This subject is for demostrate the container size (Usage only in edit mode).
+        this._screenWidthSubject = new BehaviorSubject('100%');
+        // This subject is for load the current editor (Usage only in edit mode).
+        this._editorSubject = new BehaviorSubject(null);
+        // This is the sections columns drop list subject.
+        this._sectionsColumnsDropListSubject = new BehaviorSubject([]);
+        // This is the sections subject (a pare from the layout view object)
+        this._sectionsViewSubject = new BehaviorSubject([]);
+        // This subject is for layout view change.
+        this._layoutViewSubject = new BehaviorSubject(null);
+        // This subject is for edit mode when block is dragging now or not.
+        this._draggingBlockKey = new BehaviorSubject('');
+        // This subject is for edit mode when section is dragging now or not.
+        this._draggingSectionKey = new BehaviorSubject('');
+        // This subject is for lock or unlock the screen (Usage only in edit mode).
+        this._lockScreenSubject = new BehaviorSubject(false);
+        // This is for control the preview mode (for load the blocks with the CPI events) 
+        this._previewModeSubject = new BehaviorSubject(false);
+        // This is for editor mode for block added.
+        this._blockAddedEventSubject = new BehaviorSubject(null);
+        // This is for editor mode for blocks removed.
+        this._blocksRemovedEventSubject = new BehaviorSubject([]);
+        // This subject is for skeleton.
+        this._showSkeletonSubject = new BehaviorSubject(true);
+        // This subjects is for load the available blocks to drag into map for better performance.
+        this._availableBlocksForDragMap = new Map();
+        this._availableBlocksForDragMapSubject = new BehaviorSubject(this.availableBlocksForDragMap);
+        //
+        this._defaultSectionTitle = this.translate.instant('LAYOUT_BUILDER.SECTION');
+    }
+    setBlocksLimitNumber(value) {
+        this._blocksLimitNumber = value;
+    }
+    get editMode() {
+        return this._editMode;
+    }
+    setEditMode(value) {
+        this._editMode = value;
+        this.setEditableState();
+    }
+    get editableState() {
+        return this._editableState;
+    }
+    get screenSizeChange$() {
+        return this._screenSizeSubject.asObservable().pipe(distinctUntilChanged());
+    }
+    get screenWidthChange$() {
+        return this._screenWidthSubject.asObservable().pipe(distinctUntilChanged());
+    }
+    get editorChange$() {
+        return this._editorSubject.asObservable().pipe(distinctUntilChanged());
+    }
+    get sectionsColumnsDropListChange$() {
+        return this._sectionsColumnsDropListSubject.asObservable();
+    }
+    get sectionsChange$() {
+        return this._sectionsViewSubject.asObservable();
+        // (prevSections, nextSections) => JSON.stringify(prevSections) === JSON.stringify(nextSections)));
+    }
+    get layoutViewChange$() {
+        return this._layoutViewSubject.asObservable().pipe(filter(layout => !!layout));
+    }
+    get draggingBlockKey() {
+        return this._draggingBlockKey.asObservable().pipe(distinctUntilChanged());
+    }
+    get draggingSectionKey() {
+        return this._draggingSectionKey.asObservable().pipe(distinctUntilChanged());
+    }
+    get lockScreenChange$() {
+        return this._lockScreenSubject.asObservable().pipe(distinctUntilChanged());
+    }
+    get previewModeChange$() {
+        return this._previewModeSubject.asObservable().pipe(distinctUntilChanged());
+    }
+    get blockAddedEventSubject$() {
+        return this._blockAddedEventSubject.asObservable();
+    }
+    get blocksRemovedEventSubject$() {
+        return this._blocksRemovedEventSubject.asObservable();
+    }
+    get showSkeletonChange$() {
+        return this._showSkeletonSubject.asObservable().pipe(distinctUntilChanged());
+    }
+    get availableBlocksForDragMap() {
+        return this._availableBlocksForDragMap;
+    }
+    get availableBlocksForDragMapChange$() {
+        return this._availableBlocksForDragMapSubject.asObservable();
+    }
+    setEditableState() {
+        this._editableState = this.editMode && !this._previewModeSubject.getValue();
+    }
+    notifyLayoutViewChange(layoutViewToUpdate) {
+        if (layoutViewToUpdate) {
+            if (this.editMode) {
+                this.updateLayoutEditorProperties(layoutViewToUpdate);
+            }
+            // Update the layout for the view.
+            this._layoutViewSubject.next(layoutViewToUpdate);
+            // Update the sections for the view.
+            this._sectionsViewSubject.next(layoutViewToUpdate?.Layout.Sections || []);
+        }
+    }
+    notifyBlockAdded(blockAddedEventData) {
+        // Notify that the block is added (to raise the event for the client).
+        this._blockAddedEventSubject.next(blockAddedEventData);
+    }
+    notifyBlocksRemoved(keys) {
+        if (keys) {
+            // Notify that the blocks are removed (to raise the event for the client).
+            this._blocksRemovedEventSubject.next(keys);
+        }
+    }
+    notifyEditorChange(editor) {
+        this._editorSubject.next(editor);
+    }
+    notifyAvailableBlocksForDragMapChange() {
+        this._availableBlocksForDragMapSubject.next(this.availableBlocksForDragMap);
+    }
+    notifyPreviewModeChange(value) {
+        this._previewModeSubject.next(value);
+        this.setEditableState();
+    }
+    notifyLockScreen(value) {
+        this._lockScreenSubject.next(value);
+    }
+    notifySectionsColumnsDropListChange(sectionsColumnsDropList) {
+        this._sectionsColumnsDropListSubject.next(sectionsColumnsDropList);
+    }
+    updateLayoutEditorProperties(layoutView) {
+        if (this._editorsBreadCrumb[0]) {
+            const layoutEditor = {
+                maxWidth: layoutView?.Layout.MaxWidth || 0,
+                verticalSpacing: layoutView?.Layout.VerticalSpacing,
+                horizontalSpacing: layoutView?.Layout.HorizontalSpacing,
+                sectionsGap: layoutView?.Layout.SectionsGap,
+                columnsGap: layoutView?.Layout.ColumnsGap,
+                // roundedCorners: layoutView?.layout.
+            };
+            this._editorsBreadCrumb[0].hostObject = layoutEditor;
+        }
+    }
+    loadDefaultEditor(layoutView) {
+        this._editorsBreadCrumb = new Array();
+        if (layoutView) {
+            this._editorsBreadCrumb.push({
+                id: LayoutBuilderInternalService.MAIN_EDITOR_ID,
+                type: 'layout-builder',
+                title: layoutView.Title || this.translate.instant('LAYOUT_BUILDER.DEFAULT_TITLE'),
+                // hostObject: {} // Updates in updateLayoutEditorProperties function above.
+            });
+            this.updateLayoutEditorProperties(layoutView);
+            this.notifyEditorChange(this._editorsBreadCrumb[0]);
+        }
+        else {
+            this.notifyEditorChange(null);
+        }
+    }
+    changeCurrentEditor() {
+        if (this._editorsBreadCrumb.length > 0) {
+            this.notifyEditorChange(this._editorsBreadCrumb[this._editorsBreadCrumb.length - 1]);
+        }
+    }
+    getEditorByType(editorType, id) {
+        // Build editor object.
+        let editor = null;
+        if (editorType === 'section') {
+            editor = this.getSectionEditor(id);
+        }
+        else if (editorType === 'block') {
+            editor = this.getBlockEditor(id);
+        }
+        return editor;
+    }
+    getBlockEditor(blockKey) {
+        const blockContainer = this.getBlockContainerByBlockKey(blockKey);
+        const defaultTitle = this.translate.instant('LAYOUT_BUILDER.NO_TITLE');
+        let blockTitle = defaultTitle;
+        if (blockContainer) {
+            blockTitle = this.availableBlocksForDragMap?.get(blockContainer?.DraggableItemKey)?.title || defaultTitle;
+        }
+        return {
+            id: blockKey,
+            type: 'block',
+            title: blockTitle,
+            // remoteModuleOptions: remoteLoaderOptions,
+            hostObject: {} // JSON.parse(JSON.stringify(hostObject))
+        };
+    }
+    getSectionEditorTitle(section, sectionIndex) {
+        return section.Name || `${this._defaultSectionTitle} ${sectionIndex + 1}`;
+    }
+    getSectionEditor(sectionId) {
+        const layoutView = this._layoutViewSubject.getValue();
+        const sections = layoutView?.Layout.Sections || [];
+        const sectionIndex = sections.findIndex(section => section.Key === sectionId);
+        if (sectionIndex >= 0) {
+            let section = sections[sectionIndex];
+            const sectionEditor = {
+                id: section.Key,
+                sectionName: section.Name || '',
+                split: section.Split || undefined,
+                height: section.Height || 0,
+                collapseOnTablet: section.CollapseOnTablet ?? false,
+                fillHeight: section.FillHeight ?? false
+            };
+            return {
+                id: sectionId,
+                type: 'section',
+                title: this.getSectionEditorTitle(section, sectionIndex),
+                hostObject: sectionEditor
+            };
+        }
+        else {
+            return null;
+        }
+    }
+    getSectionColumnByIdForEditor(sectionColumnId) {
+        let currentColumn = null;
+        // Get the section and column array by the pattern of the section column key.
+        const sectionColumnPatternSeparator = this.getSectionColumnKey();
+        const sectionColumnArr = sectionColumnId.split(sectionColumnPatternSeparator);
+        if (sectionColumnArr.length === 2) {
+            const layoutView = this._layoutViewSubject.getValue();
+            const sections = layoutView?.Layout.Sections || [];
+            // Get the section id to get the section index.
+            const sectionId = sectionColumnArr[0];
+            const sectionIndex = sections.findIndex(section => section.Key === sectionId);
+            // Get the column index.
+            const columnIndex = coerceNumberProperty(sectionColumnArr[1], -1);
+            if (sectionIndex >= 0 && columnIndex >= 0) {
+                currentColumn = sections[sectionIndex].Columns[columnIndex];
+            }
+        }
+        return currentColumn;
+    }
+    // private setSectionsColumnsGap(layoutView: IPepLayoutView) {
+    //     if (layoutView?.Layout?.Sections) {
+    //         for (let index = 0; index < layoutView.Layout.Sections.length; index++) {
+    //             const section = layoutView.Layout.Sections[index];
+    //             section.ColumnsGap = layoutView.Layout.ColumnsGap;
+    //         }
+    //     }
+    // }
+    getCssScreenWidh(screenType) {
+        let widthToSet = '100%';
+        if (screenType === 'Tablet') {
+            widthToSet = '720';
+        }
+        else if (screenType === 'Phablet') {
+            widthToSet = '360';
+        }
+        return widthToSet;
+    }
+    getBlockContainerByBlockKey(blockKey) {
+        let blockContainerToFind = undefined;
+        const layoutView = this._layoutViewSubject.getValue();
+        const sections = layoutView?.Layout.Sections || [];
+        for (let sectionIndex = 0; sectionIndex < sections.length; sectionIndex++) {
+            const section = sections[sectionIndex];
+            // Get the block container.
+            const columnIndex = section.Columns.findIndex(column => column.BlockContainer?.BlockKey === blockKey);
+            if (columnIndex > -1) {
+                blockContainerToFind = section.Columns[columnIndex].BlockContainer;
+                break;
+            }
+        }
+        return blockContainerToFind;
+    }
+    getBlocksNumber() {
+        let blocksNumber = 0;
+        const sections = this._layoutViewSubject.getValue()?.Layout.Sections || [];
+        for (let index = 0; index < sections.length; index++) {
+            const section = sections[index];
+            for (let columnIndex = 0; columnIndex < section.Columns.length; columnIndex++) {
+                const column = section.Columns[columnIndex];
+                if (column.BlockContainer && column.BlockContainer.BlockKey?.length > 0) {
+                    blocksNumber++;
+                }
+            }
+        }
+        return blocksNumber;
+    }
+    changeCursorOnDragStart() {
+        document.body.classList.add('inheritCursors');
+        document.body.style.cursor = 'grabbing';
+    }
+    changeCursorOnDragEnd() {
+        document.body.classList.remove('inheritCursors');
+        document.body.style.cursor = 'unset';
+    }
+    /***********************************************************************************************/
+    /*                                  Public functions
+    /***********************************************************************************************/
+    setSectionsColumnsDropListChange(sectionsColumnsDropList) {
+        this.notifySectionsColumnsDropListChange(sectionsColumnsDropList);
+    }
+    setLockScreen(value) {
+        this.notifyLockScreen(value);
+    }
+    changePreviewMode(value) {
+        this.notifyPreviewModeChange(value);
+    }
+    setAvailableBlocksToDrag(availableBlocksForDrag) {
+        this._availableBlocksForDragMap.clear();
+        availableBlocksForDrag.forEach(block => {
+            this._availableBlocksForDragMap.set(block.data.key, block);
+        });
+        this.notifyAvailableBlocksForDragMapChange();
+    }
+    getCurrentScreenType() {
+        return this.getScreenType(this._screenSizeSubject.getValue());
+    }
+    getScreenType(size) {
+        const screenType = size < PepScreenSizeType.MD ? 'Landscape' :
+            (size === PepScreenSizeType.MD || size === PepScreenSizeType.SM ? 'Tablet' : 'Phablet');
+        return screenType;
+    }
+    getSectionColumnKey(sectionKey = '', index = '') {
+        return `${sectionKey}_column_${index}`;
+    }
+    getIsHidden(hideIn, currentScreenType) {
+        return (hideIn && hideIn?.length > 0) ? hideIn.some(hi => hi === currentScreenType) : false;
+    }
+    navigateToEditor(editorType, id) {
+        let success = false;
+        // Cannot navigate into 'layout-builder' because this is first and const in the editorsBreadCrumbs.
+        if (editorType !== 'layout-builder' && id?.length > 0) {
+            // Check which editor we have now
+            const currentEditor = this._editorsBreadCrumb[this._editorsBreadCrumb.length - 1];
+            // Only if it's another editor.
+            if (currentEditor.id !== id) {
+                if (currentEditor.type !== 'layout-builder') {
+                    // Always pop the last and insert the current.
+                    this._editorsBreadCrumb.pop();
+                }
+                let editor = this.getEditorByType(editorType, id);
+                if (editor) {
+                    this._editorsBreadCrumb.push(editor);
+                    this.changeCurrentEditor();
+                    success = true;
+                }
+                else {
+                    success = false;
+                }
+            }
+        }
+        return success;
+    }
+    navigateBackFromEditor() {
+        // Keep the layout builder editor.
+        if (this._editorsBreadCrumb.length > 1) {
+            // Maybe we want to compare the last editor for validation ?
+            const lastEditor = this._editorsBreadCrumb.pop();
+            this.changeCurrentEditor();
+        }
+    }
+    updateLayoutFromEditor(editorData) {
+        const layoutView = this._layoutViewSubject.getValue();
+        if (layoutView) {
+            layoutView.Layout.MaxWidth = editorData.maxWidth;
+            layoutView.Layout.HorizontalSpacing = editorData.horizontalSpacing;
+            layoutView.Layout.VerticalSpacing = editorData.verticalSpacing;
+            layoutView.Layout.SectionsGap = editorData.sectionsGap;
+            layoutView.Layout.ColumnsGap = editorData.columnsGap;
+            // layoutView.layout.RoundedCorners = editorData.roundedCorners;
+            // this.setSectionsColumnsGap(layoutView);
+            this.notifyLayoutViewChange(layoutView);
+        }
+    }
+    updateSectionFromEditor(sectionData) {
+        const layoutView = this._layoutViewSubject.getValue();
+        const sections = layoutView?.Layout.Sections || [];
+        const sectionIndex = sections.findIndex(section => section.Key === sectionData.id);
+        // Update section details.
+        if (sectionIndex >= 0) {
+            const blocksIdsToRemove = [];
+            const currentSection = sections[sectionIndex];
+            currentSection.Name = sectionData.sectionName;
+            currentSection.Split = sectionData.split;
+            currentSection.Height = sectionData.height;
+            currentSection.CollapseOnTablet = sectionData.collapseOnTablet;
+            currentSection.FillHeight = sectionData.fillHeight;
+            // Get the new columns number from currentSection.Split, if its undefined put a default 1.
+            const newColumnsLength = currentSection.Split?.split(' ').length || 1;
+            if (newColumnsLength > currentSection.Columns.length) {
+                while (newColumnsLength > currentSection.Columns.length) {
+                    currentSection.Columns.push({});
+                }
+            }
+            else if (newColumnsLength < currentSection.Columns.length) {
+                while (newColumnsLength < currentSection.Columns.length) {
+                    const colunm = currentSection.Columns.pop();
+                    // If there is block in this column delete it.
+                    if (colunm && colunm.BlockContainer) {
+                        blocksIdsToRemove.push(colunm.BlockContainer.BlockKey);
+                    }
+                }
+            }
+            // Update editor title
+            const currentEditor = this._editorSubject.getValue();
+            if (currentEditor && currentEditor.type === 'section' && currentEditor.id === currentSection.Key) {
+                const title = this.getSectionEditorTitle(currentSection, sectionIndex);
+                currentEditor.title = title;
+                this.notifyEditorChange(currentEditor);
+            }
+            // Update sections change.
+            this.notifyLayoutViewChange(layoutView);
+            // If there are blocks to remove, notify the blocks removed.
+            if (blocksIdsToRemove.length > 0) {
+                this.notifyBlocksRemoved(blocksIdsToRemove);
+            }
+        }
+    }
+    addSection(section = null) {
+        // Create new section
+        if (!section) {
+            section = {
+                Key: PepGuid.newGuid(),
+                Columns: [{}],
+                Hide: []
+            };
+        }
+        // Add the new section to layout view.
+        const layoutView = this._layoutViewSubject.getValue();
+        const sections = layoutView?.Layout.Sections || [];
+        sections.push(section);
+        this.notifyLayoutViewChange(layoutView);
+    }
+    removeSection(sectionId) {
+        const layoutView = this._layoutViewSubject.getValue();
+        const sections = layoutView?.Layout.Sections || [];
+        const index = sections.findIndex(section => section.Key === sectionId);
+        if (index > -1) {
+            // Get the blocks id's to remove.
+            const blocksIdsToRemove = sections[index].Columns.map(column => column?.BlockContainer?.BlockKey);
+            // Remove section.
+            sections.splice(index, 1);
+            this.notifyLayoutViewChange(layoutView);
+            // If there are blocks to remove, notify the blocks removed.
+            if (blocksIdsToRemove.length > 0) {
+                this.notifyBlocksRemoved(blocksIdsToRemove);
+            }
+        }
+    }
+    hideSection(sectionId, hideIn) {
+        const layoutView = this._layoutViewSubject.getValue();
+        const sections = layoutView?.Layout.Sections || [];
+        const index = sections.findIndex(section => section.Key === sectionId);
+        if (index > -1) {
+            sections[index].Hide = hideIn;
+            this.notifyLayoutViewChange(layoutView);
+        }
+    }
+    onSectionDropped(event) {
+        const layoutView = this._layoutViewSubject.getValue();
+        const sections = layoutView?.Layout.Sections || [];
+        moveItemInArray(sections, event.previousIndex, event.currentIndex);
+        this.notifyLayoutViewChange(layoutView);
+    }
+    onSectionDragStart(event) {
+        this.changeCursorOnDragStart();
+        this._draggingSectionKey.next(event.source.data);
+    }
+    onSectionDragEnd(event) {
+        this.changeCursorOnDragEnd();
+        this._draggingSectionKey.next('');
+    }
+    removeBlockFromSection(blockId) {
+        let blockRemoved = false;
+        // Remove the block from section column.
+        const layoutView = this._layoutViewSubject.getValue();
+        const sections = layoutView?.Layout.Sections || [];
+        for (let sectionIndex = 0; sectionIndex < sections.length; sectionIndex++) {
+            const section = sections[sectionIndex];
+            // Remove the block container.
+            const columnIndex = section.Columns.findIndex(column => column.BlockContainer?.BlockKey === blockId);
+            if (columnIndex > -1) {
+                delete section.Columns[columnIndex].BlockContainer;
+                this.notifyLayoutViewChange(layoutView);
+                blockRemoved = true;
+                break;
+            }
+        }
+        // If the block was removed, notify the block removed.
+        if (blockRemoved) {
+            this.notifyBlocksRemoved([blockId]);
+        }
+    }
+    hideBlock(sectionId, blockId, hideIn) {
+        const layoutView = this._layoutViewSubject.getValue();
+        const sections = layoutView?.Layout.Sections || [];
+        const index = sections.findIndex(section => section.Key === sectionId);
+        if (index > -1) {
+            const columnIndex = sections[index].Columns.findIndex(column => column.BlockContainer?.BlockKey === blockId);
+            if (columnIndex > -1) {
+                const blockContainer = sections[index].Columns[columnIndex].BlockContainer;
+                if (blockContainer) {
+                    blockContainer.Hide = hideIn;
+                    this.notifyLayoutViewChange(layoutView);
+                }
+            }
+        }
+    }
+    onBlockDropped(event, sectionId) {
+        const layoutView = this._layoutViewSubject.getValue();
+        if (event.previousContainer.id === LayoutBuilderInternalService.AVAILABLE_BLOCKS_CONTAINER_ID) {
+            // Validate if blocks number allow.
+            if (this._blocksLimitNumber > 0 && this.getBlocksNumber() >= this._blocksLimitNumber) {
+                const data = new PepDialogData({
+                    title: this.translate.instant('MESSAGES.DIALOG_NOTICE_TITLE'),
+                    content: this.translate.instant('LAYOUT_BUILDER.BLOCKS_COUNT_LIMIT_MESSAGE'),
+                });
+                this.dialogService.openDefaultDialog(data);
+            }
+            else {
+                // Get the block relation (previousContainer.data is IPepDraggableItem and inside we have AvailableBlock object).
+                const draggableItem = event.previousContainer.data[event.previousIndex];
+                if (draggableItem) {
+                    // lock the screen untill the editor will be loaded.
+                    // this._lockScreenSubject.next(true);
+                    // Get the column.
+                    const currentColumn = this.getSectionColumnByIdForEditor(event.container.id);
+                    // Set the block key in the section block only if there is a blank column.
+                    if (currentColumn && !currentColumn.BlockContainer) {
+                        // Generate the block uuid.
+                        const blockKey = PepGuid.newGuid();
+                        currentColumn.BlockContainer = {
+                            BlockKey: blockKey,
+                            DraggableItemKey: draggableItem.data.key,
+                        };
+                        // Here we update the layout view cause the layout is updated.
+                        this.notifyLayoutViewChange(layoutView);
+                        // Raise block added event.
+                        const blockAddedEventData = {
+                            BlockKey: blockKey,
+                            DraggableItem: draggableItem,
+                        };
+                        this.notifyBlockAdded(blockAddedEventData);
+                        // Navigate to the block editor.
+                        this.navigateToEditor('block', blockKey);
+                    }
+                }
+                else {
+                    console.log("draggableItem is not a IPepDraggableItem type");
+                }
+            }
+        }
+        else {
+            // If the block moved between columns in the same section or between different sections but not in the same column.
+            if (event.container.id !== event.previousContainer.id) {
+                // Get the column.
+                const currentColumn = this.getSectionColumnByIdForEditor(event.container.id);
+                // Get the previous column.
+                const previuosColumn = this.getSectionColumnByIdForEditor(event.previousContainer.id);
+                if (currentColumn && previuosColumn) {
+                    currentColumn.BlockContainer = previuosColumn.BlockContainer;
+                    delete previuosColumn.BlockContainer;
+                    this.notifyLayoutViewChange(layoutView);
+                }
+            }
+        }
+    }
+    onBlockDragStart(event) {
+        this.changeCursorOnDragStart();
+        // Take the block key if exist, else take the available block key (relation key).
+        const blockKey = event.source.data?.BlockKey || event.source.data?.Key;
+        this._draggingBlockKey.next(blockKey);
+    }
+    onBlockDragEnd(event) {
+        this.changeCursorOnDragEnd();
+        this._draggingBlockKey.next('');
+    }
+    doesColumnContainBlock(sectionId, columnIndex) {
+        let res = false;
+        const layoutView = this._layoutViewSubject.getValue();
+        const section = layoutView?.Layout.Sections.find(section => section.Key === sectionId);
+        if (section && columnIndex >= 0 && section.Columns.length > columnIndex) {
+            res = !!section.Columns[columnIndex].BlockContainer;
+        }
+        return res;
+    }
+    setScreenWidth(screenType) {
+        const value = this.getCssScreenWidh(screenType);
+        let width = coerceNumberProperty(value, 0);
+        if (width === 0) {
+            this._screenWidthSubject.next('100%');
+            this._screenSizeSubject.next(PepScreenSizeType.XL);
+        }
+        else {
+            this._screenWidthSubject.next(`${width}px`);
+            // Change the size according the width.
+            if (width >= 1920) {
+                this._screenSizeSubject.next(PepScreenSizeType.XL);
+            }
+            else if (width >= 1280 && width < 1920) {
+                this._screenSizeSubject.next(PepScreenSizeType.LG);
+            }
+            else if (width >= 960 && width < 1280) {
+                this._screenSizeSubject.next(PepScreenSizeType.MD);
+            }
+            else if (width >= 600 && width < 960) {
+                this._screenSizeSubject.next(PepScreenSizeType.SM);
+            }
+            else if (width < 600) {
+                this._screenSizeSubject.next(PepScreenSizeType.XS);
+            }
+        }
+    }
+    showSkeleton(show) {
+        this._showSkeletonSubject.next(show);
+    }
+    loadLayoutBuilder(layoutView) {
+        if (this.editMode) {
+            // Load the layout editor.
+            this.loadDefaultEditor(layoutView);
+            // Set the columns gap of the sections.
+            // this.setSectionsColumnsGap(layoutView);
+        }
+        // Load only the layout view.
+        this.notifyLayoutViewChange(layoutView);
+    }
+}
+LayoutBuilderInternalService.AVAILABLE_BLOCKS_CONTAINER_ID = 'availableBlocks';
+LayoutBuilderInternalService.MAIN_EDITOR_ID = 'main';
+LayoutBuilderInternalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: LayoutBuilderInternalService, deps: [{ token: i1.TranslateService }, { token: i2.PepDialogService }], target: i0.ɵɵFactoryTarget.Injectable });
+LayoutBuilderInternalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: LayoutBuilderInternalService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: LayoutBuilderInternalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.PepDialogService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layout-builder-internal.service.js","sourceRoot":"","sources":["../../../../projects/ngx-composite-lib/layout-builder/layout-builder-internal.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAwD,eAAe,EAAqB,MAAM,wBAAwB,CAAC;AAElI,OAAO,EAAmB,OAAO,EAAkB,iBAAiB,EAA0C,MAAM,yBAAyB,CAAC;AAI9I,OAAO,EAAc,eAAe,EAAW,MAAM,MAAM,CAAC;AAC5D,OAAO,EAAgB,oBAAoB,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,aAAa,EAAoB,MAAM,gCAAgC,CAAC;;;;AAKjF,MAAM,OAAO,4BAA4B;IAmHrC,YACc,SAA2B,EAC3B,aAA+B;QAD/B,cAAS,GAAT,SAAS,CAAkB;QAC3B,kBAAa,GAAb,aAAa,CAAkB;QAjHrC,yBAAoB,GAAG,EAAE,CAAC;QAE1B,uBAAkB,GAAG,CAAC,CAAC;QAKvB,uBAAkB,GAAG,KAAK,EAAW,CAAC;QAEtC,cAAS,GAAY,KAAK,CAAC;QAS3B,mBAAc,GAAY,KAAK,CAAC;QAKxC,qDAAqD;QAC7C,uBAAkB,GAAuC,IAAI,eAAe,CAAoB,iBAAiB,CAAC,EAAE,CAAC,CAAC;QAK9H,+EAA+E;QACvE,wBAAmB,GAA4B,IAAI,eAAe,CAAS,MAAM,CAAC,CAAC;QAK3F,yEAAyE;QACjE,mBAAc,GAAoC,IAAI,eAAe,CAAiB,IAAI,CAAC,CAAC;QAKpG,kDAAkD;QAC1C,oCAA+B,GAA2B,IAAI,eAAe,CAAQ,EAAE,CAAC,CAAC;QAKjG,oEAAoE;QAC5D,yBAAoB,GAAyC,IAAI,eAAe,CAAsB,EAAE,CAAC,CAAC;QAMlH,0CAA0C;QAClC,uBAAkB,GAA2C,IAAI,eAAe,CAAwB,IAAI,CAAC,CAAC;QAKtH,mEAAmE;QAC3D,sBAAiB,GAA4B,IAAI,eAAe,CAAC,EAAE,CAAC,CAAC;QAK7E,qEAAqE;QAC7D,wBAAmB,GAA4B,IAAI,eAAe,CAAC,EAAE,CAAC,CAAC;QAK/E,2EAA2E;QACnE,uBAAkB,GAA6B,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;QAK3F,kFAAkF;QAC1E,wBAAmB,GAA6B,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;QAK5F,2CAA2C;QACnC,4BAAuB,GAAG,IAAI,eAAe,CAAmC,IAAI,CAAC,CAAC;QAI9F,8CAA8C;QACtC,+BAA0B,GAAG,IAAI,eAAe,CAAW,EAAE,CAAC,CAAC;QAKvE,gCAAgC;QACxB,yBAAoB,GAA6B,IAAI,eAAe,CAAU,IAAI,CAAC,CAAC;QAK5F,0FAA0F;QAClF,+BAA0B,GAAG,IAAI,GAAG,EAA6B,CAAC;QAIlE,sCAAiC,GAAG,IAAI,eAAe,CAAyC,IAAI,CAAC,yBAAyB,CAAC,CAAC;QASpI,EAAE;QACF,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,wBAAwB,CAAC,CAAC;IACjF,CAAC;IAlHD,oBAAoB,CAAC,KAAa;QAC9B,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IACpC,CAAC;IAKD,IAAI,QAAQ;QACR,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IACD,WAAW,CAAC,KAAc;QACtB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC5B,CAAC;IAGD,IAAI,aAAa;QACb,OAAO,IAAI,CAAC,cAAc,CAAC;IAC/B,CAAC;IAID,IAAI,iBAAiB;QACjB,OAAO,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC,CAAC;IAC/E,CAAC;IAID,IAAI,kBAAkB;QAClB,OAAO,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC,CAAC;IAChF,CAAC;IAID,IAAI,aAAa;QACb,OAAO,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC,CAAC;IAC3E,CAAC;IAID,IAAI,8BAA8B;QAC9B,OAAO,IAAI,CAAC,+BAA+B,CAAC,YAAY,EAAE,CAAC;IAC/D,CAAC;IAID,IAAI,eAAe;QACf,OAAO,IAAI,CAAC,oBAAoB,CAAC,YAAY,EAAE,CAAC;QAChD,mGAAmG;IACvG,CAAC;IAID,IAAI,iBAAiB;QACjB,OAAO,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IACnF,CAAC;IAID,IAAI,gBAAgB;QAChB,OAAO,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC,CAAC;IAC9E,CAAC;IAID,IAAI,kBAAkB;QAClB,OAAO,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC,CAAC;IAChF,CAAC;IAID,IAAI,iBAAiB;QACjB,OAAO,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC,CAAC;IAC/E,CAAC;IAID,IAAI,kBAAkB;QAClB,OAAO,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC,CAAC;IAChF,CAAC;IAID,IAAI,uBAAuB;QACvB,OAAO,IAAI,CAAC,uBAAuB,CAAC,YAAY,EAAE,CAAC;IACvD,CAAC;IAGD,IAAI,0BAA0B;QAC1B,OAAO,IAAI,CAAC,0BAA0B,CAAC,YAAY,EAAE,CAAC;IAC1D,CAAC;IAID,IAAI,mBAAmB;QACnB,OAAO,IAAI,CAAC,oBAAoB,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC,CAAC;IACjF,CAAC;IAID,IAAI,yBAAyB;QACzB,OAAO,IAAI,CAAC,0BAA0B,CAAC;IAC3C,CAAC;IAED,IAAI,gCAAgC;QAChC,OAAO,IAAI,CAAC,iCAAiC,CAAC,YAAY,EAAE,CAAC;IACjE,CAAC;IAUO,gBAAgB;QACpB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE,CAAC;IAChF,CAAC;IAEO,sBAAsB,CAAC,kBAAyC;QACpE,IAAI,kBAAkB,EAAE;YACpB,IAAI,IAAI,CAAC,QAAQ,EAAE;gBACf,IAAI,CAAC,4BAA4B,CAAC,kBAAkB,CAAC,CAAC;aACzD;YAED,kCAAkC;YAClC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;YAEjD,oCAAoC;YACpC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;SAC7E;IACL,CAAC;IAEO,gBAAgB,CAAC,mBAA8C;QACnE,sEAAsE;QACtE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;IAC3D,CAAC;IAEO,mBAAmB,CAAC,IAA0B;QAClD,IAAI,IAAI,EAAE;YACN,0EAA0E;YAC1E,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAC9C;IACL,CAAC;IAEO,kBAAkB,CAAC,MAAsB;QAC7C,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;IAEO,qCAAqC;QACzC,IAAI,CAAC,iCAAiC,CAAC,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC;IAChF,CAAC;IAEO,uBAAuB,CAAC,KAAc;QAC1C,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC5B,CAAC;IAEO,gBAAgB,CAAC,KAAc;QACnC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;IAEO,mCAAmC,CAAC,uBAA8B;QACtE,IAAI,CAAC,+BAA+B,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;IACvE,CAAC;IAEO,4BAA4B,CAAC,UAA0B;QAC3D,IAAI,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE;YAC5B,MAAM,YAAY,GAAkB;gBAChC,QAAQ,EAAE,UAAU,EAAE,MAAM,CAAC,QAAQ,IAAI,CAAC;gBAC1C,eAAe,EAAE,UAAU,EAAE,MAAM,CAAC,eAAe;gBACnD,iBAAiB,EAAE,UAAU,EAAE,MAAM,CAAC,iBAAiB;gBACvD,WAAW,EAAE,UAAU,EAAE,MAAM,CAAC,WAAW;gBAC3C,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU;gBACzC,sCAAsC;aACzC,CAAC;YAEF,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,YAAY,CAAC;SACxD;IACL,CAAC;IAEO,iBAAiB,CAAC,UAA0B;QAChD,IAAI,CAAC,kBAAkB,GAAG,IAAI,KAAK,EAAW,CAAC;QAE/C,IAAI,UAAU,EAAE;YACZ,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC;gBACzB,EAAE,EAAE,4BAA4B,CAAC,cAAc;gBAC/C,IAAI,EAAG,gBAAgB;gBACvB,KAAK,EAAE,UAAU,CAAC,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,8BAA8B,CAAC;gBACjF,4EAA4E;aAC/E,CAAC,CAAC;YAEH,IAAI,CAAC,4BAA4B,CAAC,UAAU,CAAC,CAAC;YAC9C,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;SACvD;aAAM;YACH,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;SACjC;IACL,CAAC;IAEO,mBAAmB;QACvB,IAAI,IAAI,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE;YACpC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;SACxF;IACL,CAAC;IAEO,eAAe,CAAC,UAA4B,EAAE,EAAU;QAC5D,uBAAuB;QACvB,IAAI,MAAM,GAAmB,IAAI,CAAC;QAElC,IAAI,UAAU,KAAK,SAAS,EAAE;YAC1B,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC;SACtC;aAAM,IAAI,UAAU,KAAK,OAAO,EAAE;YAC/B,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;SACpC;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAEO,cAAc,CAAC,QAAgB;QACnC,MAAM,cAAc,GAAG,IAAI,CAAC,2BAA2B,CAAC,QAAQ,CAAC,CAAC;QAClE,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,yBAAyB,CAAC,CAAA;QACtE,IAAI,UAAU,GAAG,YAAY,CAAC;QAE9B,IAAI,cAAc,EAAE;YAChB,UAAU,GAAG,IAAI,CAAC,yBAAyB,EAAE,GAAG,CAAC,cAAc,EAAE,gBAAgB,CAAC,EAAE,KAAK,IAAI,YAAY,CAAC;SAC7G;QAED,OAAO;YACH,EAAE,EAAE,QAAQ;YACZ,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,UAAU;YACjB,4CAA4C;YAC5C,UAAU,EAAE,EAAE,CAAC,yCAAyC;SAC3D,CAAA;IACL,CAAC;IAEO,qBAAqB,CAAC,OAA0B,EAAE,YAAoB;QAC1E,OAAO,OAAO,CAAC,IAAI,IAAI,GAAG,IAAI,CAAC,oBAAoB,IAAI,YAAY,GAAG,CAAC,EAAE,CAAC;IAC9E,CAAC;IAEO,gBAAgB,CAAC,SAAiB;QACtC,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;QACtD,MAAM,QAAQ,GAAG,UAAU,EAAE,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC;QACnD,MAAM,YAAY,GAAG,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC;QAE9E,IAAI,YAAY,IAAI,CAAC,EAAE;YACnB,IAAI,OAAO,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;YACrC,MAAM,aAAa,GAAyB;gBACxC,EAAE,EAAE,OAAO,CAAC,GAAG;gBACf,WAAW,EAAE,OAAO,CAAC,IAAI,IAAI,EAAE;gBAC/B,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,SAAS;gBACjC,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,CAAC;gBAC3B,gBAAgB,EAAE,OAAO,CAAC,gBAAgB,IAAI,KAAK;gBACnD,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,KAAK;aAC1C,CAAA;YAED,OAAO;gBACH,EAAE,EAAE,SAAS;gBACb,IAAI,EAAE,SAAS;gBACf,KAAK,EAAE,IAAI,CAAC,qBAAqB,CAAC,OAAO,EAAE,YAAY,CAAC;gBACxD,UAAU,EAAE,aAAa;aAC5B,CAAA;SACJ;aAAM;YACH,OAAO,IAAI,CAAC;SACf;IACL,CAAC;IAEO,6BAA6B,CAAC,eAAuB;QACzD,IAAI,aAAa,GAAG,IAAI,CAAC;QAEzB,6EAA6E;QAC7E,MAAM,6BAA6B,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACjE,MAAM,gBAAgB,GAAG,eAAe,CAAC,KAAK,CAAC,6BAA6B,CAAC,CAAC;QAE9E,IAAI,gBAAgB,CAAC,MAAM,KAAK,CAAC,EAAE;YAC/B,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;YACtD,MAAM,QAAQ,GAAG,UAAU,EAAE,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC;YAEnD,+CAA+C;YAC/C,MAAM,SAAS,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;YACtC,MAAM,YAAY,GAAG,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC;YAC9E,wBAAwB;YACxB,MAAM,WAAW,GAAG,oBAAoB,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAClE,IAAI,YAAY,IAAI,CAAC,IAAI,WAAW,IAAI,CAAC,EAAE;gBACvC,aAAa,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;aAC/D;SACJ;QAED,OAAO,aAAa,CAAC;IACzB,CAAC;IAED,8DAA8D;IAC9D,0CAA0C;IAC1C,oFAAoF;IACpF,iEAAiE;IACjE,iEAAiE;IACjE,YAAY;IACZ,QAAQ;IACR,IAAI;IAEI,gBAAgB,CAAC,UAA8B;QACnD,IAAI,UAAU,GAAG,MAAM,CAAC;QAExB,IAAI,UAAU,KAAK,QAAQ,EAAE;YACzB,UAAU,GAAG,KAAK,CAAC;SACtB;aAAM,IAAI,UAAU,KAAK,SAAS,EAAE;YACjC,UAAU,GAAG,KAAK,CAAC;SACtB;QAED,OAAO,UAAU,CAAC;IACtB,CAAC;IAEO,2BAA2B,CAAC,QAAgB;QAChD,IAAI,oBAAoB,GAAyC,SAAS,CAAC;QAE3E,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;QACtD,MAAM,QAAQ,GAAG,UAAU,EAAE,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC;QAEnD,KAAK,IAAI,YAAY,GAAG,CAAC,EAAE,YAAY,GAAG,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE;YACvE,MAAM,OAAO,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;YAEvC,2BAA2B;YAC3B,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,cAAc,EAAE,QAAQ,KAAK,QAAQ,CAAC,CAAC;YACtG,IAAI,WAAW,GAAG,CAAC,CAAC,EAAE;gBAClB,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,cAAc,CAAA;gBAClE,MAAM;aACT;SACJ;QAED,OAAO,oBAAoB,CAAC;IAChC,CAAC;IAEO,eAAe;QACnB,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,MAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,EAAE,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC;QAE3E,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;YAClD,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;YAEhC,KAAK,IAAI,WAAW,GAAG,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE;gBAC3E,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;gBAC5C,IAAI,MAAM,CAAC,cAAc,IAAI,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,EAAE;oBACrE,YAAY,EAAE,CAAC;iBAClB;aACJ;SACJ;QAED,OAAO,YAAY,CAAC;IACxB,CAAC;IAEO,uBAAuB;QAC3B,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;QAC9C,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,UAAU,CAAC;IAC5C,CAAC;IAEO,qBAAqB;QACzB,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;QACjD,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,OAAO,CAAC;IACzC,CAAC;IAGD,iGAAiG;IACjG;qGACiG;IAEjG,gCAAgC,CAAC,uBAA8B;QAC3D,IAAI,CAAC,mCAAmC,CAAC,uBAAuB,CAAC,CAAC;IACtE,CAAC;IAED,aAAa,CAAC,KAAc;QACxB,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAED,iBAAiB,CAAC,KAAc;QAC5B,IAAI,CAAC,uBAAuB,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;IAED,wBAAwB,CAAC,sBAAgD;QACrE,IAAI,CAAC,0BAA0B,CAAC,KAAK,EAAE,CAAC;QACxC,sBAAsB,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACnC,IAAI,CAAC,0BAA0B,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC/D,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,qCAAqC,EAAE,CAAC;IACjD,CAAC;IAED,oBAAoB;QAChB,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC,CAAC;IAClE,CAAC;IAED,aAAa,CAAC,IAAuB;QACjC,MAAM,UAAU,GACZ,IAAI,GAAG,iBAAiB,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;YAC3C,CAAC,IAAI,KAAK,iBAAiB,CAAC,EAAE,IAAI,IAAI,KAAK,iBAAiB,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QAE5F,OAAO,UAAU,CAAC;IACtB,CAAC;IAED,mBAAmB,CAAC,aAAqB,EAAE,EAAE,QAAgB,EAAE;QAC3D,OAAO,GAAG,UAAU,WAAW,KAAK,EAAE,CAAC;IAC3C,CAAC;IAED,WAAW,CAAC,MAAwC,EAAE,iBAAqC;QACvF,OAAO,CAAC,MAAM,IAAI,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,iBAAiB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAChG,CAAC;IAED,gBAAgB,CAAC,UAA4B,EAAE,EAAU;QACrD,IAAI,OAAO,GAAG,KAAK,CAAC;QAEpB,mGAAmG;QACnG,IAAI,UAAU,KAAK,gBAAgB,IAAI,EAAE,EAAE,MAAM,GAAG,CAAC,EAAE;YACnD,iCAAiC;YACjC,MAAM,aAAa,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAElF,+BAA+B;YAC/B,IAAG,aAAa,CAAC,EAAE,KAAK,EAAE,EAAE;gBACxB,IAAI,aAAa,CAAC,IAAI,KAAK,gBAAgB,EAAE;oBACzC,8CAA8C;oBAC9C,IAAI,CAAC,kBAAkB,CAAC,GAAG,EAAE,CAAC;iBACjC;gBAED,IAAI,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;gBAElD,IAAI,MAAM,EAAE;oBACR,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;oBACrC,IAAI,CAAC,mBAAmB,EAAE,CAAC;oBAC3B,OAAO,GAAG,IAAI,CAAC;iBAClB;qBAAM;oBACH,OAAO,GAAG,KAAK,CAAC;iBACnB;aACJ;SACJ;QAED,OAAO,OAAO,CAAC;IACnB,CAAC;IAED,sBAAsB;QAClB,kCAAkC;QAClC,IAAI,IAAI,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE;YACpC,4DAA4D;YAC5D,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,EAAE,CAAC;YACjD,IAAI,CAAC,mBAAmB,EAAE,CAAC;SAC9B;IACL,CAAC;IAED,sBAAsB,CAAC,UAAyB;QAC5C,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;QAEtD,IAAI,UAAU,EAAE;YACZ,UAAU,CAAC,MAAM,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;YACjD,UAAU,CAAC,MAAM,CAAC,iBAAiB,GAAG,UAAU,CAAC,iBAAiB,CAAC;YACnE,UAAU,CAAC,MAAM,CAAC,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC;YAC/D,UAAU,CAAC,MAAM,CAAC,WAAW,GAAG,UAAU,CAAC,WAAW,CAAC;YACvD,UAAU,CAAC,MAAM,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;YACrD,gEAAgE;YAEhE,0CAA0C;YAE1C,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAC;SAC3C;IACL,CAAC;IAED,uBAAuB,CAAC,WAAiC;QACrD,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;QACtD,MAAM,QAAQ,GAAG,UAAU,EAAE,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC;QACnD,MAAM,YAAY,GAAG,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,KAAK,WAAW,CAAC,EAAE,CAAC,CAAC;QAEnF,0BAA0B;QAC1B,IAAI,YAAY,IAAI,CAAC,EAAE;YACnB,MAAM,iBAAiB,GAAG,EAAE,CAAC;YAE7B,MAAM,cAAc,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;YAC9C,cAAc,CAAC,IAAI,GAAG,WAAW,CAAC,WAAW,CAAC;YAC9C,cAAc,CAAC,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC;YACzC,cAAc,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;YAC3C,cAAc,CAAC,gBAAgB,GAAG,WAAW,CAAC,gBAAgB,CAAC;YAC/D,cAAc,CAAC,UAAU,GAAG,WAAW,CAAC,UAAU,CAAC;YAEnD,0FAA0F;YAC1F,MAAM,gBAAgB,GAAG,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC;YACtE,IAAI,gBAAgB,GAAG,cAAc,CAAC,OAAO,CAAC,MAAM,EAAE;gBAClD,OAAO,gBAAgB,GAAG,cAAc,CAAC,OAAO,CAAC,MAAM,EAAE;oBACrD,cAAc,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;iBACnC;aACJ;iBAAM,IAAI,gBAAgB,GAAG,cAAc,CAAC,OAAO,CAAC,MAAM,EAAE;gBACzD,OAAO,gBAAgB,GAAG,cAAc,CAAC,OAAO,CAAC,MAAM,EAAE;oBACrD,MAAM,MAAM,GAAG,cAAc,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;oBAC5C,8CAA8C;oBAC9C,IAAI,MAAM,IAAI,MAAM,CAAC,cAAc,EAAE;wBACjC,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;qBAC1D;iBACJ;aACJ;YAED,sBAAsB;YACtB,MAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAC;YACrD,IAAI,aAAa,IAAI,aAAa,CAAC,IAAI,KAAK,SAAS,IAAI,aAAa,CAAC,EAAE,KAAK,cAAc,CAAC,GAAG,EAAE;gBAC9F,MAAM,KAAK,GAAG,IAAI,CAAC,qBAAqB,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;gBACvE,aAAa,CAAC,KAAK,GAAG,KAAK,CAAC;gBAC5B,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;aAC1C;YAED,0BAA0B;YAC1B,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAC;YAExC,4DAA4D;YAC5D,IAAI,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC9B,IAAI,CAAC,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;aAC/C;SACJ;IACL,CAAC;IAED,UAAU,CAAC,UAAoC,IAAI;QAC/C,qBAAqB;QACrB,IAAI,CAAC,OAAO,EAAE;YACV,OAAO,GAAG;gBACN,GAAG,EAAE,OAAO,CAAC,OAAO,EAAE;gBACtB,OAAO,EAAE,CAAC,EAAE,CAAC;gBACb,IAAI,EAAE,EAAE;aACX,CAAA;SACJ;QAED,sCAAsC;QACtC,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;QACtD,MAAM,QAAQ,GAAG,UAAU,EAAE,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC;QACnD,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACvB,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAC;IAC5C,CAAC;IAED,aAAa,CAAC,SAAiB;QAC3B,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;QACtD,MAAM,QAAQ,GAAG,UAAU,EAAE,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC;QACnD,MAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC;QACvE,IAAI,KAAK,GAAG,CAAC,CAAC,EAAE;YACZ,iCAAiC;YACjC,MAAM,iBAAiB,GAAQ,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,CAAC,CAAC;YAEvG,kBAAkB;YAClB,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAC1B,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAC;YAExC,4DAA4D;YAC5D,IAAI,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC9B,IAAI,CAAC,mBAAmB,CAAC,iBAAiB,CAAC,CAAA;aAC9C;SACJ;IACL,CAAC;IAED,WAAW,CAAC,SAAiB,EAAE,MAA4B;QACvD,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;QACtD,MAAM,QAAQ,GAAG,UAAU,EAAE,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC;QACnD,MAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC;QACvE,IAAI,KAAK,GAAG,CAAC,CAAC,EAAE;YACZ,QAAQ,CAAC,KAAK,CAAC,CAAC,IAAI,GAAG,MAAM,CAAC;YAC9B,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAC;SAC3C;IACL,CAAC;IAED,gBAAgB,CAAC,KAAyB;QACtC,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;QACtD,MAAM,QAAQ,GAAG,UAAU,EAAE,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC;QACnD,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,aAAa,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;QACnE,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAC;IAC5C,CAAC;IAED,kBAAkB,CAAC,KAAmB;QAClC,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC/B,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACrD,CAAC;IAED,gBAAgB,CAAC,KAAiB;QAC9B,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC7B,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACtC,CAAC;IAED,sBAAsB,CAAC,OAAe;QAClC,IAAI,YAAY,GAAG,KAAK,CAAC;QAEzB,wCAAwC;QACxC,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;QACtD,MAAM,QAAQ,GAAG,UAAU,EAAE,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC;QAEnD,KAAK,IAAI,YAAY,GAAG,CAAC,EAAE,YAAY,GAAG,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE;YACvE,MAAM,OAAO,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;YAEvC,8BAA8B;YAC9B,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,cAAc,EAAE,QAAQ,KAAK,OAAO,CAAC,CAAC;YACrG,IAAI,WAAW,GAAG,CAAC,CAAC,EAAE;gBAClB,OAAO,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,cAAc,CAAC;gBACnD,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAC;gBACxC,YAAY,GAAG,IAAI,CAAC;gBAEpB,MAAM;aACT;SACJ;QAED,sDAAsD;QACtD,IAAI,YAAY,EAAE;YACd,IAAI,CAAC,mBAAmB,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;SACvC;IACL,CAAC;IAED,SAAS,CAAC,SAAiB,EAAE,OAAe,EAAE,MAA4B;QACtE,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;QACtD,MAAM,QAAQ,GAAG,UAAU,EAAE,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC;QAEnD,MAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC;QACvE,IAAI,KAAK,GAAG,CAAC,CAAC,EAAE;YACZ,MAAM,WAAW,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,cAAc,EAAE,QAAQ,KAAK,OAAO,CAAC,CAAC;YAC7G,IAAI,WAAW,GAAG,CAAC,CAAC,EAAE;gBAClB,MAAM,cAAc,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,cAAc,CAAC;gBAC3E,IAAI,cAAc,EAAE;oBAChB,cAAc,CAAC,IAAI,GAAG,MAAM,CAAC;oBAC7B,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAC;iBAC3C;aACJ;SACJ;IACL,CAAC;IAED,cAAc,CAAC,KAAqD,EAAE,SAAiB;QACnF,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;QAEtD,IAAI,KAAK,CAAC,iBAAiB,CAAC,EAAE,KAAK,4BAA4B,CAAC,6BAA6B,EAAE;YAC3F,mCAAmC;YACnC,IAAI,IAAI,CAAC,kBAAkB,GAAG,CAAC,IAAI,IAAI,CAAC,eAAe,EAAE,IAAI,IAAI,CAAC,kBAAkB,EAAE;gBAClF,MAAM,IAAI,GAAG,IAAI,aAAa,CAAC;oBAC3B,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,8BAA8B,CAAC;oBAC7D,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,2CAA2C,CAAC;iBAC/E,CAAC,CAAC;gBAEH,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;aAC9C;iBAAM;gBACH,iHAAiH;gBACjH,MAAM,aAAa,GAAsB,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAsB,CAAC;gBAEhH,IAAI,aAAa,EAAE;oBACf,oDAAoD;oBACpD,sCAAsC;oBAEtC,kBAAkB;oBAClB,MAAM,aAAa,GAAG,IAAI,CAAC,6BAA6B,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;oBAE7E,0EAA0E;oBAC1E,IAAI,aAAa,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE;wBAChD,2BAA2B;wBAC3B,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;wBAEnC,aAAa,CAAC,cAAc,GAAG;4BAC3B,QAAQ,EAAE,QAAQ;4BAClB,gBAAgB,EAAE,aAAa,CAAC,IAAI,CAAC,GAAG;yBAC3C,CAAC;wBAEF,8DAA8D;wBAC9D,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAC;wBAExC,2BAA2B;wBAC3B,MAAM,mBAAmB,GAA8B;4BACnD,QAAQ,EAAE,QAAQ;4BAClB,aAAa,EAAE,aAAa;yBAC/B,CAAA;wBACD,IAAI,CAAC,gBAAgB,CAAC,mBAAmB,CAAC,CAAC;wBAE3C,gCAAgC;wBAChC,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;qBAC5C;iBACJ;qBAAM;oBACH,OAAO,CAAC,GAAG,CAAC,+CAA+C,CAAC,CAAC;iBAChE;aACJ;SACJ;aAAM;YACH,mHAAmH;YACnH,IAAI,KAAK,CAAC,SAAS,CAAC,EAAE,KAAK,KAAK,CAAC,iBAAiB,CAAC,EAAE,EAAE;gBACnD,kBAAkB;gBAClB,MAAM,aAAa,GAAG,IAAI,CAAC,6BAA6B,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;gBAC7E,2BAA2B;gBAC3B,MAAM,cAAc,GAAG,IAAI,CAAC,6BAA6B,CAAC,KAAK,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;gBAEtF,IAAI,aAAa,IAAI,cAAc,EAAE;oBACjC,aAAa,CAAC,cAAc,GAAG,cAAc,CAAC,cAAc,CAAC;oBAC7D,OAAO,cAAc,CAAC,cAAc,CAAC;oBACrC,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAC;iBAC3C;aACJ;SACJ;IACL,CAAC;IAED,gBAAgB,CAAC,KAAmB;QAChC,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC/B,iFAAiF;QACjF,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC;QACvE,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC1C,CAAC;IAED,cAAc,CAAC,KAAiB;QAC5B,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC7B,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACpC,CAAC;IAED,sBAAsB,CAAC,SAAiB,EAAE,WAAmB;QACzD,IAAI,GAAG,GAAG,KAAK,CAAC;QAChB,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;QACtD,MAAM,OAAO,GAAG,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC;QAEvF,IAAI,OAAO,IAAI,WAAW,IAAI,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,WAAW,EAAE;YACrE,GAAG,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,cAAc,CAAC;SACvD;QAED,OAAO,GAAG,CAAC;IACf,CAAC;IAED,cAAc,CAAC,UAA8B;QACzC,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAA;QAE/C,IAAI,KAAK,GAAG,oBAAoB,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAC3C,IAAI,KAAK,KAAK,CAAC,EAAE;YACb,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACtC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;SACtD;aAAM;YACH,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC;YAE5C,uCAAuC;YACvC,IAAI,KAAK,IAAI,IAAI,EAAE;gBACf,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;aACtD;iBAAM,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,GAAG,IAAI,EAAE;gBACtC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;aACtD;iBAAM,IAAI,KAAK,IAAI,GAAG,IAAI,KAAK,GAAG,IAAI,EAAE;gBACrC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;aACtD;iBAAM,IAAI,KAAK,IAAI,GAAG,IAAI,KAAK,GAAG,GAAG,EAAE;gBACpC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;aACtD;iBAAM,IAAI,KAAK,GAAG,GAAG,EAAE;gBACpB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;aACtD;SACJ;IACL,CAAC;IAED,YAAY,CAAC,IAAa;QACtB,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAED,iBAAiB,CAAC,UAA0B;QACxC,IAAI,IAAI,CAAC,QAAQ,EAAE;YACf,0BAA0B;YAC1B,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;YAEnC,uCAAuC;YACvC,0CAA0C;SAC7C;QAED,6BAA6B;QAC7B,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAC;IAC5C,CAAC;;AArvBe,0DAA6B,GAAG,iBAAkB,CAAA;AAClD,2CAAc,GAAG,MAAO,CAAA;yHAF/B,4BAA4B;6HAA5B,4BAA4B,cAFzB,MAAM;2FAET,4BAA4B;kBAHxC,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","sourcesContent":["import { Injectable } from \"@angular/core\";\nimport { coerceNumberProperty } from \"@angular/cdk/coercion\";\nimport { CdkDragDrop, CdkDragEnd, CdkDragStart, copyArrayItem, moveItemInArray, transferArrayItem } from \"@angular/cdk/drag-drop\";\nimport { TranslateService } from \"@ngx-translate/core\";\nimport { PepAddonService, PepGuid, PepHttpService, PepScreenSizeType, PepSessionService, PepUtilitiesService } from \"@pepperi-addons/ngx-lib\";\nimport { IPepDraggableItem } from \"@pepperi-addons/ngx-lib/draggable-items\";\nimport { DataViewScreenSize, ScreenSizeDataConfiguration } from \"@pepperi-addons/papi-sdk\";\nimport { PepSnackBarData, PepSnackBarService } from \"@pepperi-addons/ngx-lib/snack-bar\";\nimport { Observable, BehaviorSubject, Subject } from 'rxjs';\nimport { debounceTime, distinctUntilChanged, filter } from 'rxjs/operators';\nimport { LayoutEditorType, IEditor, IPepLayoutBlockAddedEvent, ILayoutEditor, IPepLayoutSection, IPepLayoutSectionColumn, IPepLayoutView, ILayoutSectionEditor, PepLayoutSizeType, IPepLayoutBlockContainer } from \"./layout-builder.model\";\nimport { PepDialogData, PepDialogService } from \"@pepperi-addons/ngx-lib/dialog\";\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class LayoutBuilderInternalService {\n    static readonly AVAILABLE_BLOCKS_CONTAINER_ID = 'availableBlocks';\n    static readonly MAIN_EDITOR_ID = 'main';\n\n    private _defaultSectionTitle = '';\n    \n    private _blocksLimitNumber = 0;\n    setBlocksLimitNumber(value: number) {\n        this._blocksLimitNumber = value;\n    }\n    \n    private _editorsBreadCrumb = Array<IEditor>();\n\n    private _editMode: boolean = false;\n    get editMode(): boolean {\n        return this._editMode;\n    }\n    setEditMode(value: boolean) {\n        this._editMode = value;\n        this.setEditableState();\n    }\n\n    private _editableState: boolean = false;\n    get editableState(): boolean {\n        return this._editableState;\n    }\n\n    // This subject is for the screen size change events.\n    private _screenSizeSubject: BehaviorSubject<PepScreenSizeType> = new BehaviorSubject<PepScreenSizeType>(PepScreenSizeType.XL);\n    get screenSizeChange$(): Observable<PepScreenSizeType> {\n        return this._screenSizeSubject.asObservable().pipe(distinctUntilChanged());\n    }\n    \n    // This subject is for demostrate the container size (Usage only in edit mode).\n    private _screenWidthSubject: BehaviorSubject<string> = new BehaviorSubject<string>('100%');\n    get screenWidthChange$(): Observable<string> {\n        return this._screenWidthSubject.asObservable().pipe(distinctUntilChanged());\n    }\n\n    // This subject is for load the current editor (Usage only in edit mode).\n    private _editorSubject: BehaviorSubject<IEditor | null> = new BehaviorSubject<IEditor | null>(null);\n    get editorChange$(): Observable<IEditor | null> {\n        return this._editorSubject.asObservable().pipe(distinctUntilChanged());\n    }\n\n    // This is the sections columns drop list subject.\n    private _sectionsColumnsDropListSubject: BehaviorSubject<any[]> = new BehaviorSubject<any[]>([]);\n    get sectionsColumnsDropListChange$(): Observable<any[]> {\n        return this._sectionsColumnsDropListSubject.asObservable();\n    }\n\n    // This is the sections subject (a pare from the layout view object)\n    private _sectionsViewSubject: BehaviorSubject<IPepLayoutSection[]> = new BehaviorSubject<IPepLayoutSection[]>([]);\n    get sectionsChange$(): Observable<IPepLayoutSection[]> {\n        return this._sectionsViewSubject.asObservable();\n        // (prevSections, nextSections) => JSON.stringify(prevSections) === JSON.stringify(nextSections)));\n    }\n\n    // This subject is for layout view change.\n    private _layoutViewSubject: BehaviorSubject<IPepLayoutView | null> = new BehaviorSubject<IPepLayoutView | null>(null);\n    get layoutViewChange$(): Observable<IPepLayoutView | null> {\n        return this._layoutViewSubject.asObservable().pipe(filter(layout => !!layout));\n    }\n\n    // This subject is for edit mode when block is dragging now or not.\n    private _draggingBlockKey: BehaviorSubject<string> = new BehaviorSubject('');\n    get draggingBlockKey(): Observable<string> {\n        return this._draggingBlockKey.asObservable().pipe(distinctUntilChanged());\n    }\n\n    // This subject is for edit mode when section is dragging now or not.\n    private _draggingSectionKey: BehaviorSubject<string> = new BehaviorSubject('');\n    get draggingSectionKey(): Observable<string> {\n        return this._draggingSectionKey.asObservable().pipe(distinctUntilChanged());\n    }\n\n    // This subject is for lock or unlock the screen (Usage only in edit mode).\n    private _lockScreenSubject: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\n    get lockScreenChange$(): Observable<boolean> {\n        return this._lockScreenSubject.asObservable().pipe(distinctUntilChanged());\n    }\n\n    // This is for control the preview mode (for load the blocks with the CPI events) \n    private _previewModeSubject: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\n    get previewModeChange$(): Observable<boolean> {\n        return this._previewModeSubject.asObservable().pipe(distinctUntilChanged());\n    }\n\n    // This is for editor mode for block added.\n    private _blockAddedEventSubject = new BehaviorSubject<IPepLayoutBlockAddedEvent | null>(null);\n    get blockAddedEventSubject$(): Observable<IPepLayoutBlockAddedEvent | null> {\n        return this._blockAddedEventSubject.asObservable();\n    }\n    // This is for editor mode for blocks removed.\n    private _blocksRemovedEventSubject = new BehaviorSubject<string[]>([]);\n    get blocksRemovedEventSubject$(): Observable<string[]> {\n        return this._blocksRemovedEventSubject.asObservable();\n    }\n\n    // This subject is for skeleton.\n    private _showSkeletonSubject: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(true);\n    get showSkeletonChange$(): Observable<boolean> {\n        return this._showSkeletonSubject.asObservable().pipe(distinctUntilChanged());\n    }\n    \n    // This subjects is for load the available blocks to drag into map for better performance.\n    private _availableBlocksForDragMap = new Map<string, IPepDraggableItem>();\n    get availableBlocksForDragMap(): ReadonlyMap<string, IPepDraggableItem> {\n        return this._availableBlocksForDragMap;\n    }\n    private _availableBlocksForDragMapSubject = new BehaviorSubject<ReadonlyMap<string, IPepDraggableItem>>(this.availableBlocksForDragMap);\n    get availableBlocksForDragMapChange$(): Observable<ReadonlyMap<string, IPepDraggableItem>> {\n        return this._availableBlocksForDragMapSubject.asObservable();\n    }\n\n    constructor(\n        protected translate: TranslateService,\n        protected dialogService: PepDialogService,\n    ) {\n        //\n        this._defaultSectionTitle = this.translate.instant('LAYOUT_BUILDER.SECTION');\n    }\n    \n    private setEditableState() {\n        this._editableState = this.editMode && !this._previewModeSubject.getValue();\n    }\n\n    private notifyLayoutViewChange(layoutViewToUpdate: IPepLayoutView | null) {\n        if (layoutViewToUpdate) {\n            if (this.editMode) {\n                this.updateLayoutEditorProperties(layoutViewToUpdate);\n            }\n\n            // Update the layout for the view.\n            this._layoutViewSubject.next(layoutViewToUpdate);\n            \n            // Update the sections for the view.\n            this._sectionsViewSubject.next(layoutViewToUpdate?.Layout.Sections || []);\n        }\n    }\n\n    private notifyBlockAdded(blockAddedEventData: IPepLayoutBlockAddedEvent) {\n        // Notify that the block is added (to raise the event for the client).\n        this._blockAddedEventSubject.next(blockAddedEventData);\n    }\n\n    private notifyBlocksRemoved(keys: string[] | undefined) {\n        if (keys) {\n            // Notify that the blocks are removed (to raise the event for the client).\n            this._blocksRemovedEventSubject.next(keys);\n        }\n    }\n\n    private notifyEditorChange(editor: IEditor | null) {\n        this._editorSubject.next(editor);\n    }\n\n    private notifyAvailableBlocksForDragMapChange() {\n        this._availableBlocksForDragMapSubject.next(this.availableBlocksForDragMap);\n    }\n\n    private notifyPreviewModeChange(value: boolean) {\n        this._previewModeSubject.next(value);\n        this.setEditableState();\n    }\n\n    private notifyLockScreen(value: boolean) {\n        this._lockScreenSubject.next(value);\n    }\n\n    private notifySectionsColumnsDropListChange(sectionsColumnsDropList: any[]) {\n        this._sectionsColumnsDropListSubject.next(sectionsColumnsDropList);\n    }\n\n    private updateLayoutEditorProperties(layoutView: IPepLayoutView) {\n        if (this._editorsBreadCrumb[0]) {\n            const layoutEditor: ILayoutEditor = {\n                maxWidth: layoutView?.Layout.MaxWidth || 0,\n                verticalSpacing: layoutView?.Layout.VerticalSpacing,\n                horizontalSpacing: layoutView?.Layout.HorizontalSpacing,\n                sectionsGap: layoutView?.Layout.SectionsGap,\n                columnsGap: layoutView?.Layout.ColumnsGap,\n                // roundedCorners: layoutView?.layout.\n            };\n            \n            this._editorsBreadCrumb[0].hostObject = layoutEditor;\n        }\n    }\n\n    private loadDefaultEditor(layoutView: IPepLayoutView) {\n        this._editorsBreadCrumb = new Array<IEditor>();\n\n        if (layoutView) {\n            this._editorsBreadCrumb.push({\n                id: LayoutBuilderInternalService.MAIN_EDITOR_ID,\n                type : 'layout-builder',\n                title: layoutView.Title || this.translate.instant('LAYOUT_BUILDER.DEFAULT_TITLE'),\n                // hostObject: {} // Updates in updateLayoutEditorProperties function above.\n            });\n\n            this.updateLayoutEditorProperties(layoutView);\n            this.notifyEditorChange(this._editorsBreadCrumb[0]);\n        } else {\n            this.notifyEditorChange(null);\n        }\n    }\n\n    private changeCurrentEditor() {\n        if (this._editorsBreadCrumb.length > 0) {\n            this.notifyEditorChange(this._editorsBreadCrumb[this._editorsBreadCrumb.length - 1]);\n        }\n    }\n\n    private getEditorByType(editorType: LayoutEditorType, id: string): IEditor | null {\n        // Build editor object.\n        let editor: IEditor | null = null;\n\n        if (editorType === 'section') {\n            editor = this.getSectionEditor(id);\n        } else if (editorType === 'block') {\n            editor = this.getBlockEditor(id);\n        }\n\n        return editor;\n    }\n\n    private getBlockEditor(blockKey: string): IEditor {\n        const blockContainer = this.getBlockContainerByBlockKey(blockKey);\n        const defaultTitle = this.translate.instant('LAYOUT_BUILDER.NO_TITLE')\n        let blockTitle = defaultTitle;\n\n        if (blockContainer) {\n            blockTitle = this.availableBlocksForDragMap?.get(blockContainer?.DraggableItemKey)?.title || defaultTitle;\n        }\n \n        return {\n            id: blockKey,\n            type: 'block',\n            title: blockTitle,\n            // remoteModuleOptions: remoteLoaderOptions,\n            hostObject: {} // JSON.parse(JSON.stringify(hostObject))\n        }\n    }\n\n    private getSectionEditorTitle(section: IPepLayoutSection, sectionIndex: number): string {\n        return section.Name || `${this._defaultSectionTitle} ${sectionIndex + 1}`;\n    }\n\n    private getSectionEditor(sectionId: string): IEditor | null {\n        const layoutView = this._layoutViewSubject.getValue();\n        const sections = layoutView?.Layout.Sections || [];\n        const sectionIndex = sections.findIndex(section => section.Key === sectionId);\n\n        if (sectionIndex >= 0) {\n            let section = sections[sectionIndex];\n            const sectionEditor: ILayoutSectionEditor = {\n                id: section.Key,\n                sectionName: section.Name || '',\n                split: section.Split || undefined,\n                height: section.Height || 0,\n                collapseOnTablet: section.CollapseOnTablet ?? false,\n                fillHeight: section.FillHeight ?? false\n            }\n\n            return {\n                id: sectionId,\n                type: 'section',\n                title: this.getSectionEditorTitle(section, sectionIndex),\n                hostObject: sectionEditor\n            }\n        } else {\n            return null;\n        }\n    }\n\n    private getSectionColumnByIdForEditor(sectionColumnId: string): IPepLayoutSectionColumn | null {\n        let currentColumn = null;\n\n        // Get the section and column array by the pattern of the section column key.\n        const sectionColumnPatternSeparator = this.getSectionColumnKey();\n        const sectionColumnArr = sectionColumnId.split(sectionColumnPatternSeparator);\n\n        if (sectionColumnArr.length === 2) {\n            const layoutView = this._layoutViewSubject.getValue();\n            const sections = layoutView?.Layout.Sections || [];\n            \n            // Get the section id to get the section index.\n            const sectionId = sectionColumnArr[0];\n            const sectionIndex = sections.findIndex(section => section.Key === sectionId);\n            // Get the column index.\n            const columnIndex = coerceNumberProperty(sectionColumnArr[1], -1);\n            if (sectionIndex >= 0 && columnIndex >= 0) {\n                currentColumn = sections[sectionIndex].Columns[columnIndex];\n            }\n        }\n\n        return currentColumn;\n    }\n\n    // private setSectionsColumnsGap(layoutView: IPepLayoutView) {\n    //     if (layoutView?.Layout?.Sections) {\n    //         for (let index = 0; index < layoutView.Layout.Sections.length; index++) {\n    //             const section = layoutView.Layout.Sections[index];\n    //             section.ColumnsGap = layoutView.Layout.ColumnsGap;\n    //         }\n    //     }\n    // }\n\n    private getCssScreenWidh(screenType: DataViewScreenSize): string {\n        let widthToSet = '100%';\n\n        if (screenType === 'Tablet') {\n            widthToSet = '720';\n        } else if (screenType === 'Phablet') {\n            widthToSet = '360';\n        }\n\n        return widthToSet;\n    }\n    \n    private getBlockContainerByBlockKey(blockKey: string): IPepLayoutBlockContainer | undefined {\n        let blockContainerToFind: IPepLayoutBlockContainer | undefined = undefined;\n\n        const layoutView = this._layoutViewSubject.getValue();\n        const sections = layoutView?.Layout.Sections || [];\n        \n        for (let sectionIndex = 0; sectionIndex < sections.length; sectionIndex++) {\n            const section = sections[sectionIndex];\n\n            // Get the block container.\n            const columnIndex = section.Columns.findIndex(column => column.BlockContainer?.BlockKey === blockKey);\n            if (columnIndex > -1) {\n                blockContainerToFind = section.Columns[columnIndex].BlockContainer\n                break;\n            }\n        }\n\n        return blockContainerToFind;\n    }\n    \n    private getBlocksNumber(): number {\n        let blocksNumber = 0;\n        const sections = this._layoutViewSubject.getValue()?.Layout.Sections || [];\n\n        for (let index = 0; index < sections.length; index++) {\n            const section = sections[index];\n        \n            for (let columnIndex = 0; columnIndex < section.Columns.length; columnIndex++) {\n                const column = section.Columns[columnIndex];\n                if (column.BlockContainer && column.BlockContainer.BlockKey?.length > 0) {\n                    blocksNumber++;\n                }\n            }\n        }\n\n        return blocksNumber;\n    }\n\n    private changeCursorOnDragStart() {\n        document.body.classList.add('inheritCursors');\n        document.body.style.cursor = 'grabbing';\n    }\n\n    private changeCursorOnDragEnd() {\n        document.body.classList.remove('inheritCursors');\n        document.body.style.cursor = 'unset';\n    }\n\n    \n    /***********************************************************************************************/\n    /*                                  Public functions\n    /***********************************************************************************************/\n\n    setSectionsColumnsDropListChange(sectionsColumnsDropList: any[]) {\n        this.notifySectionsColumnsDropListChange(sectionsColumnsDropList);\n    }\n\n    setLockScreen(value: boolean) {\n        this.notifyLockScreen(value);\n    }\n\n    changePreviewMode(value: boolean) {\n        this.notifyPreviewModeChange(value);\n    }\n\n    setAvailableBlocksToDrag(availableBlocksForDrag: Array<IPepDraggableItem>) {\n        this._availableBlocksForDragMap.clear();\n        availableBlocksForDrag.forEach(block => {\n            this._availableBlocksForDragMap.set(block.data.key, block);\n        });\n\n        this.notifyAvailableBlocksForDragMapChange();\n    }\n\n    getCurrentScreenType(): DataViewScreenSize {\n        return this.getScreenType(this._screenSizeSubject.getValue());\n    }\n\n    getScreenType(size: PepScreenSizeType): DataViewScreenSize {\n        const screenType: DataViewScreenSize =\n            size < PepScreenSizeType.MD ? 'Landscape' :\n            (size === PepScreenSizeType.MD || size === PepScreenSizeType.SM ? 'Tablet' : 'Phablet');\n\n        return screenType;\n    }\n\n    getSectionColumnKey(sectionKey: string = '', index: string = '') {\n        return `${sectionKey}_column_${index}`;\n    }\n\n    getIsHidden(hideIn: DataViewScreenSize[] | undefined, currentScreenType: DataViewScreenSize) {\n        return (hideIn && hideIn?.length > 0) ? hideIn.some(hi => hi === currentScreenType) : false;\n    }\n\n    navigateToEditor(editorType: LayoutEditorType, id: string): boolean {\n        let success = false;\n\n        // Cannot navigate into 'layout-builder' because this is first and const in the editorsBreadCrumbs.\n        if (editorType !== 'layout-builder' && id?.length > 0) {\n            // Check which editor we have now\n            const currentEditor = this._editorsBreadCrumb[this._editorsBreadCrumb.length - 1];\n\n            // Only if it's another editor.\n            if(currentEditor.id !== id) {\n                if (currentEditor.type !== 'layout-builder') {\n                    // Always pop the last and insert the current.\n                    this._editorsBreadCrumb.pop();\n                }\n\n                let editor = this.getEditorByType(editorType, id);\n\n                if (editor) {\n                    this._editorsBreadCrumb.push(editor);\n                    this.changeCurrentEditor();\n                    success = true;\n                } else {\n                    success = false;\n                }\n            }\n        }\n\n        return success;\n    }\n\n    navigateBackFromEditor() {\n        // Keep the layout builder editor.\n        if (this._editorsBreadCrumb.length > 1) {\n            // Maybe we want to compare the last editor for validation ?\n            const lastEditor = this._editorsBreadCrumb.pop();\n            this.changeCurrentEditor();\n        }\n    }\n\n    updateLayoutFromEditor(editorData: ILayoutEditor) {\n        const layoutView = this._layoutViewSubject.getValue();\n\n        if (layoutView) {\n            layoutView.Layout.MaxWidth = editorData.maxWidth;\n            layoutView.Layout.HorizontalSpacing = editorData.horizontalSpacing;\n            layoutView.Layout.VerticalSpacing = editorData.verticalSpacing;\n            layoutView.Layout.SectionsGap = editorData.sectionsGap;\n            layoutView.Layout.ColumnsGap = editorData.columnsGap;\n            // layoutView.layout.RoundedCorners = editorData.roundedCorners;\n\n            // this.setSectionsColumnsGap(layoutView);\n            \n            this.notifyLayoutViewChange(layoutView);\n        }\n    }\n    \n    updateSectionFromEditor(sectionData: ILayoutSectionEditor) {\n        const layoutView = this._layoutViewSubject.getValue();\n        const sections = layoutView?.Layout.Sections || [];\n        const sectionIndex = sections.findIndex(section => section.Key === sectionData.id);\n\n        // Update section details.\n        if (sectionIndex >= 0) {\n            const blocksIdsToRemove = [];\n\n            const currentSection = sections[sectionIndex];\n            currentSection.Name = sectionData.sectionName;\n            currentSection.Split = sectionData.split;\n            currentSection.Height = sectionData.height;\n            currentSection.CollapseOnTablet = sectionData.collapseOnTablet;\n            currentSection.FillHeight = sectionData.fillHeight;\n\n            // Get the new columns number from currentSection.Split, if its undefined put a default 1.\n            const newColumnsLength = currentSection.Split?.split(' ').length || 1;\n            if (newColumnsLength > currentSection.Columns.length) {\n                while (newColumnsLength > currentSection.Columns.length) {\n                    currentSection.Columns.push({});\n                }\n            } else if (newColumnsLength < currentSection.Columns.length) {\n                while (newColumnsLength < currentSection.Columns.length) {\n                    const colunm = currentSection.Columns.pop();\n                    // If there is block in this column delete it.\n                    if (colunm && colunm.BlockContainer) {\n                        blocksIdsToRemove.push(colunm.BlockContainer.BlockKey);\n                    }\n                }\n            }\n\n            // Update editor title\n            const currentEditor = this._editorSubject.getValue();\n            if (currentEditor && currentEditor.type === 'section' && currentEditor.id === currentSection.Key) {\n                const title = this.getSectionEditorTitle(currentSection, sectionIndex);\n                currentEditor.title = title;\n                this.notifyEditorChange(currentEditor);\n            }\n\n            // Update sections change.\n            this.notifyLayoutViewChange(layoutView);\n\n            // If there are blocks to remove, notify the blocks removed.\n            if (blocksIdsToRemove.length > 0) {\n                this.notifyBlocksRemoved(blocksIdsToRemove);\n            }\n        }\n    }\n\n    addSection(section: IPepLayoutSection | null = null) {\n        // Create new section\n        if (!section) {\n            section = {\n                Key: PepGuid.newGuid(),\n                Columns: [{}], // Add empty section column\n                Hide: []\n            }\n        }\n\n        // Add the new section to layout view.\n        const layoutView = this._layoutViewSubject.getValue();\n        const sections = layoutView?.Layout.Sections || [];\n        sections.push(section);\n        this.notifyLayoutViewChange(layoutView);\n    }\n\n    removeSection(sectionId: string) {\n        const layoutView = this._layoutViewSubject.getValue();\n        const sections = layoutView?.Layout.Sections || [];\n        const index = sections.findIndex(section => section.Key === sectionId);\n        if (index > -1) {\n            // Get the blocks id's to remove.\n            const blocksIdsToRemove: any = sections[index].Columns.map(column => column?.BlockContainer?.BlockKey);\n\n            // Remove section.\n            sections.splice(index, 1);\n            this.notifyLayoutViewChange(layoutView);\n\n            // If there are blocks to remove, notify the blocks removed.\n            if (blocksIdsToRemove.length > 0) {\n                this.notifyBlocksRemoved(blocksIdsToRemove)\n            }\n        }\n    }\n\n    hideSection(sectionId: string, hideIn: DataViewScreenSize[]) {\n        const layoutView = this._layoutViewSubject.getValue();\n        const sections = layoutView?.Layout.Sections || [];\n        const index = sections.findIndex(section => section.Key === sectionId);\n        if (index > -1) {\n            sections[index].Hide = hideIn;\n            this.notifyLayoutViewChange(layoutView);\n        }\n    }\n\n    onSectionDropped(event: CdkDragDrop<any[]>) {\n        const layoutView = this._layoutViewSubject.getValue();\n        const sections = layoutView?.Layout.Sections || [];\n        moveItemInArray(sections, event.previousIndex, event.currentIndex);\n        this.notifyLayoutViewChange(layoutView);\n    }\n\n    onSectionDragStart(event: CdkDragStart) {\n        this.changeCursorOnDragStart();\n        this._draggingSectionKey.next(event.source.data);\n    }\n\n    onSectionDragEnd(event: CdkDragEnd) {\n        this.changeCursorOnDragEnd();\n        this._draggingSectionKey.next('');\n    }\n\n    removeBlockFromSection(blockId: string) {\n        let blockRemoved = false;\n\n        // Remove the block from section column.\n        const layoutView = this._layoutViewSubject.getValue();\n        const sections = layoutView?.Layout.Sections || [];\n        \n        for (let sectionIndex = 0; sectionIndex < sections.length; sectionIndex++) {\n            const section = sections[sectionIndex];\n\n            // Remove the block container.\n            const columnIndex = section.Columns.findIndex(column => column.BlockContainer?.BlockKey === blockId);\n            if (columnIndex > -1) {\n                delete section.Columns[columnIndex].BlockContainer;\n                this.notifyLayoutViewChange(layoutView);\n                blockRemoved = true;\n\n                break;\n            }\n        }\n\n        // If the block was removed, notify the block removed.\n        if (blockRemoved) {\n            this.notifyBlocksRemoved([blockId]);\n        }\n    }\n\n    hideBlock(sectionId: string, blockId: string, hideIn: DataViewScreenSize[]) {\n        const layoutView = this._layoutViewSubject.getValue();\n        const sections = layoutView?.Layout.Sections || [];\n        \n        const index = sections.findIndex(section => section.Key === sectionId);\n        if (index > -1) {\n            const columnIndex = sections[index].Columns.findIndex(column => column.BlockContainer?.BlockKey === blockId);\n            if (columnIndex > -1) {\n                const blockContainer = sections[index].Columns[columnIndex].BlockContainer;\n                if (blockContainer) {\n                    blockContainer.Hide = hideIn;\n                    this.notifyLayoutViewChange(layoutView);\n                }\n            }\n        }\n    }\n\n    onBlockDropped(event: CdkDragDrop<IPepLayoutSectionColumn, any, any>, sectionId: string) {\n        const layoutView = this._layoutViewSubject.getValue();\n\n        if (event.previousContainer.id === LayoutBuilderInternalService.AVAILABLE_BLOCKS_CONTAINER_ID) {\n            // Validate if blocks number allow.\n            if (this._blocksLimitNumber > 0 && this.getBlocksNumber() >= this._blocksLimitNumber) {\n                const data = new PepDialogData({\n                    title: this.translate.instant('MESSAGES.DIALOG_NOTICE_TITLE'),\n                    content: this.translate.instant('LAYOUT_BUILDER.BLOCKS_COUNT_LIMIT_MESSAGE'),\n                });\n\n                this.dialogService.openDefaultDialog(data);\n            } else {\n                // Get the block relation (previousContainer.data is IPepDraggableItem and inside we have AvailableBlock object).\n                const draggableItem: IPepDraggableItem = event.previousContainer.data[event.previousIndex] as IPepDraggableItem;\n\n                if (draggableItem) {\n                    // lock the screen untill the editor will be loaded.\n                    // this._lockScreenSubject.next(true);\n\n                    // Get the column.\n                    const currentColumn = this.getSectionColumnByIdForEditor(event.container.id);\n\n                    // Set the block key in the section block only if there is a blank column.\n                    if (currentColumn && !currentColumn.BlockContainer) {\n                        // Generate the block uuid.\n                        const blockKey = PepGuid.newGuid();\n\n                        currentColumn.BlockContainer = {\n                            BlockKey: blockKey,\n                            DraggableItemKey: draggableItem.data.key,\n                        };\n\n                        // Here we update the layout view cause the layout is updated.\n                        this.notifyLayoutViewChange(layoutView);\n\n                        // Raise block added event.\n                        const blockAddedEventData: IPepLayoutBlockAddedEvent = {\n                            BlockKey: blockKey,\n                            DraggableItem: draggableItem,\n                        }\n                        this.notifyBlockAdded(blockAddedEventData);\n\n                        // Navigate to the block editor.\n                        this.navigateToEditor('block', blockKey);\n                    }\n                } else {\n                    console.log(\"draggableItem is not a IPepDraggableItem type\");\n                }\n            }\n        } else {\n            // If the block moved between columns in the same section or between different sections but not in the same column.\n            if (event.container.id !== event.previousContainer.id) {\n                // Get the column.\n                const currentColumn = this.getSectionColumnByIdForEditor(event.container.id);\n                // Get the previous column.\n                const previuosColumn = this.getSectionColumnByIdForEditor(event.previousContainer.id);\n\n                if (currentColumn && previuosColumn) {\n                    currentColumn.BlockContainer = previuosColumn.BlockContainer;\n                    delete previuosColumn.BlockContainer;\n                    this.notifyLayoutViewChange(layoutView);\n                }\n            }\n        }\n    }\n\n    onBlockDragStart(event: CdkDragStart) {\n        this.changeCursorOnDragStart();\n        // Take the block key if exist, else take the available block key (relation key).\n        const blockKey = event.source.data?.BlockKey || event.source.data?.Key;\n        this._draggingBlockKey.next(blockKey);\n    }\n\n    onBlockDragEnd(event: CdkDragEnd) {\n        this.changeCursorOnDragEnd();\n        this._draggingBlockKey.next('');\n    }\n    \n    doesColumnContainBlock(sectionId: string, columnIndex: number): boolean {\n        let res = false;\n        const layoutView = this._layoutViewSubject.getValue();\n        const section = layoutView?.Layout.Sections.find(section => section.Key === sectionId);\n\n        if (section && columnIndex >= 0 && section.Columns.length > columnIndex) {\n            res = !!section.Columns[columnIndex].BlockContainer;\n        }\n\n        return res;\n    }\n\n    setScreenWidth(screenType: DataViewScreenSize) {\n        const value = this.getCssScreenWidh(screenType)\n\n        let width = coerceNumberProperty(value, 0);\n        if (width === 0) {\n            this._screenWidthSubject.next('100%');\n            this._screenSizeSubject.next(PepScreenSizeType.XL);\n        } else {\n            this._screenWidthSubject.next(`${width}px`);\n\n            // Change the size according the width.\n            if (width >= 1920) {\n                this._screenSizeSubject.next(PepScreenSizeType.XL);\n            } else if (width >= 1280 && width < 1920) {\n                this._screenSizeSubject.next(PepScreenSizeType.LG);\n            } else if (width >= 960 && width < 1280) {\n                this._screenSizeSubject.next(PepScreenSizeType.MD);\n            } else if (width >= 600 && width < 960) {\n                this._screenSizeSubject.next(PepScreenSizeType.SM);\n            } else if (width < 600) {\n                this._screenSizeSubject.next(PepScreenSizeType.XS);\n            }\n        }\n    }\n\n    showSkeleton(show: boolean) {\n        this._showSkeletonSubject.next(show);\n    }\n    \n    loadLayoutBuilder(layoutView: IPepLayoutView): void {\n        if (this.editMode) {\n            // Load the layout editor.\n            this.loadDefaultEditor(layoutView);\n\n            // Set the columns gap of the sections.\n            // this.setSectionsColumnsGap(layoutView);\n        }\n\n        // Load only the layout view.\n        this.notifyLayoutViewChange(layoutView);\n    }\n}\n"]}