async function uppercaseExample() {
  try {
    const response = await fetch('https://example.com/sometext.txt');

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    // レスポンスボディをTransformStreamに通して大文字に変換
    const transformedStream = response.body
      .pipeThrough(new TextDecoderStream()) // バイトをテキストに変換
      .pipeThrough(new TransformStream({ // テキストを大文字に変換
        transform(chunk, controller) {
          controller.enqueue(chunk.toUpperCase());
        }
      }))
      .pipeThrough(new TextEncoderStream()); // テキストをバイトに戻す

    // 結果の処理
    const reader = transformedStream.getReader();
    const chunks = []; // チャンクを格納する配列
    const textDecoder = new TextDecoder(); // TextDecoderを再利用

    for (;;) {
      const {
        done,
        value
      } = await reader.read();
      if (done) break;
      chunks.push(textDecoder.decode(value));
    }

    const result = chunks.join(''); // チャンクを連結
    console.log(result); // 大文字に変換されたテキスト

  } catch (error) {
    console.error('Error:', error);
  }
}

uppercaseExample();

const jsonFilterTransformer = new TransformStream({
  transform(chunk, controller) {
    try {
      const data = JSON.parse(chunk);
      
      // 例: scoreが80以上のオブジェクトのみをフィルタリング
      if (data.score >= 80) {
        controller.enqueue(JSON.stringify(data) + '\n');
      }
    } catch (error) {
      console.error('JSON解析エラー:', error);
    }
  }
});

async function filterJsonData() {
  const response = await fetch('https://example.com/data.json');
  
  // JSONデータをフィルタリング
  const filteredStream = response.body
    .pipeThrough(new TextDecoderStream())
    .pipeThrough(jsonFilterTransformer);
  
  const reader = filteredStream.getReader();
  
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    console.log('フィルタリングされたデータ:', value);
  }
}

// 画像処理のためのTransformStream
const imageProcessor = new TransformStream({
  async start(controller) {
    // WebAssemblyモジュールの読み込み（例）
    this.wasm = await WebAssembly.instantiateStreaming(
      fetch('/image-processor.wasm')
    );
  },
  async transform(chunk, controller) {
    // WAMSを使って画像データを処理
    const processedImageData = this.wasm.instance.exports.processImage(chunk);
    controller.enqueue(processedImageData);
  }
});

async function processImageStream() {
  const response = await fetch('https://example.com/large-image.jpg');
  const processedStream = response.body.pipeThrough(imageProcessor);
  
  // 処理された画像データをBlobに変換
  const reader = processedStream.getReader();
  const chunks = [];
  
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    chunks.push(value);
  }
  
  const blob = new Blob(chunks, { type: 'image/jpeg' });
  const url = URL.createObjectURL(blob);
  
  // 画像を表示（例）
  const img = document.createElement('img');
  img.src = url;
  document.body.appendChild(img);
}

// 遅延処理のシミュレーション
const slowTransformer = new TransformStream({
  async transform(chunk, controller) {
    // 重い処理をシミュレート
    await new Promise(resolve => setTimeout(resolve, 500));
    controller.enqueue(`処理済み: ${chunk}`);
  }
});

// バックプレッシャーが効いているのを確認するために
// 書き込みを高速で行う
async function demonstrateBackpressure() {
  const writer = slowTransformer.writable.getWriter();
  const reader = slowTransformer.readable.getReader();
  
  // 読み取りループを開始（バックグラウンドで）
  const readPromise = (async () => {
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      console.log('読み取り:', value);
    }
  })();
  
  console.time('書き込み時間');
  
  // 高速で書き込み - バックプレッシャーによって自動的に制御される
  for (let i = 0; i < 10; i++) {
    console.log(`書き込み #${i} 開始`);
    await writer.write(`チャンク ${i}`);
    console.log(`書き込み #${i} 完了`);
  }
  
  console.timeEnd('書き込み時間');
  writer.close();
}

const errorHandlingTransformer = new TransformStream({
  transform(chunk, controller) {
    try {
      if (chunk === 'error') {
        throw new Error('エラーを発生させるチャンク');
      }
      controller.enqueue(`変換済み: ${chunk}`);
    } catch (error) {
      controller.error(error); // エラーをストリームに伝播
    }
  }
});

async function handleErrors() {
  const { writable, readable } = errorHandlingTransformer;
  
  // 読み取り側で、エラーを処理
  const reader = readable.getReader();
  
  // 書き込み側
  const writer = writable.getWriter();
  
  try {
    await writer.write('正常なデータ');
    await writer.write('error'); // エラー発生
    await writer.write('これは処理されない');
  } catch (error) {
    console.error('書き込み側でエラーを捕捉:', error);
  }
  
  // 読み取り側
  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      console.log(value);
    }
  } catch (error) {
    console.error('読み取り側でエラーを捕捉:', error);
  }
}