devexpress-richedit 24.1.1-alpha-24085-0102 → 24.1.2-beta

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,98 @@
+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) {
+        let currentElement = this._currentElement;
+        while (currentElement.tagName.toLowerCase() !== tagName.toLowerCase()) {
+            currentElement = currentElement.parentElement;
+        }
+        this._currentElement = currentElement.parentElement;
+        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,25 @@
+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 { SubDocument } from '../../../model/sub-document';
+import { HtmlBuilder } from './html-builder';
+import { IExportModelOptions } from '../../i-document-exporter';
+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;
+    private addParentTableRecursively;
+    private getHtmlText;
+    private getBorderCssString;
+    private getTableWidthUnitCssString;
+    private getTableStyle;
+    private getCellStyle;
+    private getTextBoxStyleString;
+}