@teselagen/range-utils 0.3.6 → 0.3.8
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +94 -0
- package/flipContainedRange.d.ts +1 -1
- package/index.js +233 -85
- package/index.mjs +233 -85
- package/index.umd.js +233 -85
- package/package.json +1 -2
- package/src/adjustRangeToDeletionOfAnotherRange.test.js +166 -105
- package/src/adjustRangeToInsert.js +29 -26
- package/src/adjustRangeToInsert.test.js +197 -109
- package/src/adjustRangeToRotation.js +4 -5
- package/src/adjustRangeToRotation.test.js +203 -119
- package/src/checkIfNonCircularRangesOverlap.js +18 -15
- package/src/checkIfNonCircularRangesOverlap.test.js +67 -42
- package/src/checkIfPotentiallyCircularRangesOverlap.js +22 -12
- package/src/checkIfPotentiallyCircularRangesOverlap.test.js +115 -70
- package/src/collapseOverlapsGeneratedFromRangeComparisonIfPossible.js +72 -41
- package/src/collapseOverlapsGeneratedFromRangeComparisonIfPossible.test.js +183 -84
- package/src/convertRangeIndices.js +24 -20
- package/src/convertRangeIndices.test.js +40 -21
- package/src/convertRangeTo0Based.js +7 -4
- package/src/convertRangeTo1Based.js +8 -4
- package/src/doesRangeSpanEntireSequence.js +4 -4
- package/src/doesRangeSpanOrigin.js +3 -3
- package/src/expandOrContractCircularRangeToPosition.js +45 -38
- package/src/expandOrContractNonCircularRangeToPosition.js +24 -21
- package/src/expandOrContractRangeByLength.js +16 -11
- package/src/expandOrContractRangeByLength.test.js +109 -71
- package/src/expandOrContractRangeToPosition.js +17 -9
- package/src/flipContainedRange.js +133 -72
- package/src/flipContainedRange.test.js +143 -117
- package/src/generateRandomRange.js +17 -15
- package/src/generateRandomRange.test.js +21 -21
- package/src/getAnnotationRangeType.js +25 -21
- package/src/getAnnotationRangeType.test.js +56 -57
- package/src/getEachPositionInRangeAsArray.js +13 -13
- package/src/getEachPositionInRangeAsArray.test.js +12 -8
- package/src/getLengthOfOverlappingRegionsBetweenTwoRanges.js +16 -8
- package/src/getLengthOfOverlappingRegionsBetweenTwoRanges.test.js +32 -24
- package/src/getMiddleOfRange.js +1 -1
- package/src/getMiddleOfRange.test.js +5 -13
- package/src/getOverlapOfNonCircularRanges.js +30 -30
- package/src/getOverlapsOfPotentiallyCircularRanges.js +5 -5
- package/src/getOverlapsOfPotentiallyCircularRanges.test.js +3 -23
- package/src/getPositionFromAngle.js +12 -7
- package/src/getRangeAngles.js +1 -1
- package/src/getRangeAngles.test.js +10 -11
- package/src/getRangeLength.test.js +5 -5
- package/src/getRangesBetweenTwoRanges.js +31 -22
- package/src/getSequenceWithinRange.js +13 -13
- package/src/getSequenceWithinRange.test.js +43 -45
- package/src/getShortestDistanceBetweenTwoPositions.js +10 -6
- package/src/getShortestDistanceBetweenTwoPositions.test.js +11 -13
- package/src/getYOffsetForPotentiallyCircularRange.js +33 -21
- package/src/getYOffsetsForPotentiallyCircularRanges.js +26 -19
- package/src/getYOffsetsForPotentiallyCircularRanges.test.js +42 -29
- package/src/getZeroedRangeOverlaps.js +30 -15
- package/src/getZeroedRangeOverlaps.test.js +75 -36
- package/src/index.js +51 -51
- package/src/index.test.js +6 -8
- package/src/invertRange.test.js +103 -93
- package/src/isPositionCloserToRangeStartThanRangeEnd.js +18 -6
- package/src/isPositionCloserToRangeStartThanRangeEnd.test.js +36 -16
- package/src/isPositionWithinRange.js +4 -4
- package/src/isRangeOrPositionWithinRange.js +18 -12
- package/src/isRangeOrPositionWithinRange.test.js +6 -6
- package/src/isRangeWithinRange.js +2 -3
- package/src/loopEachPositionInRange.js +3 -3
- package/src/modulatePositionByRange.js +8 -8
- package/src/modulatePositionByRange.test.js +10 -11
- package/src/modulateRangeBySequenceLength.js +7 -7
- package/src/modulateRangeBySequenceLength.test.js +39 -16
- package/src/normalizePositionByRangeLength.js +22 -18
- package/src/normalizePositionByRangeLength.test.js +23 -23
- package/src/normalizePositionByRangeLength1Based.js +7 -4
- package/src/normalizePositionByRangeLength1Based.test.js +9 -9
- package/src/normalizeRange.js +7 -7
- package/src/normalizeRange.test.js +9 -9
- package/src/provideInclusiveOptions.js +36 -23
- package/src/reversePositionInRange.js +16 -12
- package/src/splitRangeIntoTwoPartsIfItIsCircular.js +31 -28
- package/src/splitRangeIntoTwoPartsIfItIsCircular.test.js +22 -11
- package/src/translateRange.js +18 -8
- package/src/translateRange.test.js +18 -19
- package/src/trimNonCicularRangeByAnotherNonCircularRange.js +45 -42
- package/src/trimNumberToFitWithin0ToAnotherNumber.js +13 -10
- package/src/trimRangeByAnotherRange.js +20 -19
- package/src/trimRangeByAnotherRange.test.js +6 -6
- package/src/zeroSubrangeByContainerRange.js +29 -19
- package/src/zeroSubrangeByContainerRange.test.js +57 -47
package/index.mjs
CHANGED
@@ -6045,8 +6045,8 @@ function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength,
|
|
6045
6045
|
maxRangeLength
|
6046
6046
|
);
|
6047
6047
|
let overlaps = [];
|
6048
|
-
normalizedRangeA.forEach(function(nonCircularRangeA
|
6049
|
-
normalizedRangeB.forEach(function(nonCircularRangeB
|
6048
|
+
normalizedRangeA.forEach(function(nonCircularRangeA) {
|
6049
|
+
normalizedRangeB.forEach(function(nonCircularRangeB) {
|
6050
6050
|
const overlap = getOverlapOfNonCircularRanges(
|
6051
6051
|
nonCircularRangeA,
|
6052
6052
|
nonCircularRangeB
|
@@ -6058,7 +6058,7 @@ function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength,
|
|
6058
6058
|
});
|
6059
6059
|
if (joinIfPossible && normalizedRangeA.length === 2 && normalizedRangeB.length === 2 && maxRangeLength) {
|
6060
6060
|
const joinedOverlap = {};
|
6061
|
-
overlaps = lodashExports.flatMap(overlaps, (o
|
6061
|
+
overlaps = lodashExports.flatMap(overlaps, (o) => {
|
6062
6062
|
if (o.start === 0) {
|
6063
6063
|
joinedOverlap.end = o.end;
|
6064
6064
|
return [];
|
@@ -6156,12 +6156,14 @@ function trimRangeByAnotherRange(rangeToBeTrimmed, trimmingRange, sequenceLength
|
|
6156
6156
|
});
|
6157
6157
|
splitRangesToBeTrimmed[index] = nonCircularRangeToBeTrimmed;
|
6158
6158
|
});
|
6159
|
-
const outputSplitRanges = splitRangesToBeTrimmed.filter(
|
6160
|
-
|
6161
|
-
|
6159
|
+
const outputSplitRanges = splitRangesToBeTrimmed.filter(
|
6160
|
+
function(trimmedRange) {
|
6161
|
+
if (trimmedRange) {
|
6162
|
+
return true;
|
6163
|
+
}
|
6164
|
+
return false;
|
6162
6165
|
}
|
6163
|
-
|
6164
|
-
});
|
6166
|
+
);
|
6165
6167
|
let outputTrimmedRange;
|
6166
6168
|
if (outputSplitRanges.length < 0)
|
6167
6169
|
;
|
@@ -6260,11 +6262,19 @@ function checkIfNonCircularRangesOverlap(range, comparisonRange) {
|
|
6260
6262
|
}
|
6261
6263
|
__name(checkIfNonCircularRangesOverlap, "checkIfNonCircularRangesOverlap");
|
6262
6264
|
function checkIfPotentiallyCircularRangesOverlap(range, comparisonRange) {
|
6263
|
-
return splitRangeIntoTwoPartsIfItIsCircular(range, Infinity).some(
|
6264
|
-
|
6265
|
-
return
|
6266
|
-
|
6267
|
-
|
6265
|
+
return splitRangeIntoTwoPartsIfItIsCircular(range, Infinity).some(
|
6266
|
+
function(splitRange) {
|
6267
|
+
return splitRangeIntoTwoPartsIfItIsCircular(
|
6268
|
+
comparisonRange,
|
6269
|
+
Infinity
|
6270
|
+
).some(function(splitComparisonRange) {
|
6271
|
+
return checkIfNonCircularRangesOverlap(
|
6272
|
+
splitRange,
|
6273
|
+
splitComparisonRange
|
6274
|
+
);
|
6275
|
+
});
|
6276
|
+
}
|
6277
|
+
);
|
6268
6278
|
}
|
6269
6279
|
__name(checkIfPotentiallyCircularRangesOverlap, "checkIfPotentiallyCircularRangesOverlap");
|
6270
6280
|
function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps, sequenceLength, optionalOriginalRange) {
|
@@ -6273,15 +6283,19 @@ function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps, sequen
|
|
6273
6283
|
return overlaps;
|
6274
6284
|
} else if (overlaps.length === 2) {
|
6275
6285
|
if (overlaps[0].start === 0 && overlaps[1].end + 1 === sequenceLength && !originalRangeLinear) {
|
6276
|
-
return [
|
6277
|
-
|
6278
|
-
|
6279
|
-
|
6286
|
+
return [
|
6287
|
+
{
|
6288
|
+
start: overlaps[1].start,
|
6289
|
+
end: overlaps[0].end
|
6290
|
+
}
|
6291
|
+
];
|
6280
6292
|
} else if (overlaps[1].start === 0 && overlaps[0].end + 1 === sequenceLength && !originalRangeLinear) {
|
6281
|
-
return [
|
6282
|
-
|
6283
|
-
|
6284
|
-
|
6293
|
+
return [
|
6294
|
+
{
|
6295
|
+
start: overlaps[0].start,
|
6296
|
+
end: overlaps[1].end
|
6297
|
+
}
|
6298
|
+
];
|
6285
6299
|
} else {
|
6286
6300
|
return overlaps;
|
6287
6301
|
}
|
@@ -6289,17 +6303,29 @@ function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps, sequen
|
|
6289
6303
|
const firstOverlap = overlaps[0];
|
6290
6304
|
const secondOverlap = overlaps[1];
|
6291
6305
|
const thirdOverlap = overlaps[2];
|
6292
|
-
let collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
|
6306
|
+
let collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
|
6307
|
+
[firstOverlap, secondOverlap],
|
6308
|
+
sequenceLength,
|
6309
|
+
optionalOriginalRange
|
6310
|
+
);
|
6293
6311
|
if (collapsedOverlaps.length === 1) {
|
6294
6312
|
collapsedOverlaps.push(thirdOverlap);
|
6295
6313
|
return collapsedOverlaps;
|
6296
6314
|
} else {
|
6297
|
-
collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
|
6315
|
+
collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
|
6316
|
+
[firstOverlap, thirdOverlap],
|
6317
|
+
sequenceLength,
|
6318
|
+
optionalOriginalRange
|
6319
|
+
);
|
6298
6320
|
if (collapsedOverlaps.length === 1) {
|
6299
6321
|
collapsedOverlaps.push(secondOverlap);
|
6300
6322
|
return collapsedOverlaps;
|
6301
6323
|
} else {
|
6302
|
-
collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
|
6324
|
+
collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
|
6325
|
+
[secondOverlap, thirdOverlap],
|
6326
|
+
sequenceLength,
|
6327
|
+
optionalOriginalRange
|
6328
|
+
);
|
6303
6329
|
if (collapsedOverlaps.length === 1) {
|
6304
6330
|
collapsedOverlaps.push(firstOverlap);
|
6305
6331
|
return collapsedOverlaps;
|
@@ -6321,11 +6347,18 @@ function convertRangeIndices(range, inputType, outputType) {
|
|
6321
6347
|
}
|
6322
6348
|
__name(convertRangeIndices, "convertRangeIndices");
|
6323
6349
|
function convertRangeTo0Based(range) {
|
6324
|
-
return convertRangeIndices(range, {
|
6350
|
+
return convertRangeIndices(range, {
|
6351
|
+
inclusive1BasedStart: true,
|
6352
|
+
inclusive1BasedEnd: true
|
6353
|
+
});
|
6325
6354
|
}
|
6326
6355
|
__name(convertRangeTo0Based, "convertRangeTo0Based");
|
6327
6356
|
function convertRangeTo1Based(range) {
|
6328
|
-
return convertRangeIndices(
|
6357
|
+
return convertRangeIndices(
|
6358
|
+
range,
|
6359
|
+
{},
|
6360
|
+
{ inclusive1BasedStart: true, inclusive1BasedEnd: true }
|
6361
|
+
);
|
6329
6362
|
}
|
6330
6363
|
__name(convertRangeTo1Based, "convertRangeTo1Based");
|
6331
6364
|
function provideInclusiveOptions(funToWrap) {
|
@@ -6440,7 +6473,11 @@ function expandOrContractCircularRangeToPosition(range, position, maxLength) {
|
|
6440
6473
|
let endMoved = true;
|
6441
6474
|
if (range.end >= position) {
|
6442
6475
|
if (position + maxLength - range.start > range.end - position) {
|
6443
|
-
newRange.end = normalizePositionByRangeLength(
|
6476
|
+
newRange.end = normalizePositionByRangeLength(
|
6477
|
+
position - 1,
|
6478
|
+
maxLength,
|
6479
|
+
false
|
6480
|
+
);
|
6444
6481
|
} else {
|
6445
6482
|
newRange.start = position;
|
6446
6483
|
endMoved = false;
|
@@ -6513,19 +6550,32 @@ function expandOrContractRangeToPosition(range, position, maxLength) {
|
|
6513
6550
|
if (range.start > range.end) {
|
6514
6551
|
return expandOrContractCircularRangeToPosition(range, position, maxLength);
|
6515
6552
|
} else {
|
6516
|
-
return expandOrContractNonCircularRangeToPosition(
|
6553
|
+
return expandOrContractNonCircularRangeToPosition(
|
6554
|
+
range,
|
6555
|
+
position
|
6556
|
+
);
|
6517
6557
|
}
|
6518
6558
|
}
|
6519
6559
|
__name(expandOrContractRangeToPosition, "expandOrContractRangeToPosition");
|
6520
6560
|
function translateRange(rangeToBeAdjusted, translateBy, rangeLength) {
|
6521
6561
|
return lodashExports.assign({}, rangeToBeAdjusted, {
|
6522
|
-
start: normalizePositionByRangeLength(
|
6523
|
-
|
6562
|
+
start: normalizePositionByRangeLength(
|
6563
|
+
rangeToBeAdjusted.start + translateBy,
|
6564
|
+
rangeLength
|
6565
|
+
),
|
6566
|
+
end: normalizePositionByRangeLength(
|
6567
|
+
rangeToBeAdjusted.end + translateBy,
|
6568
|
+
rangeLength
|
6569
|
+
)
|
6524
6570
|
});
|
6525
6571
|
}
|
6526
6572
|
__name(translateRange, "translateRange");
|
6527
|
-
function flipRelativeRange(innerRange, outerRange, sequenceLength
|
6528
|
-
const isFullyContained = isRangeWithinRange(
|
6573
|
+
function flipRelativeRange(innerRange, outerRange, sequenceLength) {
|
6574
|
+
const isFullyContained = isRangeWithinRange(
|
6575
|
+
innerRange,
|
6576
|
+
outerRange,
|
6577
|
+
sequenceLength
|
6578
|
+
);
|
6529
6579
|
if (isFullyContained) {
|
6530
6580
|
return flipFullyContainedRange(innerRange, outerRange, sequenceLength);
|
6531
6581
|
} else {
|
@@ -6533,42 +6583,92 @@ function flipRelativeRange(innerRange, outerRange, sequenceLength, options) {
|
|
6533
6583
|
}
|
6534
6584
|
}
|
6535
6585
|
__name(flipRelativeRange, "flipRelativeRange");
|
6536
|
-
function flipNonFullyContainedRange(innerRange, outerRange, sequenceLength
|
6537
|
-
const outerFullyContained = isRangeWithinRange(
|
6586
|
+
function flipNonFullyContainedRange(innerRange, outerRange, sequenceLength) {
|
6587
|
+
const outerFullyContained = isRangeWithinRange(
|
6588
|
+
outerRange,
|
6589
|
+
innerRange,
|
6590
|
+
sequenceLength
|
6591
|
+
);
|
6538
6592
|
let flippedInnerRange;
|
6539
6593
|
if (outerFullyContained) {
|
6540
|
-
const expandBy1 = getRangeLength(
|
6541
|
-
|
6542
|
-
|
6543
|
-
|
6544
|
-
|
6545
|
-
|
6546
|
-
|
6547
|
-
|
6548
|
-
|
6549
|
-
|
6594
|
+
const expandBy1 = getRangeLength(
|
6595
|
+
{
|
6596
|
+
start: innerRange.start,
|
6597
|
+
end: outerRange.start
|
6598
|
+
},
|
6599
|
+
sequenceLength
|
6600
|
+
) - 1;
|
6601
|
+
flippedInnerRange = expandOrContractRangeByLength(
|
6602
|
+
outerRange,
|
6603
|
+
expandBy1,
|
6604
|
+
false,
|
6605
|
+
sequenceLength
|
6606
|
+
);
|
6607
|
+
const expandBy2 = getRangeLength(
|
6608
|
+
{
|
6609
|
+
end: innerRange.end,
|
6610
|
+
start: outerRange.end
|
6611
|
+
},
|
6612
|
+
sequenceLength
|
6613
|
+
) - 1;
|
6614
|
+
flippedInnerRange = expandOrContractRangeByLength(
|
6615
|
+
flippedInnerRange,
|
6616
|
+
expandBy2,
|
6617
|
+
true,
|
6618
|
+
sequenceLength
|
6619
|
+
);
|
6550
6620
|
} else {
|
6551
|
-
const overlaps = getOverlapsOfPotentiallyCircularRanges(
|
6621
|
+
const overlaps = getOverlapsOfPotentiallyCircularRanges(
|
6622
|
+
innerRange,
|
6623
|
+
outerRange,
|
6624
|
+
sequenceLength
|
6625
|
+
);
|
6552
6626
|
if (overlaps.length >= 1) {
|
6553
|
-
let overlapExtendsForward;
|
6554
6627
|
const firstOverlap = overlaps[0];
|
6555
|
-
overlapExtendsForward = firstOverlap.start !== outerRange.start;
|
6556
|
-
const flippedTruncatedInner = flipFullyContainedRange(
|
6628
|
+
const overlapExtendsForward = firstOverlap.start !== outerRange.start;
|
6629
|
+
const flippedTruncatedInner = flipFullyContainedRange(
|
6630
|
+
firstOverlap,
|
6631
|
+
outerRange,
|
6632
|
+
sequenceLength
|
6633
|
+
);
|
6557
6634
|
const lengthToExtend = getRangeLength(innerRange, sequenceLength) - getRangeLength(flippedTruncatedInner, sequenceLength);
|
6558
|
-
flippedInnerRange = expandOrContractRangeByLength(
|
6635
|
+
flippedInnerRange = expandOrContractRangeByLength(
|
6636
|
+
flippedTruncatedInner,
|
6637
|
+
lengthToExtend,
|
6638
|
+
overlapExtendsForward,
|
6639
|
+
sequenceLength
|
6640
|
+
);
|
6559
6641
|
} else {
|
6560
|
-
throw new Error(
|
6642
|
+
throw new Error(
|
6643
|
+
"This case (relative ranges that do not overlap) is unsupported! "
|
6644
|
+
);
|
6561
6645
|
}
|
6562
6646
|
}
|
6563
6647
|
return flippedInnerRange;
|
6564
6648
|
}
|
6565
6649
|
__name(flipNonFullyContainedRange, "flipNonFullyContainedRange");
|
6566
|
-
function flipFullyContainedRange(innerRange, outerRange, sequenceLength
|
6650
|
+
function flipFullyContainedRange(innerRange, outerRange, sequenceLength) {
|
6567
6651
|
const translateBy = -outerRange.start;
|
6568
|
-
const translatedOuterRange = translateRange(
|
6569
|
-
|
6570
|
-
|
6571
|
-
|
6652
|
+
const translatedOuterRange = translateRange(
|
6653
|
+
outerRange,
|
6654
|
+
translateBy,
|
6655
|
+
sequenceLength
|
6656
|
+
);
|
6657
|
+
const translatedInnerRange = translateRange(
|
6658
|
+
innerRange,
|
6659
|
+
translateBy,
|
6660
|
+
sequenceLength
|
6661
|
+
);
|
6662
|
+
const translatedFlippedInnerRange = flipNonOriginSpanningContainedRange(
|
6663
|
+
translatedInnerRange,
|
6664
|
+
translatedOuterRange,
|
6665
|
+
sequenceLength
|
6666
|
+
);
|
6667
|
+
const flippedInnerRange = translateRange(
|
6668
|
+
translatedFlippedInnerRange,
|
6669
|
+
-translateBy,
|
6670
|
+
sequenceLength
|
6671
|
+
);
|
6572
6672
|
return flippedInnerRange;
|
6573
6673
|
}
|
6574
6674
|
__name(flipFullyContainedRange, "flipFullyContainedRange");
|
@@ -6586,7 +6686,10 @@ function generateRandomRange(minStart, maxEnd, maxLength) {
|
|
6586
6686
|
const start = getRandomInt(minStart, maxEnd);
|
6587
6687
|
let end;
|
6588
6688
|
if (maxLength) {
|
6589
|
-
end = normalizePositionByRangeLength(
|
6689
|
+
end = normalizePositionByRangeLength(
|
6690
|
+
getRandomInt(start, start + maxLength),
|
6691
|
+
maxEnd
|
6692
|
+
);
|
6590
6693
|
} else {
|
6591
6694
|
end = getRandomInt(minStart, maxEnd);
|
6592
6695
|
}
|
@@ -6638,7 +6741,11 @@ function getEachPositionInRangeAsArray(range, rangeMax) {
|
|
6638
6741
|
}
|
6639
6742
|
__name(getEachPositionInRangeAsArray, "getEachPositionInRangeAsArray");
|
6640
6743
|
function getLengthOfOverlappingRegionsBetweenTwoRanges(rangeA, rangeB, maxLength) {
|
6641
|
-
const overlaps = getOverlapsOfPotentiallyCircularRanges(
|
6744
|
+
const overlaps = getOverlapsOfPotentiallyCircularRanges(
|
6745
|
+
rangeA,
|
6746
|
+
rangeB,
|
6747
|
+
maxLength
|
6748
|
+
);
|
6642
6749
|
return overlaps.reduce(function(counter, overlap) {
|
6643
6750
|
return counter + getRangeLength(overlap, maxLength);
|
6644
6751
|
}, 0);
|
@@ -6691,13 +6798,16 @@ function getRangesBetweenTwoRanges(range1, range2) {
|
|
6691
6798
|
if (!(range1.start > -1 && range1.end > -1 && range2.start > -1 && range2.end > -1)) {
|
6692
6799
|
return newRanges;
|
6693
6800
|
}
|
6694
|
-
return [
|
6695
|
-
|
6696
|
-
|
6697
|
-
|
6698
|
-
|
6699
|
-
|
6700
|
-
|
6801
|
+
return [
|
6802
|
+
{
|
6803
|
+
start: range1.start,
|
6804
|
+
end: range2.end
|
6805
|
+
},
|
6806
|
+
{
|
6807
|
+
start: range2.start,
|
6808
|
+
end: range1.end
|
6809
|
+
}
|
6810
|
+
];
|
6701
6811
|
}
|
6702
6812
|
__name(getRangesBetweenTwoRanges, "getRangesBetweenTwoRanges");
|
6703
6813
|
function getSequenceWithinRange(range, sequence) {
|
@@ -6729,18 +6839,26 @@ function getShortestDistanceBetweenTwoPositions(position1, position2, sequenceLe
|
|
6729
6839
|
__name(getShortestDistanceBetweenTwoPositions, "getShortestDistanceBetweenTwoPositions");
|
6730
6840
|
function getYOffsetForPotentiallyCircularRange(range, YOffsetLevelsWithRanges, assignYOffsetToRange) {
|
6731
6841
|
let yOffset = [];
|
6732
|
-
const openYOffsetFound = YOffsetLevelsWithRanges.some(
|
6733
|
-
|
6734
|
-
|
6735
|
-
|
6736
|
-
|
6737
|
-
|
6738
|
-
|
6739
|
-
|
6740
|
-
|
6741
|
-
|
6842
|
+
const openYOffsetFound = YOffsetLevelsWithRanges.some(
|
6843
|
+
function(rangesAlreadyAddedToYOffset, index) {
|
6844
|
+
const rangeBlocked = rangesAlreadyAddedToYOffset.some(
|
6845
|
+
function(comparisonRange) {
|
6846
|
+
return checkIfPotentiallyCircularRangesOverlap(
|
6847
|
+
range,
|
6848
|
+
comparisonRange
|
6849
|
+
);
|
6850
|
+
}
|
6851
|
+
);
|
6852
|
+
if (!rangeBlocked) {
|
6853
|
+
yOffset = index;
|
6854
|
+
if (assignYOffsetToRange)
|
6855
|
+
range.yOffset = index;
|
6856
|
+
rangesAlreadyAddedToYOffset.push(range);
|
6857
|
+
return true;
|
6858
|
+
}
|
6859
|
+
return false;
|
6742
6860
|
}
|
6743
|
-
|
6861
|
+
);
|
6744
6862
|
if (!openYOffsetFound) {
|
6745
6863
|
yOffset = YOffsetLevelsWithRanges.length;
|
6746
6864
|
if (assignYOffsetToRange)
|
@@ -6754,7 +6872,11 @@ function getYOffsetsForPotentiallyCircularRanges(ranges, assignYOffsetToRange) {
|
|
6754
6872
|
let maxYOffset = 0;
|
6755
6873
|
const yOffsetLevels = [];
|
6756
6874
|
ranges.forEach(function(range) {
|
6757
|
-
const yOffset = getYOffsetForPotentiallyCircularRange(
|
6875
|
+
const yOffset = getYOffsetForPotentiallyCircularRange(
|
6876
|
+
range,
|
6877
|
+
yOffsetLevels,
|
6878
|
+
assignYOffsetToRange
|
6879
|
+
);
|
6758
6880
|
yOffsets.push(yOffset);
|
6759
6881
|
if (yOffset > maxYOffset) {
|
6760
6882
|
maxYOffset = yOffset;
|
@@ -6787,8 +6909,16 @@ function invertRange$1(rangeOrCaret, rangeMax) {
|
|
6787
6909
|
}
|
6788
6910
|
__name(invertRange$1, "invertRange$1");
|
6789
6911
|
function isPositionCloserToRangeStartThanRangeEnd(position, range, maxLength) {
|
6790
|
-
const distanceFromStart = getShortestDistanceBetweenTwoPositions(
|
6791
|
-
|
6912
|
+
const distanceFromStart = getShortestDistanceBetweenTwoPositions(
|
6913
|
+
range.start,
|
6914
|
+
position,
|
6915
|
+
maxLength
|
6916
|
+
);
|
6917
|
+
const distanceFromEnd = getShortestDistanceBetweenTwoPositions(
|
6918
|
+
range.end,
|
6919
|
+
position,
|
6920
|
+
maxLength
|
6921
|
+
);
|
6792
6922
|
return distanceFromStart <= distanceFromEnd;
|
6793
6923
|
}
|
6794
6924
|
__name(isPositionCloserToRangeStartThanRangeEnd, "isPositionCloserToRangeStartThanRangeEnd");
|
@@ -6833,9 +6963,15 @@ function trimNumberToFitWithin0ToAnotherNumber(numberToBeTrimmed, max) {
|
|
6833
6963
|
}
|
6834
6964
|
__name(trimNumberToFitWithin0ToAnotherNumber, "trimNumberToFitWithin0ToAnotherNumber");
|
6835
6965
|
function zeroSubrangeByContainerRange(subRange, containerRange, sequenceLength) {
|
6836
|
-
const trimmedSubRange = trimRangeByAnotherRange(
|
6966
|
+
const trimmedSubRange = trimRangeByAnotherRange(
|
6967
|
+
subRange,
|
6968
|
+
containerRange,
|
6969
|
+
sequenceLength
|
6970
|
+
);
|
6837
6971
|
if (trimmedSubRange) {
|
6838
|
-
throw new Error(
|
6972
|
+
throw new Error(
|
6973
|
+
"subRange must be fully contained by containerRange! Otherwise this function does not make sense"
|
6974
|
+
);
|
6839
6975
|
}
|
6840
6976
|
const newSubrange = {};
|
6841
6977
|
newSubrange.start = subRange.start - containerRange.start;
|
@@ -6863,12 +6999,24 @@ function modulo(n, m) {
|
|
6863
6999
|
}
|
6864
7000
|
__name(modulo, "modulo");
|
6865
7001
|
function getZeroedRangeOverlaps(annotation, selection, sequenceLength) {
|
6866
|
-
const overlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
|
7002
|
+
const overlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
|
7003
|
+
getOverlapsOfPotentiallyCircularRanges(
|
7004
|
+
annotation,
|
7005
|
+
selection,
|
7006
|
+
sequenceLength
|
7007
|
+
),
|
7008
|
+
sequenceLength,
|
7009
|
+
annotation
|
7010
|
+
);
|
6867
7011
|
const zeroedOverlaps = overlaps.map((overlap) => {
|
6868
|
-
return zeroSubrangeByContainerRange(
|
6869
|
-
|
6870
|
-
|
6871
|
-
|
7012
|
+
return zeroSubrangeByContainerRange(
|
7013
|
+
overlap,
|
7014
|
+
{
|
7015
|
+
start: selection.start,
|
7016
|
+
end: normalizePositionByRangeLength(selection.start - 1, sequenceLength)
|
7017
|
+
},
|
7018
|
+
sequenceLength
|
7019
|
+
);
|
6872
7020
|
});
|
6873
7021
|
return zeroedOverlaps;
|
6874
7022
|
}
|