novo-elements 8.0.0-next.3 → 8.0.0-next.5

package/{elements/ckeditor/novo-elements-elements-ckeditor.d.ts → addons/ace-editor/novo-elements-addons-ace-editor.d.ts}

@@ -1,5 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
-/// <amd-module name="novo-elements/elements/ckeditor" />
+/// <amd-module name="novo-elements/addons/ace-editor" />
 export * from './index';

package/addons/ace-editor/package.json

@@ -0,0 +1,10 @@
+{
+  "module": "../../fesm2015/novo-elements-addons-ace-editor.mjs",
+  "es2020": "../../fesm2020/novo-elements-addons-ace-editor.mjs",
+  "esm2020": "../../esm2020/addons/ace-editor/novo-elements-addons-ace-editor.mjs",
+  "fesm2020": "../../fesm2020/novo-elements-addons-ace-editor.mjs",
+  "fesm2015": "../../fesm2015/novo-elements-addons-ace-editor.mjs",
+  "typings": "novo-elements-addons-ace-editor.d.ts",
+  "sideEffects": false,
+  "name": "novo-elements/addons/ace-editor"
+}

package/{elements/dragula/novo-elements-elements-dragula.d.ts → addons/ckeditor/novo-elements-addons-ckeditor.d.ts}

@@ -1,5 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
-/// <amd-module name="novo-elements/elements/dragula" />
+/// <amd-module name="novo-elements/addons/ckeditor" />
 export * from './index';

package/addons/ckeditor/package.json

@@ -0,0 +1,10 @@
+{
+  "module": "../../fesm2015/novo-elements-addons-ckeditor.mjs",
+  "es2020": "../../fesm2020/novo-elements-addons-ckeditor.mjs",
+  "esm2020": "../../esm2020/addons/ckeditor/novo-elements-addons-ckeditor.mjs",
+  "fesm2020": "../../fesm2020/novo-elements-addons-ckeditor.mjs",
+  "fesm2015": "../../fesm2015/novo-elements-addons-ckeditor.mjs",
+  "typings": "novo-elements-addons-ckeditor.d.ts",
+  "sideEffects": false,
+  "name": "novo-elements/addons/ckeditor"
+}

package/{elements/ace-editor/novo-elements-elements-ace-editor.d.ts → addons/dragula/novo-elements-addons-dragula.d.ts}

@@ -1,5 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
-/// <amd-module name="novo-elements/elements/ace-editor" />
+/// <amd-module name="novo-elements/addons/dragula" />
 export * from './index';

package/addons/dragula/package.json

@@ -0,0 +1,10 @@
+{
+  "module": "../../fesm2015/novo-elements-addons-dragula.mjs",
+  "es2020": "../../fesm2020/novo-elements-addons-dragula.mjs",
+  "esm2020": "../../esm2020/addons/dragula/novo-elements-addons-dragula.mjs",
+  "fesm2020": "../../fesm2020/novo-elements-addons-dragula.mjs",
+  "fesm2015": "../../fesm2015/novo-elements-addons-dragula.mjs",
+  "typings": "novo-elements-addons-dragula.d.ts",
+  "sideEffects": false,
+  "name": "novo-elements/addons/dragula"
+}

package/addons/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ace-editor';
+export * from './ckeditor';
+export * from './dragula';

package/addons/novo-elements-addons.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="novo-elements/addons" />
+export * from './index';

package/addons/package.json

@@ -0,0 +1,10 @@
+{
+  "module": "../fesm2015/novo-elements-addons.mjs",
+  "es2020": "../fesm2020/novo-elements-addons.mjs",
+  "esm2020": "../esm2020/addons/novo-elements-addons.mjs",
+  "fesm2020": "../fesm2020/novo-elements-addons.mjs",
+  "fesm2015": "../fesm2015/novo-elements-addons.mjs",
+  "typings": "novo-elements-addons.d.ts",
+  "sideEffects": false,
+  "name": "novo-elements/addons"
+}

package/elements/data-table/data-table.module.d.ts

@@ -33,8 +33,9 @@ import * as i31 from "novo-elements/elements/tooltip";
 import * as i32 from "novo-elements/elements/checkbox";
 import * as i33 from "novo-elements/elements/flex";
 import * as i34 from "novo-elements/elements/field";
+import * as i35 from "@angular/cdk/scrolling";
 export declare class NovoDataTableModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<NovoDataTableModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoDataTableModule, [typeof i1.DataTableInterpolatePipe, typeof i1.DateTableDateRendererPipe, typeof i1.DateTableCurrencyRendererPipe, typeof i1.DateTableDateTimeRendererPipe, typeof i1.DateTableNumberRendererPipe, typeof i1.DateTableTimeRendererPipe, typeof i1.DataTableBigDecimalRendererPipe, typeof i2.NovoDataTableCellHeader, typeof i3.NovoDataTableSortFilter, typeof i4.NovoDataTableHeaderCell, typeof i5.NovoDataTableCellFilterHeader, typeof i6.NovoDataTableCell, typeof i7.NovoDataTableHeaderRow, typeof i8.NovoDataTableRow, typeof i9.NovoDataTablePagination, typeof i10.NovoDataTableCheckboxCell, typeof i11.NovoDataTableCheckboxHeaderCell, typeof i12.NovoDataTableExpandCell, typeof i13.NovoDataTableExpandHeaderCell, typeof i14.NovoDataTable, typeof i15.NovoDataTableExpandDirective, typeof i16.NovoDataTableClearButton, typeof i17.NovoDataTableSortButton], [typeof i18.NovoDatePickerModule, typeof i19.CdkTableModule, typeof i20.CommonModule, typeof i21.FormsModule, typeof i22.NovoIconModule, typeof i23.NovoButtonModule, typeof i24.NovoDropdownModule, typeof i25.NovoFormExtrasModule, typeof i26.NovoLoadingModule, typeof i27.NovoTilesModule, typeof i28.NovoSearchBoxModule, typeof i29.NovoOptionModule, typeof i29.NovoCommonModule, typeof i30.NovoSelectModule, typeof i31.NovoTooltipModule, typeof i32.NovoCheckboxModule, typeof i33.NovoFlexModule, typeof i34.NovoFieldModule], [typeof i14.NovoDataTable, typeof i1.DataTableInterpolatePipe, typeof i1.DateTableDateRendererPipe, typeof i1.DateTableCurrencyRendererPipe, typeof i1.DateTableDateTimeRendererPipe, typeof i1.DateTableNumberRendererPipe, typeof i1.DateTableTimeRendererPipe, typeof i1.DataTableBigDecimalRendererPipe, typeof i5.NovoDataTableCellFilterHeader, typeof i16.NovoDataTableClearButton, typeof i17.NovoDataTableSortButton]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoDataTableModule, [typeof i1.DataTableInterpolatePipe, typeof i1.DateTableDateRendererPipe, typeof i1.DateTableCurrencyRendererPipe, typeof i1.DateTableDateTimeRendererPipe, typeof i1.DateTableNumberRendererPipe, typeof i1.DateTableTimeRendererPipe, typeof i1.DataTableBigDecimalRendererPipe, typeof i2.NovoDataTableCellHeader, typeof i3.NovoDataTableSortFilter, typeof i4.NovoDataTableHeaderCell, typeof i5.NovoDataTableCellFilterHeader, typeof i6.NovoDataTableCell, typeof i7.NovoDataTableHeaderRow, typeof i8.NovoDataTableRow, typeof i9.NovoDataTablePagination, typeof i10.NovoDataTableCheckboxCell, typeof i11.NovoDataTableCheckboxHeaderCell, typeof i12.NovoDataTableExpandCell, typeof i13.NovoDataTableExpandHeaderCell, typeof i14.NovoDataTable, typeof i15.NovoDataTableExpandDirective, typeof i16.NovoDataTableClearButton, typeof i17.NovoDataTableSortButton], [typeof i18.NovoDatePickerModule, typeof i19.CdkTableModule, typeof i20.CommonModule, typeof i21.FormsModule, typeof i22.NovoIconModule, typeof i23.NovoButtonModule, typeof i24.NovoDropdownModule, typeof i25.NovoFormExtrasModule, typeof i26.NovoLoadingModule, typeof i27.NovoTilesModule, typeof i28.NovoSearchBoxModule, typeof i29.NovoOptionModule, typeof i29.NovoCommonModule, typeof i30.NovoSelectModule, typeof i31.NovoTooltipModule, typeof i32.NovoCheckboxModule, typeof i33.NovoFlexModule, typeof i34.NovoFieldModule, typeof i35.ScrollingModule], [typeof i14.NovoDataTable, typeof i1.DataTableInterpolatePipe, typeof i1.DateTableDateRendererPipe, typeof i1.DateTableCurrencyRendererPipe, typeof i1.DateTableDateTimeRendererPipe, typeof i1.DateTableNumberRendererPipe, typeof i1.DateTableTimeRendererPipe, typeof i1.DataTableBigDecimalRendererPipe, typeof i5.NovoDataTableCellFilterHeader, typeof i16.NovoDataTableClearButton, typeof i17.NovoDataTableSortButton]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<NovoDataTableModule>;
 }

package/elements/form/Form.module.d.ts

@@ -16,19 +16,19 @@ import * as i14 from "novo-elements/elements/chips";
 import * as i15 from "novo-elements/elements/date-picker";
 import * as i16 from "novo-elements/elements/time-picker";
 import * as i17 from "novo-elements/elements/date-time-picker";
-import * as i18 from "novo-elements/elements/ckeditor";
+import * as i18 from "novo-elements/addons/ckeditor";
 import * as i19 from "./extras/FormExtras.module";
 import * as i20 from "novo-elements/elements/quick-note";
 import * as i21 from "novo-elements/elements/header";
 import * as i22 from "novo-elements/elements/tooltip";
 import * as i23 from "novo-elements/elements/popover";
-import * as i24 from "novo-elements/elements/dragula";
+import * as i24 from "novo-elements/addons/dragula";
 import * as i25 from "angular-imask";
 import * as i26 from "angular2-text-mask";
 import * as i27 from "novo-elements/elements/tip-well";
 import * as i28 from "novo-elements/elements/modal";
 import * as i29 from "novo-elements/elements/button";
-import * as i30 from "novo-elements/elements/ace-editor";
+import * as i30 from "novo-elements/addons/ace-editor";
 import * as i31 from "novo-elements/elements/common";
 import * as i32 from "novo-elements/elements/checkbox";
 import * as i33 from "novo-elements/elements/icon";

package/elements/form/extras/FormExtras.module.d.ts

@@ -8,7 +8,7 @@ import * as i6 from "novo-elements/elements/button";
 import * as i7 from "novo-elements/elements/select";
 import * as i8 from "novo-elements/elements/picker";
 import * as i9 from "novo-elements/elements/loading";
-import * as i10 from "novo-elements/elements/dragula";
+import * as i10 from "novo-elements/addons/dragula";
 import * as i11 from "novo-elements/elements/tooltip";
 import * as i12 from "novo-elements/elements/checkbox";
 export declare class NovoFormExtrasModule {

package/elements/form/extras/file/FileInput.d.ts

@@ -1,7 +1,7 @@
 import { FocusKeyManager } from '@angular/cdk/a11y';
 import { ElementRef, EventEmitter, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
 import { ControlValueAccessor, FormGroupDirective, NgControl, NgForm } from '@angular/forms';
-import { NovoDragulaService } from 'novo-elements/elements/dragula';
+import { NovoDragulaService } from 'novo-elements/addons/dragula';
 import { NovoLabelService } from 'novo-elements/services';
 import { CanUpdateErrorStateCtor, ErrorStateMatcher } from 'novo-elements/elements/common';
 import { NovoFieldControl } from 'novo-elements/elements/field';

package/elements/index.d.ts

@@ -1,4 +1,3 @@
-export * from 'novo-elements/elements/ace-editor';
 export * from 'novo-elements/elements/agenda';
 export * from 'novo-elements/elements/aside';
 export * from 'novo-elements/elements/autocomplete';
@@ -10,14 +9,12 @@ export * from 'novo-elements/elements/card';
 export * from 'novo-elements/elements/category-dropdown';
 export * from 'novo-elements/elements/checkbox';
 export * from 'novo-elements/elements/chips';
-export * from 'novo-elements/elements/ckeditor';
 export * from 'novo-elements/elements/color-picker';
 export * from 'novo-elements/elements/common';
 export * from 'novo-elements/elements/data-table';
 export * from 'novo-elements/elements/date-picker';
 export * from 'novo-elements/elements/date-time-picker';
 export * from 'novo-elements/elements/divider';
-export * from 'novo-elements/elements/dragula';
 export * from 'novo-elements/elements/dropdown';
 export * from 'novo-elements/elements/expansion';
 export * from 'novo-elements/elements/field';

package/esm2020/addons/ace-editor/AceEditor.mjs

@@ -0,0 +1,132 @@
+// NG2
+import { Component, ElementRef, EventEmitter, forwardRef, Input, Output } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+// Vendor
+// organize-imports-ignore
+import 'brace/index';
+import 'brace/mode/javascript';
+import 'brace/theme/chrome';
+import 'brace/ext/language_tools.js';
+// APP
+import { Helpers } from 'novo-elements/utils';
+import * as i0 from "@angular/core";
+const ACE_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => NovoAceEditor),
+    multi: true,
+};
+export class NovoAceEditor {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this.blur = new EventEmitter();
+        this.focus = new EventEmitter();
+        this._options = {
+            showPrintMargin: false,
+            displayIndentGuides: true,
+        };
+        this._theme = 'chrome';
+        this._mode = 'javascript';
+        this.text = '';
+        this.onChange = (_) => { };
+        this.onTouched = () => { };
+    }
+    set theme(theme) {
+        this.setTheme(theme);
+    }
+    set options(options) {
+        this.setOptions(options);
+    }
+    set mode(mode) {
+        this.setMode(mode);
+    }
+    ngOnDestroy() {
+        if (this.editor) {
+            this.editor.destroy();
+        }
+    }
+    ngOnInit() {
+        this.initializeEditor();
+        this.initializeOptions();
+        this.initializeEvents();
+    }
+    initializeEditor() {
+        const el = this.elementRef.nativeElement;
+        this.editor = ace.edit(el);
+        this.editor.$blockScrolling = Infinity;
+    }
+    initializeOptions() {
+        this.setOptions(this._options || {});
+        this.setTheme(this._theme);
+        this.setMode(this._mode);
+    }
+    initializeEvents() {
+        this.editor.on('focus', (event) => this.focus.emit(event));
+        this.editor.on('blur', (event) => this.focus.emit(event));
+        this.editor.on('change', () => this.updateText());
+        this.editor.on('paste', () => this.updateText());
+    }
+    updateText() {
+        const newVal = this.editor.getValue();
+        if (newVal === this.oldText) {
+            return;
+        }
+        this.text = newVal;
+        this.onChange(newVal);
+        this.oldText = newVal;
+    }
+    setText(text) {
+        if (Helpers.isBlank(text)) {
+            text = '';
+        }
+        if (this.text !== text) {
+            this.text = text;
+            this.editor.setValue(text);
+            this.onChange(text);
+            this.editor.clearSelection();
+        }
+    }
+    setOptions(options) {
+        this._options = options;
+        this.editor.setOptions(options || {});
+    }
+    setTheme(theme) {
+        this._theme = theme;
+        this.editor.setTheme(`ace/theme/${theme}`);
+    }
+    setMode(mode) {
+        this._mode = mode;
+        this.editor.getSession().setMode(`ace/mode/${this._mode}`);
+    }
+    writeValue(value) {
+        this.setText(value);
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+}
+NovoAceEditor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NovoAceEditor, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+NovoAceEditor.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: NovoAceEditor, selector: "novo-ace-editor", inputs: { theme: "theme", options: "options", mode: "mode", name: "name" }, outputs: { blur: "blur", focus: "focus" }, providers: [ACE_VALUE_ACCESSOR], ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NovoAceEditor, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'novo-ace-editor',
+                    template: '',
+                    providers: [ACE_VALUE_ACCESSOR],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { theme: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], blur: [{
+                type: Output
+            }], focus: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AceEditor.js","sourceRoot":"","sources":["../../../../../projects/novo-elements/src/addons/ace-editor/AceEditor.ts"],"names":[],"mappings":"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","sourcesContent":["// NG2\nimport { Component, ElementRef, EventEmitter, forwardRef, Input, OnDestroy, OnInit, Output } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n// Vendor\n// organize-imports-ignore\nimport 'brace/index';\nimport 'brace/mode/javascript';\nimport 'brace/theme/chrome';\nimport 'brace/ext/language_tools.js';\n// APP\nimport { Helpers } from 'novo-elements/utils';\n\ndeclare var ace: any;\n\nconst ACE_VALUE_ACCESSOR = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => NovoAceEditor),\n  multi: true,\n};\n\n@Component({\n  selector: 'novo-ace-editor',\n  template: '',\n  providers: [ACE_VALUE_ACCESSOR],\n})\nexport class NovoAceEditor implements ControlValueAccessor, OnInit, OnDestroy {\n  @Input()\n  set theme(theme: any) {\n    this.setTheme(theme);\n  }\n\n  @Input()\n  set options(options: any) {\n    this.setOptions(options);\n  }\n\n  @Input()\n  set mode(mode: any) {\n    this.setMode(mode);\n  }\n\n  @Input()\n  name: string;\n  @Output()\n  blur = new EventEmitter();\n  @Output()\n  focus = new EventEmitter();\n\n  private _options: any = {\n    showPrintMargin: false,\n    displayIndentGuides: true,\n  };\n  private _theme: string = 'chrome';\n  private _mode: string = 'javascript';\n\n  private text: string = '';\n  private oldText: string;\n  private editor: any;\n\n  private onChange = (_: any) => {};\n  private onTouched = () => {};\n\n  constructor(private elementRef: ElementRef) {}\n\n  ngOnDestroy() {\n    if (this.editor) {\n      this.editor.destroy();\n    }\n  }\n\n  ngOnInit() {\n    this.initializeEditor();\n    this.initializeOptions();\n    this.initializeEvents();\n  }\n\n  private initializeEditor() {\n    const el = this.elementRef.nativeElement;\n    this.editor = ace.edit(el);\n    this.editor.$blockScrolling = Infinity;\n  }\n\n  private initializeOptions() {\n    this.setOptions(this._options || {});\n    this.setTheme(this._theme);\n    this.setMode(this._mode);\n  }\n\n  private initializeEvents() {\n    this.editor.on('focus', (event) => this.focus.emit(event));\n    this.editor.on('blur', (event) => this.focus.emit(event));\n    this.editor.on('change', () => this.updateText());\n    this.editor.on('paste', () => this.updateText());\n  }\n\n  private updateText() {\n    const newVal = this.editor.getValue();\n\n    if (newVal === this.oldText) {\n      return;\n    }\n\n    this.text = newVal;\n    this.onChange(newVal);\n    this.oldText = newVal;\n  }\n\n  private setText(text: string) {\n    if (Helpers.isBlank(text)) {\n      text = '';\n    }\n    if (this.text !== text) {\n      this.text = text;\n      this.editor.setValue(text);\n      this.onChange(text);\n      this.editor.clearSelection();\n    }\n  }\n\n  private setOptions(options: any) {\n    this._options = options;\n    this.editor.setOptions(options || {});\n  }\n\n  private setTheme(theme: string) {\n    this._theme = theme;\n    this.editor.setTheme(`ace/theme/${theme}`);\n  }\n\n  private setMode(mode: any) {\n    this._mode = mode;\n    this.editor.getSession().setMode(`ace/mode/${this._mode}`);\n  }\n\n  writeValue(value: any) {\n    this.setText(value);\n  }\n\n  registerOnChange(fn: any) {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: any) {\n    this.onTouched = fn;\n  }\n}\n"]}

package/esm2020/{elements → addons}/ace-editor/AceEditor.module.mjs

@@ -17,4 +17,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImpo
                     exports: [NovoAceEditor],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWNlRWRpdG9yLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25vdm8tZWxlbWVudHMvc3JjL2VsZW1lbnRzL2FjZS1lZGl0b3IvQWNlRWRpdG9yLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNO0FBQ04sT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsTUFBTTtBQUNOLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxhQUFhLENBQUM7O0FBTzVDLE1BQU0sT0FBTyxtQkFBbUI7O2lIQUFuQixtQkFBbUI7a0hBQW5CLG1CQUFtQixpQkFIZixhQUFhLGFBRGxCLFlBQVksYUFFWixhQUFhO2tIQUVaLG1CQUFtQixZQUpyQixDQUFDLFlBQVksQ0FBQzs0RkFJWixtQkFBbUI7a0JBTC9CLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixZQUFZLEVBQUUsQ0FBQyxhQUFhLENBQUM7b0JBQzdCLE9BQU8sRUFBRSxDQUFDLGFBQWEsQ0FBQztpQkFDekIiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBORzJcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuLy8gQVBQXG5pbXBvcnQgeyBOb3ZvQWNlRWRpdG9yIH0gZnJvbSAnLi9BY2VFZGl0b3InO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcbiAgZGVjbGFyYXRpb25zOiBbTm92b0FjZUVkaXRvcl0sXG4gIGV4cG9ydHM6IFtOb3ZvQWNlRWRpdG9yXSxcbn0pXG5leHBvcnQgY2xhc3MgTm92b0FjZUVkaXRvck1vZHVsZSB7fVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWNlRWRpdG9yLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25vdm8tZWxlbWVudHMvc3JjL2FkZG9ucy9hY2UtZWRpdG9yL0FjZUVkaXRvci5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTTtBQUNOLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE1BQU07QUFDTixPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sYUFBYSxDQUFDOztBQU81QyxNQUFNLE9BQU8sbUJBQW1COztpSEFBbkIsbUJBQW1CO2tIQUFuQixtQkFBbUIsaUJBSGYsYUFBYSxhQURsQixZQUFZLGFBRVosYUFBYTtrSEFFWixtQkFBbUIsWUFKckIsQ0FBQyxZQUFZLENBQUM7NEZBSVosbUJBQW1CO2tCQUwvQixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsWUFBWSxFQUFFLENBQUMsYUFBYSxDQUFDO29CQUM3QixPQUFPLEVBQUUsQ0FBQyxhQUFhLENBQUM7aUJBQ3pCIiwic291cmNlc0NvbnRlbnQiOlsiLy8gTkcyXG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbi8vIEFQUFxuaW1wb3J0IHsgTm92b0FjZUVkaXRvciB9IGZyb20gJy4vQWNlRWRpdG9yJztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIGRlY2xhcmF0aW9uczogW05vdm9BY2VFZGl0b3JdLFxuICBleHBvcnRzOiBbTm92b0FjZUVkaXRvcl0sXG59KVxuZXhwb3J0IGNsYXNzIE5vdm9BY2VFZGl0b3JNb2R1bGUge31cbiJdfQ==

package/esm2020/addons/ace-editor/index.mjs

@@ -0,0 +1,3 @@
+export * from './AceEditor';
+export * from './AceEditor.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ub3ZvLWVsZW1lbnRzL3NyYy9hZGRvbnMvYWNlLWVkaXRvci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9BY2VFZGl0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9BY2VFZGl0b3IubW9kdWxlJztcbiJdfQ==

package/esm2020/{elements/ckeditor/novo-elements-elements-ckeditor.mjs → addons/ace-editor/novo-elements-addons-ace-editor.mjs}

@@ -2,4 +2,4 @@
  * Generated bundle index. Do not edit.
  */
 export * from './index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm92by1lbGVtZW50cy1lbGVtZW50cy1ja2VkaXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25vdm8tZWxlbWVudHMvc3JjL2VsZW1lbnRzL2NrZWRpdG9yL25vdm8tZWxlbWVudHMtZWxlbWVudHMtY2tlZGl0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm92by1lbGVtZW50cy1hZGRvbnMtYWNlLWVkaXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25vdm8tZWxlbWVudHMvc3JjL2FkZG9ucy9hY2UtZWRpdG9yL25vdm8tZWxlbWVudHMtYWRkb25zLWFjZS1lZGl0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2020/addons/ckeditor/CKEditor.mjs

@@ -0,0 +1,253 @@
+// NG2
+import { Component, EventEmitter, forwardRef, Input, NgZone, Output, ViewChild } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+// Value accessor for the component (supports ngModel)
+const CKEDITOR_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => NovoCKEditorElement),
+    multi: true,
+};
+/**
+ * CKEditor component
+ * Usage :
+ *  <novo-editor [(ngModel)]="data" [config]="{...}" debounce="500"></novo-editor>
+ */
+export class NovoCKEditorElement {
+    constructor(zone) {
+        this.zone = zone;
+        this.startupFocus = false;
+        this.fileBrowserImageUploadUrl = '';
+        this.disabled = false;
+        this.change = new EventEmitter();
+        this.ready = new EventEmitter();
+        this.blur = new EventEmitter();
+        this.focus = new EventEmitter();
+        this.paste = new EventEmitter();
+        this.loaded = new EventEmitter();
+        this._value = '';
+    }
+    get value() {
+        return this._value;
+    }
+    set value(v) {
+        if (v !== this._value) {
+            this._value = v;
+            this.onChange(v);
+        }
+    }
+    ngOnDestroy() {
+        if (this.instance) {
+            this.instance.focusManager.blur(true); // Remove focus from editor
+            setTimeout(() => {
+                this.instance.removeAllListeners();
+                const aInstance = CKEDITOR.instances[this.instance.name];
+                if (aInstance) {
+                    aInstance.destroy();
+                }
+                this.instance.destroy();
+                this.instance = null;
+            });
+        }
+    }
+    ngAfterViewInit() {
+        const config = Object.assign(this.getBaseConfig(), this.config);
+        if (this.startupFocus) {
+            config.startupFocus = true;
+        }
+        if (this.disabled) {
+            config.readOnly = true;
+        }
+        this.ckeditorInit(config);
+    }
+    updateValue(value) {
+        this.zone.run(() => {
+            this.value = value;
+            this.onChange(value);
+            this.onTouched();
+            this.change.emit(value);
+        });
+    }
+    ckeditorInit(config) {
+        if (!CKEDITOR) {
+            console.error('Make sure to include CKEditor sources in your dependencies!');
+            return;
+        }
+        // CKEditor replace textarea
+        this.instance = CKEDITOR.replace(this.host.nativeElement, config);
+        // Set initial value
+        this.instance.setData(this.value);
+        // listen for instanceReady event
+        this.instance.on('instanceReady', (evt) => {
+            // send the evt to the EventEmitter
+            this.ready.emit(evt);
+        });
+        // CKEditor change event
+        this.instance.on('change', () => {
+            this.onTouched();
+            const value = this.instance.getData();
+            // Debounce update
+            if (this.debounce) {
+                if (this.debounceTimeout) {
+                    clearTimeout(this.debounceTimeout);
+                }
+                this.debounceTimeout = setTimeout(() => {
+                    this.updateValue(value);
+                    this.debounceTimeout = null;
+                }, parseInt(this.debounce, 10));
+            }
+            else {
+                this.updateValue(value);
+            }
+        });
+        this.instance.on('blur', (event) => {
+            this.blur.emit(event);
+        });
+        this.instance.on('focus', (event) => {
+            this.focus.emit(event);
+        });
+        this.instance.on('paste', (event) => {
+            this.paste.emit(event);
+        });
+        this.instance.on('loaded', (event) => {
+            this.loaded.emit(event);
+        });
+    }
+    getBaseConfig() {
+        const baseConfig = {
+            enterMode: CKEDITOR.ENTER_BR,
+            entities: false,
+            shiftEnterMode: CKEDITOR.ENTER_P,
+            disableNativeSpellChecker: false,
+            removePlugins: 'liststyle,tabletools,contextmenu,tableselection',
+            extraAllowedContent: '*(*){*};table tbody tr td th[*];',
+            font_names: 'Arial/Arial, Helvetica, sans-serif;' +
+                'Calibri/Calibri, Verdana, Geneva, sans-serif;' +
+                'Comic Sans MS/Comic Sans MS, cursive;' +
+                'Courier New/Courier New, Courier, monospace;' +
+                'Georgia/Georgia, serif;' +
+                'Lucida Sans Unicode/Lucida Sans Unicode, Lucida Grande, sans-serif;' +
+                'Tahoma/Tahoma, Geneva, sans-serif;' +
+                'Times New Roman/Times New Roman, Times, serif;' +
+                'Trebuchet MS/Trebuchet MS, Helvetica, sans-serif;' +
+                'Verdana/Verdana, Geneva, sans-serif',
+        };
+        const minimalConfig = {
+            toolbar: [
+                {
+                    name: 'basicstyles',
+                    items: [
+                        'Styles',
+                        'FontSize',
+                        'Bold',
+                        'Italic',
+                        'Underline',
+                        'TextColor',
+                        '-',
+                        'NumberedList',
+                        'BulletedList',
+                        'Outdent',
+                        'Indent',
+                        'Link',
+                    ],
+                },
+            ],
+        };
+        const extendedConfig = {
+            toolbar: [
+                { name: 'clipboard', items: ['Paste', 'PasteText', 'PasteFromWord', 'Undo', 'Redo'] },
+                {
+                    name: 'paragraph',
+                    items: [
+                        'NumberedList',
+                        'BulletedList',
+                        'Outdent',
+                        'Indent',
+                        'Blockquote',
+                        'JustifyLeft',
+                        'JustifyCenter',
+                        'JustifyRight',
+                        'JustifyBlock',
+                        'BidiLtr',
+                        'BidiRtl',
+                    ],
+                },
+                { name: 'links', items: ['Link'] },
+                { name: 'insert', items: ['Image', 'Table', 'HorizontalRule'] },
+                { name: 'tools', items: ['Maximize', 'Source'] },
+                '/',
+                { name: 'basicstyles', items: ['Bold', 'Italic', 'Underline', 'Strike', 'Subscript', 'Superscript'] },
+                { name: 'styles', items: ['Styles', 'Format', 'Font', 'FontSize'] },
+                { name: 'colors', items: ['TextColor', 'BGColor'] },
+            ],
+            filebrowserImageUploadUrl: this.fileBrowserImageUploadUrl,
+        };
+        return Object.assign(baseConfig, this.minimal ? minimalConfig : extendedConfig);
+    }
+    writeValue(value) {
+        this._value = value;
+        if (this.instance) {
+            this.instance.setData(value);
+        }
+    }
+    onChange(value) { }
+    onTouched(event) { }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(disabled) {
+        this.disabled = disabled;
+        if (this.instance) {
+            CKEDITOR.instances[this.instance.name].setReadOnly(disabled);
+        }
+    }
+    insertText(text) {
+        const trimmedText = text.trim();
+        this.instance.insertText(trimmedText);
+    }
+}
+NovoCKEditorElement.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NovoCKEditorElement, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+NovoCKEditorElement.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: NovoCKEditorElement, selector: "novo-editor", inputs: { config: "config", debounce: "debounce", name: "name", minimal: "minimal", startupFocus: "startupFocus", fileBrowserImageUploadUrl: "fileBrowserImageUploadUrl", disabled: "disabled", value: "value" }, outputs: { change: "change", ready: "ready", blur: "blur", focus: "focus", paste: "paste", loaded: "loaded" }, providers: [CKEDITOR_CONTROL_VALUE_ACCESSOR], viewQueries: [{ propertyName: "host", first: true, predicate: ["host"], descendants: true }], ngImport: i0, template: '<textarea [name]="name" [id]="name" #host></textarea>', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NovoCKEditorElement, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'novo-editor',
+                    providers: [CKEDITOR_CONTROL_VALUE_ACCESSOR],
+                    template: '<textarea [name]="name" [id]="name" #host></textarea>',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }]; }, propDecorators: { config: [{
+                type: Input
+            }], debounce: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], minimal: [{
+                type: Input
+            }], startupFocus: [{
+                type: Input
+            }], fileBrowserImageUploadUrl: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], change: [{
+                type: Output
+            }], ready: [{
+                type: Output
+            }], blur: [{
+                type: Output
+            }], focus: [{
+                type: Output
+            }], paste: [{
+                type: Output
+            }], loaded: [{
+                type: Output
+            }], host: [{
+                type: ViewChild,
+                args: ['host']
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CKEditor.js","sourceRoot":"","sources":["../../../../../projects/novo-elements/src/addons/ckeditor/CKEditor.ts"],"names":[],"mappings":"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","sourcesContent":["// NG2\nimport { AfterViewInit, Component, EventEmitter, forwardRef, Input, NgZone, OnDestroy, Output, ViewChild } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\n// Value accessor for the component (supports ngModel)\nconst CKEDITOR_CONTROL_VALUE_ACCESSOR = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => NovoCKEditorElement),\n  multi: true,\n};\n\ndeclare var CKEDITOR: any;\ndeclare global {\n  interface Window {\n    CKEDITOR: any;\n  }\n}\n\n/**\n * CKEditor component\n * Usage :\n *  <novo-editor [(ngModel)]=\"data\" [config]=\"{...}\" debounce=\"500\"></novo-editor>\n */\n@Component({\n  selector: 'novo-editor',\n  providers: [CKEDITOR_CONTROL_VALUE_ACCESSOR],\n  template: '<textarea [name]=\"name\" [id]=\"name\" #host></textarea>',\n})\nexport class NovoCKEditorElement implements OnDestroy, AfterViewInit, ControlValueAccessor {\n  @Input()\n  config;\n  @Input()\n  debounce;\n  @Input()\n  name;\n  @Input()\n  minimal;\n  @Input()\n  startupFocus: boolean = false;\n  @Input()\n  fileBrowserImageUploadUrl: string = '';\n  @Input()\n  disabled: boolean = false;\n\n  @Output()\n  change = new EventEmitter();\n  @Output()\n  ready = new EventEmitter();\n  @Output()\n  blur = new EventEmitter();\n  @Output()\n  focus = new EventEmitter();\n  @Output()\n  paste = new EventEmitter();\n  @Output()\n  loaded = new EventEmitter();\n  @ViewChild('host')\n  host;\n\n  _value: string = '';\n  instance;\n  debounceTimeout;\n\n  constructor(private zone: NgZone) {}\n\n  get value() {\n    return this._value;\n  }\n\n  @Input()\n  set value(v) {\n    if (v !== this._value) {\n      this._value = v;\n      this.onChange(v);\n    }\n  }\n\n  ngOnDestroy() {\n    if (this.instance) {\n      this.instance.focusManager.blur(true); // Remove focus from editor\n      setTimeout(() => {\n        this.instance.removeAllListeners();\n        const aInstance = CKEDITOR.instances[this.instance.name];\n        if (aInstance) {\n          aInstance.destroy();\n        }\n        this.instance.destroy();\n        this.instance = null;\n      });\n    }\n  }\n\n  ngAfterViewInit() {\n    const config = Object.assign(this.getBaseConfig(), this.config);\n    if (this.startupFocus) {\n      config.startupFocus = true;\n    }\n    if (this.disabled) {\n      config.readOnly = true;\n    }\n    this.ckeditorInit(config);\n  }\n\n  updateValue(value) {\n    this.zone.run(() => {\n      this.value = value;\n      this.onChange(value);\n      this.onTouched();\n      this.change.emit(value);\n    });\n  }\n\n  private ckeditorInit(config) {\n    if (!CKEDITOR) {\n      console.error('Make sure to include CKEditor sources in your dependencies!');\n      return;\n    }\n\n    // CKEditor replace textarea\n    this.instance = CKEDITOR.replace(this.host.nativeElement, config);\n\n    // Set initial value\n    this.instance.setData(this.value);\n\n    // listen for instanceReady event\n    this.instance.on('instanceReady', (evt) => {\n      // send the evt to the EventEmitter\n      this.ready.emit(evt);\n    });\n\n    // CKEditor change event\n    this.instance.on('change', () => {\n      this.onTouched();\n      const value = this.instance.getData();\n\n      // Debounce update\n      if (this.debounce) {\n        if (this.debounceTimeout) {\n          clearTimeout(this.debounceTimeout);\n        }\n        this.debounceTimeout = setTimeout(() => {\n          this.updateValue(value);\n          this.debounceTimeout = null;\n        }, parseInt(this.debounce, 10));\n      } else {\n        this.updateValue(value);\n      }\n    });\n    this.instance.on('blur', (event) => {\n      this.blur.emit(event);\n    });\n    this.instance.on('focus', (event) => {\n      this.focus.emit(event);\n    });\n    this.instance.on('paste', (event) => {\n      this.paste.emit(event);\n    });\n    this.instance.on('loaded', (event) => {\n      this.loaded.emit(event);\n    });\n  }\n\n  getBaseConfig(): { [key: string]: any } {\n    const baseConfig = {\n      enterMode: CKEDITOR.ENTER_BR,\n      entities: false,\n      shiftEnterMode: CKEDITOR.ENTER_P,\n      disableNativeSpellChecker: false,\n      removePlugins: 'liststyle,tabletools,contextmenu,tableselection', // allows browser based spell checking\n      extraAllowedContent: '*(*){*};table tbody tr td th[*];', // allows class names (*) and inline styles {*} for all and attributes [*] on tables\n      font_names:\n        'Arial/Arial, Helvetica, sans-serif;' +\n        'Calibri/Calibri, Verdana, Geneva, sans-serif;' +\n        'Comic Sans MS/Comic Sans MS, cursive;' +\n        'Courier New/Courier New, Courier, monospace;' +\n        'Georgia/Georgia, serif;' +\n        'Lucida Sans Unicode/Lucida Sans Unicode, Lucida Grande, sans-serif;' +\n        'Tahoma/Tahoma, Geneva, sans-serif;' +\n        'Times New Roman/Times New Roman, Times, serif;' +\n        'Trebuchet MS/Trebuchet MS, Helvetica, sans-serif;' +\n        'Verdana/Verdana, Geneva, sans-serif',\n    };\n\n    const minimalConfig = {\n      toolbar: [\n        {\n          name: 'basicstyles',\n          items: [\n            'Styles',\n            'FontSize',\n            'Bold',\n            'Italic',\n            'Underline',\n            'TextColor',\n            '-',\n            'NumberedList',\n            'BulletedList',\n            'Outdent',\n            'Indent',\n            'Link',\n          ],\n        },\n      ],\n    };\n\n    const extendedConfig = {\n      toolbar: [\n        { name: 'clipboard', items: ['Paste', 'PasteText', 'PasteFromWord', 'Undo', 'Redo'] },\n        {\n          name: 'paragraph',\n          items: [\n            'NumberedList',\n            'BulletedList',\n            'Outdent',\n            'Indent',\n            'Blockquote',\n            'JustifyLeft',\n            'JustifyCenter',\n            'JustifyRight',\n            'JustifyBlock',\n            'BidiLtr',\n            'BidiRtl',\n          ],\n        },\n        { name: 'links', items: ['Link'] },\n        { name: 'insert', items: ['Image', 'Table', 'HorizontalRule'] },\n        { name: 'tools', items: ['Maximize', 'Source'] },\n        '/', // line break\n        { name: 'basicstyles', items: ['Bold', 'Italic', 'Underline', 'Strike', 'Subscript', 'Superscript'] },\n        { name: 'styles', items: ['Styles', 'Format', 'Font', 'FontSize'] },\n        { name: 'colors', items: ['TextColor', 'BGColor'] },\n      ],\n      filebrowserImageUploadUrl: this.fileBrowserImageUploadUrl,\n    };\n\n    return Object.assign(baseConfig, this.minimal ? minimalConfig : extendedConfig);\n  }\n\n  writeValue(value) {\n    this._value = value;\n    if (this.instance) {\n      this.instance.setData(value);\n    }\n  }\n\n  onChange(value?: any) {}\n\n  onTouched(event?) {}\n\n  registerOnChange(fn) {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn) {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(disabled: boolean): void {\n    this.disabled = disabled;\n    if (this.instance) {\n      CKEDITOR.instances[this.instance.name].setReadOnly(disabled);\n    }\n  }\n\n  insertText(text) {\n    const trimmedText = text.trim();\n    this.instance.insertText(trimmedText);\n  }\n}\n"]}