react-native-store-version 1.4.2 → 2.0.0

package/src/react/texts.ts

@@ -0,0 +1,119 @@
+// デフォルト UI の文言。型、英語の既定値、既定値との 1 段のマージと `{remote}` / `{local}` の置き換え。
+// React に依存しない純粋な関数にして、デフォルト UI と `components` の両方がこの結果を受け取る。
+// 日本語のプリセットは src/texts/ja.ts（`react-native-store-version/texts/ja`）
+
+/** Force（強制アップデート）の文言。`{remote}`（最新バージョン）/ `{local}`（現在のバージョン）は表示時に置き換える */
+export type StoreVersionForceTexts = {
+  title: string;
+  message: string;
+  /** 更新ボタン */
+  update: string;
+};
+
+/** Warning（閉じられるボトムシート）の文言。`{remote}` / `{local}` は表示時に置き換える */
+export type StoreVersionWarningTexts = {
+  title: string;
+  message: string;
+  /** 更新ボタン */
+  update: string;
+  /** 「あとで」ボタン */
+  later: string;
+};
+
+/**
+ * Provider の `texts`。`force` / `warning` ごとに、指定しなかったキーは英語の既定値で補完する（1 段だけマージ）。
+ * 日本語は `react-native-store-version/texts/ja` のプリセットを使う。変わったら表示中のモーダルにも反映する
+ */
+export type StoreVersionTexts = {
+  force?: Partial<StoreVersionForceTexts>;
+  warning?: Partial<StoreVersionWarningTexts>;
+};
+
+/** すべてのキーが埋まった文言（英語の既定値、`texts/ja` のプリセット、{@link resolveTexts} の結果の形） */
+export type StoreVersionResolvedTexts = {
+  force: StoreVersionForceTexts;
+  warning: StoreVersionWarningTexts;
+};
+
+/** 英語の既定値（元のデザインと同じ文言） */
+export const DEFAULT_TEXTS: StoreVersionResolvedTexts = {
+  force: {
+    title: 'Update required',
+    message:
+      'A new version ({remote}) is available. Please update to continue using the app.',
+    update: 'Update',
+  },
+  warning: {
+    title: 'Update available',
+    message: 'Version {remote} is now available.',
+    update: 'Update',
+    later: 'Later',
+  },
+};
+
+/** 置き換えに使う値。最新バージョンが比較できず、最低バージョンで force になったときは `remote` が null */
+export type TextVariables = {
+  local: string | null;
+  remote: string | null;
+};
+
+// プレースホルダーと、それを直接囲む括弧（半角 / 全角）・その前の空白。1 回の replace で全部を扱う
+// （置き換えた値をもう一度走査しないので、remote に "{local}" が入っていても二重に置換しない。
+// String.prototype.replaceAll に頼らないので古い JSC でも動く）
+const PLACEHOLDER = /(\s*)([(（]?)\{(local|remote)\}([)）]?)/g;
+
+const isPair = (open: string, close: string) =>
+  (open === '(' && close === ')') || (open === '（' && close === '）');
+
+// `{remote}` / `{local}` のすべての出現を置き換える。値が null（Play の版が比較できず、最低バージョンで force になったとき）は
+// 空文字にし、プレースホルダーを直接囲んでいた空の括弧「()」「（）」（とその前の空白）を取り除く。元の文言にある無関係な括弧は消さない。
+// 余った空白（連続する空白・前後の空白）も取り除く。既定の英語は「A new version is available. …」、
+// 日本語は「新しいバージョンが公開されています。…」になる。括弧を使っていない独自の文言では、ただ空文字に置き換わるだけ。
+// 値がそろっているときは文言に手を加えない
+const fill = (text: string, variables: TextVariables): string => {
+  let emptied = false;
+  const out = text.replace(
+    PLACEHOLDER,
+    (_match, space: string, open: string, key: string, close: string) => {
+      const value = variables[key as keyof TextVariables];
+      if (value !== null) {
+        return `${space}${open}${value}${close}`;
+      }
+      emptied = true;
+      return isPair(open, close) ? '' : `${space}${open}${close}`;
+    }
+  );
+  return emptied ? out.replace(/ {2,}/g, ' ').trim() : out;
+};
+
+// 指定された値が文字列のときだけ使う（JS からの利用で数値や null を渡されても既定の文言に戻す）
+const textOrDefault = (value: unknown, fallback: string): string =>
+  typeof value === 'string' ? value : fallback;
+
+/**
+ * Provider の `texts` を表示用の文言にする。`force` / `warning` ごとに、指定しなかったキー（文字列でない値も）を英語の既定値で
+ * 補完し（1 段だけマージ）、`{remote}` / `{local}` のすべての出現を置き換える。
+ * `texts` / `local` / `remote` が変わるたびに呼ぶ（`texts` の変更を表示中のモーダルにも即座に反映するため）
+ */
+export const resolveTexts = (
+  texts: StoreVersionTexts | undefined,
+  variables: TextVariables
+): StoreVersionResolvedTexts => {
+  const force = { ...DEFAULT_TEXTS.force };
+  const warning = { ...DEFAULT_TEXTS.warning };
+  for (const key of Object.keys(force) as (keyof StoreVersionForceTexts)[]) {
+    force[key] = fill(
+      textOrDefault(texts?.force?.[key], force[key]),
+      variables
+    );
+  }
+  for (const key of Object.keys(
+    warning
+  ) as (keyof StoreVersionWarningTexts)[]) {
+    warning[key] = fill(
+      textOrDefault(texts?.warning?.[key], warning[key]),
+      variables
+    );
+  }
+  return { force, warning };
+};

package/src/react/useIsomorphicLayoutEffect.ts

@@ -0,0 +1,8 @@
+// サーバーでの描画（react-native-web の SSR など）では useLayoutEffect が React 18 で警告を出すので、window が無ければ useEffect にする。
+// Provider（props の ref）とデフォルト UI の Modal（閉じる途中に描く最後の props）が、commit の後・配下の passive effect より先に ref を書くために使う
+import { useEffect, useLayoutEffect } from 'react';
+
+export const useIsomorphicLayoutEffect =
+  (globalThis as { window?: unknown }).window === undefined
+    ? useEffect
+    : useLayoutEffect;

package/src/react/useStoreVersion.ts

@@ -0,0 +1,153 @@
+// Provider が持つ判定結果を配下に配る Context と、それを読むだけの hook。
+// 判定は Provider が 1 つだけ持つので、hook を何箇所で使っても fetch は増えない
+import { type ComponentType, createContext, useContext } from 'react';
+import type { ColorValue, ImageSourcePropType } from 'react-native';
+
+import type { CompareDetail, CompareResult, DiffType } from '../compare.ts';
+import type { StoreVersionError } from '../errors.ts';
+import type { Action } from '../policy.ts';
+import type {
+  StoreVersionForceTexts,
+  StoreVersionTexts,
+  StoreVersionWarningTexts,
+} from './texts.ts';
+
+/**
+ * 進行状態。
+ * - `idle`: まだ判定していない（マウント直後。バックグラウンドのままマウントされたら active になるまで）
+ * - `checking`: 判定中
+ * - `ready`: 判定できた（`result` / `action` などに値が入る）
+ * - `skipped`: 判定しない環境（web / ios・android 以外の OS / Expo Go / `enabled={false}`）。`onError` は呼ばない
+ * - `error`: 判定できなかった（`error` に理由。UI は出さない）
+ */
+export type StoreVersionStatus =
+  | 'idle'
+  | 'checking'
+  | 'ready'
+  | 'skipped'
+  | 'error';
+
+/** {@link useStoreVersion} の戻り値 */
+export type UseStoreVersionResult = {
+  /** 進行状態 */
+  status: StoreVersionStatus;
+  /**
+   * 比較の結果（`ready` のときのみ。再チェック中の `checking` では前回の ready の値）。v1 の `checkVersion()` と同じ値で、policy では変わらない。
+   * 最新バージョンが比較できず、最低バージョンで force になったときは null
+   */
+  result: CompareResult | null;
+  /** v1 の `checkVersion()` と同じ `detail`（`result` と同じく、ready と再チェック中のみ） */
+  detail: CompareDetail | null;
+  /**
+   * policy と最低バージョンを当てた結果（`result` と同じく、ready と再チェック中のみ）。デフォルト UI はこれで出す。
+   * 再チェックの間も前回の値のままなので、force のモーダルは再チェック中に消えない
+   */
+  action: Action | null;
+  /** 差分の種類（`result` が `'new'` のときのみ） */
+  diff: DiffType | null;
+  /** `action` が `warning` だが「あとで」（`dismiss`）が押されて UI を出していない。remote が変われば false に戻る */
+  dismissed: boolean;
+  /** アプリのバージョン（ネイティブのバージョン）。判定を始めた後に入る */
+  local: string | null;
+  /** 最新バージョン（`result` と同じく、ready と再チェック中のみ） */
+  remote: string | null;
+  /** 開くべきストアの URL（`result` と同じく、ready と再チェック中のみ）。iOS で URL を取得中・取得に失敗したときは null */
+  storeUrl: string | null;
+  /** iOS でストアのバージョンを使ったときの `releaseNotes`（`result` と同じく、ready と再チェック中のみ）。Android と `getLatestVersion` 使用時は undefined */
+  releaseNotes: string | undefined;
+  /**
+   * ストアのアプリのページを開く。iOS で URL を取得中なら待ち、取れていなければその場でもう一度 lookup する。
+   * 開けたら true、開けなかったら false で resolve する（reject しない。`onPress={openStore}` のまま使える）。
+   * 失敗（iOS の lookup の失敗・`Linking.openURL` の失敗・判定前や skipped で開く先が分からない）は
+   * `STORE_URL_UNAVAILABLE` で `onError` に渡す。`status` / `error` は変えない
+   */
+  openStore: () => Promise<boolean>;
+  /** warning を閉じる（同じ remote のバージョンの間は出さない。メモリだけに持つので、次に起動したら再び出る） */
+  dismiss: () => void;
+  /**
+   * 手動で再チェックする（判定中なら、それを取り消してやり直す）。再チェックの間も前回の結果は残り、失敗したら前回の結果に戻る。
+   * バックグラウンドの間に呼ばれたら、active になってから始める
+   */
+  recheck: () => void;
+  /** 判定できなかった理由（`error` のときのみ。再チェックの失敗では前回の結果に戻るので入らない。`onError` には渡る） */
+  error: StoreVersionError | null;
+};
+
+/**
+ * `components.Force` に渡す props。このコンポーネントが描くのはカードの中身だけで、Modal・幕・配置・
+ * Android の戻るボタンで閉じないこと・開閉のアニメーションはライブラリが持つ。
+ * 置かれ方: 左右 24 の余白の内側で画面の縦中央、ScrollView の中。カードの面（背景・角丸・影・最大幅 480）はライブラリは掛けないので、
+ * このコンポーネントが自分で描く
+ */
+export type StoreVersionForceProps = {
+  local: string;
+  /** 最新バージョン。Play の版が比較できず、最低バージョンで force になったときは null */
+  remote: string | null;
+  storeUrl: string | null;
+  releaseNotes: string | undefined;
+  /** `{remote}` / `{local}` を置き換え済みの文言 */
+  texts: StoreVersionForceTexts;
+  icon: ImageSourcePropType | undefined;
+  /** 開けたら true、開けなかったら false（reject しない。失敗は `onError` に渡る） */
+  openStore: () => Promise<boolean>;
+};
+
+/**
+ * `components.Warning` に渡す props。Force の props に加えて `dismiss`（「あとで」）。このコンポーネントが描くのはシートの中身だけで、
+ * Modal・幕・配置・戻るボタン / 背景タップで `dismiss` すること・開閉のアニメーションはライブラリが持つ。
+ * 置かれ方: 画面幅で下寄せ、ScrollView の中。シートの面（背景・角丸・影・最大幅 480）はライブラリは掛けないので、
+ * このコンポーネントが自分で描く
+ */
+export type StoreVersionWarningProps = Omit<StoreVersionForceProps, 'texts'> & {
+  /** `{remote}` / `{local}` を置き換え済みの文言 */
+  texts: StoreVersionWarningTexts;
+  dismiss: () => void;
+};
+
+/**
+ * デフォルト UI の中身の差し替え。差し替えられるのはカード（Force）/ シート（Warning）の中身だけ。
+ * Modal、幕（オーバーレイ）の色、配置、Android の戻るボタンと背景タップの扱い（Force は閉じない、Warning は `dismiss`）、
+ * 開閉のアニメーションはライブラリが持ち、差し替えても変わらない。
+ * 置かれ方: Force は左右 24 の余白の内側で画面の縦中央、Warning は画面幅で下寄せ。どちらも ScrollView の中。
+ * カード / シートの面（背景・角丸・影・最大幅 480）はライブラリは掛けないので、差し替えたコンポーネントが自分で描く
+ */
+export type StoreVersionComponents = {
+  Force?: ComponentType<StoreVersionForceProps>;
+  Warning?: ComponentType<StoreVersionWarningProps>;
+};
+
+/** デフォルト UI に渡す表示の設定（Provider の props をそのまま置く） */
+export type StoreVersionDisplay = {
+  ui: boolean;
+  texts: StoreVersionTexts | undefined;
+  icon: ImageSourcePropType | undefined;
+  components: StoreVersionComponents | undefined;
+  primaryColor: ColorValue | undefined;
+};
+
+/**
+ * 判定の状態の Context（hook が読む。パッケージの入口からは export しない）。
+ * 表示の設定とは分けてある（インラインの `texts` などで Provider が描画し直しても、hook を使う側を描画し直さないように）
+ */
+export const StoreVersionStateContext =
+  createContext<UseStoreVersionResult | null>(null);
+StoreVersionStateContext.displayName = 'StoreVersionStateContext';
+
+/** 表示の設定の Context（デフォルト UI が読む。パッケージの入口からは export しない） */
+export const StoreVersionDisplayContext =
+  createContext<StoreVersionDisplay | null>(null);
+StoreVersionDisplayContext.displayName = 'StoreVersionDisplayContext';
+
+/**
+ * `StoreVersionProvider` が持つ判定結果を読む。Provider 配下ならどこでも呼べ、何箇所で呼んでも fetch は増えない。
+ * Provider の外で呼ぶと throw する
+ */
+export const useStoreVersion = (): UseStoreVersionResult => {
+  const state = useContext(StoreVersionStateContext);
+  if (state === null) {
+    throw new Error(
+      'useStoreVersion() must be called inside <StoreVersionProvider>. Wrap your app (or the component tree that calls it) with <StoreVersionProvider> from react-native-store-version.'
+    );
+  }
+  return state;
+};

package/src/request.ts

@@ -0,0 +1,328 @@
+// ストアへの取得の共通部分（タイムアウト / in-flight の共有 / iTunes のキャッシュ回避）。
+// react-native を import しない（Node でも動かす。canary でも使う）。
+// 古い Hermes に無い API（AbortSignal.timeout / AbortSignal.any / DOMException など）は使わず、
+// AbortController と setTimeout だけで組む
+import { StoreVersionError } from './errors.ts';
+
+/**
+ * 呼び出し元の `signal` が abort されたときに投げるエラー（`name === 'AbortError'`）。
+ * 古い Hermes には DOMException が無いので、name だけを合わせた Error にする
+ */
+export const createAbortError = (): Error => {
+  const error = new Error('The operation was aborted.');
+  error.name = 'AbortError';
+  return error;
+};
+
+/** `createAbortError` や fetch の abort で投げられたエラーか */
+export const isAbortError = (error: unknown): boolean =>
+  typeof error === 'object' &&
+  error !== null &&
+  (error as { name?: unknown }).name === 'AbortError';
+
+// setTimeout は 2^31 - 1 ms を超えるとすぐに発火する（オーバーフロー）ので、そこで頭打ちにする
+const MAX_TIMEOUT_MS = 2147483647;
+
+/** タイムアウトを入れるか。正の有限の数のときだけ（0 / 負 / NaN / Infinity / 未指定はタイムアウトなし） */
+const hasTimeout = (timeoutMs: number | undefined): timeoutMs is number =>
+  typeof timeoutMs === 'number' && timeoutMs > 0 && timeoutMs !== Infinity;
+
+/** 呼び出し元の signal とタイムアウトを 1 つにまとめた signal（{@link createScope}） */
+export type Scope = {
+  /** 呼び出し元の signal が abort されたとき、またはタイムアウトしたときに abort される */
+  readonly signal: AbortSignal;
+  /** abort の理由がタイムアウトだったか */
+  readonly timedOut: boolean;
+  /** 自分から abort する（タイムアウト扱いにはしない） */
+  abort(): void;
+  /** タイマーと呼び出し元の signal への登録を外す（終わったら必ず呼ぶ） */
+  dispose(): void;
+};
+
+/**
+ * 呼び出し元の `signal` と `timeoutMs` から、どちらかで abort される signal を作る。
+ * `timeoutMs` が未指定（または正の有限の数でない）ならタイムアウトしない
+ */
+export const createScope = ({
+  signal,
+  timeoutMs,
+}: {
+  signal?: AbortSignal;
+  timeoutMs?: number;
+} = {}): Scope => {
+  const controller = new AbortController();
+  let timedOut = false;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+
+  const dispose = () => {
+    if (timer !== undefined) {
+      clearTimeout(timer);
+      timer = undefined;
+    }
+    signal?.removeEventListener('abort', onAbort);
+  };
+  function onAbort() {
+    dispose();
+    controller.abort();
+  }
+
+  if (signal?.aborted) {
+    controller.abort();
+  } else {
+    signal?.addEventListener('abort', onAbort);
+    if (hasTimeout(timeoutMs)) {
+      timer = setTimeout(
+        () => {
+          timer = undefined;
+          timedOut = true;
+          dispose();
+          controller.abort();
+        },
+        Math.min(timeoutMs, MAX_TIMEOUT_MS)
+      );
+    }
+  }
+
+  return {
+    signal: controller.signal,
+    get timedOut() {
+      return timedOut;
+    },
+    abort: () => {
+      dispose();
+      controller.abort();
+    },
+    dispose,
+  };
+};
+
+/**
+ * `promise` の完了か `signal` の abort の早い方で終わる。abort なら `createAbortError()` で reject する。
+ * `signal` を見ない処理（開発者の `getLatestVersion` など）を、タイムアウトや呼び出し元の abort で打ち切るため。
+ * 打ち切った後に `promise` が reject しても unhandled rejection にはならない
+ */
+export const raceAbort = <T>(
+  promise: PromiseLike<T>,
+  signal: AbortSignal
+): Promise<T> =>
+  new Promise<T>((resolve, reject) => {
+    const onAbort = () => reject(createAbortError());
+    if (signal.aborted) {
+      onAbort();
+    } else {
+      signal.addEventListener('abort', onAbort);
+    }
+    promise.then(
+      (value) => {
+        signal.removeEventListener('abort', onAbort);
+        resolve(value);
+      },
+      (error: unknown) => {
+        signal.removeEventListener('abort', onAbort);
+        reject(error);
+      }
+    );
+  });
+
+/** {@link requestText} の結果。成功・失敗を問わず status と本文を返す（status の扱いは fetcher が決める） */
+export type TextResponse = {
+  readonly status: number;
+  readonly body: string;
+};
+
+/** {@link requestText} のオプション */
+export type RequestOptions = {
+  /**
+   * この呼び出し元のタイムアウト（ms）。未指定ならタイムアウトしない（10 秒の既定は Provider が渡す）。
+   * 共有中の取得に後から加わった呼び出し元も、自分の `timeoutMs` で数える（ほかの呼び出し元の値には影響されない）。
+   * 時間切れの呼び出し元だけが `TIMEOUT` で抜け、その時点で待っている呼び出し元がいなければ fetch も止める
+   */
+  timeoutMs?: number;
+  /**
+   * この呼び出し元の取り消し。abort するとこの呼び出し元だけが `AbortError` で抜ける。
+   * ほかの呼び出し元が同じ取得を待っていれば fetch は続く
+   */
+  signal?: AbortSignal;
+  /**
+   * iTunes Lookup の CDN キャッシュを避ける。URL の末尾にタイムスタンプ（`&<ts>`）を付け、
+   * `cache-control: no-cache` を送る（v1 と同じ形）
+   */
+  noCache?: boolean;
+};
+
+// 本文の読み込みに失敗した NETWORK のエラーと、その応答の status。StoreVersionError にフィールドを足さずに（公開の形を変えずに）
+// v1 互換の checkVersion へ status を渡すため。WeakMap なのでエラーが捨てられれば消える（キャッシュではない）
+const failedResponseStatus = new WeakMap<object, number>();
+
+/**
+ * {@link requestText} の `NETWORK` のうち、応答（status）は受け取ったが本文の読み込みに失敗したものなら、その status を返す。
+ * fetch 自体が失敗した場合やほかの値なら undefined。v1 互換の checkVersion が、v1 と同じく Android の 200 以外を
+ * 本文より先に `androidStoreURL is invalid.` にするために使う（パッケージの入口からは export しない）
+ */
+export const failedResponseStatusOf = (error: unknown): number | undefined =>
+  typeof error === 'object' && error !== null
+    ? failedResponseStatus.get(error)
+    : undefined;
+
+type Entry = {
+  key: string;
+  promise: Promise<TextResponse>;
+  controller: AbortController;
+  /** この取得を待っている呼び出し元の数 */
+  waiters: number;
+  settled: boolean;
+  /** 待っている呼び出し元が 0 になってから fetch を止めるまでのタイマー */
+  idleTimer: ReturnType<typeof setTimeout> | undefined;
+};
+
+// 取得中のものだけを持つ（完了したら消す。結果は保持しない）。キーはタイムスタンプを付ける前の取得先
+const inflight = new Map<string, Entry>();
+
+const clearIdleTimer = (entry: Entry) => {
+  if (entry.idleTimer !== undefined) {
+    clearTimeout(entry.idleTimer);
+    entry.idleTimer = undefined;
+  }
+};
+
+/** 誰も待っていなければ fetch を止める。後から来た呼び出し元は新しく取り直す */
+const stopIfIdle = (entry: Entry) => {
+  clearIdleTimer(entry);
+  if (entry.settled || entry.waiters > 0) {
+    return;
+  }
+  if (inflight.get(entry.key) === entry) {
+    inflight.delete(entry.key);
+  }
+  entry.controller.abort();
+};
+
+const start = (key: string, url: string, noCache: boolean): Entry => {
+  const controller = new AbortController();
+  // v1 と同じく、タイムスタンプはクエリの最後に `&<ts>` で付ける
+  const target = noCache
+    ? `${url}${url.includes('?') ? '&' : '?'}${Date.now()}`
+    : url;
+  const init: RequestInit = noCache
+    ? { headers: { 'cache-control': 'no-cache' }, signal: controller.signal }
+    : { signal: controller.signal };
+
+  const promise = (async (): Promise<TextResponse> => {
+    let status: number | undefined;
+    try {
+      const response = await fetch(target, init);
+      status = response.status;
+      return { status, body: await response.text() };
+    } catch (cause) {
+      const error = new StoreVersionError(
+        'NETWORK',
+        `request to ${url} failed`,
+        { cause }
+      );
+      // 応答は来たが本文の読み込みに失敗した場合だけ、その status を添える（{@link failedResponseStatusOf}）
+      if (typeof status === 'number') {
+        failedResponseStatus.set(error, status);
+      }
+      throw error;
+    }
+  })();
+
+  const entry: Entry = {
+    key,
+    promise,
+    controller,
+    waiters: 0,
+    settled: false,
+    idleTimer: undefined,
+  };
+  const settle = () => {
+    entry.settled = true;
+    clearIdleTimer(entry);
+    if (inflight.get(key) === entry) {
+      inflight.delete(key);
+    }
+  };
+  // 待っている呼び出し元が全員抜けた後の reject（abort）も、ここで受けるので unhandled rejection にならない
+  promise.then(settle, settle);
+  return entry;
+};
+
+/**
+ * `url` を取得して status と本文を返す。同じ取得先（タイムスタンプを付ける前の URL と `noCache`）への同時の呼び出しは
+ * 1 回の fetch にまとめ、完了したら（成功・失敗とも）共有をやめる（次の呼び出しは取り直す。キャッシュしない）。
+ *
+ * - 通信の失敗（fetch の reject / 本文の読み込みの失敗）は `StoreVersionError('NETWORK')`（cause に元のエラー）
+ * - この呼び出し元のタイムアウトは `StoreVersionError('TIMEOUT')`
+ * - この呼び出し元の `signal` の abort は `AbortError`（{@link isAbortError}）
+ * - 実際の fetch を止めるのは、待っている呼び出し元が全員抜けたとき。タイムアウトで抜けた場合はすぐ止め、
+ *   abort で抜けた場合は次のタスクまで待ってから止める（StrictMode では 1 回目の effect の cleanup の abort の直後に
+ *   2 回目の effect が同じ取得に加わるので、それを受け取れるようにするため）。上位（resolve など）のタイムアウトは
+ *   `signal` の abort として届くので、abort と同じく次のタスクで止める
+ *
+ * HTTP の status は見ない（200 以外の扱いは fetcher が決める）
+ */
+export const requestText = (
+  url: string,
+  { timeoutMs, signal, noCache = false }: RequestOptions = {}
+): Promise<TextResponse> =>
+  new Promise<TextResponse>((resolve, reject) => {
+    const scope = createScope({ signal, timeoutMs });
+    if (scope.signal.aborted) {
+      reject(createAbortError());
+      return;
+    }
+
+    const key = `${noCache ? 'no-cache ' : ''}${url}`;
+    let entry = inflight.get(key);
+    if (!entry) {
+      entry = start(key, url, noCache);
+      inflight.set(key, entry);
+    }
+    const joined = entry;
+    joined.waiters += 1;
+    clearIdleTimer(joined);
+
+    let done = false;
+    const finish = () => {
+      done = true;
+      scope.signal.removeEventListener('abort', onLeave);
+      scope.dispose();
+    };
+    // finish() で外すので、結果を受け取った後には呼ばれない
+    function onLeave() {
+      const timedOut = scope.timedOut;
+      finish();
+      joined.waiters -= 1;
+      if (joined.waiters === 0) {
+        if (timedOut) {
+          stopIfIdle(joined);
+        } else {
+          joined.idleTimer = setTimeout(() => stopIfIdle(joined), 0);
+        }
+      }
+      reject(
+        timedOut
+          ? new StoreVersionError(
+              'TIMEOUT',
+              `request to ${url} timed out after ${timeoutMs}ms`
+            )
+          : createAbortError()
+      );
+    }
+    scope.signal.addEventListener('abort', onLeave);
+
+    joined.promise.then(
+      (value) => {
+        if (!done) {
+          finish();
+          resolve(value);
+        }
+      },
+      (error: unknown) => {
+        if (!done) {
+          finish();
+          reject(error);
+        }
+      }
+    );
+  });