react-native-store-version 1.4.2 → 2.0.0-beta.1

package/src/fetchers/ios.ts

@@ -0,0 +1,160 @@
+// App Store（iTunes Lookup API）の取得。react-native を import しない（Node でも動かす）
+import { StoreVersionError } from '../errors.ts';
+import { requestText } from '../request.ts';
+
+/** lookup の引き先。`bundleId`（v2 の既定）か、ストア URL から抜き出した数字の App ID（v1 互換の URL 方式） */
+export type IOSLookupTarget = { bundleId: string } | { appId: string };
+
+/** {@link lookupIOS} のオプション */
+export type IOSLookupOptions = {
+  /** 未指定ならタイムアウトしない（`requestText` の `timeoutMs`） */
+  timeoutMs?: number;
+  signal?: AbortSignal;
+};
+
+/** {@link lookupIOS} の結果 */
+export type IOSLookupResult = {
+  /** `results[0].version` */
+  version: string;
+  /** `results[0].trackViewUrl`（ストアを開く URL）。応答に無ければ null */
+  storeUrl: string | null;
+  /** `results[0].releaseNotes`。応答に無ければ undefined */
+  releaseNotes?: string;
+};
+
+/**
+ * App Store の URL（`https://apps.apple.com/jp/app/github/id1477376905` など）から数字の App ID を抜き出す。
+ * v1 と同じ正規表現。取れなければ null
+ */
+export const appIdFromStoreUrl = (storeUrl: string): string | null =>
+  storeUrl.match(/.+id([0-9]+)\??/)?.[1] ?? null;
+
+/** lookup の URL（タイムスタンプを付ける前。in-flight の共有のキーにもなる） */
+export const lookupUrl = (target: IOSLookupTarget, country: string): string => {
+  const query =
+    'bundleId' in target
+      ? `bundleId=${encodeURIComponent(target.bundleId)}`
+      : `id=${encodeURIComponent(target.appId)}`;
+  return `https://itunes.apple.com/lookup?${query}&country=${encodeURIComponent(country)}`;
+};
+
+const describeTarget = (target: IOSLookupTarget): string =>
+  'bundleId' in target
+    ? `bundleId ${JSON.stringify(target.bundleId)}`
+    : `appId ${JSON.stringify(target.appId)}`;
+
+/**
+ * iTunes Lookup API で App Store の版を引く。v1 と同じく URL にタイムスタンプを付け、`cache-control: no-cache` を送る。
+ *
+ * - 通信の失敗 / 200 以外 / JSON として読めない / `results[0].version` が文字列でない → `NETWORK`
+ * - `results` が空（未リリース・その国で未配信）→ `NOT_FOUND`
+ * - タイムアウト → `TIMEOUT`、`signal` の abort → `AbortError`
+ */
+export const lookupIOS = async (
+  target: IOSLookupTarget,
+  country: string,
+  { timeoutMs, signal }: IOSLookupOptions = {}
+): Promise<IOSLookupResult> => {
+  const url = lookupUrl(target, country);
+  const { status, body } = await requestText(url, {
+    timeoutMs,
+    signal,
+    noCache: true,
+  });
+  if (status !== 200) {
+    throw new StoreVersionError(
+      'NETWORK',
+      `iTunes Lookup responded with status ${status}`
+    );
+  }
+
+  let json: unknown;
+  try {
+    json = JSON.parse(body);
+  } catch (cause) {
+    throw new StoreVersionError(
+      'NETWORK',
+      'iTunes Lookup returned a response that is not JSON',
+      { cause }
+    );
+  }
+
+  // v1 と同じく、results が無い・空なら「ストアに無い」（v1 は `appID(<id>) is not released.`）
+  const results = (json as { results?: unknown } | null)?.results;
+  if (!Array.isArray(results) || results.length === 0) {
+    throw new StoreVersionError(
+      'NOT_FOUND',
+      `the app (${describeTarget(target)}) is not found on the App Store (${country})`
+    );
+  }
+
+  const app = results[0] as {
+    version?: unknown;
+    trackViewUrl?: unknown;
+    releaseNotes?: unknown;
+  } | null;
+  if (typeof app?.version !== 'string') {
+    throw new StoreVersionError(
+      'NETWORK',
+      'iTunes Lookup returned a result without a version'
+    );
+  }
+
+  const result: IOSLookupResult = {
+    version: app.version,
+    storeUrl:
+      typeof app.trackViewUrl === 'string' && app.trackViewUrl !== ''
+        ? app.trackViewUrl
+        : null,
+  };
+  if (typeof app.releaseNotes === 'string') {
+    result.releaseNotes = app.releaseNotes;
+  }
+  return result;
+};
+
+/**
+ * ストアを開く URL の取得結果。reject しない形にしてある（判定とは別に後から受け取るので、
+ * 誰も待っていなくても unhandled rejection にならないように）
+ */
+export type StoreUrlResult =
+  | { storeUrl: string; error: null }
+  | { storeUrl: null; error: StoreVersionError };
+
+/** lookup に失敗して URL を取れなかったときの `STORE_URL_UNAVAILABLE`。cause に lookup のエラー */
+export const storeUrlUnavailable = (
+  cause: unknown
+): { storeUrl: null; error: StoreVersionError } => ({
+  storeUrl: null,
+  error: new StoreVersionError(
+    'STORE_URL_UNAVAILABLE',
+    'could not get the App Store URL',
+    { cause }
+  ),
+});
+
+/** lookup の `storeUrl` から {@link StoreUrlResult} を作る（trackViewUrl が無ければ `STORE_URL_UNAVAILABLE`） */
+export const toStoreUrlResult = (storeUrl: string | null): StoreUrlResult =>
+  storeUrl === null
+    ? {
+        storeUrl: null,
+        error: new StoreVersionError(
+          'STORE_URL_UNAVAILABLE',
+          'iTunes Lookup returned no trackViewUrl'
+        ),
+      }
+    : { storeUrl, error: null };
+
+/**
+ * bundleId で lookup して、ストアを開く URL（`trackViewUrl`）だけを取る。`version` / `releaseNotes` は使わない
+ * （`getLatestVersion` の値と食い違いうるため）。失敗は reject せず `STORE_URL_UNAVAILABLE`（cause に lookup のエラー）で返す
+ */
+export const lookupStoreUrl = (
+  bundleId: string,
+  country: string,
+  options: IOSLookupOptions = {}
+): Promise<StoreUrlResult> =>
+  lookupIOS({ bundleId }, country, options).then(
+    (result) => toStoreUrlResult(result.storeUrl),
+    storeUrlUnavailable
+  );

package/src/index.ts

@@ -0,0 +1,37 @@
+// パッケージの入口。ここから export したものだけが公開 API になる
+// （resolve / evaluatePolicy / request / fetcher / detect / openStore などの内部の関数と、Provider の Context は出さない）
+import { checkVersion } from './checkVersion.ts';
+
+export type {
+  CheckVersionParams,
+  CheckVersionResponse,
+} from './checkVersion.ts';
+export type { CompareDetail, CompareResult, DiffType } from './compare.ts';
+export { compareVersion } from './compare.ts';
+export type { StoreVersionErrorCode } from './errors.ts';
+export { StoreVersionError } from './errors.ts';
+export type { VersionGetter, VersionGetterContext } from './fetchers/custom.ts';
+export type { Action, Policy } from './policy.ts';
+export type {
+  StoreVersionCheckResult,
+  StoreVersionProviderProps,
+} from './react/StoreVersionProvider.tsx';
+export { StoreVersionProvider } from './react/StoreVersionProvider.tsx';
+export type {
+  StoreVersionForceTexts,
+  StoreVersionResolvedTexts,
+  StoreVersionTexts,
+  StoreVersionWarningTexts,
+} from './react/texts.ts';
+export type {
+  StoreVersionComponents,
+  StoreVersionForceProps,
+  StoreVersionStatus,
+  StoreVersionWarningProps,
+  UseStoreVersionResult,
+} from './react/useStoreVersion.ts';
+export { useStoreVersion } from './react/useStoreVersion.ts';
+export { checkVersion };
+
+// v1 互換の default export。MIGRATION では named import（`import { checkVersion } from ...`）を勧める
+export default checkVersion;

package/src/openStore.ts

@@ -0,0 +1,74 @@
+// ストアを開く。ストアの URL は常にアプリ自身の ID から求める（開発者が URL や App ID を指定する手段は作らない。
+// 指定できると、意図的に別のアプリへ誘導できてしまう）
+import { Linking } from 'react-native';
+
+import { StoreVersionError } from './errors.ts';
+import { playStoreUrl } from './fetchers/android.ts';
+import { lookupStoreUrl, type StoreUrlResult } from './fetchers/ios.ts';
+
+/** `Linking.openURL` の失敗を、lookup の失敗と同じ `STORE_URL_UNAVAILABLE` に包む（cause に元のエラー） */
+const openURL = async (url: string): Promise<void> => {
+  try {
+    await Linking.openURL(url);
+  } catch (cause) {
+    throw new StoreVersionError(
+      'STORE_URL_UNAVAILABLE',
+      `could not open the store URL: ${url}`,
+      { cause }
+    );
+  }
+};
+
+/** {@link openStore} の引数 */
+export type OpenStoreParams = {
+  platform: 'ios' | 'android';
+  /** iOS は bundleId、Android は package name（detect の `appId`） */
+  appId: string;
+  /** iOS でもう一度 lookup するときの `country`（判定と同じ値） */
+  country: string;
+  /**
+   * iOS: 判定で取得中 / 取得済みの URL（resolve の `storeUrlResult`）。取得中なら完了を待ってから開き、
+   * 失敗していた・渡されなかったら、その場でもう一度 lookup する。Android では使わない
+   */
+  storeUrl?: PromiseLike<StoreUrlResult> | null;
+  /** iOS でもう一度 lookup するときのタイムアウト（ms）。未指定ならタイムアウトしない */
+  timeoutMs?: number;
+};
+
+/**
+ * ストアのアプリのページを開く。失敗はすべて `STORE_URL_UNAVAILABLE`（cause に元のエラー）で reject する
+ * （開発者が `onError` だけで失敗を拾えるように、Provider はこのエラーを `onError` にも渡す）。
+ *
+ * - iOS: lookup の `trackViewUrl` を開く。取得中なら待ち、失敗していたらもう一度 lookup する。
+ *   それも失敗したら reject する（cause に lookup のエラー。もう一度呼べば再試行する）。
+ *   `Linking.openURL` 自体の失敗も reject する（cause に `Linking.openURL` のエラー）
+ * - Android: `market://details?id=<package>` を開き、失敗したら `https://play.google.com/store/apps/details?id=<package>`。
+ *   https も失敗したときだけ reject する（cause に https の `Linking.openURL` のエラー）。
+ *   `canOpenURL` には頼らない（iOS の LSApplicationQueriesSchemes / Android 11 以降の queries の宣言が要るため）
+ */
+export const openStore = async ({
+  platform,
+  appId,
+  country,
+  storeUrl,
+  timeoutMs,
+}: OpenStoreParams): Promise<void> => {
+  if (platform === 'ios') {
+    let found = storeUrl ? await storeUrl : null;
+    if (!found || found.error) {
+      found = await lookupStoreUrl(appId, country, { timeoutMs });
+    }
+    if (found.error) {
+      throw found.error;
+    }
+    await openURL(found.storeUrl);
+    return;
+  }
+
+  try {
+    await Linking.openURL(`market://details?id=${encodeURIComponent(appId)}`);
+  } catch {
+    // Play ストアのアプリが無い端末（一部のエミュレータ・中国向けの端末など）はブラウザで開く
+    await openURL(playStoreUrl(appId));
+  }
+};

package/src/policy.ts

@@ -0,0 +1,223 @@
+import {
+  assertValidVersion,
+  type CompareDetail,
+  type CompareResult,
+  compareVersionOrThrow,
+  type DiffType,
+  diffType,
+  toDetail,
+} from './compare.ts';
+import { StoreVersionError } from './errors.ts';
+
+/** 判定の結果。`force` は強制、`warning` は警告、`none` は何も出さない */
+export type Action = 'force' | 'warning' | 'none';
+
+export type { DiffType };
+
+/**
+ * ストアとの差分に対する扱い。
+ *
+ * - 文字列 1 つ: 差分の種類によらずその値
+ * - オブジェクト: 差分の種類（`major` / `minor` / `patch`）ごとの値。省略したキーはデフォルト
+ *   （`{ major: 'force', minor: 'warning', patch: 'warning' }`）
+ * - 関数: `(local, remote)` から値を返す
+ *
+ * 注意（Android の段階公開）: Android で段階公開を使う場合、公開対象外のユーザーは新バージョンを
+ * 入手できないため、ストア差分による `force` でアプリを使えなくなる可能性がある。
+ * `Platform.OS === 'android'` のときは `major: 'warning'` にするか、`getMinimumVersion` で
+ * force を制御すること。iOS の段階的リリースは自動アップデートの配信ペースだけを制御し、
+ * App Store から手動ならいつでも更新できるので問題ない。
+ */
+export type Policy =
+  | Action
+  | Partial<Record<DiffType, Action>>
+  | ((local: string, remote: string) => Action);
+
+/** デフォルトの policy */
+export const DEFAULT_POLICY: Readonly<Record<DiffType, Action>> = Object.freeze(
+  {
+    major: 'force',
+    minor: 'warning',
+    patch: 'warning',
+  }
+);
+
+/** {@link evaluatePolicy} の結果 */
+export type PolicyResult = {
+  /** local と remote の比較（policy では変わらない）。remote が比較できず最低バージョンで force になったときだけ null */
+  result: CompareResult | null;
+  /** v1 と同じ `detail`（policy では変わらない）。`result` が null のときは null */
+  detail: CompareDetail | null;
+  /** policy と最低バージョンから決まる扱い */
+  action: Action;
+  /** 差分の種類。`result === 'new'` のときだけ値がある */
+  diff: DiffType | null;
+  /** 最低バージョンが比較できなかったとき（`MINIMUM_VERSION_FAILED`）。最低バージョンを飛ばして判定した */
+  minimumError?: StoreVersionError;
+  /** remote が比較できないが最低バージョン未満で force にしたとき（`INVALID_VERSION`） */
+  remoteError?: StoreVersionError;
+};
+
+/** {@link evaluatePolicy} の引数 */
+export type EvaluatePolicyParams = {
+  local: string;
+  remote: string;
+  /** 空文字 / null / undefined は指定なし */
+  minimum?: string | null;
+  /** 省略 / null / undefined はデフォルト */
+  policy?: Policy | null;
+};
+
+const ACTIONS: readonly string[] = ['force', 'warning', 'none'];
+
+const toAction = (value: unknown, cause?: unknown): Action => {
+  if (typeof value === 'string' && ACTIONS.includes(value)) {
+    return value as Action;
+  }
+  throw new StoreVersionError(
+    'POLICY_FAILED',
+    `policy returned an invalid action: ${typeof value === 'string' ? JSON.stringify(value) : `(${typeof value})`}`,
+    { cause }
+  );
+};
+
+const resolveAction = (
+  policy: Policy,
+  diff: DiffType,
+  local: string,
+  remote: string
+): Action => {
+  if (typeof policy === 'function') {
+    let value: unknown;
+    try {
+      value = policy(local, remote);
+    } catch (cause) {
+      throw new StoreVersionError('POLICY_FAILED', 'policy function threw', {
+        cause,
+      });
+    }
+    return toAction(value);
+  }
+  if (typeof policy === 'string') {
+    return toAction(policy);
+  }
+  if (typeof policy === 'object' && policy !== null) {
+    return toAction(policy[diff] ?? DEFAULT_POLICY[diff]);
+  }
+  return toAction(policy);
+};
+
+/**
+ * 最低バージョンが比較できない値なら、その `MINIMUM_VERSION_FAILED`（cause に compare-versions のエラー）を返す。
+ * 有効な値、または空文字 / null / undefined（指定なし）なら undefined。
+ * {@link evaluatePolicy} の `minimumError` と同じもの。判定が `INVALID_VERSION` で止まるときにも、
+ * 最低バージョンの不正を `onError` に渡せるようにするために分けてある
+ */
+export const minimumVersionError = (
+  minimum: string | null | undefined
+): StoreVersionError | undefined => {
+  if (minimum == null || minimum === '') {
+    return undefined;
+  }
+  try {
+    assertValidVersion(minimum, 'minimum');
+    return undefined;
+  } catch (e) {
+    return new StoreVersionError(
+      'MINIMUM_VERSION_FAILED',
+      (e as Error).message,
+      { cause: (e as StoreVersionError).cause }
+    );
+  }
+};
+
+const POLICY_KEYS: readonly DiffType[] = ['major', 'minor', 'patch'];
+
+const invalidPolicyValue = (value: unknown, key?: DiffType) =>
+  new StoreVersionError(
+    'POLICY_FAILED',
+    `policy${key ? `.${key}` : ''} is an invalid action: ${typeof value === 'string' ? JSON.stringify(value) : `(${typeof value})`}`
+  );
+
+/**
+ * 値で指定した policy（文字列・オブジェクト）を、差分が出る前に検証する。不正なら `POLICY_FAILED` を投げる。
+ * `evaluatePolicy` は差分が出たときにだけ policy を引くので、`local >= remote` の間は不正な値に気づけないため。
+ *
+ * - null / undefined（デフォルト）と関数は検証しない（関数の戻り値は判定のときに確かめる）
+ * - 文字列は `'force' | 'warning' | 'none'` のどれか
+ * - オブジェクトは `major` / `minor` / `patch` のうち、null / undefined でない値（省略はデフォルト）がどれも 3 値のどれか
+ * - それ以外の型（数値・真偽値など）は不正
+ */
+export const validatePolicy = (policy: unknown): void => {
+  if (policy == null || typeof policy === 'function') {
+    return;
+  }
+  if (typeof policy === 'object') {
+    for (const key of POLICY_KEYS) {
+      const value = (policy as Partial<Record<DiffType, unknown>>)[key];
+      if (value != null && !ACTIONS.includes(value as string)) {
+        throw invalidPolicyValue(value, key);
+      }
+    }
+    return;
+  }
+  if (!ACTIONS.includes(policy as string)) {
+    throw invalidPolicyValue(policy);
+  }
+};
+
+/**
+ * ポリシー判定（純粋関数）。順序: 1. `minimum` があり `local < minimum` なら `force`、
+ * 2. `local >= remote` なら `none`、3. 差分の種類で policy を引く。
+ *
+ * - local が比較できない値なら `INVALID_VERSION` を投げる（minimum があっても）
+ * - minimum が比較できない値なら、minimum を飛ばして判定を続け、結果に `minimumError` を添える
+ * - remote が比較できない値で、minimum が有効かつ `local < minimum` なら、
+ *   `{ result: null, detail: null, diff: null, action: 'force', remoteError }` を返す。それ以外は `INVALID_VERSION` を投げる
+ * - policy の関数が throw した / 不正な値を返したら `POLICY_FAILED` を投げる
+ */
+export const evaluatePolicy = ({
+  local,
+  remote,
+  minimum,
+  policy,
+}: EvaluatePolicyParams): PolicyResult => {
+  assertValidVersion(local, 'local');
+
+  const minimumError = minimumVersionError(minimum);
+  // local は上で検証済みなので、minimum が有効なら比較は投げない
+  const belowMinimum =
+    minimum != null &&
+    minimum !== '' &&
+    minimumError === undefined &&
+    compareVersionOrThrow(local, minimum, ['local', 'minimum']) === 'new';
+
+  try {
+    assertValidVersion(remote, 'remote');
+  } catch (e) {
+    if (belowMinimum) {
+      return {
+        result: null,
+        detail: null,
+        action: 'force',
+        diff: null,
+        remoteError: e as StoreVersionError,
+      };
+    }
+    throw e;
+  }
+
+  const result = compareVersionOrThrow(local, remote);
+  const detail = toDetail(result);
+  const diff = result === 'new' ? diffType(local, remote) : null;
+  const extra = minimumError ? { minimumError } : {};
+
+  if (belowMinimum) {
+    return { result, detail, action: 'force', diff, ...extra };
+  }
+  if (diff === null) {
+    return { result, detail, action: 'none', diff, ...extra };
+  }
+  const action = resolveAction(policy ?? DEFAULT_POLICY, diff, local, remote);
+  return { result, detail, action, diff, ...extra };
+};

package/src/react/DefaultForceModal.tsx

@@ -0,0 +1,100 @@
+// Force（強制アップデート）のデフォルト UI の中身。Force の元のデザインの実測値で作る。
+// 閉じるボタンは無い。Modal の枠（Android の戻るボタンで閉じない、幕、配置、アニメーション）は StoreVersionModal.tsx が持ち、
+// ここは `components.Force` が無いときにその中に描かれるカード
+import { Image, Platform, StyleSheet, Text, View } from 'react-native';
+
+import {
+  ActionButton,
+  BUTTON_TEXT_COLOR,
+  MAX_CONTENT_WIDTH,
+  messageStyle,
+  titleStyle,
+  usePalette,
+} from './defaultUi.tsx';
+import type { StoreVersionForceProps } from './useStoreVersion.ts';
+
+/** デザインの幕 `rgba(0, 0, 0, 0.55)` */
+export const FORCE_OVERLAY_COLOR = 'rgba(0, 0, 0, 0.55)';
+
+/**
+ * カードの影（デザイン: `box-shadow: 0 12px 40px rgba(0, 0, 0, .3)`）。iOS は shadow* にそのまま写し、
+ * Android は elevation に読み替える（影の y オフセット 12 を elevation に）。Platform.select はモジュールの読み込み時に評価される
+ */
+export const cardShadow = Platform.select({
+  ios: {
+    shadowColor: '#000000',
+    shadowOffset: { width: 0, height: 12 },
+    shadowOpacity: 0.3,
+    shadowRadius: 40,
+  },
+  android: { elevation: 12 },
+});
+
+/** デザインどおりのカード（`components.Force` が無いときの中身）。`texts` は置き換え済み */
+export const ForceCard = ({
+  texts,
+  icon,
+  openStore,
+}: StoreVersionForceProps) => {
+  const palette = usePalette();
+  return (
+    <View style={[styles.card, { backgroundColor: palette.card }]}>
+      {icon === undefined ? null : (
+        <Image
+          source={icon}
+          style={[styles.icon, { backgroundColor: palette.iconBg }]}
+        />
+      )}
+      <Text
+        accessibilityRole="header"
+        style={[titleStyle, styles.centered, { color: palette.text }]}
+      >
+        {texts.title}
+      </Text>
+      <Text style={[messageStyle, styles.centered, { color: palette.sub }]}>
+        {texts.message}
+      </Text>
+      <View style={styles.buttonRow}>
+        <ActionButton
+          label={texts.update}
+          onPress={() => {
+            // 開けたかどうかは使わない（失敗は onError に渡る。reject しない）
+            void openStore();
+          }}
+          backgroundColor={palette.primary}
+          color={BUTTON_TEXT_COLOR}
+        />
+      </View>
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  // デザイン: left/right 24（枠側の padding で取る）・radius 20・padding 28px 24px 24px・gap 14。
+  // 幅は枠いっぱい（スマホ縦向きではデザインと同じ）で、最大 480 に抑えて中央に置く（意図的に変える点）
+  card: {
+    width: '100%',
+    maxWidth: MAX_CONTENT_WIDTH,
+    alignSelf: 'center',
+    borderRadius: 20,
+    paddingTop: 28,
+    paddingHorizontal: 24,
+    paddingBottom: 24,
+    gap: 14,
+    ...cardShadow,
+  },
+  // デザイン: 64×64・radius 15・align-self center
+  icon: {
+    width: 64,
+    height: 64,
+    borderRadius: 15,
+    alignSelf: 'center',
+  },
+  centered: {
+    textAlign: 'center',
+  },
+  // デザイン: ボタンの前の margin-top 6
+  buttonRow: {
+    marginTop: 6,
+  },
+});