novo-elements 8.0.0-next.2 → 8.0.0-next.4

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"]}

package/esm2020/{elements → addons}/ckeditor/CKEditor.module.mjs

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

package/esm2020/addons/ckeditor/index.mjs

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

package/esm2020/addons/ckeditor/novo-elements-addons-ckeditor.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm92by1lbGVtZW50cy1hZGRvbnMtY2tlZGl0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ub3ZvLWVsZW1lbnRzL3NyYy9hZGRvbnMvY2tlZGl0b3Ivbm92by1lbGVtZW50cy1hZGRvbnMtY2tlZGl0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2020/addons/dragula/Dragula.mjs

@@ -0,0 +1,77 @@
+// NG2
+import { Directive, ElementRef, Input } from '@angular/core';
+// Vendor
+import dragula from '@bullhorn/dragula';
+// APP
+import { notify } from 'novo-elements/utils';
+import { NovoDragulaService } from './DragulaService';
+import * as i0 from "@angular/core";
+import * as i1 from "./DragulaService";
+/**
+* @deprecated since v8.0.0 - slated for deletion.
+*
+* Moving away from all CommonJS dependencies to improve tree-shaking.
+*
+* Please look at built-in ng or third party drag-drop libraries like
+* angular-draggable-droppable, ngx-drag-drop, ngx-sortablejs, ng2-dragula.
+*/
+export class NovoDragulaElement {
+    constructor(element, dragulaService) {
+        this.dragulaService = dragulaService;
+        this.drake = null;
+        notify('[dragula] has been deprecated - please look at built-in ng or third party drag-drop libraries instead');
+        this.container = element.nativeElement;
+    }
+    ngOnInit() {
+        const bag = this.dragulaService.find(this.bag);
+        if (bag) {
+            this.drake = bag.drake;
+            this.checkModel();
+            this.drake.containers.push(this.container);
+        }
+        else {
+            this.drake = dragula({
+                containers: [this.container],
+            });
+            this.checkModel();
+            this.dragulaService.add(this.bag, this.drake);
+        }
+    }
+    checkModel() {
+        if (this.dragulaModel) {
+            if (this.drake.models) {
+                this.drake.models.push(this.dragulaModel);
+            }
+            else {
+                this.drake.models = [this.dragulaModel];
+            }
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes && changes.dragulaModel) {
+            if (this.drake) {
+                if (this.drake.models) {
+                    const modelIndex = this.drake.models.indexOf(changes.dragulaModel.previousValue);
+                    this.drake.models.splice(modelIndex, 1, changes.dragulaModel.currentValue);
+                }
+                else {
+                    this.drake.models = [changes.dragulaModel.currentValue];
+                }
+            }
+        }
+    }
+}
+NovoDragulaElement.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NovoDragulaElement, deps: [{ token: i0.ElementRef }, { token: i1.NovoDragulaService }], target: i0.ɵɵFactoryTarget.Directive });
+NovoDragulaElement.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: NovoDragulaElement, selector: "[dragula]", inputs: { bag: ["dragula", "bag"], dragulaModel: "dragulaModel" }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NovoDragulaElement, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dragula]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.NovoDragulaService }]; }, propDecorators: { bag: [{
+                type: Input,
+                args: ['dragula']
+            }], dragulaModel: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/{elements → addons}/dragula/Dragula.module.mjs

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

package/esm2020/addons/dragula/DragulaService.mjs

@@ -0,0 +1,127 @@
+// NG2
+import { EventEmitter, Injectable } from '@angular/core';
+// Vendor
+import dragula from '@bullhorn/dragula';
+import * as i0 from "@angular/core";
+/**
+* @deprecated since v8.0.0 - slated for deletion.
+*
+* Moving away from all CommonJS dependencies to improve tree-shaking.
+*
+* Please look at built-in ng or third party drag-drop libraries like
+* angular-draggable-droppable, ngx-drag-drop, ngx-sortablejs, ng2-dragula.
+*/
+export class NovoDragulaService {
+    constructor() {
+        this.cancel = new EventEmitter();
+        this.cloned = new EventEmitter();
+        this.drag = new EventEmitter();
+        this.dragend = new EventEmitter();
+        this.drop = new EventEmitter();
+        this.out = new EventEmitter();
+        this.over = new EventEmitter();
+        this.remove = new EventEmitter();
+        this.shadow = new EventEmitter();
+        this.dropModel = new EventEmitter();
+        this.removeModel = new EventEmitter();
+        this.events = ['cancel', 'cloned', 'drag', 'dragend', 'drop', 'out', 'over', 'remove', 'shadow', 'dropModel', 'removeModel'];
+        this.bags = [];
+    }
+    add(name, drake) {
+        let bag = this.find(name);
+        if (bag) {
+            throw new Error(`Bag named: ${name} already exists.`);
+        }
+        bag = {
+            name,
+            drake,
+        };
+        this.bags.push(bag);
+        if (drake.models) {
+            // models to sync with (must have same structure as containers)
+            this.handleModels(name, drake);
+        }
+        if (!bag.initEvents) {
+            this.setupEvents(bag);
+        }
+        return bag;
+    }
+    find(name) {
+        for (let i = 0; i < this.bags.length; i++) {
+            if (this.bags[i].name === name) {
+                return this.bags[i];
+            }
+        }
+        return null;
+    }
+    destroy(name) {
+        const bag = this.find(name);
+        const i = this.bags.indexOf(bag);
+        this.bags.splice(i, 1);
+        bag.drake.destroy();
+    }
+    setOptions(name, options) {
+        const bag = this.add(name, dragula(options));
+        this.handleModels(name, bag.drake);
+    }
+    handleModels(name, drake) {
+        let dragElm;
+        let dragIndex;
+        let dropIndex;
+        let sourceModel;
+        drake.on('remove', (el, source) => {
+            if (!drake.models) {
+                return;
+            }
+            sourceModel = drake.models[drake.containers.indexOf(source)];
+            sourceModel.splice(dragIndex, 1);
+            this.removeModel.emit([name, el, source]);
+        });
+        drake.on('drag', (el, source) => {
+            dragElm = el;
+            dragIndex = this.domIndexOf(el, source);
+        });
+        drake.on('drop', (dropElm, target, source) => {
+            if (!drake.models) {
+                return;
+            }
+            dropIndex = this.domIndexOf(dropElm, target);
+            sourceModel = drake.models[drake.containers.indexOf(source)];
+            if (target === source) {
+                sourceModel.splice(dropIndex, 0, sourceModel.splice(dragIndex, 1)[0]);
+            }
+            else {
+                const notCopy = dragElm === dropElm;
+                const targetModel = drake.models[drake.containers.indexOf(target)];
+                const dropElmModel = notCopy ? sourceModel[dragIndex] : JSON.parse(JSON.stringify(sourceModel[dragIndex]));
+                if (notCopy) {
+                    sourceModel.splice(dragIndex, 1);
+                }
+                targetModel.splice(dropIndex, 0, dropElmModel);
+                target.removeChild(dropElm); // element must be removed for ngFor to apply correctly
+            }
+            this.dropModel.emit([name, dropElm, target, source]);
+        });
+    }
+    setupEvents(bag) {
+        bag.initEvents = true;
+        const that = this;
+        const emitter = (type) => {
+            function replicate() {
+                const args = Array.prototype.slice.call(arguments);
+                that[type].emit([bag.name].concat(args));
+            }
+            bag.drake.on(type, replicate);
+        };
+        this.events.forEach(emitter);
+    }
+    domIndexOf(child, parent) {
+        return Array.prototype.indexOf.call(parent.children, child);
+    }
+}
+NovoDragulaService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NovoDragulaService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NovoDragulaService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NovoDragulaService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NovoDragulaService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DragulaService.js","sourceRoot":"","sources":["../../../../../projects/novo-elements/src/addons/dragula/DragulaService.ts"],"names":[],"mappings":"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","sourcesContent":["// NG2\nimport { EventEmitter, Injectable } from '@angular/core';\n// Vendor\nimport dragula from '@bullhorn/dragula';\n\n/**\n* @deprecated since v8.0.0 - slated for deletion.\n*\n* Moving away from all CommonJS dependencies to improve tree-shaking.\n*\n* Please look at built-in ng or third party drag-drop libraries like\n* angular-draggable-droppable, ngx-drag-drop, ngx-sortablejs, ng2-dragula.\n*/\n@Injectable()\nexport class NovoDragulaService {\n  cancel: EventEmitter<any> = new EventEmitter();\n  cloned: EventEmitter<any> = new EventEmitter();\n  drag: EventEmitter<any> = new EventEmitter();\n  dragend: EventEmitter<any> = new EventEmitter();\n  drop: EventEmitter<any> = new EventEmitter();\n  out: EventEmitter<any> = new EventEmitter();\n  over: EventEmitter<any> = new EventEmitter();\n  remove: EventEmitter<any> = new EventEmitter();\n  shadow: EventEmitter<any> = new EventEmitter();\n  dropModel: EventEmitter<any> = new EventEmitter();\n  removeModel: EventEmitter<any> = new EventEmitter();\n  events: Array<string> = ['cancel', 'cloned', 'drag', 'dragend', 'drop', 'out', 'over', 'remove', 'shadow', 'dropModel', 'removeModel'];\n  bags: Array<any> = [];\n\n  add(name, drake) {\n    let bag = this.find(name);\n    if (bag) {\n      throw new Error(`Bag named: ${name} already exists.`);\n    }\n    bag = {\n      name,\n      drake,\n    };\n    this.bags.push(bag);\n    if (drake.models) {\n      // models to sync with (must have same structure as containers)\n      this.handleModels(name, drake);\n    }\n    if (!bag.initEvents) {\n      this.setupEvents(bag);\n    }\n    return bag;\n  }\n\n  find(name) {\n    for (let i = 0; i < this.bags.length; i++) {\n      if (this.bags[i].name === name) {\n        return this.bags[i];\n      }\n    }\n    return null;\n  }\n\n  destroy(name) {\n    const bag = this.find(name);\n    const i = this.bags.indexOf(bag);\n    this.bags.splice(i, 1);\n    bag.drake.destroy();\n  }\n\n  setOptions(name, options) {\n    const bag = this.add(name, dragula(options));\n    this.handleModels(name, bag.drake);\n  }\n\n  handleModels(name, drake) {\n    let dragElm;\n    let dragIndex;\n    let dropIndex;\n    let sourceModel;\n    drake.on('remove', (el, source) => {\n      if (!drake.models) {\n        return;\n      }\n      sourceModel = drake.models[drake.containers.indexOf(source)];\n      sourceModel.splice(dragIndex, 1);\n      this.removeModel.emit([name, el, source]);\n    });\n    drake.on('drag', (el, source) => {\n      dragElm = el;\n      dragIndex = this.domIndexOf(el, source);\n    });\n    drake.on('drop', (dropElm, target, source) => {\n      if (!drake.models) {\n        return;\n      }\n      dropIndex = this.domIndexOf(dropElm, target);\n      sourceModel = drake.models[drake.containers.indexOf(source)];\n      if (target === source) {\n        sourceModel.splice(dropIndex, 0, sourceModel.splice(dragIndex, 1)[0]);\n      } else {\n        const notCopy = dragElm === dropElm;\n        const targetModel = drake.models[drake.containers.indexOf(target)];\n        const dropElmModel = notCopy ? sourceModel[dragIndex] : JSON.parse(JSON.stringify(sourceModel[dragIndex]));\n\n        if (notCopy) {\n          sourceModel.splice(dragIndex, 1);\n        }\n        targetModel.splice(dropIndex, 0, dropElmModel);\n        target.removeChild(dropElm); // element must be removed for ngFor to apply correctly\n      }\n      this.dropModel.emit([name, dropElm, target, source]);\n    });\n  }\n\n  setupEvents(bag) {\n    bag.initEvents = true;\n    const that = this;\n    const emitter = (type) => {\n      function replicate() {\n        const args = Array.prototype.slice.call(arguments);\n        that[type].emit([bag.name].concat(args));\n      }\n\n      bag.drake.on(type, replicate);\n    };\n    this.events.forEach(emitter);\n  }\n\n  domIndexOf(child, parent) {\n    return Array.prototype.indexOf.call(parent.children, child);\n  }\n}\n"]}

package/esm2020/addons/dragula/index.mjs

@@ -0,0 +1,4 @@
+export * from './Dragula';
+export * from './Dragula.module';
+export * from './DragulaService';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ub3ZvLWVsZW1lbnRzL3NyYy9hZGRvbnMvZHJhZ3VsYS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsa0JBQWtCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL0RyYWd1bGEnO1xuZXhwb3J0ICogZnJvbSAnLi9EcmFndWxhLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL0RyYWd1bGFTZXJ2aWNlJztcbiJdfQ==

package/esm2020/addons/dragula/novo-elements-addons-dragula.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm92by1lbGVtZW50cy1hZGRvbnMtZHJhZ3VsYS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25vdm8tZWxlbWVudHMvc3JjL2FkZG9ucy9kcmFndWxhL25vdm8tZWxlbWVudHMtYWRkb25zLWRyYWd1bGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2020/addons/index.mjs

@@ -0,0 +1,4 @@
+export * from './ace-editor';
+export * from './ckeditor';
+export * from './dragula';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9ub3ZvLWVsZW1lbnRzL3NyYy9hZGRvbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FjZS1lZGl0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9ja2VkaXRvcic7XG5leHBvcnQgKiBmcm9tICcuL2RyYWd1bGEnO1xuIl19

package/esm2020/addons/novo-elements-addons.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm92by1lbGVtZW50cy1hZGRvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9ub3ZvLWVsZW1lbnRzL3NyYy9hZGRvbnMvbm92by1lbGVtZW50cy1hZGRvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=