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

package/dist/checkVersion.d.ts

@@ -0,0 +1,73 @@
+import { type CompareDetail, type CompareResult } from './compare.ts';
+/** {@link checkVersion} の引数。v2 ではすべて省略できる */
+export type CheckVersionParams = {
+    /**
+     * アプリのバージョン。必ずネイティブのバージョン（iOS の `CFBundleShortVersionString` / Android の `versionName`）を渡す。
+     * `Constants.expoConfig.version` や `package.json` の値は JS バンドルに含まれ、OTA 更新で変わってしまう
+     * （ネイティブは古いのに「更新済み」と誤判定する）ので使わないこと。
+     *
+     * 省略（空文字も含む）すると、iOS / Android では expo-application の `nativeApplicationVersion` →
+     * react-native-device-info の `getVersion()` の順に取る。取れなければ `local version is not set.` を throw する。
+     * Expo Go の中では Expo Go 自体のバージョンが取れてしまうので、Expo Go で試すときは明示的に渡すこと
+     */
+    version?: string;
+    /**
+     * App Store の URL（`https://apps.apple.com/jp/app/github/id1477376905` など。`id<数字>` から App ID を取る）。
+     * 省略（空文字も含む）すると、iOS ではアプリの bundleId（expo-application の `applicationId` →
+     * react-native-device-info の `getBundleId()`）で引く。取れなければ `iosStoreURL is not set.` を throw する。
+     * Expo Go の中で省略すると Expo Go 自体（`host.exp.Exponent`）を引いてしまうので、Expo Go で試すときは URL も明示すること
+     */
+    iosStoreURL?: string;
+    /**
+     * Google Play の URL（`https://play.google.com/store/apps/details?id=<package>`）。
+     * 省略（空文字も含む）すると、Android ではアプリの package name（expo-application の `applicationId` →
+     * react-native-device-info の `getBundleId()`）から URL を組み立てる。取れなければ `androidStoreURL is not set.` を throw する。
+     * Expo Go の中で省略すると Expo Go 自体（`host.exp.exponent`）を引いてしまうので、Expo Go で試すときは URL も明示すること
+     */
+    androidStoreURL?: string;
+    /** iTunes Lookup の国コード（iOS のみ）。省略（空文字も含む）すると `jp`（v1 と同じ） */
+    country?: string;
+    /**
+     * ストアへの問い合わせのタイムアウト（ms）。省略するとタイムアウトしない（v1 と同じ）。
+     * 正の有限の数のときだけ有効（0・負の数・NaN・Infinity はタイムアウトなし）。
+     * 時間切れのときは `StoreVersionError`（`code: 'TIMEOUT'`）を throw する
+     */
+    timeoutMs?: number;
+};
+/** {@link checkVersion} の戻り値（v1 と同じ形） */
+export type CheckVersionResponse = {
+    /** アプリのバージョン（渡した値か、自動取得した値） */
+    local: string;
+    /** ストアのバージョン */
+    remote: string;
+    /** `remote` が新しければ `new`、古ければ `old`、同じなら `equal` */
+    result: CompareResult;
+    detail: CompareDetail;
+};
+/**
+ * v1 互換のバージョン確認。ストアのバージョンを取得して、`version` と比べた結果を返す。
+ *
+ * 引数をすべて渡した場合は v1 と同じ結果・同じエラーメッセージになる（`country` の既定も `jp`）。ただし次の 2 点は v1 と違う:
+ * - バージョンの比較は compare-versions 6.1.1 の挙動（プレリリースの一部や、先頭の `^` / `~` / `=` / 大文字の `V` などの扱い）
+ * - Android の版は v2 の抽出（構造に錨を下ろしたパターン → v1 のパターンの順）で取る。v1 では取れなかった
+ *   `5` / `1.0.0-beta.1` のような版も返し、版の位置より前にある古い版は拾わない。版の位置が空なら `can't get android app version.`
+ *
+ * 省略した引数は、iOS / Android では自動取得する（expo-application か react-native-device-info が必要）。
+ * `Platform.OS` が ios / android 以外（web など）のときは v1 と同じく Android の経路で `androidStoreURL` を取得し、自動取得はしない。
+ *
+ * 失敗は `Error` で reject する（メッセージは v1 と同じ）。`timeoutMs` の時間切れだけは `StoreVersionError`（`code: 'TIMEOUT'`）。
+ * Expo Go や web でも判定を省かない（v1 と同じ）。Expo Go の中で version / URL を省略すると Expo Go 自体の値を使ってしまうので、
+ * Expo Go で試すときはすべて明示すること。v2 の Provider / hook と違い、起動を止めない仕組みは持たないので、
+ * 呼び出し側で catch すること
+ *
+ * @example
+ * import { checkVersion } from 'react-native-store-version';
+ *
+ * const { result } = await checkVersion({
+ *   version: '1.0.0', // ネイティブのバージョン
+ *   iosStoreURL: 'https://apps.apple.com/jp/app/github/id1477376905',
+ *   androidStoreURL: 'https://play.google.com/store/apps/details?id=com.github.android',
+ * });
+ */
+export declare const checkVersion: (params?: CheckVersionParams) => Promise<CheckVersionResponse>;
+//# sourceMappingURL=checkVersion.d.ts.map

package/dist/checkVersion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkVersion.d.ts","sourceRoot":"","sources":["../src/checkVersion.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,aAAa,EAGnB,MAAM,cAAc,CAAC;AAOtB,6CAA6C;AAC7C,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,yCAAyC;AACzC,MAAM,MAAM,oBAAoB,GAAG;IACjC,+BAA+B;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,MAAM,EAAE,aAAa,CAAC;IACtB,MAAM,EAAE,aAAa,CAAC;CACvB,CAAC;AAgHF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,YAAY,YACf,kBAAkB,KACzB,OAAO,CAAC,oBAAoB,CAoE9B,CAAC"}

package/dist/checkVersion.js

@@ -0,0 +1,193 @@
+// v1 互換の checkVersion。取得の層（request / fetcher / detect）の上に載せ替えたもの。
+// 同じ入力（v1 で必須だった引数をすべて渡した場合）なら v1 と同じ戻り値・エラーメッセージを返す。
+// 例外は compare-versions 6.1.1 の比較の差と、Android の版の抽出が v2 の抽出（構造に錨を下ろしたパターン → v1 のパターンの順）になること。
+// v1 で throw していた「引数が無い」場面だけ、自動取得に回す。
+// v2 の判定の層（resolve）は使わない。policy / getter が無く、エラーを v1 のメッセージに戻すには取得の層を直接呼ぶ必要があり、
+// Expo Go や ios / android 以外の OS の skip（v2 の判定）も checkVersion では行わない（v1 と同じく判定する）ため
+import { Platform } from 'react-native';
+import { compareVersion, toDetail, } from './compare.js';
+import { nativeAppId, nativeVersion } from './detect.js';
+import { StoreVersionError } from './errors.js';
+import { extractPlayVersion, playStoreUrl } from './fetchers/android.js';
+import { appIdFromStoreUrl, lookupIOS } from './fetchers/ios.js';
+import { failedResponseStatusOf, requestText } from './request.js';
+/*
+ * v1 のエラーメッセージへの対応表（v1 の src/index.ts / ios.ts / android.ts の全経路）。
+ * 取得の段階で起きたものは、v1 と同じく `new Error(e.message)`（Error でなければ `can't get ${Platform.OS} version`）で
+ * 投げ直す。v2 の層の `StoreVersionError` は {@link toV1Error} で v1 のメッセージに戻す。
+ *
+ * | 経路（v1）                                          | v1 のメッセージ                       | v2 の層での扱い                                         | checkVersion が投げるもの             |
+ * |-----------------------------------------------------|---------------------------------------|---------------------------------------------------------|---------------------------------------|
+ * | `version` が falsy                                   | `local version is not set.`           | ios / android は自動取得。取れなければ v1 と同じ          | 同じ                                  |
+ * | iOS で `iosStoreURL` が falsy                        | `iosStoreURL is not set.`             | bundleId を自動取得。取れなければ v1 と同じ               | 同じ                                  |
+ * | Android で `androidStoreURL` が falsy                | `androidStoreURL is not set.`         | package name を自動取得。取れなければ v1 と同じ           | 同じ                                  |
+ * | iOS の URL が正規表現に合わない                       | `iosStoreURL is invalid.`             | `appIdFromStoreUrl` が null                              | 同じ                                  |
+ * | fetch / `text()` が Error で reject                  | 元のメッセージ                        | `requestText` の `NETWORK`（cause に元のエラー）          | `new Error(cause.message)`            |
+ * | fetch / `text()` が Error でないもので reject         | `can't get ${Platform.OS} version`    | `NETWORK`（cause が Error でない）                        | 同じ                                  |
+ * | iOS の本文が JSON でない（status は見ない）           | `JSON.parse` のメッセージ             | URL: v1 と同じ処理 / bundleId: `NETWORK`（cause に SyntaxError） | `new Error(SyntaxError の message)` |
+ * | iOS の `results` が無い・空（`null` の応答も）         | `appID(<id>) is not released.`        | URL: v1 と同じ処理 / bundleId: `NOT_FOUND`                | 同じ（bundleId は `appID(<bundleId>)`）|
+ * | iOS の `results[0]` が null など（TypeError）         | TypeError のメッセージ                | URL: v1 と同じ処理 / bundleId: `NETWORK`（cause なし）    | URL: 同じ / bundleId: `can't get ios version` |
+ * | iOS の `results[0].version` が文字列でない            | （そのまま remote にして比較で throw） | URL: v1 と同じ処理 / bundleId: `NETWORK`（cause なし）    | URL: 同じ / bundleId: `can't get ios version` |
+ * | iOS の 200 以外                                       | （見ない。本文で上のどれかになる）     | URL: v1 と同じ処理 / bundleId: `NETWORK`（cause なし）    | URL: 同じ / bundleId: `can't get ios version` |
+ * | Android の URL が正規表現に合わない（ios 以外で省略も） | `androidStoreURL is invalid.`         | checkVersion で検証                                      | 同じ                                  |
+ * | Android の 200 以外                                   | `androidStoreURL is invalid.`         | `requestText` の status を checkVersion で見る             | 同じ（package name の経路も）          |
+ * | Android の 200 以外で本文の読み込みが失敗              | `androidStoreURL is invalid.`（v1 は本文を読まない） | `NETWORK`（`failedResponseStatusOf` で status が分かる） | 同じ（package name の経路も）          |
+ * | Android の 200 で本文の読み込みが失敗                  | 元のメッセージ                        | `NETWORK`（cause に元のエラー）                           | `new Error(cause.message)`            |
+ * | Android の版が抽出できない                            | `can't get android app version.`      | `extractPlayVersion` の `PARSE_FAILED` / `INVALID_VERSION`（Varies・比較できない版） | 同じ |
+ * | 比較できない local（取得の後）                        | compare-versions のメッセージ          | `compareVersion`（try の外。包まない）                    | 同じ                                  |
+ * | （v1 に無い）`timeoutMs` の時間切れ                    | —                                     | `TIMEOUT`                                                | `StoreVersionError('TIMEOUT')` そのまま |
+ *
+ * iOS の URL 方式は `lookupIOS` を使わず `requestText` で v1 と同じ処理をする。`lookupIOS` は 200 以外を `NETWORK` にし、
+ * `country` を encode し、`results[0].version` が文字列でないと `NETWORK` にするので、v1 の結果（本文の JSON を読む）を
+ * 再現できないため。Android は 200 以外のメッセージ（`androidStoreURL is invalid.`）を通信の失敗と分けるために、
+ * `fetchAndroidVersion` ではなく `requestText` と `extractPlayVersion`（v2 の抽出）を使う。
+ * Android の抽出は URL を渡した経路でも v2 のもの（v1 と同じ結果を保つ方針の例外）で、v1 と結果が分かれるのは、版の位置に v1 のパターン
+ * （数字とドットだけ）に合わない比較できる版（`5` / `1.0.0-beta.1` / `v2.1` など）がある場合（v1 は抽出できず throw）、
+ * 版の位置より前に v1 のパターン（`[[["x.y.z"]],`）の形の別の要素がある場合（v1 はそれを拾う）、版の位置が空なのにほかの場所に
+ * v1 のパターンが当たる場合（v1 はそれを拾う）。2026-11-08 の実ページでは v1 のパターンに当たるのは版の位置だけで、v1 と結果は同じだった
+ */
+/** v1 の `getAndroidVersion` の URL の検証 */
+const V1_ANDROID_STORE_URL = /^https?:\/\/play\.google\.com\/store\/apps\/details\?id=[0-9a-zA-Z.]+/;
+/** 取得の段階で起きたエラーを v1 のメッセージに戻す（上の表） */
+const toV1Error = (error, os, appId) => {
+    if (error instanceof StoreVersionError) {
+        switch (error.code) {
+            // v1 にはタイムアウトが無い（`timeoutMs` を渡したときだけ起きる）ので、code で区別できるようにそのまま投げる
+            case 'TIMEOUT':
+                return error;
+            // 通信の失敗は、v1 と同じく元のエラーのメッセージで投げ直す
+            case 'NETWORK':
+                return error.cause instanceof Error
+                    ? new Error(error.cause.message)
+                    : new Error(`can't get ${os} version`);
+            case 'NOT_FOUND':
+                return new Error(`appID(${appId}) is not released.`);
+            case 'PARSE_FAILED':
+            case 'INVALID_VERSION':
+                return new Error("can't get android app version.");
+        }
+    }
+    return error instanceof Error
+        ? new Error(error.message)
+        : new Error(`can't get ${os} version`);
+};
+/** v1 の `getIOSVersion` と同じ処理（status は見ず、本文を JSON として読む）。取得だけ `requestText` に載せる */
+const iosVersionByStoreUrl = async (appId, country, timeoutMs) => {
+    // v1 と同じく country は encode しない。タイムスタンプと no-cache は requestText が付ける
+    const { body } = await requestText(`https://itunes.apple.com/lookup?id=${appId}&country=${country}`, { noCache: true, timeoutMs });
+    const response = JSON.parse(body);
+    // v1 の `!response || !response.results || ...` と同じ（null / false / 0 などの応答も未リリース扱い）
+    if (!response?.results || response.results.length === 0) {
+        throw new Error(`appID(${appId}) is not released.`);
+    }
+    return response.results[0].version;
+};
+/** Play Store のページを取得して版を返す。200 以外は v1 と同じく `androidStoreURL is invalid.` */
+const androidVersionByUrl = async (url, timeoutMs) => {
+    let response;
+    try {
+        response = await requestText(url, { timeoutMs });
+    }
+    catch (error) {
+        // v1 は status を先に見て、200 以外なら本文を読まない。v2 の request は本文を読むので、その読み込みに失敗しても
+        // 200 以外なら v1 と同じメッセージにする
+        const status = failedResponseStatusOf(error);
+        if (status !== undefined && status !== 200) {
+            throw new Error('androidStoreURL is invalid.');
+        }
+        throw error;
+    }
+    if (response.status !== 200) {
+        throw new Error('androidStoreURL is invalid.');
+    }
+    return extractPlayVersion(response.body);
+};
+/**
+ * v1 互換のバージョン確認。ストアのバージョンを取得して、`version` と比べた結果を返す。
+ *
+ * 引数をすべて渡した場合は v1 と同じ結果・同じエラーメッセージになる（`country` の既定も `jp`）。ただし次の 2 点は v1 と違う:
+ * - バージョンの比較は compare-versions 6.1.1 の挙動（プレリリースの一部や、先頭の `^` / `~` / `=` / 大文字の `V` などの扱い）
+ * - Android の版は v2 の抽出（構造に錨を下ろしたパターン → v1 のパターンの順）で取る。v1 では取れなかった
+ *   `5` / `1.0.0-beta.1` のような版も返し、版の位置より前にある古い版は拾わない。版の位置が空なら `can't get android app version.`
+ *
+ * 省略した引数は、iOS / Android では自動取得する（expo-application か react-native-device-info が必要）。
+ * `Platform.OS` が ios / android 以外（web など）のときは v1 と同じく Android の経路で `androidStoreURL` を取得し、自動取得はしない。
+ *
+ * 失敗は `Error` で reject する（メッセージは v1 と同じ）。`timeoutMs` の時間切れだけは `StoreVersionError`（`code: 'TIMEOUT'`）。
+ * Expo Go や web でも判定を省かない（v1 と同じ）。Expo Go の中で version / URL を省略すると Expo Go 自体の値を使ってしまうので、
+ * Expo Go で試すときはすべて明示すること。v2 の Provider / hook と違い、起動を止めない仕組みは持たないので、
+ * 呼び出し側で catch すること
+ *
+ * @example
+ * import { checkVersion } from 'react-native-store-version';
+ *
+ * const { result } = await checkVersion({
+ *   version: '1.0.0', // ネイティブのバージョン
+ *   iosStoreURL: 'https://apps.apple.com/jp/app/github/id1477376905',
+ *   androidStoreURL: 'https://play.google.com/store/apps/details?id=com.github.android',
+ * });
+ */
+export const checkVersion = async (params = {}) => {
+    const os = Platform.OS;
+    // 自動取得は ios / android だけ（ほかの OS は v1 と同じ挙動のまま。ネイティブの値がストアの版と対応しないため）
+    const autoDetect = os === 'ios' || os === 'android';
+    // v1 が `local version is not set.` を投げていた条件（falsy）のときだけ自動取得に回す
+    const version = params.version || (autoDetect ? nativeVersion() : null);
+    if (!version) {
+        throw new Error('local version is not set.');
+    }
+    let fetchRemote;
+    // NOT_FOUND を v1 の `appID(<id>) is not released.` に戻すときの id
+    let appId = '';
+    if (os === 'ios') {
+        const country = params.country || 'jp';
+        if (params.iosStoreURL) {
+            const storeUrl = params.iosStoreURL;
+            fetchRemote = async () => {
+                const id = appIdFromStoreUrl(storeUrl);
+                if (id === null) {
+                    throw new Error('iosStoreURL is invalid.');
+                }
+                return iosVersionByStoreUrl(id, country, params.timeoutMs);
+            };
+        }
+        else {
+            const bundleId = nativeAppId();
+            if (bundleId === null) {
+                throw new Error('iosStoreURL is not set.');
+            }
+            appId = bundleId;
+            fetchRemote = async () => (await lookupIOS({ bundleId }, country, {
+                timeoutMs: params.timeoutMs,
+            })).version;
+        }
+    }
+    else if (os === 'android' && !params.androidStoreURL) {
+        const packageName = nativeAppId();
+        if (packageName === null) {
+            throw new Error('androidStoreURL is not set.');
+        }
+        fetchRemote = () => androidVersionByUrl(playStoreUrl(packageName), params.timeoutMs);
+    }
+    else {
+        // v1 は ios 以外をすべて Android の経路に進める（web などで省略された場合は `androidStoreURL is invalid.`）。
+        // v1 の `getAndroidVersion(storeURL = '')` の既定引数と同じく、undefined のときだけ空文字にする
+        const storeUrl = params.androidStoreURL === undefined ? '' : params.androidStoreURL;
+        fetchRemote = async () => {
+            if (!storeUrl.match(V1_ANDROID_STORE_URL)) {
+                throw new Error('androidStoreURL is invalid.');
+            }
+            return androidVersionByUrl(storeUrl, params.timeoutMs);
+        };
+    }
+    let remote;
+    try {
+        remote = await fetchRemote();
+    }
+    catch (error) {
+        throw toV1Error(error, os, appId);
+    }
+    // v1 と同じく比較は try の外（比較できない local は compare-versions のメッセージがそのまま出る）
+    const result = compareVersion(version, remote);
+    return { local: version, remote, result, detail: toDetail(result) };
+};

package/dist/cli/check.js

@@ -0,0 +1,38 @@
+// `check` サブコマンドのチェックを順に回す
+import { resolveIds } from './checks/ids.js';
+import { checkInstalled } from './checks/installed.js';
+import { checkPeers } from './checks/peers.js';
+import { checkRollout } from './checks/rollout.js';
+import { checkStore } from './checks/store.js';
+import { checkVersions } from './checks/versions.js';
+import { readProject } from './project/index.js';
+/** アプリの構成（Expo の設定・ネイティブのプロジェクト）を使うチェック */
+const PROJECT_CHECKS = ['C2', 'C3', 'C4', 'C8'];
+/** チェックを C1 → C2 → C3 → C4 → C7 → C8 の順に回す。`ignore` にあるものは回さない */
+export const runChecks = async ({ cwd, country, ignore, }) => {
+    const enabled = (id) => !ignore.has(id);
+    const entries = [];
+    // C3（ID で引く）・C8（Android か）は C2 が特定した ID を使うので、`--ignore C2` でも ID の特定はする（C2 の行だけを出さない）。
+    // Expo の設定の評価（アプリの app.config.* を動かす）は、どれも使わないときはしない
+    const project = PROJECT_CHECKS.some(enabled) ? readProject(cwd) : null;
+    const ids = project === null ? null : resolveIds(project);
+    if (enabled('C1')) {
+        entries.push(...checkInstalled(cwd));
+    }
+    if (ids !== null && enabled('C2')) {
+        entries.push(...ids.entries);
+    }
+    if (ids !== null && enabled('C3')) {
+        entries.push(...(await checkStore({ ios: ids.ios, android: ids.android }, { country })));
+    }
+    if (project !== null && enabled('C4')) {
+        entries.push(...checkVersions(project));
+    }
+    if (enabled('C7')) {
+        entries.push(...checkPeers(cwd));
+    }
+    if (ids !== null && enabled('C8')) {
+        entries.push(...checkRollout(cwd, ids.android));
+    }
+    return entries;
+};

package/dist/cli/checks/ids.js

@@ -0,0 +1,111 @@
+const IOS = {
+    name: 'iOS',
+    idName: 'bundleId',
+    dir: 'ios/',
+    expoKey: 'ios.bundleIdentifier',
+};
+const ANDROID = {
+    name: 'Android',
+    idName: 'package',
+    dir: 'android/',
+    expoKey: 'android.package',
+};
+/**
+ * 1 つのプラットフォームの ID を決める。ネイティブのディレクトリがあればその値（Expo の設定とずれていれば info）、
+ * ネイティブから特定できなければ Expo の設定の値。ネイティブのディレクトリが無ければ（CNG・bare RN で片方だけなど）Expo の設定の値
+ */
+const resolvePlatform = (spec, project, expoValue, native) => {
+    const { name, idName, dir, expoKey } = spec;
+    const expoFile = project.expo?.config?.file;
+    const fromExpo = expoValue !== null && expoFile !== undefined
+        ? `${expoKey} in ${expoFile}`
+        : null;
+    if (native?.value != null) {
+        const notes = fromExpo !== null && expoValue !== native.value
+            ? [
+                `the ${name} ${idName} differs between ${native.label} "${native.value}" (${native.file}) and ${expoKey} "${expoValue}" (${expoFile}); using the native one, "${native.value}"`,
+            ]
+            : [];
+        return {
+            id: native.value,
+            message: `${name} ${idName} "${native.value}" (${native.label} in ${native.file})`,
+            notes,
+        };
+    }
+    if (native !== null) {
+        // ネイティブのディレクトリはあるが、値が特定できない
+        if (fromExpo !== null && expoValue !== null) {
+            return {
+                id: expoValue,
+                message: `${name} ${idName} "${expoValue}" (${fromExpo})`,
+                notes: [
+                    `could not determine the ${name} ${idName} from ${dir} (${native.reason}); using ${expoKey} "${expoValue}" (${expoFile})`,
+                ],
+            };
+        }
+        return { id: null, reason: native.reason, notes: [] };
+    }
+    if (fromExpo !== null && expoValue !== null) {
+        return {
+            id: expoValue,
+            message: `${name} ${idName} "${expoValue}" (${fromExpo})`,
+            notes: [],
+        };
+    }
+    if (expoFile !== undefined) {
+        return {
+            id: null,
+            reason: `${expoKey} is not set in ${expoFile} and there is no ${dir} directory`,
+            notes: [],
+        };
+    }
+    return {
+        id: null,
+        reason: project.expo === null
+            ? `there is no ${dir} directory and expo is not installed`
+            : `the Expo config could not be read and there is no ${dir} directory`,
+        notes: [],
+    };
+};
+/**
+ * C2。両方のプラットフォームが特定できなければ error、片方だけなら、もう片方は info（C3 はそのプラットフォームを飛ばす）。
+ * Expo の設定の評価の失敗・複数の .xcodeproj / アプリのターゲット・flavor の無視・Expo の設定とネイティブのずれは info で添える
+ */
+export const resolveIds = (project) => {
+    const config = project.expo?.config ?? null;
+    const ios = resolvePlatform(IOS, project, config?.bundleIdentifier ?? null, project.ios?.bundleId ?? null);
+    const android = resolvePlatform(ANDROID, project, config?.package ?? null, project.android?.packageName ?? null);
+    const entries = [];
+    if (ios.id === null && android.id === null) {
+        entries.push({
+            id: 'C2',
+            level: 'error',
+            message: `could not determine either the iOS bundleId or the Android package. iOS: ${ios.reason}. Android: ${android.reason}. Check that --cwd is the app directory`,
+        });
+    }
+    else {
+        for (const [spec, resolved] of [
+            [IOS, ios],
+            [ANDROID, android],
+        ]) {
+            entries.push(resolved.id === null
+                ? {
+                    id: 'C2',
+                    level: 'info',
+                    message: `could not determine the ${spec.name} ${spec.idName}: ${resolved.reason}. C3 skips ${spec.name}`,
+                }
+                : { id: 'C2', level: 'ok', message: resolved.message });
+        }
+    }
+    const notes = [
+        ...(project.expo?.notes ?? []),
+        ...(project.ios?.notes ?? []),
+        ...ios.notes,
+        ...(project.android?.notes ?? []),
+        ...android.notes,
+    ];
+    for (const message of notes) {
+        entries.push({ id: 'C2', level: 'info', message });
+    }
+    return { ios: ios.id, android: android.id, entries };
+};

package/dist/cli/checks/installed.js

@@ -0,0 +1,51 @@
+// C1: react-native-store-version がインストールされていて v2 以上か
+import { readFileSync } from 'node:fs';
+import { compareVersion } from '../../compare.js';
+import { findPackageJson } from '../packages.js';
+const PACKAGE_NAME = 'react-native-store-version';
+/**
+ * v2 の最初の版（プレリリースを含む）。`2.0.0-beta.x` も `2.0.0` もこれ以上になる
+ */
+const V2_FLOOR = '2.0.0-0';
+/**
+ * C1。`<cwd>` から `react-native-store-version/package.json` を探して（{@link findPackageJson}）`name` と `version` を読む。
+ * `npm:react-native-store-version@1` のようなエイリアス名で入れたもの（`react-native-store-version-v1` など）は見ない。
+ *
+ * - 見つからない / 読めない / 別のパッケージ / version が比較できない → error
+ * - v2 より前（`2.0.0-0` より小さい）→ info
+ */
+export const checkInstalled = (cwd) => {
+    const entry = (level, message) => [
+        { id: 'C1', level, message },
+    ];
+    const path = findPackageJson(cwd, PACKAGE_NAME);
+    if (path === null) {
+        return entry('error', `${PACKAGE_NAME} is not installed (no node_modules/${PACKAGE_NAME}/package.json in ${cwd} or its parents)`);
+    }
+    let json;
+    try {
+        json = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (error) {
+        return entry('error', `could not read ${path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const { name, version } = (json ?? {});
+    if (name !== PACKAGE_NAME) {
+        return entry('error', `${path} is not ${PACKAGE_NAME} (name: ${JSON.stringify(name)})`);
+    }
+    let result;
+    try {
+        if (typeof version !== 'string') {
+            throw new TypeError('not a string');
+        }
+        // compareVersion(local, remote) は remote の方が新しいときに 'new'。つまり version < 2.0.0-0
+        result = compareVersion(version, V2_FLOOR);
+    }
+    catch {
+        return entry('error', `could not read the version of ${PACKAGE_NAME} in ${path} (version: ${JSON.stringify(version)})`);
+    }
+    if (result === 'new') {
+        return entry('info', `${PACKAGE_NAME} ${version} is v1. StoreVersionProvider and this check are for v2 or later`);
+    }
+    return entry('ok', `${PACKAGE_NAME} ${version} is installed`);
+};

package/dist/cli/checks/peers.js

@@ -0,0 +1,31 @@
+// C7: version / ID の自動取得に使う optional peer があるか。パッケージの解決だけを見て、
+// アプリのソースは検索しない（Provider に値を渡しているかは見ない）
+import { isInstalled } from '../packages.js';
+/** 自動取得に使う optional peer（src/detect.ts が読む順） */
+export const AUTO_DETECT_PEERS = [
+    'expo-application',
+    'react-native-device-info',
+];
+/**
+ * C7。どちらかが `<cwd>` から見つかれば（{@link isInstalled}）ok、どちらも無ければ info
+ * （`version` / `bundleId` / `packageName` を Provider に渡していれば不要なので、warning にはしない）
+ */
+export const checkPeers = (cwd) => {
+    const found = AUTO_DETECT_PEERS.filter((name) => isInstalled(cwd, name));
+    if (found.length > 0) {
+        return [
+            {
+                id: 'C7',
+                level: 'ok',
+                message: `${found.join(' and ')} found for detecting the app version and ID`,
+            },
+        ];
+    }
+    return [
+        {
+            id: 'C7',
+            level: 'info',
+            message: `neither ${AUTO_DETECT_PEERS.join(' nor ')} is installed. Pass version / bundleId / packageName to StoreVersionProvider, or install one of them`,
+        },
+    ];
+};

package/dist/cli/checks/rollout.js

@@ -0,0 +1,141 @@
+// C8: Android の段階公開の注意。Google Play の段階公開では、公開対象外のユーザーは新しい版を入手できない。
+// ストアの版との差分で force にしていると、その人たちはアプリを使えなくなる。ソースの簡易なテキスト検索で、
+// その設定になっていそうなときに注意を出す（誤検知はありうるので、--ignore C8 で抑止できることを書く）
+import { displayPath } from '../project/files.js';
+import { findOpeningTags, maskSource, readObjectLiteral, } from '../project/jsx.js';
+import { SCAN_LIMITS, scanSources, } from '../project/sources.js';
+const PROVIDER = 'StoreVersionProvider';
+/** ストアの差分によらず版を渡す関数。どこかで使っていれば、force をストアの差分だけで決めていない */
+const VERSION_GETTERS = /\b(getLatestVersion|getMinimumVersion)\b/;
+/** 一覧に出すファイルの数（多いと 1 行が長くなりすぎる） */
+const MAX_LISTED = 5;
+const files = (n) => `${n} file${n === 1 ? '' : 's'}`;
+const listFiles = (files) => files.length > MAX_LISTED
+    ? `${files.slice(0, MAX_LISTED).join(', ')} and ${files.length - MAX_LISTED} more`
+    : files.join(', ');
+const ROLLOUT_NOTE = "If you use a staged rollout on Google Play, users outside the rollout cannot get the new version, so a force update from the store version can leave them unable to use the app. When Platform.OS === 'android', set major: 'warning' in the policy, or control force with getMinimumVersion. This is a simple text search and may be a false positive (a policy that already uses major: 'warning' only on Android still has 'force' in it); if so, suppress it with --ignore C8";
+/** 理由の文言（`<StoreVersionProvider> …` に続く） */
+const REASONS = {
+    noPolicy: "has no policy prop (the default policy has major: 'force')",
+    spread: 'has no policy prop (it may come from a spread)',
+    force: "has 'force' in its policy",
+    noMajor: "does not set major in its policy, so major updates use the default 'force'",
+    defaultPolicy: (expression) => `has policy={${expression}}, so the default policy (major: 'force') is used`,
+};
+/** null / undefined は省略と同じで既定値になる */
+const isDefault = (expression) => expression === 'undefined' || expression === 'null';
+/**
+ * policy 属性の値（`{…}` / `"…"` の書かれたまま）から、ストアの差分で force になりそうな理由。
+ * `'force'` / `"force"` があるか、`{undefined}` / `{null}`（既定の policy）か、オブジェクトリテラルで `major` が無い・
+ * null / undefined（既定の major は force）。変数や関数の policy は中身が分からないので、`'force'` の有無だけを見る。
+ * `...base` を含むオブジェクトは major がそこから来うるので、major の有無は見ない
+ */
+const policyReasons = (value) => {
+    if (value === null) {
+        // 値の無い `policy`（true）。型の誤りで、判定の材料にならない
+        return [];
+    }
+    const reasons = [];
+    if (/'force'|"force"/.test(value)) {
+        reasons.push(REASONS.force);
+    }
+    if (!value.startsWith('{') || !value.endsWith('}')) {
+        return reasons;
+    }
+    const expression = maskSource(value.slice(1, -1), { strings: false }).trim();
+    if (isDefault(expression)) {
+        return [REASONS.defaultPolicy(expression)];
+    }
+    const object = readObjectLiteral(expression);
+    if (object !== null && !object.spread) {
+        const major = object.properties.get('major');
+        if (major === undefined || (major !== null && isDefault(major))) {
+            reasons.push(REASONS.noMajor);
+        }
+    }
+    return reasons;
+};
+/**
+ * 1 つのファイルの `<StoreVersionProvider …>` の開始タグのうち、ストアの差分で force になりそうなものの理由
+ * （policy 属性が無い = デフォルトの major が force。{@link policyReasons}）。重複は 1 つにする
+ */
+const forceReasons = (source) => {
+    const reasons = new Set();
+    for (const tag of findOpeningTags(source, PROVIDER)) {
+        const policy = tag.attributes.find(({ name }) => name === 'policy');
+        if (policy === undefined) {
+            reasons.add(tag.spreads > 0 ? REASONS.spread : REASONS.noPolicy);
+            continue;
+        }
+        for (const reason of policyReasons(policy.value)) {
+            reasons.add(reason);
+        }
+    }
+    return [...reasons];
+};
+/**
+ * C8。Android の package が特定できたときだけ（無ければ skipped）。`<cwd>` の下のソースを走査し、
+ * `<StoreVersionProvider>` の開始タグが force になりそうなファイルごとに warning。ただし `getLatestVersion` /
+ * `getMinimumVersion` が走査したどこかのファイルにあれば、どれも出さない。ファイル数の上限を超えたら判定せずに info
+ */
+export const checkRollout = (cwd, androidPackage, limits = SCAN_LIMITS) => {
+    if (androidPackage === null) {
+        return [
+            {
+                id: 'C8',
+                level: 'skipped',
+                message: 'no Android package was determined, so the staged rollout note does not apply',
+            },
+        ];
+    }
+    const flagged = [];
+    let getterFile = null;
+    const scan = scanSources(cwd, (path, source) => {
+        // コメントの中の名前（`// TODO: getMinimumVersion を使う`）は使っていることにならない
+        if (getterFile === null &&
+            VERSION_GETTERS.test(maskSource(source, { strings: false }))) {
+            getterFile = displayPath(cwd, path);
+        }
+        if (source.includes(PROVIDER)) {
+            const reasons = forceReasons(source);
+            if (reasons.length > 0) {
+                flagged.push({ file: displayPath(cwd, path), reasons });
+            }
+        }
+    }, limits);
+    if (scan.truncated) {
+        return [
+            {
+                id: 'C8',
+                level: 'info',
+                message: `stopped scanning the sources at ${files(limits.maxFiles)} (.ts / .tsx / .js / .jsx outside node_modules, ios, android, and build output), so the staged rollout note was not checked. Check --cwd, or suppress this with --ignore C8`,
+            },
+        ];
+    }
+    const entries = [];
+    if (scan.tooLarge.length > 0) {
+        entries.push({
+            id: 'C8',
+            level: 'info',
+            message: `did not scan ${scan.tooLarge.length} source ${scan.tooLarge.length === 1 ? 'file' : 'files'} larger than ${limits.maxFileBytes} bytes: ${listFiles(scan.tooLarge.map((path) => displayPath(cwd, path)))}`,
+        });
+    }
+    if (getterFile !== null || flagged.length === 0) {
+        entries.push({
+            id: 'C8',
+            level: 'ok',
+            message: getterFile !== null
+                ? `getLatestVersion / getMinimumVersion is used (${getterFile}), so force updates do not depend only on the store version`
+                : `no <${PROVIDER}> that forces updates from the store version was found (${files(scan.scanned)} scanned)`,
+        });
+        return entries;
+    }
+    for (const { file, reasons } of flagged) {
+        entries.push({
+            id: 'C8',
+            level: 'warning',
+            message: `${file}: <${PROVIDER}> ${reasons.join(' / ')}, and getLatestVersion / getMinimumVersion is not used in the sources. ${ROLLOUT_NOTE}`,
+        });
+    }
+    return entries;
+};