291 lines
9.7 KiB
JavaScript
291 lines
9.7 KiB
JavaScript
"use strict";
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
var __generator = (this && this.__generator) || function (thisArg, body) {
|
|
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
|
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (_) try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0: case 1: t = op; break;
|
|
case 4: _.label++; return { value: op[1], done: false };
|
|
case 5: _.label++; y = op[1]; op = [0]; continue;
|
|
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
|
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
|
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop(); continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
};
|
|
exports.__esModule = true;
|
|
exports.getUniqFiles = exports.encodeFileToText = exports.arraySwapIndex = exports.arrayFilesToFileList = exports.deleteArrayElementByIndex = exports.getIndexOfFileList = exports.getRandom = exports.cloneJSON = exports.uniqValuesArray = exports.updateJSON = exports.range = exports.dec = exports.inc = void 0;
|
|
/**
|
|
* Increase the value of a `number`.
|
|
*
|
|
* @param {number} number The number to increase.
|
|
* @param {number} number Increase.
|
|
* @return {number} Returns the decrease.
|
|
* @example
|
|
*
|
|
* inc(4)
|
|
* // => 5
|
|
*
|
|
* inc(5, 3)
|
|
* // => 8
|
|
*
|
|
* inc(7.3)
|
|
* // => 8.3
|
|
*
|
|
*/
|
|
function inc(number, increase) {
|
|
if (increase === void 0) { increase = 1; }
|
|
return number + increase;
|
|
}
|
|
exports.inc = inc;
|
|
/**
|
|
* Decrease the value of a `number`.
|
|
*
|
|
* @param {number} number - The number to decrease.
|
|
* @param {number} number - Decrease.
|
|
* @return {number} Returns the decrease.
|
|
* @example
|
|
*
|
|
* dec(4)
|
|
* // => 3
|
|
*
|
|
* dec(5, 3)
|
|
* // => 2
|
|
*
|
|
* dec(7.3)
|
|
* // => 6.3
|
|
*
|
|
* dec("foo")
|
|
* // => false
|
|
*/
|
|
function dec(number, decrease) {
|
|
if (decrease === void 0) { decrease = 1; }
|
|
return number - decrease;
|
|
}
|
|
exports.dec = dec;
|
|
/**
|
|
* Returns an array with a sequence.
|
|
*
|
|
* @param {number} start - Beginning of the range.
|
|
* @param {number} stop - End of range.
|
|
* @param {number} step - Interval between numbers. Default is 1.
|
|
* @return {Array} Sequence.
|
|
* @example
|
|
*
|
|
* range(4)
|
|
* // => [0, 1, 2, 3, 4]
|
|
*
|
|
* range(2, 4)
|
|
* // => [2, 3, 4]
|
|
*
|
|
* range(0, 9, 3)
|
|
* // => [0, 3, 6, 9]
|
|
*/
|
|
function range(start, stop, step) {
|
|
if (stop === void 0) { stop = null; }
|
|
if (step === void 0) { step = 1; }
|
|
var startArray = stop === null ? 0 : start;
|
|
var stopArray = stop === null ? start : stop;
|
|
return Array.from({ length: (stopArray - startArray) / step + 1 }, function (_, i) { return startArray + (i * step); });
|
|
}
|
|
exports.range = range;
|
|
/**
|
|
* Returns a JSON with an updated value
|
|
* @param {string} key
|
|
* @param {string} newValue
|
|
* @param {JSON} json
|
|
* @return {JSON}
|
|
* @example
|
|
*
|
|
* const person = {name: 'James', age: 20, pets: ['dog', 'cat']};
|
|
* updateJSON('name', 'maria', person);
|
|
* // {"age": 20, "name": "maria", "pets": ["dog", "cat"]}
|
|
*
|
|
* Others: "modify" in Ramda
|
|
*/
|
|
function updateJSON(key, newValue, json) {
|
|
// JSON to Array
|
|
return Object.entries(json).map(function (row) {
|
|
// Replace value
|
|
return row[0] == key ? row.slice(0, 1).concat(newValue) : row;
|
|
}).reduce(function (jsonUpdate, valueUpdate) {
|
|
// Array to JSON
|
|
jsonUpdate[valueUpdate[0]] = valueUpdate[1];
|
|
return jsonUpdate;
|
|
}, {});
|
|
}
|
|
exports.updateJSON = updateJSON;
|
|
/**
|
|
* Creates a duplicate-free version of an array.
|
|
*
|
|
* @param {Array} array - The array to inspect.
|
|
* @return {Array} - Returns the new duplicate free array.
|
|
* @example
|
|
*
|
|
* uniqValuesArray([2, 1, 2, 2])
|
|
* // => [2, 1]
|
|
*/
|
|
function uniqValuesArray(array) {
|
|
return Array.from(new Set(array));
|
|
}
|
|
exports.uniqValuesArray = uniqValuesArray;
|
|
/**
|
|
* Clone JSON.
|
|
*
|
|
* @param {JSON} json - Object. Default {}.
|
|
* @return {JSON} New object.
|
|
* @example
|
|
*
|
|
* cloneObject({"edad": 23})
|
|
* // => {"edad": 23}
|
|
*
|
|
* cloneObject()
|
|
* // => {}
|
|
*
|
|
*/
|
|
function cloneJSON(json) {
|
|
return JSON.parse(JSON.stringify(json));
|
|
}
|
|
exports.cloneJSON = cloneJSON;
|
|
/**
|
|
* Return random number.
|
|
*
|
|
* @param {number} min - Minimum number. It is inclusive.
|
|
* @param {number} max - Maximum number. It is inclusive.
|
|
* @param {number} decimals - Number of decimals. Default 0.
|
|
* @return {number}
|
|
* @example
|
|
*
|
|
* getRandom(0, 4)
|
|
* // => 3 (Maybe)
|
|
*
|
|
* getRandom(0, 10, 2)
|
|
* // => 8.31 (Maybe)
|
|
*
|
|
*/
|
|
function getRandom(min, max, decimals) {
|
|
if (decimals === void 0) { decimals = 0; }
|
|
var minRandom = Math.ceil(min);
|
|
var maxRandom = Math.floor(max);
|
|
return (Math.random() * (maxRandom - minRandom + 1) + minRandom).toFixed(decimals);
|
|
}
|
|
exports.getRandom = getRandom;
|
|
/**
|
|
* Returns the index of an Array of Files from its name. If there are multiple files with the same name, the last one will be returned.
|
|
* @param {string} name - Name file.
|
|
* @param {Array<File>} list - List of files.
|
|
* @return number
|
|
*/
|
|
function getIndexOfFileList(name, list) {
|
|
return list.reduce(function (position, file, index) { return (file.name === name ? index : position); }, -1);
|
|
}
|
|
exports.getIndexOfFileList = getIndexOfFileList;
|
|
/**
|
|
* Returns a copy of the array by removing one position by index.
|
|
* @param {number} index
|
|
* @param {Array} list
|
|
* @return {Array} list
|
|
* @example
|
|
*
|
|
* deleteArrayElementByIndex(2, ['a', 'b', 'c', 'd'])
|
|
* // => ['a', 'b', 'd']
|
|
*/
|
|
function deleteArrayElementByIndex(index, list) {
|
|
return list.filter(function (item, itemIndex) { return itemIndex !== index; });
|
|
}
|
|
exports.deleteArrayElementByIndex = deleteArrayElementByIndex;
|
|
/**
|
|
* Returns a FileLists from an array containing Files.
|
|
* @param {Array<File>} filesList
|
|
* @return {FileList}
|
|
*/
|
|
function arrayFilesToFileList(filesList) {
|
|
return filesList.reduce(function (dataTransfer, file) {
|
|
dataTransfer.items.add(file);
|
|
return dataTransfer;
|
|
}, new DataTransfer()).files;
|
|
}
|
|
exports.arrayFilesToFileList = arrayFilesToFileList;
|
|
/**
|
|
* Returns a copy of the Array by swapping 2 indices.
|
|
* @param {number} firstIndex
|
|
* @param {number} secondIndex
|
|
* @param {Array<any>} list
|
|
* @example
|
|
*
|
|
* arraySwapIndex(0, 2, ['a', 'b', 'c', 'd'])
|
|
* // => ['c', 'b', 'a', 'd']
|
|
*/
|
|
function arraySwapIndex(firstIndex, secondIndex, list) {
|
|
var tempList = list.slice();
|
|
var tmpFirstPos = tempList[firstIndex];
|
|
tempList[firstIndex] = tempList[secondIndex];
|
|
tempList[secondIndex] = tmpFirstPos;
|
|
return tempList;
|
|
}
|
|
exports.arraySwapIndex = arraySwapIndex;
|
|
/**
|
|
* Returns a File in text.
|
|
* @param {File} file
|
|
* @return {Promise<string>}
|
|
*/
|
|
function encodeFileToText(file) {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
return __generator(this, function (_a) {
|
|
return [2 /*return*/, file.text().then(function (text) {
|
|
return text;
|
|
})];
|
|
});
|
|
});
|
|
}
|
|
exports.encodeFileToText = encodeFileToText;
|
|
/**
|
|
* Returns an Array from the union of 2 Arrays of Files avoiding repetitions.
|
|
* @param {Array<File>} newFiles
|
|
* @param {Array<File>} currentListFiles
|
|
* @return Promise<File[]>
|
|
*/
|
|
function getUniqFiles(newFiles, currentListFiles) {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
return __generator(this, function (_a) {
|
|
return [2 /*return*/, new Promise(function (resolve) {
|
|
Promise.all(newFiles.map(function (inputFile) { return encodeFileToText(inputFile); })).then(function (inputFilesText) {
|
|
// Check all the files to save
|
|
Promise.all(currentListFiles.map(function (savedFile) { return encodeFileToText(savedFile); })).then(function (savedFilesText) {
|
|
var newFileList = currentListFiles;
|
|
inputFilesText.forEach(function (inputFileText, index) {
|
|
if (!savedFilesText.includes(inputFileText)) {
|
|
newFileList = newFileList.concat(newFiles[index]);
|
|
}
|
|
});
|
|
resolve(newFileList);
|
|
});
|
|
});
|
|
})];
|
|
});
|
|
});
|
|
}
|
|
exports.getUniqFiles = getUniqFiles;
|