lib: move kEnumerableProperty to internal/util

PR-URL: nodejs#41877
Reviewed-By: Luigi Pinca <[email protected]>
Reviewed-By: Benjamin Gruenbaum <[email protected]>
Reviewed-By: Antoine du Hamel <[email protected]>

Author: Mesteery

lib/internal/abort_controller.js

@@ -25,6 +25,7 @@ const {
 } = require('internal/event_target');
 const {
   customInspectSymbol,
+  kEnumerableProperty,
 } = require('internal/util');
 const { inspect } = require('internal/util/inspect');
 const {
@@ -253,7 +254,7 @@ function ClonedAbortSignal() {
 ClonedAbortSignal.prototype[kDeserialize] = () => {};
 
 ObjectDefineProperties(AbortSignal.prototype, {
-  aborted: { enumerable: true }
+  aborted: kEnumerableProperty,
 });
 
 ObjectDefineProperty(AbortSignal.prototype, SymbolToStringTag, {
@@ -322,8 +323,8 @@ class AbortController {
 }
 
 ObjectDefineProperties(AbortController.prototype, {
-  signal: { enumerable: true },
-  abort: { enumerable: true }
+  signal: kEnumerableProperty,
+  abort: kEnumerableProperty,
 });
 
 ObjectDefineProperty(AbortController.prototype, SymbolToStringTag, {

lib/internal/crypto/webcrypto.js

@@ -5,7 +5,6 @@ const {
   JSONParse,
   JSONStringify,
   ObjectDefineProperties,
-  ObjectGetOwnPropertyDescriptor,
   SafeSet,
   SymbolToStringTag,
   StringPrototypeRepeat,
@@ -60,6 +59,7 @@ const {
 } = require('internal/crypto/util');
 
 const {
+  kEnumerableProperty,
   lazyDOMException,
 } = require('internal/util');
 
@@ -703,10 +703,7 @@ ObjectDefineProperties(
       writable: false,
       value: 'Crypto',
     },
-    subtle: {
-      ...ObjectGetOwnPropertyDescriptor(Crypto.prototype, 'subtle'),
-      enumerable: true,
-    },
+    subtle: kEnumerableProperty,
     getRandomValues: {
       enumerable: true,
       configurable: true,

lib/internal/encoding.js

@@ -30,7 +30,8 @@ const kEncoder = Symbol('encoder');
 
 const {
   getConstructorOf,
-  customInspectSymbol: inspect
+  customInspectSymbol: inspect,
+  kEnumerableProperty,
 } = require('internal/util');
 
 const {
@@ -358,9 +359,9 @@ class TextEncoder {
 
 ObjectDefineProperties(
   TextEncoder.prototype, {
-    'encode': { enumerable: true },
-    'encodeInto': { enumerable: true },
-    'encoding': { enumerable: true },
+    'encode': kEnumerableProperty,
+    'encodeInto': kEnumerableProperty,
+    'encoding': kEnumerableProperty,
     [SymbolToStringTag]: { configurable: true, value: 'TextEncoder' },
   });
 
@@ -569,7 +570,7 @@ ObjectDefineProperties(
 );
 
 ObjectDefineProperties(TextDecoder.prototype, {
-  decode: { enumerable: true },
+  decode: kEnumerableProperty,
   [inspect]: { enumerable: false },
   [SymbolToStringTag]: {
     configurable: true,

lib/internal/event_target.js

@@ -8,7 +8,6 @@ const {
   FunctionPrototypeCall,
   NumberIsInteger,
   ObjectAssign,
-  ObjectCreate,
   ObjectDefineProperties,
   ObjectDefineProperty,
   ObjectGetOwnPropertyDescriptor,
@@ -36,7 +35,7 @@ const {
 } = require('internal/errors');
 const { validateObject, validateString } = require('internal/validators');
 
-const { customInspectSymbol } = require('internal/util');
+const { customInspectSymbol, kEnumerableProperty } = require('internal/util');
 const { inspect } = require('util');
 
 const kIsEventTarget = SymbolFor('nodejs.event_target');
@@ -298,9 +297,6 @@ class Event {
   static BUBBLING_PHASE = 3;
 }
 
-const kEnumerableProperty = ObjectCreate(null);
-kEnumerableProperty.enumerable = true;
-
 ObjectDefineProperties(
   Event.prototype, {
     [SymbolToStringTag]: {

lib/internal/url.js

@@ -43,6 +43,7 @@ const {
   getConstructorOf,
   removeColors,
   toUSVString,
+  kEnumerableProperty,
 } = require('internal/util');
 
 const {
@@ -507,18 +508,18 @@ class URLSearchParams {
 }
 
 ObjectDefineProperties(URLSearchParams.prototype, {
-  append: { enumerable: true },
-  delete: { enumerable: true },
-  get: { enumerable: true },
-  getAll: { enumerable: true },
-  has: { enumerable: true },
-  set: { enumerable: true },
-  sort: { enumerable: true },
-  entries: { enumerable: true },
-  forEach: { enumerable: true },
-  keys: { enumerable: true },
-  values: { enumerable: true },
-  toString: { enumerable: true },
+  append: kEnumerableProperty,
+  delete: kEnumerableProperty,
+  get: kEnumerableProperty,
+  getAll: kEnumerableProperty,
+  has: kEnumerableProperty,
+  set: kEnumerableProperty,
+  sort: kEnumerableProperty,
+  entries: kEnumerableProperty,
+  forEach: kEnumerableProperty,
+  keys: kEnumerableProperty,
+  values: kEnumerableProperty,
+  toString: kEnumerableProperty,
   [SymbolToStringTag]: { configurable: true, value: 'URLSearchParams' },
 
   // https://heycam.github.io/webidl/#es-iterable-entries
@@ -982,20 +983,20 @@ class URL {
 ObjectDefineProperties(URL.prototype, {
   [kFormat]: { configurable: false, writable: false },
   [SymbolToStringTag]: { configurable: true, value: 'URL' },
-  toString: { enumerable: true },
-  href: { enumerable: true },
-  origin: { enumerable: true },
-  protocol: { enumerable: true },
-  username: { enumerable: true },
-  password: { enumerable: true },
-  host: { enumerable: true },
-  hostname: { enumerable: true },
-  port: { enumerable: true },
-  pathname: { enumerable: true },
-  search: { enumerable: true },
-  searchParams: { enumerable: true },
-  hash: { enumerable: true },
-  toJSON: { enumerable: true },
+  toString: kEnumerableProperty,
+  href: kEnumerableProperty,
+  origin: kEnumerableProperty,
+  protocol: kEnumerableProperty,
+  username: kEnumerableProperty,
+  password: kEnumerableProperty,
+  host: kEnumerableProperty,
+  hostname: kEnumerableProperty,
+  port: kEnumerableProperty,
+  pathname: kEnumerableProperty,
+  search: kEnumerableProperty,
+  searchParams: kEnumerableProperty,
+  hash: kEnumerableProperty,
+  toJSON: kEnumerableProperty,
 });
 
 function update(url, params) {

lib/internal/util.js

@@ -508,6 +508,9 @@ function structuredClone(value) {
   return des.readValue();
 }
 
+const kEnumerableProperty = ObjectCreate(null);
+kEnumerableProperty.enumerable = true;
+
 module.exports = {
   assertCrypto,
   cachedResult,
@@ -546,5 +549,7 @@ module.exports = {
   // Used by the buffer module to capture an internal reference to the
   // default isEncoding implementation, just in case userland overrides it.
   kIsEncodingSymbol: Symbol('kIsEncodingSymbol'),
-  kVmBreakFirstLineSymbol: Symbol('kVmBreakFirstLineSymbol')
+  kVmBreakFirstLineSymbol: Symbol('kVmBreakFirstLineSymbol'),
+
+  kEnumerableProperty,
 };

lib/internal/webstreams/compression.js

@@ -0,0 +1,162 @@
+'use strict';
+
+const {
+  ObjectDefineProperties,
+  Symbol,
+} = primordials;
+
+const {
+  codes: {
+    ERR_INVALID_ARG_VALUE,
+    ERR_INVALID_THIS,
+  },
+} = require('internal/errors');
+
+const {
+  newReadableWritablePairFromDuplex,
+} = require('internal/webstreams/adapters');
+
+const { customInspect } = require('internal/webstreams/util');
+
+const {
+  customInspectSymbol: kInspect,
+  kEnumerableProperty,
+} = require('internal/util');
+
+let zlib;
+function lazyZlib() {
+  zlib ??= require('zlib');
+  return zlib;
+}
+
+const kHandle = Symbol('kHandle');
+const kTransform = Symbol('kTransform');
+const kType = Symbol('kType');
+
+/**
+ * @typedef {import('./readablestream').ReadableStream} ReadableStream
+ * @typedef {import('./writablestream').WritableStream} WritableStream
+ */
+
+function isCompressionStream(value) {
+  return typeof value?.[kHandle] === 'object' &&
+         value?.[kType] === 'CompressionStream';
+}
+
+function isDecompressionStream(value) {
+  return typeof value?.[kHandle] === 'object' &&
+         value?.[kType] === 'DecompressionStream';
+}
+
+class CompressionStream {
+  /**
+   * @param {'deflate'|'gzip'} format
+   */
+  constructor(format) {
+    this[kType] = 'CompressionStream';
+    switch (format) {
+      case 'deflate':
+        this[kHandle] = lazyZlib().createDeflate();
+        break;
+      case 'gzip':
+        this[kHandle] = lazyZlib().createGzip();
+        break;
+      default:
+        throw new ERR_INVALID_ARG_VALUE('format', format);
+    }
+    this[kTransform] = newReadableWritablePairFromDuplex(this[kHandle]);
+  }
+
+  /**
+   * @readonly
+   * @type {ReadableStream}
+   */
+  get readable() {
+    if (!isCompressionStream(this))
+      throw new ERR_INVALID_THIS('CompressionStream');
+    return this[kTransform].readable;
+  }
+
+  /**
+   * @readonly
+   * @type {WritableStream}
+   */
+  get writable() {
+    if (!isCompressionStream(this))
+      throw new ERR_INVALID_THIS('CompressionStream');
+    return this[kTransform].writable;
+  }
+
+  [kInspect](depth, options) {
+    if (!isCompressionStream(this))
+      throw new ERR_INVALID_THIS('CompressionStream');
+    customInspect(depth, options, 'CompressionStream', {
+      readable: this[kTransform].readable,
+      writable: this[kTransform].writable,
+    });
+  }
+}
+
+class DecompressionStream {
+  /**
+   * @param {'deflate'|'gzip'} format
+   */
+  constructor(format) {
+    this[kType] = 'DecompressionStream';
+    switch (format) {
+      case 'deflate':
+        this[kHandle] = lazyZlib().createInflate();
+        break;
+      case 'gzip':
+        this[kHandle] = lazyZlib().createGunzip();
+        break;
+      default:
+        throw new ERR_INVALID_ARG_VALUE('format', format);
+    }
+    this[kTransform] = newReadableWritablePairFromDuplex(this[kHandle]);
+  }
+
+  /**
+   * @readonly
+   * @type {ReadableStream}
+   */
+  get readable() {
+    if (!isDecompressionStream(this))
+      throw new ERR_INVALID_THIS('DecompressionStream');
+    return this[kTransform].readable;
+  }
+
+  /**
+   * @readonly
+   * @type {WritableStream}
+   */
+  get writable() {
+    if (!isDecompressionStream(this))
+      throw new ERR_INVALID_THIS('DecompressionStream');
+    return this[kTransform].writable;
+  }
+
+  [kInspect](depth, options) {
+    if (!isDecompressionStream(this))
+      throw new ERR_INVALID_THIS('DecompressionStream');
+    customInspect(depth, options, 'DecompressionStream', {
+      readable: this[kTransform].readable,
+      writable: this[kTransform].writable,
+    });
+  }
+}
+
+ObjectDefineProperties(CompressionStream.prototype, {
+  readable: kEnumerableProperty,
+  writable: kEnumerableProperty,
+});
+
+ObjectDefineProperties(DecompressionStream.prototype, {
+  readable: kEnumerableProperty,
+  writable: kEnumerableProperty,
+});
+
+module.exports = {
+  CompressionStream,
+  DecompressionStream,
+};

lib/internal/webstreams/encoding.js

@@ -14,10 +14,7 @@ const {
   TransformStream,
 } = require('internal/webstreams/transformstream');
 
-const {
-  customInspect,
-  kEnumerableProperty,
-} = require('internal/webstreams/util');
+const { customInspect } = require('internal/webstreams/util');
 
 const {
   codes: {
@@ -26,7 +23,8 @@ const {
 } = require('internal/errors');
 
 const {
-  customInspectSymbol: kInspect
+  customInspectSymbol: kInspect,
+  kEnumerableProperty,
 } = require('internal/util');
 
 const kHandle = Symbol('kHandle');