promethee 1.4.8 → 1.4.9

data/node_modules/summernote/src/js/base/core/env.js

@@ -0,0 +1,107 @@
+import $ from 'jquery';
+const isSupportAmd = typeof define === 'function' && define.amd; // eslint-disable-line
+
+/**
+ * returns whether font is installed or not.
+ *
+ * @param {String} fontName
+ * @return {Boolean}
+ */
+function isFontInstalled(fontName) {
+  const testFontName = fontName === 'Comic Sans MS' ? 'Courier New' : 'Comic Sans MS';
+  const $tester = $('<div>').css({
+    position: 'absolute',
+    left: '-9999px',
+    top: '-9999px',
+    fontSize: '200px'
+  }).text('mmmmmmmmmwwwwwww').appendTo(document.body);
+
+  const originalWidth = $tester.css('fontFamily', testFontName).width();
+  const width = $tester.css('fontFamily', fontName + ',' + testFontName).width();
+
+  $tester.remove();
+
+  return originalWidth !== width;
+}
+
+const userAgent = navigator.userAgent;
+const isMSIE = /MSIE|Trident/i.test(userAgent);
+let browserVersion;
+if (isMSIE) {
+  let matches = /MSIE (\d+[.]\d+)/.exec(userAgent);
+  if (matches) {
+    browserVersion = parseFloat(matches[1]);
+  }
+  matches = /Trident\/.*rv:([0-9]{1,}[.0-9]{0,})/.exec(userAgent);
+  if (matches) {
+    browserVersion = parseFloat(matches[1]);
+  }
+}
+
+const isEdge = /Edge\/\d+/.test(userAgent);
+
+let hasCodeMirror = !!window.CodeMirror;
+if (!hasCodeMirror && isSupportAmd) {
+  // Webpack
+  if (typeof __webpack_require__ === 'function') { // eslint-disable-line
+    try {
+      // If CodeMirror can't be resolved, `require.resolve` will throw an
+      // exception and `hasCodeMirror` won't be set to `true`.
+      require.resolve('codemirror');
+      hasCodeMirror = true;
+    } catch (e) {
+      // do nothing
+    }
+  } else if (typeof require !== 'undefined') {
+    // Browserify
+    if (typeof require.resolve !== 'undefined') {
+      try {
+        // If CodeMirror can't be resolved, `require.resolve` will throw an
+        // exception and `hasCodeMirror` won't be set to `true`.
+        require.resolve('codemirror');
+        hasCodeMirror = true;
+      } catch (e) {
+        // do nothing
+      }
+    // Almond/Require
+    } else if (typeof require.specified !== 'undefined') {
+      hasCodeMirror = require.specified('codemirror');
+    }
+  }
+}
+
+const isSupportTouch =
+  (('ontouchstart' in window) ||
+   (navigator.MaxTouchPoints > 0) ||
+   (navigator.msMaxTouchPoints > 0));
+
+// [workaround] IE doesn't have input events for contentEditable
+// - see: https://goo.gl/4bfIvA
+const inputEventName = (isMSIE || isEdge) ? 'DOMCharacterDataModified DOMSubtreeModified DOMNodeInserted' : 'input';
+
+/**
+ * @class core.env
+ *
+ * Object which check platform and agent
+ *
+ * @singleton
+ * @alternateClassName env
+ */
+export default {
+  isMac: navigator.appVersion.indexOf('Mac') > -1,
+  isMSIE,
+  isEdge,
+  isFF: !isEdge && /firefox/i.test(userAgent),
+  isPhantom: /PhantomJS/i.test(userAgent),
+  isWebkit: !isEdge && /webkit/i.test(userAgent),
+  isChrome: !isEdge && /chrome/i.test(userAgent),
+  isSafari: !isEdge && /safari/i.test(userAgent),
+  browserVersion,
+  jqueryVersion: parseFloat($.fn.jquery),
+  isSupportAmd,
+  isSupportTouch,
+  hasCodeMirror,
+  isFontInstalled,
+  isW3CRangeSupport: !!document.createRange,
+  inputEventName
+};

data/node_modules/summernote/src/js/base/core/func.js

@@ -0,0 +1,162 @@
+/**
+ * @class core.func
+ *
+ * func utils (for high-order func's arg)
+ *
+ * @singleton
+ * @alternateClassName func
+ */
+function eq(itemA) {
+  return function(itemB) {
+    return itemA === itemB;
+  };
+}
+
+function eq2(itemA, itemB) {
+  return itemA === itemB;
+}
+
+function peq2(propName) {
+  return function(itemA, itemB) {
+    return itemA[propName] === itemB[propName];
+  };
+}
+
+function ok() {
+  return true;
+}
+
+function fail() {
+  return false;
+}
+
+function not(f) {
+  return () => {
+    return !f.apply(f, arguments);
+  };
+}
+
+function and(fA, fB) {
+  return function(item) {
+    return fA(item) && fB(item);
+  };
+}
+
+function self(a) {
+  return a;
+}
+
+function invoke(obj, method) {
+  return () => {
+    return obj[method].apply(obj, arguments);
+  };
+}
+
+let idCounter = 0;
+
+/**
+ * generate a globally-unique id
+ *
+ * @param {String} [prefix]
+ */
+function uniqueId(prefix) {
+  const id = ++idCounter + '';
+  return prefix ? prefix + id : id;
+}
+
+/**
+ * returns bnd (bounds) from rect
+ *
+ * - IE Compatibility Issue: http://goo.gl/sRLOAo
+ * - Scroll Issue: http://goo.gl/sNjUc
+ *
+ * @param {Rect} rect
+ * @return {Object} bounds
+ * @return {Number} bounds.top
+ * @return {Number} bounds.left
+ * @return {Number} bounds.width
+ * @return {Number} bounds.height
+ */
+function rect2bnd(rect) {
+  const $document = $(document);
+  return {
+    top: rect.top + $document.scrollTop(),
+    left: rect.left + $document.scrollLeft(),
+    width: rect.right - rect.left,
+    height: rect.bottom - rect.top
+  };
+}
+
+/**
+ * returns a copy of the object where the keys have become the values and the values the keys.
+ * @param {Object} obj
+ * @return {Object}
+ */
+function invertObject(obj) {
+  const inverted = {};
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      inverted[obj[key]] = key;
+    }
+  }
+  return inverted;
+}
+
+/**
+ * @param {String} namespace
+ * @param {String} [prefix]
+ * @return {String}
+ */
+function namespaceToCamel(namespace, prefix) {
+  prefix = prefix || '';
+  return prefix + namespace.split('.').map(function(name) {
+    return name.substring(0, 1).toUpperCase() + name.substring(1);
+  }).join('');
+}
+
+/**
+ * Returns a function, that, as long as it continues to be invoked, will not
+ * be triggered. The function will be called after it stops being called for
+ * N milliseconds. If `immediate` is passed, trigger the function on the
+ * leading edge, instead of the trailing.
+ * @param {Function} func
+ * @param {Number} wait
+ * @param {Boolean} immediate
+ * @return {Function}
+ */
+function debounce(func, wait, immediate) {
+  let timeout;
+  return () => {
+    const context = this;
+    const args = arguments;
+    const later = () => {
+      timeout = null;
+      if (!immediate) {
+        func.apply(context, args);
+      }
+    };
+    const callNow = immediate && !timeout;
+    clearTimeout(timeout);
+    timeout = setTimeout(later, wait);
+    if (callNow) {
+      func.apply(context, args);
+    }
+  };
+}
+
+export default {
+  eq,
+  eq2,
+  peq2,
+  ok,
+  fail,
+  self,
+  not,
+  and,
+  invoke,
+  uniqueId,
+  rect2bnd,
+  invertObject,
+  namespaceToCamel,
+  debounce
+};

data/node_modules/summernote/src/js/base/core/key.js

@@ -0,0 +1,92 @@
+import lists from './lists';
+import func from './func';
+
+const KEY_MAP = {
+  'BACKSPACE': 8,
+  'TAB': 9,
+  'ENTER': 13,
+  'SPACE': 32,
+  'DELETE': 46,
+
+  // Arrow
+  'LEFT': 37,
+  'UP': 38,
+  'RIGHT': 39,
+  'DOWN': 40,
+
+  // Number: 0-9
+  'NUM0': 48,
+  'NUM1': 49,
+  'NUM2': 50,
+  'NUM3': 51,
+  'NUM4': 52,
+  'NUM5': 53,
+  'NUM6': 54,
+  'NUM7': 55,
+  'NUM8': 56,
+
+  // Alphabet: a-z
+  'B': 66,
+  'E': 69,
+  'I': 73,
+  'J': 74,
+  'K': 75,
+  'L': 76,
+  'R': 82,
+  'S': 83,
+  'U': 85,
+  'V': 86,
+  'Y': 89,
+  'Z': 90,
+
+  'SLASH': 191,
+  'LEFTBRACKET': 219,
+  'BACKSLASH': 220,
+  'RIGHTBRACKET': 221
+};
+
+/**
+ * @class core.key
+ *
+ * Object for keycodes.
+ *
+ * @singleton
+ * @alternateClassName key
+ */
+export default {
+  /**
+   * @method isEdit
+   *
+   * @param {Number} keyCode
+   * @return {Boolean}
+   */
+  isEdit: (keyCode) => {
+    return lists.contains([
+      KEY_MAP.BACKSPACE,
+      KEY_MAP.TAB,
+      KEY_MAP.ENTER,
+      KEY_MAP.SPACE,
+      KEY_MAP.DELETE
+    ], keyCode);
+  },
+  /**
+   * @method isMove
+   *
+   * @param {Number} keyCode
+   * @return {Boolean}
+   */
+  isMove: (keyCode) => {
+    return lists.contains([
+      KEY_MAP.LEFT,
+      KEY_MAP.UP,
+      KEY_MAP.RIGHT,
+      KEY_MAP.DOWN
+    ], keyCode);
+  },
+  /**
+   * @property {Object} nameFromCode
+   * @property {String} nameFromCode.8 "BACKSPACE"
+   */
+  nameFromCode: func.invertObject(KEY_MAP),
+  code: KEY_MAP
+};

data/node_modules/summernote/src/js/base/core/lists.js

@@ -0,0 +1,210 @@
+import $ from 'jquery';
+import func from './func';
+
+/**
+ * returns the first item of an array.
+ *
+ * @param {Array} array
+ */
+function head(array) {
+  return array[0];
+}
+
+/**
+ * returns the last item of an array.
+ *
+ * @param {Array} array
+ */
+function last(array) {
+  return array[array.length - 1];
+}
+
+/**
+ * returns everything but the last entry of the array.
+ *
+ * @param {Array} array
+ */
+function initial(array) {
+  return array.slice(0, array.length - 1);
+}
+
+/**
+ * returns the rest of the items in an array.
+ *
+ * @param {Array} array
+ */
+function tail(array) {
+  return array.slice(1);
+}
+
+/**
+ * returns item of array
+ */
+function find(array, pred) {
+  for (let idx = 0, len = array.length; idx < len; idx++) {
+    const item = array[idx];
+    if (pred(item)) {
+      return item;
+    }
+  }
+}
+
+/**
+ * returns true if all of the values in the array pass the predicate truth test.
+ */
+function all(array, pred) {
+  for (let idx = 0, len = array.length; idx < len; idx++) {
+    if (!pred(array[idx])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * returns index of item
+ */
+function indexOf(array, item) {
+  return $.inArray(item, array);
+}
+
+/**
+ * returns true if the value is present in the list.
+ */
+function contains(array, item) {
+  return indexOf(array, item) !== -1;
+}
+
+/**
+ * get sum from a list
+ *
+ * @param {Array} array - array
+ * @param {Function} fn - iterator
+ */
+function sum(array, fn) {
+  fn = fn || func.self;
+  return array.reduce(function(memo, v) {
+    return memo + fn(v);
+  }, 0);
+}
+
+/**
+ * returns a copy of the collection with array type.
+ * @param {Collection} collection - collection eg) node.childNodes, ...
+ */
+function from(collection) {
+  const result = [];
+  const length = collection.length;
+  let idx = -1;
+  while (++idx < length) {
+    result[idx] = collection[idx];
+  }
+  return result;
+}
+
+/**
+ * returns whether list is empty or not
+ */
+function isEmpty(array) {
+  return !array || !array.length;
+}
+
+/**
+ * cluster elements by predicate function.
+ *
+ * @param {Array} array - array
+ * @param {Function} fn - predicate function for cluster rule
+ * @param {Array[]}
+ */
+function clusterBy(array, fn) {
+  if (!array.length) { return []; }
+  const aTail = tail(array);
+  return aTail.reduce(function(memo, v) {
+    const aLast = last(memo);
+    if (fn(last(aLast), v)) {
+      aLast[aLast.length] = v;
+    } else {
+      memo[memo.length] = [v];
+    }
+    return memo;
+  }, [[head(array)]]);
+}
+
+/**
+ * returns a copy of the array with all false values removed
+ *
+ * @param {Array} array - array
+ * @param {Function} fn - predicate function for cluster rule
+ */
+function compact(array) {
+  const aResult = [];
+  for (let idx = 0, len = array.length; idx < len; idx++) {
+    if (array[idx]) { aResult.push(array[idx]); }
+  }
+  return aResult;
+}
+
+/**
+ * produces a duplicate-free version of the array
+ *
+ * @param {Array} array
+ */
+function unique(array) {
+  const results = [];
+
+  for (let idx = 0, len = array.length; idx < len; idx++) {
+    if (!contains(results, array[idx])) {
+      results.push(array[idx]);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * returns next item.
+ * @param {Array} array
+ */
+function next(array, item) {
+  const idx = indexOf(array, item);
+  if (idx === -1) { return null; }
+
+  return array[idx + 1];
+}
+
+/**
+ * returns prev item.
+ * @param {Array} array
+ */
+function prev(array, item) {
+  const idx = indexOf(array, item);
+  if (idx === -1) { return null; }
+
+  return array[idx - 1];
+}
+
+/**
+ * @class core.list
+ *
+ * list utils
+ *
+ * @singleton
+ * @alternateClassName list
+ */
+export default {
+  head,
+  last,
+  initial,
+  tail,
+  prev,
+  next,
+  find,
+  contains,
+  all,
+  sum,
+  from,
+  isEmpty,
+  clusterBy,
+  compact,
+  unique
+};