@tinymce/tinymce-angular 4.2.5-rc.20210919050154855.sha0b70a66 → 5.0.0-feature.20220112013259140.sha34bc082

package/README.md

@@ -11,6 +11,10 @@ This package is a thin wrapper around [TinyMCE](https://github.com/tinymce/tinym
 
 ### Support
 
+For Angular 13+, use integration version 5.x:
+
+`npm install @tinymce/tinymce-angular@^5.0.0`
+
 For Angular 9+, use integration version 4.x:
 
 `npm install @tinymce/tinymce-angular@^4.0.0`

package/editor/Events.d.ts

@@ -1,7 +1,9 @@
 import { EventEmitter } from '@angular/core';
+import { Editor as TinyMCEEditor } from 'tinymce';
+import * as i0 from "@angular/core";
 export interface EventObj<T> {
     event: T;
-    editor: any;
+    editor: TinyMCEEditor;
 }
 export declare class Events {
     onBeforePaste: EventEmitter<EventObj<ClipboardEvent>>;
@@ -69,5 +71,7 @@ export declare class Events {
     onSubmit: EventEmitter<EventObj<any>>;
     onUndo: EventEmitter<EventObj<any>>;
     onVisualAid: EventEmitter<EventObj<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Events, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Events, never, never, {}, { "onBeforePaste": "onBeforePaste"; "onBlur": "onBlur"; "onClick": "onClick"; "onContextMenu": "onContextMenu"; "onCopy": "onCopy"; "onCut": "onCut"; "onDblclick": "onDblclick"; "onDrag": "onDrag"; "onDragDrop": "onDragDrop"; "onDragEnd": "onDragEnd"; "onDragGesture": "onDragGesture"; "onDragOver": "onDragOver"; "onDrop": "onDrop"; "onFocus": "onFocus"; "onFocusIn": "onFocusIn"; "onFocusOut": "onFocusOut"; "onKeyDown": "onKeyDown"; "onKeyPress": "onKeyPress"; "onKeyUp": "onKeyUp"; "onMouseDown": "onMouseDown"; "onMouseEnter": "onMouseEnter"; "onMouseLeave": "onMouseLeave"; "onMouseMove": "onMouseMove"; "onMouseOut": "onMouseOut"; "onMouseOver": "onMouseOver"; "onMouseUp": "onMouseUp"; "onPaste": "onPaste"; "onSelectionChange": "onSelectionChange"; "onActivate": "onActivate"; "onAddUndo": "onAddUndo"; "onBeforeAddUndo": "onBeforeAddUndo"; "onBeforeExecCommand": "onBeforeExecCommand"; "onBeforeGetContent": "onBeforeGetContent"; "onBeforeRenderUI": "onBeforeRenderUI"; "onBeforeSetContent": "onBeforeSetContent"; "onChange": "onChange"; "onClearUndos": "onClearUndos"; "onDeactivate": "onDeactivate"; "onDirty": "onDirty"; "onExecCommand": "onExecCommand"; "onGetContent": "onGetContent"; "onHide": "onHide"; "onInit": "onInit"; "onInitNgModel": "onInitNgModel"; "onLoadContent": "onLoadContent"; "onNodeChange": "onNodeChange"; "onPostProcess": "onPostProcess"; "onPostRender": "onPostRender"; "onPreInit": "onPreInit"; "onPreProcess": "onPreProcess"; "onProgressState": "onProgressState"; "onRedo": "onRedo"; "onRemove": "onRemove"; "onReset": "onReset"; "onResizeEditor": "onResizeEditor"; "onSaveContent": "onSaveContent"; "onSetAttrib": "onSetAttrib"; "onObjectResizeStart": "onObjectResizeStart"; "onObjectResized": "onObjectResized"; "onObjectSelected": "onObjectSelected"; "onSetContent": "onSetContent"; "onShow": "onShow"; "onSubmit": "onSubmit"; "onUndo": "onUndo"; "onVisualAid": "onVisualAid"; }, never>;
 }
 export declare const validEvents: (keyof Events)[];

package/editor/editor.component.d.ts

@@ -1,13 +1,15 @@
 import { AfterViewInit, ElementRef, NgZone, OnDestroy, InjectionToken } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
 import { Events } from './Events';
+import { Editor as TinyMCEEditor, RawEditorSettings } from 'tinymce';
+import * as i0 from "@angular/core";
 export declare const TINYMCE_SCRIPT_SRC: InjectionToken<string>;
 export declare class EditorComponent extends Events implements AfterViewInit, ControlValueAccessor, OnDestroy {
     private platformId;
     private tinymceScriptSrc?;
     cloudChannel: string;
     apiKey: string;
-    init: Record<string, any> | undefined;
+    init: RawEditorSettings | undefined;
     id: string;
     initialValue: string | undefined;
     outputFormat: 'html' | 'text' | undefined;
@@ -20,7 +22,7 @@ export declare class EditorComponent extends Events implements AfterViewInit, Co
     ignoreEvents: string | string[] | undefined;
     set disabled(val: boolean);
     get disabled(): boolean;
-    get editor(): any;
+    get editor(): TinyMCEEditor;
     ngZone: NgZone;
     private _elementRef;
     private _element;
@@ -28,6 +30,7 @@ export declare class EditorComponent extends Events implements AfterViewInit, Co
     private _editor;
     private onTouchedCallback;
     private onChangeCallback;
+    private destroy$;
     constructor(elementRef: ElementRef, ngZone: NgZone, platformId: Object, tinymceScriptSrc?: string);
     writeValue(value: string | null): void;
     registerOnChange(fn: (_: any) => void): void;
@@ -36,8 +39,10 @@ export declare class EditorComponent extends Events implements AfterViewInit, Co
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     createElement(): void;
-    initialise(): void;
+    initialise: () => void;
     private getScriptSrc;
     private initEditor;
     private emitOnChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorComponent, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditorComponent, "editor", never, { "cloudChannel": "cloudChannel"; "apiKey": "apiKey"; "init": "init"; "id": "id"; "initialValue": "initialValue"; "outputFormat": "outputFormat"; "inline": "inline"; "tagName": "tagName"; "plugins": "plugins"; "toolbar": "toolbar"; "modelEvents": "modelEvents"; "allowedEvents": "allowedEvents"; "ignoreEvents": "ignoreEvents"; "disabled": "disabled"; }, {}, never, never>;
 }

package/editor/editor.module.d.ts

@@ -1,2 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./editor.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
 export declare class EditorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EditorModule, [typeof i1.EditorComponent], [typeof i2.CommonModule, typeof i3.FormsModule], [typeof i1.EditorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EditorModule>;
 }

package/{esm2015/TinyMCE.js → esm2020/TinyMCE.mjs}

@@ -9,7 +9,5 @@ const getTinymce = () => {
     const w = typeof window !== 'undefined' ? window : undefined;
     return w && w.tinymce ? w.tinymce : null;
 };
-const ɵ0 = getTinymce;
 export { getTinymce };
-export { ɵ0 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVGlueU1DRS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RpbnltY2UtYW5ndWxhci1jb21wb25lbnQvc3JjL21haW4vdHMvVGlueU1DRS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxNQUFNLFVBQVUsR0FBRyxHQUFHLEVBQUU7SUFDdEIsTUFBTSxDQUFDLEdBQUcsT0FBTyxNQUFNLEtBQUssV0FBVyxDQUFDLENBQUMsQ0FBRSxNQUFjLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQztJQUN0RSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7QUFDM0MsQ0FBQyxDQUFDOztBQUVGLE9BQU8sRUFBRSxVQUFVLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IChjKSAyMDE3LXByZXNlbnQsIEVwaG94LCBJbmMuXG4gKlxuICogVGhpcyBzb3VyY2UgY29kZSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIDIgbGljZW5zZSBmb3VuZCBpbiB0aGVcbiAqIExJQ0VOU0UgZmlsZSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBzb3VyY2UgdHJlZS5cbiAqXG4gKi9cblxuY29uc3QgZ2V0VGlueW1jZSA9ICgpID0+IHtcbiAgY29uc3QgdyA9IHR5cGVvZiB3aW5kb3cgIT09ICd1bmRlZmluZWQnID8gKHdpbmRvdyBhcyBhbnkpIDogdW5kZWZpbmVkO1xuICByZXR1cm4gdyAmJiB3LnRpbnltY2UgPyB3LnRpbnltY2UgOiBudWxsO1xufTtcblxuZXhwb3J0IHsgZ2V0VGlueW1jZSB9O1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVGlueU1DRS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RpbnltY2UtYW5ndWxhci1jb21wb25lbnQvc3JjL21haW4vdHMvVGlueU1DRS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxNQUFNLFVBQVUsR0FBRyxHQUFHLEVBQUU7SUFDdEIsTUFBTSxDQUFDLEdBQUcsT0FBTyxNQUFNLEtBQUssV0FBVyxDQUFDLENBQUMsQ0FBRSxNQUFjLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQztJQUN0RSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7QUFDM0MsQ0FBQyxDQUFDO0FBRUYsT0FBTyxFQUFFLFVBQVUsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTctcHJlc2VudCwgRXBob3gsIEluYy5cbiAqXG4gKiBUaGlzIHNvdXJjZSBjb2RlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgMiBsaWNlbnNlIGZvdW5kIGluIHRoZVxuICogTElDRU5TRSBmaWxlIGluIHRoZSByb290IGRpcmVjdG9yeSBvZiB0aGlzIHNvdXJjZSB0cmVlLlxuICpcbiAqL1xuXG5jb25zdCBnZXRUaW55bWNlID0gKCkgPT4ge1xuICBjb25zdCB3ID0gdHlwZW9mIHdpbmRvdyAhPT0gJ3VuZGVmaW5lZCcgPyAod2luZG93IGFzIGFueSkgOiB1bmRlZmluZWQ7XG4gIHJldHVybiB3ICYmIHcudGlueW1jZSA/IHcudGlueW1jZSA6IG51bGw7XG59O1xuXG5leHBvcnQgeyBnZXRUaW55bWNlIH07XG4iXX0=

package/esm2020/editor/Events.mjs

@@ -0,0 +1,272 @@
+import { Output, EventEmitter, Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class Events {
+    constructor() {
+        this.onBeforePaste = new EventEmitter();
+        this.onBlur = new EventEmitter();
+        this.onClick = new EventEmitter();
+        this.onContextMenu = new EventEmitter();
+        this.onCopy = new EventEmitter();
+        this.onCut = new EventEmitter();
+        this.onDblclick = new EventEmitter();
+        this.onDrag = new EventEmitter();
+        this.onDragDrop = new EventEmitter();
+        this.onDragEnd = new EventEmitter();
+        this.onDragGesture = new EventEmitter();
+        this.onDragOver = new EventEmitter();
+        this.onDrop = new EventEmitter();
+        this.onFocus = new EventEmitter();
+        this.onFocusIn = new EventEmitter();
+        this.onFocusOut = new EventEmitter();
+        this.onKeyDown = new EventEmitter();
+        this.onKeyPress = new EventEmitter();
+        this.onKeyUp = new EventEmitter();
+        this.onMouseDown = new EventEmitter();
+        this.onMouseEnter = new EventEmitter();
+        this.onMouseLeave = new EventEmitter();
+        this.onMouseMove = new EventEmitter();
+        this.onMouseOut = new EventEmitter();
+        this.onMouseOver = new EventEmitter();
+        this.onMouseUp = new EventEmitter();
+        this.onPaste = new EventEmitter();
+        this.onSelectionChange = new EventEmitter();
+        this.onActivate = new EventEmitter();
+        this.onAddUndo = new EventEmitter();
+        this.onBeforeAddUndo = new EventEmitter();
+        this.onBeforeExecCommand = new EventEmitter();
+        this.onBeforeGetContent = new EventEmitter();
+        this.onBeforeRenderUI = new EventEmitter();
+        this.onBeforeSetContent = new EventEmitter();
+        this.onChange = new EventEmitter();
+        this.onClearUndos = new EventEmitter();
+        this.onDeactivate = new EventEmitter();
+        this.onDirty = new EventEmitter();
+        this.onExecCommand = new EventEmitter();
+        this.onGetContent = new EventEmitter();
+        this.onHide = new EventEmitter();
+        this.onInit = new EventEmitter();
+        this.onInitNgModel = new EventEmitter();
+        this.onLoadContent = new EventEmitter();
+        this.onNodeChange = new EventEmitter();
+        this.onPostProcess = new EventEmitter();
+        this.onPostRender = new EventEmitter();
+        this.onPreInit = new EventEmitter();
+        this.onPreProcess = new EventEmitter();
+        this.onProgressState = new EventEmitter();
+        this.onRedo = new EventEmitter();
+        this.onRemove = new EventEmitter();
+        this.onReset = new EventEmitter();
+        this.onResizeEditor = new EventEmitter();
+        this.onSaveContent = new EventEmitter();
+        this.onSetAttrib = new EventEmitter();
+        this.onObjectResizeStart = new EventEmitter();
+        this.onObjectResized = new EventEmitter();
+        this.onObjectSelected = new EventEmitter();
+        this.onSetContent = new EventEmitter();
+        this.onShow = new EventEmitter();
+        this.onSubmit = new EventEmitter();
+        this.onUndo = new EventEmitter();
+        this.onVisualAid = new EventEmitter();
+    }
+}
+Events.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: Events, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+Events.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.2", type: Events, outputs: { onBeforePaste: "onBeforePaste", onBlur: "onBlur", onClick: "onClick", onContextMenu: "onContextMenu", onCopy: "onCopy", onCut: "onCut", onDblclick: "onDblclick", onDrag: "onDrag", onDragDrop: "onDragDrop", onDragEnd: "onDragEnd", onDragGesture: "onDragGesture", onDragOver: "onDragOver", onDrop: "onDrop", onFocus: "onFocus", onFocusIn: "onFocusIn", onFocusOut: "onFocusOut", onKeyDown: "onKeyDown", onKeyPress: "onKeyPress", onKeyUp: "onKeyUp", onMouseDown: "onMouseDown", onMouseEnter: "onMouseEnter", onMouseLeave: "onMouseLeave", onMouseMove: "onMouseMove", onMouseOut: "onMouseOut", onMouseOver: "onMouseOver", onMouseUp: "onMouseUp", onPaste: "onPaste", onSelectionChange: "onSelectionChange", onActivate: "onActivate", onAddUndo: "onAddUndo", onBeforeAddUndo: "onBeforeAddUndo", onBeforeExecCommand: "onBeforeExecCommand", onBeforeGetContent: "onBeforeGetContent", onBeforeRenderUI: "onBeforeRenderUI", onBeforeSetContent: "onBeforeSetContent", onChange: "onChange", onClearUndos: "onClearUndos", onDeactivate: "onDeactivate", onDirty: "onDirty", onExecCommand: "onExecCommand", onGetContent: "onGetContent", onHide: "onHide", onInit: "onInit", onInitNgModel: "onInitNgModel", onLoadContent: "onLoadContent", onNodeChange: "onNodeChange", onPostProcess: "onPostProcess", onPostRender: "onPostRender", onPreInit: "onPreInit", onPreProcess: "onPreProcess", onProgressState: "onProgressState", onRedo: "onRedo", onRemove: "onRemove", onReset: "onReset", onResizeEditor: "onResizeEditor", onSaveContent: "onSaveContent", onSetAttrib: "onSetAttrib", onObjectResizeStart: "onObjectResizeStart", onObjectResized: "onObjectResized", onObjectSelected: "onObjectSelected", onSetContent: "onSetContent", onShow: "onShow", onSubmit: "onSubmit", onUndo: "onUndo", onVisualAid: "onVisualAid" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: Events, decorators: [{
+            type: Directive
+        }], propDecorators: { onBeforePaste: [{
+                type: Output
+            }], onBlur: [{
+                type: Output
+            }], onClick: [{
+                type: Output
+            }], onContextMenu: [{
+                type: Output
+            }], onCopy: [{
+                type: Output
+            }], onCut: [{
+                type: Output
+            }], onDblclick: [{
+                type: Output
+            }], onDrag: [{
+                type: Output
+            }], onDragDrop: [{
+                type: Output
+            }], onDragEnd: [{
+                type: Output
+            }], onDragGesture: [{
+                type: Output
+            }], onDragOver: [{
+                type: Output
+            }], onDrop: [{
+                type: Output
+            }], onFocus: [{
+                type: Output
+            }], onFocusIn: [{
+                type: Output
+            }], onFocusOut: [{
+                type: Output
+            }], onKeyDown: [{
+                type: Output
+            }], onKeyPress: [{
+                type: Output
+            }], onKeyUp: [{
+                type: Output
+            }], onMouseDown: [{
+                type: Output
+            }], onMouseEnter: [{
+                type: Output
+            }], onMouseLeave: [{
+                type: Output
+            }], onMouseMove: [{
+                type: Output
+            }], onMouseOut: [{
+                type: Output
+            }], onMouseOver: [{
+                type: Output
+            }], onMouseUp: [{
+                type: Output
+            }], onPaste: [{
+                type: Output
+            }], onSelectionChange: [{
+                type: Output
+            }], onActivate: [{
+                type: Output
+            }], onAddUndo: [{
+                type: Output
+            }], onBeforeAddUndo: [{
+                type: Output
+            }], onBeforeExecCommand: [{
+                type: Output
+            }], onBeforeGetContent: [{
+                type: Output
+            }], onBeforeRenderUI: [{
+                type: Output
+            }], onBeforeSetContent: [{
+                type: Output
+            }], onChange: [{
+                type: Output
+            }], onClearUndos: [{
+                type: Output
+            }], onDeactivate: [{
+                type: Output
+            }], onDirty: [{
+                type: Output
+            }], onExecCommand: [{
+                type: Output
+            }], onGetContent: [{
+                type: Output
+            }], onHide: [{
+                type: Output
+            }], onInit: [{
+                type: Output
+            }], onInitNgModel: [{
+                type: Output
+            }], onLoadContent: [{
+                type: Output
+            }], onNodeChange: [{
+                type: Output
+            }], onPostProcess: [{
+                type: Output
+            }], onPostRender: [{
+                type: Output
+            }], onPreInit: [{
+                type: Output
+            }], onPreProcess: [{
+                type: Output
+            }], onProgressState: [{
+                type: Output
+            }], onRedo: [{
+                type: Output
+            }], onRemove: [{
+                type: Output
+            }], onReset: [{
+                type: Output
+            }], onResizeEditor: [{
+                type: Output
+            }], onSaveContent: [{
+                type: Output
+            }], onSetAttrib: [{
+                type: Output
+            }], onObjectResizeStart: [{
+                type: Output
+            }], onObjectResized: [{
+                type: Output
+            }], onObjectSelected: [{
+                type: Output
+            }], onSetContent: [{
+                type: Output
+            }], onShow: [{
+                type: Output
+            }], onSubmit: [{
+                type: Output
+            }], onUndo: [{
+                type: Output
+            }], onVisualAid: [{
+                type: Output
+            }] } });
+export const validEvents = [
+    'onActivate',
+    'onAddUndo',
+    'onBeforeAddUndo',
+    'onBeforeExecCommand',
+    'onBeforeGetContent',
+    'onBeforeRenderUI',
+    'onBeforeSetContent',
+    'onBeforePaste',
+    'onBlur',
+    'onChange',
+    'onClearUndos',
+    'onClick',
+    'onContextMenu',
+    'onCopy',
+    'onCut',
+    'onDblclick',
+    'onDeactivate',
+    'onDirty',
+    'onDrag',
+    'onDragDrop',
+    'onDragEnd',
+    'onDragGesture',
+    'onDragOver',
+    'onDrop',
+    'onExecCommand',
+    'onFocus',
+    'onFocusIn',
+    'onFocusOut',
+    'onGetContent',
+    'onHide',
+    'onInit',
+    'onKeyDown',
+    'onKeyPress',
+    'onKeyUp',
+    'onLoadContent',
+    'onMouseDown',
+    'onMouseEnter',
+    'onMouseLeave',
+    'onMouseMove',
+    'onMouseOut',
+    'onMouseOver',
+    'onMouseUp',
+    'onNodeChange',
+    'onObjectResizeStart',
+    'onObjectResized',
+    'onObjectSelected',
+    'onPaste',
+    'onPostProcess',
+    'onPostRender',
+    'onPreProcess',
+    'onProgressState',
+    'onRedo',
+    'onRemove',
+    'onReset',
+    'onResizeEditor',
+    'onSaveContent',
+    'onSelectionChange',
+    'onSetAttrib',
+    'onSetContent',
+    'onShow',
+    'onSubmit',
+    'onUndo',
+    'onVisualAid'
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Events.js","sourceRoot":"","sources":["../../../../tinymce-angular-component/src/main/ts/editor/Events.ts"],"names":[],"mappings":"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","sourcesContent":["import { Output, EventEmitter, Directive } from '@angular/core';\nimport { Editor as TinyMCEEditor } from 'tinymce';\n\nexport interface EventObj<T> {\n  event: T;\n  editor: TinyMCEEditor;\n}\n\n@Directive()\nexport class Events {\n  @Output() public onBeforePaste: EventEmitter<EventObj<ClipboardEvent>> = new EventEmitter();\n  @Output() public onBlur: EventEmitter<EventObj<FocusEvent>> = new EventEmitter();\n  @Output() public onClick: EventEmitter<EventObj<MouseEvent>> = new EventEmitter();\n  @Output() public onContextMenu: EventEmitter<EventObj<MouseEvent>> = new EventEmitter();\n  @Output() public onCopy: EventEmitter<EventObj<ClipboardEvent>> = new EventEmitter();\n  @Output() public onCut: EventEmitter<EventObj<ClipboardEvent>> = new EventEmitter();\n  @Output() public onDblclick: EventEmitter<EventObj<MouseEvent>> = new EventEmitter();\n  @Output() public onDrag: EventEmitter<EventObj<DragEvent>> = new EventEmitter();\n  @Output() public onDragDrop: EventEmitter<EventObj<DragEvent>> = new EventEmitter();\n  @Output() public onDragEnd: EventEmitter<EventObj<DragEvent>> = new EventEmitter();\n  @Output() public onDragGesture: EventEmitter<EventObj<DragEvent>> = new EventEmitter();\n  @Output() public onDragOver: EventEmitter<EventObj<DragEvent>> = new EventEmitter();\n  @Output() public onDrop: EventEmitter<EventObj<DragEvent>> = new EventEmitter();\n  @Output() public onFocus: EventEmitter<EventObj<FocusEvent>> = new EventEmitter();\n  @Output() public onFocusIn: EventEmitter<EventObj<FocusEvent>> = new EventEmitter();\n  @Output() public onFocusOut: EventEmitter<EventObj<FocusEvent>> = new EventEmitter();\n  @Output() public onKeyDown: EventEmitter<EventObj<KeyboardEvent>> = new EventEmitter();\n  @Output() public onKeyPress: EventEmitter<EventObj<KeyboardEvent>> = new EventEmitter();\n  @Output() public onKeyUp: EventEmitter<EventObj<KeyboardEvent>> = new EventEmitter();\n  @Output() public onMouseDown: EventEmitter<EventObj<MouseEvent>> = new EventEmitter();\n  @Output() public onMouseEnter: EventEmitter<EventObj<MouseEvent>> = new EventEmitter();\n  @Output() public onMouseLeave: EventEmitter<EventObj<MouseEvent>> = new EventEmitter();\n  @Output() public onMouseMove: EventEmitter<EventObj<MouseEvent>> = new EventEmitter();\n  @Output() public onMouseOut: EventEmitter<EventObj<MouseEvent>> = new EventEmitter();\n  @Output() public onMouseOver: EventEmitter<EventObj<MouseEvent>> = new EventEmitter();\n  @Output() public onMouseUp: EventEmitter<EventObj<MouseEvent>> = new EventEmitter();\n  @Output() public onPaste: EventEmitter<EventObj<ClipboardEvent>> = new EventEmitter();\n  @Output() public onSelectionChange: EventEmitter<EventObj<Event>> = new EventEmitter();\n  @Output() public onActivate: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onAddUndo: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onBeforeAddUndo: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onBeforeExecCommand: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onBeforeGetContent: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onBeforeRenderUI: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onBeforeSetContent: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onChange: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onClearUndos: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onDeactivate: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onDirty: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onExecCommand: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onGetContent: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onHide: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onInit: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onInitNgModel: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onLoadContent: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onNodeChange: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onPostProcess: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onPostRender: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onPreInit: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onPreProcess: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onProgressState: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onRedo: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onRemove: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onReset: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onResizeEditor: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onSaveContent: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onSetAttrib: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onObjectResizeStart: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onObjectResized: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onObjectSelected: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onSetContent: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onShow: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onSubmit: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onUndo: EventEmitter<EventObj<any>> = new EventEmitter();\n  @Output() public onVisualAid: EventEmitter<EventObj<any>> = new EventEmitter();\n}\n\nexport const validEvents: (keyof Events)[] = [\n  'onActivate',\n  'onAddUndo',\n  'onBeforeAddUndo',\n  'onBeforeExecCommand',\n  'onBeforeGetContent',\n  'onBeforeRenderUI',\n  'onBeforeSetContent',\n  'onBeforePaste',\n  'onBlur',\n  'onChange',\n  'onClearUndos',\n  'onClick',\n  'onContextMenu',\n  'onCopy',\n  'onCut',\n  'onDblclick',\n  'onDeactivate',\n  'onDirty',\n  'onDrag',\n  'onDragDrop',\n  'onDragEnd',\n  'onDragGesture',\n  'onDragOver',\n  'onDrop',\n  'onExecCommand',\n  'onFocus',\n  'onFocusIn',\n  'onFocusOut',\n  'onGetContent',\n  'onHide',\n  'onInit',\n  'onKeyDown',\n  'onKeyPress',\n  'onKeyUp',\n  'onLoadContent',\n  'onMouseDown',\n  'onMouseEnter',\n  'onMouseLeave',\n  'onMouseMove',\n  'onMouseOut',\n  'onMouseOver',\n  'onMouseUp',\n  'onNodeChange',\n  'onObjectResizeStart',\n  'onObjectResized',\n  'onObjectSelected',\n  'onPaste',\n  'onPostProcess',\n  'onPostRender',\n  'onPreProcess',\n  'onProgressState',\n  'onRedo',\n  'onRemove',\n  'onReset',\n  'onResizeEditor',\n  'onSaveContent',\n  'onSelectionChange',\n  'onSetAttrib',\n  'onSetContent',\n  'onShow',\n  'onSubmit',\n  'onUndo',\n  'onVisualAid'\n];\n"]}

package/esm2020/editor/editor.component.mjs

@@ -0,0 +1,203 @@
+/* eslint-disable @typescript-eslint/no-parameter-properties */
+import { isPlatformBrowser } from '@angular/common';
+import { Component, forwardRef, Inject, Input, PLATFORM_ID, InjectionToken, Optional } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { getTinymce } from '../TinyMCE';
+import { listenTinyMCEEvent, bindHandlers, isTextarea, mergePlugins, uuid, noop, isNullOrUndefined } from '../utils/Utils';
+import { Events } from './Events';
+import { ScriptLoader } from '../utils/ScriptLoader';
+import * as i0 from "@angular/core";
+export const TINYMCE_SCRIPT_SRC = new InjectionToken('TINYMCE_SCRIPT_SRC');
+const EDITOR_COMPONENT_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => EditorComponent),
+    multi: true
+};
+export class EditorComponent extends Events {
+    constructor(elementRef, ngZone, platformId, tinymceScriptSrc) {
+        super();
+        this.platformId = platformId;
+        this.tinymceScriptSrc = tinymceScriptSrc;
+        this.cloudChannel = '5';
+        this.apiKey = 'no-api-key';
+        this.id = '';
+        this.modelEvents = 'change input undo redo';
+        this.onTouchedCallback = noop;
+        this.destroy$ = new Subject();
+        this.initialise = () => {
+            const finalInit = {
+                ...this.init,
+                selector: undefined,
+                target: this._element,
+                inline: this.inline,
+                readonly: this.disabled,
+                plugins: mergePlugins((this.init && this.init.plugins), this.plugins),
+                toolbar: this.toolbar || (this.init && this.init.toolbar),
+                setup: (editor) => {
+                    this._editor = editor;
+                    listenTinyMCEEvent(editor, 'init', this.destroy$).subscribe(() => {
+                        this.initEditor(editor);
+                    });
+                    bindHandlers(this, editor, this.destroy$);
+                    if (this.init && typeof this.init.setup === 'function') {
+                        this.init.setup(editor);
+                    }
+                }
+            };
+            if (isTextarea(this._element)) {
+                this._element.style.visibility = '';
+            }
+            this.ngZone.runOutsideAngular(() => {
+                getTinymce().init(finalInit);
+            });
+        };
+        this._elementRef = elementRef;
+        this.ngZone = ngZone;
+    }
+    set disabled(val) {
+        this._disabled = val;
+        if (this._editor && this._editor.initialized) {
+            this._editor.setMode(val ? 'readonly' : 'design');
+        }
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    get editor() {
+        return this._editor;
+    }
+    writeValue(value) {
+        if (this._editor && this._editor.initialized) {
+            this._editor.setContent(isNullOrUndefined(value) ? '' : value);
+        }
+        else {
+            this.initialValue = value === null ? undefined : value;
+        }
+    }
+    registerOnChange(fn) {
+        this.onChangeCallback = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouchedCallback = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    ngAfterViewInit() {
+        if (isPlatformBrowser(this.platformId)) {
+            this.id = this.id || uuid('tiny-angular');
+            this.inline = this.inline !== undefined ? this.inline !== false : !!(this.init?.inline);
+            this.createElement();
+            if (getTinymce() !== null) {
+                this.initialise();
+            }
+            else if (this._element && this._element.ownerDocument) {
+                // Caretaker note: the component might be destroyed before the script is loaded and its code is executed.
+                // This will lead to runtime exceptions if `initialise` will be called when the component has been destroyed.
+                ScriptLoader.load(this._element.ownerDocument, this.getScriptSrc())
+                    .pipe(takeUntil(this.destroy$))
+                    .subscribe(this.initialise);
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        if (getTinymce() !== null) {
+            getTinymce().remove(this._editor);
+        }
+    }
+    createElement() {
+        const tagName = typeof this.tagName === 'string' ? this.tagName : 'div';
+        this._element = document.createElement(this.inline ? tagName : 'textarea');
+        if (this._element) {
+            if (document.getElementById(this.id)) {
+                /* eslint no-console: ["error", { allow: ["warn"] }] */
+                console.warn(`TinyMCE-Angular: an element with id [${this.id}] already exists. Editors with duplicate Id will not be able to mount`);
+            }
+            this._element.id = this.id;
+            if (isTextarea(this._element)) {
+                this._element.style.visibility = 'hidden';
+            }
+            this._elementRef.nativeElement.appendChild(this._element);
+        }
+    }
+    getScriptSrc() {
+        return isNullOrUndefined(this.tinymceScriptSrc) ?
+            `https://cdn.tiny.cloud/1/${this.apiKey}/tinymce/${this.cloudChannel}/tinymce.min.js` :
+            this.tinymceScriptSrc;
+    }
+    initEditor(editor) {
+        listenTinyMCEEvent(editor, 'blur', this.destroy$).subscribe(() => {
+            this.ngZone.run(() => this.onTouchedCallback());
+        });
+        listenTinyMCEEvent(editor, this.modelEvents, this.destroy$).subscribe(() => {
+            this.ngZone.run(() => this.emitOnChange(editor));
+        });
+        if (typeof this.initialValue === 'string') {
+            this.ngZone.run(() => {
+                editor.setContent(this.initialValue);
+                if (editor.getContent() !== this.initialValue) {
+                    this.emitOnChange(editor);
+                }
+                if (this.onInitNgModel !== undefined) {
+                    this.onInitNgModel.emit(editor);
+                }
+            });
+        }
+    }
+    emitOnChange(editor) {
+        if (this.onChangeCallback) {
+            this.onChangeCallback(editor.getContent({ format: this.outputFormat }));
+        }
+    }
+}
+EditorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: EditorComponent, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: PLATFORM_ID }, { token: TINYMCE_SCRIPT_SRC, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+EditorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: EditorComponent, selector: "editor", inputs: { cloudChannel: "cloudChannel", apiKey: "apiKey", init: "init", id: "id", initialValue: "initialValue", outputFormat: "outputFormat", inline: "inline", tagName: "tagName", plugins: "plugins", toolbar: "toolbar", modelEvents: "modelEvents", allowedEvents: "allowedEvents", ignoreEvents: "ignoreEvents", disabled: "disabled" }, providers: [EDITOR_COMPONENT_VALUE_ACCESSOR], usesInheritance: true, ngImport: i0, template: '<ng-template></ng-template>', isInline: true, styles: [":host{display:block}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: EditorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'editor',
+                    template: '<ng-template></ng-template>',
+                    styles: [':host { display: block; }'],
+                    providers: [EDITOR_COMPONENT_VALUE_ACCESSOR]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TINYMCE_SCRIPT_SRC]
+                }] }]; }, propDecorators: { cloudChannel: [{
+                type: Input
+            }], apiKey: [{
+                type: Input
+            }], init: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], initialValue: [{
+                type: Input
+            }], outputFormat: [{
+                type: Input
+            }], inline: [{
+                type: Input
+            }], tagName: [{
+                type: Input
+            }], plugins: [{
+                type: Input
+            }], toolbar: [{
+                type: Input
+            }], modelEvents: [{
+                type: Input
+            }], allowedEvents: [{
+                type: Input
+            }], ignoreEvents: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor.component.js","sourceRoot":"","sources":["../../../../tinymce-angular-component/src/main/ts/editor/editor.component.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-parameter-properties */\nimport { isPlatformBrowser } from '@angular/common';\nimport { AfterViewInit, Component, ElementRef, forwardRef, Inject, Input, NgZone, OnDestroy, PLATFORM_ID, InjectionToken, Optional } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { getTinymce } from '../TinyMCE';\nimport { listenTinyMCEEvent, bindHandlers, isTextarea, mergePlugins, uuid, noop, isNullOrUndefined } from '../utils/Utils';\nimport { EventObj, Events } from './Events';\nimport { ScriptLoader } from '../utils/ScriptLoader';\nimport { Editor as TinyMCEEditor, RawEditorSettings } from 'tinymce';\n\nexport const TINYMCE_SCRIPT_SRC = new InjectionToken<string>('TINYMCE_SCRIPT_SRC');\n\nconst EDITOR_COMPONENT_VALUE_ACCESSOR = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => EditorComponent),\n  multi: true\n};\n\n@Component({\n  selector: 'editor',\n  template: '<ng-template></ng-template>',\n  styles: [ ':host { display: block; }' ],\n  providers: [ EDITOR_COMPONENT_VALUE_ACCESSOR ]\n})\nexport class EditorComponent extends Events implements AfterViewInit, ControlValueAccessor, OnDestroy {\n\n  @Input() public cloudChannel = '5';\n  @Input() public apiKey = 'no-api-key';\n  @Input() public init: RawEditorSettings | undefined;\n  @Input() public id = '';\n  @Input() public initialValue: string | undefined;\n  @Input() public outputFormat: 'html' | 'text' | undefined;\n  @Input() public inline: boolean | undefined;\n  @Input() public tagName: string | undefined;\n  @Input() public plugins: string | undefined;\n  @Input() public toolbar: string | string[] | undefined;\n  @Input() public modelEvents = 'change input undo redo';\n  @Input() public allowedEvents: string | string[] | undefined;\n  @Input() public ignoreEvents: string | string[] | undefined;\n  @Input()\n  public set disabled(val) {\n    this._disabled = val;\n    if (this._editor && this._editor.initialized) {\n      this._editor.setMode(val ? 'readonly' : 'design');\n    }\n  }\n\n  public get disabled() {\n    return this._disabled;\n  }\n\n  public get editor() {\n    return this._editor;\n  }\n\n  public ngZone: NgZone;\n\n  private _elementRef: ElementRef;\n  private _element: HTMLElement | undefined;\n  private _disabled: boolean | undefined;\n  private _editor: TinyMCEEditor | undefined;\n\n  private onTouchedCallback = noop;\n  private onChangeCallback: any;\n\n  private destroy$ = new Subject<void>();\n\n  public constructor(\n    elementRef: ElementRef,\n    ngZone: NgZone,\n    @Inject(PLATFORM_ID) private platformId: Object,\n    @Optional() @Inject(TINYMCE_SCRIPT_SRC) private tinymceScriptSrc?: string\n  ) {\n    super();\n    this._elementRef = elementRef;\n    this.ngZone = ngZone;\n  }\n\n  public writeValue(value: string | null): void {\n    if (this._editor && this._editor.initialized) {\n      this._editor.setContent(isNullOrUndefined(value) ? '' : value);\n    } else {\n      this.initialValue = value === null ? undefined : value;\n    }\n  }\n\n  public registerOnChange(fn: (_: any) => void): void {\n    this.onChangeCallback = fn;\n  }\n\n  public registerOnTouched(fn: any): void {\n    this.onTouchedCallback = fn;\n  }\n\n  public setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n\n  public ngAfterViewInit() {\n    if (isPlatformBrowser(this.platformId)) {\n      this.id = this.id || uuid('tiny-angular');\n      this.inline = this.inline !== undefined ? this.inline !== false : !!(this.init?.inline);\n      this.createElement();\n      if (getTinymce() !== null) {\n        this.initialise();\n      } else if (this._element && this._element.ownerDocument) {\n        // Caretaker note: the component might be destroyed before the script is loaded and its code is executed.\n        // This will lead to runtime exceptions if `initialise` will be called when the component has been destroyed.\n        ScriptLoader.load(this._element.ownerDocument, this.getScriptSrc())\n          .pipe(takeUntil(this.destroy$))\n          .subscribe(this.initialise);\n      }\n    }\n  }\n\n  public ngOnDestroy() {\n    this.destroy$.next();\n\n    if (getTinymce() !== null) {\n      getTinymce().remove(this._editor);\n    }\n  }\n\n  public createElement() {\n    const tagName = typeof this.tagName === 'string' ? this.tagName : 'div';\n    this._element = document.createElement(this.inline ? tagName : 'textarea');\n    if (this._element) {\n      if (document.getElementById(this.id)) {\n        /* eslint no-console: [\"error\", { allow: [\"warn\"] }] */\n        console.warn(`TinyMCE-Angular: an element with id [${this.id}] already exists. Editors with duplicate Id will not be able to mount`);\n      }\n      this._element.id = this.id;\n      if (isTextarea(this._element)) {\n        this._element.style.visibility = 'hidden';\n      }\n      this._elementRef.nativeElement.appendChild(this._element);\n    }\n  }\n\n  public initialise = (): void => {\n    const finalInit: RawEditorSettings = {\n      ...this.init,\n      selector: undefined,\n      target: this._element,\n      inline: this.inline,\n      readonly: this.disabled,\n      plugins: mergePlugins((this.init && this.init.plugins) as string, this.plugins),\n      toolbar: this.toolbar || (this.init && this.init.toolbar),\n      setup: (editor: TinyMCEEditor) => {\n        this._editor = editor;\n\n        listenTinyMCEEvent(editor, 'init', this.destroy$).subscribe(() => {\n          this.initEditor(editor);\n        });\n\n        bindHandlers(this, editor, this.destroy$);\n\n        if (this.init && typeof this.init.setup === 'function') {\n          this.init.setup(editor);\n        }\n      }\n    };\n\n    if (isTextarea(this._element)) {\n      this._element.style.visibility = '';\n    }\n\n    this.ngZone.runOutsideAngular(() => {\n      getTinymce().init(finalInit);\n    });\n  };\n\n  private getScriptSrc() {\n    return isNullOrUndefined(this.tinymceScriptSrc) ?\n      `https://cdn.tiny.cloud/1/${this.apiKey}/tinymce/${this.cloudChannel}/tinymce.min.js` :\n      this.tinymceScriptSrc;\n  }\n\n  private initEditor(editor: TinyMCEEditor) {\n    listenTinyMCEEvent(editor, 'blur', this.destroy$).subscribe(() => {\n      this.ngZone.run(() => this.onTouchedCallback());\n    });\n\n    listenTinyMCEEvent(editor, this.modelEvents, this.destroy$).subscribe(() => {\n      this.ngZone.run(() => this.emitOnChange(editor));\n    });\n\n    if (typeof this.initialValue === 'string') {\n      this.ngZone.run(() => {\n        editor.setContent(this.initialValue as string);\n        if (editor.getContent() !== this.initialValue) {\n          this.emitOnChange(editor);\n        }\n        if (this.onInitNgModel !== undefined) {\n          this.onInitNgModel.emit(editor as unknown as EventObj<any>);\n        }\n      });\n    }\n  }\n\n  private emitOnChange(editor: TinyMCEEditor) {\n    if (this.onChangeCallback) {\n      this.onChangeCallback(editor.getContent({ format: this.outputFormat }));\n    }\n  }\n}\n"]}