tweb-i2p/src/lib/utils.js

/*!
 * Webogram v0.7.0 - messaging web application for MTProto
 * https://github.com/zhukov/webogram
 * Copyright (C) 2014 Igor Zhukov <igor.beatle@gmail.com>
 * https://github.com/zhukov/webogram/blob/master/LICENSE
 */
var _logTimer = (new Date()).getTime()
export function dT () {
  return '[' + (((new Date()).getTime() - _logTimer) / 1000).toFixed(3) + ']'
}

export function checkClick (e, noprevent) {
  if (e.which == 1 && (e.ctrlKey || e.metaKey) || e.which == 2) {
    return true
  }

  if (!noprevent) {
    e.preventDefault()
  }

  return false
}

export function isInDOM (element, parentNode) {
  if (!element) {
    return false
  }
  parentNode = parentNode || document.body
  if (element == parentNode) {
    return true
  }
  return isInDOM(element.parentNode, parentNode)
}

export function checkDragEvent(e) {
  if (!e || e.target && (e.target.tagName == 'IMG' || e.target.tagName == 'A')) return false
  if (e.dataTransfer && e.dataTransfer.types) {
    for (var i = 0; i < e.dataTransfer.types.length; i++) {
      if (e.dataTransfer.types[i] == 'Files') {
        return true
      }
    }
  } else {
    return true
  }

  return false
}

export function cancelEvent (event) {
  event = event || window.event
  if (event) {
    event = event.originalEvent || event

    if (event.stopPropagation) event.stopPropagation()
    if (event.preventDefault) event.preventDefault()
    event.returnValue = false
    event.cancelBubble = true
  }

  return false
}

export function onCtrlEnter (textarea, cb) {
  $(textarea).on('keydown', function (e) {
    if (e.keyCode == 13 && (e.ctrlKey || e.metaKey)) {
      cb()
      return cancelEvent(e)
    }
  })
}

export function setFieldSelection (field, from, to) {
  field = $(field)[0]
  try {
    field.focus()
    if (from === undefined || from === false) {
      from = field.value.length
    }
    if (to === undefined || to === false) {
      to = from
    }
    if (field.createTextRange) {
      var range = field.createTextRange()
      range.collapse(true)
      range.moveEnd('character', to)
      range.moveStart('character', from)
      range.select()
    }
    else if (field.setSelectionRange) {
      field.setSelectionRange(from, to)
    }
  } catch(e) {}
}

export function getFieldSelection (field) {
  if (field.selectionStart) {
    return field.selectionStart
  }
  else if (!document.selection) {
    return 0
  }

  var c = '\x01'
  var sel = document.selection.createRange()
  var txt = sel.text
  var dup = sel.duplicate()
  var len = 0

  try {
    dup.moveToElementText(field)
  } catch(e) {
    return 0
  }

  sel.text = txt + c
  len = dup.text.indexOf(c)
  sel.moveStart('character', -1)
  sel.text = ''

  // if (browser.msie && len == -1) {
  //   return field.value.length
  // }
  return len
}

export function getRichValue (field) {
  if (!field) {
    return ''
  }
  var lines = []
  var line = []

  getRichElementValue(field, lines, line)
  if (line.length) {
    lines.push(line.join(''))
  }

  var value = lines.join('\n')
  value = value.replace(/\u00A0/g, ' ')

  return value
}

export function placeCaretAtEnd(el) {
  el.focus();
  if (typeof window.getSelection != "undefined"
          && typeof document.createRange != "undefined") {
      var range = document.createRange();
      range.selectNodeContents(el);
      range.collapse(false);
      var sel = window.getSelection();
      sel.removeAllRanges();
      sel.addRange(range);
  } else if (typeof document.body.createTextRange != "undefined") {
      var textRange = document.body.createTextRange();
      textRange.moveToElementText(el);
      textRange.collapse(false);
      textRange.select();
  }
}

export function getRichValueWithCaret (field) {
  if (!field) {
    return []
  }
  var lines = []
  var line = []

  var sel = window.getSelection ? window.getSelection() : false
  var selNode
  var selOffset
  if (sel && sel.rangeCount) {
    var range = sel.getRangeAt(0)
    /* if (range.startContainer &&
      range.startContainer == range.endContainer &&
      range.startOffset == range.endOffset) { */
      selNode = range.startContainer
      selOffset = range.startOffset
    //}
  }

  getRichElementValue(field, lines, line, selNode, selOffset)

  if (line.length) {
    lines.push(line.join(''))
  }

  var value = lines.join('\n')
  var caretPos = value.indexOf('\x01')
  if (caretPos != -1) {
    value = value.substr(0, caretPos) + value.substr(caretPos + 1)
  }
  value = value.replace(/\u00A0/g, ' ')

  return [value, caretPos]
}

export function getRichElementValue (node, lines, line, selNode, selOffset) {
  if (node.nodeType == 3) { // TEXT
    if (selNode === node) {
      var value = node.nodeValue
      line.push(value.substr(0, selOffset) + '\x01' + value.substr(selOffset))
    } else {
      line.push(node.nodeValue)
    }
    return
  }
  if (node.nodeType != 1) { // NON-ELEMENT
    return
  }
  var isSelected = (selNode === node)
  var isBlock = node.tagName == 'DIV' || node.tagName == 'P'
  var curChild
  if (isBlock && line.length || node.tagName == 'BR') {
    lines.push(line.join(''))
    line.splice(0, line.length)
  }
  else if (node.tagName == 'IMG') {
    if (node.alt) {
      line.push(node.alt)
    }
  }
  if (isSelected && !selOffset) {
    line.push('\x01')
  }
  var curChild = node.firstChild
  while (curChild) {
    getRichElementValue(curChild, lines, line, selNode, selOffset)
    curChild = curChild.nextSibling
  }
  if (isSelected && selOffset) {
    line.push('\x01')
  }
  if (isBlock && line.length) {
    lines.push(line.join(''))
    line.splice(0, line.length)
  }
}

export function setRichFocus (field, selectNode, noCollapse) {
  field.focus()
  if (selectNode &&
    selectNode.parentNode == field &&
    !selectNode.nextSibling &&
    !noCollapse) {
    field.removeChild(selectNode)
    selectNode = null
  }
  if (window.getSelection && document.createRange) {
    var range = document.createRange()
    if (selectNode) {
      range.selectNode(selectNode)
    } else {
      range.selectNodeContents(field)
    }
    if (!noCollapse) {
      range.collapse(false)
    }

    var sel = window.getSelection()
    sel.removeAllRanges()
    sel.addRange(range)
  }
  else if (document.body.createTextRange !== undefined) {
    var textRange = document.body.createTextRange()
    textRange.moveToElementText(selectNode || field)
    if (!noCollapse) {
      textRange.collapse(false)
    }
    textRange.select()
  }
}

export function getSelectedText() {
  var sel = (
  window.getSelection && window.getSelection() ||
  document.getSelection && document.getSelection() ||
  document.selection && document.selection.createRange().text || ''
    ).toString().replace(/^\s+|\s+$/g, '')

  return sel
}

/* if (Config.Modes.animations &&
  typeof window.requestAnimationFrame == 'function') {
  window.onAnimationFrameCallback = function (cb) {
    return (function () {
      window.requestAnimationFrame(cb)
    })
  }
} else {
  window.onAnimationFrameCallback = function (cb) {
    return cb
  }
} */

export const $rootScope = {
  $broadcast: (name/* : string */, detail/*? : any */) => {
    console.log(dT(), 'Broadcasting ' + name + ' event, with args:', detail);
    //console.trace();
    let myCustomEvent = new CustomEvent(name, {detail});
    document.dispatchEvent(myCustomEvent);
  },
  $on: (name/* : string */, callback/* : any */) => {
    document.addEventListener(name, callback);
  },

  selectedPeerID: 0,
  idle: {
    isIDLE: false
  }
};

export const langPack = {
  "messageActionChatCreate": "created the group",
	"messageActionChatEditTitle": "changed group name",
	"messageActionChatEditPhoto": "changed group photo",
	"messageActionChatDeletePhoto": "removed group photo",
	"messageActionChatReturn": "returned to group",
	"messageActionChatJoined": "joined the group",
  "messageActionChatAddUser": "invited {user}",
  "messageActionChatAddUsers": "invited {} users",
	"messageActionChatLeave": "left group",
	"messageActionChatDeleteUser": "removed user",
	"messageActionChatJoinedByLink": "joined the group",
	"messageActionChannelCreate": "Channel created",
	"messageActionChannelEditTitle": "Channel renamed",
	"messageActionChannelEditPhoto": "Channel photo updated",
	"messageActionChannelDeletePhoto": "Channel photo removed",
	"messageActionPinMessage": "pinned message",

  "messageActionPhoneCall.in_ok": "Incoming Call",
	"messageActionPhoneCall.out_ok": "Outgoing Call",
	"messageActionPhoneCall.in_missed": "Missed Call",
	"messageActionPhoneCall.out_missed": "Cancelled Call",
};

export const _ = (str/* : string */) => {
  str = str.replace('_raw', '');

  return langPack[str] ? langPack[str] : str;
};

export function isObject(object) {
  return typeof(object) === 'object' && object !== null;
}

export function tsNow (seconds) {
  var t = +new Date() + (window.tsOffset || 0)
  return seconds ? Math.floor(t / 1000) : t
}

export function safeReplaceObject (wasObject, newObject) {
  for (var key in wasObject) {
    if (!newObject.hasOwnProperty(key) && key.charAt(0) != '$') {
      delete wasObject[key]
    }
  }
  for (var key in newObject) {
    if (newObject.hasOwnProperty(key)) {
      wasObject[key] = newObject[key]
    }
  }
}

export function numberWithCommas(x) {
  var parts = x.toString().split(".");
  parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
  return parts.join(".");
}

export function findUpClassName(el, className) {
  if(el.classList.contains(className)) return el; // 03.02.2020

  while(el.parentNode) {
    el = el.parentNode;
    if(el.classList.contains(className)) 
      return el;
  }
  return null;
}

export function findUpTag(el, tag) {
  if(el.tagName == tag) return el; // 03.02.2020

  while(el.parentNode) {
    el = el.parentNode;
    if(el.tagName === tag) 
      return el;
  }
  return null;
}

export function isElementInViewport(el) {
  var rect   = el.getBoundingClientRect(),
    vWidth   = window.innerWidth || document.documentElement.clientWidth,
    vHeight  = window.innerHeight || document.documentElement.clientHeight,
    efp      = function(x, y) { return document.elementFromPoint(x, y) };     

  // Return false if it's not in the viewport
  if(rect.right < 0 || rect.bottom < 0 
    || rect.left > vWidth || rect.top > vHeight 
    || !rect.width || !rect.height) {
    return false;
  }

  let elements = [
    efp(rect.left + 1,  rect.top + 1),
    efp(rect.right - 1, rect.top + 1),
    efp(rect.right - 1, rect.bottom - 1),
    efp(rect.left + 1,  rect.bottom - 1)
  ];

  // Return true if any of its four corners are visible
  return elements.find(e => el.contains(e) || el.parentElement == e) !== undefined;
}

export function isScrolledIntoView(el) {
  var rect = el.getBoundingClientRect();
  var elemTop = rect.top;
  var elemBottom = rect.bottom;

  // Only completely visible elements return true:
  //var isVisible = (elemTop >= 0) && (elemBottom <= window.innerHeight);
  // Partially visible elements return true:
  var isVisible = elemTop < window.innerHeight && elemBottom >= 0;
  return isVisible;
}

/* export function isScrolledIntoView(el) {
  var rect = el.getBoundingClientRect(), top = rect.top, height = rect.height, 
    el = el.parentNode
  // Check if bottom of the element is off the page
  if (rect.bottom < 0) return false
  // Check its within the document viewport
  if (top > document.documentElement.clientHeight) return false
  do {
    rect = el.getBoundingClientRect()
    if (top <= rect.bottom === false) return false
    // Check if the element is out of view due to a container scrolling
    if ((top + height) <= rect.top) return false
    el = el.parentNode
  } while (el != document.body)
  return true
}; */

export function whichChild(elem/* : Node */) {
  let i = 0;
  // @ts-ignore
  while((elem = elem.previousElementSibling) != null) ++i;
  return i;
};

export function copy(obj) {
  //in case of premitives
  if(obj===null || typeof obj !== "object"){
    return obj;
  }
 
  //date objects should be 
  if(obj instanceof Date){
    return new Date(obj.getTime());
  }
 
  //handle Array
  if(Array.isArray(obj)){
    var clonedArr = [];
    obj.forEach(function(element){
      clonedArr.push(copy(element))
    });
    return clonedArr;
  }
 
  //lastly, handle objects
  let clonedObj = new obj.constructor();
  for(var prop in obj){
    if(obj.hasOwnProperty(prop)){
      clonedObj[prop] = copy(obj[prop]);
    }
  }
  return clonedObj;
}

/* export function ripple(elem) {
  elem.addEventListener('mousedown', function(e) {
    let rect = this.getBoundingClientRect();

    const startTime = Date.now();
    const animationTime = 350;

    let X = e.clientX - rect.left;
    let Y = e.clientY - rect.top;
    let rippleDiv = document.createElement("div");
    rippleDiv.classList.add("ripple");
    rippleDiv.setAttribute("style", "top:" + Y + "px; left:" + X + "px;");
    this.appendChild(rippleDiv);

    elem.addEventListener('mouseup', () => {
      let elapsed = Date.now() - startTime;

      setTimeout(() => {
        rippleDiv.parentElement.removeChild(rippleDiv);
      }, elapsed < animationTime ? animationTime - elapsed : 0);
    }, {once: true});
  });
}; */

export function formatBytes(bytes, decimals = 2) {
  if (bytes === 0) return '0 Bytes';

  const k = 1024;
  const dm = decimals < 0 ? 0 : decimals;
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];

  const i = Math.floor(Math.log(bytes) / Math.log(k));

  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
}

export function formatNumber(bytes, decimals = 2) {
  if(bytes === 0) return '0';

  const k = 1000;
  const dm = decimals < 0 ? 0 : decimals;
  const sizes = ['', 'K', 'M', 'B', 'T'];

  const i = Math.floor(Math.log(bytes) / Math.log(k));

  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + sizes[i];
}

export function deepEqual(x, y) {
  const ok = Object.keys, tx = typeof x, ty = typeof y;
  return x && y && tx === 'object' && tx === ty ? (
    ok(x).length === ok(y).length &&
      ok(x).every(key => deepEqual(x[key], y[key]))
  ) : (x === y);
}

export function listMergeSorted (list1, list2) {
  list1 = list1 || []
  list2 = list2 || []

  var result = copy(list1);

  var minID = list1.length ? list1[list1.length - 1] : 0xFFFFFFFF
  for (var i = 0; i < list2.length; i++) {
    if (list2[i] < minID) {
      result.push(list2[i])
    }
  }

  return result
}

export function listUniqSorted (list) {
  list = list || []
  var resultList = []
  var prev = false
  for (var i = 0; i < list.length; i++) {
    if (list[i] !== prev) {
      resultList.push(list[i])
    }
    prev = list[i]
  }

  return resultList
}

export function encodeEntities (value) {
  return value.replace(/&/g, '&amp;').replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, function (value) {
    var hi = value.charCodeAt(0)
    var low = value.charCodeAt(1)
    return '&#' + (((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000) + ';'
  }).replace(/([^\#-~| |!])/g, function (value) { // non-alphanumeric
    return '&#' + value.charCodeAt(0) + ';'
  }).replace(/</g, '&lt;').replace(/>/g, '&gt;')
}

export function calcImageInBox (imageW, imageH, boxW, boxH, noZooom) {
  var boxedImageW = boxW
  var boxedImageH = boxH

  if((imageW / imageH) > (boxW / boxH)) {
    boxedImageH = parseInt(imageH * boxW / imageW)
  } else {
    boxedImageW = parseInt(imageW * boxH / imageH)
    if(boxedImageW > boxW) {
      boxedImageH = parseInt(boxedImageH * boxW / boxedImageW)
      boxedImageW = boxW
    }
  }

  // if (Config.Navigator.retina) {
  //   imageW = Math.floor(imageW / 2)
  //   imageH = Math.floor(imageH / 2)
  // }

  if(noZooom && boxedImageW >= imageW && boxedImageH >= imageH) {
    boxedImageW = imageW
    boxedImageH = imageH
  }

  return {w: boxedImageW, h: boxedImageH}
}

/**
 * emojiUnicode
 * Get the unicode code of an emoji in base 16.
 *
 * @name emojiUnicode
 * @function
 * @param {String} input The emoji character.
 * @returns {String} The base 16 unicode code.
 */
/* export function emojiUnicode (input) {
  let pairs = emojiUnicode.raw(input).split(' ').map(val => parseInt(val).toString(16));
  if(pairs[0].length == 2) pairs[0] = '00' + pairs[0];
  return pairs.join('-').toUpperCase();
} */

/**
* emojiunicode.raw
* Get the unicode code points of an emoji in base 16.
*
* @name emojiunicode.raw
* @function
* @param {String} input The emoji character.
* @returns {String} The unicode code points.
*/
/* emojiUnicode.raw = function (input) {
  if(input.length === 1) {
    return input.charCodeAt(0).toString();
  } else if(input.length > 1) {
    const pairs = [];
    for(var i = 0; i < input.length; i++) {
      // high surrogate
      if(input.charCodeAt(i) >= 0xd800 && input.charCodeAt(i) <= 0xdbff) {
              if(input.charCodeAt(i + 1) >= 0xdc00 && input.charCodeAt(i + 1) <= 0xdfff) {
                  // low surrogate
                  pairs.push(
                      (input.charCodeAt(i) - 0xd800) * 0x400
                    + (input.charCodeAt(i + 1) - 0xdc00) + 0x10000
                  );
              }
          } else if (input.charCodeAt(i) < 0xd800 || input.charCodeAt(i) > 0xdfff) {
              // modifiers and joiners
              pairs.push(input.charCodeAt(i))
          }
    }

    return pairs.join(' ');
  }

  return '';
}; */

// country code regex
const CC_REGEX = /^[a-z]{2}$/i;

// offset between uppercase ascii and regional indicator symbols
const OFFSET = 127397;

/**
 * convert country code to corresponding emoji flag
 * @param {string} cc - country code string
 * @returns {string} country code emoji
 */
export function countryCodeEmoji(cc/* : string */) {
  if(!CC_REGEX.test(cc)) {
    const type = typeof cc;
    throw new TypeError(
      `cc argument must be an ISO 3166-1 alpha-2 string, but got '${
        type === 'string' ? cc : type
      }' instead.`,
    );
  }

  const chars = [...cc.toUpperCase()].map(c => c.charCodeAt(0) + OFFSET);
  //console.log(chars);
  return String.fromCodePoint(...chars);
}

export function unifiedCountryCodeEmoji(cc/* : string */) {
  if(!CC_REGEX.test(cc)) {
    const type = typeof cc;
    throw new TypeError(
      `cc argument must be an ISO 3166-1 alpha-2 string, but got '${
        type === 'string' ? cc : type
      }' instead.`,
    );
  }

  const chars = [...cc.toUpperCase()].map(c => c.charCodeAt(0) + OFFSET);
  return chars.map(c => c.toString(16).toUpperCase()).join('-');
}

function versionCompare (ver1, ver2) {
  if (typeof ver1 !== 'string') {
    ver1 = ''
  }
  if (typeof ver2 !== 'string') {
    ver2 = ''
  }
  ver1 = ver1.replace(/^\s+|\s+$/g, '').split('.')
  ver2 = ver2.replace(/^\s+|\s+$/g, '').split('.')

  var a = Math.max(ver1.length, ver2.length), i

  for (i = 0; i < a; i++) {
    if (ver1[i] == ver2[i]) {
      continue
    }
    if (ver1[i] > ver2[i]) {
      return 1
    } else {
      return -1
    }
  }

  return 0
}


  var badCharsRe = /[`~!@#$%^&*()\-_=+\[\]\\|{}'";:\/?.>,<\s]+/g,
    trimRe = /^\s+|\s$/g

  function createIndex () {
    return {
      shortIndexes: {},
      fullTexts: {}
    }
  }

  function cleanSearchText (text) {
    var hasTag = text.charAt(0) == '%'
    text = text.replace(badCharsRe, ' ').replace(trimRe, '')
    text = text.replace(/[^A-Za-z0-9]/g, function (ch) {
      var latinizeCh = Config.LatinizeMap[ch]
      return latinizeCh !== undefined ? latinizeCh : ch
    })
    text = text.toLowerCase()
    if (hasTag) {
      text = '%' + text
    }

    return text
  }

  function cleanUsername (username) {
    return username && username.toLowerCase() || ''
  }

  function indexObject (id, searchText, searchIndex) {
    if (searchIndex.fullTexts[id] !== undefined) {
      return false
    }

    searchText = cleanSearchText(searchText)

    if (!searchText.length) {
      return false
    }

    var shortIndexes = searchIndex.shortIndexes

    searchIndex.fullTexts[id] = searchText

    searchText.split(' ').forEach(function(searchWord) {
      var len = Math.min(searchWord.length, 3),
        wordPart, i
      for (i = 1; i <= len; i++) {
        wordPart = searchWord.substr(0, i)
        if (shortIndexes[wordPart] === undefined) {
          shortIndexes[wordPart] = [id]
        } else {
          shortIndexes[wordPart].push(id)
        }
      }
    })
  }

  function search (query, searchIndex) {
    var shortIndexes = searchIndex.shortIndexes
    var fullTexts = searchIndex.fullTexts

    query = cleanSearchText(query)

    var queryWords = query.split(' ')
    var foundObjs = false,
      newFoundObjs, i
    var j, searchText
    var found

    for (i = 0; i < queryWords.length; i++) {
      newFoundObjs = shortIndexes[queryWords[i].substr(0, 3)]
      if (!newFoundObjs) {
        foundObjs = []
        break
      }
      if (foundObjs === false || foundObjs.length > newFoundObjs.length) {
        foundObjs = newFoundObjs
      }
    }

    newFoundObjs = {}

    for (j = 0; j < foundObjs.length; j++) {
      found = true
      searchText = fullTexts[foundObjs[j]]
      for (i = 0; i < queryWords.length; i++) {
        if (searchText.indexOf(queryWords[i]) == -1) {
          found = false
          break
        }
      }
      if (found) {
        newFoundObjs[foundObjs[j]] = true
      }
    }

    return newFoundObjs
  }

  let SearchIndexManager = {
    createIndex: createIndex,
    indexObject: indexObject,
    cleanSearchText: cleanSearchText,
    cleanUsername: cleanUsername,
    search: search
  };
  window.SearchIndexManager = SearchIndexManager;

  export {SearchIndexManager};
//})(window)