stream: use private properties for encoding

PR-URL: #47218 Reviewed-By: Erick Wendel <[email protected]> Reviewed-By: Minwoo Jung <[email protected]> Reviewed-By: Antoine du Hamel <[email protected]> Reviewed-By: Robert Nagy <[email protected]>

Author: anonrig

lib/internal/webstreams/encoding.js

@@ -4,7 +4,6 @@ const{
  ObjectDefineProperties,
  String,
  StringPrototypeCharCodeAt,
- Symbol,
  Uint8Array,
 }=primordials;
 
@@ -31,50 +30,37 @@ const{
  kEnumerableProperty,
 }=require('internal/util');
 
-constkHandle=Symbol('kHandle');
-constkTransform=Symbol('kTransform');
-constkType=Symbol('kType');
-constkPendingHighSurrogate=Symbol('kPendingHighSurrogate');
-
 /**
  * @typedef{import('./readablestream').ReadableStream} ReadableStream
  * @typedef{import('./writablestream').WritableStream} WritableStream
  */
 
-functionisTextEncoderStream(value){
-returntypeofvalue?.[kHandle]==='object'&&
-value?.[kType]==='TextEncoderStream';
-}
-
-functionisTextDecoderStream(value){
-returntypeofvalue?.[kHandle]==='object'&&
-value?.[kType]==='TextDecoderStream';
-}
-
 classTextEncoderStream{
+ #pendingHighSurrogate =null;
+ #handle;
+ #transform;
+
 constructor(){
-this[kPendingHighSurrogate]=null;
-this[kType]='TextEncoderStream';
-this[kHandle]=newTextEncoder();
-this[kTransform]=newTransformStream({
+this.#handle =newTextEncoder();
+this.#transform =newTransformStream({
 transform: (chunk,controller)=>{
 // https://encoding.spec.whatwg.org/#encode-and-enqueue-a-chunk
 chunk=String(chunk);
 letfinalChunk='';
 for(leti=0;i<chunk.length;i++){
 constitem=chunk[i];
 constcodeUnit=StringPrototypeCharCodeAt(item,0);
-if(this[kPendingHighSurrogate]!==null){
-consthighSurrogate=this[kPendingHighSurrogate];
-this[kPendingHighSurrogate]=null;
+if(this.#pendingHighSurrogate!==null){
+consthighSurrogate=this.#pendingHighSurrogate;
+this.#pendingHighSurrogate=null;
 if(0xDC00<=codeUnit&&codeUnit<=0xDFFF){
 finalChunk+=highSurrogate+item;
 continue;
 }
 finalChunk+='\uFFFD';
 }
 if(0xD800<=codeUnit&&codeUnit<=0xDBFF){
-this[kPendingHighSurrogate]=item;
+this.#pendingHighSurrogate=item;
 continue;
 }
 if(0xDC00<=codeUnit&&codeUnit<=0xDFFF){
@@ -84,13 +70,13 @@ class TextEncoderStream{
 finalChunk+=item;
 }
 if(finalChunk){
-constvalue=this[kHandle].encode(finalChunk);
+constvalue=this.#handle.encode(finalChunk);
 controller.enqueue(value);
 }
 },
 flush: (controller)=>{
 // https://encoding.spec.whatwg.org/#encode-and-flush
-if(this[kPendingHighSurrogate]!==null){
+if(this.#pendingHighSurrogate!==null){
 controller.enqueue(newUint8Array([0xEF,0xBF,0xBD]));
 }
 },
@@ -102,43 +88,40 @@ class TextEncoderStream{
  * @type{string}
  */
 getencoding(){
-if(!isTextEncoderStream(this))
-thrownewERR_INVALID_THIS('TextEncoderStream');
-returnthis[kHandle].encoding;
+returnthis.#handle.encoding;
 }
 
 /**
  * @readonly
  * @type{ReadableStream}
  */
 getreadable(){
-if(!isTextEncoderStream(this))
-thrownewERR_INVALID_THIS('TextEncoderStream');
-returnthis[kTransform].readable;
+returnthis.#transform.readable;
 }
 
 /**
  * @readonly
  * @type{WritableStream}
  */
 getwritable(){
-if(!isTextEncoderStream(this))
-thrownewERR_INVALID_THIS('TextEncoderStream');
-returnthis[kTransform].writable;
+returnthis.#transform.writable;
 }
 
 [kInspect](depth,options){
-if(!isTextEncoderStream(this))
+if(this==null)
 thrownewERR_INVALID_THIS('TextEncoderStream');
 returncustomInspect(depth,options,'TextEncoderStream',{
-encoding: this[kHandle].encoding,
-readable: this[kTransform].readable,
-writable: this[kTransform].writable,
+encoding: this.#handle.encoding,
+readable: this.#transform.readable,
+writable: this.#transform.writable,
 });
 }
 }
 
 classTextDecoderStream{
+ #handle;
+ #transform;
+
 /**
  * @param{string} [encoding]
  * @param{{
@@ -147,16 +130,15 @@ class TextDecoderStream{
  * }} [options]
  */
 constructor(encoding='utf-8',options=kEmptyObject){
-this[kType]='TextDecoderStream';
-this[kHandle]=newTextDecoder(encoding,options);
-this[kTransform]=newTransformStream({
+this.#handle =newTextDecoder(encoding,options);
+this.#transform =newTransformStream({
 transform: (chunk,controller)=>{
-constvalue=this[kHandle].decode(chunk,{stream: true});
+constvalue=this.#handle.decode(chunk,{stream: true});
 if(value)
 controller.enqueue(value);
 },
 flush: (controller)=>{
-constvalue=this[kHandle].decode();
+constvalue=this.#handle.decode();
 if(value)
 controller.enqueue(value);
 controller.terminate();
@@ -169,60 +151,50 @@ class TextDecoderStream{
  * @type{string}
  */
 getencoding(){
-if(!isTextDecoderStream(this))
-thrownewERR_INVALID_THIS('TextDecoderStream');
-returnthis[kHandle].encoding;
+returnthis.#handle.encoding;
 }
 
 /**
  * @readonly
  * @type{boolean}
  */
 getfatal(){
-if(!isTextDecoderStream(this))
-thrownewERR_INVALID_THIS('TextDecoderStream');
-returnthis[kHandle].fatal;
+returnthis.#handle.fatal;
 }
 
 /**
  * @readonly
  * @type{boolean}
  */
 getignoreBOM(){
-if(!isTextDecoderStream(this))
-thrownewERR_INVALID_THIS('TextDecoderStream');
-returnthis[kHandle].ignoreBOM;
+returnthis.#handle.ignoreBOM;
 }
 
 /**
  * @readonly
  * @type{ReadableStream}
  */
 getreadable(){
-if(!isTextDecoderStream(this))
-thrownewERR_INVALID_THIS('TextDecoderStream');
-returnthis[kTransform].readable;
+returnthis.#transform.readable;
 }
 
 /**
  * @readonly
  * @type{WritableStream}
  */
 getwritable(){
-if(!isTextDecoderStream(this))
-thrownewERR_INVALID_THIS('TextDecoderStream');
-returnthis[kTransform].writable;
+returnthis.#transform.writable;
 }
 
 [kInspect](depth,options){
-if(!isTextDecoderStream(this))
+if(this==null)
 thrownewERR_INVALID_THIS('TextDecoderStream');
 returncustomInspect(depth,options,'TextDecoderStream',{
-encoding: this[kHandle].encoding,
-fatal: this[kHandle].fatal,
-ignoreBOM: this[kHandle].ignoreBOM,
-readable: this[kTransform].readable,
-writable: this[kTransform].writable,
+encoding: this.#handle.encoding,
+fatal: this.#handle.fatal,
+ignoreBOM: this.#handle.ignoreBOM,
+readable: this.#transform.readable,
+writable: this.#transform.writable,
 });
 }
 }

test/parallel/test-whatwg-webstreams-encoding.js

@@ -48,23 +48,28 @@ const kEuro = Buffer.from([0xe2, 0x82, 0xac]).toString();
 
 assert.throws(
 ()=>Reflect.get(TextDecoderStream.prototype,'encoding',{}),{
-code: 'ERR_INVALID_THIS',
+name: 'TypeError',
+message: /Cannotreadprivatemember/,
 });
 assert.throws(
 ()=>Reflect.get(TextDecoderStream.prototype,'fatal',{}),{
-code: 'ERR_INVALID_THIS',
+name: 'TypeError',
+message: /Cannotreadprivatemember/,
 });
 assert.throws(
 ()=>Reflect.get(TextDecoderStream.prototype,'ignoreBOM',{}),{
-code: 'ERR_INVALID_THIS',
+name: 'TypeError',
+message: /Cannotreadprivatemember/,
 });
 assert.throws(
 ()=>Reflect.get(TextDecoderStream.prototype,'readable',{}),{
-code: 'ERR_INVALID_THIS',
+name: 'TypeError',
+message: /Cannotreadprivatemember/,
 });
 assert.throws(
 ()=>Reflect.get(TextDecoderStream.prototype,'writable',{}),{
-code: 'ERR_INVALID_THIS',
+name: 'TypeError',
+message: /Cannotreadprivatemember/,
 });
 }
 
@@ -89,14 +94,17 @@ const kEuro = Buffer.from([0xe2, 0x82, 0xac]).toString();
 
 assert.throws(
 ()=>Reflect.get(TextEncoderStream.prototype,'encoding',{}),{
-code: 'ERR_INVALID_THIS',
+name: 'TypeError',
+message: /Cannotreadprivatemember/,
 });
 assert.throws(
 ()=>Reflect.get(TextEncoderStream.prototype,'readable',{}),{
-code: 'ERR_INVALID_THIS',
+name: 'TypeError',
+message: /Cannotreadprivatemember/,
 });
 assert.throws(
 ()=>Reflect.get(TextEncoderStream.prototype,'writable',{}),{
-code: 'ERR_INVALID_THIS',
+name: 'TypeError',
+message: /Cannotreadprivatemember/,
 });
 }