diff options
Diffstat (limited to 'alarm/node_modules/ranges-apply/dist/ranges-apply.dev.umd.js')
| -rw-r--r-- | alarm/node_modules/ranges-apply/dist/ranges-apply.dev.umd.js | 294 |
1 files changed, 294 insertions, 0 deletions
diff --git a/alarm/node_modules/ranges-apply/dist/ranges-apply.dev.umd.js b/alarm/node_modules/ranges-apply/dist/ranges-apply.dev.umd.js new file mode 100644 index 0000000..03cc17b --- /dev/null +++ b/alarm/node_modules/ranges-apply/dist/ranges-apply.dev.umd.js @@ -0,0 +1,294 @@ +/** + * @name ranges-apply + * @fileoverview Take an array of string index ranges, delete/replace the string according to them + * @version 5.1.0 + * @author Roy Revelt, Codsen Ltd + * @license MIT + * {@link https://codsen.com/os/ranges-apply/} + */ + +(function (global, factory) { +typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : +typeof define === 'function' && define.amd ? define(['exports'], factory) : +(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.rangesApply = {})); +}(this, (function (exports) { 'use strict'; + +/** + * @name ranges-sort + * @fileoverview Sort string index ranges + * @version 4.1.0 + * @author Roy Revelt, Codsen Ltd + * @license MIT + * {@link https://codsen.com/os/ranges-sort/} + */ +const defaults$1 = { + strictlyTwoElementsInRangeArrays: false, + progressFn: null +}; +function rSort(arrOfRanges, originalOptions) { + if (!Array.isArray(arrOfRanges) || !arrOfRanges.length) { + return arrOfRanges; + } + const opts = { ...defaults$1, + ...originalOptions + }; + let culpritsIndex; + let culpritsLen; + if (opts.strictlyTwoElementsInRangeArrays && !arrOfRanges.filter(range => range).every((rangeArr, indx) => { + if (rangeArr.length !== 2) { + culpritsIndex = indx; + culpritsLen = rangeArr.length; + return false; + } + return true; + })) { + throw new TypeError(`ranges-sort: [THROW_ID_03] The first argument should be an array and must consist of arrays which are natural number indexes representing TWO string index ranges. However, ${culpritsIndex}th range (${JSON.stringify(arrOfRanges[culpritsIndex], null, 4)}) has not two but ${culpritsLen} elements!`); + } + if (!arrOfRanges.filter(range => range).every((rangeArr, indx) => { + if (!Number.isInteger(rangeArr[0]) || rangeArr[0] < 0 || !Number.isInteger(rangeArr[1]) || rangeArr[1] < 0) { + culpritsIndex = indx; + return false; + } + return true; + })) { + throw new TypeError(`ranges-sort: [THROW_ID_04] The first argument should be an array and must consist of arrays which are natural number indexes representing string index ranges. However, ${culpritsIndex}th range (${JSON.stringify(arrOfRanges[culpritsIndex], null, 4)}) does not consist of only natural numbers!`); + } + const maxPossibleIterations = arrOfRanges.filter(range => range).length ** 2; + let counter = 0; + return Array.from(arrOfRanges).filter(range => range).sort((range1, range2) => { + if (opts.progressFn) { + counter += 1; + opts.progressFn(Math.floor(counter * 100 / maxPossibleIterations)); + } + if (range1[0] === range2[0]) { + if (range1[1] < range2[1]) { + return -1; + } + if (range1[1] > range2[1]) { + return 1; + } + return 0; + } + if (range1[0] < range2[0]) { + return -1; + } + return 1; + }); +} + +/** + * @name ranges-merge + * @fileoverview Merge and sort string index ranges + * @version 7.1.0 + * @author Roy Revelt, Codsen Ltd + * @license MIT + * {@link https://codsen.com/os/ranges-merge/} + */ +const defaults = { + mergeType: 1, + progressFn: null, + joinRangesThatTouchEdges: true +}; +function rMerge(arrOfRanges, originalOpts) { + function isObj(something) { + return something && typeof something === "object" && !Array.isArray(something); + } + if (!Array.isArray(arrOfRanges) || !arrOfRanges.length) { + return null; + } + let opts; + if (originalOpts) { + if (isObj(originalOpts)) { + opts = { ...defaults, + ...originalOpts + }; + if (opts.progressFn && isObj(opts.progressFn) && !Object.keys(opts.progressFn).length) { + opts.progressFn = null; + } else if (opts.progressFn && typeof opts.progressFn !== "function") { + throw new Error(`ranges-merge: [THROW_ID_01] opts.progressFn must be a function! It was given of a type: "${typeof opts.progressFn}", equal to ${JSON.stringify(opts.progressFn, null, 4)}`); + } + if (opts.mergeType && +opts.mergeType !== 1 && +opts.mergeType !== 2) { + throw new Error(`ranges-merge: [THROW_ID_02] opts.mergeType was customised to a wrong thing! It was given of a type: "${typeof opts.mergeType}", equal to ${JSON.stringify(opts.mergeType, null, 4)}`); + } + if (typeof opts.joinRangesThatTouchEdges !== "boolean") { + throw new Error(`ranges-merge: [THROW_ID_04] opts.joinRangesThatTouchEdges was customised to a wrong thing! It was given of a type: "${typeof opts.joinRangesThatTouchEdges}", equal to ${JSON.stringify(opts.joinRangesThatTouchEdges, null, 4)}`); + } + } else { + throw new Error(`emlint: [THROW_ID_03] the second input argument must be a plain object. It was given as:\n${JSON.stringify(originalOpts, null, 4)} (type ${typeof originalOpts})`); + } + } else { + opts = { ...defaults + }; + } + const filtered = arrOfRanges + .filter(range => range).map(subarr => [...subarr]).filter( + rangeArr => rangeArr[2] !== undefined || rangeArr[0] !== rangeArr[1]); + let sortedRanges; + let lastPercentageDone; + let percentageDone; + if (opts.progressFn) { + sortedRanges = rSort(filtered, { + progressFn: percentage => { + percentageDone = Math.floor(percentage / 5); + if (percentageDone !== lastPercentageDone) { + lastPercentageDone = percentageDone; + opts.progressFn(percentageDone); + } + } + }); + } else { + sortedRanges = rSort(filtered); + } + if (!sortedRanges) { + return null; + } + const len = sortedRanges.length - 1; + for (let i = len; i > 0; i--) { + if (opts.progressFn) { + percentageDone = Math.floor((1 - i / len) * 78) + 21; + if (percentageDone !== lastPercentageDone && percentageDone > lastPercentageDone) { + lastPercentageDone = percentageDone; + opts.progressFn(percentageDone); + } + } + if (sortedRanges[i][0] <= sortedRanges[i - 1][0] || !opts.joinRangesThatTouchEdges && sortedRanges[i][0] < sortedRanges[i - 1][1] || opts.joinRangesThatTouchEdges && sortedRanges[i][0] <= sortedRanges[i - 1][1]) { + sortedRanges[i - 1][0] = Math.min(sortedRanges[i][0], sortedRanges[i - 1][0]); + sortedRanges[i - 1][1] = Math.max(sortedRanges[i][1], sortedRanges[i - 1][1]); + if (sortedRanges[i][2] !== undefined && (sortedRanges[i - 1][0] >= sortedRanges[i][0] || sortedRanges[i - 1][1] <= sortedRanges[i][1])) { + if (sortedRanges[i - 1][2] !== null) { + if (sortedRanges[i][2] === null && sortedRanges[i - 1][2] !== null) { + sortedRanges[i - 1][2] = null; + } else if (sortedRanges[i - 1][2] != null) { + if (+opts.mergeType === 2 && sortedRanges[i - 1][0] === sortedRanges[i][0]) { + sortedRanges[i - 1][2] = sortedRanges[i][2]; + } else { + sortedRanges[i - 1][2] += sortedRanges[i][2]; + } + } else { + sortedRanges[i - 1][2] = sortedRanges[i][2]; + } + } + } + sortedRanges.splice(i, 1); + i = sortedRanges.length; + } + } + return sortedRanges.length ? sortedRanges : null; +} + +var version$1 = "5.1.0"; + +const version = version$1; +function rApply(str, originalRangesArr, progressFn) { + let percentageDone = 0; + let lastPercentageDone = 0; + if (arguments.length === 0) { + throw new Error("ranges-apply: [THROW_ID_01] inputs missing!"); + } + if (typeof str !== "string") { + throw new TypeError(`ranges-apply: [THROW_ID_02] first input argument must be a string! Currently it's: ${typeof str}, equal to: ${JSON.stringify(str, null, 4)}`); + } + if (originalRangesArr && !Array.isArray(originalRangesArr)) { + throw new TypeError(`ranges-apply: [THROW_ID_03] second input argument must be an array (or null)! Currently it's: ${typeof originalRangesArr}, equal to: ${JSON.stringify(originalRangesArr, null, 4)}`); + } + if (progressFn && typeof progressFn !== "function") { + throw new TypeError(`ranges-apply: [THROW_ID_04] the third input argument must be a function (or falsey)! Currently it's: ${typeof progressFn}, equal to: ${JSON.stringify(progressFn, null, 4)}`); + } + if (!originalRangesArr || + !originalRangesArr.filter((range) => range).length) { + // quick ending - no ranges passed + return str; + } + let rangesArr; + if (Array.isArray(originalRangesArr) && + Number.isInteger(originalRangesArr[0]) && + Number.isInteger(originalRangesArr[1])) { + // if single array was passed, wrap it into an array + rangesArr = [Array.from(originalRangesArr)]; + } + else { + rangesArr = Array.from(originalRangesArr); + } + // allocate first 10% of progress to this stage + const len = rangesArr.length; + let counter = 0; + rangesArr + .filter((range) => range) + .forEach((el, i) => { + if (progressFn) { + percentageDone = Math.floor((counter / len) * 10); + /* istanbul ignore else */ + if (percentageDone !== lastPercentageDone) { + lastPercentageDone = percentageDone; + progressFn(percentageDone); + } + } + if (!Array.isArray(el)) { + throw new TypeError(`ranges-apply: [THROW_ID_05] ranges array, second input arg., has ${i}th element not an array: ${JSON.stringify(el, null, 4)}, which is ${typeof el}`); + } + if (!Number.isInteger(el[0])) { + if (!Number.isInteger(+el[0]) || +el[0] < 0) { + throw new TypeError(`ranges-apply: [THROW_ID_06] ranges array, second input arg. has ${i}th element, array ${JSON.stringify(el, null, 0)}. Its first element is not an integer, string index, but ${typeof el[0]}, equal to: ${JSON.stringify(el[0], null, 4)}.`); + } + else { + rangesArr[i][0] = +rangesArr[i][0]; + } + } + if (!Number.isInteger(el[1])) { + if (!Number.isInteger(+el[1]) || +el[1] < 0) { + throw new TypeError(`ranges-apply: [THROW_ID_07] ranges array, second input arg. has ${i}th element, array ${JSON.stringify(el, null, 0)}. Its second element is not an integer, string index, but ${typeof el[1]}, equal to: ${JSON.stringify(el[1], null, 4)}.`); + } + else { + rangesArr[i][1] = +rangesArr[i][1]; + } + } + counter += 1; + }); + // allocate another 10% of the progress indicator length to the rangesMerge step: + const workingRanges = rMerge(rangesArr, { + progressFn: (perc) => { + if (progressFn) { + // since "perc" is already from zero to hundred, we just divide by 10 and + // get the range from zero to ten: + percentageDone = 10 + Math.floor(perc / 10); + /* istanbul ignore else */ + if (percentageDone !== lastPercentageDone) { + lastPercentageDone = percentageDone; + progressFn(percentageDone); + } + } + }, + }); + // allocate the rest 80% to the actual string assembly: + const len2 = Array.isArray(workingRanges) ? workingRanges.length : 0; + /* istanbul ignore else */ + if (len2 > 0) { + const tails = str.slice(workingRanges[len2 - 1][1]); + // eslint-disable-next-line no-param-reassign + str = workingRanges.reduce((acc, _val, i, arr) => { + if (progressFn) { + // since "perc" is already from zero to hundred, we just divide by 10 and + // get the range from zero to ten: + percentageDone = 20 + Math.floor((i / len2) * 80); + /* istanbul ignore else */ + if (percentageDone !== lastPercentageDone) { + lastPercentageDone = percentageDone; + progressFn(percentageDone); + } + } + const beginning = i === 0 ? 0 : arr[i - 1][1]; + const ending = arr[i][0]; + return acc + str.slice(beginning, ending) + (arr[i][2] || ""); + }, ""); + // eslint-disable-next-line no-param-reassign + str += tails; + } + return str; +} + +exports.rApply = rApply; +exports.version = version; + +Object.defineProperty(exports, '__esModule', { value: true }); + +}))); |