devexpress-reporting 23.2.0-build-000-1111 → 23.2.2-beta

package/viewer/editing/models/popupImageEditingField.js

@@ -1,94 +1,107 @@
-/**
-* DevExpress HTML/JS Reporting (viewer\editing\models\popupImageEditingField.js)
-* Version:  23.2.1-build-23191-1448
-* Build date: Jul 10, 2023
-* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
-* License: https://www.devexpress.com/Support/EULAs/universal.xml
-*/
-import * as $ from 'jquery';
-import * as ko from 'knockout';
+/**
+* DevExpress HTML/JS Reporting (viewer\editing\models\popupImageEditingField.js)
+* Version:  23.2.2-beta
+* Build date: Nov 13, 2023
+* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { $dx, getParentContainer } from '@devexpress/analytics-core/analytics-internal-native';
+import { createViewModelGenerator, mutable } from '@devexpress/analytics-core/analytics-serializer-native';
 import { ImageEditingFieldViewModel } from './imageEditingField';
 export class PopupImageEditingFieldViewModel extends ImageEditingFieldViewModel {
     constructor() {
         super(...arguments);
-        this.parentPopupClass = 'dxrp-editing-field-popup-container';
+        this._parentPopupClass = 'dxrp-editing-field-popup-container';
         this._popupInitializedClass = 'dxrp-editing-field-popup-container-initialized';
-        this._getPopupContainer = (element) => $.fn.constructor(element).closest('.' + this.parentPopupClass);
-        this._getPainterModel = (element) => {
-            var $painter = this._getPopupContainer(element).find('.dx-painter');
-            return $painter.length ? ko.dataFor($painter[0]) : null;
-        };
-        this._getPictureEditorModel = (element) => {
-            var $popupEditing = $.fn.constructor(element).find('.dx-picture-editing');
-            return $popupEditing.length ? ko.dataFor($popupEditing[0]) : null;
-        };
+        this._getPopupContainer = (element) => $dx(element).closest('.' + this._parentPopupClass);
         this._resetPictureEditor = (pictureEditorModel) => {
             pictureEditorModel.reset(this.painterData.imageSource, this.painterData.alignment, this.painterData.sizeMode, this.painterData.imageType);
             this._resetPainter(pictureEditorModel.painter);
         };
         this._resetPainter = (painter) => {
-            painter.imagePainter.format(painter.imageFormatByType(this.getImageType()));
-            painter.imagePainter.sizeMode(this.sizeMode());
-            painter.imagePainter.alignment(this.alignment());
-            painter.imagePainter.image(this.getImage());
+            painter.imagePainter.format = painter.imageFormatByType(this.getImageType());
+            painter.imageSizeMode = this.sizeMode;
+            painter.imageAlignment = this.alignment;
+            painter.image = this.getImage();
             painter.refresh();
         };
+        this.canActivateEditor = true;
         this.template = 'dxrp-popup-editing-field-image';
     }
-    isPopupActive(element) {
-        return this.active() && this._getPopupContainer(element).hasClass(this._popupInitializedClass);
-    }
-    getPainter() {
+    _getPainterOptions() {
         if (this.painterData == null) {
             this.painterData = {
                 imageSource: this.getImage(),
                 imageType: this.getImageType(),
-                alignment: this.alignment(),
-                sizeMode: this.sizeMode(),
-                zoom: this.zoom,
-                canDraw: ko.observable(false)
+                alignment: this.alignment,
+                sizeMode: this.sizeMode,
+                editingFieldModel: this,
+                setPainter: (painter) => this.painter = painter
             };
         }
         return this.painterData;
     }
-    getPopupData() {
-        var _showContent = ko.observable(false);
-        this.popupData = {
-            contentData: this,
-            paintData: this.painterData,
-            contentTemplate: 'dxrp-editing-field-image-editor',
-            isVisible: (element) => this.isPopupActive(element),
-            getPositionTarget: (element) => this._getPopupContainer(element),
-            shading: this.shadingEnabled,
-            showContent: _showContent,
-            onShown: (e) => {
-                _showContent(true);
-            },
-            onHiding: (e) => {
-                this._getPictureEditorModel(e.component._$popupContent[0]).painter.signaturePainter.resetLastPosition();
-                this._resetPainter(this._getPainterModel(e.element));
-                document.activeElement['blur']();
-                this.active(false);
-            },
-            onContentReady: (e) => {
-                this._resetPainter(this._getPainterModel(e.element));
-                e.component && e.component.registerKeyHandler('tab', (_) => {
-                    this.popupData.onHiding(e);
-                });
-            },
-            renderedHandler: (element, model) => {
-                this._resetPictureEditor(this._getPictureEditorModel(element));
-            }
-        };
-        return this.popupData;
+    createViewModel() {
+        const viewModel = createViewModelGenerator(super.createViewModel())
+            .generateProperty('parentPopupClass', this._parentPopupClass)
+            .generateProperty('getPainterOptions', () => this._getPainterOptions())
+            .generateProperty('popupData', createViewModelGenerator()
+            .generateProperty('contentTemplate', 'dxrp-editing-field-image-editor')
+            .generateProperty('visible', this.active)
+            .generateProperty('getPositionTarget', (element) => this._getPopupContainer(element).element)
+            .generateProperty('shading', this.shadingEnabled)
+            .generateProperty('showContent', this._showContent)
+            .generateProperty('onShown', () => this._showContent = true)
+            .generateProperty('onHiding', (event) => {
+            this.pictureEditor.painter.signaturePainter.resetLastPosition();
+            this._resetPainter(this.painter);
+            document.activeElement['blur']();
+            this.active = false;
+            this._showContent = false;
+        })
+            .generateProperty('onContentReady', (event) => {
+            this._resetPainter(this.painter);
+            event.component && event.component.registerKeyHandler('tab', (_) => {
+                viewModel.popupData.onHiding(event);
+            });
+        })
+            .generateProperty('renderedHandler', () => this._renderedHandler())
+            .generateProperty('getPopupContainer', getParentContainer)
+            .getViewModel())
+            .getViewModel();
+        return viewModel;
+    }
+    _renderedHandler() {
+        this._resetPictureEditor(this.pictureEditor);
+    }
+    _setPictureEditor(editor) {
+        this.pictureEditor = editor;
+    }
+    updateViewModel(args) {
+        super.updateViewModel(args);
+        const viewModel = this.getViewModel();
+        if (args.propertyName === 'active')
+            viewModel.popupData.visible = this.active;
+        if (args.propertyName === '_showContent')
+            viewModel.popupData.showContent = this._showContent;
     }
     activateEditor(viewModel, e) {
-        if (!this.field.readOnly()) {
+        if (!this.field.readOnly) {
             var _parentPopup = this._getPopupContainer(e.target);
             if (!_parentPopup.hasClass(this._popupInitializedClass))
                 _parentPopup.addClass(this._popupInitializedClass);
-            this.active(true);
+            this.active = true;
         }
     }
+    deferredUpdateViewModel() { return false; }
 }
+__decorate([
+    mutable(false)
+], PopupImageEditingFieldViewModel.prototype, "_showContent", void 0);
 export var DefaultImageEditingFieldViewModel = PopupImageEditingFieldViewModel;

package/viewer/editing/models/textEditingField.d.ts

@@ -1,31 +1,74 @@
-/**
-* DevExpress HTML/JS Reporting (viewer\editing\models\textEditingField.d.ts)
-* Version:  23.2.1-build-23191-1448
-* Build date: Jul 10, 2023
-* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
-* License: https://www.devexpress.com/Support/EULAs/universal.xml
-*/
-import { IEditingFieldViewModel, EditingField, IBounds } from '../editingField';
-import * as ko from 'knockout';
-export declare class TextEditingFieldViewModelBase {
-    keypressAction(data: any, event: any): void;
+/**
+* DevExpress HTML/JS Reporting (viewer\editing\models\textEditingField.d.ts)
+* Version:  23.2.2-beta
+* Build date: Nov 13, 2023
+* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+import { IEditingFieldModel, EditingField, IBounds } from '../editingField';
+import { getParentContainer } from '@devexpress/analytics-core/analytics-internal-native';
+import { PreviewPage } from '../../internal/_page';
+import { ArrayPropertyChangedEventArgs, PropertyChangedEventArgs } from '@devexpress/analytics-core/analytics-serializer-native';
+import { IEditingFieldViewModelBase, EditingFieldBase } from './editingFieldBase';
+export interface ITextEditingFieldViewModelBase extends IEditingFieldViewModelBase {
+    textStyle: {
+        [key: string]: string;
+    };
     hideEditor: (shouldCommit: boolean) => void;
+    keypressAction: (data: any, event: any) => void;
 }
-export declare class TextEditingFieldViewModel extends TextEditingFieldViewModelBase implements IEditingFieldViewModel {
-    constructor(field: EditingField, pageWidth: number, pageHeight: number, zoom: ko.Observable<number> | ko.Computed<number>, bounds: IBounds);
-    dispose?: () => void;
+export declare class TextEditingFieldViewModelBase<T extends ITextEditingFieldViewModelBase> extends EditingFieldBase<T> {
+    keypressAction(data: ITextEditingFieldData, event: KeyboardEvent): void;
+    createViewModel(): T;
+    canActivateEditor: boolean;
+    activateEditor(model: EditingFieldBase<IEditingFieldViewModelBase>, event: {
+        target: EventTarget;
+        currentTarget: EventTarget;
+    }, elementFocused?: boolean): void;
+    hideEditor: (shouldCommit: boolean) => void;
+    textStyle: {
+        [key: string]: string;
+    };
+}
+export interface ITextEditingFieldData {
+    value: string | Date;
+    textStyle: {
+        [key: string]: string;
+    };
+    hideEditor: (shouldCommit: boolean) => void;
+    keypressAction: (data: ITextEditingFieldData, event: KeyboardEvent) => void;
+    options: any;
+    getOptions: (options: any) => any;
+    getPopupContainer: typeof getParentContainer;
+}
+export interface ITextEditingFieldViewModel extends ITextEditingFieldViewModelBase {
+    borderStyle: {
+        [key: string]: string;
+    };
+    breakOffsetStyle: {
+        [key: string]: string;
+    };
+    wordWrap: boolean;
+    editorTemplate: string;
+    data: ITextEditingFieldData;
+}
+export declare class TextEditingFieldViewModel extends TextEditingFieldViewModelBase<ITextEditingFieldViewModel> implements IEditingFieldModel {
+    constructor(field: EditingField<string>, pageWidth: number, pageHeight: number, page: PreviewPage, bounds: IBounds);
+    onPropertyChanged(args: PropertyChangedEventArgs<EditingFieldBase> | ArrayPropertyChangedEventArgs<EditingFieldBase>): void;
+    createViewModel(): ITextEditingFieldViewModel;
+    dispose: () => void;
     template: string;
     editorTemplate: string;
     field: EditingField;
-    data: any;
-    textStyle: () => {};
-    containerStyle: () => {};
-    breakOffsetStyle: () => {};
-    borderStyle: () => {};
-    zoom: ko.Observable<number> | ko.Computed<number>;
-    htmlValue: () => string;
+    data: ITextEditingFieldData;
+    breakOffsetStyle: {
+        [key: string]: string;
+    };
+    borderStyle: {
+        [key: string]: string;
+    };
     wordWrap: boolean;
-    active: ko.Observable<boolean>;
-    activateEditor(viewModel: any, e: any): void;
+    canActivateEditor: boolean;
+    activateEditor(viewModel: TextEditingFieldViewModel, e: MouseEvent): void;
 }
 export declare function focusTextElement(target: HTMLElement): void;

package/viewer/editing/models/textEditingField.js

@@ -1,18 +1,22 @@
-/**
-* DevExpress HTML/JS Reporting (viewer\editing\models\textEditingField.js)
-* Version:  23.2.1-build-23191-1448
-* Build date: Jul 10, 2023
-* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
-* License: https://www.devexpress.com/Support/EULAs/universal.xml
-*/
+/**
+* DevExpress HTML/JS Reporting (viewer\editing\models\textEditingField.js)
+* Version:  23.2.2-beta
+* Build date: Nov 13, 2023
+* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
 import { brickStyleSerializationsInfo } from '../../../common/metadata';
-import { EditingFieldExtensions } from '../../../common/utils/editingFieldExtensions';
-import { ModelSerializer } from '@devexpress/analytics-core/analytics-utils';
-import { processTextEditorHotKeys, CssCalculator } from '@devexpress/analytics-core/analytics-internal';
-import * as ko from 'knockout';
-import * as $ from 'jquery';
-export class TextEditingFieldViewModelBase {
+import { EditingFieldExtensions, ___isCancelFlag } from '../../../common/utils/editingFieldExtensions';
+import { processTextEditorHotKeys, CssCalculator, $dx, extend, getParentContainer } from '@devexpress/analytics-core/analytics-internal-native';
+import { createViewModelGenerator, currentModelSerializer, currentMultiPlatformEngine } from '@devexpress/analytics-core/analytics-serializer-native';
+import { EditingFieldBase } from './editingFieldBase';
+export class TextEditingFieldViewModelBase extends EditingFieldBase {
+    constructor() {
+        super(...arguments);
+        this.canActivateEditor = true;
+    }
     keypressAction(data, event) {
+        this.field._editorValue = event.target['value'];
         processTextEditorHotKeys(event, {
             esc: () => {
                 this.hideEditor(false);
@@ -22,69 +26,86 @@ export class TextEditingFieldViewModelBase {
             }
         });
     }
+    createViewModel() {
+        return createViewModelGenerator(super.createViewModel())
+            .generateProperty('textStyle', this.textStyle)
+            .getViewModel();
+    }
+    activateEditor(model, event, elementFocused = false) {
+        const eventTarget = event === null || event === void 0 ? void 0 : event.currentTarget;
+        if (!elementFocused) {
+            setTimeout(() => {
+                focusTextElement(eventTarget);
+            });
+        }
+    }
 }
 export class TextEditingFieldViewModel extends TextEditingFieldViewModelBase {
-    constructor(field, pageWidth, pageHeight, zoom, bounds) {
-        super();
+    constructor(field, pageWidth, pageHeight, page, bounds) {
+        super(page);
         this.template = 'dxrp-editing-field-container';
-        this.htmlValue = () => this.field.htmlValue();
         this.wordWrap = true;
-        this.active = ko.observable(false);
+        this.canActivateEditor = true;
         var brickStyle = field.model().brickOptions;
         var style = { rtl: () => brickStyle.rtl };
-        new ModelSerializer().deserialize(style, JSON.parse(brickStyle.style), brickStyleSerializationsInfo);
-        var cssCalculator = new CssCalculator(style, ko.observable(!!brickStyle.rtlLayout));
+        currentModelSerializer().deserialize(style, JSON.parse(brickStyle.style), brickStyleSerializationsInfo);
+        var cssCalculator = new CssCalculator(style, !!brickStyle.rtlLayout);
         var padding = cssCalculator.paddingsCss();
         var verticalPadding = parseInt(padding['paddingTop']) + parseInt(padding['paddingBottom']);
         if (cssCalculator.borderCss()['borderTop'] !== 'none') {
-            verticalPadding += style['borderWidth']();
+            verticalPadding += currentMultiPlatformEngine.unwrap(style['borderWidth']);
         }
         if (cssCalculator.borderCss()['borderBottom'] !== 'none') {
-            verticalPadding += style['borderWidth']();
+            verticalPadding += currentMultiPlatformEngine.unwrap(style['borderWidth']);
         }
-        this.breakOffsetStyle = () => {
-            return {
-                top: bounds.offset.y * -100 / bounds.height + '%',
-                left: bounds.offset.x * -100 / bounds.width + '%'
-            };
+        this.breakOffsetStyle = {
+            top: bounds.offset.y * -100 / bounds.height + '%',
+            left: bounds.offset.x * -100 / bounds.width + '%'
         };
-        this.textStyle = () => $.extend({}, cssCalculator.fontCss(), cssCalculator.foreColorCss(), cssCalculator.textAlignmentCss());
-        this.zoom = zoom;
+        this.textStyle = extend({}, cssCalculator.fontCss(), cssCalculator.foreColorCss(), cssCalculator.textAlignmentCss());
         this.field = field;
         if (brickStyle.wordWrap != undefined) {
             this.wordWrap = brickStyle.wordWrap;
         }
         this.hideEditor = (shouldCommit) => {
             setTimeout(() => {
-                if (shouldCommit) {
+                if (shouldCommit && this.active) {
                     if (editorOptions.onHideEditor) {
                         editorOptions.onHideEditor(field);
                     }
                     else {
-                        field.editValue(field._editorValue());
+                        field.setEditValue(field._editorValue);
                     }
                 }
                 else {
-                    field._editorValue(field.editValue());
+                    field._editorValue = field.getEditValue();
                 }
-                this.active(false);
+                this.active = false;
             }, 1);
         };
         var editor = EditingFieldExtensions.instance().editor(field.editorName());
-        var editorOptions = $.extend(true, {}, editor && editor.options || {});
-        this.data = {
-            value: field._editorValue,
-            hideEditor: this.hideEditor,
-            keypressAction: this.keypressAction,
-            textStyle: this.textStyle,
-            options: editorOptions,
-            getOptions: (templateOptions) => { return $.extend({}, this.data.options, templateOptions); }
-        };
+        var editorOptions = extend(true, {}, (editor === null || editor === void 0 ? void 0 : editor.options) || {});
+        this.data = createViewModelGenerator().createDefaultModel(this)
+            .generateProperty('value', field._editorValue)
+            .generateProperty('hideEditor', (shouldCommit) => this.hideEditor(shouldCommit))
+            .generateProperty('keypressAction', (data, event) => this.keypressAction(data, event))
+            .generateProperty('textStyle', this.textStyle)
+            .generateProperty('options', editorOptions)
+            .generateProperty('getPopupContainer', getParentContainer)
+            .generateProperty('getOptions', (templateOptions) => extend({}, this.data.options, templateOptions))
+            .getViewModel();
         var isCustomEditor = !!(editor && editor.template && editor.template !== 'dxrp-editing-field-datetime');
         if (!isCustomEditor) {
             var self = this;
-            this.data.options = $.extend(true, {}, editorOptions, {
+            this.data.options = extend(true, {}, editorOptions, {
                 value: field._editorValue,
+                onValueChanged: (event) => {
+                    if (!event.component[___isCancelFlag]) {
+                        (editorOptions === null || editorOptions === void 0 ? void 0 : editorOptions.onValueChanged) && (editorOptions === null || editorOptions === void 0 ? void 0 : editorOptions.onValueChanged(event));
+                        this.field._editorValue = event.value;
+                        this.data.options.value = event.value;
+                    }
+                },
                 onFocusOut: (e) => {
                     self.hideEditor(true);
                 }
@@ -96,50 +117,72 @@ export class TextEditingFieldViewModel extends TextEditingFieldViewModelBase {
         else {
             this.editorTemplate = 'dxrp-editing-field-text';
         }
-        this.containerStyle = ko.pureComputed(() => {
-            return $.extend({
+        this._updateContainerStyle = () => {
+            if (!bounds)
+                return;
+            this.containerStyle = extend({
                 width: bounds.width + 'px',
                 height: bounds.height + 'px',
                 'line-height': (bounds.height - verticalPadding) + 'px',
                 top: bounds.top * 100 / pageHeight + '%',
                 left: bounds.left * 100 / pageWidth + '%',
-                cursor: this.field.readOnly() ? 'auto' : 'text'
-            }, this.active() || !this.htmlValue() ? cssCalculator.borderCss() : { border: 'none' }, isCustomEditor && this.active() || (!!this.htmlValue() && !this.active()) ? { padding: 0 } : cssCalculator.paddingsCss(), { 'border-color': 'transparent' });
-        });
-        this.borderStyle = ko.pureComputed(() => {
-            if (style['borderWidth']() > 0 && style['borders']() !== 'None') {
-                return {
-                    left: '-' + style['borderWidth']() + 'px',
-                    top: '-' + style['borderWidth']() + 'px',
-                    paddingRight: (style['borderWidth']() * 2 - 2) + 'px',
-                    paddingBottom: (style['borderWidth']() * 2 - 2) + 'px'
-                };
-            }
-        });
+                cursor: this.field.readOnly ? 'auto' : 'text'
+            }, this.active || !this.field.htmlValue ? cssCalculator.borderCss() : { border: 'none' }, isCustomEditor && this.active || (!!this.field.htmlValue && !this.active) ? { padding: 0 } : cssCalculator.paddingsCss(), { 'border-color': 'transparent' });
+        };
+        const borderWidth = currentMultiPlatformEngine.unwrap(style['borderWidth']);
+        const borders = currentMultiPlatformEngine.unwrap(style['borders']);
+        if (borderWidth && borderWidth > 0 && borders !== 'None') {
+            this.borderStyle = {
+                left: '-' + borderWidth + 'px',
+                top: '-' + borderWidth + 'px',
+                paddingRight: (borderWidth * 2 - 2) + 'px',
+                paddingBottom: (borderWidth * 2 - 2) + 'px'
+            };
+        }
+        this.addDisposable(this.field.events.on('htmlValueChanged', (args) => {
+            this._updateContainerStyle();
+        }), this.field.events.on('readOnlyChanged', (args) => {
+            this._updateContainerStyle();
+        }), this.field.events.on('_editorValueChanged', (args) => {
+            this.data.value = this.field._editorValue;
+        }));
+        this._updateContainerStyle();
+    }
+    onPropertyChanged(args) {
+        if (args.propertyName === 'active')
+            this._updateContainerStyle();
+    }
+    createViewModel() {
+        return createViewModelGenerator(super.createViewModel())
+            .generateProperty('borderStyle', this.borderStyle)
+            .generateProperty('breakOffsetStyle', this.breakOffsetStyle)
+            .generateProperty('wordWrap', this.wordWrap)
+            .generateProperty('editorTemplate', this.editorTemplate)
+            .generateProperty('data', this.data)
+            .getViewModel();
     }
     activateEditor(viewModel, e) {
-        if (this.field.readOnly() || this.active()) {
+        if (this.field.readOnly || this.active) {
             return;
         }
         var data = viewModel.data;
         if (data && data.options && data.options.onPreRender) {
-            data.options.onPreRender(this.data);
+            data.options.onPreRender(this.data, this.field);
         }
-        this.active(true);
+        this.active = true;
         var elementFocused = false;
-        if (viewModel.options && viewModel.options.onEditorShown) {
-            elementFocused = viewModel.options.onEditorShown(this.data, $.fn.constructor(e && e.currentTarget).first().get(0));
-        }
-        if (!elementFocused) {
-            focusTextElement(e && e.currentTarget);
+        const options = viewModel['options'];
+        if (options === null || options === void 0 ? void 0 : options.onEditorShown) {
+            elementFocused = options.onEditorShown(this.data, e === null || e === void 0 ? void 0 : e.currentTarget);
         }
+        super.activateEditor(viewModel, e, elementFocused);
     }
 }
 export function focusTextElement(target) {
-    var element = $.fn.constructor(target).find('input').eq(0)[0];
+    var element = $dx(target).find('input:visible').element || $dx(target).find('textarea:visible').element;
     if (!element)
-        element = $.fn.constructor(target).find('textarea').eq(0)[0];
-    element.focus();
+        return;
+    element === null || element === void 0 ? void 0 : element.focus();
     if (element['setSelectionRange']) {
         element['setSelectionRange'](element['value'].length, element['value'].length);
     }

package/viewer/exportOptions/csvExportOptionsPreview.d.ts

@@ -1,10 +1,10 @@
-/**
-* DevExpress HTML/JS Reporting (viewer\exportOptions\csvExportOptionsPreview.d.ts)
-* Version:  23.2.1-build-23191-1448
-* Build date: Jul 10, 2023
-* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
-* License: https://www.devexpress.com/Support/EULAs/universal.xml
-*/
+/**
+* DevExpress HTML/JS Reporting (viewer\exportOptions\csvExportOptionsPreview.d.ts)
+* Version:  23.2.2-beta
+* Build date: Nov 13, 2023
+* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
 import { CsvExportOptions } from '../../common/exportOptions/csvExportOptions';
 export declare class CsvExportOptionsPreview extends CsvExportOptions {
     isPropertyVisible(name: string): boolean;

package/viewer/exportOptions/csvExportOptionsPreview.js

@@ -1,10 +1,10 @@
-/**
-* DevExpress HTML/JS Reporting (viewer\exportOptions\csvExportOptionsPreview.js)
-* Version:  23.2.1-build-23191-1448
-* Build date: Jul 10, 2023
-* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
-* License: https://www.devexpress.com/Support/EULAs/universal.xml
-*/
+/**
+* DevExpress HTML/JS Reporting (viewer\exportOptions\csvExportOptionsPreview.js)
+* Version:  23.2.2-beta
+* Build date: Nov 13, 2023
+* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
 import { CsvExportOptions } from '../../common/exportOptions/csvExportOptions';
 import { useCustomSeparator } from '../../common/exportOptions/metadata';
 export class CsvExportOptionsPreview extends CsvExportOptions {

package/viewer/exportOptions/docxExportOptionsPreview.d.ts

@@ -1,12 +1,12 @@
-/**
-* DevExpress HTML/JS Reporting (viewer\exportOptions\docxExportOptionsPreview.d.ts)
-* Version:  23.2.1-build-23191-1448
-* Build date: Jul 10, 2023
-* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
-* License: https://www.devexpress.com/Support/EULAs/universal.xml
-*/
+/**
+* DevExpress HTML/JS Reporting (viewer\exportOptions\docxExportOptionsPreview.d.ts)
+* Version:  23.2.2-beta
+* Build date: Nov 13, 2023
+* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
 import { DocxExportOptions } from '../../common/exportOptions/docxExportOptions';
-import { ISerializationInfoArray } from '@devexpress/analytics-core/analytics-utils';
+import { ISerializationInfoArray } from '@devexpress/analytics-core/analytics-utils-native';
 export declare class DocxExportOptionsPreview extends DocxExportOptions {
     static toJson(value: any, serializer: any, refs: any): any;
     getInfo(): ISerializationInfoArray;

package/viewer/exportOptions/docxExportOptionsPreview.js

@@ -1,10 +1,10 @@
-/**
-* DevExpress HTML/JS Reporting (viewer\exportOptions\docxExportOptionsPreview.js)
-* Version:  23.2.1-build-23191-1448
-* Build date: Jul 10, 2023
-* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
-* License: https://www.devexpress.com/Support/EULAs/universal.xml
-*/
+/**
+* DevExpress HTML/JS Reporting (viewer\exportOptions\docxExportOptionsPreview.js)
+* Version:  23.2.2-beta
+* Build date: Nov 13, 2023
+* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
 import { pageRange, docxTableLayout, rasterizeImages, rasterizationResolution, exportPageBreaks, exportWatermarks, docxExportMode } from '../../common/exportOptions/metadata';
 import { keepRowHeight } from '../../common/exportOptions/rtfMetaData';
 import { docxDocumentOptions } from '../../common/exportOptions/docxMetaData';
@@ -41,6 +41,6 @@ export class DocxExportOptionsMergedPreview extends DocxExportOptionsPreview {
     }
     constructor(model, serializer) {
         super(model, serializer);
-        this.docxExportMode(excludeModesForMergedDocuments(this.docxExportMode())());
+        this._set('docxExportMode', excludeModesForMergedDocuments);
     }
 }

package/viewer/exportOptions/exportOptionsModel.d.ts

@@ -1,11 +1,11 @@
-/**
-* DevExpress HTML/JS Reporting (viewer\exportOptions\exportOptionsModel.d.ts)
-* Version:  23.2.1-build-23191-1448
-* Build date: Jul 10, 2023
-* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
-* License: https://www.devexpress.com/Support/EULAs/universal.xml
-*/
-import { Disposable, TabInfo } from '@devexpress/analytics-core/analytics-utils';
+/**
+* DevExpress HTML/JS Reporting (viewer\exportOptions\exportOptionsModel.d.ts)
+* Version:  23.2.2-beta
+* Build date: Nov 13, 2023
+* Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+import { Disposable, TabInfoWithPropertyGrid } from '@devexpress/analytics-core/analytics-utils-native';
 import { ReportPreview } from '../reportPreview';
 export declare class ExportOptionsModel extends Disposable {
     private _reportPreview;
@@ -18,7 +18,7 @@ export declare class ExportOptionsModel extends Disposable {
     getActions(context: any): any[];
     dispose(): void;
     actions: any[];
-    tabInfo: TabInfo;
+    tabInfo: TabInfoWithPropertyGrid;
 }
 export declare class ExportOptionsEventHandlers {
     private _menuButton;