@marktiderman/genesis-native 0.2.0 → 0.3.0

package/dist/block-Dh5ny06W.d.ts

@@ -1,535 +0,0 @@
-import * as react from 'react';
-import { ComponentType, ReactNode } from 'react';
-import { Slots, SlotPropsFor } from '@marktiderman/genesis-core/slots';
-
-/** A tiny external store for `useSyncExternalStore`: immutable state, one notify per change. */
-interface Store<T> {
-    getState(): T;
-    setState(next: Partial<T>): void;
-    subscribe(listener: () => void): () => void;
-}
-
-/**
- * The native modules the updates block reads, as the shapes it needs. Pass
- * the real ones (`import * as Updates from "expo-updates"`,
- * `import * as Application from "expo-application"`); tests pass fakes.
- * Both are optional peers: without `expo-updates` there is no update banner
- * and no channel switching, and without `expo-application` no force upgrade.
- */
-/** `expo-updates` (SDK 58): the constants and calls this block uses. */
-interface UpdatesModuleLike {
-    /** False in development, Expo Go, or a build without updates configured. */
-    readonly isEnabled: boolean;
-    /** The running update's id; `null` when updates are off. */
-    readonly updateId: string | null;
-    /** The build's channel; `null` in development builds and Expo Go. */
-    readonly channel: string | null;
-    readonly runtimeVersion: string | null;
-    /** True when the code that shipped in the binary is running, not a downloaded update. */
-    readonly isEmbeddedLaunch: boolean;
-    /** True when expo-updates fell back to the embedded update after a failed launch. */
-    readonly isEmergencyLaunch?: boolean;
-    readonly emergencyLaunchReason?: string | null;
-    checkForUpdateAsync(): Promise<{
-        isAvailable: boolean;
-        isRollBackToEmbedded?: boolean;
-        manifest?: unknown;
-    }>;
-    fetchUpdateAsync(): Promise<{
-        isNew: boolean;
-        isRollBackToEmbedded?: boolean;
-        manifest?: unknown;
-    }>;
-    reloadAsync(options?: {
-        reloadScreenOptions?: object;
-    }): Promise<void>;
-    /** Overrides the `expo-channel-name` header (persists on the device); `null` removes the override. */
-    setUpdateRequestHeadersOverride?(requestHeaders: Record<string, string> | null): void;
-}
-/** `expo-application`: the installed store version and build number. */
-interface ApplicationLike {
-    /** `CFBundleShortVersionString` / `versionName`, e.g. `"1.4.0"`. */
-    readonly nativeApplicationVersion: string | null;
-    /** `CFBundleVersion` / `versionCode`, e.g. `"37"`. */
-    readonly nativeBuildVersion: string | null;
-}
-/** AsyncStorage, MMKV's async adapter, or a stand-in. */
-interface UpdatesStorageLike {
-    getItem(key: string): Promise<string | null>;
-    setItem(key: string, value: string): Promise<void>;
-    removeItem?(key: string): Promise<void>;
-}
-/** React Native's `AppState`. */
-interface UpdatesAppStateLike {
-    addEventListener(type: "change", listener: (state: string) => void): {
-        remove(): void;
-    };
-}
-/** Where a reported error came from. */
-type UpdatesErrorSource = "policy" | "check" | "reload" | "storage" | "channel";
-type UpdatesOnError = (error: Error, source: UpdatesErrorSource) => void;
-
-/**
- * The update banner's engine: ask expo-updates for a newer update, download
- * it, and reload only when the person taps and nothing is mid-edit.
- *
- * - It never reloads on its own. A downloaded update also applies on the next
- *   cold start, so dismissing the banner loses nothing.
- * - The reload guard says no while any `useBlockReload(true)` is mounted (a
- *   form with unsaved changes) or your `canReload()` returns false (or
- *   throws). The banner then asks the person to finish first.
- * - expo-updates only serves updates built for this binary's runtime
- *   version; an update whose manifest names another runtime is ignored too.
- */
-
-interface ReloadGuard {
-    /** Hold reloads off until the returned function is called. */
-    block(): () => void;
-    /** True when nothing blocks and your `canReload` agrees. */
-    canReload(): boolean;
-    /** Fires when a block starts or ends. */
-    subscribe(listener: () => void): () => void;
-}
-declare function createReloadGuard(canReload?: () => boolean): ReloadGuard;
-type UpdateCheckStatus = "disabled" | "idle" | "checking" | "downloading" | "ready" | "reloading" | "error";
-interface UpdateCheckState {
-    status: UpdateCheckStatus;
-    /** The downloaded update's id, when the manifest has one. */
-    updateId: string | null;
-    /** The person closed the banner; the update still applies on the next cold start. */
-    dismissed: boolean;
-    /** The last tap was refused by the reload guard; cleared when the guard opens. */
-    blocked: boolean;
-    error: Error | null;
-}
-interface UpdateCheckerOptions {
-    updates?: UpdatesModuleLike;
-    guard: ReloadGuard;
-    /** Passed to `reloadAsync` (a branded reload screen). */
-    reloadScreenOptions?: object;
-    now?: () => number;
-    onError?: UpdatesOnError;
-}
-interface UpdateChecker extends Pick<Store<UpdateCheckState>, "getState" | "subscribe"> {
-    /** Check and download. Never rejects; does nothing while one is in flight or an update is ready. */
-    check(): Promise<void>;
-    /** `check()` unless the last one started less than `minIntervalMs` ago. */
-    checkIfDue(minIntervalMs: number): Promise<void>;
-    /** Reload into the downloaded update. Resolves false when there is none or the guard refuses. */
-    reload(): Promise<boolean>;
-    dismiss(): void;
-    /** Stop following the guard. */
-    dispose(): void;
-}
-declare function createUpdateChecker(options: UpdateCheckerOptions): UpdateChecker;
-
-/**
- * Switching a test build to another update channel (EAS "channel surfing"):
- * override the `expo-channel-name` header, check, fetch, reload. The
- * override persists on the device until it is reset or the app is removed.
- *
- * Off unless you turn it on, and turn it on only in development and preview
- * builds (`enabled: __DEV__ || isPreviewBuild`): a store build that can be
- * pointed at any channel can be pointed at an unreviewed one. Going back
- * (`reset`) always works, for everyone, because it only removes the
- * override.
- *
- * Switching reloads, so it respects the reload guard: with unsaved changes
- * it sets the channel and says `blocked`; the channel applies on the next
- * launch.
- */
-
-type ChannelSwitchResult = 
-/** The reload was sent; JS may stop at any moment. */
-{
-    kind: "reloading";
-}
-/** The channel is set, but something is mid-edit: it applies on the next launch. */
- | {
-    kind: "blocked";
-}
-/** expo-updates is off or too old here (development, Expo Go). Nothing changed. */
- | {
-    kind: "unavailable";
-    reason: string;
-}
-/** The channel is set but checking, fetching or reloading failed. */
- | {
-    kind: "error";
-    error: Error;
-};
-interface ChannelSwitcher {
-    /** True when this build may switch channels (`channels.enabled`). */
-    readonly enabled: boolean;
-    /** Switch to `channel` and reload. Throws when switching is off. */
-    switchTo(channel: string): Promise<ChannelSwitchResult>;
-    /** Back to the build's own channel. Always allowed. */
-    reset(): Promise<ChannelSwitchResult>;
-    /** The channel picked on this device, or `null` when it follows the build. */
-    requested(): Promise<string | null>;
-}
-interface ChannelSwitcherOptions {
-    updates?: UpdatesModuleLike;
-    /** Must be explicitly true (development and preview builds only). */
-    enabled: boolean;
-    guard: ReloadGuard;
-    /** Remembers the picked channel, for the version signature. */
-    storage?: UpdatesStorageLike;
-    /** Default `"genesis:updates:channel"`. */
-    storageKey?: string;
-    reloadScreenOptions?: object;
-    onError?: UpdatesOnError;
-}
-declare function createChannelSwitcher(options: ChannelSwitcherOptions): ChannelSwitcher;
-
-/**
- * The release policy: the oldest store version each platform may run, a
- * maintenance switch, and release notes. It comes from an
- * `UpdatePolicySource` (a static object, Supabase, or your own), is cached on
- * the phone, and **fails open**: no answer, a timeout, a malformed value or
- * an untrusted cache never blocks anyone.
- *
- * What may block, and from where:
- * - Force upgrade: a policy fetched this session, or a cached one no older
- *   than `cacheMaxAgeMs` (7 days) by the phone's clock. A cache whose time is
- *   in the future (the clock moved back) is not trusted. A minimum without a
- *   store link for the platform forces nothing (there would be no way out).
- * - Maintenance: only a policy fetched from the network this session. A
- *   cached maintenance flag never blocks a cold start.
- */
-
-type UpdatePlatform = "ios" | "android";
-interface ReleaseNote {
-    /** The store version these notes describe, e.g. `"1.4.0"`. */
-    version: string;
-    title?: string;
-    body: string;
-}
-interface UpdatePolicy {
-    /** The oldest store version still supported, per platform. Missing or malformed: no minimum. */
-    minimumVersion?: Partial<Record<UpdatePlatform, string>>;
-    /** Where "Update" goes (`https://apps.apple.com/…`, `itms-apps://…`, `market://…`, `https://play.google.com/…`). */
-    storeUrl?: Partial<Record<UpdatePlatform, string>>;
-    maintenance?: {
-        active: boolean;
-        message: string | null;
-    };
-    notes?: readonly ReleaseNote[];
-}
-/** Where the policy comes from. `load` throws (or rejects) when it can't answer; resolving `null` means "no policy". */
-interface UpdatePolicySource {
-    load(): Promise<UpdatePolicy | null | undefined>;
-}
-/** A policy written in the app (or a test). */
-declare function staticPolicySource(policy: UpdatePolicy): UpdatePolicySource;
-/** A Supabase client: anything with `from(table)` (a real `SupabaseClient` fits without a cast). */
-interface PolicyClientLike {
-    from(table: string): unknown;
-}
-interface SupabasePolicySourceOptions {
-    /** The `app_id` row to read. Default `"default"`. */
-    appId?: string;
-    /** Default `"app_release_policy"` (migration `0002_genesis_app_release_policy.sql` in `@marktiderman/genesis-supabase`). */
-    table?: string;
-}
-/**
- * Reads one row of `public.app_release_policy` (readable by anon and
- * authenticated, written only with the service role). No row is no policy.
- */
-declare function supabasePolicySource(client: PolicyClientLike, options?: SupabasePolicySourceOptions): UpdatePolicySource;
-/** Keeps only well-formed fields; throws when `raw` isn't an object at all (so the cache answers instead). */
-declare function sanitizePolicy(raw: unknown): UpdatePolicy;
-type PolicyOrigin = "network" | "cache" | "none";
-interface PolicyState {
-    /** `loading` until the first answer (or the timeout); then `ready`, with or without a policy. */
-    status: "loading" | "ready";
-    policy: UpdatePolicy | null;
-    /** `network`: fetched this session. `cache`: read from the phone. `none`: no answer yet (fail open). */
-    origin: PolicyOrigin;
-    /** When it was fetched, by the phone's clock (ms). */
-    fetchedAt: number | null;
-    /** The last failed fetch, if the most recent one failed. */
-    error: Error | null;
-    /** A fetch is in flight. */
-    refreshing: boolean;
-}
-interface PolicyStoreOptions {
-    source: UpdatePolicySource;
-    storage?: UpdatesStorageLike;
-    /** Default `"genesis:updates:policy"`. */
-    cacheKey?: string;
-    /** The longest `load()` waits before carrying on without an answer. Default 3000 ms. */
-    timeoutMs?: number;
-    now?: () => number;
-    onError?: UpdatesOnError;
-}
-interface PolicyStore extends Pick<Store<PolicyState>, "getState" | "subscribe"> {
-    /** The first load: the cache and the network together, for at most `timeoutMs`. Never rejects; runs once. */
-    load(): Promise<void>;
-    /** Fetch again (maintenance "Try again", the app coming to the front). Never rejects; resolves true on an answer. */
-    refresh(): Promise<boolean>;
-    /** `refresh()` unless one ran less than `minIntervalMs` ago. */
-    refreshIfDue(minIntervalMs: number): Promise<boolean>;
-}
-declare function createPolicyStore(options: PolicyStoreOptions): PolicyStore;
-/** What the policy says this install must do. */
-type UpdateVerdict = {
-    kind: "ok";
-} | {
-    kind: "forceUpgrade";
-    minimumVersion: string;
-    installedVersion: string;
-    storeUrl: string;
-} | {
-    kind: "maintenance";
-    message: string | null;
-};
-interface EvaluatePolicyOptions {
-    /** `Platform.OS`. Only `ios` and `android` can be forced to upgrade. */
-    platform: string;
-    /** The installed store version (`Application.nativeApplicationVersion`). `null`: never forced. */
-    installedVersion: string | null;
-    now: number;
-    /** How old a cached policy may be and still force an upgrade. Default 7 days. */
-    cacheMaxAgeMs?: number;
-}
-/** How far in the future a cache's time may be (clocks drift) before it isn't trusted. */
-declare const CLOCK_SKEW_MS: number;
-declare const WEEK_MS: number;
-/** Force upgrade first (the store is the way out), then maintenance, else ok. Fails open. */
-declare function evaluatePolicy(state: PolicyState, options: EvaluatePolicyOptions): UpdateVerdict;
-
-/**
- * The version signature: which binary and which update this is, in one
- * line for Settings "About" and in a few lines for a support report.
- *
- *   1.4.0 (37) · preview · 3f2a9c1b
- *   1.4.0 (37) · production · embedded
- *   1.4.0 (37) · updates off
- *
- * A value the modules can't give is printed as `unknown`, never left out.
- */
-
-interface VersionSignature {
-    version: string | null;
-    build: string | null;
-    platform: string;
-    /** The build's channel (expo-updates). */
-    channel: string | null;
-    /** A channel picked on this device (a test build switched channels); `null` when it follows the build. */
-    requestedChannel: string | null;
-    runtimeVersion: string | null;
-    updateId: string | null;
-    /** `update`: a downloaded update runs. `embedded`: the binary's own code. `off`: updates are off (development, Expo Go). */
-    launch: "update" | "embedded" | "off";
-    /** expo-updates fell back to the embedded code after a failed launch. */
-    emergency: boolean;
-    /** One line, for an About row. */
-    short: string;
-    /** Several lines, for a support report. */
-    text: string;
-}
-interface VersionSignatureInput {
-    application?: ApplicationLike;
-    updates?: UpdatesModuleLike;
-    /** `Platform.OS`. */
-    platform: string;
-    requestedChannel?: string | null;
-}
-declare function versionSignature({ application, updates, platform, requestedChannel }: VersionSignatureInput): VersionSignature;
-
-/**
- * What's new: release notes shown once per version, remembered in storage.
- *
- * - First launch after an install (nothing stored): nothing shows; the
- *   version is remembered, so a new install never opens on a sheet.
- * - A newer version than the one remembered: the notes for every version
- *   after it, up to this one, newest first. Closing them remembers this
- *   version. With no notes for it, the version is remembered once the policy
- *   has answered from the network (or there is no policy source), so notes
- *   that arrive late still show.
- * - Storage that can't be read shows nothing (rather than every launch).
- */
-
-interface WhatsNewState {
-    status: "loading" | "hidden" | "showing";
-    notes: readonly ReleaseNote[];
-}
-interface WhatsNewOptions {
-    storage?: UpdatesStorageLike;
-    /** The installed version notes are matched against. `null`: never shows. */
-    version: string | null;
-    /** Default `"genesis:updates:seen-version"`. */
-    storageKey?: string;
-    onError?: UpdatesOnError;
-}
-interface WhatsNewStore extends Pick<Store<WhatsNewState>, "getState" | "subscribe"> {
-    /** Read the remembered version. Never rejects; runs once. */
-    load(): Promise<void>;
-    /** Recompute with the notes known now; `final` once no more notes can arrive. */
-    update(notes: readonly ReleaseNote[], final: boolean): void;
-    /** Close the notes and remember this version. */
-    dismiss(): void;
-}
-/** The notes after `seen`, up to `version`, newest first. */
-declare function notesSince(notes: readonly ReleaseNote[], seen: string, version: string): ReleaseNote[];
-declare function createWhatsNewStore(options: WhatsNewOptions): WhatsNewStore;
-
-interface ForceUpgradeProps {
-    minimumVersion: string;
-    installedVersion: string;
-    /** The policy's store link for this platform (a minimum without one forces nothing). */
-    storeUrl: string;
-    /** Opens `storeUrl`. */
-    openStore: () => void;
-    /** Ask the policy again (it may have been lowered). */
-    retry: () => void;
-    checking: boolean;
-}
-/** Blocking: this version is below the minimum. "Update" opens the store. */
-declare function ForceUpgradeScreen({ minimumVersion, installedVersion, openStore, retry, checking }: ForceUpgradeProps): react.JSX.Element;
-interface MaintenanceProps {
-    /** The policy's message, or `null` for the default copy. */
-    message: string | null;
-    retry: () => void;
-    retrying: boolean;
-}
-/** Blocking: the policy says maintenance is on. "Try again" asks again. */
-declare function MaintenanceScreen({ message, retry, retrying }: MaintenanceProps): react.JSX.Element;
-interface UpdateBannerProps {
-    /** Reload into the downloaded update (refused while `canReload` is false). */
-    reload: () => void;
-    /** Hide the banner; the update still applies on the next cold start. */
-    dismiss: () => void;
-    /** False while something is mid-edit (`useBlockReload`) or your `canReload` says no. */
-    canReload: boolean;
-    /** The last tap was refused because something is mid-edit. */
-    blocked: boolean;
-    reloading: boolean;
-}
-/** Non-blocking: floats over the top of the screens while an update is downloaded. */
-declare function UpdateBanner({ reload, dismiss, canReload, blocked, reloading }: UpdateBannerProps): react.JSX.Element;
-interface WhatsNewProps {
-    /** Newest first. */
-    notes: readonly ReleaseNote[];
-    /** The installed version. */
-    version: string | null;
-    /** Close and remember this version. */
-    dismiss: () => void;
-}
-/** The release notes for this version, once, in a sheet. */
-declare function WhatsNewSheet({ notes, dismiss }: WhatsNewProps): react.JSX.Element;
-
-type UpdatesSlots = {
-    /** Blocking. Default `ForceUpgradeScreen`. */
-    forceUpgrade: ForceUpgradeProps;
-    /** Blocking. Default `MaintenanceScreen`. */
-    maintenance: MaintenanceProps;
-    /** Over your screens while an update is downloaded. Default `UpdateBanner`. */
-    updateBanner: UpdateBannerProps;
-    /** Once per version. Default `WhatsNewSheet`. */
-    whatsNew: WhatsNewProps;
-};
-interface UpdatesOptions {
-    /** `Platform.OS`. Force upgrade applies to `ios` and `android` only. */
-    platform: string;
-    /** `expo-application`: the installed version. Without it, nothing is ever forced and notes never show. */
-    application?: ApplicationLike;
-    /** `expo-updates`. Without it (or with updates off), no banner and no channel switching. */
-    updates?: UpdatesModuleLike;
-    /** Min versions, maintenance and notes. Without it, only `notes` and the banner. */
-    policy?: UpdatePolicySource;
-    /** AsyncStorage: the policy cache, the version whose notes were seen, the picked channel. */
-    storage?: UpdatesStorageLike;
-    /** `AppState`: ask again when the app comes to the front. */
-    appState?: UpdatesAppStateLike;
-    /** `Linking.openURL`, for the store link. */
-    openURL?: (url: string) => unknown;
-    /** Extra say over reloading (return false to hold it off); `useBlockReload` covers forms. */
-    canReload?: () => boolean;
-    /** Release notes written in the app, merged with the policy's. */
-    notes?: readonly ReleaseNote[];
-    /** `false` turns what's new off. */
-    whatsNew?: boolean;
-    /** Channel switching, for development and preview builds only: `{ enabled: __DEV__ || isPreview }`. */
-    channels?: {
-        enabled: boolean;
-    };
-    /** The longest the first policy load holds the splash. Default 3000 ms. */
-    policyTimeoutMs?: number;
-    /** How old a cached policy may be and still force an upgrade. Default 7 days. */
-    cacheMaxAgeMs?: number;
-    /** Ask for the policy again on coming to the front at most this often. Default 5 minutes. */
-    policyRefreshMs?: number;
-    /** Check for an update on coming to the front at most this often. Default 15 minutes. */
-    checkIntervalMs?: number;
-    /** `reloadAsync`'s reload screen (background color, spinner). */
-    reloadScreenOptions?: object;
-    /** Storage key prefix. Default `"genesis:updates"`. */
-    storageKeyPrefix?: string;
-    /** Every caught error, for reporting. None of them blocks anyone. */
-    onError?: UpdatesOnError;
-    now?: () => number;
-}
-interface UpdatesBlock {
-    readonly options: UpdatesOptions;
-    readonly policy: PolicyStore;
-    readonly checker: UpdateChecker;
-    readonly guard: ReloadGuard;
-    readonly whatsNew: WhatsNewStore;
-    /** Channel switching: `switchTo` throws unless `channels.enabled` was passed; `reset` always works. */
-    readonly channels: ChannelSwitcher;
-    /** The signature from the modules, without the picked channel (see `useVersionSignature`). */
-    readonly signature: VersionSignature;
-    /** Loads the policy and the seen version behind the splash; never fails, done within `policyTimeoutMs`. */
-    readonly bootStep: {
-        id: string;
-        run: () => Promise<void>;
-        timeoutMs: number;
-    };
-    /** Start following the app's state; returns the stop. `UpdatesRoot` calls it. */
-    start(): () => void;
-    /** The block's root, for `GenesisNativeApp`. */
-    readonly Root: ComponentType<Omit<UpdatesRootProps, "block">>;
-}
-/** Build the block once, at module scope, next to your Supabase client. */
-declare function createUpdates(options: UpdatesOptions): UpdatesBlock;
-/** Provides the block to the hooks, without rendering any of its parts (rung 4). */
-declare function UpdatesProvider({ block, children }: {
-    block: UpdatesBlock;
-    children?: ReactNode;
-}): react.JSX.Element;
-/** The block from `UpdatesProvider` / `UpdatesRoot` / `GenesisNativeApp`. Throws outside one. */
-declare function useUpdates(): UpdatesBlock;
-/**
- * Hold reloads off while `active` (a form with unsaved changes):
- * `useBlockReload(form.formState.isDirty)`. Does nothing without an updates
- * block, so a screen can call it whether or not the block is on.
- */
-declare function useBlockReload(active: boolean): void;
-declare function useUpdatePolicy(): PolicyState;
-/** What the policy says now: `ok`, `forceUpgrade` or `maintenance`. */
-declare function useUpdateVerdict(): UpdateVerdict;
-/** The force-upgrade screen's props, or `null` when this version is supported. */
-declare function useForceUpgrade(): ForceUpgradeProps | null;
-/** The maintenance screen's props, or `null` when maintenance is off (or not known live). */
-declare function useMaintenance(): MaintenanceProps | null;
-declare function useUpdateCheck(): UpdateCheckState;
-/** True when a reload would be allowed now. */
-declare function useCanReload(): boolean;
-/** The banner's props, or `null` when there is nothing to show. */
-declare function useUpdateBanner(): UpdateBannerProps | null;
-/** The notes to show now, or `null`. */
-declare function useWhatsNew(): WhatsNewProps | null;
-/** The version signature, with the channel picked on this device once it has been read. */
-declare function useVersionSignature(): VersionSignature;
-interface UpdatesRootProps {
-    block: UpdatesBlock;
-    slots?: Slots<UpdatesSlots>;
-    slotProps?: SlotPropsFor<UpdatesSlots>;
-    children?: ReactNode;
-}
-/** The block's parts around your screens. */
-declare function UpdatesRoot({ block, slots, slotProps, children }: UpdatesRootProps): react.JSX.Element;
-
-export { evaluatePolicy as $, type ApplicationLike as A, UpdatesProvider as B, CLOCK_SKEW_MS as C, UpdatesRoot as D, type EvaluatePolicyOptions as E, type ForceUpgradeProps as F, type UpdatesRootProps as G, type UpdatesStorageLike as H, type VersionSignatureInput as I, type WhatsNewOptions as J, type WhatsNewProps as K, WhatsNewSheet as L, type MaintenanceProps as M, type WhatsNewState as N, type WhatsNewStore as O, type PolicyClientLike as P, createChannelSwitcher as Q, type ReleaseNote as R, type SupabasePolicySourceOptions as S, createPolicyStore as T, type UpdatesBlock as U, type VersionSignature as V, WEEK_MS as W, createReloadGuard as X, createUpdateChecker as Y, createUpdates as Z, createWhatsNewStore as _, type UpdatesSlots as a, notesSince as a0, sanitizePolicy as a1, staticPolicySource as a2, supabasePolicySource as a3, useBlockReload as a4, useCanReload as a5, useForceUpgrade as a6, useMaintenance as a7, useUpdateBanner as a8, useUpdateCheck as a9, useUpdatePolicy as aa, useUpdateVerdict as ab, useUpdates as ac, useVersionSignature as ad, useWhatsNew as ae, versionSignature as af, type ChannelSwitchResult as b, type ChannelSwitcher as c, type ChannelSwitcherOptions as d, ForceUpgradeScreen as e, MaintenanceScreen as f, type PolicyOrigin as g, type PolicyState as h, type PolicyStore as i, type PolicyStoreOptions as j, type ReloadGuard as k, UpdateBanner as l, type UpdateBannerProps as m, type UpdateCheckState as n, type UpdateCheckStatus as o, type UpdateChecker as p, type UpdateCheckerOptions as q, type UpdatePlatform as r, type UpdatePolicy as s, type UpdatePolicySource as t, type UpdateVerdict as u, type UpdatesAppStateLike as v, type UpdatesErrorSource as w, type UpdatesModuleLike as x, type UpdatesOnError as y, type UpdatesOptions as z };

package/dist/chunk-MMTPWUWI.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/query.ts"],"names":[],"mappings":";;;AAgBO,IAAM,MAAA,GAAS,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK;AAS9B,SAAS,uBAAA,CAAwB,MAAA,GAA4B,EAAC,EAAgB;AACnF,EAAA,MAAM,EAAE,SAAS,SAAA,EAAW,GAAG,MAAK,GAAI,MAAA,CAAO,kBAAkB,EAAC;AAClE,EAAA,OAAO,IAAI,WAAA,CAAY;AAAA,IACrB,GAAG,MAAA;AAAA,IACH,cAAA,EAAgB;AAAA,MACd,GAAG,IAAA;AAAA,MACH,OAAA,EAAS,EAAE,WAAA,EAAa,QAAA,EAAU,QAAQ,MAAA,EAAQ,SAAA,EAAW,GAAA,EAAQ,GAAG,OAAA,EAAQ;AAAA,MAChF,SAAA,EAAW,EAAE,WAAA,EAAa,QAAA,EAAU,GAAG,SAAA;AAAU;AACnD,GACD,CAAA;AACH;AAuCO,SAAS,qBAAA,CAAsB,EAAE,QAAA,EAAU,OAAA,EAAQ,EAAsC;AAC9F,EAAA,IAAI,QAAA,EAAU;AACZ,IAAA,YAAA,CAAa,gBAAA,CAAiB,CAAC,UAAA,KAAe;AAC5C,MAAA,MAAM,YAAA,GAAe,SAAS,gBAAA,CAAiB,QAAA,EAAU,CAAC,KAAA,KAAU,UAAA,CAAW,KAAA,KAAU,QAAQ,CAAC,CAAA;AAClG,MAAA,OAAO,MAAM,aAAa,MAAA,EAAO;AAAA,IACnC,CAAC,CAAA;AAAA,EACH;AACA,EAAA,IAAI,OAAA,EAAS;AACX,IAAA,aAAA,CAAc,gBAAA,CAAiB,CAAC,SAAA,KAAc,OAAA,CAAQ,gBAAA,CAAiB,CAAC,KAAA,KAAU,SAAA,CAAU,KAAA,CAAM,WAAA,KAAgB,KAAK,CAAC,CAAC,CAAA;AAAA,EAC3H;AACA,EAAA,OAAO,MAAM;AAEX,IAAA,IAAI,QAAA,EAAU,YAAA,CAAa,gBAAA,CAAiB,MAAM,MAAM;AAAA,IAAC,CAAC,CAAA;AAC1D,IAAA,IAAI,OAAA,EAAS,aAAA,CAAc,gBAAA,CAAiB,MAAM,MAAM;AAAA,IAAC,CAAC,CAAA;AAAA,EAC5D,CAAA;AACF","file":"chunk-MMTPWUWI.js","sourcesContent":["/**\n * Query: a TanStack Query client with offline-safe defaults, and the contract\n * for saving it to the phone. The persister itself is in\n * `@marktiderman/genesis-native/persist`, so an app that saves nothing doesn't\n * install TanStack's persister packages.\n */\nimport { QueryClient, focusManager, onlineManager, type QueryClientConfig } from \"@tanstack/react-query\";\n\n/** The part of AsyncStorage (or any async key-value store) Genesis uses. */\nexport interface AsyncStorageLike {\n  getItem(key: string): Promise<string | null>;\n  setItem(key: string, value: string): Promise<void>;\n  removeItem(key: string): Promise<void>;\n}\n\n/** One day in milliseconds: the default max age of the saved query cache. */\nexport const DAY_MS = 24 * 60 * 60 * 1000;\n\n/**\n * A QueryClient for a phone. `networkMode: \"always\"` runs a query or mutation\n * even when the device reports offline, so it fails (and shows its error or\n * cached data) instead of waiting forever for a network that may never come\n * back. `gcTime` matches the persisted max age, or restored queries would be\n * collected before they are used. Your `config` wins.\n */\nexport function createNativeQueryClient(config: QueryClientConfig = {}): QueryClient {\n  const { queries, mutations, ...rest } = config.defaultOptions ?? {};\n  return new QueryClient({\n    ...config,\n    defaultOptions: {\n      ...rest,\n      queries: { networkMode: \"always\", gcTime: DAY_MS, staleTime: 60_000, ...queries },\n      mutations: { networkMode: \"always\", ...mutations },\n    },\n  });\n}\n\n/**\n * The saved query cache. A `scope` (the signed-in user's id, `\"\"` for nobody)\n * is part of what is saved: a cache saved for one user is discarded, on disk\n * too, when another scope restores it.\n */\nexport interface QueryPersistence {\n  /** Load the saved cache into the client, if it was saved for `scope`. */\n  restore(scope: string): Promise<void>;\n  /** Save on every cache change, for `scope`; returns the unsubscribe. */\n  subscribe(scope: string): () => void;\n  /**\n   * Delete the saved cache. Clear the QueryClient first: the subscription\n   * then saves the empty cache, so a save already in flight can't leave the\n   * old queries on disk.\n   */\n  clear(): Promise<void>;\n}\n\n/** React Native's `AppState`, or a stand-in. */\nexport interface AppStateLike {\n  addEventListener(type: \"change\", listener: (state: string) => void): { remove(): void };\n}\n\n/** `@react-native-community/netinfo`'s default export, or a stand-in. */\nexport interface NetInfoLike {\n  addEventListener(listener: (state: { isConnected: boolean | null }) => void): () => void;\n}\n\nexport interface QueryLifecycleOptions {\n  appState?: AppStateLike;\n  netInfo?: NetInfoLike;\n}\n\n/**\n * Tell TanStack Query when the app comes to the front (refetch stale\n * queries) and when the network comes and goes. Returns the cleanup.\n */\nexport function connectQueryLifecycle({ appState, netInfo }: QueryLifecycleOptions): () => void {\n  if (appState) {\n    focusManager.setEventListener((setFocused) => {\n      const subscription = appState.addEventListener(\"change\", (state) => setFocused(state === \"active\"));\n      return () => subscription.remove();\n    });\n  }\n  if (netInfo) {\n    onlineManager.setEventListener((setOnline) => netInfo.addEventListener((state) => setOnline(state.isConnected !== false)));\n  }\n  return () => {\n    // Replacing the listener runs the cleanup of the one set above.\n    if (appState) focusManager.setEventListener(() => () => {});\n    if (netInfo) onlineManager.setEventListener(() => () => {});\n  };\n}\n"]}