|
|
|
/*!
|
|
|
|
* Webogram v0.5.3 - 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
|
|
|
|
*/
|
|
|
|
|
|
|
|
angular.module('izhukov.utils', [])
|
|
|
|
|
|
|
|
.provider('Storage', function () {
|
|
|
|
|
|
|
|
this.setPrefix = function (newPrefix) {
|
|
|
|
ConfigStorage.prefix(newPrefix);
|
|
|
|
};
|
|
|
|
|
|
|
|
this.$get = ['$q', function ($q) {
|
|
|
|
var methods = {};
|
|
|
|
angular.forEach(['get', 'set', 'remove'], function (methodName) {
|
|
|
|
methods[methodName] = function () {
|
|
|
|
var deferred = $q.defer(),
|
|
|
|
args = Array.prototype.slice.call(arguments);
|
|
|
|
|
|
|
|
args.push(function (result) {
|
|
|
|
deferred.resolve(result);
|
|
|
|
});
|
|
|
|
ConfigStorage[methodName].apply(ConfigStorage, args);
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
};
|
|
|
|
});
|
|
|
|
return methods;
|
|
|
|
}];
|
|
|
|
|
|
|
|
})
|
|
|
|
|
|
|
|
.service('qSync', function () {
|
|
|
|
|
|
|
|
return {
|
|
|
|
when: function (result) {
|
|
|
|
return {then: function (cb) {
|
|
|
|
return cb(result);
|
|
|
|
}};
|
|
|
|
},
|
|
|
|
reject: function (result) {
|
|
|
|
return {then: function (cb, badcb) {
|
|
|
|
if (badcb) {
|
|
|
|
return badcb(result);
|
|
|
|
}
|
|
|
|
}};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
})
|
|
|
|
|
|
|
|
.service('FileManager', function ($window, $q, $timeout, qSync) {
|
|
|
|
|
|
|
|
$window.URL = $window.URL || $window.webkitURL;
|
|
|
|
$window.BlobBuilder = $window.BlobBuilder || $window.WebKitBlobBuilder || $window.MozBlobBuilder;
|
|
|
|
var buggyUnknownBlob = navigator.userAgent.indexOf('Safari') != -1 &&
|
|
|
|
navigator.userAgent.indexOf('Chrome') == -1;
|
|
|
|
|
|
|
|
var blobSupported = true;
|
|
|
|
|
|
|
|
try {
|
|
|
|
blobConstruct([], '');
|
|
|
|
} catch (e) {
|
|
|
|
blobSupported = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
function isBlobAvailable () {
|
|
|
|
return blobSupported;
|
|
|
|
}
|
|
|
|
|
|
|
|
function fileCopyTo (fromFileEntry, toFileEntry) {
|
|
|
|
return getFileWriter(toFileEntry).then(function (fileWriter) {
|
|
|
|
return fileWriteData(fileWriter, fromFileEntry).then(function () {
|
|
|
|
return fileWriter;
|
|
|
|
}, function (error) {
|
|
|
|
return $q.reject(error);
|
|
|
|
fileWriter.truncate(0);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
function fileWriteData(fileWriter, bytes) {
|
|
|
|
var deferred = $q.defer();
|
|
|
|
|
|
|
|
fileWriter.onwriteend = function(e) {
|
|
|
|
deferred.resolve();
|
|
|
|
};
|
|
|
|
fileWriter.onerror = function (e) {
|
|
|
|
deferred.reject(e);
|
|
|
|
};
|
|
|
|
|
|
|
|
if (bytes.file) {
|
|
|
|
bytes.file(function (file) {
|
|
|
|
fileWriter.write(file);
|
|
|
|
}, function (error) {
|
|
|
|
deferred.reject(error);
|
|
|
|
})
|
|
|
|
}
|
|
|
|
else if (bytes instanceof Blob) { // is file bytes
|
|
|
|
fileWriter.write(bytes);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
try {
|
|
|
|
var blob = blobConstruct([bytesToArrayBuffer(bytes)]);
|
|
|
|
fileWriter.write(blob);
|
|
|
|
} catch (e) {
|
|
|
|
deferred.reject(e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
|
|
|
|
function chooseSaveFile (fileName, ext, mimeType) {
|
|
|
|
if (!$window.chrome || !chrome.fileSystem || !chrome.fileSystem.chooseEntry) {
|
|
|
|
return qSync.reject();
|
|
|
|
};
|
|
|
|
var deferred = $q.defer();
|
|
|
|
|
|
|
|
chrome.fileSystem.chooseEntry({
|
|
|
|
type: 'saveFile',
|
|
|
|
suggestedName: fileName,
|
|
|
|
accepts: [{
|
|
|
|
mimeTypes: [mimeType],
|
|
|
|
extensions: [ext]
|
|
|
|
}]
|
|
|
|
}, function (writableFileEntry) {
|
|
|
|
deferred.resolve(writableFileEntry);
|
|
|
|
});
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getFileWriter (fileEntry) {
|
|
|
|
var deferred = $q.defer();
|
|
|
|
|
|
|
|
fileEntry.createWriter(function (fileWriter) {
|
|
|
|
deferred.resolve(fileWriter);
|
|
|
|
}, function (error) {
|
|
|
|
deferred.reject(error);
|
|
|
|
});
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getFakeFileWriter (mimeType, saveFileCallback) {
|
|
|
|
var blobParts = [],
|
|
|
|
fakeFileWriter = {
|
|
|
|
write: function (blob) {
|
|
|
|
if (!blobSupported) {
|
|
|
|
if (fakeFileWriter.onerror) {
|
|
|
|
fakeFileWriter.onerror(new Error('Blob not supported by browser'));
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
blobParts.push(blob);
|
|
|
|
setZeroTimeout(function () {
|
|
|
|
if (fakeFileWriter.onwriteend) {
|
|
|
|
fakeFileWriter.onwriteend();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
},
|
|
|
|
truncate: function () {
|
|
|
|
blobParts = [];
|
|
|
|
},
|
|
|
|
finalize: function () {
|
|
|
|
var blob = blobConstruct(blobParts, mimeType);
|
|
|
|
if (saveFileCallback) {
|
|
|
|
saveFileCallback(blob);
|
|
|
|
}
|
|
|
|
return blob;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
return fakeFileWriter;
|
|
|
|
};
|
|
|
|
|
|
|
|
function getUrl (fileData, mimeType) {
|
|
|
|
// console.log(dT(), 'get url', fileData, mimeType, fileData.toURL !== undefined, fileData instanceof Blob);
|
|
|
|
if (fileData.toURL !== undefined) {
|
|
|
|
return fileData.toURL(mimeType);
|
|
|
|
}
|
|
|
|
if (fileData instanceof Blob) {
|
|
|
|
return URL.createObjectURL(fileData);
|
|
|
|
}
|
|
|
|
return 'data:' + mimeType + ';base64,' + bytesToBase64(fileData);
|
|
|
|
}
|
|
|
|
|
|
|
|
function getByteArray(fileData) {
|
|
|
|
if (fileData instanceof Blob) {
|
|
|
|
var deferred = $q.defer();
|
|
|
|
try {
|
|
|
|
var reader = new FileReader();
|
|
|
|
reader.onloadend = function (e) {
|
|
|
|
deferred.resolve(new Uint8Array(e.target.result));
|
|
|
|
};
|
|
|
|
reader.onerror = function (e) {
|
|
|
|
deferred.reject(e);
|
|
|
|
};
|
|
|
|
reader.readAsArrayBuffer(fileData);
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
} catch (e) {
|
|
|
|
return $q.reject(e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (fileData.file) {
|
|
|
|
var deferred = $q.defer();
|
|
|
|
fileData.file(function (blob) {
|
|
|
|
getByteArray(blob).then(function (result) {
|
|
|
|
deferred.resolve(result);
|
|
|
|
}, function (error) {
|
|
|
|
deferred.reject(error);
|
|
|
|
})
|
|
|
|
}, function (error) {
|
|
|
|
deferred.reject(error);
|
|
|
|
});
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
return $q.when(fileData);
|
|
|
|
}
|
|
|
|
|
|
|
|
function getDataUrl(blob) {
|
|
|
|
var deferred;
|
|
|
|
try {
|
|
|
|
var reader = new FileReader();
|
|
|
|
reader.onloadend = function() {
|
|
|
|
deferred.resolve(reader.result);
|
|
|
|
}
|
|
|
|
reader.readAsDataURL(blob);
|
|
|
|
} catch (e) {
|
|
|
|
return $q.reject(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
deferred = $q.defer();
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getFileCorrectUrl(blob, mimeType) {
|
|
|
|
if (buggyUnknownBlob && blob instanceof Blob) {
|
|
|
|
var mimeType = blob.type || blob.mimeType || mimeType || '';
|
|
|
|
if (!mimeType.match(/image\/(jpeg|gif|png|bmp)|video\/quicktime/)) {
|
|
|
|
return getDataUrl(blob);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return qSync.when(getUrl(blob, mimeType));
|
|
|
|
}
|
|
|
|
|
|
|
|
function downloadFile (blob, mimeType, fileName) {
|
|
|
|
if (window.navigator && navigator.msSaveBlob !== undefined) {
|
|
|
|
window.navigator.msSaveBlob(blob, fileName);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (window.navigator && navigator.getDeviceStorage) {
|
|
|
|
var storageName = 'sdcard';
|
|
|
|
var subdir = 'telegram/';
|
|
|
|
switch (mimeType.split('/')[0]) {
|
|
|
|
case 'video': storageName = 'videos'; break;
|
|
|
|
case 'audio': storageName = 'music'; break;
|
|
|
|
case 'image': storageName = 'pictures'; break;
|
|
|
|
}
|
|
|
|
var deviceStorage = navigator.getDeviceStorage(storageName);
|
|
|
|
|
|
|
|
var request = deviceStorage.addNamed(blob, subdir + fileName);
|
|
|
|
|
|
|
|
request.onsuccess = function () {
|
|
|
|
console.log('Device storage save result', this.result);
|
|
|
|
};
|
|
|
|
request.onerror = function () {
|
|
|
|
};
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
var popup = false;
|
|
|
|
if (window.safari) {
|
|
|
|
popup = window.open();
|
|
|
|
}
|
|
|
|
|
|
|
|
getFileCorrectUrl(blob, mimeType).then(function (url) {
|
|
|
|
if (popup) {
|
|
|
|
try {
|
|
|
|
popup.location.href = url;
|
|
|
|
return;
|
|
|
|
} catch (e) {}
|
|
|
|
}
|
|
|
|
var anchor = document.createElementNS('http://www.w3.org/1999/xhtml', 'a');
|
|
|
|
anchor.href = url;
|
|
|
|
anchor.target = '_blank';
|
|
|
|
anchor.download = fileName;
|
|
|
|
if (anchor.dataset) {
|
|
|
|
anchor.dataset.downloadurl = ["video/quicktime", fileName, url].join(':');
|
|
|
|
}
|
|
|
|
$(anchor).css({position: 'absolute', top: 1, left: 1}).appendTo('body');
|
|
|
|
|
|
|
|
try {
|
|
|
|
var clickEvent = document.createEvent('MouseEvents');
|
|
|
|
clickEvent.initMouseEvent(
|
|
|
|
'click', true, false, window, 0, 0, 0, 0, 0
|
|
|
|
, false, false, false, false, 0, null
|
|
|
|
);
|
|
|
|
anchor.dispatchEvent(clickEvent);
|
|
|
|
} catch (e) {
|
|
|
|
console.error('Download click error', e);
|
|
|
|
try {
|
|
|
|
anchor[0].click();
|
|
|
|
} catch (e) {
|
|
|
|
window.open(url, '_blank');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
$timeout(function () {
|
|
|
|
$(anchor).remove();
|
|
|
|
}, 100);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return {
|
|
|
|
isAvailable: isBlobAvailable,
|
|
|
|
copy: fileCopyTo,
|
|
|
|
write: fileWriteData,
|
|
|
|
getFileWriter: getFileWriter,
|
|
|
|
getFakeFileWriter: getFakeFileWriter,
|
|
|
|
chooseSave: chooseSaveFile,
|
|
|
|
getUrl: getUrl,
|
|
|
|
getDataUrl: getDataUrl,
|
|
|
|
getByteArray: getByteArray,
|
|
|
|
getFileCorrectUrl: getFileCorrectUrl,
|
|
|
|
download: downloadFile
|
|
|
|
};
|
|
|
|
})
|
|
|
|
|
|
|
|
.service('IdbFileStorage', function ($q, $window, FileManager) {
|
|
|
|
|
|
|
|
$window.indexedDB = $window.indexedDB || $window.webkitIndexedDB || $window.mozIndexedDB || $window.OIndexedDB || $window.msIndexedDB;
|
|
|
|
$window.IDBTransaction = $window.IDBTransaction || $window.webkitIDBTransaction || $window.OIDBTransaction || $window.msIDBTransaction;
|
|
|
|
|
|
|
|
var dbName = 'cachedFiles';
|
|
|
|
var dbStoreName = 'files';
|
|
|
|
var dbVersion = 2;
|
|
|
|
var openDbPromise;
|
|
|
|
var storageIsAvailable = $window.indexedDB !== undefined &&
|
|
|
|
$window.IDBTransaction !== undefined;
|
|
|
|
|
|
|
|
// IndexedDB is REALLY slow without blob support in Safari 8, no point in it
|
|
|
|
if (storageIsAvailable &&
|
|
|
|
navigator.userAgent.indexOf('Safari') != -1 &&
|
|
|
|
navigator.userAgent.indexOf('Chrome') == -1 &&
|
|
|
|
navigator.userAgent.match(/Version\/[678]/)
|
|
|
|
) {
|
|
|
|
storageIsAvailable = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
var storeBlobsAvailable = storageIsAvailable || false;
|
|
|
|
|
|
|
|
function isAvailable () {
|
|
|
|
return storageIsAvailable;
|
|
|
|
}
|
|
|
|
|
|
|
|
function openDatabase() {
|
|
|
|
if (openDbPromise) {
|
|
|
|
return openDbPromise;
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
|
|
|
var request = indexedDB.open(dbName, dbVersion),
|
|
|
|
deferred = $q.defer(),
|
|
|
|
createObjectStore = function (db) {
|
|
|
|
db.createObjectStore(dbStoreName);
|
|
|
|
};
|
|
|
|
if (!request) {
|
|
|
|
throw new Exception();
|
|
|
|
}
|
|
|
|
} catch (error) {
|
|
|
|
console.error('error opening db', error.message);
|
|
|
|
storageIsAvailable = false;
|
|
|
|
return $q.reject(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
var finished = false;
|
|
|
|
setTimeout(function () {
|
|
|
|
if (!finished) {
|
|
|
|
request.onerror({type: 'IDB_CREATE_TIMEOUT'});
|
|
|
|
}
|
|
|
|
}, 3000);
|
|
|
|
|
|
|
|
request.onsuccess = function (event) {
|
|
|
|
finished = true;
|
|
|
|
db = request.result;
|
|
|
|
|
|
|
|
db.onerror = function (error) {
|
|
|
|
storageIsAvailable = false;
|
|
|
|
console.error('Error creating/accessing IndexedDB database', error);
|
|
|
|
deferred.reject(error);
|
|
|
|
};
|
|
|
|
|
|
|
|
deferred.resolve(db);
|
|
|
|
};
|
|
|
|
|
|
|
|
request.onerror = function (event) {
|
|
|
|
finished = true;
|
|
|
|
storageIsAvailable = false;
|
|
|
|
console.error('Error creating/accessing IndexedDB database', event);
|
|
|
|
deferred.reject(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
request.onupgradeneeded = function (event) {
|
|
|
|
finished = true;
|
|
|
|
console.warn('performing idb upgrade from', event.oldVersion, 'to', event.newVersion);
|
|
|
|
var db = event.target.result;
|
|
|
|
if (event.oldVersion == 1) {
|
|
|
|
db.deleteObjectStore(dbStoreName);
|
|
|
|
}
|
|
|
|
createObjectStore(db);
|
|
|
|
};
|
|
|
|
|
|
|
|
return openDbPromise = deferred.promise;
|
|
|
|
};
|
|
|
|
|
|
|
|
function saveFile (fileName, blob) {
|
|
|
|
return openDatabase().then(function (db) {
|
|
|
|
if (!storeBlobsAvailable) {
|
|
|
|
return saveFileBase64(db, fileName, blob);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(blob instanceof Blob)) {
|
|
|
|
blob = blobConstruct([blob]);
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
|
|
|
var objectStore = db.transaction([dbStoreName], IDBTransaction.READ_WRITE || 'readwrite').objectStore(dbStoreName),
|
|
|
|
request = objectStore.put(blob, fileName);
|
|
|
|
} catch (error) {
|
|
|
|
if (storeBlobsAvailable) {
|
|
|
|
storeBlobsAvailable = false;
|
|
|
|
return saveFileBase64(db, fileName, blob);
|
|
|
|
}
|
|
|
|
storageIsAvailable = false;
|
|
|
|
return $q.reject(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
var deferred = $q.defer();
|
|
|
|
|
|
|
|
request.onsuccess = function (event) {
|
|
|
|
deferred.resolve(blob);
|
|
|
|
};
|
|
|
|
|
|
|
|
request.onerror = function (error) {
|
|
|
|
deferred.reject(error);
|
|
|
|
};
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
function saveFileBase64(db, fileName, blob) {
|
|
|
|
if (getBlobSize(blob) > 10 * 1024 * 1024) {
|
|
|
|
return $q.reject();
|
|
|
|
}
|
|
|
|
if (!(blob instanceof Blob)) {
|
|
|
|
var mimeType = blob.type || 'image/jpeg';
|
|
|
|
var address = 'data:' + mimeType + ';base64,' + bytesToBase64(blob);
|
|
|
|
return storagePutB64String(db, fileName, address).then(function () {
|
|
|
|
return blob;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
|
|
|
var reader = new FileReader();
|
|
|
|
} catch (e) {
|
|
|
|
storageIsAvailable = false;
|
|
|
|
return $q.reject();
|
|
|
|
}
|
|
|
|
|
|
|
|
var deferred = $q.defer();
|
|
|
|
|
|
|
|
reader.onloadend = function() {
|
|
|
|
storagePutB64String(db, fileName, reader.result).then(function () {
|
|
|
|
deferred.resolve(blob);
|
|
|
|
}, function (error) {
|
|
|
|
deferred.reject(error);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
reader.onerror = function (error) {
|
|
|
|
deferred.reject(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
|
|
|
reader.readAsDataURL(blob);
|
|
|
|
} catch (e) {
|
|
|
|
storageIsAvailable = false;
|
|
|
|
return $q.reject();
|
|
|
|
}
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
|
|
|
|
function storagePutB64String (db, fileName, b64string) {
|
|
|
|
try {
|
|
|
|
var objectStore = db.transaction([dbStoreName], IDBTransaction.READ_WRITE || 'readwrite').objectStore(dbStoreName),
|
|
|
|
request = objectStore.put(b64string, fileName);
|
|
|
|
} catch (error) {
|
|
|
|
storageIsAvailable = false;
|
|
|
|
return $q.reject(error);
|
|
|
|
};
|
|
|
|
|
|
|
|
var deferred = $q.defer();
|
|
|
|
|
|
|
|
request.onsuccess = function (event) {
|
|
|
|
deferred.resolve();
|
|
|
|
};
|
|
|
|
|
|
|
|
request.onerror = function (error) {
|
|
|
|
deferred.reject(error);
|
|
|
|
};
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getBlobSize (blob) {
|
|
|
|
return blob.size || blob.byteLength || blob.length;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getFile (fileName) {
|
|
|
|
return openDatabase().then(function (db) {
|
|
|
|
var deferred = $q.defer(),
|
|
|
|
objectStore = db.transaction([dbStoreName], IDBTransaction.READ || 'readonly').objectStore(dbStoreName),
|
|
|
|
request = objectStore.get(fileName);
|
|
|
|
|
|
|
|
request.onsuccess = function (event) {
|
|
|
|
var result = event.target.result;
|
|
|
|
if (result === undefined) {
|
|
|
|
deferred.reject();
|
|
|
|
} else if (typeof result === 'string' &&
|
|
|
|
result.substr(0, 5) === 'data:') {
|
|
|
|
deferred.resolve(dataUrlToBlob(result));
|
|
|
|
} else {
|
|
|
|
deferred.resolve(result);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
request.onerror = function (error) {
|
|
|
|
deferred.reject(error);
|
|
|
|
};
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
function getFileWriter (fileName, mimeType) {
|
|
|
|
var fakeWriter = FileManager.getFakeFileWriter(mimeType, function (blob) {
|
|
|
|
saveFile(fileName, blob);
|
|
|
|
});
|
|
|
|
return $q.when(fakeWriter);
|
|
|
|
}
|
|
|
|
|
|
|
|
openDatabase();
|
|
|
|
|
|
|
|
return {
|
|
|
|
name: 'IndexedDB',
|
|
|
|
isAvailable: isAvailable,
|
|
|
|
saveFile: saveFile,
|
|
|
|
getFile: getFile,
|
|
|
|
getFileWriter: getFileWriter
|
|
|
|
};
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
|
|
.service('TmpfsFileStorage', function ($q, $window, FileManager) {
|
|
|
|
|
|
|
|
$window.requestFileSystem = $window.requestFileSystem || $window.webkitRequestFileSystem;
|
|
|
|
|
|
|
|
var reqFsPromise,
|
|
|
|
fileSystem,
|
|
|
|
storageIsAvailable = $window.requestFileSystem !== undefined;
|
|
|
|
|
|
|
|
function requestFS () {
|
|
|
|
if (reqFsPromise) {
|
|
|
|
return reqFsPromise;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!$window.requestFileSystem) {
|
|
|
|
return reqFsPromise = $q.reject({type: 'FS_BROWSER_UNSUPPORTED', description: 'requestFileSystem not present'});
|
|
|
|
}
|
|
|
|
|
|
|
|
var deferred = $q.defer();
|
|
|
|
|
|
|
|
$window.requestFileSystem($window.TEMPORARY, 500 * 1024 * 1024, function (fs) {
|
|
|
|
cachedFs = fs;
|
|
|
|
deferred.resolve();
|
|
|
|
}, function (e) {
|
|
|
|
storageIsAvailable = false;
|
|
|
|
deferred.reject(e);
|
|
|
|
});
|
|
|
|
|
|
|
|
return reqFsPromise = deferred.promise;
|
|
|
|
};
|
|
|
|
|
|
|
|
function isAvailable () {
|
|
|
|
return storageIsAvailable;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getFile (fileName, size) {
|
|
|
|
size = size || 1;
|
|
|
|
return requestFS().then(function () {
|
|
|
|
// console.log(dT(), 'get file', fileName);
|
|
|
|
var deferred = $q.defer();
|
|
|
|
cachedFs.root.getFile(fileName, {create: false}, function(fileEntry) {
|
|
|
|
fileEntry.file(function(file) {
|
|
|
|
// console.log(dT(), 'aa', file);
|
|
|
|
if (file.size >= size) {
|
|
|
|
deferred.resolve(fileEntry);
|
|
|
|
} else {
|
|
|
|
deferred.reject(new Error('FILE_NOT_FOUND'));
|
|
|
|
}
|
|
|
|
}, function (error) {
|
|
|
|
console.log(dT(), 'error', error);
|
|
|
|
deferred.reject(error);
|
|
|
|
});
|
|
|
|
}, function () {
|
|
|
|
deferred.reject(new Error('FILE_NOT_FOUND'));
|
|
|
|
});
|
|
|
|
return deferred.promise;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
function saveFile (fileName, blob) {
|
|
|
|
return getFileWriter(fileName).then(function (fileWriter) {
|
|
|
|
return FileManager.write(fileWriter, blob).then(function () {
|
|
|
|
return fileWriter.finalize();
|
|
|
|
})
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
function getFileWriter (fileName) {
|
|
|
|
// console.log(dT(), 'get file writer', fileName);
|
|
|
|
return requestFS().then(function () {
|
|
|
|
var deferred = $q.defer();
|
|
|
|
cachedFs.root.getFile(fileName, {create: true}, function (fileEntry) {
|
|
|
|
FileManager.getFileWriter(fileEntry).then(function (fileWriter) {
|
|
|
|
fileWriter.finalize = function () {
|
|
|
|
return fileEntry;
|
|
|
|
}
|
|
|
|
deferred.resolve(fileWriter);
|
|
|
|
}, function (error) {
|
|
|
|
storageIsAvailable = false;
|
|
|
|
deferred.reject(error);
|
|
|
|
});
|
|
|
|
}, function (error) {
|
|
|
|
storageIsAvailable = false;
|
|
|
|
deferred.reject(error);
|
|
|
|
});
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
requestFS();
|
|
|
|
|
|
|
|
return {
|
|
|
|
name: 'TmpFS',
|
|
|
|
isAvailable: isAvailable,
|
|
|
|
saveFile: saveFile,
|
|
|
|
getFile: getFile,
|
|
|
|
getFileWriter: getFileWriter
|
|
|
|
};
|
|
|
|
})
|
|
|
|
|
|
|
|
.service('MemoryFileStorage', function ($q, FileManager) {
|
|
|
|
|
|
|
|
var storage = {};
|
|
|
|
|
|
|
|
function isAvailable () {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getFile (fileName, size) {
|
|
|
|
if (storage[fileName]) {
|
|
|
|
return $q.when(storage[fileName]);
|
|
|
|
}
|
|
|
|
return $q.reject(new Error('FILE_NOT_FOUND'));
|
|
|
|
}
|
|
|
|
|
|
|
|
function saveFile (fileName, blob) {
|
|
|
|
return $q.when(storage[fileName] = blob);
|
|
|
|
}
|
|
|
|
|
|
|
|
function getFileWriter (fileName, mimeType) {
|
|
|
|
var fakeWriter = FileManager.getFakeFileWriter(mimeType, function (blob) {
|
|
|
|
saveFile(fileName, blob);
|
|
|
|
});
|
|
|
|
return $q.when(fakeWriter);
|
|
|
|
}
|
|
|
|
|
|
|
|
return {
|
|
|
|
name: 'Memory',
|
|
|
|
isAvailable: isAvailable,
|
|
|
|
saveFile: saveFile,
|
|
|
|
getFile: getFile,
|
|
|
|
getFileWriter: getFileWriter
|
|
|
|
};
|
|
|
|
})
|
|
|
|
|
|
|
|
.service('WebpManager', function (qSync, $q) {
|
|
|
|
var nativeWebpSupport = false;
|
|
|
|
|
|
|
|
var image = new Image();
|
|
|
|
image.onload = function () {
|
|
|
|
nativeWebpSupport = this.width === 2 && this.height === 1;
|
|
|
|
};
|
|
|
|
image.onerror = function () {
|
|
|
|
nativeWebpSupport = false;
|
|
|
|
};
|
|
|
|
image.src = 'data:image/webp;base64,UklGRjIAAABXRUJQVlA4ICYAAACyAgCdASoCAAEALmk0mk0iIiIiIgBoSygABc6zbAAA/v56QAAAAA==';
|
|
|
|
|
|
|
|
var canvas, context;
|
|
|
|
|
|
|
|
function getCanvasFromWebp(data) {
|
|
|
|
var start = tsNow();
|
|
|
|
|
|
|
|
var decoder = new WebPDecoder();
|
|
|
|
|
|
|
|
var config = decoder.WebPDecoderConfig;
|
|
|
|
var buffer = config.j || config.output;
|
|
|
|
var bitstream = config.input;
|
|
|
|
|
|
|
|
if (!decoder.WebPInitDecoderConfig(config)) {
|
|
|
|
console.error('[webpjs] Library version mismatch!');
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// console.log('[webpjs] status code', decoder.VP8StatusCode);
|
|
|
|
var StatusCode = decoder.VP8StatusCode;
|
|
|
|
|
|
|
|
status = decoder.WebPGetFeatures(data, data.length, bitstream);
|
|
|
|
if (status != (StatusCode.VP8_STATUS_OK || 0)) {
|
|
|
|
console.error('[webpjs] status error', status, StatusCode);
|
|
|
|
}
|
|
|
|
|
|
|
|
var mode = decoder.WEBP_CSP_MODE;
|
|
|
|
buffer.colorspace = mode.MODE_RGBA;
|
|
|
|
buffer.J = 4;
|
|
|
|
|
|
|
|
try {
|
|
|
|
status = decoder.WebPDecode(data, data.length, config);
|
|
|
|
} catch (e) {
|
|
|
|
status = e;
|
|
|
|
}
|
|
|
|
|
|
|
|
ok = (status == 0);
|
|
|
|
if (!ok) {
|
|
|
|
console.error('[webpjs] decoding failed', status, StatusCode);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// console.log('[webpjs] decoded: ', buffer.width, buffer.height, bitstream.has_alpha, 'Now saving...');
|
|
|
|
var bitmap = buffer.c.RGBA.ma;
|
|
|
|
|
|
|
|
// console.log('[webpjs] done in ', tsNow() - start);
|
|
|
|
|
|
|
|
if (!bitmap) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
var biHeight = buffer.height;
|
|
|
|
var biWidth = buffer.width;
|
|
|
|
|
|
|
|
if (!canvas || !context) {
|
|
|
|
canvas = document.createElement('canvas');
|
|
|
|
context = canvas.getContext('2d');
|
|
|
|
} else {
|
|
|
|
context.clearRect(0, 0, canvas.width, canvas.height);
|
|
|
|
}
|
|
|
|
canvas.height = biHeight;
|
|
|
|
canvas.width = biWidth;
|
|
|
|
|
|
|
|
var output = context.createImageData(canvas.width, canvas.height);
|
|
|
|
var outputData = output.data;
|
|
|
|
|
|
|
|
for (var h = 0; h < biHeight; h++) {
|
|
|
|
for (var w = 0; w < biWidth; w++) {
|
|
|
|
outputData[0+w*4+(biWidth*4)*h] = bitmap[1+w*4+(biWidth*4)*h];
|
|
|
|
outputData[1+w*4+(biWidth*4)*h] = bitmap[2+w*4+(biWidth*4)*h];
|
|
|
|
outputData[2+w*4+(biWidth*4)*h] = bitmap[3+w*4+(biWidth*4)*h];
|
|
|
|
outputData[3+w*4+(biWidth*4)*h] = bitmap[0+w*4+(biWidth*4)*h];
|
|
|
|
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
context.putImageData(output, 0, 0);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getPngBlobFromWebp (data) {
|
|
|
|
if (!getCanvasFromWebp(data)) {
|
|
|
|
return $q.reject({type: 'WEBP_PROCESS_FAILED'});
|
|
|
|
}
|
|
|
|
if (canvas.toBlob === undefined) {
|
|
|
|
return qSync.when(dataUrlToBlob(canvas.toDataURL('image/png')));
|
|
|
|
}
|
|
|
|
|
|
|
|
var deferred = $q.defer();
|
|
|
|
canvas.toBlob(function (blob) {
|
|
|
|
deferred.resolve(blob);
|
|
|
|
}, 'image/png');
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
|
|
|
|
return {
|
|
|
|
isWebpSupported: function () {
|
|
|
|
return nativeWebpSupport;
|
|
|
|
},
|
|
|
|
getPngBlobFromWebp: getPngBlobFromWebp
|
|
|
|
}
|
|
|
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
|
|
.service('CryptoWorker', function ($timeout, $q) {
|
|
|
|
|
|
|
|
var webWorker = false,
|
|
|
|
naClEmbed = false,
|
|
|
|
taskID = 0,
|
|
|
|
awaiting = {},
|
|
|
|
webCrypto = Config.Modes.webcrypto && window.crypto && (window.crypto.subtle || window.crypto.webkitSubtle)/* || window.msCrypto && window.msCrypto.subtle*/,
|
|
|
|
useSha1Crypto = webCrypto && webCrypto.digest !== undefined,
|
|
|
|
useSha256Crypto = webCrypto && webCrypto.digest !== undefined,
|
|
|
|
finalizeTask = function (taskID, result) {
|
|
|
|
var deferred = awaiting[taskID];
|
|
|
|
if (deferred !== undefined) {
|
|
|
|
// console.log(dT(), 'CW done');
|
|
|
|
deferred.resolve(result);
|
|
|
|
delete awaiting[taskID];
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
if (Config.Modes.nacl &&
|
|
|
|
navigator.mimeTypes &&
|
|
|
|
navigator.mimeTypes['application/x-pnacl'] !== undefined) {
|
|
|
|
var listener = $('<div id="nacl_listener"><embed id="mtproto_crypto" width="0" height="0" src="nacl/mtproto_crypto.nmf" type="application/x-pnacl" /></div>').appendTo($('body'))[0];
|
|
|
|
listener.addEventListener('load', function (e) {
|
|
|
|
naClEmbed = listener.firstChild;
|
|
|
|
console.log(dT(), 'NaCl ready');
|
|
|
|
}, true);
|
|
|
|
listener.addEventListener('message', function (e) {
|
|
|
|
finalizeTask(e.data.taskID, e.data.result);
|
|
|
|
}, true);
|
|
|
|
listener.addEventListener('error', function (e) {
|
|
|
|
console.error('NaCl error', e);
|
|
|
|
}, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (window.Worker) {
|
|
|
|
var tmpWorker = new Worker('js/lib/crypto_worker.js');
|
|
|
|
tmpWorker.onmessage = function (e) {
|
|
|
|
if (!webWorker) {
|
|
|
|
webWorker = tmpWorker;
|
|
|
|
} else {
|
|
|
|
finalizeTask(e.data.taskID, e.data.result);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
tmpWorker.onerror = function(error) {
|
|
|
|
console.error('CW error', error, error.stack);
|
|
|
|
webWorker = false;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
function performTaskWorker (task, params, embed) {
|
|
|
|
// console.log(dT(), 'CW start', task);
|
|
|
|
var deferred = $q.defer();
|
|
|
|
|
|
|
|
awaiting[taskID] = deferred;
|
|
|
|
|
|
|
|
params.task = task;
|
|
|
|
params.taskID = taskID;
|
|
|
|
(embed || webWorker).postMessage(params);
|
|
|
|
|
|
|
|
taskID++;
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
|
|
|
|
return {
|
|
|
|
sha1Hash: function (bytes) {
|
|
|
|
if (useSha1Crypto) {
|
|
|
|
// We don't use buffer since typedArray.subarray(...).buffer gives the whole buffer and not sliced one. webCrypto.digest supports typed array
|
|
|
|
var deferred = $q.defer(),
|
|
|
|
bytesTyped = Array.isArray(bytes) ? convertToUint8Array(bytes) : bytes;
|
|
|
|
// console.log(dT(), 'Native sha1 start');
|
|
|
|
webCrypto.digest({name: 'SHA-1'}, bytesTyped).then(function (digest) {
|
|
|
|
// console.log(dT(), 'Native sha1 done');
|
|
|
|
deferred.resolve(digest);
|
|
|
|
}, function (e) {
|
|
|
|
console.error('Crypto digest error', e);
|
|
|
|
useSha1Crypto = false;
|
|
|
|
deferred.resolve(sha1HashSync(bytes));
|
|
|
|
});
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
return $timeout(function () {
|
|
|
|
return sha1HashSync(bytes);
|
|
|
|
});
|
|
|
|
},
|
|
|
|
sha256Hash: function (bytes) {
|
|
|
|
if (useSha256Crypto) {
|
|
|
|
var deferred = $q.defer(),
|
|
|
|
bytesTyped = Array.isArray(bytes) ? convertToUint8Array(bytes) : bytes;
|
|
|
|
// console.log(dT(), 'Native sha1 start');
|
|
|
|
webCrypto.digest({name: 'SHA-256'}, bytesTyped).then(function (digest) {
|
|
|
|
// console.log(dT(), 'Native sha1 done');
|
|
|
|
deferred.resolve(digest);
|
|
|
|
}, function (e) {
|
|
|
|
console.error('Crypto digest error', e);
|
|
|
|
useSha256Crypto = false;
|
|
|
|
deferred.resolve(sha256HashSync(bytes));
|
|
|
|
});
|
|
|
|
|
|
|
|
return deferred.promise;
|
|
|
|
}
|
|
|
|
return $timeout(function () {
|
|
|
|
return sha256HashSync(bytes);
|
|
|
|
});
|
|
|
|
},
|
|
|
|
aesEncrypt: function (bytes, keyBytes, ivBytes) {
|
|
|
|
if (naClEmbed) {
|
|
|
|
return performTaskWorker('aes-encrypt', {
|
|
|
|
bytes: addPadding(convertToArrayBuffer(bytes)),
|
|
|
|
keyBytes: convertToArrayBuffer(keyBytes),
|
|
|
|
ivBytes: convertToArrayBuffer(ivBytes)
|
|
|
|
}, naClEmbed);
|
|
|
|
}
|
|
|
|
return $timeout(function () {
|
|
|
|
return convertToArrayBuffer(aesEncryptSync(bytes, keyBytes, ivBytes));
|
|
|
|
});
|
|
|
|
},
|
|
|
|
aesDecrypt: function (encryptedBytes, keyBytes, ivBytes) {
|
|
|
|
if (naClEmbed) {
|
|
|
|
return performTaskWorker('aes-decrypt', {
|
|
|
|
encryptedBytes: addPadding(convertToArrayBuffer(encryptedBytes)),
|
|
|
|
keyBytes: convertToArrayBuffer(keyBytes),
|
|
|
|
ivBytes: convertToArrayBuffer(ivBytes)
|
|
|
|
}, naClEmbed);
|
|
|
|
}
|
|
|
|
return $timeout(function () {
|
|
|
|
return convertToArrayBuffer(aesDecryptSync(encryptedBytes, keyBytes, ivBytes));
|
|
|
|
});
|
|
|
|
},
|
|
|
|
factorize: function (bytes) {
|
|
|
|
bytes = convertToByteArray(bytes);
|
|
|
|
if (naClEmbed && bytes.length <= 8) {
|
|
|
|
return performTaskWorker('factorize', {bytes: bytes}, naClEmbed);
|
|
|
|
}
|
|
|
|
if (webWorker) {
|
|
|
|
return performTaskWorker('factorize', {bytes: bytes});
|
|
|
|
}
|
|
|
|
return $timeout(function () {
|
|
|
|
return pqPrimeFactorization(bytes);
|
|
|
|
});
|
|
|
|
},
|
|
|
|
modPow: function (x, y, m) {
|
|
|
|
if (webWorker) {
|
|
|
|
return performTaskWorker('mod-pow', {
|
|
|
|
x: x,
|
|
|
|
y: y,
|
|
|
|
m: m
|
|
|
|
});
|
|
|
|
}
|
|
|
|
return $timeout(function () {
|
|
|
|
return bytesModPow(x, y, m);
|
|
|
|
});
|
|
|
|
},
|
|
|
|
};
|
|
|
|
})
|
|
|
|
|
|
|
|
.service('ExternalResourcesManager', function ($q, $http, $sce) {
|
|
|
|
var urlPromises = {};
|
|
|
|
|
|
|
|
function downloadByURL (url) {
|
|
|
|
if (urlPromises[url] !== undefined) {
|
|
|
|
return urlPromises[url];
|
|
|
|
}
|
|
|
|
|
|
|
|
return urlPromises[url] = $http.get(url, {responseType: 'blob', transformRequest: null})
|
|
|
|
.then(function (response) {
|
|
|
|
window.URL = window.URL || window.webkitURL;
|
|
|
|
var url = window.URL.createObjectURL(response.data);
|
|
|
|
return $sce.trustAsResourceUrl(url);
|
|
|
|
}, function (error) {
|
|
|
|
if (!Config.Modes.chrome_packed) {
|
|
|
|
return $q.when($sce.trustAsResourceUrl(url));
|
|
|
|
}
|
|
|
|
return $q.reject(error);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return {
|
|
|
|
downloadByURL: downloadByURL
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
.service('IdleManager', function ($rootScope, $window, $timeout) {
|
|
|
|
|
|
|
|
$rootScope.idle = {isIDLE: false};
|
|
|
|
|
|
|
|
var toPromise, started = false;
|
|
|
|
|
|
|
|
var hidden = 'hidden';
|
|
|
|
var visibilityChange = 'visibilitychange';
|
|
|
|
if (typeof document.hidden !== 'undefined') {
|
|
|
|
// default
|
|
|
|
} else if (typeof document.mozHidden !== 'undefined') {
|
|
|
|
hidden = 'mozHidden';
|
|
|
|
visibilityChange = 'mozvisibilitychange';
|
|
|
|
} else if (typeof document.msHidden !== 'undefined') {
|
|
|
|
hidden = 'msHidden';
|
|
|
|
visibilityChange = 'msvisibilitychange';
|
|
|
|
} else if (typeof document.webkitHidden !== 'undefined') {
|
|
|
|
hidden = 'webkitHidden';
|
|
|
|
visibilityChange = 'webkitvisibilitychange';
|
|
|
|
}
|
|
|
|
|
|
|
|
return {
|
|
|
|
start: start
|
|
|
|
};
|
|
|
|
|
|
|
|
function start () {
|
|
|
|
if (!started) {
|
|
|
|
started = true;
|
|
|
|
$($window).on(visibilityChange + ' blur focus keydown mousedown touchstart', onEvent);
|
|
|
|
|
|
|
|
setTimeout(function () {
|
|
|
|
onEvent({type: 'blur'});
|
|
|
|
}, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function onEvent (e) {
|
|
|
|
// console.log('event', e.type);
|
|
|
|
if (e.type == 'mousemove') {
|
|
|
|
var e = e.originalEvent || e;
|
|
|
|
if (e && e.movementX === 0 && e.movementY === 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
$($window).off('mousemove', onEvent);
|
|
|
|
}
|
|
|
|
|
|
|
|
var isIDLE = e.type == 'blur' || e.type == 'timeout' ? true : false;
|
|
|
|
if (hidden && document[hidden]) {
|
|
|
|
isIDLE = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
$timeout.cancel(toPromise);
|
|
|
|
if (!isIDLE) {
|
|
|
|
// console.log('update timeout');
|
|
|
|
toPromise = $timeout(function () {
|
|
|
|
onEvent({type: 'timeout'});
|
|
|
|
}, 30000);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (e.type == 'focus' && !$rootScope.idle.afterFocus) {
|
|
|
|
$rootScope.idle.afterFocus = true;
|
|
|
|
setTimeout(function () {
|
|
|
|
delete $rootScope.idle.afterFocus;
|
|
|
|
}, 10);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($rootScope.idle.isIDLE == isIDLE) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// console.log('IDLE changed', isIDLE);
|
|
|
|
$rootScope.$apply(function () {
|
|
|
|
$rootScope.idle.isIDLE = isIDLE;
|
|
|
|
});
|
|
|
|
|
|
|
|
if (isIDLE && e.type == 'timeout') {
|
|
|
|
$($window).on('mousemove', onEvent);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
.service('AppRuntimeManager', function ($window) {
|
|
|
|
|
|
|
|
return {
|
|
|
|
reload: function () {
|
|
|
|
try {
|
|
|
|
location.reload();
|
|
|
|
} catch (e) {};
|
|
|
|
|
|
|
|
if ($window.chrome && chrome.runtime && chrome.runtime.reload) {
|
|
|
|
chrome.runtime.reload();
|
|
|
|
};
|
|
|
|
},
|
|
|
|
close: function () {
|
|
|
|
try {
|
|
|
|
$window.close();
|
|
|
|
} catch (e) {}
|
|
|
|
},
|
|
|
|
focus: function () {
|
|
|
|
if (window.navigator.mozApps && document.hidden) {
|
|
|
|
// Get app instance and launch it to bring app to foreground
|
|
|
|
window.navigator.mozApps.getSelf().onsuccess = function() {
|
|
|
|
this.result.launch();
|
|
|
|
};
|
|
|
|
} else {
|
|
|
|
if (window.chrome && chrome.app && chrome.app.window) {
|
|
|
|
chrome.app.window.current().focus();
|
|
|
|
}
|
|
|
|
window.focus();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
.service('RichTextProcessor', function ($sce, $sanitize) {
|
|
|
|
|
|
|
|
var emojiMap = {},
|
|
|
|
emojiData = Config.Emoji,
|
|
|
|
emojiIconSize = 18,
|
|
|
|
emojiSupported = navigator.userAgent.search(/OS X|iPhone|iPad|iOS|Android/i) != -1,
|
|
|
|
emojiCode;
|
|
|
|
|
|
|
|
var emojiRegExp = "\\u0023\\u20E3|\\u00a9|\\u00ae|\\u203c|\\u2049|\\u2139|[\\u2194-\\u2199]|\\u21a9|\\u21aa|\\u231a|\\u231b|\\u23e9|[\\u23ea-\\u23ec]|\\u23f0|\\u24c2|\\u25aa|\\u25ab|\\u25b6|\\u2611|\\u2614|\\u26fd|\\u2705|\\u2709|[\\u2795-\\u2797]|\\u27a1|\\u27b0|\\u27bf|\\u2934|\\u2935|[\\u2b05-\\u2b07]|\\u2b1b|\\u2b1c|\\u2b50|\\u2b55|\\u3030|\\u303d|\\u3297|\\u3299|[\\uE000-\\uF8FF\\u270A-\\u2764\\u2122\\u25C0\\u25FB-\\u25FE\\u2615\\u263a\\u2648-\\u2653\\u2660-\\u2668\\u267B\\u267F\\u2693\\u261d\\u26A0-\\u26FA\\u2708\\u2702\\u2601\\u260E]|[\\u2600\\u26C4\\u26BE\\u23F3\\u2764]|\\uD83D[\\uDC00-\\uDFFF]|\\uD83C[\\uDDE8-\\uDDFA\uDDEC]\\uD83C[\\uDDEA-\\uDDFA\uDDE7]|[0-9]\\u20e3|\\uD83C[\\uDC00-\\uDFFF]";
|
|
|
|
|
|
|
|
for (emojiCode in emojiData) {
|
|
|
|
emojiMap[emojiData[emojiCode][0]] = emojiCode;
|
|
|
|
}
|
|
|
|
|
|
|
|
var alphaCharsRegExp = "a-z" +
|
|
|
|
"\\u00c0-\\u00d6\\u00d8-\\u00f6\\u00f8-\\u00ff" + // Latin-1
|
|
|
|
"\\u0100-\\u024f" + // Latin Extended A and B
|
|
|
|
"\\u0253\\u0254\\u0256\\u0257\\u0259\\u025b\\u0263\\u0268\\u026f\\u0272\\u0289\\u028b" + // IPA Extensions
|
|
|
|
"\\u02bb" + // Hawaiian
|
|
|
|
"\\u0300-\\u036f" + // Combining diacritics
|
|
|
|
"\\u1e00-\\u1eff" + // Latin Extended Additional (mostly for Vietnamese)
|
|
|
|
"\\u0400-\\u04ff\\u0500-\\u0527" + // Cyrillic
|
|
|
|
"\\u2de0-\\u2dff\\ua640-\\ua69f" + // Cyrillic Extended A/B
|
|
|
|
"\\u0591-\\u05bf\\u05c1-\\u05c2\\u05c4-\\u05c5\\u05c7" +
|
|
|
|
"\\u05d0-\\u05ea\\u05f0-\\u05f4" + // Hebrew
|
|
|
|
"\\ufb1d-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40-\\ufb41" +
|
|
|
|
"\\ufb43-\\ufb44\\ufb46-\\ufb4f" + // Hebrew Pres. Forms
|
|
|
|
"\\u0610-\\u061a\\u0620-\\u065f\\u066e-\\u06d3\\u06d5-\\u06dc" +
|
|
|
|
"\\u06de-\\u06e8\\u06ea-\\u06ef\\u06fa-\\u06fc\\u06ff" + // Arabic
|
|
|
|
"\\u0750-\\u077f\\u08a0\\u08a2-\\u08ac\\u08e4-\\u08fe" + // Arabic Supplement and Extended A
|
|
|
|
"\\ufb50-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb" + // Pres. Forms A
|
|
|
|
"\\ufe70-\\ufe74\\ufe76-\\ufefc" + // Pres. Forms B
|
|
|
|
"\\u200c" + // Zero-Width Non-Joiner
|
|
|
|
"\\u0e01-\\u0e3a\\u0e40-\\u0e4e" + // Thai
|
|
|
|
"\\u1100-\\u11ff\\u3130-\\u3185\\uA960-\\uA97F\\uAC00-\\uD7AF\\uD7B0-\\uD7FF" + // Hangul (Korean)
|
|
|
|
"\\u3003\\u3005\\u303b" + // Kanji/Han iteration marks
|
|
|
|
"\\uff21-\\uff3a\\uff41-\\uff5a" + // full width Alphabet
|
|
|
|
"\\uff66-\\uff9f" + // half width Katakana
|
|
|
|
"\\uffa1-\\uffdc"; // half width Hangul (Korean)
|
|
|
|
|
|
|
|
var alphaNumericRegExp = "0-9\_" + alphaCharsRegExp;
|
|
|
|
|
|
|
|
var domainAddChars = "\u00b7";
|
|
|
|
|
|
|
|
// Based on Regular Expression for URL validation by Diego Perini
|
|
|
|
var urlRegExp = "((?:https?|ftp)://|mailto:)?" +
|
|
|
|
// user:pass authentication
|
|
|
|
"(?:\\S{1,64}(?::\\S{0,64})?@)?" +
|
|
|
|
"(?:" +
|
|
|
|
// sindresorhus/ip-regexp
|
|
|
|
"(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])(?:\\.(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])){3}" +
|
|
|
|
"|" +
|
|
|
|
// host name
|
|
|
|
"[" + alphaCharsRegExp + "0-9][" + alphaCharsRegExp + domainAddChars + "0-9\-]{0,64}" +
|
|
|
|
// domain name
|
|
|
|
"(?:\\.[" + alphaCharsRegExp + "0-9][" + alphaCharsRegExp + domainAddChars + "0-9\-]{0,64}){0,10}" +
|
|
|
|
|
|
|
|
// TLD identifier
|
|
|
|
"(?:\\.(xn--[0-9a-z]{2,16}|[" + alphaCharsRegExp + "]{2,24}))" +
|
|
|
|
")" +
|
|
|
|
// port number
|
|
|
|
"(?::\\d{2,5})?" +
|
|
|
|
// resource path
|
|
|
|
"(?:/(?:\\S{0,255}[^\\s.;,(\\[\\]{}<>\"'])?)?";
|
|
|
|
|
|
|
|
var usernameRegExp = "[a-zA-Z\\d_]{5,32}";
|
|
|
|
var botCommandRegExp = "\\/([a-zA-Z\\d_]{1,32})(?:@(" + usernameRegExp + "))?(\\b|$)"
|
|
|
|
|
|
|
|
var fullRegExp = new RegExp('(^| )(@)(' + usernameRegExp + ')|(' + urlRegExp + ')|(\\n)|(' + emojiRegExp + ')|(^|[\\s\\(\\]])(#[' + alphaNumericRegExp + ']{2,64})|(^|\\s)' + botCommandRegExp, 'i');
|
|
|
|
|
|
|
|
var emailRegExp = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
|
|
|
|
var youtubeRegExp = /^(?:https?:\/\/)?(?:www\.)?youtu(?:|\.be|be\.com|\.b)(?:\/v\/|\/watch\\?v=|e\/|(?:\/\??#)?\/watch(?:.+)v=)(.{11})(?:\&[^\s]*)?/;
|
|
|
|
var vimeoRegExp = /^(?:https?:\/\/)?(?:www\.)?vimeo\.com\/(\d+)/;
|
|
|
|
var instagramRegExp = /^https?:\/\/(?:instagr\.am\/p\/|instagram\.com\/p\/)([a-zA-Z0-9\-\_]+)/i;
|
|
|
|
var vineRegExp = /^https?:\/\/vine\.co\/v\/([a-zA-Z0-9\-\_]+)/i;
|
|
|
|
var twitterRegExp = /^https?:\/\/twitter\.com\/.+?\/status\/\d+/i;
|
|
|
|
var facebookRegExp = /^https?:\/\/(?:www\.|m\.)?facebook\.com\/(?:.+?\/posts\/\d+|(?:story\.php|permalink\.php)\?story_fbid=(\d+)(?:&substory_index=\d+)?&id=(\d+))/i;
|
|
|
|
var gplusRegExp = /^https?:\/\/plus\.google\.com\/\d+\/posts\/[a-zA-Z0-9\-\_]+/i;
|
|
|
|
var soundcloudRegExp = /^https?:\/\/(?:soundcloud\.com|snd\.sc)\/([a-zA-Z0-9%\-\_]+)\/([a-zA-Z0-9%\-\_]+)/i;
|
|
|
|
var spotifyRegExp = /(https?:\/\/(open\.spotify\.com|play\.spotify\.com|spoti\.fi)\/(.+)|spotify:(.+))/i;
|
|
|
|
|
|
|
|
var markdownRegExp = /(^|\s)(````?)([\s\S]+?)(````?)([\s\n\.,:?!;]|$)|(^|\s)`([^\n]+?)`([\s\.,:?!;]|$)/;
|
|
|
|
|
|
|
|
var siteHashtags = {
|
|
|
|
Telegram: 'tg://search_hashtag?hashtag={1}',
|
|
|
|
Twitter: 'https://twitter.com/hashtag/{1}',
|
|
|
|
Instagram: 'https://instagram.com/explore/tags/{1}/',
|
|
|
|
'Google Plus': 'https://plus.google.com/explore/{1}'
|
|
|
|
};
|
|
|
|
|
|
|
|
var siteMentions = {
|
|
|
|
Telegram: '#/im?p=%40{1}',
|
|
|
|
Twitter: 'https://twitter.com/{1}',
|
|
|
|
Instagram: 'https://instagram.com/{1}/',
|
|
|
|
GitHub: 'https://github.com/{1}'
|
|
|
|
};
|
|
|
|
|
|
|
|
return {
|
|
|
|
wrapRichText: wrapRichText,
|
|
|
|
wrapPlainText: wrapPlainText,
|
|
|
|
parseEntities: parseEntities,
|
|
|
|
parseMarkdown: parseMarkdown,
|
|
|
|
parseEmojis: parseEmojis,
|
|
|
|
mergeEntities: mergeEntities
|
|
|
|
};
|
|
|
|
|
|
|
|
function getEmojiSpritesheetCoords(emojiCode) {
|
|
|
|
var i, row, column, totalColumns;
|
|
|
|
for (var cat = 0; cat < Config.EmojiCategories.length; cat++) {
|
|
|
|
totalColumns = Config.EmojiCategorySpritesheetDimens[cat][1];
|
|
|
|
i = Config.EmojiCategories[cat].indexOf(emojiCode);
|
|
|
|
if (i > -1) {
|
|
|
|
row = Math.floor(i / totalColumns);
|
|
|
|
column = (i % totalColumns);
|
|
|
|
return { category: cat, row: row, column: column };
|
|
|
|
}
|
|
|
|
}
|
|
|
|
console.error('emoji not found in spritesheet', emojiCode);
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
function parseEntities (text, options) {
|
|
|
|
options = options || {};
|
|
|
|
|
|
|
|
var match,
|
|
|
|
raw = text,
|
|
|
|
url,
|
|
|
|
entities = [],
|
|
|
|
emojiCode,
|
|
|
|
emojiCoords,
|
|
|
|
matchIndex,
|
|
|
|
rawOffset = 0;
|
|
|
|
|
|
|
|
// var start = tsNow();
|
|
|
|
|
|
|
|
while ((match = raw.match(fullRegExp))) {
|
|
|
|
matchIndex = rawOffset + match.index;
|
|
|
|
|
|
|
|
if (match[3]) { // mentions
|
|
|
|
entities.push({
|
|
|
|
_: 'messageEntityMention',
|
|
|
|
offset: matchIndex + match[1].length,
|
|
|
|
length: match[2].length + match[3].length
|
|
|
|
});
|
|
|
|
}
|
|
|
|
else if (match[4]) {
|
|
|
|
if (emailRegExp.test(match[4])) { // email
|
|
|
|
entities.push({
|
|
|
|
_: 'messageEntityEmail',
|
|
|
|
offset: matchIndex,
|
|
|
|
length: match[4].length
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
var url = false,
|
|
|
|
protocol = match[5],
|
|
|
|
tld = match[6],
|
|
|
|
excluded = '';
|
|
|
|
|
|
|
|
if (tld) { // URL
|
|
|
|
if (!protocol && (tld.substr(0, 4) === 'xn--' || Config.TLD.indexOf(tld.toLowerCase()) !== -1)) {
|
|
|
|
protocol = 'http://';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (protocol) {
|
|
|
|
var balanced = checkBrackets(match[4]);
|
|
|
|
|
|
|
|
if (balanced.length !== match[4].length) {
|
|
|
|
excluded = match[4].substring(balanced.length);
|
|
|
|
match[4] = balanced;
|
|
|
|
}
|
|
|
|
|
|
|
|
url = (match[5] ? '' : protocol) + match[4];
|
|
|
|
}
|
|
|
|
} else { // IP address
|
|
|
|
url = (match[5] ? '' : 'http://') + match[4];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (url) {
|
|
|
|
entities.push({
|
|
|
|
_: 'messageEntityUrl',
|
|
|
|
offset: matchIndex,
|
|
|
|
length: match[4].length
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (match[7]) { // New line
|
|
|
|
entities.push({
|
|
|
|
_: 'messageEntityLinebreak',
|
|
|
|
offset: matchIndex,
|
|
|
|
length: 1
|
|
|
|
});
|
|
|
|
}
|
|
|
|
else if (match[8]) { // Emoji
|
|
|
|
if ((emojiCode = emojiMap[match[8]]) &&
|
|
|
|
(emojiCoords = getEmojiSpritesheetCoords(emojiCode))) {
|
|
|
|
|
|
|
|
entities.push({
|
|
|
|
_: 'messageEntityEmoji',
|
|
|
|
offset: matchIndex,
|
|
|
|
length: match[0].length,
|
|
|
|
coords: emojiCoords,
|
|
|
|
title: emojiData[emojiCode][1][0]
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (match[10]) { // Hashtag
|
|
|
|
entities.push({
|
|
|
|
_: 'messageEntityHashtag',
|
|
|
|
offset: matchIndex + match[9].length,
|
|
|
|
length: match[10].length
|
|
|
|
});
|
|
|
|
}
|
|
|
|
else if (match[12]) { // Bot command
|
|
|
|
entities.push({
|
|
|
|
_: 'messageEntityBotCommand',
|
|
|
|
offset: matchIndex + match[11].length,
|
|
|
|
length: 1 + match[12].length + (match[13] ? 1 + match[13].length : 0)
|
|
|
|
});
|
|
|
|
}
|
|
|
|
raw = raw.substr(match.index + match[0].length);
|
|
|
|
rawOffset += match.index + match[0].length;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if (entities.length) {
|
|
|
|
// console.log('parse entities', text, entities.slice());
|
|
|
|
// }
|
|
|
|
|
|
|
|
return entities;
|
|
|
|
}
|
|
|
|
|
|
|
|
function parseEmojis(text) {
|
|
|
|
return text.replace(/:([a-z0-9\-\+\*_]+?):/gi, function (all, shortcut) {
|
|
|
|
var emojiCode = EmojiHelper.shortcuts[shortcut];
|
|
|
|
if (emojiCode !== undefined) {
|
|
|
|
return EmojiHelper.emojis[emojiCode][0];
|
|
|
|
}
|
|
|
|
return all;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
function parseMarkdown (text, entities) {
|
|
|
|
if (text.indexOf('`') == -1) {
|
|
|
|
return text;
|
|
|
|
}
|
|
|
|
var raw = text;
|
|
|
|
var match;
|
|
|
|
var newText = [];
|
|
|
|
var rawOffset = 0;
|
|
|
|
var matchIndex;
|
|
|
|
while (match = raw.match(markdownRegExp)) {
|
|
|
|
matchIndex = rawOffset + match.index;
|
|
|
|
newText.push(raw.substr(0, match.index));
|
|
|
|
|
|
|
|
var text = (match[3] || match[7]);
|
|
|
|
rawOffset -= text.length;
|
|
|
|
text = text.replace(/^\s+|\s+$/g, '');
|
|
|
|
rawOffset += text.length;
|
|
|
|
|
|
|
|
if (text.match(/^`*$/)) {
|
|
|
|
newText.push(match[0]);
|
|
|
|
}
|
|
|
|
else if (match[3]) { // pre
|
|
|
|
if (match[5] == "\n") {
|
|
|
|
match[5] = '';
|
|
|
|
rawOffset -= 1;
|
|
|
|
}
|
|
|
|
newText.push(match[1] + text + match[5]);
|
|
|
|
entities.push({
|
|
|
|
_: 'messageEntityPre',
|
|
|
|
language: '',
|
|
|
|
offset: matchIndex + match[1].length,
|
|
|
|
length: text.length
|
|
|
|
});
|
|
|
|
rawOffset -= match[2].length + match[4].length;
|
|
|
|
} else { // code
|
|
|
|
newText.push(match[6] + text + match[8]);
|
|
|
|
entities.push({
|
|
|
|
_: 'messageEntityCode',
|
|
|
|
offset: matchIndex + match[6].length,
|
|
|
|
length: text.length
|
|
|
|
});
|
|
|
|
rawOffset -= 2;
|
|
|
|
}
|
|
|
|
raw = raw.substr(match.index + match[0].length);
|
|
|
|
rawOffset += match.index + match[0].length;
|
|
|
|
}
|
|
|
|
newText.push(raw);
|
|
|
|
newText = newText.join('');
|
|
|
|
|
|
|
|
if (!newText.replace(/\s+/g, '').length) {
|
|
|
|
newText = text;
|
|
|
|
entities.splice(0, entities.length);
|
|
|
|
}
|
|
|
|
return newText;
|
|
|
|
}
|
|
|
|
|
|
|
|
function mergeEntities (currentEntities, newEntities, fromApi) {
|
|
|
|
var totalEntities = newEntities.slice();
|
|
|
|
|
|
|
|
var i, len = currentEntities.length;
|
|
|
|
var j, len2 = newEntities.length;
|
|
|
|
var startJ = 0;
|
|
|
|
var curEntity, newEntity;
|
|
|
|
var start, end, cStart, cEnd, bad;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
curEntity = currentEntities[i];
|
|
|
|
if (fromApi &&
|
|
|
|
curEntity._ != 'messageEntityLinebreak' &&
|
|
|
|
curEntity._ != 'messageEntityEmoji') {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// console.log('s', curEntity, newEntities);
|
|
|
|
start = curEntity.offset;
|
|
|
|
end = start + curEntity.length;
|
|
|
|
bad = false;
|
|
|
|
for (j = startJ; j < len2; j++) {
|
|
|
|
newEntity = newEntities[j];
|
|
|
|
cStart = newEntity.offset;
|
|
|
|
cEnd = cStart + newEntity.length;
|
|
|
|
if (cStart <= start) {
|
|
|
|
startJ = j;
|
|
|
|
}
|
|
|
|
if (start >= cStart && start < cEnd ||
|
|
|
|
end > cStart && end <= cEnd) {
|
|
|
|
// console.log('bad', curEntity, newEntity);
|
|
|
|
if (fromApi &&
|
|
|
|
start >= cStart && end <= cEnd) {
|
|
|
|
if (newEntity.nested === undefined) {
|
|
|
|
newEntity.nested = [];
|
|
|
|
}
|
|
|
|
curEntity.offset -= cStart;
|
|
|
|
newEntity.nested.push(angular.copy(curEntity));
|
|
|
|
}
|
|
|
|
bad = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (cStart >= end) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (bad) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
totalEntities.push(curEntity);
|
|
|
|
}
|
|
|
|
|
|
|
|
totalEntities.sort(function (a, b) {
|
|
|
|
return a.offset - b.offset;
|
|
|
|
});
|
|
|
|
|
|
|
|
// console.log('merge', currentEntities, newEntities, totalEntities);
|
|
|
|
|
|
|
|
return totalEntities;
|
|
|
|
}
|
|
|
|
|
|
|
|
function wrapRichNestedText (text, nested, options) {
|
|
|
|
if (nested === undefined) {
|
|
|
|
return encodeEntities(text);
|
|
|
|
}
|
|
|
|
options.hasNested = true;
|
|
|
|
|
|
|
|
return wrapRichText(text, {entities: nested, nested: true});
|
|
|
|
}
|
|
|
|
|
|
|
|
function wrapRichText (text, options) {
|
|
|
|
if (!text || !text.length) {
|
|
|
|
return '';
|
|
|
|
}
|
|
|
|
|
|
|
|
options = options || {};
|
|
|
|
|
|
|
|
var entities = options.entities,
|
|
|
|
contextSite = options.contextSite || 'Telegram',
|
|
|
|
contextExternal = contextSite != 'Telegram',
|
|
|
|
emojiFound = false;
|
|
|
|
|
|
|
|
if (entities === undefined) {
|
|
|
|
entities = parseEntities(text, options);
|
|
|
|
}
|
|
|
|
|
|
|
|
var i = 0;
|
|
|
|
var len = entities.length;
|
|
|
|
var entity;
|
|
|
|
var entityText;
|
|
|
|
var skipEntity;
|
|
|
|
var url;
|
|
|
|
var html = [];
|
|
|
|
var lastOffset = 0;
|
|
|
|
var curEmojiSize = options.emojiIconSize || emojiIconSize;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
entity = entities[i];
|
|
|
|
if (entity.offset > lastOffset) {
|
|
|
|
html.push(
|
|
|
|
encodeEntities(text.substr(lastOffset, entity.offset - lastOffset))
|
|
|
|
);
|
|
|
|
}
|
|
|
|
else if (entity.offset < lastOffset) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
skipEntity = false;
|
|
|
|
entityText = text.substr(entity.offset, entity.length);
|
|
|
|
switch (entity._) {
|
|
|
|
case 'messageEntityMention':
|
|
|
|
var contextUrl = !options.noLinks && siteMentions[contextSite];
|
|
|
|
if (!contextUrl) {
|
|
|
|
skipEntity = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
var username = entityText.substr(1);
|
|
|
|
var attr = '';
|
|
|
|
if (options.highlightUsername &&
|
|
|
|
options.highlightUsername.toLowerCase() == username.toLowerCase()) {
|
|
|
|
attr = 'class="im_message_mymention"';
|
|
|
|
}
|
|
|
|
html.push(
|
|
|
|
'<a ',
|
|
|
|
attr,
|
|
|
|
contextExternal ? ' target="_blank" ' : '',
|
|
|
|
' href="',
|
|
|
|
contextUrl.replace('{1}', encodeURIComponent(username)),
|
|
|
|
'">',
|
|
|
|
encodeEntities(entityText),
|
|
|
|
'</a>'
|
|
|
|
);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'messageEntityHashtag':
|
|
|
|
var contextUrl = !options.noLinks && siteHashtags[contextSite];
|
|
|
|
if (!contextUrl) {
|
|
|
|
skipEntity = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
var hashtag = entityText.substr(1);
|
|
|
|
html.push(
|
|
|
|
'<a ',
|
|
|
|
contextExternal ? ' target="_blank" ' : '',
|
|
|
|
'href="',
|
|
|
|
contextUrl.replace('{1}', encodeURIComponent(hashtag))
|
|
|
|
,
|
|
|
|
'">',
|
|
|
|
encodeEntities(entityText),
|
|
|
|
'</a>'
|
|
|
|
);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'messageEntityEmail':
|
|
|
|
if (options.noLinks) {
|
|
|
|
skipEntity = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
html.push(
|
|
|
|
'<a href="',
|
|
|
|
encodeEntities('mailto:' + entityText),
|
|
|
|
'" target="_blank">',
|
|
|
|
encodeEntities(entityText),
|
|
|
|
'</a>'
|
|
|
|
);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'messageEntityUrl':
|
|
|
|
case 'messageEntityTextUrl':
|
|
|
|
if (options.noLinks) {
|
|
|
|
skipEntity = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
var url = entity.url || entityText;
|
|
|
|
if (!url.match(/^https?:\/\//i)) {
|
|
|
|
url = 'http://' + url;
|
|
|
|
}
|
|
|
|
var tgMeMatch;
|
|
|
|
if (entity._ == 'messageEntityTextUrl') {
|
|
|
|
url = 'tg://unsafe_url?url=' + encodeURIComponent(url);
|
|
|
|
}
|
|
|
|
else if ((tgMeMatch = url.match(/^https?:\/\/telegram\.me\/(.+)/))) {
|
|
|
|
var path = tgMeMatch[1].split('/');
|
|
|
|
switch (path[0]) {
|
|
|
|
case 'joinchat':
|
|
|
|
url = 'tg://join?invite=' + path[1];
|
|
|
|
break;
|
|
|
|
case 'addstickers':
|
|
|
|
url = 'tg://addstickers?set=' + path[1];
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (path[1] && path[1].match(/^\d+$/)) {
|
|
|
|
url = 'tg://resolve?domain=' + path[0] + '&post=' + path[1];
|
|
|
|
}
|
|
|
|
else if (!path[1]) {
|
|
|
|
var domainQuery = path[0].split('?');
|
|
|
|
url = 'tg://resolve?domain=' + domainQuery[0] + (domainQuery[1] ? '&' + domainQuery[1] : '');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
html.push(
|
|
|
|
'<a href="',
|
|
|
|
encodeEntities(url),
|
|
|
|
'" target="_blank">',
|
|
|
|
wrapRichNestedText(entityText, entity.nested, options),
|
|
|
|
'</a>'
|
|
|
|
);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'messageEntityLinebreak':
|
|
|
|
html.push(options.noLinebreaks ? ' ' : '<br/>');
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'messageEntityEmoji':
|
|
|
|
html.push(
|
|
|
|
'<span class="emoji emoji-',
|
|
|
|
entity.coords.category,
|
|
|
|
'-',
|
|
|
|
(curEmojiSize * entity.coords.column),
|
|
|
|
'-',
|
|
|
|
(curEmojiSize * entity.coords.row),
|
|
|
|
'" ',
|
|
|
|
'title="', entity.title, '">',
|
|
|
|
':', entity.title, ':</span>'
|
|
|
|
);
|
|
|
|
emojiFound = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'messageEntityBotCommand':
|
|
|
|
if (options.noLinks || options.noCommands || contextExternal) {
|
|
|
|
skipEntity = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
var command = entityText.substr(1);
|
|
|
|
var bot, atPos;
|
|
|
|
if ((atPos = command.indexOf('@')) != -1) {
|
|
|
|
bot = command.substr(atPos + 1);
|
|
|
|
command = command.substr(0, atPos);
|
|
|
|
} else {
|
|
|
|
bot = options.fromBot;
|
|
|
|
}
|
|
|
|
html.push(
|
|
|
|
'<a href="',
|
|
|
|
encodeEntities('tg://bot_command?command=' + encodeURIComponent(command) + (bot ? '&bot=' + encodeURIComponent(bot) : '')),
|
|
|
|
'">',
|
|
|
|
encodeEntities(entityText),
|
|
|
|
'</a>'
|
|
|
|
);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'messageEntityBold':
|
|
|
|
html.push(
|
|
|
|
'<strong>',
|
|
|
|
wrapRichNestedText(entityText, entity.nested, options),
|
|
|
|
'</strong>'
|
|
|
|
);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'messageEntityItalic':
|
|
|
|
html.push(
|
|
|
|
'<em>',
|
|
|
|
wrapRichNestedText(entityText, entity.nested, options),
|
|
|
|
'</em>'
|
|
|
|
);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'messageEntityCode':
|
|
|
|
html.push(
|
|
|
|
'<code>',
|
|
|
|
encodeEntities(entityText),
|
|
|
|
'</code>'
|
|
|
|
);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'messageEntityPre':
|
|
|
|
html.push(
|
|
|
|
'<pre><code',(entity.language ? ' class="language-' + encodeEntities(entity.language) +'"' : ''),'>',
|
|
|
|
encodeEntities(entityText),
|
|
|
|
'</code></pre>'
|
|
|
|
);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
skipEntity = true;
|
|
|
|
}
|
|
|
|
lastOffset = entity.offset + (skipEntity ? 0 : entity.length);
|
|
|
|
}
|
|
|
|
html.push(encodeEntities(text.substr(lastOffset)));
|
|
|
|
|
|
|
|
text = $sanitize(html.join(''));
|
|
|
|
|
|
|
|
if (!options.nested && (emojiFound || options.hasNested)) {
|
|
|
|
text = text.replace(/\ufe0f|️|�|‍/g, '', text);
|
|
|
|
var emojiSizeClass = curEmojiSize == 18 ? '' : (' emoji-w' + curEmojiSize);
|
|
|
|
text = text.replace(/<span class="emoji emoji-(\d)-(\d+)-(\d+)"(.+?)<\/span>/g,
|
|
|
|
'<span class="emoji ' + emojiSizeClass + ' emoji-spritesheet-$1" style="background-position: -$2px -$3px;" $4</span>');
|
|
|
|
}
|
|
|
|
|
|
|
|
return $sce.trustAs('html', text);
|
|
|
|
}
|
|
|
|
|
|
|
|
function checkBrackets(url) {
|
|
|
|
var urlLength = url.length,
|
|
|
|
urlOpenBrackets = url.split('(').length - 1,
|
|
|
|
urlCloseBrackets = url.split(')').length - 1;
|
|
|
|
|
|
|
|
while (urlCloseBrackets > urlOpenBrackets &&
|
|
|
|
url.charAt(urlLength - 1) === ')') {
|
|
|
|
url = url.substr(0, urlLength - 1);
|
|
|
|
urlCloseBrackets--;
|
|
|
|
urlLength--;
|
|
|
|
}
|
|
|
|
if (urlOpenBrackets > urlCloseBrackets) {
|
|
|
|
url = url.replace(/\)+$/, '');
|
|
|
|
}
|
|
|
|
return url;
|
|
|
|
}
|
|
|
|
|
|
|
|
function wrapPlainText (text, options) {
|
|
|
|
if (emojiSupported) {
|
|
|
|
return text;
|
|
|
|
}
|
|
|
|
if (!text || !text.length) {
|
|
|
|
return '';
|
|
|
|
}
|
|
|
|
|
|
|
|
options = options || {};
|
|
|
|
|
|
|
|
text = text.replace(/\ufe0f/g, '', text);
|
|
|
|
|
|
|
|
var match,
|
|
|
|
raw = text,
|
|
|
|
text = [],
|
|
|
|
emojiTitle;
|
|
|
|
|
|
|
|
while ((match = raw.match(fullRegExp))) {
|
|
|
|
text.push(raw.substr(0, match.index));
|
|
|
|
|
|
|
|
if (match[8]) {
|
|
|
|
if ((emojiCode = emojiMap[match[8]]) &&
|
|
|
|
(emojiTitle = emojiData[emojiCode][1][0])) {
|
|
|
|
text.push(':' + emojiTitle + ':');
|
|
|
|
} else {
|
|
|
|
text.push(match[0]);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
text.push(match[0]);
|
|
|
|
}
|
|
|
|
raw = raw.substr(match.index + match[0].length);
|
|
|
|
}
|
|
|
|
text.push(raw);
|
|
|
|
|
|
|
|
return text.join('');
|
|
|
|
}
|
|
|
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|