argous 1.2.132 → 1.2.136

package/lib/components/DropArea/Html5FileSelector.js

@@ -0,0 +1,164 @@
+const DEFAULT_FILES_TO_IGNORE = [
+  '.DS_Store', // OSX indexing file
+  'Thumbs.db' // Windows indexing file
+];
+
+// map of common (mostly media types) mime types to use when the browser does not supply the mime type
+const 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) {
+  const reader = entry.createReader();
+  // Resolved when the entire directory is traversed
+  return new Promise((resolveDirectory) => {
+    const iterationAttempts = [];
+    const errorHandler = () => {};
+    function readEntries() {
+      // According to the FileSystem API spec, readEntries() must be called until
+      // it calls the callback with an empty array.
+      reader.readEntries((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((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) {
+  // 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, // provide access to the raw File object (required for uploading)
+    fullPath: entry ? copyString(entry.fullPath)?.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((resolve) => {
+    entry.file((file) => {
+      resolve(packageFile(file, entry));
+    });
+  });
+}
+
+async function handleFilePromises(promises, fileList) {
+  const files = await Promise.all(promises);
+  files.forEach((file) => {
+    if (!shouldIgnoreFile(file)) {
+      fileList.push(file);
+    }
+  });
+  return fileList;
+}
+
+/**
+ * @param {DataTransfer} dataTransfer 
+ */
+export async function getDataTransferFiles(dataTransfer) {
+  const dataTransferFiles = [];
+  const folderPromises = [];
+  const filePromises = [];
+
+  [].slice.call(dataTransfer.items).forEach((listItem) => {
+    if (typeof listItem.webkitGetAsEntry === 'function') {
+      const entry = listItem.webkitGetAsEntry();
+
+      if (entry) {
+        if (entry.isDirectory) {
+          folderPromises.push(traverseDirectory(entry));
+        } else {
+          filePromises.push(getFile(entry));
+        }
+      }
+    } else {
+      dataTransferFiles.push(listItem);
+    }
+  });
+  if (folderPromises.length) {
+    const flatten = (array) => array.reduce((a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []);
+    const fileEntries = await Promise.all(folderPromises);
+    const flattenedEntries = flatten(fileEntries);
+    // collect async promises to convert each fileEntry into a File object
+    flattenedEntries.forEach((fileEntry) => {
+      filePromises.push(getFile(fileEntry));
+    });
+    return await handleFilePromises(filePromises, dataTransferFiles);
+  } else if (filePromises.length) {
+    return handleFilePromises(filePromises, dataTransferFiles);
+  }
+  return Promise.resolve(dataTransferFiles);
+}
+
+/**
+ * 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
+ */
+export async function getDroppedOrSelectedFiles(event) {
+  const dataTransfer = event.dataTransfer;
+  if (dataTransfer && dataTransfer.items) {
+    return await getDataTransferFiles(dataTransfer);
+  }
+  const files = [];
+  const dragDropFileList = dataTransfer && dataTransfer.files;
+  const inputFieldFileList = event.target && event.target.files;
+  const fileList = dragDropFileList || inputFieldFileList || [];
+  // convert the FileList to a simple array of File objects
+  for (let i = 0; i < fileList.length; i++) {
+    files.push(packageFile(fileList[i]));
+  }
+  return files;
+}

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

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

package/lib/components/DropArea/index.js

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

package/lib/components/Editor/Events.ts

@@ -0,0 +1,83 @@
+/**
+ * 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 type EventHandler<A> = (a: EditorEvent<A>, editor: TinyMCEEditor) => unknown;
+
+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 {}

package/lib/components/Editor/ScriptLoader.ts

@@ -0,0 +1,96 @@
+/**
+ * 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 { uuid } from './Utils';
+
+export type callbackFn = () => void;
+export interface IStateObj {
+  listeners: callbackFn[];
+  scriptId: string;
+  scriptLoading: boolean;
+  scriptLoaded: boolean;
+}
+
+const createState = (): IStateObj => ({
+  listeners: [],
+  scriptId: uuid('tiny-script'),
+  scriptLoading: false,
+  scriptLoaded: false
+});
+
+interface ScriptLoaderInterface {
+  load: (doc: Document, url: string, async: boolean, defer: boolean, delay: number, callback: callbackFn) => void;
+  reinitialize: () => void;
+}
+
+const CreateScriptLoader = (): ScriptLoaderInterface => {
+  let state: IStateObj = createState();
+
+  const injectScriptTag = (scriptId: string, doc: Document, url: string, async: boolean, defer: boolean, callback: callbackFn) => {
+    const 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));
+
+    const handler = () => {
+      scriptTag.removeEventListener('load', handler);
+      callback();
+    };
+    scriptTag.addEventListener('load', handler);
+    if (doc.head) {
+      doc.head.appendChild(scriptTag);
+    }
+    // document.body.appendChild(scriptTag);
+  };
+
+  const load = (doc: Document, url: string, async: boolean, defer: boolean, delay: number, callback: callbackFn) => {
+
+    const scriptTagInjection = () => injectScriptTag(
+      state.scriptId, doc, url, async, defer,
+      () => {
+        state.listeners.forEach((fn) => 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.
+  const reinitialize = () => {
+    state = createState();
+  };
+
+  return {
+    load,
+    reinitialize
+  };
+};
+
+const ScriptLoader = CreateScriptLoader();
+
+export {
+  ScriptLoader
+};

package/lib/components/Editor/TinyMCE.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 { TinyMCE as TinyMCEGlobal } from './tinymce/tinymce';
+
+const getGlobal = (): any => (typeof window !== 'undefined' ? window : global);
+
+const getTinymce = (): TinyMCEGlobal | null => {
+  const global = getGlobal();
+
+  return global && global.tinymce ? global.tinymce : null;
+};
+
+export { getTinymce };

package/lib/components/Editor/Utils.ts

@@ -0,0 +1,95 @@
+/**
+ * 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 { eventPropTypes, IEventPropTypes } from './components/EditorPropTypes';
+import { Editor as TinyMCEEditor, EditorEvent } from './tinymce/tinymce';
+
+export const isFunction = (x: unknown): x is Function => typeof x === 'function';
+
+const isEventProp = (name: string): name is keyof IEventPropTypes => name in eventPropTypes;
+
+const eventAttrToEventName = <T extends string>(attrName: `on${T}`): T => attrName.substr(2) as T;
+
+type PropLookup = <K extends keyof IAllProps>(key: K) => IAllProps[K] | undefined;
+
+export const configHandlers2 = <H> (
+  handlerLookup: PropLookup,
+  on: (name: string, handler: H) => void,
+  off: (name: string, handler: H) => void,
+  adapter: <K extends keyof IEventPropTypes> (lookup: PropLookup, key: K) => H,
+  prevProps: Partial<IAllProps>,
+  props: Partial<IAllProps>,
+  boundHandlers: Record<string, H>
+): void => {
+  const prevEventKeys = Object.keys(prevProps).filter(isEventProp);
+  const currEventKeys = Object.keys(props).filter(isEventProp);
+
+  const removedKeys = prevEventKeys.filter((key) => props[key] === undefined);
+  const addedKeys = currEventKeys.filter((key) => prevProps[key] === undefined);
+
+  removedKeys.forEach((key) => {
+    // remove event handler
+    const eventName = eventAttrToEventName(key);
+    const wrappedHandler = boundHandlers[eventName];
+    off(eventName, wrappedHandler);
+    delete boundHandlers[eventName];
+  });
+
+  addedKeys.forEach((key) => {
+    const wrappedHandler = adapter(handlerLookup, key);
+    const eventName = eventAttrToEventName(key);
+    boundHandlers[eventName] = wrappedHandler;
+    on(eventName, wrappedHandler);
+  });
+};
+
+export const configHandlers = (
+  editor: TinyMCEEditor,
+  prevProps: Partial<IAllProps>,
+  props: Partial<IAllProps>,
+  boundHandlers: Record<string, (event: EditorEvent<any>) => unknown>,
+  lookup: PropLookup
+): void =>
+  configHandlers2(
+    lookup,
+    editor.on.bind(editor),
+    editor.off.bind(editor),
+    (handlerLookup, key) => (e) => handlerLookup(key)?.(e, editor),
+    prevProps,
+    props,
+    boundHandlers
+  );
+
+let unique = 0;
+
+export const uuid = (prefix: string): string => {
+  const time = Date.now();
+  const random = Math.floor(Math.random() * 1000000000);
+
+  unique++;
+
+  return prefix + '_' + random + unique + String(time);
+};
+
+export const isTextareaOrInput = (element: Element | null): element is (HTMLTextAreaElement | HTMLInputElement) =>
+  element !== null && (element.tagName.toLowerCase() === 'textarea' || element.tagName.toLowerCase() === 'input');
+
+const normalizePluginArray = (plugins?: string | string[]): string[] => {
+  if (typeof plugins === 'undefined' || plugins === '') {
+    return [];
+  }
+
+  return Array.isArray(plugins) ? plugins : plugins.split(' ');
+};
+
+// eslint-disable-next-line max-len
+export const mergePlugins = (initPlugins: string | string[] | undefined, inputPlugins: string | string[] | undefined): string[] => normalizePluginArray(initPlugins).concat(normalizePluginArray(inputPlugins));
+
+export const isBeforeInputEventAvailable = () => window.InputEvent && typeof (InputEvent.prototype as any).getTargetRanges === 'function';
+