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

package/lib/client/formats/docx/import/destination/notes/footnotes/footnotes-destination.js

@@ -0,0 +1,39 @@
+import { MapCreator } from "../../../../../../../common/utils/map-creator";
+import { ElementDestination } from "../../destination";
+import { SubDocumentInfoType } from "../../../../../../../common/model/enums";
+import { NoteType } from "../../../../../../../common/model/footnotes/footnote";
+import { StringUtils } from "@devexpress/utils/lib/utils/string";
+import { NoteDestination } from "../note-destination";
+export class FootNotesDestination extends ElementDestination {
+    get elementHandlerTable() {
+        return FootNotesDestination.handlerTable;
+    }
+}
+FootNotesDestination.handlerTable = new MapCreator()
+    .add('footnote', (data) => new FootNoteDestination(data))
+    .get();
+class FootNoteDestination extends NoteDestination {
+    get SubDocumentType() {
+        return SubDocumentInfoType.FootNote;
+    }
+    addNote(id, subDocId, type) {
+        if (!this.canAddFootNote(id, type))
+            return false;
+        if (type == NoteType.Normal)
+            this.data.footNotesImporter.notes[id] = subDocId;
+        else
+            this.documentModel.footNoteSeparators.setSeparator(subDocId, type);
+        return true;
+    }
+    canAddFootNote(id, type) {
+        if (StringUtils.isNullOrEmpty(id))
+            return false;
+        if (type == NoteType.Normal)
+            return !(id in this.data.footNotesImporter.notes);
+        else {
+            if (this.documentModel.footNoteSeparators.getSeparator(type))
+                return false;
+            return this.data.footNotesImporter.separatorIds.includes(id);
+        }
+    }
+}

package/lib/client/formats/docx/import/destination/notes/note-destination.d.ts

@@ -0,0 +1,18 @@
+import { SubDocumentInfoType } from "../../../../../../common/model/enums";
+import { NoteType } from "../../../../../../common/model/footnotes/footnote";
+import { XmlReader } from "../../../zip/xml-reader";
+import { ElementHandlerTable } from "../destination";
+import { BodyDestinationBase } from "../document/body-destination-base";
+export declare type NoteSubDocumentType = SubDocumentInfoType.FootNote | SubDocumentInfoType.EndNote;
+export declare abstract class NoteDestination extends BodyDestinationBase {
+    static handlerTable: ElementHandlerTable;
+    protected get elementHandlerTable(): ElementHandlerTable;
+    private id;
+    private subDocId;
+    private type;
+    protected abstract get SubDocumentType(): NoteSubDocumentType;
+    processElementOpen(reader: XmlReader): Promise<void>;
+    processElementClose(_reader: XmlReader): Promise<void>;
+    private createSubDocument;
+    protected abstract addNote(id: string, subDocId: number, type: NoteType): boolean;
+}

package/lib/client/formats/docx/import/destination/notes/note-destination.js

@@ -0,0 +1,45 @@
+import { __awaiter } from "tslib";
+import { NoteType } from "../../../../../../common/model/footnotes/footnote";
+import { SubDocument } from "../../../../../../common/model/sub-document";
+import { MapCreator } from "../../../../../../common/utils/map-creator";
+import { TranslationTables } from "../../../translation-table/translation-tables";
+import { BodyDestinationBase } from "../document/body-destination-base";
+import { ParagraphDestination } from "../paragraph/paragraph-destination";
+import { HeaderFooterDestination } from "../section/header-footer/header-footer-destination";
+import { TableDestination } from "../table/table/table-destination";
+export class NoteDestination extends BodyDestinationBase {
+    get elementHandlerTable() {
+        return HeaderFooterDestination.handlerTable;
+    }
+    processElementOpen(reader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.type = this.data.readerHelper.getWpEnumValue(reader, "type", TranslationTables.noteTypeTable.importMap, NoteType.Normal);
+            const note = this.createSubDocument(this.SubDocumentType);
+            note.info.noteType = this.type;
+            this.data.pushCurrentSubDocument(note);
+            this.id = reader.getAttributeNS("id", this.data.constants.wordProcessingNamespaceConst);
+        });
+    }
+    processElementClose(_reader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.data.fixLastParagraph();
+            const subDoc = this.data.popCurrentSubDocument();
+            this.subDocId = subDoc.id;
+            if (!this.addNote(this.id, this.subDocId, this.type))
+                this.data.documentModel.subDocumentsCollection.delete(this.subDocId);
+        });
+    }
+    createSubDocument(type) {
+        return this.documentModel.createSubDocument(type, SubDocument.MAIN_SUBDOCUMENT_ID, true);
+    }
+}
+NoteDestination.handlerTable = new MapCreator()
+    .add('p', (data) => new ParagraphDestination(data))
+    .add('tbl', (data) => new TableDestination(data))
+    .add('bookmarkStart', BodyDestinationBase.onBookmarkStart)
+    .add('bookmarkEnd', BodyDestinationBase.onBookmarkEnd)
+    .add('permStart', BodyDestinationBase.onRangePermissionStart)
+    .add('permEnd', BodyDestinationBase.onRangePermissionEnd)
+    .add('sdt', BodyDestinationBase.onStructuredDocument)
+    .add('customXml', BodyDestinationBase.onCustomXml)
+    .get();

package/lib/client/formats/docx/import/destination/notes/note-properties-destination.d.ts

@@ -0,0 +1,32 @@
+import { NoteProperties, NotePosition } from "../../../../../../common/model/footnotes/footnote";
+import { NumberingFormat } from "../../../../../../common/model/numbering-lists/list-level-properties";
+import { XmlReader } from "../../../zip/xml-reader";
+import { Data } from "../../data";
+import { LeafElementDestination, ElementDestination, ElementHandlerTable } from "../destination";
+export declare abstract class NotePropertiesLeafElementDestination extends LeafElementDestination {
+    readonly footNote: NoteProperties;
+    constructor(data: Data, footNote: NoteProperties);
+}
+export declare abstract class NotePropertiesDestination extends ElementDestination {
+    static handlerTable: ElementHandlerTable;
+    static getThis(data: Data): NotePropertiesDestination;
+    readonly notes: NoteProperties;
+    private readonly defaultPosition;
+    private readonly defaultFormat;
+    constructor(data: Data, defaultPosition: NotePosition, defaultFormat: NumberingFormat);
+    protected get elementHandlerTable(): ElementHandlerTable;
+    processElementClose(_reader: XmlReader): Promise<void>;
+    protected createPlacementDestination(data: Data): ElementDestination;
+    protected createNumberingFormatDestination(data: Data): ElementDestination;
+    protected abstract setProperties(notes: NoteProperties): void;
+}
+export declare class NotePlacementDestination extends NotePropertiesLeafElementDestination {
+    readonly defaultPosition: NotePosition;
+    constructor(data: Data, footNote: NoteProperties, defaultPosition: NotePosition);
+    processElementOpen(reader: XmlReader): Promise<void>;
+}
+export declare class NoteNumberingFormatDestination extends NotePropertiesLeafElementDestination {
+    readonly defaultNumberingFormat: NumberingFormat;
+    constructor(data: Data, footNote: NoteProperties, defaultNumberingFormat: NumberingFormat);
+    processElementOpen(reader: XmlReader): Promise<void>;
+}

package/lib/client/formats/docx/import/destination/notes/note-properties-destination.js

@@ -0,0 +1,81 @@
+var _a;
+import { __awaiter } from "tslib";
+import { NoteProperties, NoteNumberingRestartType } from "../../../../../../common/model/footnotes/footnote";
+import { MapCreator } from "../../../../../../common/utils/map-creator";
+import { TranslationTables } from "../../../translation-table/translation-tables";
+import { LeafElementDestination, ElementDestination } from "../destination";
+export class NotePropertiesLeafElementDestination extends LeafElementDestination {
+    constructor(data, footNote) {
+        super(data);
+        this.footNote = footNote;
+    }
+}
+class NoteNumberingStartDestination extends NotePropertiesLeafElementDestination {
+    processElementOpen(reader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.footNote.startingNumber = this.data.readerHelper.getWpSTIntegerValue(reader, "val", 1);
+        });
+    }
+}
+class NoteNumberingRestartTypeDestination extends NotePropertiesLeafElementDestination {
+    processElementOpen(reader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.footNote.numberingRestartType = this.data.readerHelper.getWpEnumValue(reader, "val", TranslationTables.noteNumberingRestartTypeTable.importMap, NoteNumberingRestartType.Continuous);
+        });
+    }
+}
+export class NotePropertiesDestination extends ElementDestination {
+    constructor(data, defaultPosition, defaultFormat) {
+        super(data);
+        this.notes = NoteProperties.createDefault();
+        this.defaultPosition = defaultPosition;
+        this.defaultFormat = defaultFormat;
+    }
+    static getThis(data) {
+        return data.destinationStack.getThis();
+    }
+    get elementHandlerTable() {
+        return NotePropertiesDestination.handlerTable;
+    }
+    processElementClose(_reader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setProperties(this.notes);
+        });
+    }
+    createPlacementDestination(data) {
+        return new NotePlacementDestination(data, this.notes, this.defaultPosition);
+    }
+    createNumberingFormatDestination(data) {
+        return new NoteNumberingFormatDestination(data, this.notes, this.defaultFormat);
+    }
+}
+_a = NotePropertiesDestination;
+NotePropertiesDestination.handlerTable = new MapCreator()
+    .add('pos', (data) => _a.getThis(data).createPlacementDestination(data))
+    .add('numFmt', (data) => _a.getThis(data).createNumberingFormatDestination(data))
+    .add('numStart', (data) => new NoteNumberingStartDestination(data, _a.getThis(data).notes))
+    .add('numRestart', (data) => new NoteNumberingRestartTypeDestination(data, _a.getThis(data).notes))
+    .get();
+export class NotePlacementDestination extends NotePropertiesLeafElementDestination {
+    constructor(data, footNote, defaultPosition) {
+        super(data, footNote);
+        this.defaultPosition = defaultPosition;
+    }
+    processElementOpen(reader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const footNotePosition = this.data.readerHelper.getWpEnumValue(reader, "val", TranslationTables.footNotePlacementTable.importMap, this.defaultPosition);
+            this.footNote.position = footNotePosition;
+        });
+    }
+}
+export class NoteNumberingFormatDestination extends NotePropertiesLeafElementDestination {
+    constructor(data, footNote, defaultNumberingFormat) {
+        super(data, footNote);
+        this.defaultNumberingFormat = defaultNumberingFormat;
+    }
+    processElementOpen(reader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.footNote.numberingFormat = this.data.readerHelper.getWpEnumValue(reader, "val", TranslationTables.pageNumberingFormatTable.importMap, this.defaultNumberingFormat);
+        });
+    }
+}

package/lib/client/formats/docx/import/destination/notes/note-reference-destination.d.ts

@@ -0,0 +1,8 @@
+import { XmlReader } from "../../../zip/xml-reader";
+import { LeafElementDestination } from "../destination";
+export declare abstract class NoteReferenceDestination extends LeafElementDestination {
+    protected abstract get notes(): Record<string, number>;
+    protected abstract insertNoteRun(subDocId: number): void;
+    protected processCustomNoteRun(subDocId: number): void;
+    processElementOpen(reader: XmlReader): Promise<void>;
+}

package/lib/client/formats/docx/import/destination/notes/note-reference-destination.js

@@ -0,0 +1,21 @@
+import { __awaiter } from "tslib";
+import { isDefined } from "@devexpress/utils/lib/utils/common";
+import { LeafElementDestination } from "../destination";
+export class NoteReferenceDestination extends LeafElementDestination {
+    processCustomNoteRun(subDocId) {
+        this.data.subDocumentInfo.characterImporter.noteDocumentId = subDocId;
+    }
+    processElementOpen(reader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = reader.getAttributeNS("id", this.data.constants.wordProcessingNamespaceConst);
+            let subDocId = this.notes[id];
+            if (!isDefined(subDocId))
+                return;
+            const customMarkFollows = this.data.readerHelper.getWpSTOnOffValue(reader, "customMarkFollows", false);
+            if (customMarkFollows)
+                this.processCustomNoteRun(subDocId);
+            else
+                this.insertNoteRun(subDocId);
+        });
+    }
+}

package/lib/client/formats/docx/import/destination/notes/note-self-reference-destination.d.ts

@@ -0,0 +1,5 @@
+import { XmlReader } from "../../../zip/xml-reader";
+import { LeafElementDestination } from "../destination";
+export declare class NoteSelfReferenceDestination extends LeafElementDestination {
+    processElementOpen(_reader: XmlReader): Promise<void>;
+}

package/lib/client/formats/docx/import/destination/notes/note-self-reference-destination.js

@@ -0,0 +1,12 @@
+import { __awaiter } from "tslib";
+import { LeafElementDestination } from "../destination";
+export class NoteSelfReferenceDestination extends LeafElementDestination {
+    processElementOpen(_reader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.data.subDocument.isFootNote())
+                this.data.footNotesImporter.insertRun();
+            else
+                this.data.endNotesImporter.insertRun();
+        });
+    }
+}

package/lib/client/formats/docx/import/destination/notes/note-separator-destination.d.ts

@@ -0,0 +1,8 @@
+import { XmlReader } from "../../../zip/xml-reader";
+import { LeafElementDestination } from "../destination";
+export declare class NoteSeparatorDestination extends LeafElementDestination {
+    processElementOpen(_reader: XmlReader): Promise<void>;
+}
+export declare class NoteContinuationSeparatorDestination extends LeafElementDestination {
+    processElementOpen(_reader: XmlReader): Promise<void>;
+}

package/lib/client/formats/docx/import/destination/notes/note-separator-destination.js

@@ -0,0 +1,20 @@
+import { __awaiter } from "tslib";
+import { NoteContinuationSeparatorRun, NoteSeparatorRun } from "../../../../../../common/model/runs/simple-runs";
+import { LeafElementDestination } from "../destination";
+import { RichUtils } from "../../../../../../common/model/rich-utils";
+export class NoteSeparatorDestination extends LeafElementDestination {
+    processElementOpen(_reader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const run = new NoteSeparatorRun(this.data.subDocumentInfo.positionImporter.currPosition, this.data.subDocumentInfo.paragraphImporter.paragraph, this.data.subDocumentInfo.characterImporter.charPropsBundle);
+            this.data.subDocumentInfo.characterImporter.addRun(run, RichUtils.specialCharacters.ETX);
+        });
+    }
+}
+export class NoteContinuationSeparatorDestination extends LeafElementDestination {
+    processElementOpen(_reader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const run = new NoteContinuationSeparatorRun(this.data.subDocumentInfo.positionImporter.currPosition, this.data.subDocumentInfo.paragraphImporter.paragraph, this.data.subDocumentInfo.characterImporter.charPropsBundle);
+            this.data.subDocumentInfo.characterImporter.addRun(run, RichUtils.specialCharacters.EOT);
+        });
+    }
+}

package/lib/client/formats/docx/import/destination/paragraph-properties/paragraph-numbering-reference-destination.js

@@ -6,7 +6,7 @@ export class ParagraphNumberingReferenceDestination extends ElementDestination {
     constructor(data, paragraphPropertiesDestination) {
         super(data);
         this.paragraphPropertiesDestination = paragraphPropertiesDestination;
-        this.paragraphPropertiesDestination.listLevelIndex = 0;
+        this.paragraphPropertiesDestination.listLevelIndex = -1;
     }
     get listLevelIndex() { return this.paragraphPropertiesDestination.listLevelIndex; }
     set listLevelIndex(value) { this.paragraphPropertiesDestination.listLevelIndex = value; }

package/lib/client/formats/docx/import/destination/runs/run-destination.js

@@ -17,15 +17,17 @@ import { RunTabDestination } from './run-tab-destination';
 import { SeparatorDestination } from './separator-destination';
 import { SymbolDestination } from './symbol-destination';
 import { TextDestination } from './text-destination';
+import { FootNoteReferenceDestination } from '../notes/footnotes/footnote-reference-destination';
+import { NoteSelfReferenceDestination } from '../notes/note-self-reference-destination';
+import { EndNoteReferenceDestination } from '../notes/endnotes/endnote-reference-destination';
+import { NoteContinuationSeparatorDestination, NoteSeparatorDestination } from '../notes/note-separator-destination';
 export class RunDestination extends ElementDestination {
     constructor(data) {
         super(data);
         this.resetProperties();
     }
     resetProperties() {
-        this.data.subDocumentInfo.characterImporter
-            .resetProperties()
-            .resetStyle();
+        this.data.subDocumentInfo.characterImporter.reset();
     }
     get elementHandlerTable() {
         return RunDestination.handlerTable;
@@ -55,8 +57,12 @@ RunDestination.handlerTable = new MapCreator()
     .add('object', (data) => new InlineObjectDestination(data))
     .add('fldChar', (data) => new FieldCharDestination(data))
     .add('drawing', (data) => new DrawingDestination(data))
-    .add('footnoteRef', (_data) => null)
-    .add('endnoteRef', (_data) => null)
+    .add("footnoteReference", (data) => new FootNoteReferenceDestination(data))
+    .add("endnoteReference", (data) => new EndNoteReferenceDestination(data))
+    .add('footnoteRef', (data) => new NoteSelfReferenceDestination(data))
+    .add('endnoteRef', (data) => new NoteSelfReferenceDestination(data))
+    .add('separator', (data) => new NoteSeparatorDestination(data))
+    .add('continuationSeparator', (data) => new NoteContinuationSeparatorDestination(data))
     .add('commentReference', (_data) => null)
     .add('spr', (data) => new SeparatorDestination(data))
     .add('customObject', (data) => new CustomRunDestination(data))

package/lib/client/formats/docx/import/destination/section/section-destination.js

@@ -8,6 +8,8 @@ import { SectionPageNumberingDestination } from './section-page-numbering-destin
 import { SectionPageSizeDestination } from './section-page-size-destination';
 import { SectionStartTypeDestination } from './section-start-type-destination';
 import { SectionLineNumberingDestination } from './section-line-numbering-destination';
+import { SectionFootNoteColumnsCountDestination, SectionLevelFootNotePropertiesDestination } from '../notes/footnotes/footnote-properties-destination';
+import { SectionLevelEndNotePropertiesDestination } from '../notes/endnotes/endnote-properties-destination';
 export class SectionDestination extends ElementDestination {
     get elementHandlerTable() {
         return SectionDestination.handlerTable;
@@ -28,6 +30,7 @@ SectionDestination.handlerTable = new MapCreator()
     .add('headerReference', (data) => new HeaderReferenceDestination(data))
     .add('footerReference', (data) => new FooterReferenceDestination(data))
     .add('titlePg', (data) => new SectionDifferentFirstPageDestination(data))
-    .add('footnotePr', (_data) => null)
-    .add('endnotePr', (_data) => null)
+    .add('footnotePr', (data) => new SectionLevelFootNotePropertiesDestination(data))
+    .add('endnotePr', (data) => new SectionLevelEndNotePropertiesDestination(data))
+    .add('footnoteColumns', (data) => new SectionFootNoteColumnsCountDestination(data))
     .get();

package/lib/client/formats/docx/import/destination/settings/settings.js

@@ -6,6 +6,8 @@ import { DocumentSettingsDifferentOddAndEvenPagesDestination } from './different
 import { DocumentProtectionDestination } from './document-protection';
 import { DocumentSettingsDocVarsDestination } from './document-variables-destination';
 import { DocumentSettingsMirrorMarginsDestination } from './mirror-margins-destination';
+import { DocumentLevelFootNotePropertiesDestination } from '../notes/footnotes/footnote-properties-destination';
+import { DocumentLevelEndNotePropertiesDestination } from '../notes/endnotes/endnote-properties-destination';
 export class DocumentSettingsDestination extends ElementDestination {
     get elementHandlerTable() {
         return DocumentSettingsDestination.handlerTable;
@@ -18,4 +20,6 @@ DocumentSettingsDestination.handlerTable = new MapCreator()
     .add('compat', (data) => new DocumentSettingsCompatDestination(data))
     .add('docVars', (data) => new DocumentSettingsDocVarsDestination(data))
     .add('mirrorMargins', (data) => new DocumentSettingsMirrorMarginsDestination(data))
+    .add('footnotePr', (data) => new DocumentLevelFootNotePropertiesDestination(data))
+    .add('endnotePr', (data) => new DocumentLevelEndNotePropertiesDestination(data))
     .get();

package/lib/client/formats/docx/import/importer.d.ts

@@ -13,6 +13,8 @@ export declare class Importer implements IDocumentImporter {
     private importRootRelations;
     private importMainSubDocument;
     private importStyles;
+    private importFootNotes;
+    private importEndNotes;
     private importThemes;
     private importNumbering;
     private importSettings;

package/lib/client/formats/docx/import/importer.js

@@ -16,6 +16,8 @@ import { NumberingsDestination } from './destination/numbering/numberings-destin
 import { DocumentSettingsDestination } from './destination/settings/settings';
 import { StylesDestination } from './destination/style/styles-destination';
 import { OfficeThemeDestination } from './destination/themes/office-theme-destination';
+import { FootNotesDestination } from './destination/notes/footnotes/footnotes-destination';
+import { EndNotesDestination } from './destination/notes/endnotes/endnotes-destination';
 export class Importer {
     constructor(options) {
         this.asyncImportFromFile = true;
@@ -64,6 +66,8 @@ export class Importer {
             yield this.importThemes();
             yield this.importNumbering();
             yield this.importStyles();
+            yield this.importFootNotes();
+            yield this.importEndNotes();
             this.linkNumberingListStyles();
             const documentReader = yield this.data.archiveData.getXmlReader(documentFileName);
             if (documentReader.readToFollowingNS('document', this.data.constants.wordProcessingNamespaceConst)) {
@@ -92,6 +96,28 @@ export class Importer {
             }
         });
     }
+    importFootNotes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const footNotesFileName = 'footnotes.xml';
+            const footNotesFilePath = this.data.relationsStack.last.lookupRelationTargetByType(this.data.constants.rels.officeFootNoteType, this.data.documentRootFolder, footNotesFileName);
+            yield this.data.addRelations(`${this.data.documentRootFolder}/_rels/${footNotesFileName}.rels`);
+            const footNotesReader = yield this.data.archiveData.getXmlReader(footNotesFilePath);
+            if (footNotesReader && footNotesReader.readToFollowingNS('footnotes', this.data.constants.wordProcessingNamespaceConst))
+                yield this.data.importContent(footNotesReader, new FootNotesDestination(this.data));
+            this.data.relationsStack.pop();
+        });
+    }
+    importEndNotes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endNotesFileName = 'endnotes.xml';
+            const endNotesFilePath = this.data.relationsStack.last.lookupRelationTargetByType(this.data.constants.rels.officeEndNoteType, this.data.documentRootFolder, endNotesFileName);
+            yield this.data.addRelations(`${this.data.documentRootFolder}/_rels/${endNotesFileName}.rels`);
+            const endNotesReader = yield this.data.archiveData.getXmlReader(endNotesFilePath);
+            if (endNotesReader && endNotesReader.readToFollowingNS('endnotes', this.data.constants.wordProcessingNamespaceConst))
+                yield this.data.importContent(endNotesReader, new EndNotesDestination(this.data));
+            this.data.relationsStack.pop();
+        });
+    }
     importThemes() {
         return __awaiter(this, void 0, void 0, function* () {
             const themeFileName = this.data.relationsStack.last.lookupRelationTargetByType(this.data.constants.rels.officeThemesType, this.data.documentRootFolder, 'theme/theme1.xml');

package/lib/client/formats/docx/import/importers/character-importer.d.ts

@@ -5,6 +5,7 @@ import { MaskedCharacterPropertiesBundle } from '../../../../../common/rich-util
 import { Data } from '../data';
 export declare class CharacterImporter {
     data: Data;
+    noteDocumentId: number;
     _style: CharacterStyle;
     get style(): CharacterStyle;
     set style(value: CharacterStyle);
@@ -13,6 +14,8 @@ export declare class CharacterImporter {
     constructor(data: Data);
     resetProperties(): this;
     resetStyle(): this;
+    resetNoteDocumentId(): this;
+    reset(): void;
     insertText(text: string): void;
     addRun(run: RunBase, text: string): void;
     addRunAtPos(run: RunBase, text: string, pos: number): void;

package/lib/client/formats/docx/import/importers/character-importer.js

@@ -29,9 +29,20 @@ export class CharacterImporter {
         this._style = this.data.stylesImporter.characterManager.defaultStyle;
         return this;
     }
+    resetNoteDocumentId() {
+        delete this.noteDocumentId;
+        return this;
+    }
+    reset() {
+        this.resetProperties()
+            .resetStyle()
+            .resetNoteDocumentId();
+    }
     insertText(text) {
         const length = text.length;
-        this.addRun(new TextRun(this.data.subDocumentInfo.positionImporter.currPosition, length, this.data.subDocumentInfo.paragraphImporter.paragraph, this.charPropsBundle), text);
+        const run = new TextRun(this.data.subDocumentInfo.positionImporter.currPosition, length, this.data.subDocumentInfo.paragraphImporter.paragraph, this.charPropsBundle);
+        run.noteDocumentId = this.noteDocumentId;
+        this.addRun(run, text);
     }
     addRun(run, text) {
         const chunk = ListUtils.last(this.data.subDocument.chunks);

package/lib/client/formats/docx/import/importers/end-notes-importer.d.ts

@@ -1,5 +1,4 @@
-import { Data } from '../data';
-export declare class EndNotesImporter {
-    data: Data;
-    constructor(data: Data);
+import { NotesImporter } from './notes-importer';
+export declare class EndNotesImporter extends NotesImporter {
+    insertRun(subDocId?: number): void;
 }

package/lib/client/formats/docx/import/importers/end-notes-importer.js

@@ -1,5 +1,10 @@
-export class EndNotesImporter {
-    constructor(data) {
-        this.data = data;
+import { EndNoteRun } from '../../../../../common/model/runs/simple-runs';
+import { RichUtils } from '../../../../../common/model/rich-utils';
+import { NotesImporter } from './notes-importer';
+export class EndNotesImporter extends NotesImporter {
+    insertRun(subDocId) {
+        const pos = this.data.subDocumentInfo.positionImporter.currPosition;
+        const run = new EndNoteRun(pos, this.data.subDocumentInfo.paragraphImporter.paragraph, this.data.subDocumentInfo.characterImporter.charPropsBundle, subDocId);
+        this.data.subDocumentInfo.characterImporter.addRun(run, RichUtils.specialCharacters.LayoutDependentText);
     }
 }

package/lib/client/formats/docx/import/importers/foot-notes-importer.d.ts

@@ -1,6 +1,4 @@
-import { Data } from '../data';
-export declare class FootNotesImporter {
-    data: Data;
-    constructor(data: Data);
-    import(): void;
+import { NotesImporter } from './notes-importer';
+export declare class FootNotesImporter extends NotesImporter {
+    insertRun(subDocId?: number): void;
 }

package/lib/client/formats/docx/import/importers/foot-notes-importer.js

@@ -1,7 +1,10 @@
-export class FootNotesImporter {
-    constructor(data) {
-        this.data = data;
-    }
-    import() {
+import { FootNoteRun } from '../../../../../common/model/runs/simple-runs';
+import { RichUtils } from '../../../../../common/model/rich-utils';
+import { NotesImporter } from './notes-importer';
+export class FootNotesImporter extends NotesImporter {
+    insertRun(subDocId) {
+        const pos = this.data.subDocumentInfo.positionImporter.currPosition;
+        const run = new FootNoteRun(pos, this.data.subDocumentInfo.paragraphImporter.paragraph, this.data.subDocumentInfo.characterImporter.charPropsBundle, subDocId);
+        this.data.subDocumentInfo.characterImporter.addRun(run, RichUtils.specialCharacters.LayoutDependentText);
     }
 }

package/lib/client/formats/docx/import/importers/notes-importer.d.ts

@@ -0,0 +1,8 @@
+import { Data } from "../data";
+export declare abstract class NotesImporter {
+    data: Data;
+    notes: Record<string, number>;
+    separatorIds: string[];
+    constructor(data: Data);
+    abstract insertRun(subDocId?: number): void;
+}

package/lib/client/formats/docx/import/importers/notes-importer.js

@@ -0,0 +1,7 @@
+export class NotesImporter {
+    constructor(data) {
+        this.notes = {};
+        this.separatorIds = [];
+        this.data = data;
+    }
+}

package/lib/client/formats/docx/translation-table/translation-tables.d.ts

@@ -13,6 +13,7 @@ import { ConditionalTableStyleFormatting, HorizontalAlignMode, HorizontalAnchorT
 import { TableHeightUnitType, TableWidthUnitType } from '../../../../common/model/tables/secondary-structures/table-units';
 import { SchemeColorValues, SystemColorValues } from '../../../../common/model/themes/enums';
 import { TranslationTablesData } from './translation-tables-data';
+import { NoteNumberingRestartType, NotePosition, NoteType } from '../../../../common/model/footnotes/footnote';
 export declare abstract class TranslationTables {
     static readonly sectionStartTypeTable: TranslationTablesData<SectionStartType>;
     static readonly lineNumberingRestartTable: TranslationTablesData<LineNumberingRestartType>;
@@ -64,6 +65,9 @@ export declare abstract class TranslationTables {
     static readonly listNumberAlignmentTable: TranslationTablesData<ListNumberAlignment>;
     static readonly schemeColorTable: TranslationTablesData<SchemeColorValues>;
     static readonly systemColorTable: TranslationTablesData<SystemColorValues>;
+    static readonly noteNumberingRestartTypeTable: TranslationTablesData<NoteNumberingRestartType>;
+    static readonly footNotePlacementTable: TranslationTablesData<NotePosition>;
+    static readonly noteTypeTable: TranslationTablesData<NoteType>;
     static horizontalPositionTypeAttributeTable: TranslationTablesData<AnchorObjectHorizontalPositionType>;
     static verticalPositionTypeAttributeTable: TranslationTablesData<AnchorObjectVerticalPositionType>;
     static createHorizontalPositionTypeAttributeTable(): TranslationTablesData<AnchorObjectHorizontalPositionType>;
@@ -118,4 +122,7 @@ export declare abstract class TranslationTables {
     private static createFloatingObjectCssRelativeFromVerticalTable;
     private static createThemeColorIndexTable;
     private static createTextDirectionTable;
+    private static createNoteNumberingRestartTypeTable;
+    private static createFootNotePlacementTable;
+    private static createNoteTypeTable;
 }

package/lib/client/formats/docx/translation-table/translation-tables.js

@@ -21,6 +21,7 @@ import { NumberMapUtils } from '@devexpress/utils/lib/utils/map/number';
 import { MLTableData } from './ml-table-data';
 import { TranslationTablesData } from './translation-tables-data';
 import { WordProcessingMLValue } from './word-processing-mlvalue';
+import { NoteNumberingRestartType, NotePosition, NoteType } from '../../../../common/model/footnotes/footnote';
 export class TranslationTables {
     static createHorizontalPositionTypeAttributeTable() {
         const data = new TranslationTablesData();
@@ -855,6 +856,29 @@ export class TranslationTables {
         TranslationTables.makeData(data, TextDirection.TopToBottomRightToLeftRotated, 'tbRlV');
         return data;
     }
+    static createNoteNumberingRestartTypeTable() {
+        const data = new TranslationTablesData();
+        TranslationTables.makeData(data, NoteNumberingRestartType.Continuous, 'continuous');
+        TranslationTables.makeData(data, NoteNumberingRestartType.NewPage, 'eachPage');
+        TranslationTables.makeData(data, NoteNumberingRestartType.NewSection, 'eachSect');
+        return data;
+    }
+    static createFootNotePlacementTable() {
+        const data = new TranslationTablesData();
+        TranslationTables.makeData(data, NotePosition.BelowText, 'beneathText');
+        TranslationTables.makeData(data, NotePosition.BottomOfPage, 'pageBottom');
+        TranslationTables.makeData(data, NotePosition.EndOfDocument, 'docEnd');
+        TranslationTables.makeData(data, NotePosition.EndOfSection, 'sectEnd');
+        return data;
+    }
+    static createNoteTypeTable() {
+        const data = new TranslationTablesData();
+        TranslationTables.makeData(data, NoteType.Normal, 'normal');
+        TranslationTables.makeData(data, NoteType.Separator, 'separator');
+        TranslationTables.makeData(data, NoteType.ContinuationSeparator, 'continuationSeparator');
+        TranslationTables.makeData(data, NoteType.ContinuationNotice, 'continuationNotice');
+        return data;
+    }
 }
 TranslationTables.sectionStartTypeTable = TranslationTables.createSectionStartTypeTable();
 TranslationTables.lineNumberingRestartTable = TranslationTables.createLineNumberingRestartTable();
@@ -906,5 +930,8 @@ TranslationTables.listNumberSeparatorTable = TranslationTables.createListNumberS
 TranslationTables.listNumberAlignmentTable = TranslationTables.createListNumberAlignmentTable();
 TranslationTables.schemeColorTable = TranslationTables.createSchemeColorTable();
 TranslationTables.systemColorTable = TranslationTables.createSystemColorTable();
+TranslationTables.noteNumberingRestartTypeTable = TranslationTables.createNoteNumberingRestartTypeTable();
+TranslationTables.footNotePlacementTable = TranslationTables.createFootNotePlacementTable();
+TranslationTables.noteTypeTable = TranslationTables.createNoteTypeTable();
 TranslationTables.horizontalPositionTypeAttributeTable = TranslationTables.createHorizontalPositionTypeAttributeTable();
 TranslationTables.verticalPositionTypeAttributeTable = TranslationTables.createVerticalPositionTypeAttributeTable();