@talrace/ngx-noder 0.0.12 → 0.0.14

package/README.md

@@ -22,24 +22,17 @@ Import editor module. This is basic module and provides creating, editing and vi
 import { EditorModule } from '@talrace/ngx-noder';
 
 @NgModule({
-    // ...
-    imports: [EditorModule]
-    // ...
-})
-export class SomeModule {}
-```
-
-If you need save your changes in document, you need provide CommandsService in your module. This service provides passing commands from the editor to your application for further saving and applying them to your document.
-
-```typescript
-import { CommandsService } from '@talrace/ngx-noder';
-
-@NgModule({
-    // ...
-    provides: [CommandsService]
-    // ...
+    ...
+    imports: [
+        EditorModule.forRoot({
+            elementService: ElementApiService,
+            imageApiService: ImageUploadService,
+            sidenav: { autoFocus: true }
+        }),
+     ],
+    ...
 })
-export class SomeModule {}
+export class SomeModule{}
 ```
 
 ### Editor Toolbar
@@ -57,16 +50,15 @@ import { EditorToolbarModule } from '@talrace/ngx-noder';
 export class SomeModule {}
 ```
 
-### Editor Header
+### Editor Title
 
-Import standalone editor header component, if you need header for your editor. This component provides editor header component with buttons that contains basic functional with document and part of the document content editing functionality.
+Import standalone editor title components to display and edit the document title line and to change the document editing mode (editing, filling, viewing).
 
 ```typescript
-import { EditorHeaderComponent } from '@talrace/ngx-noder';
-
+import { EditorTitleComponent, EditorTitleMobileComponent } from '@talrace/ngx-noder';
 @NgModule({
     // ...
-    imports: [EditorHeaderComponent]
+    imports: [EditorTitleComponent, EditorTitleMobileComponent]
     // ...
 })
 export class SomeModule {}
@@ -109,32 +101,46 @@ Example of full-featured NgxNoder with toolbar, header, custom search and receiv
 app.module.ts
 
 ```typescript
-import { NgModule } from '@angular/core';
-import { BrowserModule } from '@angular/platform-browser';
 import { AppComponent } from './app.component';
-import { EditorHeaderComponent, EditorModule, EditorSearchDialogComponent, EditorToolbarModule } from '@talrace/ngx-noder';
+import {
+    EditorModule,
+    EditorSearchDialogComponent,
+    EditorSearchDialogComponent,
+    EditorTitleComponent,
+    EditorTitleMobileComponent,
+    EditorToolbarModule
+} from '@talrace/ngx-noder';
+import { NgModule } from '@angular/core';
 
 @NgModule({
     declarations: [AppComponent],
-    imports: [BrowserModule, EditorHeaderComponent, EditorModule, EditorSearchDialogComponent, EditorToolbarModule],
-    providers: [CommandsService],
+    imports: [
+        …
+        EditorModule.forRoot({
+            elementService: ElementApiService,
+            imageApiService: ImageUploadService,
+            sidenav: { autoFocus: true }
+        }),
+        EditorSearchDialogComponent,
+        EditorTitleComponent,
+        EditorTitleMobileComponent,
+        EditorToolbarModule
+        …
+    ],
+    providers: [EditorService, ElementApiService, ImageUploadService],
     bootstrap: [AppComponent]
 })
-export class AppModule {}
+
+export class AppModule{}
 ```
 
 app.component.html
 
 ```html
-<app-page-header>
-    <app-nod-editor-toolbar
-        [showActions]="(isViewOnly$ | async) === false"
-        [isViewOnly]="isViewOnly$ | async"
-        [hasSelection]="hasSelection$ | async"
-        [clipboardData]="clipboardData$ | async"
-        [historyInfo]="historyInfo$ | async"
-        [styles]="styles$ | async"
-        (openFileFromDisk)="onConvertFile($event)"
+<div class="”header”">
+    <app-nod-editor-mobile-toolbar
+        *ngIf="isMobile; else desktopToolbar"
+        (openFileFromDisk)="fileInput.click()"
         (addCustomElement)="addCustomElement($event)"
         (insertPageBreak)="onInsertPageBreak()"
         (createDocument)="createDocument()"
@@ -144,93 +150,258 @@ app.component.html
         (rename)="rename$.next()"
         (undo)="onUndo()"
         (redo)="onRedo()"
-        (openEditMenu)="onOpenEditMenu()"
-        (cutSelected)="onCutSelected()"
-        (copySelected)="onCopySelected()"
-        (pasteClipboardData)="onPasteClipboardData()"
-        (selectAll)="onSelectAll()"
-        (removeSelected)="onRemoveSelected()"
-        (insertImage)="onInsertImage($event)"
+        (insertImage)="imageFileInput.click()"
         (insertLink)="onInsertLink()"
-        (insertTable)="onInsertTable($event)"
+        (insertTable)="onInsertTableMobile()"
         (createElement)="createElement($event)"
         (changeParagraphStyle)="onSetParagraphStyle($event)"
         (changeTextStyle)="onSetTextStyle($event)"
-        (setNumberingTemplateType)="onSetNumberingTemplateType($event)"
-        (removeNumberings)="onRemoveNumberings()" />
-</app-page-header>
+        (textFormat)="onTextFormatMobile()" />
+    <ng-template #desktopToolbar>
+        <app-nod-editor-toolbar
+            (openFileFromDisk)="fileInput.click()"
+            (addCustomElement)="addCustomElement($event)"
+            (insertPageBreak)="onInsertPageBreak()"
+            (createDocument)="createDocument()"
+            (saveAs)="onSave()"
+            (print)="onPrint()"
+            (delete)="onDelete()"
+            (rename)="rename$.next()"
+            (undo)="onUndo()"
+            (redo)="onRedo()"
+            (openEditMenu)="onOpenEditMenu()"
+            (cutSelected)="onCutSelected()"
+            (copySelected)="onCopySelected()"
+            (pasteClipboardData)="onPasteClipboardData()"
+            (selectAll)="onSelectAll()"
+            (removeSelected)="onRemoveSelected()"
+            (insertImage)="imageFileInput.click()"
+            (insertLink)="onInsertLink()"
+            (insertTable)="onInsertTable($event)"
+            (createElement)="createElement($event)"
+            (changeParagraphStyle)="onSetParagraphStyle($event)"
+            (changeTextStyle)="onSetTextStyle($event)"
+            (setNumberingTemplateType)="onSetNumberingTemplateType($event)"
+            (removeNumberings)="onRemoveNumberings()" />
+    </ng-template>
+</div>
 <app-nod-editor
     #editor
+    [isMobile]="isMobile"
     [customPageWidth]="customPageWidth"
     [content]="content$ | async" />
-<app-nod-editor-title
-    [title]="title"
-    [rename$]="rename$.asObservable()"
-    (changeMode)="onModeChanged($event)"
-    (renameDocumentTitle)="onRenameDocumentTitle($event)" />
+<ng-container *ngIf="{ mode: mode$ | async } as modeData">
+    <ng-container *ngIf="isMobile; else desktopTitle">
+        <app-nod-editor-title-mobile
+            *ngIf="showTitleModes.includes(editorToolbarService.mode$ | async)"
+            [selectedMode]="modeData.mode"
+            [title]="title"
+            [rename$]="rename$.asObservable()"
+            (changeMode)="onModeChanged($event)"
+            (renameDocumentTitle)="onRenameDocumentTitle($event)" />
+    </ng-container>
+    <ng-template #desktopTitle>
+        <app-nod-editor-title
+            [selectedMode]="modeData.mode"
+            [title]="title"
+            [rename$]="rename$.asObservable()"
+            (changeMode)="onModeChanged($event)"
+            (renameDocumentTitle)="onRenameDocumentTitle($event)" />
+    </ng-template>
+</ng-container>
+<input
+    #fileInput
+    class="upload-input"
+    accept=".docx"
+    type="file"
+    id="file-input"
+    (change)="onConvertFile($event)" />
+<input
+    #imageFileInput
+    class="upload-input"
+    accept="image/gif, image/jpeg, image/png, image/bmp, image/webp"
+    type="file"
+    id="image-file-input"
+    (change)="onInsertImage($event)" />
 ```
 
 app.component.ts
 
 ```typescript
-import { Store } from '@ngxs/store';
-import { BehaviorSubject, filter, Observable, Subscription, take, tap } from 'rxjs';
+import { Actions, ofActionDispatched, Store } from '@ngxs/store';
+import { ActivatedRoute } from '@angular/router';
+import { BehaviorSubject, filter, Observable, Subject, take, takeUntil, tap } from 'rxjs';
 import {
+    AddLinkDialogComponent,
+    AddLinkDialogOptions,
+    AddLinkMobileComponent,
     BreakTypes,
     CommandsService,
-    DEFAULT_FILE_NAME,
+    DestroyComponent,
     DocxModel,
     EditorComponent,
     EditorSearchDialogComponent,
     EditorService,
+    EditorToolbarMode,
+    EditorToolbarService,
     ElementDataModel,
     Mode,
     NumberingLevelModel,
+    ParagraphStyleModel,
     RevisionHelper,
+    TextFormatMobileComponent,
     TextStyleModel
 } from '@talrace/ngx-noder';
-import { Component, OnInit, ViewChild } from '@angular/core';
+import { Component, ElementRef, ViewChild } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { Navigate } from '@ngxs/router-plugin';
 
+import { ClearRevision, ConvertFile, OpenDocx, RenameDocument, SaveDocument, SetMode } from '../../store/noder/noder.actions';
 import { CreateOperation } from '../../store/operations/operations.actions';
+import { DeleteDocuments } from '../../../documents/store/documents/documents.actions';
+import { FileSaveDialogComponent } from '../file-save/file-save-dialog.component';
+import { ImageUploadService } from '../../services/image-upload.service';
+import { LayoutState } from '../../../+shared/layout/store/layout.state';
 import { NoderState } from '../../store/noder/noder.state';
-import { ObserverComponent } from '../../../+shared/abstract/observer.component';
 
 @Component({
     selector: 'app-root',
     templateUrl: './app.component.html',
     styleUrls: ['./app.component.scss']
 })
-export class AppComponent extends ObserverComponent implements OnInit {
-    isViewOnly$: Observable<boolean>;
-
+export class AppComponent extends DestroyComponent {
+    mode$ = this.store.select(NoderState.mode);
+    rename$ = new Subject<void>();
+    title: string;
     documentId: number;
-
+    isMobile = false;
     get content$(): Observable<DocxModel> {
         return this._content$.asObservable();
     }
     private _content$ = new BehaviorSubject<DocxModel>(RevisionHelper.getEmptyDocxModel());
-
     @ViewChild('editor', { static: true }) editor: EditorComponent;
-
-    constructor(private editorService: EditorService, private store: Store, private commandService: CommandsService) {
+    @ViewChild('fileInput', { static: true }) fileInput: ElementRef<HTMLInputElement>;
+    readonly customPageWidth = this.store.selectSnapshot(LayoutState.isMobile) ? window.innerWidth : null;
+    readonly showTitleModes = [
+        EditorToolbarMode.Base,
+        EditorToolbarMode.TextFormat,
+        EditorToolbarMode.StyleFormat,
+        EditorToolbarMode.AlignFormat
+    ];
+
+    constructor(
+        private actions$: Actions,
+        private commandService: CommandsService,
+        private dialog: MatDialog,
+        private editorService: EditorService,
+        private imageUploadService: ImageUploadService,
+        private route: ActivatedRoute,
+        private store: Store,
+        public editorToolbarService: EditorToolbarService
+    ) {
         super();
         const mode: Mode = this.store.selectSnapshot(NoderState.mode);
         this.editorService.setIsViewOnly(mode !== Mode.Edit);
-        this.isViewOnly$ = this.editorService.isViewOnly$;
     }
 
     ngOnInit() {
-        this.subscriptions.push(this.createCommandSubscription());
+        this.isMobileSubscription();
+        this.openCloseSearchSubscription();
+        this.routeDataSubscription();
+        this.documentTitleSubscription();
+        this.documentIdSubscription();
+        this.createCommandSubscription();
+        this.editorHotKeyDownSubscription();
+    }
+
+    createDocument(): void {
+        const documentId = +this.route.snapshot.params['id'];
+        if (documentId) {
+            this.store.dispatch([new ClearRevision(), new Navigate([''])]);
+        } else {
+            this.store.dispatch(new ClearRevision());
+            this._content$.next(RevisionHelper.getEmptyDocxModel());
+        }
+    }
+
+    onConvertFile(event: any): void {
+        if (!event?.target?.files?.length) {
+            return;
+        }
+        let file: File = event.target.files[0];
+        if (!file.type.match('application/vnd.openxmlformats-officedocument.wordprocessingml.document')) {
+            return;
+        }
+        this.store.dispatch(new ConvertFile(file as Blob));
+        this.actions$
+            .pipe(ofActionDispatched(OpenDocx), take(1))
+            .subscribe(payload => this.store.dispatch(new Navigate([`noder/${payload.documentId}`])));
+        event.target.value = null;
+    }
+
+    onSave(): void {
+        const dialogRef = this.dialog.open(FileSaveDialogComponent, {
+            panelClass: 'file-save-dialog',
+            height: '230px',
+            width: '350px',
+            data: { documentName: '' }
+        });
+        dialogRef.afterClosed().subscribe((name: string) => {
+            if (!name?.length) {
+                return;
+            }
+            this.store.dispatch(new SaveDocument(name, this.editor.content));
+        });
     }
 
     onPrint(): void {
-        this.editor.printDocument();
+        this.editorService.print();
+    }
+
+    onDelete(): void {
+        const documentId = this.store.selectSnapshot(NoderState.documentId);
+        this.dialog
+            .open<ConfirmDialogComponent>(ConfirmDialogComponent, {
+                autoFocus: false,
+                restoreFocus: false,
+                data: <IDialogData>{ message: 'Are you sure you want to delete?' }
+            })
+            .afterClosed()
+            .pipe(filter(x => !!x))
+            .subscribe(() => {
+                const actions: any = [new Navigate(['noder', 'new'])];
+                if (documentId) {
+                    actions.unshift(new DeleteDocuments([documentId]));
+                }
+                this.store.dispatch(actions);
+            });
     }
 
     onInsertPageBreak(): void {
         this.editorService.insertBreak(BreakTypes.Page);
     }
 
+    async onInsertImage(event: any): Promise<void> {
+        if (!event?.target?.files?.length) {
+            return;
+        }
+        const file = event.target.files[0];
+        if (!'image/gif, image/jpeg, image/png, image/bmp, image/webp'.match(file.type as string)) {
+            return;
+        }
+        const model = await this.imageUploadService.uploadImage(file as Blob);
+        this.editorService.insertImage(model);
+        event.target.value = null;
+    }
+
+    onInsertTable(model: { rows: number; columns: number }): void {
+        this.editorService.insertTable(model);
+    }
+
+    onInsertTableMobile(): void {
+        this.editorService.openSidenav(InsertTableMobileComponent);
+    }
+
     onSetTextStyle(value: TextStyleModel): void {
         this.editorService.setTextStyles(value);
     }
@@ -239,14 +410,110 @@ export class AppComponent extends ObserverComponent implements OnInit {
         this.editorService.setNumberingTemplateType(value);
     }
 
+    onRemoveNumberings(): void {
+        this.editorService.removeNumberings();
+    }
+
+    onInsertLink(): void {
+        if (this.isMobile) {
+            this.editorService.openSidenav(AddLinkMobileComponent);
+        } else {
+            const data = new AddLinkDialogOptions({
+                textPlaceholder: 'Text',
+                linkPlaceholder: 'Link',
+                title: 'Add Link'
+            });
+
+            this.dialog
+                .open(AddLinkDialogComponent, { panelClass: 'add-link-dialog', data })
+                .afterClosed()
+                .subscribe((result: any) => {
+                    if (result) {
+                        this.editorService.insertLink(result.text as string, result.link as string);
+                    }
+                });
+        }
+    }
+
     addCustomElement(model: ElementDataModel): void {
         this.editorService.createCustomComponent(model);
     }
 
+    onSetParagraphStyle(value: ParagraphStyleModel): void {
+        this.editorService.setParagraphStyles(value);
+    }
+
+    onModeChanged(value: Mode): void {
+        this.store.dispatch(new SetMode(value));
+        this.editorService.setIsViewOnly(value !== Mode.Edit);
+    }
+
     onUndo(): void {
         this.editorService.undo();
     }
 
+    onRedo(): void {
+        this.editorService.redo();
+    }
+
+    async onOpenEditMenu(): Promise<void> {
+        const read = await navigator.permissions.query({ name: 'clipboard-read' as PermissionName });
+        if (read.state != 'denied' && navigator.clipboard) {
+            navigator.clipboard
+                .readText()
+                .then(value => {
+                    return this.editorService.setClipboardData(value);
+                })
+                .catch(() => {
+                    // continue regardless error
+                });
+        }
+    }
+
+    onCutSelected(): void {
+        this.editorService.cutSelected();
+    }
+
+    onCopySelected(): void {
+        this.editorService.copySelected();
+    }
+
+    onPasteClipboardData(): void {
+        this.editorService.pasteFromClipboard();
+    }
+
+    onSelectAll(): void {
+        this.editorService.selectAll();
+    }
+
+    onRemoveSelected(): void {
+        this.editorService.removeSelected();
+    }
+
+    onRenameDocumentTitle(title: string): void {
+        this.store.dispatch(new RenameDocument(new DocumentNameModel({ documentId: this.documentId, name: title })));
+    }
+
+    createElement(model: ElementDataModel) {
+        this.editor.editor.createCustomElement(model);
+        this.editor.editor.focus();
+    }
+
+    onTextFormatMobile(): void {
+        this.editorService.openSidenav(TextFormatMobileComponent);
+    }
+
+    onEditorHotKeyDown(event: KeyboardEvent): void {
+        if (event.ctrlKey && event.code === 'KeyO') {
+            this.fileInput.nativeElement.click();
+        } else if (event.ctrlKey && event.code === 'KeyK') {
+            this.onInsertLink();
+        } else {
+            return;
+        }
+        event.preventDefault();
+    }
+
     private onOpenSearch(): void {
         this.dialog.open(EditorSearchDialogComponent, {
             position: { top: '0px', right: '0px' },
@@ -254,16 +521,52 @@ export class AppComponent extends ObserverComponent implements OnInit {
         });
     }
 
-    private createCommandSubscription(): Subscription {
-        return this.commandService.createCommand$
+    private isMobileSubscription(): void {
+        this.store
+            .select(LayoutState.isMobile)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(x => (this.isMobile = x));
+    }
+
+    private openCloseSearchSubscription(): void {
+        this.editorService.openSearchDialog$.pipe(takeUntil(this.destroy$)).subscribe(value => {
+            value ? this.onOpenSearch() : this.dialog.closeAll();
+        });
+    }
+
+    private routeDataSubscription(): void {
+        this.route.data.pipe(takeUntil(this.destroy$)).subscribe(({ content }) => this._content$.next(content as DocxModel));
+    }
+
+    private documentTitleSubscription(): void {
+        this.store
+            .select(NoderState.title)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(x => (this.title = x ?? 'Untitled document'));
+    }
+
+    private documentIdSubscription(): void {
+        this.store
+            .select(NoderState.documentId)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(x => (this.documentId = x));
+    }
+
+    private createCommandSubscription(): void {
+        this.commandService.createCommand$
             .pipe(
                 filter(x => !!x),
                 tap(command => {
                     this.store.dispatch(new CreateOperation(command));
-                })
+                }),
+                takeUntil(this.destroy$)
             )
             .subscribe();
     }
+
+    private editorHotKeyDownSubscription(): void {
+        this.editorService.keyDown$.pipe(takeUntil(this.destroy$)).subscribe(event => this.onEditorHotKeyDown(event));
+    }
 }
 ```
 

package/esm2022/lib/apart-components/editor-title/editor-title.component.mjs

@@ -89,4 +89,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 type: ViewChild,
                 args: ['titleSpan', { static: true }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor-title.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-noder/src/lib/apart-components/editor-title/editor-title.component.ts","../../../../../../projects/ngx-noder/src/lib/apart-components/editor-title/editor-title.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAqB,SAAS,EAAc,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1I,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAG7D,OAAO,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;;;;;;AAU1D,MAAM,OAAO,oBAAoB;IAS7B,IACI,OAAO,CAAC,KAAuB;QAC/B,KAAK,EAAE,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC;IAC9E,CAAC;IA0BD,YAAoB,GAAsB;QAAtB,QAAG,GAAH,GAAG,CAAmB;QArCjC,iBAAY,GAAG,IAAI,CAAC,IAAI,CAAC;QAEzB,cAAS,GAAG,IAAI,CAAC;QAIjB,oBAAe,GAAG,mBAAmB,CAAC;QAOrC,eAAU,GAAG,IAAI,YAAY,EAAQ,CAAC;QAEtC,wBAAmB,GAAG,IAAI,YAAY,EAAU,CAAC;QAI3D,gBAAW,GAAG;YACV;gBACI,EAAE,EAAE,IAAI,CAAC,IAAI;gBACb,IAAI,EAAE,eAAe;gBACrB,IAAI,EAAE,gBAAgB;aACzB;YACD;gBACI,EAAE,EAAE,IAAI,CAAC,IAAI;gBACb,IAAI,EAAE,wBAAwB;gBAC9B,IAAI,EAAE,gBAAgB;aACzB;YACD;gBACI,EAAE,EAAE,IAAI,CAAC,IAAI;gBACb,IAAI,EAAE,wBAAwB;gBAC9B,IAAI,EAAE,WAAW;aACpB;SACJ,CAAC;IAE2C,CAAC;IAE9C,aAAa,CAAC,KAAiB;QAC1B,KAAK,CAAC,MAAsB,CAAC,eAAe,GAAG,OAAO,CAAC;QACxD,IAAI,CAAC,KAAK,GAAI,KAAK,CAAC,MAAsB,CAAC,WAAW,IAAI,IAAI,CAAC,eAAe,CAAC;QAC9E,KAAK,CAAC,MAAsB,CAAC,SAAS,GAAG,EAAE,CAAC,CAAC,8EAA8E;QAC5H,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1C,UAAU,CAAC,GAAG,EAAE;YACX,KAAK,CAAC,MAAsB,CAAC,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC;YACrD,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC;IAC7B,CAAC;IAED,OAAO,CAAC,KAAiB;QACrB,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,MAAqB,CAAC,CAAC;IACrD,CAAC;IAEO,cAAc,CAAC,OAAoB;QACvC,IAAI,OAAO,CAAC,eAAe,KAAK,MAAM,EAAE;YACpC,OAAO;SACV;QAED,OAAO,CAAC,eAAe,GAAG,MAAM,CAAC;QACjC,MAAM,KAAK,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;QACrC,MAAM,GAAG,GAAG,MAAM,CAAC,YAAY,EAAE,CAAC;QAClC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,UAAU,EAAE,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAC/D,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACrB,GAAG,CAAC,eAAe,EAAE,CAAC;QACtB,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACpB,OAAO,CAAC,KAAK,EAAE,CAAC;IACpB,CAAC;+GArEQ,oBAAoB;mGAApB,oBAAoB,maCjBjC,mzBA2BA,uqBDhBc,YAAY,+PAAE,eAAe,2IAAE,aAAa,mLAAE,gBAAgB;;4FAM/D,oBAAoB;kBARhC,SAAS;iCACM,IAAI,WACP,CAAC,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,gBAAgB,CAAC,YAC/D,sBAAsB,mBAGf,uBAAuB,CAAC,MAAM;sFAGtC,YAAY;sBAApB,KAAK;gBAEG,SAAS;sBAAjB,KAAK;gBAEG,KAAK;sBAAb,KAAK;gBAEG,eAAe;sBAAvB,KAAK;gBAGF,OAAO;sBADV,KAAK;gBAKI,UAAU;sBAAnB,MAAM;gBAEG,mBAAmB;sBAA5B,MAAM;gBAEmC,SAAS;sBAAlD,SAAS;uBAAC,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Input, Output, ViewChild } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatTooltipModule } from '@angular/material/tooltip';\nimport { Observable } from 'rxjs';\n\nimport { Mode } from '../../editor/interaction/mode.enum';\n\n@Component({\n    standalone: true,\n    imports: [CommonModule, MatButtonModule, MatIconModule, MatTooltipModule],\n    selector: 'app-nod-editor-title',\n    templateUrl: './editor-title.component.html',\n    styleUrls: ['./editor-title.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class EditorTitleComponent {\n    @Input() selectedMode = Mode.Edit;\n\n    @Input() showTitle = true;\n\n    @Input() title: string;\n\n    @Input() defaultFileName = 'Untitled document';\n\n    @Input()\n    set rename$(value: Observable<void>) {\n        value?.subscribe(() => this.setTitleActive(this.titleSpan.nativeElement));\n    }\n\n    @Output() changeMode = new EventEmitter<Mode>();\n\n    @Output() renameDocumentTitle = new EventEmitter<string>();\n\n    @ViewChild('titleSpan', { static: true }) titleSpan: ElementRef<HTMLElement>;\n\n    modeOptions = [\n        {\n            id: Mode.Edit,\n            text: 'Edit document',\n            icon: 'icon-edit-mode'\n        },\n        {\n            id: Mode.Fill,\n            text: 'Fill or print document',\n            icon: 'icon-fill-done'\n        },\n        {\n            id: Mode.View,\n            text: 'Read or print document',\n            icon: 'icon-view'\n        }\n    ];\n\n    constructor(private cdr: ChangeDetectorRef) {}\n\n    onRenameTitle(event: FocusEvent): void {\n        (event.target as HTMLElement).contentEditable = 'false';\n        this.title = (event.target as HTMLElement).textContent || this.defaultFileName;\n        (event.target as HTMLElement).innerText = ''; // to correctly display text that is significantly larger than the input width\n        this.renameDocumentTitle.emit(this.title);\n        setTimeout(() => {\n            (event.target as HTMLElement).innerText = this.title;\n            this.cdr.detectChanges();\n        });\n        this.cdr.detectChanges();\n    }\n\n    onFocus(event: MouseEvent) {\n        this.setTitleActive(event.target as HTMLElement);\n    }\n\n    private setTitleActive(element: HTMLElement): void {\n        if (element.contentEditable === 'true') {\n            return;\n        }\n\n        element.contentEditable = 'true';\n        const range = document.createRange();\n        const sel = window.getSelection();\n        range.setStart(element.firstChild, element.textContent.length);\n        range.collapse(true);\n        sel.removeAllRanges();\n        sel.addRange(range);\n        element.focus();\n    }\n}\n","<div\n    *ngIf=\"showTitle\"\n    class=\"menu-header\">\n    <div class=\"file-name\">\n        <span\n            #titleSpan\n            class=\"title\"\n            matTooltip=\"Double click to rename\"\n            (blur)=\"onRenameTitle($event)\"\n            (keydown.enter)=\"$event.target.blur()\"\n            (dblclick)=\"onFocus($event)\">\n            {{ title }}\n        </span>\n    </div>\n</div>\n<div class=\"editor-mode\">\n    <button\n        *ngFor=\"let mode of modeOptions\"\n        mat-icon-button\n        [class.selected-mode]=\"selectedMode === mode.id\"\n        [matTooltip]=\"mode.text\"\n        (click)=\"selectedMode = mode.id; changeMode.emit(mode.id)\">\n        <mat-icon\n            fontSet=\"noder-icon\"\n            fontIcon=\"{{ mode.icon }}\" />\n    </button>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor-title.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-noder/src/lib/apart-components/editor-title/editor-title.component.ts","../../../../../../projects/ngx-noder/src/lib/apart-components/editor-title/editor-title.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Input, Output, ViewChild } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatTooltipModule } from '@angular/material/tooltip';\nimport { Observable } from 'rxjs';\n\nimport { Mode } from '../../editor/interaction/mode.enum';\n\n@Component({\n    standalone: true,\n    imports: [CommonModule, MatButtonModule, MatIconModule, MatTooltipModule],\n    selector: 'app-nod-editor-title',\n    templateUrl: './editor-title.component.html',\n    styleUrls: ['./editor-title.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class EditorTitleComponent {\n    @Input() selectedMode = Mode.Edit;\n\n    @Input() showTitle = true;\n\n    @Input() title: string;\n\n    @Input() defaultFileName = 'Untitled document';\n\n    @Input()\n    set rename$(value: Observable<void>) {\n        value?.subscribe(() => this.setTitleActive(this.titleSpan.nativeElement));\n    }\n\n    @Output() changeMode = new EventEmitter<Mode>();\n\n    @Output() renameDocumentTitle = new EventEmitter<string>();\n\n    @ViewChild('titleSpan', { static: true }) titleSpan: ElementRef<HTMLElement>;\n\n    modeOptions = [\n        {\n            id: Mode.Edit,\n            text: 'Edit document',\n            icon: 'icon-edit-mode'\n        },\n        {\n            id: Mode.Fill,\n            text: 'Fill or print document',\n            icon: 'icon-fill-done'\n        },\n        {\n            id: Mode.View,\n            text: 'Read or print document',\n            icon: 'icon-view'\n        }\n    ];\n\n    constructor(private cdr: ChangeDetectorRef) {}\n\n    onRenameTitle(event: FocusEvent): void {\n        (event.target as HTMLElement).contentEditable = 'false';\n        this.title = (event.target as HTMLElement).textContent || this.defaultFileName;\n        (event.target as HTMLElement).innerText = ''; // to correctly display text that is significantly larger than the input width\n        this.renameDocumentTitle.emit(this.title);\n        setTimeout(() => {\n            (event.target as HTMLElement).innerText = this.title;\n            this.cdr.detectChanges();\n        });\n        this.cdr.detectChanges();\n    }\n\n    onFocus(event: MouseEvent): void {\n        this.setTitleActive(event.target as HTMLElement);\n    }\n\n    private setTitleActive(element: HTMLElement): void {\n        if (element.contentEditable === 'true') {\n            return;\n        }\n\n        element.contentEditable = 'true';\n        const range = document.createRange();\n        const sel = window.getSelection();\n        range.setStart(element.firstChild, element.textContent.length);\n        range.collapse(true);\n        sel.removeAllRanges();\n        sel.addRange(range);\n        element.focus();\n    }\n}\n","<div\n    *ngIf=\"showTitle\"\n    class=\"menu-header\">\n    <div class=\"file-name\">\n        <span\n            #titleSpan\n            class=\"title\"\n            matTooltip=\"Double click to rename\"\n            (blur)=\"onRenameTitle($event)\"\n            (keydown.enter)=\"$event.target.blur()\"\n            (dblclick)=\"onFocus($event)\">\n            {{ title }}\n        </span>\n    </div>\n</div>\n<div class=\"editor-mode\">\n    <button\n        *ngFor=\"let mode of modeOptions\"\n        mat-icon-button\n        [class.selected-mode]=\"selectedMode === mode.id\"\n        [matTooltip]=\"mode.text\"\n        (click)=\"selectedMode = mode.id; changeMode.emit(mode.id)\">\n        <mat-icon\n            fontSet=\"noder-icon\"\n            fontIcon=\"{{ mode.icon }}\" />\n    </button>\n</div>\n"]}