argous 1.2.134 → 1.2.135

package/dist/components/DropArea/Html5FileSelector.js

@@ -0,0 +1,229 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDroppedOrSelectedFiles = exports.getDataTransferFiles = void 0;
+var DEFAULT_FILES_TO_IGNORE = [
+    '.DS_Store',
+    'Thumbs.db' // Windows indexing file
+];
+// map of common (mostly media types) mime types to use when the browser does not supply the mime type
+var EXTENSION_TO_MIME_TYPE_MAP = {
+    avi: 'video/avi',
+    gif: 'image/gif',
+    ico: 'image/x-icon',
+    jpeg: 'image/jpeg',
+    jpg: 'image/jpeg',
+    mkv: 'video/x-matroska',
+    mov: 'video/quicktime',
+    mp4: 'video/mp4',
+    pdf: 'application/pdf',
+    png: 'image/png',
+    zip: 'application/zip'
+};
+function shouldIgnoreFile(file) {
+    return DEFAULT_FILES_TO_IGNORE.indexOf(file.name) >= 0;
+}
+function copyString(aString) {
+    return (" " + aString).slice(1);
+}
+function traverseDirectory(entry) {
+    var reader = entry.createReader();
+    // Resolved when the entire directory is traversed
+    return new Promise(function (resolveDirectory) {
+        var iterationAttempts = [];
+        var errorHandler = function () { };
+        function readEntries() {
+            // According to the FileSystem API spec, readEntries() must be called until
+            // it calls the callback with an empty array.
+            reader.readEntries(function (batchEntries) {
+                if (!batchEntries.length) {
+                    // Done iterating this particular directory
+                    resolveDirectory(Promise.all(iterationAttempts));
+                }
+                else {
+                    // Add a list of promises for each directory entry.  If the entry is itself
+                    // a directory, then that promise won't resolve until it is fully traversed.
+                    iterationAttempts.push(Promise.all(batchEntries.map(function (batchEntry) {
+                        if (batchEntry.isDirectory) {
+                            return traverseDirectory(batchEntry);
+                        }
+                        return Promise.resolve(batchEntry);
+                    })));
+                    // Try calling readEntries() again for the same dir, according to spec
+                    readEntries();
+                }
+            }, errorHandler);
+        }
+        // initial call to recursive entry reader function
+        readEntries();
+    });
+}
+// package the file in an object that includes the fullPath from the file entry
+// that would otherwise be lost
+function packageFile(file, entry) {
+    var _a;
+    // let fileTypeOverride = '';
+    // handle some browsers sometimes missing mime types for dropped files
+    // const hasExtension = file.name && file.name.lastIndexOf('.') !== -1;
+    // if (hasExtension && !file.type) {
+    // const fileExtension = (file.name || '').split('.').pop();
+    // fileTypeOverride = EXTENSION_TO_MIME_TYPE_MAP[fileExtension];
+    // }
+    return {
+        fileObject: file,
+        fullPath: entry ? (_a = copyString(entry.fullPath)) === null || _a === void 0 ? void 0 : _a.replace(file.name, '') : file.name,
+        // lastModified: file.lastModified,
+        // lastModifiedDate: file.lastModifiedDate,
+        // name: file.name,
+        // size: file.size,
+        // type: file.type ? file.type : fileTypeOverride,
+        // webkitRelativePath: file.webkitRelativePath
+    };
+}
+function getFile(entry) {
+    return new Promise(function (resolve) {
+        entry.file(function (file) {
+            resolve(packageFile(file, entry));
+        });
+    });
+}
+function handleFilePromises(promises, fileList) {
+    return __awaiter(this, void 0, void 0, function () {
+        var files;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.all(promises)];
+                case 1:
+                    files = _a.sent();
+                    files.forEach(function (file) {
+                        if (!shouldIgnoreFile(file)) {
+                            fileList.push(file);
+                        }
+                    });
+                    return [2 /*return*/, fileList];
+            }
+        });
+    });
+}
+/**
+ * @param {DataTransfer} dataTransfer
+ */
+function getDataTransferFiles(dataTransfer) {
+    return __awaiter(this, void 0, void 0, function () {
+        var dataTransferFiles, folderPromises, filePromises, flatten_1, fileEntries, flattenedEntries;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    dataTransferFiles = [];
+                    folderPromises = [];
+                    filePromises = [];
+                    [].slice.call(dataTransfer.items).forEach(function (listItem) {
+                        if (typeof listItem.webkitGetAsEntry === 'function') {
+                            var entry = listItem.webkitGetAsEntry();
+                            if (entry) {
+                                if (entry.isDirectory) {
+                                    folderPromises.push(traverseDirectory(entry));
+                                }
+                                else {
+                                    filePromises.push(getFile(entry));
+                                }
+                            }
+                        }
+                        else {
+                            dataTransferFiles.push(listItem);
+                        }
+                    });
+                    if (!folderPromises.length) return [3 /*break*/, 3];
+                    flatten_1 = function (array) { return array.reduce(function (a, b) { return a.concat(Array.isArray(b) ? flatten_1(b) : b); }, []); };
+                    return [4 /*yield*/, Promise.all(folderPromises)];
+                case 1:
+                    fileEntries = _a.sent();
+                    flattenedEntries = flatten_1(fileEntries);
+                    // collect async promises to convert each fileEntry into a File object
+                    flattenedEntries.forEach(function (fileEntry) {
+                        filePromises.push(getFile(fileEntry));
+                    });
+                    return [4 /*yield*/, handleFilePromises(filePromises, dataTransferFiles)];
+                case 2: return [2 /*return*/, _a.sent()];
+                case 3:
+                    if (filePromises.length) {
+                        return [2 /*return*/, handleFilePromises(filePromises, dataTransferFiles)];
+                    }
+                    _a.label = 4;
+                case 4: return [2 /*return*/, Promise.resolve(dataTransferFiles)];
+            }
+        });
+    });
+}
+exports.getDataTransferFiles = getDataTransferFiles;
+/**
+ * This function should be called from both the onDrop event from your drag/drop
+ * dropzone as well as from the HTML5 file selector input field onChange event
+ * handler.  Pass the event object from the triggered event into this function.
+ * Supports mix of files and folders dropped via drag/drop.
+ *
+ * Returns: an array of File objects, that includes all files within folders
+ *   and subfolders of the dropped/selected items.
+ *
+ * @param {React.DragEvent<HTMLDivElement>} event
+ */
+function getDroppedOrSelectedFiles(event) {
+    return __awaiter(this, void 0, void 0, function () {
+        var dataTransfer, files, dragDropFileList, inputFieldFileList, fileList, i;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    dataTransfer = event.dataTransfer;
+                    if (!(dataTransfer && dataTransfer.items)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, getDataTransferFiles(dataTransfer)];
+                case 1: return [2 /*return*/, _a.sent()];
+                case 2:
+                    files = [];
+                    dragDropFileList = dataTransfer && dataTransfer.files;
+                    inputFieldFileList = event.target && event.target.files;
+                    fileList = dragDropFileList || inputFieldFileList || [];
+                    // convert the FileList to a simple array of File objects
+                    for (i = 0; i < fileList.length; i++) {
+                        files.push(packageFile(fileList[i]));
+                    }
+                    return [2 /*return*/, files];
+            }
+        });
+    });
+}
+exports.getDroppedOrSelectedFiles = getDroppedOrSelectedFiles;

package/dist/components/DropArea/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './DropArea';
+export * from './DropArea'; 

package/dist/components/DropArea/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var DropArea_1 = require("./DropArea");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(DropArea_1).default; } });

package/dist/components/Editor/Events.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2017-present, Ephox, Inc.
+ *
+ * This source code is licensed under the Apache 2 license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { Editor as TinyMCEEditor, EditorEvent, Events } from './tinymce/tinymce';
+export declare type EventHandler<A> = (a: EditorEvent<A>, editor: TinyMCEEditor) => unknown;
+declare type EEventHandler<K extends keyof Events.EditorEventMap> = EventHandler<Events.EditorEventMap[K]>;
+export interface INativeEvents {
+    onBeforePaste: EEventHandler<'beforepaste'>;
+    onBlur: EEventHandler<'blur'>;
+    onClick: EEventHandler<'click'>;
+    onContextMenu: EEventHandler<'contextmenu'>;
+    onCopy: EEventHandler<'copy'>;
+    onCut: EEventHandler<'cut'>;
+    onDblclick: EEventHandler<'dblclick'>;
+    onDrag: EEventHandler<'drag'>;
+    onDragDrop: EEventHandler<'dragdrop'>;
+    onDragEnd: EEventHandler<'dragend'>;
+    onDragGesture: EEventHandler<'draggesture'>;
+    onDragOver: EEventHandler<'dragover'>;
+    onDrop: EEventHandler<'drop'>;
+    onFocus: EEventHandler<'focus'>;
+    onFocusIn: EEventHandler<'focusin'>;
+    onFocusOut: EEventHandler<'focusout'>;
+    onKeyDown: EEventHandler<'keydown'>;
+    onKeyPress: EEventHandler<'keypress'>;
+    onKeyUp: EEventHandler<'keyup'>;
+    onMouseDown: EEventHandler<'mousedown'>;
+    onMouseEnter: EEventHandler<'mouseenter'>;
+    onMouseLeave: EEventHandler<'mouseleave'>;
+    onMouseMove: EEventHandler<'mousemove'>;
+    onMouseOut: EEventHandler<'mouseout'>;
+    onMouseOver: EEventHandler<'mouseover'>;
+    onMouseUp: EEventHandler<'mouseup'>;
+    onPaste: EEventHandler<'paste'>;
+    onSelectionChange: EEventHandler<'selectionchange'>;
+}
+export interface ITinyEvents {
+    onActivate: EEventHandler<'activate'>;
+    onAddUndo: EEventHandler<'AddUndo'>;
+    onBeforeAddUndo: EEventHandler<'BeforeAddUndo'>;
+    onBeforeExecCommand: EEventHandler<'BeforeExecCommand'>;
+    onBeforeGetContent: EEventHandler<'BeforeGetContent'>;
+    onBeforeRenderUI: EventHandler<unknown>;
+    onBeforeSetContent: EEventHandler<'BeforeSetContent'>;
+    onChange: EventHandler<unknown>;
+    onClearUndos: EEventHandler<'ClearUndos'>;
+    onDeactivate: EEventHandler<'deactivate'>;
+    onDirty: EventHandler<unknown>;
+    onExecCommand: EEventHandler<'ExecCommand'>;
+    onGetContent: EEventHandler<'GetContent'>;
+    onHide: EventHandler<unknown>;
+    onInit: EEventHandler<'init'>;
+    onLoadContent: EEventHandler<'LoadContent'>;
+    onNodeChange: EEventHandler<'NodeChange'>;
+    onPostProcess: EventHandler<unknown>;
+    onPostRender: EEventHandler<'PostRender'>;
+    onPreProcess: EventHandler<unknown>;
+    onProgressState: EEventHandler<'ProgressState'>;
+    onRedo: EEventHandler<'Redo'>;
+    onRemove: EEventHandler<'remove'>;
+    onReset: EventHandler<unknown>;
+    onSaveContent: EventHandler<unknown>;
+    onSetAttrib: EventHandler<unknown>;
+    onObjectResizeStart: EEventHandler<'ObjectResizeStart'>;
+    onObjectResized: EEventHandler<'ObjectResized'>;
+    onObjectSelected: EEventHandler<'ObjectSelected'>;
+    onSetContent: EEventHandler<'SetContent'>;
+    onShow: EventHandler<unknown>;
+    onSubmit: EventHandler<unknown>;
+    onUndo: EEventHandler<'Undo'>;
+    onVisualAid: EventHandler<unknown>;
+}
+export interface IEvents extends INativeEvents, ITinyEvents {
+}
+export {};

package/dist/components/Editor/Events.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Copyright (c) 2017-present, Ephox, Inc.
+ *
+ * This source code is licensed under the Apache 2 license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/components/Editor/ScriptLoader.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2017-present, Ephox, Inc.
+ *
+ * This source code is licensed under the Apache 2 license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export declare type callbackFn = () => void;
+export interface IStateObj {
+    listeners: callbackFn[];
+    scriptId: string;
+    scriptLoading: boolean;
+    scriptLoaded: boolean;
+}
+interface ScriptLoaderInterface {
+    load: (doc: Document, url: string, async: boolean, defer: boolean, delay: number, callback: callbackFn) => void;
+    reinitialize: () => void;
+}
+declare const ScriptLoader: ScriptLoaderInterface;
+export { ScriptLoader };

package/dist/components/Editor/ScriptLoader.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Copyright (c) 2017-present, Ephox, Inc.
+ *
+ * This source code is licensed under the Apache 2 license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptLoader = void 0;
+var Utils_1 = require("./Utils");
+var createState = function () { return ({
+    listeners: [],
+    scriptId: Utils_1.uuid('tiny-script'),
+    scriptLoading: false,
+    scriptLoaded: false
+}); };
+var CreateScriptLoader = function () {
+    var state = createState();
+    var injectScriptTag = function (scriptId, doc, url, async, defer, callback) {
+        var scriptTag = doc.createElement('script');
+        scriptTag.referrerPolicy = 'origin';
+        scriptTag.type = 'application/javascript';
+        scriptTag.id = scriptId;
+        scriptTag.src = url;
+        scriptTag.async = async;
+        scriptTag.defer = defer;
+        // scriptTag.appendChild(document.createTextNode(url));
+        var handler = function () {
+            scriptTag.removeEventListener('load', handler);
+            callback();
+        };
+        scriptTag.addEventListener('load', handler);
+        if (doc.head) {
+            doc.head.appendChild(scriptTag);
+        }
+        // document.body.appendChild(scriptTag);
+    };
+    var load = function (doc, url, async, defer, delay, callback) {
+        var scriptTagInjection = function () { return injectScriptTag(state.scriptId, doc, url, async, defer, function () {
+            state.listeners.forEach(function (fn) { return fn(); });
+            state.scriptLoaded = true;
+        }); };
+        if (state.scriptLoaded) {
+            callback();
+        }
+        else {
+            state.listeners.push(callback);
+            if (!state.scriptLoading) {
+                state.scriptLoading = true;
+                if (delay > 0) {
+                    setTimeout(scriptTagInjection, delay);
+                }
+                else {
+                    scriptTagInjection();
+                }
+            }
+        }
+    };
+    // Only to be used by tests.
+    var reinitialize = function () {
+        state = createState();
+    };
+    return {
+        load: load,
+        reinitialize: reinitialize
+    };
+};
+var ScriptLoader = CreateScriptLoader();
+exports.ScriptLoader = ScriptLoader;

package/dist/components/Editor/TinyMCE.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) 2017-present, Ephox, Inc.
+ *
+ * This source code is licensed under the Apache 2 license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { TinyMCE as TinyMCEGlobal } from './tinymce/tinymce';
+declare const getTinymce: () => TinyMCEGlobal | null;
+export { getTinymce };

package/dist/components/Editor/TinyMCE.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Copyright (c) 2017-present, Ephox, Inc.
+ *
+ * This source code is licensed under the Apache 2 license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTinymce = void 0;
+var getGlobal = function () { return (typeof window !== 'undefined' ? window : global); };
+var getTinymce = function () {
+    var global = getGlobal();
+    return global && global.tinymce ? global.tinymce : null;
+};
+exports.getTinymce = getTinymce;

package/dist/components/Editor/Utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2017-present, Ephox, Inc.
+ *
+ * This source code is licensed under the Apache 2 license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { IAllProps } from './components/Editor';
+import { IEventPropTypes } from './components/EditorPropTypes';
+import { Editor as TinyMCEEditor, EditorEvent } from './tinymce/tinymce';
+export declare const isFunction: (x: unknown) => x is Function;
+declare type PropLookup = <K extends keyof IAllProps>(key: K) => IAllProps[K] | undefined;
+export declare const configHandlers2: <H>(handlerLookup: PropLookup, on: (name: string, handler: H) => void, off: (name: string, handler: H) => void, adapter: <K extends keyof import("./Events").IEvents>(lookup: PropLookup, key: K) => H, prevProps: Partial<IAllProps>, props: Partial<IAllProps>, boundHandlers: Record<string, H>) => void;
+export declare const configHandlers: (editor: TinyMCEEditor, prevProps: Partial<IAllProps>, props: Partial<IAllProps>, boundHandlers: Record<string, (event: EditorEvent<any>) => unknown>, lookup: PropLookup) => void;
+export declare const uuid: (prefix: string) => string;
+export declare const isTextareaOrInput: (element: Element | null) => element is HTMLInputElement | HTMLTextAreaElement;
+export declare const mergePlugins: (initPlugins: string | string[] | undefined, inputPlugins: string | string[] | undefined) => string[];
+export declare const isBeforeInputEventAvailable: () => boolean;
+export {};

package/dist/components/Editor/Utils.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Copyright (c) 2017-present, Ephox, Inc.
+ *
+ * This source code is licensed under the Apache 2 license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBeforeInputEventAvailable = exports.mergePlugins = exports.isTextareaOrInput = exports.uuid = exports.configHandlers = exports.configHandlers2 = exports.isFunction = void 0;
+var EditorPropTypes_1 = require("./components/EditorPropTypes");
+var isFunction = function (x) { return typeof x === 'function'; };
+exports.isFunction = isFunction;
+var isEventProp = function (name) { return name in EditorPropTypes_1.eventPropTypes; };
+var eventAttrToEventName = function (attrName) { return attrName.substr(2); };
+var configHandlers2 = function (handlerLookup, on, off, adapter, prevProps, props, boundHandlers) {
+    var prevEventKeys = Object.keys(prevProps).filter(isEventProp);
+    var currEventKeys = Object.keys(props).filter(isEventProp);
+    var removedKeys = prevEventKeys.filter(function (key) { return props[key] === undefined; });
+    var addedKeys = currEventKeys.filter(function (key) { return prevProps[key] === undefined; });
+    removedKeys.forEach(function (key) {
+        // remove event handler
+        var eventName = eventAttrToEventName(key);
+        var wrappedHandler = boundHandlers[eventName];
+        off(eventName, wrappedHandler);
+        delete boundHandlers[eventName];
+    });
+    addedKeys.forEach(function (key) {
+        var wrappedHandler = adapter(handlerLookup, key);
+        var eventName = eventAttrToEventName(key);
+        boundHandlers[eventName] = wrappedHandler;
+        on(eventName, wrappedHandler);
+    });
+};
+exports.configHandlers2 = configHandlers2;
+var configHandlers = function (editor, prevProps, props, boundHandlers, lookup) {
+    return exports.configHandlers2(lookup, editor.on.bind(editor), editor.off.bind(editor), function (handlerLookup, key) { return function (e) { var _a; return (_a = handlerLookup(key)) === null || _a === void 0 ? void 0 : _a(e, editor); }; }, prevProps, props, boundHandlers);
+};
+exports.configHandlers = configHandlers;
+var unique = 0;
+var uuid = function (prefix) {
+    var time = Date.now();
+    var random = Math.floor(Math.random() * 1000000000);
+    unique++;
+    return prefix + '_' + random + unique + String(time);
+};
+exports.uuid = uuid;
+var isTextareaOrInput = function (element) {
+    return element !== null && (element.tagName.toLowerCase() === 'textarea' || element.tagName.toLowerCase() === 'input');
+};
+exports.isTextareaOrInput = isTextareaOrInput;
+var normalizePluginArray = function (plugins) {
+    if (typeof plugins === 'undefined' || plugins === '') {
+        return [];
+    }
+    return Array.isArray(plugins) ? plugins : plugins.split(' ');
+};
+// eslint-disable-next-line max-len
+var mergePlugins = function (initPlugins, inputPlugins) { return normalizePluginArray(initPlugins).concat(normalizePluginArray(inputPlugins)); };
+exports.mergePlugins = mergePlugins;
+var isBeforeInputEventAvailable = function () { return window.InputEvent && typeof InputEvent.prototype.getTargetRanges === 'function'; };
+exports.isBeforeInputEventAvailable = isBeforeInputEventAvailable;

package/dist/components/Editor/components/Editor.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2017-present, Ephox, Inc.
+ *
+ * This source code is licensed under the Apache 2 license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { IEditorPropTypes } from './EditorPropTypes';
+import { IEvents } from '../Events';
+import { Editor as TinyMCEEditor, RawEditorSettings } from '../tinymce/tinymce';
+import * as React from 'react';
+export interface IProps {
+    apiKey: string;
+    id: string;
+    inline: boolean;
+    initialValue: string;
+    onEditorChange: (a: string, editor: TinyMCEEditor) => void;
+    value: string;
+    init: RawEditorSettings & {
+        selector?: undefined;
+        target?: undefined;
+    };
+    /** @deprecated use `editor.getContent({format: 'text' })` in `onEditorChange` prop instead */
+    outputFormat: 'html' | 'text';
+    tagName: string;
+    cloudChannel: string;
+    plugins: NonNullable<RawEditorSettings['plugins']>;
+    toolbar: NonNullable<RawEditorSettings['toolbar']>;
+    disabled: boolean;
+    textareaName: string;
+    tinymceScriptSrc: string;
+    scriptLoading: {
+        async?: boolean;
+        defer?: boolean;
+        delay?: number;
+    };
+}
+export interface IAllProps extends Partial<IProps>, Partial<IEvents> {
+}
+export declare class Editor extends React.Component<IAllProps> {
+    static propTypes: IEditorPropTypes;
+    static defaultProps: Partial<IAllProps>;
+    editor?: TinyMCEEditor;
+    private id;
+    private elementRef;
+    private inline;
+    private currentContent?;
+    private boundHandlers;
+    private rollbackTimer;
+    private valueCursor;
+    constructor(props: Partial<IAllProps>);
+    componentDidUpdate(prevProps: Partial<IAllProps>): void;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+    private renderInline;
+    private renderIframe;
+    private getScriptSrc;
+    private getInitialValue;
+    private bindHandlers;
+    private rollbackChange;
+    private handleBeforeInput;
+    private handleBeforeInputSpecial;
+    private handleEditorChange;
+    private handleEditorChangeSpecial;
+    private initialise;
+}