move _data from BufferLine to new LogicalLine class

addons/addon-image/test/ImageAddon.test.ts

@@ -117,8 +117,8 @@ test.describe('ImageAddon', () => {
       );
     }
     // bufferline privates
-    strictEqual(await ctx.page.evaluate('window.term._core.buffer.lines.get(0)._data instanceof Uint32Array'), true);
-    strictEqual(await ctx.page.evaluate('window.term._core.buffer.lines.get(0)._extendedAttrs instanceof Object'), true);
+    strictEqual(await ctx.page.evaluate('window.term._core.buffer.lines.get(0)._logicalLine._data instanceof Uint32Array'), true);
+    strictEqual(await ctx.page.evaluate('window.term._core.buffer.lines.get(0)._logicalLine._extendedAttrs instanceof Object'), true);
     // inputhandler privates
     strictEqual(await ctx.page.evaluate('window.term._core._inputHandler._curAttrData.constructor.name'), '_AttributeData');
     strictEqual(await ctx.page.evaluate('window.term._core._inputHandler._parser.constructor.name'), 'EscapeSequenceParser');

addons/addon-serialize/test/SerializeAddon.test.ts

@@ -49,14 +49,20 @@ test.describe('SerializeAddon', () => {
         for (let i = 0; i < buffer.length; i++) {
           // Do this intentionally to get content of underlining source
           const bufferLine = buffer.getLine(i)._line;
-          lines.push(JSON.stringify(bufferLine, (key, value) => {
-            // BufferLine caches are internal/transient and can legitimately differ
-            // across equivalent terminal states.
-            if (key === '_stringCache' || key === '_stringCacheEntryRef') {
-              return undefined;
-            }
-            return value;
-          }));
+          if (bufferLine.isWrapped) {
+            lines.push({ startColumn: bufferLine.startColumn, length: bufferLine.length});
+          } else {
+            const logical = bufferLine.logical();
+            lines.push(JSON.stringify(logical, (key, value) => {
+              if (key === 'firstBufferLine' ) {
+                return undefined;
+              }
+              if (key === '_data') {
+                return new Uint32Array(value.buffer, 0, logical.length * 3);
+              }
+              return value;
+            }));
+          }
         }
         return {
           x: buffer.cursorX,

src/browser/OscLinkProvider.test.ts

@@ -62,7 +62,7 @@ describe('OscLinkProvider', () => {
     setUrl(line1, 2, 'bbb', 1);
     setUrl(line2, 0, 'cccc', 1);
     setText(line2, 4, 'x');
-    line2!.isWrapped = true;
+    bufferService.buffer.setWrapped(1, true);
 
     const links = await getLinks(provider, 2);
     assert.lengthOf(links, 1);
@@ -78,7 +78,7 @@ describe('OscLinkProvider', () => {
     setUrl(line1, 0, 'aaaaa', 1);
     setUrl(line2, 0, 'bb', 1);
     setText(line2, 2, 'ccc');
-    line2!.isWrapped = true;
+    bufferService.buffer.setWrapped(1, true);
 
     const links = await getLinks(provider, 1);
     assert.lengthOf(links, 1);
@@ -94,7 +94,7 @@ describe('OscLinkProvider', () => {
     setUrl(line1, 0, 'aaaaa', 1);
     setUrl(line2, 0, 'bbb', 2);
     setText(line2, 3, 'cc');
-    line2!.isWrapped = true;
+    bufferService.buffer.setWrapped(1, true);
 
     const links = await getLinks(provider, 1);
     assert.lengthOf(links, 1);

src/browser/TestUtils.test.ts

@@ -271,6 +271,9 @@ export class MockBuffer implements IBuffer {
   public clearAllMarkers(): void {
     throw new Error('Method not implemented.');
   }
+  public setWrapped(row: number, value: boolean): void {
+    throw new Error('Method not implemented.');
+  }
 }
 
 export class MockRenderer implements IRenderer {

src/browser/services/SelectionService.test.ts

@@ -196,7 +196,7 @@ describe('SelectionService', () => {
     it('should expand upwards or downards for wrapped lines', () => {
       buffer.lines.set(0, stringToRow('                 foo'));
       buffer.lines.set(1, stringToRow('bar                 '));
-      buffer.lines.get(1)!.isWrapped = true;
+      buffer.setWrapped(1, true);
       selectionService.selectWordAt([1, 1]);
       assert.equal(selectionService.selectionText, 'foobar');
       selectionService.model.clearSelection();
@@ -210,10 +210,10 @@ describe('SelectionService', () => {
       buffer.lines.set(2, stringToRow('bbbbbbbbbbbbbbbbbbbb'));
       buffer.lines.set(3, stringToRow('cccccccccccccccccccc'));
       buffer.lines.set(4, stringToRow('bar                 '));
-      buffer.lines.get(1)!.isWrapped = true;
-      buffer.lines.get(2)!.isWrapped = true;
-      buffer.lines.get(3)!.isWrapped = true;
-      buffer.lines.get(4)!.isWrapped = true;
+      buffer.setWrapped(1, true);
+      buffer.setWrapped(2, true);
+      buffer.setWrapped(3, true);
+      buffer.setWrapped(4, true);
       selectionService.selectWordAt([18, 0]);
       assert.equal(selectionService.selectionText, expectedText);
       selectionService.model.clearSelection();
@@ -352,8 +352,8 @@ describe('SelectionService', () => {
     it('should select the entire wrapped line', () => {
       buffer.lines.set(0, stringToRow('foo'));
       const line2 = stringToRow('bar');
-      line2.isWrapped = true;
       buffer.lines.set(1, line2);
+      buffer.setWrapped(1, true);
       selectionService.selectLineAt(0);
       assert.equal(selectionService.selectionText, 'foobar', 'The selected text is correct');
       assert.deepEqual(selectionService.model.selectionStart, [0, 0]);

src/common/InputHandler.test.ts

@@ -461,8 +461,10 @@ describe('InputHandler', () => {
       await resetToBaseState();
       bufferService.buffer.y = 2;
       bufferService.buffer.x = 40;
-      inputHandler.eraseInLine(Params.fromArray([0]));
       assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, true);
+      assert.equal(bufferService.buffer.lines.get(3)!.isWrapped, true);
+      inputHandler.eraseInLine(Params.fromArray([0]));
+      assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, true);assert.equal(bufferService.buffer.lines.get(3)!.isWrapped, false);
       bufferService.buffer.y = 2;
       bufferService.buffer.x = 0;
       inputHandler.eraseInLine(Params.fromArray([0]));
@@ -473,14 +475,16 @@ describe('InputHandler', () => {
       bufferService.buffer.y = 2;
       bufferService.buffer.x = 40;
       inputHandler.eraseInLine(Params.fromArray([1]));
-      assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, true);
+      assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, false);
+      assert.equal(bufferService.buffer.lines.get(3)!.isWrapped, true);
 
       // params[2] - erase complete line
       await resetToBaseState();
       bufferService.buffer.y = 2;
       bufferService.buffer.x = 40;
       inputHandler.eraseInLine(Params.fromArray([2]));
       assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, false);
+      assert.equal(bufferService.buffer.lines.get(3)!.isWrapped, false);
     });
     it('ED2 with scrollOnEraseInDisplay turned on', async () => {
       const inputHandler = new TestInputHandler(