Rename position to index (#1994)

https://github.com/tc39/proposal-intl-segmenter/pull/55

test/intl402/Segmenter/iterator/following.js

@@ -24,9 +24,9 @@ const tests = [
   [text.length - 1, text.length],
 ];
 
-for (const [input, position] of tests) {
+for (const [input, index] of tests) {
   assert.sameValue(iter.following(input), false);
-  assert.sameValue(iter.position, position, String(input));
+  assert.sameValue(iter.index, index, String(input));
 }
 
 assert.throws(RangeError, () => iter.following(-3));

test/intl402/Segmenter/iterator/granularity.js

@@ -12,7 +12,7 @@ for (const granularity of ["grapheme", "word", "sentence", "line"]) {
   const segmenter = new Intl.Segmenter("en", { granularity });
   const iter = segmenter.segment(text);
 
-  assert.sameValue(typeof iter.position, "number");
-  assert.sameValue(iter.position, 0);
+  assert.sameValue(typeof iter.index, "number");
+  assert.sameValue(iter.index, 0);
   assert.sameValue(iter.breakType, undefined);
 }

test/intl402/Segmenter/iterator/position.js

@@ -11,4 +11,4 @@ const segmenter = new Intl.Segmenter();
 const text = "Hello World, Test 123! Foo Bar. How are you?";
 const iter = segmenter.segment(text);
 
-assert.sameValue(iter.position, 0);
+assert.sameValue(iter.index, 0);

test/intl402/Segmenter/iterator/preceding.js

@@ -22,9 +22,9 @@ const tests = [
   [text.length, text.length - 1],
 ];
 
-for (const [input, position] of tests) {
+for (const [input, index] of tests) {
   assert.sameValue(iter.preceding(input), false);
-  assert.sameValue(iter.position, position, String(input));
+  assert.sameValue(iter.index, index, String(input));
 }
 
 assert.throws(RangeError, () => iter.preceding("ABC"));

test/intl402/Segmenter/iterator/prototype.js

@@ -17,7 +17,7 @@ for (const func of ["next", "following", "preceding"]) {
   });
 }
 
-for (const property of ["position", "breakType"]) {
+for (const property of ["index", "breakType"]) {
   let desc = Object.getOwnPropertyDescriptor(prototype, property);
   assert.sameValue(desc.get.name, `get ${property}`);
   assert.sameValue(typeof desc.get, "function")

test/intl402/Segmenter/prototype/segment/segment-grapheme-following.js

@@ -33,11 +33,11 @@ for (const text of [
   let segments = [];
   while (!iter.following()) {
     assert.sameValue(undefined, iter.breakType);
-    assert(iter.position >= 0);
-    assert(iter.position <= text.length);
-    assert(iter.position > prev);
-    segments.push(text.substring(prev, iter.position));
-    prev = iter.position;
+    assert(iter.index >= 0);
+    assert(iter.index <= text.length);
+    assert(iter.index > prev);
+    segments.push(text.substring(prev, iter.index));
+    prev = iter.index;
   }
   assert.sameValue(text, segments.join(""));
 }

test/intl402/Segmenter/prototype/segment/segment-grapheme-iterable.js

@@ -42,8 +42,8 @@ for (const text of [
     // manually advance the iter.
     assert.sameValue(iter.following(), false);
     assert.sameValue(iter.breakType, v.breakType);
-    assert.sameValue(text.substring(prev, iter.position), v.segment);
-    prev = iter.position;
+    assert.sameValue(text.substring(prev, iter.index), v.segment);
+    prev = iter.index;
   }
   assert(iter.following());
   assert.sameValue(text, segments.join(''));

test/intl402/Segmenter/prototype/segment/segment-grapheme-next.js

@@ -37,9 +37,9 @@ for (const text of [
     assert.sameValue("string", typeof v.segment);
     assert(v.segment.length > 0);
     segments.push(v.segment);
-    assert.sameValue(typeof v.position, "number");
-    assert(oldPos < v.position);
-    oldPos = v.position;
+    assert.sameValue(typeof v.index, "number");
+    assert(oldPos < v.index);
+    oldPos = v.index;
   }
   assert.sameValue(text, segments.join(''));
 }

test/intl402/Segmenter/prototype/segment/segment-grapheme-preceding.js

@@ -33,17 +33,17 @@ for (const text of [
   let segments = [];
   iter.preceding(prev)
   assert.sameValue(undefined, iter.breakType)
-  assert(iter.position >= 0);
-  assert(iter.position < prev);
-  segments.push(text.substring(iter.position, prev));
-  prev = iter.position;
+  assert(iter.index >= 0);
+  assert(iter.index < prev);
+  segments.push(text.substring(iter.index, prev));
+  prev = iter.index;
   while (!iter.preceding()) {
     assert.sameValue(undefined, iter.breakType);
-    assert(iter.position >= 0);
-    assert(iter.position <= text.length);
-    assert(iter.position < prev);
-    segments.push(text.substring(iter.position, prev));
-    prev = iter.position;
+    assert(iter.index >= 0);
+    assert(iter.index <= text.length);
+    assert(iter.index < prev);
+    segments.push(text.substring(iter.index, prev));
+    prev = iter.index;
   }
   assert.sameValue(text, segments.reverse().join(""));
 }

test/intl402/Segmenter/prototype/segment/segment-grapheme.js

@@ -30,5 +30,5 @@ for (const text of [
     ]) {
   const iter = seg.segment(text);
   assert.sameValue(undefined, iter.breakType);
-  assert.sameValue(0, iter.position);
+  assert.sameValue(0, iter.index);
 }

test/intl402/Segmenter/prototype/segment/segment-line-following.js

@@ -33,11 +33,11 @@ for (const text of [
   let segments = [];
   while (!iter.following()) {
     assert(["soft", "hard"].includes(iter.breakType), iter.breakType);
-    assert(iter.position >= 0);
-    assert(iter.position <= text.length);
-    assert(iter.position > prev);
-    segments.push(text.substring(prev, iter.position));
-    prev = iter.position;
+    assert(iter.index >= 0);
+    assert(iter.index <= text.length);
+    assert(iter.index > prev);
+    segments.push(text.substring(prev, iter.index));
+    prev = iter.index;
   }
   assert.sameValue(text, segments.join(""));
 }

test/intl402/Segmenter/prototype/segment/segment-line-iterable.js

@@ -42,8 +42,8 @@ for (const text of [
     // manually advance the iter.
     assert.sameValue(iter.following(), false);
     assert.sameValue(iter.breakType, v.breakType);
-    assert.sameValue(text.substring(prev, iter.position), v.segment);
-    prev = iter.position;
+    assert.sameValue(text.substring(prev, iter.index), v.segment);
+    prev = iter.index;
   }
   assert(iter.following());
   assert.sameValue(text, segments.join(''));

test/intl402/Segmenter/prototype/segment/segment-line-next.js

@@ -37,9 +37,9 @@ for (const text of [
     assert.sameValue("string", typeof v.segment);
     assert(v.segment.length > 0);
     segments.push(v.segment);
-    assert.sameValue(typeof v.position, "number");
-    assert(oldPos < v.position);
-    oldPos = v.position;
+    assert.sameValue(typeof v.index, "number");
+    assert(oldPos < v.index);
+    oldPos = v.index;
   }
   assert.sameValue(text, segments.join(''));
 }

test/intl402/Segmenter/prototype/segment/segment-line-preceding.js

@@ -33,17 +33,17 @@ for (const text of [
   let segments = [];
   iter.preceding(prev)
   assert(["soft", "hard"].includes(iter.breakType), iter.breakType);
-  assert(iter.position >= 0);
-  assert(iter.position < prev);
-  segments.push(text.substring(iter.position, prev));
-  prev = iter.position;
+  assert(iter.index >= 0);
+  assert(iter.index < prev);
+  segments.push(text.substring(iter.index, prev));
+  prev = iter.index;
   while (!iter.preceding()) {
     assert(["soft", "hard"].includes(iter.breakType), iter.breakType);
-    assert(iter.position >= 0);
-    assert(iter.position <= text.length);
-    assert(iter.position < prev);
-    segments.push(text.substring(iter.position, prev));
-    prev = iter.position;
+    assert(iter.index >= 0);
+    assert(iter.index <= text.length);
+    assert(iter.index < prev);
+    segments.push(text.substring(iter.index, prev));
+    prev = iter.index;
   }
   assert.sameValue(text, segments.reverse().join(""));
 }

test/intl402/Segmenter/prototype/segment/segment-line.js

@@ -30,5 +30,5 @@ for (const text of [
     ]) {
   const iter = seg.segment(text);
   assert.sameValue(undefined, iter.breakType);
-  assert.sameValue(0, iter.position);
+  assert.sameValue(0, iter.index);
 }

test/intl402/Segmenter/prototype/segment/segment-sentence-following.js

@@ -33,11 +33,11 @@ for (const text of [
   let segments = [];
   while (!iter.following()) {
     assert(["sep", "term"].includes(iter.breakType), iter.breakType);
-    assert(iter.position >= 0);
-    assert(iter.position <= text.length);
-    assert(iter.position > prev);
-    segments.push(text.substring(prev, iter.position));
-    prev = iter.position;
+    assert(iter.index >= 0);
+    assert(iter.index <= text.length);
+    assert(iter.index > prev);
+    segments.push(text.substring(prev, iter.index));
+    prev = iter.index;
   }
   assert.sameValue(text, segments.join(""));
 }

test/intl402/Segmenter/prototype/segment/segment-sentence-iterable.js

@@ -42,8 +42,8 @@ for (const text of [
     // manually advance the iter.
     assert.sameValue(iter.following(), false);
     assert.sameValue(iter.breakType, v.breakType);
-    assert.sameValue(text.substring(prev, iter.position), v.segment);
-    prev = iter.position;
+    assert.sameValue(text.substring(prev, iter.index), v.segment);
+    prev = iter.index;
   }
   assert(iter.following());
   assert.sameValue(text, segments.join(''));

test/intl402/Segmenter/prototype/segment/segment-sentence-next.js

@@ -37,9 +37,9 @@ for (const text of [
     assert.sameValue("string", typeof v.segment);
     assert(v.segment.length > 0);
     segments.push(v.segment);
-    assert.sameValue(typeof v.position, "number");
-    assert(oldPos < v.position);
-    oldPos = v.position;
+    assert.sameValue(typeof v.index, "number");
+    assert(oldPos < v.index);
+    oldPos = v.index;
   }
   assert.sameValue(text, segments.join(''));
 }

test/intl402/Segmenter/prototype/segment/segment-sentence-preceding.js

@@ -33,17 +33,17 @@ for (const text of [
   let segments = [];
   iter.preceding(prev);
   assert(["sep", "term"].includes(iter.breakType), iter.breakType);
-  assert(iter.position >= 0);
-  assert(iter.position < prev);
-  segments.push(text.substring(iter.position, prev));
-  prev = iter.position;
+  assert(iter.index >= 0);
+  assert(iter.index < prev);
+  segments.push(text.substring(iter.index, prev));
+  prev = iter.index;
   while (!iter.preceding()) {
     assert(["sep", "term"].includes(iter.breakType), iter.breakType);
-    assert(iter.position >= 0);
-    assert(iter.position <= text.length);
-    assert(iter.position < prev);
-    segments.push(text.substring(iter.position, prev));
-    prev = iter.position;
+    assert(iter.index >= 0);
+    assert(iter.index <= text.length);
+    assert(iter.index < prev);
+    segments.push(text.substring(iter.index, prev));
+    prev = iter.index;
   }
   assert.sameValue(text, segments.reverse().join(""));
 }

test/intl402/Segmenter/prototype/segment/segment-sentence.js

@@ -30,5 +30,5 @@ for (const text of [
     ]) {
   const iter = seg.segment(text);
   assert.sameValue(undefined, iter.breakType);
-  assert.sameValue(0, iter.position);
+  assert.sameValue(0, iter.index);
 }

test/intl402/Segmenter/prototype/segment/segment-tostring.js

@@ -29,7 +29,7 @@ for (const [args, expected] of tests) {
   const result = iterator.next().value;
   assert.sameValue(result.segment, expected, `Expected segment "${expected}", found "${result.segment}" for arguments ${args}`);
   assert(["word", "none"].includes(result.breakType), `Expected valid breakType, found "${result.breakType}" for arguments ${args}`);
-  assert.sameValue(result.position, expected.length, `Expected position ${expected.length}, found ${result.position} for arguments ${args}`);
+  assert.sameValue(result.index, expected.length, `Expected index ${expected.length}, found ${result.index} for arguments ${args}`);
 }
 
 const symbol = Symbol();

test/intl402/Segmenter/prototype/segment/segment-word-following.js

@@ -33,11 +33,11 @@ for (const text of [
   let segments = [];
   while (!iter.following()) {
     assert(["word", "none"].includes(iter.breakType), iter.breakType);
-    assert(iter.position >= 0);
-    assert(iter.position <= text.length);
-    assert(iter.position > prev);
-    segments.push(text.substring(prev, iter.position));
-    prev = iter.position;
+    assert(iter.index >= 0);
+    assert(iter.index <= text.length);
+    assert(iter.index > prev);
+    segments.push(text.substring(prev, iter.index));
+    prev = iter.index;
   }
   assert.sameValue(text, segments.join(""));
 }

test/intl402/Segmenter/prototype/segment/segment-word-iterable.js

@@ -42,8 +42,8 @@ for (const text of [
     // manually advance the iter.
     assert.sameValue(iter.following(), false);
     assert.sameValue(iter.breakType, v.breakType);
-    assert.sameValue(text.substring(prev, iter.position), v.segment);
-    prev = iter.position;
+    assert.sameValue(text.substring(prev, iter.index), v.segment);
+    prev = iter.index;
   }
   assert(iter.following());
   assert.sameValue(text, segments.join(''));

test/intl402/Segmenter/prototype/segment/segment-word-next.js

@@ -37,9 +37,9 @@ for (const text of [
     assert.sameValue("string", typeof v.segment);
     assert(v.segment.length > 0);
     segments.push(v.segment);
-    assert.sameValue(typeof v.position, "number");
-    assert(oldPos < v.position);
-    oldPos = v.position;
+    assert.sameValue(typeof v.index, "number");
+    assert(oldPos < v.index);
+    oldPos = v.index;
   }
   assert.sameValue(text, segments.join(''));
 }

test/intl402/Segmenter/prototype/segment/segment-word-preceding.js

@@ -33,17 +33,17 @@ for (const text of [
   let segments = [];
   iter.preceding(prev);
   assert(["word", "none"].includes(iter.breakType), iter.breakType);
-  assert(iter.position >= 0);
-  assert(iter.position < prev);
-  segments.push(text.substring(iter.position, prev));
-  prev = iter.position;
+  assert(iter.index >= 0);
+  assert(iter.index < prev);
+  segments.push(text.substring(iter.index, prev));
+  prev = iter.index;
   while (!iter.preceding()) {
     assert(["word", "none"].includes(iter.breakType), iter.breakType);
-    assert(iter.position >= 0);
-    assert(iter.position <= text.length);
-    assert(iter.position < prev);
-    segments.push(text.substring(iter.position, prev));
-    prev = iter.position;
+    assert(iter.index >= 0);
+    assert(iter.index <= text.length);
+    assert(iter.index < prev);
+    segments.push(text.substring(iter.index, prev));
+    prev = iter.index;
   }
   assert.sameValue(text, segments.reverse().join(""));
 }

test/intl402/Segmenter/prototype/segment/segment-word.js

@@ -30,5 +30,5 @@ for (const text of [
     ]) {
   const iter = seg.segment(text);
   assert.sameValue(undefined, iter.breakType);
-  assert.sameValue(0, iter.position);
+  assert.sameValue(0, iter.index);
 }