/**
* AngularJS Service with useful utility functions
*
* @module utilityService
* @see https://docs.angularjs.org/api/ng/type/angular.Module#service
*/
/* eslint-disable no-param-reassign, no-restricted-properties, no-bitwise */
angular.module('tgaApp').service('utilityService', [
'$window',
'$document',
function utilityService($window, $document) {
/**
* Check whether browser is likely to be a mobile device (including an iPad).
*
* @return {boolean}
*/
this.isMobile = () => /Mobi|Android/.test($window.navigator.userAgent) || this.isIPad();
/**
* Check whether browser is likely to be an iPad.
*
* @return {boolean}
*/
this.isIPad = () => {
const ua = $window.navigator.userAgent.toLowerCase();
return (ua.indexOf('ipad') > -1 || ua.indexOf('macintosh') > -1) && 'ontouchend' in $document[0];
};
/**
* Check whether browser claims to be iOS.
*
* @return {boolean}
*/
this.isIOS = () => /iPad|iPhone|iPod/.test($window.navigator.platform) || this.isIPad();
/**
* Deep copy an object via JSON serialization and deserialization.
*
* @param {*} object - Any JSON-serializable object.
* @return {*} A deep copy of the object.
*/
this.deepCopy = (object) => angular.fromJson(angular.toJson(object));
/**
* Generate a Version 4 (random) UUID.
*
* @return {string} A 36-character UUID string.
*/
this.generateUUID = () => 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
const r = (Math.random() * 16) | 0;
// eslint-disable-next-line no-mixed-operators
const v = c === 'x' ? r : (r & 0x3) | 0x8;
return v.toString(16);
});
/**
* SHA256 hashing algorithm.
*
* @param {string} ascii - Input string (must only contain 1-byte characters).
* @return {string} A 64-character hexadecimal string hash result.
*/
this.sha256 = (ascii) => {
function rightRotate(value, amount) {
return (value >>> amount) | (value << (32 - amount));
}
const mathPow = Math.pow;
const maxWord = mathPow(2, 32);
const lengthProperty = 'length';
let i;
let j; // Used as a counter across the whole file
let result = '';
const words = [];
const asciiBitLength = ascii[lengthProperty] * 8;
//* caching results is optional - remove/add slash from front of this line to toggle
// Initial hash value: first 32 bits of the fractional parts of the square roots of the first 8 primes
// (we actually calculate the first 64, but extra values are just ignored)
let hash = [];
// Round constants: first 32 bits of the fractional parts of the cube roots of the first 64 primes
const k = [];
let primeCounter = k[lengthProperty];
/*
var hash = [], k = [];
var primeCounter = 0;
*/
const isComposite = {};
for (let candidate = 2; primeCounter < 64; candidate++) {
if (!isComposite[candidate]) {
for (i = 0; i < 313; i += candidate) {
isComposite[i] = candidate;
}
hash[primeCounter] = (mathPow(candidate, 0.5) * maxWord) | 0;
k[primeCounter++] = (mathPow(candidate, 1 / 3) * maxWord) | 0;
}
}
ascii += '\x80'; // Append Ƈ' bit (plus zero padding)
while ((ascii[lengthProperty] % 64) - 56) ascii += '\x00'; // More zero padding
for (i = 0; i < ascii[lengthProperty]; i++) {
j = ascii.charCodeAt(i);
if (j >> 8) return null; // ASCII check: only accept characters in range 0-255
words[i >> 2] |= j << (((3 - i) % 4) * 8);
}
words[words[lengthProperty]] = (asciiBitLength / maxWord) | 0;
words[words[lengthProperty]] = asciiBitLength;
// process each chunk
for (j = 0; j < words[lengthProperty];) {
const w = words.slice(j, (j += 16)); // The message is expanded into 64 words as part of the iteration
const oldHash = hash;
// This is now the undefinedworking hash", often labelled as variables a...g
// (we have to truncate as well, otherwise extra entries at the end accumulate
hash = hash.slice(0, 8);
for (i = 0; i < 64; i++) {
// Expand the message into 64 words
// Used below if
const w15 = w[i - 15];
const w2 = w[i - 2];
// Iterate
const a = hash[0];
const e = hash[4];
const temp1 = hash[7]
+ (rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25)) // S1
+ ((e & hash[5]) ^ (~e & hash[6])) // ch
+ k[i]
// Expand the message schedule if needed
+ (w[i] = i < 16
? w[i]
: (w[i - 16]
+ (rightRotate(w15, 7) ^ rightRotate(w15, 18) ^ (w15 >>> 3)) // s0
+ w[i - 7]
+ (rightRotate(w2, 17) ^ rightRotate(w2, 19) ^ (w2 >>> 10))) // s1
| 0);
// This is only used once, so *could* be moved below, but it only saves 4 bytes and makes things unreadble
const temp2 = (rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22)) // S0
+ ((a & hash[1]) ^ (a & hash[2]) ^ (hash[1] & hash[2])); // maj
// We don't bother trimming off the extra ones,
// they're harmless as long as we're truncating when we do the slice()
hash = [(temp1 + temp2) | 0].concat(hash);
hash[4] = (hash[4] + temp1) | 0;
}
for (i = 0; i < 8; i++) {
hash[i] = (hash[i] + oldHash[i]) | 0;
}
}
for (i = 0; i < 8; i++) {
for (j = 3; j + 1; j--) {
const b = (hash[i] >> (j * 8)) & 255;
result += (b < 16 ? 0 : '') + b.toString(16);
}
}
return result;
};
/**
* Durstenfeld shuffle an array.
* @see https://en.wikipedia.org/wiki/Fisher-Yates_shuffle
*
* @param {Array} array - Source array.
* @return {Array} Shuffled shallow copy of source array.
*/
this.shuffleArray = (array) => {
const result = array.concat([]);
for (let i = result.length - 1; i > 0; i--) {
const j = Math.floor(Math.random() * (i + 1));
[result[i], result[j]] = [result[j], result[i]];
}
return result;
};
},
]);