@talrace/ngx-noder 0.0.11 → 0.0.13

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":"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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) {\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"]}

package/esm2022/lib/apart-components/editor-toolbar/components/buttons/font/font.component.mjs

@@ -13,7 +13,7 @@ export class FontComponent {
     constructor() {
         this.isDisabled = false;
         this.selectFont = new EventEmitter();
-        this.fonts = [DEFAULT_FONT_FAMILY, 'Verdana', 'Arial', 'Times New Roman'];
+        this.fonts = ['Arial', DEFAULT_FONT_FAMILY, 'Times New Roman', 'Verdana'];
         this.font = DEFAULT_FONT_FAMILY;
     }
     set styles(value) {
@@ -46,4 +46,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
             }], selectFont: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9udC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbm9kZXIvc3JjL2xpYi9hcGFydC1jb21wb25lbnRzL2VkaXRvci10b29sYmFyL2NvbXBvbmVudHMvYnV0dG9ucy9mb250L2ZvbnQuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LW5vZGVyL3NyYy9saWIvYXBhcnQtY29tcG9uZW50cy9lZGl0b3ItdG9vbGJhci9jb21wb25lbnRzL2J1dHRvbnMvZm9udC9mb250LmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDaEcsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdkQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRXZELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHNEQUFzRCxDQUFDOzs7Ozs7QUFXOUcsTUFBTSxPQUFPLGFBQWE7SUFSMUI7UUFTYSxlQUFVLEdBQUcsS0FBSyxDQUFDO1FBbUJsQixlQUFVLEdBQUcsSUFBSSxZQUFZLEVBQVUsQ0FBQztRQUVsRCxVQUFLLEdBQUcsQ0FBQyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsaUJBQWlCLEVBQUUsU0FBUyxDQUFDLENBQUM7UUFFckUsU0FBSSxHQUFHLG1CQUFtQixDQUFDO0tBSzlCO0lBMUJHLElBQ0ksTUFBTSxDQUFDLEtBQXFCO1FBQzVCLElBQUksQ0FBQyxLQUFLLEVBQUUsVUFBVSxFQUFFO1lBQ3BCLE9BQU87U0FDVjtRQUVELEtBQUssSUFBSSxVQUFVLElBQUksS0FBSyxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLEVBQUU7WUFDakQsTUFBTSxNQUFNLEdBQUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDN0MsTUFBTSxJQUFJLEdBQUcsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDdkMsTUFBTSxVQUFVLEdBQUcsR0FBRyxNQUFNLEdBQUcsSUFBSSxHQUFHLEtBQUssQ0FBQyxRQUFRLElBQUksaUJBQWlCLE1BQU0sVUFBVSxFQUFFLENBQUM7WUFDNUYsSUFBSSxRQUFRLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsRUFBRTtnQkFDbEMsSUFBSSxDQUFDLElBQUksR0FBRyxVQUFVLENBQUMsVUFBVSxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsQ0FBQztnQkFDM0MsT0FBTzthQUNWO1NBQ0o7SUFDTCxDQUFDO0lBUUQsWUFBWSxDQUFDLElBQVk7UUFDckIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDL0IsQ0FBQzsrR0E1QlEsYUFBYTttR0FBYixhQUFhLHVLQ2pCMUIsc25CQXVCQSxtT0RaYyxZQUFZLDJKQUFFLGVBQWUsMk5BQUUsYUFBYSxtTEFBRSxhQUFhOzs0RkFNNUQsYUFBYTtrQkFSekIsU0FBUztpQ0FDTSxJQUFJLFdBQ1AsQ0FBQyxZQUFZLEVBQUUsZUFBZSxFQUFFLGFBQWEsRUFBRSxhQUFhLENBQUMsWUFDNUQsY0FBYyxtQkFHUCx1QkFBdUIsQ0FBQyxNQUFNOzhCQUd0QyxVQUFVO3NCQUFsQixLQUFLO2dCQUdGLE1BQU07c0JBRFQsS0FBSztnQkFpQkksVUFBVTtzQkFBbkIsTUFBTSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDb21wb25lbnQsIEV2ZW50RW1pdHRlciwgSW5wdXQsIE91dHB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE1hdEJ1dHRvbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2J1dHRvbic7XG5pbXBvcnQgeyBNYXRJY29uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvaWNvbic7XG5pbXBvcnQgeyBNYXRNZW51TW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvbWVudSc7XG5cbmltcG9ydCB7IERFRkFVTFRfRk9OVF9GQU1JTFksIERFRkFVTFRfRk9OVF9TSVpFIH0gZnJvbSAnLi4vLi4vLi4vLi4vLi4vZWRpdG9yL2NvbnRlbnQvY29uc3RhbnRzL2VkaXRvci5jb25zdCc7XG5pbXBvcnQgeyBJVG9vbGJhclN0eWxlcyB9IGZyb20gJy4uLy4uLy4uLy4uLy4uL2VkaXRvci9jb250ZW50L2Rpc3BsYXktZGF0YS90b29sYmFyLXN0eWxlcy5pbnRlcmZhY2UnO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzdGFuZGFsb25lOiB0cnVlLFxuICAgIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIE1hdEJ1dHRvbk1vZHVsZSwgTWF0SWNvbk1vZHVsZSwgTWF0TWVudU1vZHVsZV0sXG4gICAgc2VsZWN0b3I6ICdhcHAtbm9kLWZvbnQnLFxuICAgIHRlbXBsYXRlVXJsOiAnZm9udC5jb21wb25lbnQuaHRtbCcsXG4gICAgc3R5bGVVcmxzOiBbJ2ZvbnQuY29tcG9uZW50LnNjc3MnXSxcbiAgICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaFxufSlcbmV4cG9ydCBjbGFzcyBGb250Q29tcG9uZW50IHtcbiAgICBASW5wdXQoKSBpc0Rpc2FibGVkID0gZmFsc2U7XG5cbiAgICBASW5wdXQoKVxuICAgIHNldCBzdHlsZXModmFsdWU6IElUb29sYmFyU3R5bGVzKSB7XG4gICAgICAgIGlmICghdmFsdWU/LmZvbnRGYW1pbHkpIHtcbiAgICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuXG4gICAgICAgIGZvciAobGV0IGZvbnRGYW1pbHkgb2YgdmFsdWUuZm9udEZhbWlseS5zcGxpdCgnLCAnKSkge1xuICAgICAgICAgICAgY29uc3QgaXRhbGljID0gdmFsdWUuaXRhbGljID8gJ2l0YWxpYyAnIDogJyc7XG4gICAgICAgICAgICBjb25zdCBib2xkID0gdmFsdWUuYm9sZCA/ICdib2xkICcgOiAnJztcbiAgICAgICAgICAgIGNvbnN0IGZvbnRTdHlsZXMgPSBgJHtpdGFsaWN9JHtib2xkfSR7dmFsdWUuZm9udFNpemUgPz8gREVGQVVMVF9GT05UX1NJWkV9cHQgJHtmb250RmFtaWx5fWA7XG4gICAgICAgICAgICBpZiAoZG9jdW1lbnQuZm9udHMuY2hlY2soZm9udFN0eWxlcykpIHtcbiAgICAgICAgICAgICAgICB0aGlzLmZvbnQgPSBmb250RmFtaWx5LnJlcGxhY2VBbGwoJ1wiJywgJycpO1xuICAgICAgICAgICAgICAgIHJldHVybjtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgIH1cblxuICAgIEBPdXRwdXQoKSBzZWxlY3RGb250ID0gbmV3IEV2ZW50RW1pdHRlcjxzdHJpbmc+KCk7XG5cbiAgICBmb250cyA9IFsnQXJpYWwnLCBERUZBVUxUX0ZPTlRfRkFNSUxZLCAnVGltZXMgTmV3IFJvbWFuJywgJ1ZlcmRhbmEnXTtcblxuICAgIGZvbnQgPSBERUZBVUxUX0ZPTlRfRkFNSUxZO1xuXG4gICAgb25TZWxlY3RGb250KGZvbnQ6IHN0cmluZyk6IHZvaWQge1xuICAgICAgICB0aGlzLnNlbGVjdEZvbnQuZW1pdChmb250KTtcbiAgICB9XG59XG4iLCI8YnV0dG9uXG4gICAgbWF0LWJ1dHRvblxuICAgIFttYXRNZW51VHJpZ2dlckZvcl09XCJmb250TWVudVwiXG4gICAgW21hdE1lbnVUcmlnZ2VyUmVzdG9yZUZvY3VzXT1cImZhbHNlXCI+XG4gICAgPGRpdiBjbGFzcz1cImZvbnQtbWVudVwiPlxuICAgICAgICA8c3Bhbj57eyBmb250IH19PC9zcGFuPlxuICAgICAgICA8bWF0LWljb25cbiAgICAgICAgICAgIGZvbnRTZXQ9XCJub2Rlci1pY29uXCJcbiAgICAgICAgICAgIGZvbnRJY29uPVwiaWNvbi1hcnJvdy1kcm9wZG93blwiPjwvbWF0LWljb24+XG4gICAgPC9kaXY+XG48L2J1dHRvbj5cbjxtYXQtbWVudVxuICAgICNmb250TWVudT1cIm1hdE1lbnVcIlxuICAgIGNsYXNzPVwibm9kZXItbW9kYWxcIj5cbiAgICA8bmctY29udGFpbmVyICpuZ0Zvcj1cImxldCBmb250IG9mIGZvbnRzXCI+XG4gICAgICAgIDxidXR0b25cbiAgICAgICAgICAgIG1hdC1tZW51LWl0ZW1cbiAgICAgICAgICAgIFtkaXNhYmxlZF09XCJpc0Rpc2FibGVkXCJcbiAgICAgICAgICAgIChjbGljayk9XCJvblNlbGVjdEZvbnQoZm9udClcIj5cbiAgICAgICAgICAgIHt7IGZvbnQgfX1cbiAgICAgICAgPC9idXR0b24+XG4gICAgPC9uZy1jb250YWluZXI+XG48L21hdC1tZW51PlxuIl19