core-cde/dist/core-cde/stateChanger/src/Operations.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Operations = void 0;
const tslib_1 = require("tslib");
const Errors_1 = require("./Errors");
const Page_1 = require("./Page");
const Text_1 = require("./descriptiveClasses/Text");
const List_1 = require("./descriptiveClasses/List");
const TypeComponent_1 = require("./TypeComponent");
const Widget_1 = require("./descriptiveClasses/Widget");
const DM = (0, tslib_1.__importStar)(require("../../data/Data.module"));
/**
 * Выполняемые операции для изменения компонента
 */
class Operations {
    /**
     * Переименовать документ
     * @param action Действие
     * @param state Состояние
     * @returns Состояние документа
     */
    renameDocument(action, state) {
        var _a;
        if (!state || !((_a = action === null || action === void 0 ? void 0 : action.props) === null || _a === void 0 ? void 0 : _a.name)) {
            throw new Errors_1.EmptyParametersError('renameDocument');
        }
        try {
            if (typeof state === 'string') {
                state = JSON.parse(state);
                state.name = action.props.name;
                return JSON.stringify(state);
            }
            state.name = action.props.name;
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Создать документ
     * @param action Действие для создания документа
     * @returns JSON Документ
     */
    createDocument(action) {
        if (!action) {
            throw new Errors_1.EmptyParametersError('createDocument');
        }
        try {
            return JSON.stringify(action.props);
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Создать страницу
     * @param action Действие для создания страницы
     * @param state Состояния документа
     * @returns Новое состояние документа
     */
    createPage(action, state, ds) {
        if (!action || !action.props) {
            throw new Errors_1.EmptyParametersError('createPage');
        }
        // TODO переписать этот код
        try {
            let page;
            if (action.props.jsonPage) {
                page = Page_1.Page.fromJSON(action.props.jsonPage);
                if (action.props.jsonWidgets) {
                    const widgets = JSON.parse(action.props.jsonWidgets);
                    widgets.forEach(element => {
                        const widget = Widget_1.Widget.createWidgetByJSON(JSON.stringify(element), ds);
                        page.widgets.add(widget);
                    });
                    ds === null || ds === void 0 ? void 0 : ds.refreshAfterRestore();
                }
            }
            else {
                page = new Page_1.Page(action.props.name, action.props.id);
            }
            if (!state) {
                return JSON.stringify(page);
            }
            if (action.prev_guid) {
                const prevWidgetIndex = state.pages.toArray().findIndex(val => val.id === action.prev_guid);
                const prevWidget = state.pages.getNodeByIndex(prevWidgetIndex);
                if (!prevWidget) {
                    throw new Errors_1.ElementNotFoundError('createPage');
                }
                state.pages.addAfter(prevWidget, page);
            }
            else {
                state.pages.addFirst(page);
            }
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Удалить страницу
     * @param action Действие для удаление страницы
     * @param state Состояния документа
     * @returns Новое состояние документа
     */
    removePage(action, state, ds) {
        if (!action || !state || !state.pages) {
            throw new Errors_1.EmptyParametersError('removePage');
        }
        try {
            const page = state.pages.toArray().find(val => val.id === action.props.id);
            if (page) {
                page.removeDataTableFromDataSet(ds); // Удаляем все DataTabe из DataSet
                // state.makeAllPagesInactive();
                state.pages.remove(page);
            }
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Переименовать страницу
     * @param action Действие
     * @param state Состояния документа
     * @returns Новое состояние документа
     */
    renamePage(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('createPage');
        }
        if (typeof state === 'string') {
            const page = Page_1.Page.fromJSON(state);
            page.name = action.props.nameNew;
            return JSON.stringify(page);
        }
        else {
            const page = state.pages.toArray().find(val => val.id === action.props.id);
            if (page) {
                page.name = action.props.nameNew;
            }
            return state;
        }
    }
    /**
     * Сделать страницу активной
     * @param action Действие для выбора страницы
     * @param state Состояние документа
     * @returns Новое состояние документа
     */
    selectPage(action, state) {
        state.pages.toArray().map(val => val.active = false);
        const page = state.pages.toArray().find(val => val.id === action.props.idNew);
        if (page) {
            page.active = true;
        }
        return state;
    }
    /**
     * Создать виджет
     * @param action Действие для создания виджета
     * @param state Состояния страницы
     * @returns Новое состояние страницы
     */
    createWidget(action, state) {
        if (!action) {
            throw new Errors_1.EmptyParametersError('createWidget');
        }
        try {
            const widget = action.props.jsonWidget ?
                Widget_1.Widget.createWidgetByJSON(action.props.jsonWidget) :
                Widget_1.Widget.createWidgetByType(action.props.type, action.props.id);
            if (!state) {
                return JSON.stringify(widget);
            }
            state.widgets.insert(action.index, widget);
            if (List_1.List.isList(widget.type)) {
                this._recListLevels((action === null || action === void 0 ? void 0 : action.index) || state.widgets.count - 1, state);
            }
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Изменить тип компонента
     * @param action Действие для изменения типа компонента
     * @param state Состояние страницы
     * @returns Новое состояние страницы
     */
    changeTypeWidget(action, state) {
        var _a;
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('changeTypeWidget');
        }
        if (typeof state === 'string') {
            const widget = JSON.parse(state);
            widget.type = action.props.newType;
            return JSON.stringify(widget);
        }
        const index = state.widgets.toArray().findIndex(widget => widget.id === action.props.id);
        const widgetNode = state.widgets.getNodeByIndex(index);
        const widget = widgetNode.value;
        if (!widget) {
            throw new Errors_1.ElementNotFoundError('changeTypeWidget');
        }
        widget.type = action.props.newType;
        const newWidget = Widget_1.Widget.createWidgetByJSON(JSON.stringify(widget));
        state.widgets.set(index, newWidget);
        // FIXME пересчет если это List
        if (List_1.List.isList(widget.type)) {
            this._recListLevels(index, state);
        }
        else if (List_1.List.isList((_a = widgetNode === null || widgetNode === void 0 ? void 0 : widgetNode.next) === null || _a === void 0 ? void 0 : _a.value.type)) {
            this._recListLevels(index + 1, state);
        }
        return state;
    }
    /**
     * Удалить виджет
     * @param action Действие для удаление виджета
     * @param state Состояния страницы
     * @returns Новое состояние страницы
     */
    removeWidget(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('removeWidget');
        }
        const widget = state.widgets.toArray().find(widget => widget.id === action.props.id);
        if (!widget) {
            throw new Errors_1.ElementNotFoundError('removeWidget');
        }
        state.widgets.remove(widget);
        return state;
    }
    /**
     * Переместить виджет
     * @param action Действие для перемещения виджета
     * @param state Состояния страницы
     * @returns Новое состояние страницы
     */
    transferWidget(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('transferWidget');
        }
        try {
            let curWidgetNode;
            if (action.props.current_prev_guid) {
                curWidgetNode = state.widgets.getNodeById(action.props.current_prev_guid).next;
            }
            else if (action.props.current_next_guid) {
                curWidgetNode = state.widgets.getNodeById(action.props.current_next_guid).previous;
            }
            if (!curWidgetNode) {
                throw new Errors_1.ElementNotFoundError('curWidgetNode');
            }
            const insertWidgetNode = state.widgets.getNodeById(action.props.insert_prev_guid ?
                action.props.insert_prev_guid :
                action.props.insert_next_guid);
            if (action.props.insert_prev_guid) {
                state.widgets.addAfter(insertWidgetNode, curWidgetNode.value);
                state.widgets.removeNode(curWidgetNode);
            }
            else if (action.props.insert_next_guid) {
                state.widgets.addBefor(insertWidgetNode, curWidgetNode.value);
                state.widgets.removeNode(curWidgetNode);
            }
            if (insertWidgetNode.value instanceof List_1.List) {
                List_1.List.down(insertWidgetNode);
            }
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Перенос текста на новый виджет
     * @param action Действие
     * @param state Состояние страницы
     * @returns Новое состояние
     */
    textWrapping(action, state) {
        if (!action || !action.newWidgetId) {
            throw new Errors_1.EmptyParametersError('textWrapping');
        }
        const { textWidget, textNewWidget, listStyleWidget, listStyleNewWidget } = action.props;
        switch (typeof state) {
            case 'string': {
                const widgetNode = Widget_1.Widget.createWidgetByJSON(state);
                widgetNode.value = textWidget;
                widgetNode.styles = listStyleWidget;
                return JSON.stringify(widgetNode);
            }
            case 'undefined': {
                const newWidget = Widget_1.Widget.createWidgetByType(action.props.typeNewWidget, action.newWidgetId);
                newWidget.value = textNewWidget;
                newWidget.styles = listStyleNewWidget;
                return JSON.stringify(newWidget);
            }
            case 'object': {
                const widgetNode = state.widgets.getNodeById(action.widgetId);
                const widget = widgetNode.value;
                widget.value = textWidget;
                widget.styles = listStyleWidget;
                const newWidget = Widget_1.Widget.createWidgetByType(action.props.typeNewWidget, action.newWidgetId);
                newWidget.value = textNewWidget;
                newWidget.styles = listStyleNewWidget;
                state.widgets.addAfter(widgetNode, newWidget);
                // widget?.$eventChangeState.emit(ETextActions.removeText, { startPos: widget.value.length });
                // widget?.$eventChangeState.emit(EventHandlerName, {
                //     type: ETextActions.removeText,
                //     data: { startPos: widget.value.length }
                // } as EventHandler<any>);
                // newWidget?.$eventChangeState.emit(EventHandlerName, {
                //     type: ETextActions.addStyleText,
                //     data: null
                // } as EventHandler<any>);
                // Если список то пересчет позиций
                if (widgetNode.value instanceof List_1.List) {
                    newWidget.level = widgetNode.value.level;
                    List_1.List.down(widgetNode);
                }
                break;
            }
            default:
                break;
        }
        return state;
    }
    /**
     * Обратный перенос текста
     * @param action Действие
     * @param state Состояние страницы
     * @returns Состояние страницы
     */
    textUnWrapping(action, state) {
        if (!action) {
            throw new Errors_1.EmptyParametersError('textWrapping');
        }
        const { textWidget, listStyleWidget } = action.props;
        switch (typeof state) {
            case 'string': {
                const widgetNode = Widget_1.Widget.createWidgetByJSON(state);
                widgetNode.value = textWidget;
                widgetNode.styles = listStyleWidget;
                return JSON.stringify(widgetNode);
            }
            case null:
            case undefined:
                return;
            case 'object': {
                const widgetNode = state.widgets.getNodeById(action.widgetId);
                const removeWidgetNode = state.widgets.getNodeById(action.removeWidgetId);
                state.widgets.removeNode(removeWidgetNode);
                const widget = widgetNode.value;
                widget.value = action.props.textWidget;
                widget.styles = action.props.listStyleWidget;
                // widget?.$eventChangeState.emit(ETextActions.addStyleText);
                // widget?.$eventChangeState.emit(EventHandlerName, {
                //     type: ETextActions.addStyleText,
                //     data: null
                // } as EventHandler<any>);
                break;
            }
            default:
                break;
        }
        return state;
    }
    /**
     * Вставить текст
     * @param action Действие для вставки текста
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    insertText(action, state) {
        const widgetText = (typeof state === 'string') ?
            JSON.parse(state) :
            state;
        const { startPos, value } = action.props;
        if (widgetText.value === null || widgetText.value === undefined) {
            widgetText.value = '';
        }
        // Вставляем текст в startPos позицию
        widgetText.value = widgetText.value.slice(0, startPos) + action.props.value + widgetText.value.slice(startPos);
        // Если есть стили у текста то сдвиг вправо на N количество
        if (widgetText.styles) {
            Operations.shiftStylePosRight(widgetText, startPos, value.length);
        }
        return (typeof state === 'string') ? JSON.stringify(widgetText) : widgetText;
    }
    /**
     * Удалить текст
     * @param action Действие для удаление текста
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    removeText(action, state) {
        const widgetText = (typeof state === 'string') ?
            JSON.parse(state) :
            state;
        // const widgetText: Text = state as Text;
        const { startPos, endPos } = action.props;
        // Вырезаем кусок текста из строки
        const arraySymbol = widgetText.value.split('');
        arraySymbol.splice(action.props.startPos, endPos - startPos);
        widgetText.value = arraySymbol.join('');
        // Сдвигаем стили текста
        if (widgetText.styles) {
            for (let index = endPos; index > startPos; index--) {
                this._shiftStylePosLeft(widgetText, index, 1);
            }
        }
        return (typeof state === 'string') ? JSON.stringify(widgetText) : widgetText;
    }
    /**
     * Обернуть кусок текста стилем Bold
     * @param action Действие
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    addStyleText(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('addStyleText');
        }
        try {
            const widgetText = (typeof state === 'string') ?
                JSON.parse(state) :
                state;
            if (!widgetText.styles) {
                widgetText.styles = [];
            }
            // TODO переписать этот код
            let arrSymbols = Text_1.Text.getPosCharStl(widgetText.value, widgetText.styles);
            arrSymbols = Text_1.Text.addStyle(arrSymbols, action.props.position, action.props.style);
            widgetText.styles = Text_1.Text.groupPosByStyle(arrSymbols);
            widgetText.styles.sort((a, b) => a.position[0] - b.position[0]);
            return (typeof state === 'string') ? JSON.stringify(widgetText) : widgetText;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Выравнивание текста
     * @param action Действие
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    textAlignment(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('textAlignment');
        }
        const textWidget = (typeof state === 'string') ?
            JSON.parse(state) :
            state;
        textWidget.textAlign = action.props.newAlign;
        return (typeof state === 'string') ? JSON.stringify(textWidget) : textWidget;
    }
    /**
     * Удалить стиль из текста
     * @param action Действие
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    removeStyleText(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('removeStyleText');
        }
        // TODO исправить
        const widgetText = state;
        const indexRemove = widgetText.styles.findIndex(val => JSON.stringify(val.position) === JSON.stringify(action.props.position));
        if (indexRemove >= 0) {
            const findStyleIndex = widgetText.styles[indexRemove].style.findIndex(val => val === action.props.style);
            if (findStyleIndex) {
                widgetText.styles[indexRemove].style.splice(findStyleIndex, 1);
            }
            else {
                widgetText.styles.splice(indexRemove, 1);
            }
        }
        widgetText.styles.sort((a, b) => a.position[0] - b.position[0]);
        return state;
    }
    // ========== Lists ==============
    /**
     * Увеличить уровень списка
     * @param action Действие
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    incrementLevel(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('incrementLevel');
        }
        if (typeof state === 'string') {
            const newState = JSON.parse(state);
            newState.level++;
            return JSON.stringify(newState);
        }
        const indexNode = state.widgets.toArray().findIndex(val => val.id === action.widgetId);
        const listNode = state.widgets.getNodeByIndex(indexNode);
        if (!listNode) {
            throw new Errors_1.ElementNotFoundError('incrementLevel');
        }
        if (!listNode.value.level) {
            throw new Error('Not found value level! Method incrementLevel()');
        }
        listNode.value.level++;
        List_1.List.down(listNode);
        return state;
    }
    /**
     * Уменьшить уровень списка
     * @param action Действие
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    deIncrementLevel(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('deIncrementLevel');
        }
        if (typeof state === 'string') {
            const newState = JSON.parse(state);
            newState.level--;
            newState.level = Math.max(newState.level, 1);
            return JSON.stringify(newState);
        }
        const indexNode = state.widgets.toArray().findIndex(val => val.id === action.widgetId);
        const listNode = state.widgets.getNodeByIndex(indexNode);
        if (!listNode) {
            throw new Errors_1.ElementNotFoundError('deIncrementLevel');
        }
        if (!listNode.value.level) {
            throw new Error('Not found value level! Method deIncrementLevel()');
        }
        listNode.value.level--;
        listNode.value.level = Math.max(listNode.value.level, 1);
        List_1.List.down(listNode);
        return state;
    }
    /**
     * Пометить элемент списка
     * @param action Действие
     * @param state Состояние
     * @returns Новое состояние
     */
    checked(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('checked');
        }
        try {
            if (typeof state === 'string') {
                const widget = JSON.parse(state);
                widget.checked = action.props.checked;
                return JSON.stringify(widget);
            }
            const widgetNode = state.widgets.getNodeById(action.widgetId);
            if (!widgetNode) {
                throw new Errors_1.ElementNotFoundError('checked()');
            }
            widgetNode.value.checked = action.props.checked;
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    // ========== TABLE ==============
    /**
     * Создать виджет с таблицей
     * @param action Действие для создания виджета с таблицей
     * @param state Состояние страницы
     * @param ds Новое состояние страницы
     */
    createWidgetTable(action, state, ds) {
        try {
            const widget = Widget_1.Widget.createWidgetByType(TypeComponent_1.TypeComponent.table, action.props.id);
            if (!widget) {
                throw new Error('I can not create a widget with a table');
            }
            if (!state) {
                const widgetObj = {
                    originalPerformance: action.props.originalPerformance || false,
                    idTable: action.tableGuid,
                    viewTableJson: action.props.dataViewJson,
                    tableJson: null,
                    type: TypeComponent_1.TypeComponent.table,
                    id: action.props.id
                };
                return JSON.stringify(widgetObj);
            }
            if (action.props.dataViewJson) {
                const table = action.props.dataTableJson ?
                    ds.addTable(DM.DataTable.fromJSON(action.props.dataTableJson)) :
                    ds.getTableByName(action.props.dataTableName);
                if (!table) {
                    throw new Errors_1.ElementNotFoundError('createWidgetTable() table');
                }
                widget.viewTable = DM.DataView.fromJSON(action.props.dataViewJson);
                widget.viewTable.table = table;
                widget.viewTable.table.rowCollection.updateIndex(0);
                widget.originalPerformance = action.props.dataTableJson ? true : false;
            }
            action.props.indexWidget ?
                state.widgets.insert(action.props.indexWidget - 1, widget) :
                state.widgets.add(widget);
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Удалить виджет с таблицей
     * @param action Действие для удаление виджета с таблицей
     * @param state Состояние страницы
     * @param ds Новое состояние страницы
     */
    removeWidgetTable(action, state, ds) {
        try {
            const widget = state.widgets.toArray().find(widget => widget.id === action.props.id);
            if (!widget) {
                throw new Errors_1.ElementNotFoundError('removeWidgetTable() widget ');
            }
            if (action.props.dataTableJson) {
                ds.removeTableByName(action.props.dataTableName);
            }
            state.widgets.remove(widget);
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Создать представление таблицы
     * @param action Действие для создания
     * @param state Состояние виджета
     * @param ds Новое состояние виджета
     */
    createDataView(action, state, ds) {
        try {
            const idTable = action.props.id;
            // Создаем Таблицу
            if (!state) {
                const table = DM.DataTable.createNew(null, action.props.dataTableName);
                table.id = action.props.id;
                return JSON.stringify(table);
            }
            // Создаем состояние DataView для TableWidget
            if (typeof state === 'string') {
                const tableWidgetJSON = {
                    idTable,
                    originalPerformance: action.props.originalPerformance,
                    type: TypeComponent_1.TypeComponent.table,
                    viewTableJson: action.props.dataViewJson,
                };
                return JSON.stringify(tableWidgetJSON);
            }
            let table;
            if (!action.props.originalPerformance) {
                table = ds.getTableByName(action.props.dataTableName);
            }
            else {
                table = ds.addTable(action.props.dataTableName);
                state.originalPerformance = true;
            }
            table.id = idTable;
            const viewTable = new DM.DataView(action.props.dataViewName, table);
            state.viewTable = viewTable;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Удалить представления таблицы
     * @param action Действие для удаления
     * @param state Состояние страницы
     * @param ds Новое состояние страницы
     */
    removeDataView(action, state, ds) {
        try {
            if (action.props.dataTableName) {
                ds.removeTableByName(action.props.dataTableName);
            }
            state.viewTable = null;
            state.originalPerformance = false;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Добавить колонку
     * @param action Действие для добавления
     * @param state Текущие состояние таблицы
     * @returns Новое состояние таблицы
     */
    addColumn(action, state) {
        if (!action) {
            throw new Errors_1.EmptyParametersError('addColumn');
        }
        try {
            if (!state) {
                const column = {
                    dataType: DM.DataType.String,
                    id: action.props.id,
                    index: action.props.indexColumn,
                    name: action.props.nameColumn,
                };
                return JSON.stringify(column);
            }
            state.viewTable.table.addColumn(action.props.nameColumn, DM.DataType.String);
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Сортировка колонки
     * @param action Действие для сотрировки
     * @param state Текущие состояние таблицы
     * @returns Новое состояние таблицы
     */
    sortColumn(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('sortColumn');
        }
        try {
            if (typeof state === 'string') {
                const newState = JSON.parse(state);
                if (typeof newState.viewTableJson === 'string') {
                    newState.viewTableJson = JSON.parse(newState.viewTableJson);
                }
                newState.viewTableJson.sort = action.props.sort;
                return JSON.stringify(newState);
            }
            state.viewTable.sort = action.props.sort;
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Удалить колонку
     * @param action Действие для удаления
     * @param state Текущие состояние таблицы
     * @returns Новое состояние таблицы
     */
    removeColumn(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('removeColumn');
        }
        try {
            const { indexColumn } = action.props;
            state.viewTable.table.removeColumnByIndex(indexColumn);
        }
        catch (error) {
            throw error;
        }
        return state;
    }
    //    // Создаем Таблицу
    //    if (!state) {
    //     const table = DataTable.createNew(null, action.props.dataTableName);
    //     table.id = action.props.id;
    //     return JSON.stringify(table);
    // }
    // // Создаем состояние DataView для TableWidget
    // if (typeof state === 'string') {
    // const tableWidgetJSON = {
    //     idTable,
    //     originalPerformance: action.props.originalPerformance,
    //     type: TypeComponent.table,
    //     viewTableJson: action.props.dataViewJson,
    // } as TableWidgetJSON;
    /**
     * Переименовать таблицу
     * @param action Действие для переименования
     * @param state Текущие состояние таблицы
     * @returns Новое состояние таблицы
     */
    renameTable(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('renameTable');
        }
        try {
            if (action.props.originalPerformance === true) {
                if (typeof state === 'string') {
                    const newState = JSON.parse(state);
                    newState.uniqueName = action.props.newName;
                    return JSON.stringify(newState);
                }
                state.viewTable.table.uniqueName = action.props.newName;
            }
            else {
                if (typeof state === 'string') {
                    const newState = JSON.parse(state);
                    if (typeof newState.viewTableJson === 'string') {
                        newState.viewTableJson = JSON.parse(newState.viewTableJson);
                    }
                    newState.viewTableJson.uniqueName = action.props.newName;
                    return JSON.stringify(newState);
                }
                state.viewTable.uniqueName = action.props.newName;
                return state;
            }
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Переименовать колонку
     * @param action Действие для переименования колокни
     * @param state Текущие состояние таблицы
     * @returns Новое состояние таблицы
     */
    renameColumn(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('renameColumn');
        }
        try {
            if (typeof state === 'string') {
                const column = JSON.parse(state);
                column.name = action.props.newName;
                return JSON.stringify(column);
            }
            const column = state.viewTable.table.getColumnByName(action.props.oldName);
            if (!column) {
                throw new Errors_1.ElementNotFoundError('renameColumn');
            }
            column.name = action.props.newName;
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Применить фильтр к таблице
     * @param action Действие для фильтра
     * @param state Состояние виджета
     * @param ds DataSet
     * @returns Новое состояние виджета
     */
    applyFilter(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('applyFilter');
        }
        try {
            const filter = new DM.FilterExprestion();
            action.props.filter.forEach(val => {
                const res = Object.assign(new DM.FilterExprestionItem(), val);
                filter.add(res);
            });
            if (typeof state === 'string') {
                const newState = JSON.parse(state);
                const newViewTable = typeof newState.viewTableJson === 'string' ? JSON.parse(newState.viewTableJson) : newState.viewTableJson;
                newViewTable.filter = filter;
                newState.viewTableJson = newViewTable;
                return JSON.stringify(newState);
            }
            state.viewTable.filter = filter;
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Обновить select
     * @param action Действие для Select
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    updateSelect(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('addSelect');
        }
        try {
            if (typeof state === 'string') {
                const newStateColumn = DM.DataColumnSelect.fromJSON(state);
                const select = newStateColumn.dataSelect.getSelectByName(action.props.name);
                if (!select) {
                    throw new Errors_1.ElementNotFoundError('updateSelect');
                }
                select.name = action.props.value;
                select.color = action.props.color;
                return JSON.stringify(newStateColumn);
            }
            const column = state.viewTable.table.getColumnByIndex(action.props.indexColumn);
            if (!column) {
                throw new Errors_1.ElementNotFoundError('updateSelect');
            }
            const select = column.dataSelect.getSelectByName(action.props.name);
            if (!select) {
                throw new Errors_1.ElementNotFoundError('updateSelect');
            }
            select.name = action.props.value;
            select.color = action.props.color;
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Добавить Select в список
     * @param action Действие для Select
     * @param state Состояние виджета
     * @returns Новое состояние
     */
    addSelect(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('addSelect');
        }
        try {
            if (typeof state === 'string') {
                const newStateColumn = DM.DataColumnSelect.fromJSON(state);
                newStateColumn.dataSelect.addSelect(new DM.Select(action.props.value, action.props.color));
                return JSON.stringify(newStateColumn);
            }
            const column = state.viewTable.table.getColumnByIndex(action.props.indexColumn);
            if (!column) {
                throw new Errors_1.ElementNotFoundError('addSelect');
            }
            column.dataSelect.addSelect(new DM.Select(action.props.value, action.props.color));
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Удалить Select
     * @param action Действие для Select
     * @param state Состяоние виджета
     * @returns Новое состояние виджета
     */
    removeSelect(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('removeSelect');
        }
        try {
            if (typeof state === 'string') {
                const newStateColumn = DM.DataColumnSelect.fromJSON(state);
                newStateColumn.dataSelect.removeSelect(action.props.name);
                return JSON.stringify(newStateColumn);
            }
            const column = state.viewTable.table.getColumnByIndex(action.props.indexColumn);
            if (!column) {
                throw new Errors_1.ElementNotFoundError('removeSelect');
            }
            column.dataSelect.removeSelect(action.props.name);
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Изменить тип колонки
     * @param action Действие для работы с колонкой
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    changeTypeColumn(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('changeTypeColumn');
        }
        try {
            if (typeof state === 'string') {
                const newStateColumn = JSON.parse(state);
                // state.viewTable.table.changeTypeColumn(column, action.props.newType);
                newStateColumn.dataType = action.props.newType;
                return JSON.stringify(newStateColumn);
            }
            const column = state.viewTable.table.getColumnByIndex(action.props.indexColumn);
            if (!column) {
                throw new Errors_1.ElementNotFoundError('changeTypeColumn');
            }
            state.viewTable.table.changeTypeColumn(column, action.props.newType);
            // column = column.changeType(action.props.newType)
            // column.dataType = action.props.newType;
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Изменить ширину колонки
     * @param action Действие для работы с колонкой
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    resizeColumn(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('resizeColumn');
        }
        try {
            if (typeof state === 'string') {
                const newStateColumn = JSON.parse(state);
                newStateColumn.width = action.props.width;
                return JSON.stringify(newStateColumn);
            }
            const column = state.viewTable.table.getColumnByIndex(action.props.indexColumn);
            if (!column) {
                throw new Errors_1.ElementNotFoundError('resizeColumn');
            }
            column.width = action.props.width;
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Добавить строку
     * @param action Действие для добавления строки
     * @param state Состояние виджета
     * @param ds DataSet
     * @returns Новое состояние виджета
     */
    addRow(action, state) {
        if (!action) {
            throw new Errors_1.EmptyParametersError('addRow');
        }
        try {
            if (!state) {
                const row = {
                    id: action.props.id,
                    index: action.props.indexRow,
                    items: action.props.data
                };
                return JSON.stringify(row);
            }
            const row = state.viewTable.table.addRow();
            row.id = action.props.id;
            row.index = action.props.indexRow;
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Вставить строку в позицию N
     * @param action Действие для вставки строки
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    insertRow(action, state) {
        var _a;
        if (!action) {
            throw new Errors_1.EmptyParametersError('insertRow');
        }
        try {
            if (!state) {
                const row = {
                    id: action.props.id,
                    index: action.props.indexRow,
                    items: action.props.data
                };
                return JSON.stringify(row);
            }
            state.viewTable.table.insertRow(action.props.indexRow, (_a = action.props.data) === null || _a === void 0 ? void 0 : _a.map(r => r === null || r === void 0 ? void 0 : r.value));
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Вставить колонку
     * @param action Действие для вставки колонки
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    insertColumn(action, state) {
        if (!action) {
            throw new Errors_1.EmptyParametersError('insertColumn');
        }
        try {
            if (!state) {
                const col = new DM.DataColumn();
                col.id = action.props.id;
                col.name = action.props.nameColumn;
                col.index = action.props.indexColumn;
                col.dataType = action.props.dataType;
                return JSON.stringify(col);
            }
            const { indexColumn, nameColumn, data, dataType } = action.props;
            const col = state.viewTable.table.insertColumn(indexColumn, nameColumn, dataType, data === null || data === void 0 ? void 0 : data.map(v => v.value));
            col.id = action.props.id;
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Изменить состояние строки
     * @param stateRow Старое состояние строки
     * @param mapCell Состояние ячейки
     * @returns Новое состояние строки
     */
    changeStateRow(stateRows, rowState) {
        if (!stateRows || !rowState) {
            throw new Errors_1.EmptyParametersError('changeStateRow');
        }
        try {
            const resRowState = JSON.parse(rowState);
            // if (stateRows instanceof Map) {
            //     if (!stateRows.has(resRowState.id)) { throw new ElementNotFoundError('changeStateRow'); }
            //     const row = stateRows.get(resRowState.id);
            //     resRowState.items.push(row);
            //     return JSON.stringify(resRowState);
            // }
            const cell = resRowState.items.find(item => item.guidColumn === stateRows.guidColumn);
            if (!cell) {
                resRowState.items.push(stateRows);
            }
            else {
                cell.value = stateRows.value;
            }
            return JSON.stringify(resRowState);
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Удалить строку
     * @param action Действие для удаления
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    removeRow(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('removeRow');
        }
        try {
            state.viewTable.table.removeRow(action.props.indexRow);
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Вставить значение в ячейку
     * @param action Действие для вставки
     * @param state Состояние виджета
     * @param ds DataSet
     * @returns Новое состояние виджета
     */
    setCellValue(action, state, ds) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('setCellValue');
        }
        try {
            const { rowIndex, columnIndex } = action.props;
            state.viewTable.table.setCellValue(rowIndex, columnIndex, action.props.newValue.value);
            return state;
        }
        catch (error) {
            throw error;
        }
    }
    // ========== Cover ===============
    /**
     * Создать обложку
     * @param action Действие
     * @param state Состояние
     * @returns Новое состояние
     */
    createCover(action, state) {
        if (typeof state === 'string') {
            const page = Page_1.Page.fromJSON(state);
            page.cover = new Page_1.Cover(action.props.image);
            return JSON.stringify(page);
        }
        const page = state;
        page.cover = new Page_1.Cover(action.props.image);
        console.log(action.props.image);
        return page;
    }
    /**
     * Удалить обложку
     * @param action Действие
     * @param state Состояние
     * @returns Новое состояние
     */
    removeCover(action, state) {
        if (typeof state === 'string') {
            const page = Page_1.Page.fromJSON(state);
            page.cover = null;
            return JSON.stringify(page);
        }
        const page = state;
        page.cover = null;
        return page;
    }
    // ========== HyperLink ===============
    /**
     * Изменить Url
     * @param action Действие
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    changeUrl(action, state) {
        var _a, _b, _c, _d;
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('changeUrl');
        }
        if (typeof state === 'string') {
            const newState = JSON.parse(state);
            newState.url = action.props.newUrl;
            newState.widgetId = ((_a = action.props) === null || _a === void 0 ? void 0 : _a.widgetId) || null;
            newState.pageId = ((_b = action.props) === null || _b === void 0 ? void 0 : _b.pageId) || null;
            return JSON.stringify(newState);
        }
        state.url = action.props.newUrl;
        state.widgetId = ((_c = action.props) === null || _c === void 0 ? void 0 : _c.widgetId) || null;
        state.pageId = ((_d = action.props) === null || _d === void 0 ? void 0 : _d.pageId) || null;
        return state;
    }
    /**
     * Изменить текст
     * @param action Действие
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    changeText(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('changeText');
        }
        if (typeof state === 'string') {
            const newState = JSON.parse(state);
            newState.value = action.props.newText;
            return JSON.stringify(newState);
        }
        state.value = action.props.newText;
        return state;
    }
    // ========== VIDEO ===============
    /**
     * Изменить параметры видео виджета
     * @param action Действие
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    changeParamsVideo(action, state) {
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('changeParamsVideo');
        }
        const videoWidget = (typeof state === 'string') ?
            JSON.parse(state) :
            state;
        videoWidget.value = action.props.value;
        videoWidget.width = action.props.width;
        videoWidget.height = action.props.height;
        return (typeof state === 'string') ? JSON.stringify(videoWidget) : videoWidget;
    }
    // ========== IMAGE ===============
    /**
     * Изменить параметры изображения
     * @param action Действие
     * @param state Состояние виджета
     * @returns Новое состояние виджета
     */
    changeParamsImage(action, state) {
        var _a, _b;
        if (!action || !state) {
            throw new Errors_1.EmptyParametersError('changeParamsImage');
        }
        if (typeof state === 'string') {
            const newState = JSON.parse(state);
            newState.data = action.props.data;
            return JSON.stringify(newState);
        }
        state.data = action.props.data;
        state.width = ((_a = action.props) === null || _a === void 0 ? void 0 : _a.width) || null;
        state.height = ((_b = action.props) === null || _b === void 0 ? void 0 : _b.height) || null;
        return state;
    }
    // ========== PRIVATE ===============
    static shiftStylePosRight(textWidget, insertPos, count = 1) {
        if (!(textWidget === null || textWidget === void 0 ? void 0 : textWidget.styles)) {
            return;
        }
        for (const style of textWidget.styles) {
            style.position = style.position.map(pos => (pos >= insertPos) ? pos + count : pos);
        }
    }
    _shiftStylePosLeft(textWidget, insertPos, count = 1) {
        for (const style of textWidget.styles) {
            style.position = style.position.map(pos => (pos >= insertPos) ? pos - count : pos);
        }
    }
    _recListLevels(indexNode, state) {
        const nodeList = state.widgets.getNodeByIndex(indexNode);
        if (!nodeList) {
            return;
        }
        List_1.List.down(nodeList);
    }
}
exports.Operations = Operations;
//# sourceMappingURL=Operations.js.map