Caret functions now return the index that was inserted, also removed the direction type variable

Author: CMCDragonkai

lib/ArrayFixed.js

@@ -212,7 +212,7 @@ class ArrayFixed<item> {
     return;
   }
 
-  caretLeft (index: number, value: item): void {
+  caretLeft (index: number, value: item): number {
     if (index >= this._array.length || index < 0) {
       throw new RangeError('Out of range index');
     }
@@ -222,7 +222,7 @@ class ArrayFixed<item> {
     if (!this._array.hasOwnProperty(index)) {
       this._array[index] = value;
       ++this._count;
-      return;
+      return index;
     }
     let emptyIndex = null;
     for (let i = index - 1; i >= 0; --i) {
@@ -237,10 +237,10 @@ class ArrayFixed<item> {
     this._array.copyWithin(emptyIndex, emptyIndex + 1, index + 1);
     this._array[index] = value;
     ++this._count;
-    return;
+    return index;
   }
 
-  caretRight (index: number, value: item) {
+  caretRight (index: number, value: item): number {
     if (index >= this._array.length || index < 0) {
       throw new RangeError('Out of range index');
     }
@@ -250,7 +250,7 @@ class ArrayFixed<item> {
     if (!this._array.hasOwnProperty(index)) {
       this._array[index] = value;
       ++this._count;
-      return;
+      return index;
     }
     let emptyIndex = null;
     for (let i = index + 1; i < this._array.length; ++i) {
@@ -265,14 +265,14 @@ class ArrayFixed<item> {
     this._array.copyWithin(index + 1, index, emptyIndex);
     this._array[index] = value;
     ++this._count;
-    return;
+    return index;
   }
 
   caret (
     index: number,
     value: item,
     preferredDirection: boolean = true,
-  ): void {
+  ): number {
     if (index >= this._array.length || index < 0) {
       throw new RangeError('Out of range index');
     }
@@ -282,7 +282,7 @@ class ArrayFixed<item> {
     if (!this._array.hasOwnProperty(index)) {
       this._array[index] = value;
       ++this._count;
-      return;
+      return index;
     }
     let emptyDirectionAndIndex = null;
     let i = index - 1, j = index + 1;
@@ -356,7 +356,7 @@ class ArrayFixed<item> {
     }
     this._array[index] = value;
     ++this._count;
-    return;
+    return index;
   }
 
 }

lib/ArrayFixedDense.js

@@ -7,18 +7,18 @@ import ArrayFixed from './ArrayFixed.js';
  * Class representing a fixed size dense array.
  * This ensures that mutation always results in a dense array.
  */
-class ArrayFixedDense<item, direction: boolean> extends ArrayFixed<item> {
+class ArrayFixedDense<item> extends ArrayFixed<item> {
 
-  _direction: direction;
+  _direction: boolean;
 
   constructor (
     sizeOrArray: number|Array<item> = 0,
-    direction_: direction = true
+    direction: boolean = true
   ) {
     if (Array.isArray(sizeOrArray)) {
       // $FlowFixMe: Arrays are objects
       const arrayNew = Object.keys(sizeOrArray).map((k) => sizeOrArray[k]);
-      if (direction_) {
+      if (direction) {
         arrayNew.length = sizeOrArray.length;
         sizeOrArray = arrayNew;
       } else {
@@ -28,38 +28,38 @@ class ArrayFixedDense<item, direction: boolean> extends ArrayFixed<item> {
       }
     }
     super(sizeOrArray);
-    this._direction = direction_;
+    this._direction = direction;
   }
 
   /**
    * Construct from reference.
    * This skips the integrity process in the normal constructor.
    * The array must already be dense, and have the correct count and direction.
    */
-  static fromArray<direction: boolean> (
+  static fromArray (
     array: Array<item>,
     count: number,
-    direction_: direction = true
-  ): ArrayFixedDense<item, direction> {
+    direction: boolean = true
+  ): ArrayFixedDense<item> {
     const arrayFixedDense = new ArrayFixedDense(array.length);
     arrayFixedDense._array = array;
     arrayFixedDense._count = count;
-    arrayFixedDense._direction = direction_;
+    arrayFixedDense._direction = direction;
     return arrayFixedDense;
   }
 
   get direction (): boolean {
     return this._direction;
   }
 
-  switchDirection (direction_: direction): void {
-    if (direction_ !== this._direction) {
-      if (direction_) {
+  switchDirection (direction: boolean): void {
+    if (direction !== this._direction) {
+      if (direction) {
         super.collapseLeft();
       } else {
         super.collapseRight();
       }
-      this._direction = direction_;
+      this._direction = direction;
     }
   }
 
@@ -109,7 +109,7 @@ class ArrayFixedDense<item, direction: boolean> extends ArrayFixed<item> {
     }
   }
 
-  reverse (): ArrayFixedDense<item, direction> {
+  reverse (): ArrayFixedDense<item> {
     let swapStart, swapMid;
     if (this._direction) {
       swapStart = 0;
@@ -148,7 +148,7 @@ class ArrayFixedDense<item, direction: boolean> extends ArrayFixed<item> {
   slice (
     begin: number = 0,
     end: number = this._array.length
-  ): ArrayFixedDense<item, direction> {
+  ): ArrayFixedDense<item> {
     begin = Math.trunc(begin);
     end = Math.trunc(end);
     if (begin < 0) {
@@ -174,7 +174,7 @@ class ArrayFixedDense<item, direction: boolean> extends ArrayFixed<item> {
     indexStart: number = 0,
     deleteCount: ?number,
     ...items: Array<item>
-  ): ArrayFixedDense<item, direction> {
+  ): ArrayFixedDense<item> {
     indexStart = Math.trunc(indexStart);
     if (indexStart < 0) {
       indexStart = Math.max(indexStart + this._array.length, 0);
@@ -213,19 +213,19 @@ class ArrayFixedDense<item, direction: boolean> extends ArrayFixed<item> {
   }
 
   map<itemNew> (
-    callback: (item, number, ArrayFixedDense<item, direction>) => itemNew
-  ): ArrayFixedDense<itemNew, direction> {
+    callback: (item, number, ArrayFixedDense<item>) => itemNew
+  ): ArrayFixedDense<itemNew> {
     const arrayNew = this._array.map((v, i) => callback(v, i, this));
     return ArrayFixedDense.fromArray(arrayNew, this._count, this._direction);
   }
 
   forEach (
-    callback: (item, number, ArrayFixedDense<item, direction>) => any
+    callback: (item, number, ArrayFixedDense<item>) => any
   ): void {
     this._array.forEach((v, i) => callback(v, i, this));
   }
 
-  caretLeft (index: number, value: item): void {
+  caretLeft (index: number, value: item): number {
     if (index >= this._array.length || index < 0) {
       throw new RangeError('Out of range index');
     }
@@ -254,10 +254,10 @@ class ArrayFixedDense<item, direction: boolean> extends ArrayFixed<item> {
     }
     this._array[index] = value;
     ++this._count;
-    return;
+    return index;
   }
 
-  caretRight (index: number, value: item): void {
+  caretRight (index: number, value: item): number {
     if (index >= this._array.length || index < 0) {
       throw new RangeError('Out of range index');
     }
@@ -285,10 +285,10 @@ class ArrayFixedDense<item, direction: boolean> extends ArrayFixed<item> {
     }
     this._array[index] = value;
     ++this._count;
-    return;
+    return index;
   }
 
-  caret (index: number, value: item): void {
+  caret (index: number, value: item): number {
     // the preferred direction is the opposite direction of this dense array
     if (this._direction) {
       return this.caretRight(index, value);

test/ArrayFixed.js

@@ -208,3 +208,9 @@ test('caret', t => {
   }, RangeError);
   t.deepEqual(arr.toArray(), [ ,2, ,]);
 });
+
+test('caret returns back inserted index', t => {
+  const arr = new ArrayFixed([1, ,2,3,4, ,5]);
+  t.is(arr.caretRight(0, 0), 0);
+  t.is(arr.caretLeft(6, 6), 6);
+});

test/ArrayFixedDense.js

@@ -292,3 +292,13 @@ test('caret', t => {
   t.is(arr.length, origLength);
   t.deepEqual(arr.toArray(), [1,2,3,4,5]);
 });
+
+test('caret returns back inserted index', t => {
+  let arr;
+  arr = new ArrayFixedDense([1,2,3, , ,], true);
+  t.is(arr.caret(4, 4), 3);
+  t.is(arr.caret(4, 4), 4);
+  arr = new ArrayFixedDense([ , , 4, 5, 6], false);
+  t.is(arr.caretRight(0, 3), 1);
+  t.is(arr.caretLeft(1, 3), 1);
+});