rails_modular_admin 0.3.1 → 0.4.0

data/app/assets/node_modules/quill/core/quill.js

@@ -0,0 +1,506 @@
+import './polyfill';
+import Delta from 'quill-delta';
+import Editor from './editor';
+import Emitter from './emitter';
+import Module from './module';
+import Parchment from 'parchment';
+import Selection, { Range } from './selection';
+import extend from 'extend';
+import logger from './logger';
+import Theme from './theme';
+
+let debug = logger('quill');
+
+
+class Quill {
+  static debug(limit) {
+    if (limit === true) {
+      limit = 'log';
+    }
+    logger.level(limit);
+  }
+
+  static find(node) {
+    return node.__quill || Parchment.find(node);
+  }
+
+  static import(name) {
+    if (this.imports[name] == null) {
+      debug.error(`Cannot import ${name}. Are you sure it was registered?`);
+    }
+    return this.imports[name];
+  }
+
+  static register(path, target, overwrite = false) {
+    if (typeof path !== 'string') {
+      let name = path.attrName || path.blotName;
+      if (typeof name === 'string') {
+        // register(Blot | Attributor, overwrite)
+        this.register('formats/' + name, path, target);
+      } else {
+        Object.keys(path).forEach((key) => {
+          this.register(key, path[key], target);
+        });
+      }
+    } else {
+      if (this.imports[path] != null && !overwrite) {
+        debug.warn(`Overwriting ${path} with`, target);
+      }
+      this.imports[path] = target;
+      if ((path.startsWith('blots/') || path.startsWith('formats/')) &&
+          target.blotName !== 'abstract') {
+        Parchment.register(target);
+      } else if (path.startsWith('modules') && typeof target.register === 'function') {
+        target.register();
+      }
+    }
+  }
+
+  constructor(container, options = {}) {
+    this.options = expandConfig(container, options);
+    this.container = this.options.container;
+    if (this.container == null) {
+      return debug.error('Invalid Quill container', container);
+    }
+    if (this.options.debug) {
+      Quill.debug(this.options.debug);
+    }
+    let html = this.container.innerHTML.trim();
+    this.container.classList.add('ql-container');
+    this.container.innerHTML = '';
+    this.container.__quill = this;
+    this.root = this.addContainer('ql-editor');
+    this.root.classList.add('ql-blank');
+    this.root.setAttribute('data-gramm', false);
+    this.scrollingContainer = this.options.scrollingContainer || this.root;
+    this.emitter = new Emitter();
+    this.scroll = Parchment.create(this.root, {
+      emitter: this.emitter,
+      whitelist: this.options.formats
+    });
+    this.editor = new Editor(this.scroll);
+    this.selection = new Selection(this.scroll, this.emitter);
+    this.theme = new this.options.theme(this, this.options);
+    this.keyboard = this.theme.addModule('keyboard');
+    this.clipboard = this.theme.addModule('clipboard');
+    this.history = this.theme.addModule('history');
+    this.theme.init();
+    this.emitter.on(Emitter.events.EDITOR_CHANGE, (type) => {
+      if (type === Emitter.events.TEXT_CHANGE) {
+        this.root.classList.toggle('ql-blank', this.editor.isBlank());
+      }
+    });
+    this.emitter.on(Emitter.events.SCROLL_UPDATE, (source, mutations) => {
+      let range = this.selection.lastRange;
+      let index = range && range.length === 0 ? range.index : undefined;
+      modify.call(this, () => {
+        return this.editor.update(null, mutations, index);
+      }, source);
+    });
+    let contents = this.clipboard.convert(`<div class='ql-editor' style="white-space: normal;">${html}<p><br></p></div>`);
+    this.setContents(contents);
+    this.history.clear();
+    if (this.options.placeholder) {
+      this.root.setAttribute('data-placeholder', this.options.placeholder);
+    }
+    if (this.options.readOnly) {
+      this.disable();
+    }
+  }
+
+  addContainer(container, refNode = null) {
+    if (typeof container === 'string') {
+      let className = container;
+      container = document.createElement('div');
+      container.classList.add(className);
+    }
+    this.container.insertBefore(container, refNode);
+    return container;
+  }
+
+  blur() {
+    this.selection.setRange(null);
+  }
+
+  deleteText(index, length, source) {
+    [index, length, , source] = overload(index, length, source);
+    return modify.call(this, () => {
+      return this.editor.deleteText(index, length);
+    }, source, index, -1*length);
+  }
+
+  disable() {
+    this.enable(false);
+  }
+
+  enable(enabled = true) {
+    this.scroll.enable(enabled);
+    this.container.classList.toggle('ql-disabled', !enabled);
+  }
+
+  focus() {
+    let scrollTop = this.scrollingContainer.scrollTop;
+    this.selection.focus();
+    this.scrollingContainer.scrollTop = scrollTop;
+    this.scrollIntoView();
+  }
+
+  format(name, value, source = Emitter.sources.API) {
+    return modify.call(this, () => {
+      let range = this.getSelection(true);
+      let change = new Delta();
+      if (range == null) {
+        return change;
+      } else if (Parchment.query(name, Parchment.Scope.BLOCK)) {
+        change = this.editor.formatLine(range.index, range.length, { [name]: value });
+      } else if (range.length === 0) {
+        this.selection.format(name, value);
+        return change;
+      } else {
+        change = this.editor.formatText(range.index, range.length, { [name]: value });
+      }
+      this.setSelection(range, Emitter.sources.SILENT);
+      return change;
+    }, source);
+  }
+
+  formatLine(index, length, name, value, source) {
+    let formats;
+    [index, length, formats, source] = overload(index, length, name, value, source);
+    return modify.call(this, () => {
+      return this.editor.formatLine(index, length, formats);
+    }, source, index, 0);
+  }
+
+  formatText(index, length, name, value, source) {
+    let formats;
+    [index, length, formats, source] = overload(index, length, name, value, source);
+    return modify.call(this, () => {
+      return this.editor.formatText(index, length, formats);
+    }, source, index, 0);
+  }
+
+  getBounds(index, length = 0) {
+    let bounds;
+    if (typeof index === 'number') {
+      bounds = this.selection.getBounds(index, length);
+    } else {
+      bounds = this.selection.getBounds(index.index, index.length);
+    }
+    let containerBounds = this.container.getBoundingClientRect();
+    return {
+      bottom: bounds.bottom - containerBounds.top,
+      height: bounds.height,
+      left: bounds.left - containerBounds.left,
+      right: bounds.right - containerBounds.left,
+      top: bounds.top - containerBounds.top,
+      width: bounds.width
+    };
+  }
+
+  getContents(index = 0, length = this.getLength() - index) {
+    [index, length] = overload(index, length);
+    return this.editor.getContents(index, length);
+  }
+
+  getFormat(index = this.getSelection(true), length = 0) {
+    if (typeof index === 'number') {
+      return this.editor.getFormat(index, length);
+    } else {
+      return this.editor.getFormat(index.index, index.length);
+    }
+  }
+
+  getIndex(blot) {
+    return blot.offset(this.scroll);
+  }
+
+  getLength() {
+    return this.scroll.length();
+  }
+
+  getLeaf(index) {
+    return this.scroll.leaf(index);
+  }
+
+  getLine(index) {
+    return this.scroll.line(index);
+  }
+
+  getLines(index = 0, length = Number.MAX_VALUE) {
+    if (typeof index !== 'number') {
+      return this.scroll.lines(index.index, index.length);
+    } else {
+      return this.scroll.lines(index, length);
+    }
+  }
+
+  getModule(name) {
+    return this.theme.modules[name];
+  }
+
+  getSelection(focus = false) {
+    if (focus) this.focus();
+    this.update();  // Make sure we access getRange with editor in consistent state
+    return this.selection.getRange()[0];
+  }
+
+  getText(index = 0, length = this.getLength() - index) {
+    [index, length] = overload(index, length);
+    return this.editor.getText(index, length);
+  }
+
+  hasFocus() {
+    return this.selection.hasFocus();
+  }
+
+  insertEmbed(index, embed, value, source = Quill.sources.API) {
+    return modify.call(this, () => {
+      return this.editor.insertEmbed(index, embed, value);
+    }, source, index);
+  }
+
+  insertText(index, text, name, value, source) {
+    let formats;
+    [index, , formats, source] = overload(index, 0, name, value, source);
+    return modify.call(this, () => {
+      return this.editor.insertText(index, text, formats);
+    }, source, index, text.length);
+  }
+
+  isEnabled() {
+    return !this.container.classList.contains('ql-disabled');
+  }
+
+  off() {
+    return this.emitter.off.apply(this.emitter, arguments);
+  }
+
+  on() {
+    return this.emitter.on.apply(this.emitter, arguments);
+  }
+
+  once() {
+    return this.emitter.once.apply(this.emitter, arguments);
+  }
+
+  pasteHTML(index, html, source) {
+    this.clipboard.dangerouslyPasteHTML(index, html, source);
+  }
+
+  removeFormat(index, length, source) {
+    [index, length, , source] = overload(index, length, source);
+    return modify.call(this, () => {
+      return this.editor.removeFormat(index, length);
+    }, source, index);
+  }
+
+  scrollIntoView() {
+    this.selection.scrollIntoView(this.scrollingContainer);
+  }
+
+  setContents(delta, source = Emitter.sources.API) {
+    return modify.call(this, () => {
+      delta = new Delta(delta);
+      let length = this.getLength();
+      let deleted = this.editor.deleteText(0, length);
+      let applied = this.editor.applyDelta(delta);
+      let lastOp = applied.ops[applied.ops.length - 1];
+      if (lastOp != null && typeof(lastOp.insert) === 'string' && lastOp.insert[lastOp.insert.length-1] === '\n') {
+        this.editor.deleteText(this.getLength() - 1, 1);
+        applied.delete(1);
+      }
+      let ret = deleted.compose(applied);
+      return ret;
+    }, source);
+  }
+
+  setSelection(index, length, source) {
+    if (index == null) {
+      this.selection.setRange(null, length || Quill.sources.API);
+    } else {
+      [index, length, , source] = overload(index, length, source);
+      this.selection.setRange(new Range(index, length), source);
+      if (source !== Emitter.sources.SILENT) {
+        this.selection.scrollIntoView(this.scrollingContainer);
+      }
+    }
+  }
+
+  setText(text, source = Emitter.sources.API) {
+    let delta = new Delta().insert(text);
+    return this.setContents(delta, source);
+  }
+
+  update(source = Emitter.sources.USER) {
+    let change = this.scroll.update(source);   // Will update selection before selection.update() does if text changes
+    this.selection.update(source);
+    return change;
+  }
+
+  updateContents(delta, source = Emitter.sources.API) {
+    return modify.call(this, () => {
+      delta = new Delta(delta);
+      return this.editor.applyDelta(delta, source);
+    }, source, true);
+  }
+}
+Quill.DEFAULTS = {
+  bounds: null,
+  formats: null,
+  modules: {},
+  placeholder: '',
+  readOnly: false,
+  scrollingContainer: null,
+  strict: true,
+  theme: 'default'
+};
+Quill.events = Emitter.events;
+Quill.sources = Emitter.sources;
+// eslint-disable-next-line no-undef
+Quill.version = typeof(QUILL_VERSION) === 'undefined' ? 'dev' : QUILL_VERSION;
+
+Quill.imports = {
+  'delta'       : Delta,
+  'parchment'   : Parchment,
+  'core/module' : Module,
+  'core/theme'  : Theme
+};
+
+
+function expandConfig(container, userConfig) {
+  userConfig = extend(true, {
+    container: container,
+    modules: {
+      clipboard: true,
+      keyboard: true,
+      history: true
+    }
+  }, userConfig);
+  if (!userConfig.theme || userConfig.theme === Quill.DEFAULTS.theme) {
+    userConfig.theme = Theme;
+  } else {
+    userConfig.theme = Quill.import(`themes/${userConfig.theme}`);
+    if (userConfig.theme == null) {
+      throw new Error(`Invalid theme ${userConfig.theme}. Did you register it?`);
+    }
+  }
+  let themeConfig = extend(true, {}, userConfig.theme.DEFAULTS);
+  [themeConfig, userConfig].forEach(function(config) {
+    config.modules = config.modules || {};
+    Object.keys(config.modules).forEach(function(module) {
+      if (config.modules[module] === true) {
+        config.modules[module] = {};
+      }
+    });
+  });
+  let moduleNames = Object.keys(themeConfig.modules).concat(Object.keys(userConfig.modules));
+  let moduleConfig = moduleNames.reduce(function(config, name) {
+    let moduleClass = Quill.import(`modules/${name}`);
+    if (moduleClass == null) {
+      debug.error(`Cannot load ${name} module. Are you sure you registered it?`);
+    } else {
+      config[name] = moduleClass.DEFAULTS || {};
+    }
+    return config;
+  }, {});
+  // Special case toolbar shorthand
+  if (userConfig.modules != null && userConfig.modules.toolbar &&
+      userConfig.modules.toolbar.constructor !== Object) {
+    userConfig.modules.toolbar = {
+      container: userConfig.modules.toolbar
+    };
+  }
+  userConfig = extend(true, {}, Quill.DEFAULTS, { modules: moduleConfig }, themeConfig, userConfig);
+  ['bounds', 'container', 'scrollingContainer'].forEach(function(key) {
+    if (typeof userConfig[key] === 'string') {
+      userConfig[key] = document.querySelector(userConfig[key]);
+    }
+  });
+  userConfig.modules = Object.keys(userConfig.modules).reduce(function(config, name) {
+    if (userConfig.modules[name]) {
+      config[name] = userConfig.modules[name];
+    }
+    return config;
+  }, {});
+  return userConfig;
+}
+
+// Handle selection preservation and TEXT_CHANGE emission
+// common to modification APIs
+function modify(modifier, source, index, shift) {
+  if (this.options.strict && !this.isEnabled() && source === Emitter.sources.USER) {
+    return new Delta();
+  }
+  let range = index == null ? null : this.getSelection();
+  let oldDelta = this.editor.delta;
+  let change = modifier();
+  if (range != null) {
+    if (index === true) index = range.index;
+    if (shift == null) {
+      range = shiftRange(range, change, source);
+    } else if (shift !== 0) {
+      range = shiftRange(range, index, shift, source);
+    }
+    this.setSelection(range, Emitter.sources.SILENT);
+  }
+  if (change.length() > 0) {
+    let args = [Emitter.events.TEXT_CHANGE, change, oldDelta, source];
+    this.emitter.emit(Emitter.events.EDITOR_CHANGE, ...args);
+    if (source !== Emitter.sources.SILENT) {
+      this.emitter.emit(...args);
+    }
+  }
+  return change;
+}
+
+function overload(index, length, name, value, source) {
+  let formats = {};
+  if (typeof index.index === 'number' && typeof index.length === 'number') {
+    // Allow for throwaway end (used by insertText/insertEmbed)
+    if (typeof length !== 'number') {
+      source = value, value = name, name = length, length = index.length, index = index.index;
+    } else {
+      length = index.length, index = index.index;
+    }
+  } else if (typeof length !== 'number') {
+    source = value, value = name, name = length, length = 0;
+  }
+  // Handle format being object, two format name/value strings or excluded
+  if (typeof name === 'object') {
+    formats = name;
+    source = value;
+  } else if (typeof name === 'string') {
+    if (value != null) {
+      formats[name] = value;
+    } else {
+      source = name;
+    }
+  }
+  // Handle optional source
+  source = source || Emitter.sources.API;
+  return [index, length, formats, source];
+}
+
+function shiftRange(range, index, length, source) {
+  if (range == null) return null;
+  let start, end;
+  if (index instanceof Delta) {
+    [start, end] = [range.index, range.index + range.length].map(function(pos) {
+      return index.transformPosition(pos, source !== Emitter.sources.USER);
+    });
+  } else {
+    [start, end] = [range.index, range.index + range.length].map(function(pos) {
+      if (pos < index || (pos === index && source === Emitter.sources.USER)) return pos;
+      if (length >= 0) {
+        return pos + length;
+      } else {
+        return Math.max(index, pos + length);
+      }
+    });
+  }
+  return new Range(start, end - start);
+}
+
+
+export { expandConfig, overload, Quill as default };