OXIESEC PANEL

Name	Size	Modified	Perms
📁 ..	-	02/20/2020 05:44:43 AM	rwxr-xr-x
📄 ApplyFormat.ts	11.18 KB	02/20/2020 05:43:19 AM	rw-r--r--
📄 CaretFormat.ts	10.27 KB	02/20/2020 05:43:19 AM	rw-r--r--
📄 DefaultFormats.ts	5.17 KB	02/20/2020 05:43:20 AM	rw-r--r--
📄 ExpandRange.ts	12.32 KB	02/20/2020 05:43:21 AM	rw-r--r--
📄 FontInfo.ts	2.1 KB	02/20/2020 05:43:21 AM	rw-r--r--
📄 FormatChanged.ts	4.52 KB	02/20/2020 05:43:22 AM	rw-r--r--
📄 FormatContainer.ts	706 bytes	02/20/2020 05:43:22 AM	rw-r--r--
📄 FormatRegistry.ts	2.7 KB	02/20/2020 05:43:23 AM	rw-r--r--
📄 FormatUtils.ts	4.83 KB	02/20/2020 05:43:23 AM	rw-r--r--
📄 Hooks.ts	1.56 KB	02/20/2020 05:43:24 AM	rw-r--r--
📄 MatchFormat.ts	5.54 KB	02/20/2020 05:43:24 AM	rw-r--r--
📄 MergeFormats.ts	6.75 KB	02/20/2020 05:43:25 AM	rw-r--r--
📄 Preview.ts	8.79 KB	02/20/2020 05:43:26 AM	rw-r--r--
📄 RemoveFormat.ts	18.89 KB	02/20/2020 05:43:26 AM	rw-r--r--
📄 ToggleFormat.ts	842 bytes	02/20/2020 05:43:27 AM	rw-r--r--

Editing: FormatChanged.ts

/**
 * Copyright (c) Tiny Technologies, Inc. All rights reserved.
 * Licensed under the LGPL or a commercial license.
 * For LGPL see License.txt in the project root for license information.
 * For commercial licenses see https://www.tiny.cloud/
 */

import { Element, Node } from '@ephox/dom-globals';
import { Arr, Cell, Obj } from '@ephox/katamari';
import Editor from '../api/Editor';
import Tools from '../api/util/Tools';
import FormatUtils from './FormatUtils';
import MatchFormat from './MatchFormat';

export type FormatChangeCallback = (state: boolean, data: { node: Node, format: string, parents: any }) => void;
type FormatCallbacks = Record<string, FormatChangeCallback[]>;
type FormatData = { similar?: boolean, callbacks: FormatChangeCallback[] };
type RegisteredFormats = Record<string, FormatData>;

const setup = (registeredFormatListeners: Cell<RegisteredFormats>, editor: Editor) => {
  const currentFormats = Cell<Record<string, FormatChangeCallback[]>>({ });

registeredFormatListeners.set({});

editor.on('NodeChange', (e) => {
    updateAndFireChangeCallbacks(editor, e.element, currentFormats, registeredFormatListeners.get());
  });
};

const updateAndFireChangeCallbacks = (editor: Editor, elm: Element, currentFormats: Cell<FormatCallbacks>, formatChangeData: RegisteredFormats) => {
  const formatsList = Obj.keys(currentFormats.get());
  const newFormats: FormatCallbacks = { };
  const matchedFormats: FormatCallbacks = { };

// Ignore bogus nodes like the <a> tag created by moveStart()
  const parents = Arr.filter(FormatUtils.getParents(editor.dom, elm), (node) => {
    return node.nodeType === 1 && !node.getAttribute('data-mce-bogus');
  });

// Check for new formats
  Obj.each(formatChangeData, (data: FormatData, format: string) => {
    Tools.each(parents, (node: Node) => {
      if (editor.formatter.matchNode(node, format, {}, data.similar)) {
        if (formatsList.indexOf(format) === -1) {
          // Execute callbacks
          Arr.each(data.callbacks, (callback: FormatChangeCallback) => {
            callback(true, { node, format, parents });
          });

newFormats[format] = data.callbacks;
        }

matchedFormats[format] = data.callbacks;
        return false;
      }

if (MatchFormat.matchesUnInheritedFormatSelector(editor, node, format)) {
        return false;
      }
    });
  });

// Check if current formats still match
  const remainingFormats = filterRemainingFormats(currentFormats.get(), matchedFormats, elm, parents);

// Update the current formats
  currentFormats.set({
    ...newFormats,
    ...remainingFormats
  });
};

const filterRemainingFormats = (currentFormats: FormatCallbacks, matchedFormats: FormatCallbacks, elm: Element, parents: Node[]) => {
  return Obj.bifilter(currentFormats, (callbacks: FormatChangeCallback[], format: string) => {
    if (!Obj.has(matchedFormats, format)) {
      // Execute callbacks
      Arr.each(callbacks, (callback: FormatChangeCallback) => {
        callback(false, { node: elm, format, parents });
      });

return false;
    } else {
      return true;
    }
  }).t;
};

const addListeners = (registeredFormatListeners: Cell<RegisteredFormats>, formats: string, callback: FormatChangeCallback, similar: boolean) => {
  const formatChangeItems = registeredFormatListeners.get();

Arr.each(formats.split(','), (format) => {
    if (!formatChangeItems[format]) {
      formatChangeItems[format] = { similar, callbacks: [] };
    }

formatChangeItems[format].callbacks.push(callback);
  });

registeredFormatListeners.set(formatChangeItems);
};

const removeListeners = (registeredFormatListeners: Cell<RegisteredFormats>, formats: string, callback: FormatChangeCallback) => {
  const formatChangeItems = registeredFormatListeners.get();

Arr.each(formats.split(','), (format) => {
    formatChangeItems[format].callbacks = Arr.filter(formatChangeItems[format].callbacks, (c) => {
      return c !== callback;
    });

if (formatChangeItems[format].callbacks.length === 0) {
      delete formatChangeItems[format];
    }
  });

registeredFormatListeners.set(formatChangeItems);
};

const formatChanged = (editor: Editor, registeredFormatListeners: Cell<RegisteredFormats>, formats: string, callback: FormatChangeCallback, similar?: boolean) => {
  if (registeredFormatListeners.get() === null) {
    setup(registeredFormatListeners, editor);
  }

addListeners(registeredFormatListeners, formats, callback, similar);

return {
    unbind: () => removeListeners(registeredFormatListeners, formats, callback)
  };
};

export {
  formatChanged
};