devexpress-richedit 24.1.1-alpha-24085-0102 → 24.1.3

package/lib/common/commands/client-command.js

@@ -390,6 +390,7 @@ export var RichEditClientCommand;
     RichEditClientCommand[RichEditClientCommand["DownloadDocx"] = 418] = "DownloadDocx";
     RichEditClientCommand[RichEditClientCommand["DownloadRtf"] = 419] = "DownloadRtf";
     RichEditClientCommand[RichEditClientCommand["DownloadTxt"] = 420] = "DownloadTxt";
+    RichEditClientCommand[RichEditClientCommand["DownloadHtml"] = 421] = "DownloadHtml";
     RichEditClientCommand[RichEditClientCommand["PdfExported"] = 430] = "PdfExported";
     RichEditClientCommand[RichEditClientCommand["ChangeCaseMenu"] = 431] = "ChangeCaseMenu";
     RichEditClientCommand[RichEditClientCommand["AlignParagraphMenu"] = 432] = "AlignParagraphMenu";
@@ -418,4 +419,5 @@ export var RichEditClientCommand;
     RichEditClientCommand[RichEditClientCommand["FloatingObjectBringForwardMenu"] = 455] = "FloatingObjectBringForwardMenu";
     RichEditClientCommand[RichEditClientCommand["FloatingObjectSendBackwardMenu"] = 456] = "FloatingObjectSendBackwardMenu";
     RichEditClientCommand[RichEditClientCommand["NoSpellingSuggestions"] = 457] = "NoSpellingSuggestions";
+    RichEditClientCommand[RichEditClientCommand["GetHtml"] = 458] = "GetHtml";
 })(RichEditClientCommand || (RichEditClientCommand = {}));

package/lib/common/commands/document/print-document-on-client-command.js

@@ -1,4 +1,4 @@
-import { HtmlBuilder } from '../../html-export';
+import { HtmlBuilder } from '../../formats/html/export/html-builder';
 import { RendererClassNames } from '../../canvas/renderer-class-names';
 import { UpdateFieldsOptions } from '../../model/fields/tree-creator';
 import { ControlOptions } from '../../model/options/control';

package/lib/common/commands/text/clipboard-commands.js

@@ -17,6 +17,7 @@ import { SelectionHistoryItem } from '../../model/history/selection/selection-hi
 import { RichEditClientCommand } from '../client-command';
 import { CommandBase, CommandSimpleOptions } from '../command-base';
 import { SimpleCommandState } from '../command-states';
+import { HtmlMimeType, PlainTextMimeType } from '@devexpress/utils/lib/utils/mime-type';
 export class ClipboardCommand extends CommandBase {
     constructor(control, queryCommandId) {
         super(control);
@@ -303,10 +304,10 @@ export class ClipboardHelper {
     }
     insertClipboardItems(items) {
         for (let item of items) {
-            if (ListUtils.anyOf(item.types, type => type === 'text/html'))
-                return this.insertClipboardItem(item, 'text/html', html => this.insertHtml(html));
-            if (ListUtils.anyOf(item.types, type => type === 'text/plain'))
-                return this.insertClipboardItem(item, 'text/plain', text => this.insertPlainText(text));
+            if (ListUtils.anyOf(item.types, type => type === HtmlMimeType))
+                return this.insertClipboardItem(item, HtmlMimeType, html => this.insertHtml(html));
+            if (ListUtils.anyOf(item.types, type => type === PlainTextMimeType))
+                return this.insertClipboardItem(item, PlainTextMimeType, text => this.insertPlainText(text));
         }
         return Promise.reject(ClipboardHelper.noDataInClipboardMessage);
     }
@@ -348,7 +349,8 @@ export class ClipboardHelper {
     writeToClipboard(clipboardData) {
         ClipboardHelper.lastWritenTextHash = -1;
         return new Promise((resolve, reject) => {
-            const exporter = new TxtExporter(this.createModelManager(clipboardData.model).modelManipulator, new DocumentExporterOptions());
+            const modelManager = this.createModelManager(clipboardData.model);
+            const exporter = new TxtExporter(modelManager.modelManipulator, new DocumentExporterOptions());
             exporter.exportToBlob((blob) => __awaiter(this, void 0, void 0, function* () {
                 const text = yield this.readAsText(blob);
                 if (this.useWithBuildInClipboard)

package/lib/common/document-format.d.ts

@@ -16,9 +16,11 @@ export declare const mimeTypeIntoDocumentFormat: {
     4: DocumentFormat;
     2: DocumentFormat;
     3: DocumentFormat;
+    14: DocumentFormat;
 };
 export declare const documentFormatIntoMimeType: {
     4: DxMimeType;
     2: DxMimeType;
     1: DxMimeType;
+    3: DxMimeType;
 };

package/lib/common/document-format.js

@@ -17,9 +17,11 @@ export const mimeTypeIntoDocumentFormat = {
     [DxMimeType.Docm]: DocumentFormat.OpenXml,
     [DxMimeType.Rtf]: DocumentFormat.Rtf,
     [DxMimeType.PlainText]: DocumentFormat.PlainText,
+    [DxMimeType.Html]: DocumentFormat.Html,
 };
 export const documentFormatIntoMimeType = {
     [DocumentFormat.OpenXml]: DxMimeType.OpenXml,
     [DocumentFormat.Rtf]: DxMimeType.Rtf,
     [DocumentFormat.PlainText]: DxMimeType.PlainText,
+    [DocumentFormat.Html]: DxMimeType.Html,
 };

package/lib/common/formats/document-importer-errors.d.ts

@@ -3,5 +3,7 @@ export declare enum DocumentImporterErrors {
     TxtImportError = 1,
     RtfFileReaderError = 2,
     RtfImportError = 3,
-    OpenXmlImportError = 4
+    OpenXmlImportError = 4,
+    HtmlFileReaderError = 5,
+    HtmlImportError = 6
 }

package/lib/common/formats/document-importer-errors.js

@@ -5,4 +5,6 @@ export var DocumentImporterErrors;
     DocumentImporterErrors[DocumentImporterErrors["RtfFileReaderError"] = 2] = "RtfFileReaderError";
     DocumentImporterErrors[DocumentImporterErrors["RtfImportError"] = 3] = "RtfImportError";
     DocumentImporterErrors[DocumentImporterErrors["OpenXmlImportError"] = 4] = "OpenXmlImportError";
+    DocumentImporterErrors[DocumentImporterErrors["HtmlFileReaderError"] = 5] = "HtmlFileReaderError";
+    DocumentImporterErrors[DocumentImporterErrors["HtmlImportError"] = 6] = "HtmlImportError";
 })(DocumentImporterErrors || (DocumentImporterErrors = {}));

package/lib/common/formats/file-name-helper.d.ts

@@ -11,6 +11,7 @@ export declare class FileNameHelper {
     checkExtension(): void;
     static normalizeVirtualFolderPath(folderPath: string, isNormalizePath: boolean): string;
     static convertToDocumentFormat(fileName: string): DocumentFormat;
+    static convertToDocumentExtension(fileName: string): string;
     static convertExtensionToDocumentFormat(extension: string): DocumentFormat;
     static convertToString(docFormat: DocumentFormat): string;
     private static testFormat;

package/lib/common/formats/file-name-helper.js

@@ -49,6 +49,12 @@ export class FileNameHelper {
             return DocumentFormat.WordML;
         return DocumentFormat.Undefined;
     }
+    static convertToDocumentExtension(fileName) {
+        const position = fileName.lastIndexOf('.');
+        const extension = fileName.slice(position);
+        const format = FileNameHelper.convertExtensionToDocumentFormat(extension);
+        return format !== DocumentFormat.Undefined ? extension : '';
+    }
     static convertExtensionToDocumentFormat(extension) {
         switch (extension.toLowerCase()) {
             case "doc":
@@ -58,7 +64,7 @@ export class FileNameHelper {
             case "html":
             case ".html":
             case "htm":
-            case "htm": return DocumentFormat.Html;
+            case ".htm": return DocumentFormat.Html;
             case "mht":
             case ".mht": return DocumentFormat.Mht;
             case "odt":

package/lib/common/formats/html/export/get-html.d.ts

@@ -0,0 +1,4 @@
+import { FixedInterval } from "@devexpress/utils/lib/intervals/fixed";
+import { SubDocument } from "../../../model/sub-document";
+import { IProcessor } from "../../../processor";
+export declare function getHtmlFromSubDocument(processor: IProcessor, subDocument: SubDocument, coreInterval: FixedInterval): string;

package/lib/common/formats/html/export/get-html.js

@@ -0,0 +1,12 @@
+import { EmptyBatchUpdatableObject } from "@devexpress/utils/lib/class/batch-updatable";
+import { ClientModelManager } from "../../../model-manager";
+import { RangeCopy } from "../../../model/manipulators/range/create-range-copy-operation";
+import { SubDocumentIntervals } from "../../../model/sub-document";
+import { HtmlDocumentExporter } from "./html-document-exporter";
+import { DocumentExporterOptions } from "../../options";
+export function getHtmlFromSubDocument(processor, subDocument, coreInterval) {
+    const rangeCopy = RangeCopy.create(new SubDocumentIntervals(subDocument, [coreInterval]));
+    const modelManager = new ClientModelManager(rangeCopy.model, processor.modelManager.richOptions, new EmptyBatchUpdatableObject());
+    const exportModelOptions = processor.getExportModelOptions({ modelManager: modelManager });
+    return new HtmlDocumentExporter(exportModelOptions, new DocumentExporterOptions()).exportAsString();
+}

package/lib/common/formats/html/export/html-builder.d.ts

@@ -0,0 +1,16 @@
+export declare class HtmlBuilder {
+    getHtmlString(needDefaultMarkup?: boolean): string;
+    private _currentElement;
+    childElements: Array<Element | string>;
+    callbacks: Array<(target: HtmlBuilder) => void>;
+    isEmpty(): boolean;
+    clear(): this;
+    startChild(tagName: string, namespaceUri?: string): this;
+    configure<T extends Element = HTMLElement>(config: (element: T) => void): this;
+    addCallback(callback: (target: HtmlBuilder) => void): void;
+    assignFrom(builder: HtmlBuilder | string): this;
+    addElement(element: Element | string): this;
+    addBreak(cssText?: string): this;
+    endChild(tagName: string): this;
+    private addDefaultMarkup;
+}

package/lib/common/formats/html/export/html-builder.js

@@ -0,0 +1,102 @@
+export class HtmlBuilder {
+    constructor() {
+        this.childElements = [];
+        this.callbacks = [];
+    }
+    getHtmlString(needDefaultMarkup = false) {
+        const content = this.childElements.map(x => {
+            if (typeof x === 'string')
+                return x;
+            return x.outerHTML;
+        }).join('');
+        return needDefaultMarkup ? this.addDefaultMarkup(content) : content;
+    }
+    isEmpty() {
+        return this.callbacks.length === 0 && this.childElements.length === 0;
+    }
+    clear() {
+        this._currentElement = null;
+        this.callbacks = [];
+        this.childElements = [];
+        return this;
+    }
+    startChild(tagName, namespaceUri) {
+        const element = (namespaceUri) ? document.createElementNS(namespaceUri, tagName) : document.createElement(tagName);
+        if (this._currentElement)
+            this._currentElement.appendChild(element);
+        else {
+            this.childElements.push(element);
+        }
+        this._currentElement = element;
+        return this;
+    }
+    configure(config) {
+        config(this._currentElement);
+        return this;
+    }
+    addCallback(callback) {
+        this.callbacks.push(callback);
+    }
+    assignFrom(builder) {
+        if (!builder)
+            return this;
+        if (typeof builder === "string") {
+            this.addElement(builder);
+            return this;
+        }
+        builder.callbacks.forEach((callback) => {
+            callback(this);
+        });
+        builder.childElements.forEach((el) => {
+            this.addElement(el);
+        });
+        builder.clear();
+        return this;
+    }
+    addElement(element) {
+        if (!element)
+            return this;
+        if (!this._currentElement) {
+            this.childElements.push(element);
+            return this;
+        }
+        if (typeof element === 'string')
+            this._currentElement.innerHTML += element;
+        else if (this._currentElement)
+            this._currentElement.appendChild(element);
+        else
+            this._currentElement = element;
+        return this;
+    }
+    addBreak(cssText) {
+        this.startChild('br');
+        if (cssText)
+            this.configure((el) => el.style.cssText = cssText);
+        this.endChild('br');
+        return this;
+    }
+    endChild(tagName) {
+        try {
+            let currentElement = this._currentElement;
+            while (currentElement.tagName.toLowerCase() !== tagName.toLowerCase())
+                currentElement = currentElement.parentElement;
+            this._currentElement = currentElement.parentElement;
+        }
+        catch (e) {
+            console.warn(`The element with the ${tagName} tag is not found.`);
+        }
+        return this;
+    }
+    addDefaultMarkup(content) {
+        return '<!DOCTYPE html>' +
+            '<html lang="en">' +
+            '<head>' +
+            '<meta charset="UTF-8">' +
+            '<meta name="viewport" content="width=device-width, initial-scale=1.0">' +
+            '</head>' +
+            '<body>' +
+            content +
+            '</body>' +
+            '</html>';
+    }
+}

package/lib/common/formats/html/export/html-document-exporter.d.ts

@@ -0,0 +1,13 @@
+import { IDocumentExporter, IExportModelOptions } from "../../i-document-exporter";
+import { DocumentExporterOptions } from "../../options";
+export declare class HtmlDocumentExporter implements IDocumentExporter {
+    private options;
+    private exportModelOptions;
+    private sessionGuid;
+    private clientGuid;
+    private get modelManipulator();
+    constructor(exportModelOptions: IExportModelOptions, options: DocumentExporterOptions);
+    exportToBlob(callback: (blob: Blob) => void): void;
+    exportToBase64(callback: (base64: string) => void): void;
+    exportAsString(): string;
+}

package/lib/common/formats/html/export/html-document-exporter.js

@@ -0,0 +1,29 @@
+import { FixedInterval } from "@devexpress/utils/lib/intervals/fixed";
+import { HtmlMimeType } from "@devexpress/utils/lib/utils/mime-type";
+import { RichUtils } from "../../../model/rich-utils";
+import { HtmlExporter } from "./html-export";
+export class HtmlDocumentExporter {
+    constructor(exportModelOptions, options) {
+        this.exportModelOptions = exportModelOptions;
+        this.options = options;
+    }
+    get modelManipulator() { return this.exportModelOptions.modelManager.modelManipulator; }
+    exportToBlob(callback) {
+        this.modelManipulator.picture.loader.ensureAllPicturesLoaded(this.options.ensurePictureLoadedTimeout, (_loaded) => {
+            callback(new Blob([this.exportAsString()], { type: HtmlMimeType }));
+        });
+    }
+    exportToBase64(callback) {
+        this.modelManipulator.picture.loader.ensureAllPicturesLoaded(this.options.ensurePictureLoadedTimeout, (_loaded) => {
+            callback(btoa(this.exportAsString()));
+        });
+    }
+    exportAsString() {
+        const model = this.modelManipulator.model;
+        const subDocument = model.mainSubDocument;
+        const interval = new FixedInterval(0, model.mainSubDocument.getDocumentEndPosition());
+        const guidLabel = RichUtils.getCopyPasteGuidLabel({ sguid: this.sessionGuid, cguid: this.clientGuid });
+        const exporter = new HtmlExporter(this.exportModelOptions);
+        return exporter.getHtmlElementsByInterval(model, subDocument, interval, guidLabel).getHtmlString(true);
+    }
+}

package/lib/common/formats/html/export/html-export.d.ts

@@ -0,0 +1,37 @@
+import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
+import { DocumentModel } from '../../../model/document-model';
+import { RangeCopy } from '../../../model/manipulators/range/create-range-copy-operation';
+import { Paragraph } from '../../../model/paragraph/paragraph';
+import { SubDocument } from '../../../model/sub-document';
+import { HtmlBuilder } from './html-builder';
+import { IExportModelOptions } from '../../i-document-exporter';
+interface List {
+    numberingListIndex: number;
+    listLevelIndex: number;
+    start: number;
+    end: number;
+}
+export declare class HtmlExporter {
+    rangeCopy: RangeCopy;
+    private exportModelOptions;
+    private get modelManager();
+    private get colorProvider();
+    private get unitConverter();
+    private get documentRenderer();
+    private get lastMaxNumPages();
+    private get pageIndex();
+    constructor(exportModelOptions: IExportModelOptions);
+    getHtmlElementsByInterval(model: DocumentModel, subDocument: SubDocument, interval: FixedInterval, guidLabel: string): HtmlBuilder;
+    getParagraphsByInterval(subDocument: SubDocument, interval: FixedInterval): Paragraph[];
+    getListsByParagraphs(paragraphs: Paragraph[]): List[];
+    private addParentTableRecursively;
+    startList(model: DocumentModel, subDocument: SubDocument, interval: FixedInterval, builder: HtmlBuilder, lists: List[], position: number): void;
+    private endList;
+    private getHtmlText;
+    private getBorderCssString;
+    private getTableWidthUnitCssString;
+    private getTableStyle;
+    private getCellStyle;
+    private getTextBoxStyleString;
+}
+export {};