feat: add extra properties on complement and substract

Author: Draeken

lib/lib.test.ts

@@ -271,6 +271,16 @@ test('will substract two arrays', t => {
   testFnToIntervals(base, mask, substract, testOutputFn, t);
 });
 
+test('substract will keep extra properties from base', t => {
+  const base = [{ start: 0, end: 10, test: 'foo' }, { start: 12, end: 20, test: 'bar' }];
+  const mask = [{ start: 1, end: 3 }, { start: 8, end: 13 }, { start: 18, end: 22 }];
+  const res = substract(base, mask);
+  t.true(res.length === 3);
+  t.true(res[0].start === 0 && res[0].end === 1 && res[0].test === 'foo');
+  t.true(res[1].start === 3 && res[1].end === 8 && res[1].test === 'foo');
+  t.true(res[2].start === 13 && res[2].end === 18 && res[2].test === 'bar');
+});
+
 test('will return complement', t => {
   const intervals = [{ start: 1, end: 2 }, { start: 5, end: 7 }, { start: 6, end: 8 }];
   const boundaries = { start: 0, end: 10 };
@@ -283,6 +293,16 @@ test('will return complement', t => {
   testFnToIntervals(boundaries, intervals, complement, testOutputFn, t);
 });
 
+test('complement will keep additional properties from boundaries', t => {
+  const intervals = [{ start: 1, end: 2 }, { start: 5, end: 7 }, { start: 6, end: 8 }];
+  const boundaries = { start: 0, end: 10, test: 'foo' };
+  const res = complement(boundaries, intervals);
+  t.true(res.length === 3);
+  t.true(res[0].start === 0 && res[0].end === 1 && res[0].test === 'foo');
+  t.true(res[1].start === 2 && res[1].end === 5 && res[0].test === 'foo');
+  t.true(res[2].start === 8 && res[2].end === 10 && res[0].test === 'foo');
+});
+
 test('will return complement when boundaries are included in intervals', t => {
   const intervals = [{ start: 1, end: 2 }, { start: 5, end: 7 }, { start: 6, end: 8 }];
   const boundaries = { start: 2, end: 6 };
@@ -404,10 +424,10 @@ test('will intersect an interval and an array', t => {
 
 test('intersection will not simplify', t => {
   const r1 = [{ start: 1, end: 5 }];
-  const r2 = [{ start: 1, end: 2 }, { start: 2, end: 5 }];
+  const r2 = [{ start: 1, end: 3 }, { start: 2, end: 5 }];
   const testOutputFn = (res: IntervalSE[]): void => {
     t.true(res.length === 2);
-    t.true(res[0].start === 1 && res[0].end === 2);
+    t.true(res[0].start === 1 && res[0].end === 3);
     t.true(res[1].start === 2 && res[1].end === 5);
   };
   testFnToIntervals(r1, r2, intersect, testOutputFn, t);
@@ -431,3 +451,13 @@ test('intersection will keep object properties when truncated', t => {
   t.true(res[0].test === 'bar');
   t.true(res[1].test === 'baz');
 });
+
+test('will trash empty interval', t => {
+  const r1 = [{ start: 0, end: 5, test: 'foo' }, { start: 8, end: 10, test: 'bar' }];
+  const r2 = { start: 6, end: 9 };
+  const res = intersect(r2, r1);
+  t.is(res.length, 1);
+  t.is(res[0].start, 8);
+  t.is(res[0].end, 9);
+  t.is(res[0].test, 'bar');
+});

lib/lib.ts

@@ -85,32 +85,33 @@ const prepareInput = (typeStr: string, i: interval | roai): IntervalSE[] => {
 
 const complementGen = (boundaries: IntervalSE, intervals: IntervalSE[]): IntervalSE[] => {
   const intervalsS = sortByStart(intervals);
+  const { start, end, ...rest} = boundaries;
   const prepRanges: IntervalSE[] = [
-    { start: -Infinity, end: boundaries.start },
+    { start: -Infinity, end: start },
     ...intervalsS,
-    { start: boundaries.end, end: Infinity },
+    { start: end, end: Infinity },
   ];
   return reject<IntervalSE | null>(
     isNil,
     aperture(2, prepRanges).map(
-      ([r1, r2]) => (r1.end >= r2.start ? null : { start: r1.end, end: r2.start })
+      ([r1, r2]) => (r1.end >= r2.start ? null : { start: r1.end, end: r2.start, ...rest })
     )
   ) as IntervalSE[];
 };
 
-const complementCurry = <T extends interval>(boundaries: interval, intervals: T | T[]): T[] => {
+const complementCurry = <D extends interval, T extends interval>(boundaries: D, intervals: T | T[]): D[] => {
   if (Array.isArray(intervals) && intervals.length < 1) {
-    return [boundaries] as T[];
+    return [boundaries] as D[];
   }
-  const typeStr = getType(intervals);
+  const typeStr = getType(boundaries);
   const intervalSE = prepareInput(typeStr, intervals);
   const boundariesSE = convertFrom(getType(boundaries))(boundaries);
-  return complementGen(boundariesSE, intervalSE).map(convertTo<T>(typeStr));
+  return complementGen(boundariesSE, intervalSE).map(convertTo<D>(typeStr));
 };
 
 /**
  * Complement of `intervals` bounded to `boundaries`. Convert space between two consecutive intervals into interval.
- *
+ * Keeps extra object properties on `boundaries`.
  * Curried function. Accept array of intervals. Doesn't mutate input. Output keeps input's structure.
  *
  * boundaries | interval(s) | result
@@ -122,16 +123,16 @@ const complementCurry = <T extends interval>(boundaries: interval, intervals: T
  * @param intervals arg2: one interval or array of intervals that complement the result.
  * @returns array of intervals.
  */
-export function complement<T extends interval>(boundaries: interval, interv: T | roat<T>): T[];
-export function complement<T extends interval>(boundaries: interval): (interv: T | roat<T>) => T[];
-export function complement<T extends interval>(boundaries: interval, interv?: T | roat<T>): any {
+export function complement<D extends interval, T extends interval>(boundaries: D, interv: T | roat<T>): D[];
+export function complement<D extends interval, T extends interval>(boundaries: D): (interv: T | roat<T>) => D[];
+export function complement<D extends interval, T extends interval>(boundaries: D, interv?: T | roat<T>): any {
   switch (arguments.length) {
     case 1:
-      return (tt2: T | T[]): T[] => {
-        return complementCurry<T>(boundaries, tt2);
+      return (tt2: T | T[]): D[] => {
+        return complementCurry<D, T>(boundaries, tt2);
       };
     case 2:
-      return complementCurry<T>(boundaries, interv as T | T[]);
+      return complementCurry<D, T>(boundaries, interv as T | T[]);
   }
 }
 
@@ -634,14 +635,15 @@ const subtractInter = (mask: IntervalSE[], base: IntervalSE): IntervalSE[] => {
 };
 
 const substractGen = (base: IntervalSE[], mask: IntervalSE[]): IntervalSE[] => {
-  const intersection = intersectGen(base, mask);
+  const intersection = intersectGen(mask, base);
   return unnest(
     base.map(b => subtractInter(intersection.filter(isOverlappingSimple.bind(null, b)), b))
   );
 };
 
 /**
  * Subtact `intervalA` with `intervalB`. `intervalB` act as a mask.
+ * Keeps extra object properties on `intervalA`.
  *
  * Curried function. Accept array of intervals. Doesn't mutate input. Output keeps input's structure.
  *
@@ -654,20 +656,20 @@ const substractGen = (base: IntervalSE[], mask: IntervalSE[]): IntervalSE[] => {
  * @param intervalB arg2: one interval or array of intervals
  * @returns intersection of `arg1` and `arg2`
  */
-export function substract<T extends interval>(intervalA: T | roat<T>, intervalB: T | roat<T>): T[];
-export function substract<T extends interval>(
-  intervalA: T | roat<T>
-): (intervalB: T | roat<T>) => T[];
-export function substract<T extends interval>(
-  intervalA: T | roat<T>,
+export function substract<D extends interval, T extends interval>(intervalA: D | roat<D>, intervalB: T | roat<T>): D[];
+export function substract<D extends interval, T extends interval>(
+  intervalA: D | roat<D>
+): (intervalB: T | roat<T>) => D[];
+export function substract<D extends interval, T extends interval>(
+  intervalA: D | roat<D>,
   intervalB?: T | roat<T>
 ): any {
   switch (arguments.length) {
     case 1:
-      return (tt2: T | T[]): T[] => {
-        return setupForTwoIntsToInts<T>(substractGen)(intervalA, tt2);
+      return (tt2: T | T[]): D[] => {
+        return setupForTwoIntsToInts<D>(substractGen)(intervalA, tt2 as any);
       };
     case 2:
-      return setupForTwoIntsToInts<T>(substractGen)(intervalA, intervalB as T | T[]);
+      return setupForTwoIntsToInts<D>(substractGen)(intervalA, intervalB as any);
   }
 }