react-native-store-version 1.4.2 → 2.0.0

package/dist/react/engine.js

@@ -0,0 +1,541 @@
+// Provider の判定の状態遷移と副作用（取得・AppState・onResult / onError）。React を import しない（React の state へは
+// setModel で写すだけ。配線は StoreVersionProvider.tsx）。判定そのものは resolve に任せ、ここでは
+// 「いつ取り直すか」「どの結果をどの状態にするか」「どのエラーを onError に渡すか」だけを決める
+import { AppState } from 'react-native';
+import { detect } from '../detect.js';
+import { StoreVersionError } from '../errors.js';
+import { openStore as openStorePage } from '../openStore.js';
+import { evaluatePolicy, validatePolicy, } from '../policy.js';
+import { isAbortError } from '../request.js';
+import { attachedErrorsOf, resolve, } from '../resolve.js';
+/** 判定全体の既定のタイムアウト（Android の HTML が約 1.25MB あるため） */
+export const DEFAULT_TIMEOUT_MS = 10000;
+const LOG_PREFIX = '[react-native-store-version]';
+const isDev = () => typeof __DEV__ !== 'undefined' && __DEV__ === true;
+/** locale（BCP 47。`ja-JP` / `zh-Hant-TW` / `en_US`）の地域を小文字の 2 文字で返す。無ければ null */
+const regionOf = (locale) => {
+    if (typeof locale !== 'string') {
+        return null;
+    }
+    const subtags = locale.split(/[-_]/);
+    // 先頭は言語。2 文字の英字の subtag は地域だけ（extlang は 3 文字、script は 4 文字、variant は 4 文字以上）。
+    // 1 文字の subtag（`-u-` などの拡張）から後は見ない。数字 3 桁の地域（`419` など）は国ではないので使わない
+    for (let i = 1; i < subtags.length; i += 1) {
+        const subtag = subtags[i];
+        if (subtag.length === 1) {
+            break;
+        }
+        if (/^[A-Za-z]{2}$/.test(subtag)) {
+            return subtag.toLowerCase();
+        }
+    }
+    return null;
+};
+/**
+ * `country` の既定。端末ロケールの地域を JS だけで取る（`Intl.DateTimeFormat().resolvedOptions().locale`）。
+ * 取れなければ `us`。例外は投げない（パッケージの入口からは export しない）
+ */
+export const defaultCountry = () => {
+    try {
+        return regionOf(Intl.DateTimeFormat().resolvedOptions().locale) ?? 'us';
+    }
+    catch {
+        return 'us';
+    }
+};
+export const IDLE = {
+    status: 'idle',
+    local: null,
+    error: null,
+    snapshot: null,
+    evaluation: null,
+};
+/** 直近の判定の最新 / 最低バージョンに policy を当て直す。値で指定した policy は差分によらず検証する（resolve と同じ） */
+const reevaluate = (local, snapshot, policy) => {
+    try {
+        validatePolicy(policy);
+        const { result, detail, action, diff } = evaluatePolicy({
+            local,
+            remote: snapshot.latest ?? '',
+            minimum: snapshot.minimum,
+            policy,
+        });
+        return { evaluation: { result, detail, action, diff } };
+    }
+    catch (error) {
+        // 取得の結果は resolve で一度判定できているので、ここで投げうるのは policy の POLICY_FAILED だけ
+        return { error: error };
+    }
+};
+/**
+ * Provider の engine を作る。判断はすべてここの変数（最新の値）で行い、React の state は `setModel` で写すだけにする。
+ * props はいつも `getProps()` で最新のものを読む（変わっても取り直さない。例外は `enabled` の切り替え）
+ */
+export const createEngine = (getProps, setModel, setDismissedRemote) => {
+    let model = IDLE;
+    // マウント中か。false の間は setState も onResult / onError も呼ばない
+    let mounted = false;
+    // 直近に始めた判定
+    let run = null;
+    // いま見せている結果（ready と、再チェック中に見せ続けている前回の ready）を出した判定。
+    // 再チェックの間も、この判定の iOS の URL の lookup は止めずに残し、終わったら見せている結果の storeUrl に反映する
+    let shownRun = null;
+    let target = null;
+    let storeUrlResult = null;
+    // snapshot の evaluation を計算した policy（policy の変更を見分ける）
+    let evaluatedPolicy;
+    // 判定の途中でバックグラウンドになって取り消した。active に戻ったら取り直す
+    let abortedByBackground = false;
+    // バックグラウンドの間に取得を始めようとした（マウント・recheck・enabled の切り替え）。active になったら始める
+    let pendingStart = false;
+    // 直近の active の後に background になったか（background → active の復帰だけを見分ける。inactive → active は数えない）
+    let wentBackground = false;
+    // 直近に見た enabled（false → true / true → false の切り替えを見分ける）
+    let lastEnabled = true;
+    let subscription = null;
+    const publish = (next) => {
+        model = next;
+        if (mounted) {
+            setModel(next);
+        }
+    };
+    const warnThrown = (name, error) => {
+        if (isDev()) {
+            console.warn(`${LOG_PREFIX} ${name} threw`, error);
+        }
+    };
+    // 開発者のコールバックが throw しても、Promise を返して reject しても、unhandled rejection にしない（アプリを止めない）。
+    // 返した Promise は待たない
+    const call = (name, fn, arg) => {
+        try {
+            const returned = fn(arg);
+            if (typeof returned === 'object' &&
+                returned !== null &&
+                typeof returned.then === 'function') {
+                returned.then(undefined, (error) => warnThrown(name, error));
+            }
+        }
+        catch (error) {
+            warnThrown(name, error);
+        }
+    };
+    const report = (error) => {
+        if (!mounted) {
+            return;
+        }
+        const { onError } = getProps();
+        if (onError) {
+            call('onError', onError, error);
+        }
+        else if (isDev()) {
+            console.warn(`${LOG_PREFIX} ${error.code}: ${error.message}`, error);
+        }
+    };
+    const notifyResult = () => {
+        const { onResult } = getProps();
+        const { evaluation, snapshot, local } = model;
+        if (!mounted || !onResult || !evaluation || !snapshot || local === null) {
+            return;
+        }
+        call('onResult', onResult, {
+            result: evaluation.result,
+            detail: evaluation.detail,
+            action: evaluation.action,
+            diff: evaluation.diff,
+            local,
+            remote: snapshot.latest,
+        });
+    };
+    const isCurrent = (r) => mounted && run === r && !r.controller.signal.aborted;
+    /** 判定をしない / できない状態にする（前回の結果も消す） */
+    const finishWithoutCheck = (next) => {
+        target = null;
+        storeUrlResult = null;
+        publish(next);
+    };
+    /** 見せている判定の結果（ready と、それを見せ続けている再チェック中）。無ければ null */
+    const shownReady = () => (model.status === 'ready' || model.status === 'checking') &&
+        model.evaluation !== null &&
+        model.snapshot !== null
+        ? model
+        : null;
+    /** 前回の判定の、まだ終わっていない iOS の URL の lookup を止める（取り直さない。onError にも渡さない） */
+    const stopLookup = (r) => {
+        if (r?.settled && r.lookupPending) {
+            r.controller.abort();
+        }
+    };
+    /**
+     * 再チェックが失敗したら、見せ続けていた前回の ready に戻す（force を再チェックの失敗で消さない）。
+     * エラーは onError に渡すだけで hook の `error` には入れない（status が ready のまま error だけが入る状態を作らない）。
+     * 再チェック中に policy が変わっていたら、前回の取得結果に当て直す
+     */
+    const restore = () => {
+        publish({ ...model, status: 'ready', error: null });
+        engine.applyPolicy(getProps().policy);
+    };
+    /** 判定の結果を受け取ったとき */
+    const onResolved = (current, local, policy, resolved) => {
+        if (!isCurrent(current)) {
+            return;
+        }
+        current.settled = true;
+        const snapshot = {
+            latest: resolved.latest,
+            minimum: resolved.minimum,
+            storeUrl: resolved.storeUrl,
+            releaseNotes: resolved.releaseNotes,
+        };
+        // 判定中に policy が変わっていたら、最新の policy で当て直してから出す（onResult を 2 回呼ばないように）
+        const latestPolicy = getProps().policy;
+        const outcome = latestPolicy === policy
+            ? { evaluation: resolved }
+            : reevaluate(local, snapshot, latestPolicy);
+        evaluatedPolicy = latestPolicy;
+        storeUrlResult = resolved.storeUrlResult;
+        // 新しい判定の結果を出すので、前回の判定の URL の lookup はもう要らない
+        if (shownRun !== current) {
+            stopLookup(shownRun);
+        }
+        shownRun = current;
+        if ('error' in outcome) {
+            publish({
+                status: 'error',
+                local,
+                error: outcome.error,
+                snapshot,
+                evaluation: null,
+            });
+        }
+        else {
+            const { result, detail, action, diff } = outcome.evaluation;
+            publish({
+                status: 'ready',
+                local,
+                error: null,
+                snapshot,
+                evaluation: { result, detail, action, diff },
+            });
+        }
+        // 判定を止めなかったエラー（MINIMUM_VERSION_FAILED と、最新が比較できず最低バージョンで force にしたときの INVALID_VERSION）
+        for (const error of resolved.errors) {
+            report(error);
+        }
+        if ('error' in outcome) {
+            report(outcome.error);
+        }
+        else {
+            notifyResult();
+        }
+        watchStoreUrl(current, resolved.storeUrlResult);
+    };
+    /**
+     * iOS で getLatestVersion を使うときは、URL の lookup が終わった時点で storeUrl を更新する。
+     * 起動時の URL の lookup の失敗（trackViewUrl が無いことも）は STORE_URL_UNAVAILABLE で onError へ（storeUrlResult は reject しない）。
+     * 再チェックの間（この判定の結果を見せ続けている間）に終わったときも、見せている結果に反映する
+     */
+    const watchStoreUrl = (current, result) => {
+        current.lookupPending = true;
+        void result.then((found) => {
+            current.lookupPending = false;
+            if (!mounted ||
+                shownRun !== current ||
+                current.controller.signal.aborted) {
+                return;
+            }
+            if (found.error) {
+                report(found.error);
+                return;
+            }
+            if (model.snapshot && model.snapshot.storeUrl !== found.storeUrl) {
+                publish({
+                    ...model,
+                    snapshot: { ...model.snapshot, storeUrl: found.storeUrl },
+                });
+            }
+        });
+    };
+    /** 判定が失敗したとき（取り消しは何もしない） */
+    const onRejected = (current, local, error) => {
+        // 取り消した判定（アンマウント・バックグラウンド・取り直し）は何も出さない
+        if (!isCurrent(current) || isAbortError(error)) {
+            return;
+        }
+        current.settled = true;
+        if (shownReady()) {
+            restore();
+        }
+        else {
+            publish({
+                ...IDLE,
+                status: 'error',
+                local,
+                error: error,
+            });
+        }
+        report(error);
+        // 判定を止めたエラーに添えられた、ほかのエラー（その時点で分かっている最低バージョンのエラー）
+        for (const attached of attachedErrorsOf(error)) {
+            report(attached);
+        }
+    };
+    /** 取得を始める（detect の後。バックグラウンドの間は active まで待つ） */
+    const fetchFor = (current, detected) => {
+        // RN のタイマーはバックグラウンドで止まるので、バックグラウンドの間は取得を始めず、active になったら始める
+        if (AppState.currentState === 'background') {
+            pendingStart = true;
+            return;
+        }
+        const props = getProps();
+        const { platform, version: local, appId } = detected;
+        const country = props.country ?? defaultCountry();
+        target = { platform, appId, country };
+        current.settled = false;
+        // 再チェックの間は前回の ready の値を見せ続ける（初回は前回の結果が無い）。
+        // 前回の URL の取得結果も、新しい判定が終わるまで openStore に使う
+        const previous = shownReady();
+        if (previous) {
+            publish({ ...previous, status: 'checking', error: null });
+        }
+        else {
+            storeUrlResult = null;
+            publish({ ...IDLE, status: 'checking', local });
+        }
+        const policy = props.policy;
+        // reject は onRejected で受ける（unhandled rejection にしない）
+        void resolve({
+            platform,
+            version: local,
+            appId,
+            country,
+            policy,
+            getLatestVersion: props.getLatestVersion,
+            getMinimumVersion: props.getMinimumVersion,
+            timeoutMs: props.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            signal: current.controller.signal,
+        }).then((resolved) => onResolved(current, local, policy, resolved), (error) => onRejected(current, local, error));
+    };
+    const start = () => {
+        if (!mounted) {
+            return;
+        }
+        pendingStart = false;
+        abortedByBackground = false;
+        // 判定中なら取り消す（onError には渡さない）。同じストアへの取得は request.ts が次の判定に引き継ぐ。
+        // 判定が終わって URL の lookup だけが残っている判定は止めない（前回の結果の storeUrl に反映するため）
+        if (run && !run.settled) {
+            run.controller.abort();
+        }
+        const current = {
+            controller: new AbortController(),
+            settled: true,
+            lookupPending: false,
+        };
+        run = current;
+        // 取得しない（skipped）・できない（LOCAL_VERSION_UNAVAILABLE）は、バックグラウンドでもすぐ決める
+        const props = getProps();
+        if (props.enabled === false) {
+            finishWithoutCheck({ ...IDLE, status: 'skipped' });
+            return;
+        }
+        let detected;
+        try {
+            detected = detect({
+                version: props.version,
+                bundleId: props.bundleId,
+                packageName: props.packageName,
+            });
+        }
+        catch (error) {
+            // LOCAL_VERSION_UNAVAILABLE
+            if (shownReady()) {
+                restore();
+            }
+            else {
+                finishWithoutCheck({
+                    ...IDLE,
+                    status: 'error',
+                    error: error,
+                });
+            }
+            // 報告は microtask に回し、そのときまだこの判定が最新のときだけ渡す（StrictMode のマウント・アンマウント・マウントで
+            // 1 回目の判定の報告を捨て、2 回報告しないように）
+            void Promise.resolve().then(() => {
+                if (isCurrent(current)) {
+                    report(error);
+                }
+            });
+            return;
+        }
+        if (detected.skipped !== null) {
+            finishWithoutCheck({ ...IDLE, status: 'skipped' });
+            return;
+        }
+        fetchFor(current, detected);
+    };
+    const onAppStateChange = (next) => {
+        if (next === 'background') {
+            wentBackground = true;
+            // RN のタイマーはバックグラウンドで止まり、復帰時に期限切れで発火する（TIMEOUT になり、この起動で force を出す機会を失う）ので、
+            // 終わっていない判定は取り消して、復帰時に取り直す（recheckOnForeground に関係なく）
+            if (run && !run.settled && !run.controller.signal.aborted) {
+                run.controller.abort();
+                abortedByBackground = true;
+            }
+            // 判定は終わったが iOS の URL の lookup がまだなら、それだけを止める（取り直さない。storeUrlResult はエラーで終わり、
+            // openStore はその場で lookup し直す）
+            stopLookup(run);
+            stopLookup(shownRun);
+            return;
+        }
+        if (next === 'active') {
+            const returned = wentBackground;
+            wentBackground = false;
+            // 待っていた取得の開始・取り消した判定の取り直し・recheckOnForeground が重なっても、始めるのは 1 回
+            if (pendingStart ||
+                (returned &&
+                    (abortedByBackground || getProps().recheckOnForeground === true))) {
+                start();
+            }
+        }
+    };
+    const engine = {
+        mount() {
+            mounted = true;
+            wentBackground = false;
+            pendingStart = false;
+            lastEnabled = getProps().enabled !== false;
+            subscription = AppState.addEventListener('change', onAppStateChange);
+            // バックグラウンドのままマウントされたら、取得は active になるまで始めない（status は idle のまま）
+            start();
+        },
+        unmount() {
+            // 取り消した後は onResult / onError / setState を呼ばない（resolve の abort は何も添えずに AbortError で終わる）
+            mounted = false;
+            pendingStart = false;
+            subscription?.remove();
+            subscription = null;
+            run?.controller.abort();
+            shownRun?.controller.abort();
+            run = null;
+            shownRun = null;
+        },
+        start,
+        setEnabled(enabled) {
+            if (!mounted || enabled === lastEnabled) {
+                return;
+            }
+            lastEnabled = enabled;
+            if (enabled) {
+                // false → true: 判定を始める
+                start();
+                return;
+            }
+            // true → false: 判定を取り消して skipped にする（onError は呼ばない）
+            run?.controller.abort();
+            shownRun?.controller.abort();
+            run = null;
+            shownRun = null;
+            pendingStart = false;
+            abortedByBackground = false;
+            finishWithoutCheck({ ...IDLE, status: 'skipped' });
+        },
+        applyPolicy(policy) {
+            const { snapshot, local } = model;
+            // 再チェック中は当て直さない（終わったときに最新の policy で当て直す。失敗したら前回の結果に当て直す）
+            if (!mounted ||
+                model.status === 'checking' ||
+                !snapshot ||
+                local === null ||
+                policy === evaluatedPolicy) {
+                return;
+            }
+            evaluatedPolicy = policy;
+            const outcome = reevaluate(local, snapshot, policy);
+            if ('error' in outcome) {
+                // 不正な policy が続く（インラインで書いた関数が描画のたびに throw するなど）間は、onError を繰り返さない
+                if (model.status === 'ready') {
+                    publish({
+                        ...model,
+                        status: 'error',
+                        error: outcome.error,
+                        evaluation: null,
+                    });
+                    report(outcome.error);
+                }
+                return;
+            }
+            // action が変わらなければ何もしない（インラインで書いた policy で、描画のたびに onResult を呼ばないように）
+            if (model.status === 'ready' &&
+                model.evaluation?.action === outcome.evaluation.action) {
+                return;
+            }
+            publish({
+                ...model,
+                status: 'ready',
+                error: null,
+                evaluation: outcome.evaluation,
+            });
+            notifyResult();
+        },
+        async openStore() {
+            const opening = target;
+            if (opening === null) {
+                // 判定しない環境（skipped）や、アプリのバージョン / ID が取れなかったときは、開く先が分からない
+                report(new StoreVersionError('STORE_URL_UNAVAILABLE', `cannot open the store: the app was not detected (status: ${model.status})`));
+                return false;
+            }
+            try {
+                await openStorePage({
+                    ...opening,
+                    storeUrl: storeUrlResult,
+                    timeoutMs: getProps().timeoutMs ?? DEFAULT_TIMEOUT_MS,
+                });
+                return true;
+            }
+            catch (error) {
+                // STORE_URL_UNAVAILABLE（iOS の lookup の失敗 / Linking.openURL の失敗）。onError に渡すだけで reject しない
+                // （`onPress={openStore}` のまま使っても unhandled rejection にならないように）。status / error は変えない
+                report(error);
+                return false;
+            }
+        },
+        dismiss() {
+            // 再チェック中も、前回の ready の warning なら閉じられる
+            const shown = shownReady();
+            if (mounted &&
+                shown?.evaluation?.action === 'warning' &&
+                shown.snapshot?.latest != null) {
+                setDismissedRemote(shown.snapshot.latest);
+            }
+        },
+    };
+    return engine;
+};
+/**
+ * engine の状態から hook の戻り値を作る。判定の結果（result / action / remote / storeUrl など）は ready のとき
+ * （再チェック中は前回の ready の値）だけ見せる
+ */
+export const stateOf = (model, dismissedRemote, engine) => {
+    const evaluation = model.evaluation;
+    const snapshot = evaluation ? model.snapshot : null;
+    const action = evaluation?.action ?? null;
+    const remote = snapshot?.latest ?? null;
+    return {
+        status: model.status,
+        result: evaluation?.result ?? null,
+        detail: evaluation?.detail ?? null,
+        action,
+        diff: evaluation?.diff ?? null,
+        // 「あとで」は remote のバージョン単位。remote が変われば解除、force なら常に出す
+        dismissed: action === 'warning' && remote !== null && remote === dismissedRemote,
+        local: model.local,
+        remote,
+        storeUrl: snapshot?.storeUrl ?? null,
+        releaseNotes: snapshot?.releaseNotes,
+        openStore: engine.openStore,
+        dismiss: engine.dismiss,
+        recheck: engine.start,
+        error: model.error,
+    };
+};

package/dist/react/texts.d.ts

@@ -0,0 +1,43 @@
+/** 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 declare const DEFAULT_TEXTS: StoreVersionResolvedTexts;
+/** 置き換えに使う値。最新バージョンが比較できず、最低バージョンで force になったときは `remote` が null */
+export type TextVariables = {
+    local: string | null;
+    remote: string | null;
+};
+/**
+ * Provider の `texts` を表示用の文言にする。`force` / `warning` ごとに、指定しなかったキー（文字列でない値も）を英語の既定値で
+ * 補完し（1 段だけマージ）、`{remote}` / `{local}` のすべての出現を置き換える。
+ * `texts` / `local` / `remote` が変わるたびに呼ぶ（`texts` の変更を表示中のモーダルにも即座に反映するため）
+ */
+export declare const resolveTexts: (texts: StoreVersionTexts | undefined, variables: TextVariables) => StoreVersionResolvedTexts;
+//# sourceMappingURL=texts.d.ts.map

package/dist/react/texts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"texts.d.ts","sourceRoot":"","sources":["../../src/react/texts.ts"],"names":[],"mappings":"AAIA,4EAA4E;AAC5E,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,gEAAgE;AAChE,MAAM,MAAM,wBAAwB,GAAG;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,eAAe;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACxC,OAAO,CAAC,EAAE,OAAO,CAAC,wBAAwB,CAAC,CAAC;CAC7C,CAAC;AAEF,yEAAyE;AACzE,MAAM,MAAM,yBAAyB,GAAG;IACtC,KAAK,EAAE,sBAAsB,CAAC;IAC9B,OAAO,EAAE,wBAAwB,CAAC;CACnC,CAAC;AAEF,0BAA0B;AAC1B,eAAO,MAAM,aAAa,EAAE,yBAa3B,CAAC;AAEF,oEAAoE;AACpE,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,CAAC;AAmCF;;;;GAIG;AACH,eAAO,MAAM,YAAY,UAChB,iBAAiB,GAAG,SAAS,aACzB,aAAa,KACvB,yBAkBF,CAAC"}

package/dist/react/texts.js

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

package/dist/react/useIsomorphicLayoutEffect.d.ts

@@ -0,0 +1,3 @@
+import { useLayoutEffect } from 'react';
+export declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;
+//# sourceMappingURL=useIsomorphicLayoutEffect.d.ts.map

package/dist/react/useIsomorphicLayoutEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsomorphicLayoutEffect.d.ts","sourceRoot":"","sources":["../../src/react/useIsomorphicLayoutEffect.ts"],"names":[],"mappings":"AAEA,OAAO,EAAa,eAAe,EAAE,MAAM,OAAO,CAAC;AAEnD,eAAO,MAAM,yBAAyB,wBAGjB,CAAC"}

package/dist/react/useIsomorphicLayoutEffect.js

@@ -0,0 +1,6 @@
+// サーバーでの描画（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.window === undefined
+    ? useEffect
+    : useLayoutEffect;