fix(bindgen): revert utf16 encoding changes

Author: vados-cosmonic

crates/js-component-bindgen/src/intrinsics/mod.rs

@@ -1195,11 +1195,7 @@ pub fn render_intrinsics(args: RenderIntrinsicsArgs) -> Source {
             .intrinsics
             .contains(&Intrinsic::String(StringIntrinsic::Utf16EncodeAsync))
     {
-        args.intrinsics.extend([
-            &Intrinsic::IsLE,
-            &Intrinsic::String(StringIntrinsic::GlobalTextEncoderUtf16),
-            &Intrinsic::String(StringIntrinsic::GlobalTextEncoderUtf16LittleEndian),
-        ]);
+        args.intrinsics.extend([&Intrinsic::IsLE]);
     }
 
     // Attempting to perform a debug message hoist will require string encoding to memory

crates/js-component-bindgen/src/intrinsics/string.rs

@@ -9,9 +9,6 @@ use crate::{intrinsics::Intrinsic, source::Source};
 pub enum StringIntrinsic {
     Utf16Decoder,
 
-    GlobalTextEncoderUtf16,
-    GlobalTextEncoderUtf16LittleEndian,
-
     Utf16Encode,
 
     Utf16EncodeAsync,
@@ -50,8 +47,6 @@ impl StringIntrinsic {
             Self::Utf8EncodeAsync.name(),
             Self::ValidateGuestChar.name(),
             Self::ValidateHostChar.name(),
-            Self::GlobalTextEncoderUtf16.name(),
-            Self::GlobalTextEncoderUtf16LittleEndian.name(),
         ]
     }
 
@@ -67,8 +62,6 @@ impl StringIntrinsic {
             Self::Utf8EncodeAsync => "_utf8AllocateAndEncodeAsync",
             Self::ValidateGuestChar => "validateGuestChar",
             Self::ValidateHostChar => "validateHostChar",
-            Self::GlobalTextEncoderUtf16 => "TEXT_DECODER_UTF16",
-            Self::GlobalTextEncoderUtf16LittleEndian => "TEXT_DECODER_UTF16_LE",
         }
     }
 
@@ -78,17 +71,8 @@ impl StringIntrinsic {
         match self {
             Self::Utf16Decoder => uwriteln!(output, "const {name} = new TextDecoder('utf-16');"),
 
-            Self::GlobalTextEncoderUtf16LittleEndian => {
-                uwriteln!(output, "const {name} = new TextEncoder('utf-16le');")
-            }
-            Self::GlobalTextEncoderUtf16 => {
-                uwriteln!(output, "const {name} = new TextEncoder('utf-16');")
-            }
-
             Self::Utf16Encode | Self::Utf16EncodeAsync => {
                 let is_le = Intrinsic::IsLE.name();
-                let utf16_encoder_le = Self::GlobalTextEncoderUtf16LittleEndian.name();
-                let utf16_encoder = Self::GlobalTextEncoderUtf16.name();
 
                 let (fn_preamble, realloc_call) = match self {
                     Self::Utf16Encode => ("", "realloc"),
@@ -98,25 +82,20 @@ impl StringIntrinsic {
                 uwriteln!(
                     output,
                     r#"
-                      {fn_preamble}function {name}(s, realloc, memory) {{
-                          if (typeof s !== 'string') {{
-                              throw new TypeError('expected a string, received [' + typeof s + ']');
-                          }}
-                          if (s.length === 0) {{ return {{ ptr: 1, len: 0 }}; }}
-
-                          let encoder;
+                      {fn_preamble}function {name}(str, realloc, memory) {{
+                          const len = str.length;
+                          const ptr = {realloc_call}(0, 0, 2, len * 2);
+                          const out = new Uint16Array(memory.buffer, ptr, len);
+                          let i = 0;
                           if ({is_le}) {{
-                              encoder = {utf16_encoder_le};
+                              while (i < len) {{ out[i] = str.charCodeAt(i++); }}
                           }} else {{
-                              encoder = {utf16_encoder};
+                              while (i < len) {{
+                                  const ch = str.charCodeAt(i);
+                                  out[i++] = (ch & 0xff) << 8 | ch >>> 8;
+                              }}
                           }}
-
-                          const bytes = encoder.encode(s);
-                          let ptr = {realloc_call}(0, 0, 1, bytes.byteLength);
-                          new Uint8Array(memory.buffer).set(bytes, ptr);
-
-                          const res = {{ ptr, len: bytes.length, codepoints: [...s].length }};
-                          return res;
+                          return {{ ptr, len, codepoints: [...str].length }};
                       }}
                     "#
                 );