@webority/mobile-core 0.0.29 → 0.2.0

package/lib/typescript/module/logger/index.d.ts

@@ -6,6 +6,7 @@ type LogFn = (message: string, ...optionalParams: unknown[]) => void;
  * library depend on any of them.
  *
  * Every method is optional; the library calls only what the adapter implements.
+ * `log` receives `info`, `warn` and `error` lines; `debug` never leaves the console.
  */
 export interface RemoteLogger {
     /** Append a breadcrumb (small, non-error event) for crash context. */
@@ -57,7 +58,21 @@ export interface LoggerOptions {
 }
 /** Configure dedupe window/threshold and screen history size. Merges with current options. */
 export declare const configureLogger: (options: LoggerOptions) => void;
+/** What `Logger.requestFailed` is told about the call beside the error itself. */
+export interface RequestFailedContext {
+    /** What the call was, in words: `'Load projects'`. Names the log line; defaults to the method and path. */
+    label?: string;
+    /**
+     * Statuses this call answers as part of its work (a 409 the screen explains, a 404 that
+     * means "none yet"): logged as a warning, never recorded as an error.
+     */
+    expectedStatuses?: readonly number[];
+    /** Anything else worth carrying to the remote sink. Never a token or a request body. */
+    [key: string]: unknown;
+}
 export interface LoggerType {
+    /** Console only, never forwarded to the remote sink. */
+    debug: LogFn;
     info: LogFn;
     warn: LogFn;
     error: LogFn;
@@ -65,6 +80,8 @@ export interface LoggerType {
     breadcrumb: (message: string, data?: Record<string, unknown>) => void;
     /** Record a non-fatal error with optional context. */
     recordError: (error: unknown, context?: Record<string, unknown>) => void;
+    /** Log a failed service call: cancel as info, an expected status as a warning, anything else as a recorded error. */
+    requestFailed: (error: unknown, context?: RequestFailedContext) => void;
     /** Bind a user identity for subsequent crash reports. */
     setUser: (id: string | null, attrs?: Record<string, unknown>) => void;
     /** Attach a custom attribute (release, build, env, role, etc.). */

package/lib/typescript/module/push/index.d.ts

@@ -1,3 +1,5 @@
-export type { PushAction, PushActionHandler, PushAndroidChannel, PushCategory, PushCategoryAction, PushConfig, PushDevice, PushLocalNotification, PushModules, PushNotificationsLike, PushPlatform, PushState, PushStatus } from './push.js';
+export type { PushAction, PushActionHandler, PushAndroidChannel, PushCategory, PushCategoryAction, PushConfig, PushDevice, PushLocalNotification, PushModules, PushNotificationsLike, PushPlatform, PushState } from './push.js';
 export { disablePush, enablePush, initPush, notifyLocal, onAction, setBadgeCount, setCategories, setPushImplementation, usePush } from './push.js';
+export type { PushStatus } from './status.js';
+export { PUSH_STATUS } from './status.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/push/push.d.ts

@@ -1,3 +1,4 @@
+import type { PushStatus } from './status.js';
 export type PushPlatform = 'Fcm' | 'Apns';
 export interface PushDevice {
     installationId: string;
@@ -62,7 +63,6 @@ export interface PushLocalNotification {
     body: string;
     data?: Record<string, string>;
 }
-export type PushStatus = 'unknown' | 'granted' | 'denied' | 'unavailable';
 export interface PushState {
     status: PushStatus;
     /** True once this process has registered the device, false after `disablePush`. */

package/lib/typescript/module/push/status.d.ts

@@ -0,0 +1,9 @@
+/** The push permission values, as runtime constants an app can compare against. */
+export declare const PUSH_STATUS: {
+    readonly unknown: "unknown";
+    readonly granted: "granted";
+    readonly denied: "denied";
+    readonly unavailable: "unavailable";
+};
+export type PushStatus = (typeof PUSH_STATUS)[keyof typeof PUSH_STATUS];
+//# sourceMappingURL=status.d.ts.map

package/lib/typescript/module/query/apiBaseQuery.d.ts

@@ -0,0 +1,55 @@
+import type { BaseQueryFn } from '@reduxjs/toolkit/query';
+import { type AxiosInstance, type Method, type ResponseType } from 'axios';
+import { type ApiError } from '../errors/index.js';
+/**
+ * What an endpoint's `query` returns. A bare string is a GET of that URL.
+ *
+ * `silent` opts this call out of the error toast (decision 42); an endpoint can
+ * instead set it once for every call with `extraOptions: { silent: true }`.
+ * `public` sends the call through the anonymous client (sign-in, sign-up, a
+ * public lookup), so one `createApi` serves both clients.
+ */
+export interface ApiRequest {
+    url: string;
+    method?: Method;
+    /** The request body. FormData is sent as multipart by the client. */
+    data?: unknown;
+    /** Query string values; build list queries with `buildListQuery`. */
+    params?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    /** Only JSON-safe types belong in the store; a blob download stays a service call. */
+    responseType?: Extract<ResponseType, 'json' | 'text'>;
+    timeout?: number;
+    silent?: boolean;
+    public?: boolean;
+}
+export type ApiQueryArgs = string | ApiRequest;
+/** Per-endpoint options, set as the endpoint's `extraOptions`. */
+export interface ApiExtraOptions {
+    silent?: boolean;
+}
+/**
+ * Returned as the base query's `meta`, which RTK Query copies onto the
+ * fulfilled and rejected actions as `action.meta.baseQueryMeta`. The toast
+ * middleware reads `silent` there. Plain values only, so the store stays
+ * serializable.
+ */
+export interface ApiBaseQueryMeta {
+    silent: boolean;
+    /** The HTTP status, or 0 when no response arrived. */
+    status: number;
+}
+export interface ApiBaseQueryOptions {
+    /** The signed-in client every call uses by default (`userClient`). */
+    client: AxiosInstance;
+    /** The anonymous client for calls marked `public: true` (`publicClient`). */
+    publicClient?: AxiosInstance;
+}
+export type ApiBaseQuery = BaseQueryFn<ApiQueryArgs, unknown, ApiError, ApiExtraOptions, ApiBaseQueryMeta>;
+/**
+ * The fleet RTK Query base query: every call goes through our axios clients,
+ * so refresh, retry, the offline check and logging stay in one place, and a
+ * failure comes back as the same `ApiError` a thunk rejects with.
+ */
+export declare const createApiBaseQuery: ({ client, publicClient }: ApiBaseQueryOptions) => ApiBaseQuery;
+//# sourceMappingURL=apiBaseQuery.d.ts.map

package/lib/typescript/module/query/createAppApi.d.ts

@@ -0,0 +1,21 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+/**
+ * The fleet `createApi` defaults. Unused data is kept a minute, and active
+ * queries refetch when the connection returns and when the user comes back to
+ * the app. Both flags only act once the app calls `setupApiListeners` on its
+ * store: window focus and online events on the web, `AppState` and the
+ * network status on a device.
+ */
+export declare const APP_API_DEFAULTS: {
+    readonly keepUnusedDataFor: 60;
+    readonly refetchOnReconnect: true;
+    readonly refetchOnFocus: true;
+};
+/**
+ * `createApi` with the fleet defaults; anything the app passes wins. One per
+ * app, in `services/api/apiSlice`, with `baseQuery: createApiBaseQuery(...)`
+ * and the app's `tagTypes`. Imported from the React entry so endpoints get
+ * their hooks; that entry needs `react-redux`, which every app has.
+ */
+export declare const createAppApi: typeof createApi;
+//# sourceMappingURL=createAppApi.d.ts.map

package/lib/typescript/module/query/index.d.ts

@@ -0,0 +1,9 @@
+export type { ApiBaseQuery, ApiBaseQueryMeta, ApiBaseQueryOptions, ApiExtraOptions, ApiQueryArgs, ApiRequest } from './apiBaseQuery.js';
+export { createApiBaseQuery } from './apiBaseQuery.js';
+export { APP_API_DEFAULTS, createAppApi } from './createAppApi.js';
+export { setupApiListeners } from './listeners.js';
+export type { ListFilterValue, ListQuery, PagedDataObject, PagedListRequest, SortOrder } from './paging.js';
+export { buildListQuery, getNextPageParam, getPreviousPageParam, hasNextPage, hasPreviousPage } from './paging.js';
+export type { ApiTag, TagId } from './tags.js';
+export { itemTag, LIST_TAG_ID, listTag, providesList, providesPagedList } from './tags.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/query/listeners.d.ts

@@ -0,0 +1,11 @@
+import type { ThunkDispatch, UnknownAction } from '@reduxjs/toolkit';
+/**
+ * Wires `refetchOnFocus` and `refetchOnReconnect` to the device. RTK's default
+ * handlers listen to `window` focus and online events, which never fire in
+ * React Native, so the app returning to the foreground counts as focus and
+ * mobile-core's network status drives online and offline (the same status the
+ * user client checks before every request). Call once after the store is
+ * created; it returns the unsubscribe.
+ */
+export declare const setupApiListeners: (dispatch: ThunkDispatch<unknown, unknown, UnknownAction>) => (() => void);
+//# sourceMappingURL=listeners.d.ts.map

package/lib/typescript/module/query/paging.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The fleet list contract, matching Webority.Delivery: the request is
+ * `PagedListRequest` (`page` 1-based, `pageSize`, `sortBy`, `sortOrder`) plus the
+ * endpoint's filters, and the response is `PagedDataObject<T>`. The server
+ * defaults a missing page to 1 and a missing size to 20, and cuts a size over
+ * 100 to 100.
+ */
+export interface PagedDataObject<T> {
+    items: T[];
+    page: number;
+    pageSize: number;
+    totalCount: number;
+    totalPages: number;
+}
+export type SortOrder = 'asc' | 'desc';
+export interface PagedListRequest {
+    page?: number;
+    pageSize?: number;
+    sortBy?: string;
+    sortOrder?: SortOrder;
+}
+export type ListFilterValue = string | number | boolean | null | undefined;
+export interface ListQuery extends PagedListRequest {
+    filters?: Record<string, ListFilterValue>;
+}
+/**
+ * The `params` for a list endpoint. Filters sit beside the paging keys, as the
+ * API's request type derives from `PagedListRequest`. Unset values and empty
+ * strings are dropped, so a cleared filter never sends `?status=`. A filter
+ * named like a paging key is refused rather than silently overriding it.
+ */
+export declare const buildListQuery: ({ page, pageSize, sortBy, sortOrder, filters }: ListQuery) => Record<string, string | number | boolean>;
+export declare const hasNextPage: (page: PagedDataObject<unknown>) => boolean;
+export declare const hasPreviousPage: (page: PagedDataObject<unknown>) => boolean;
+/**
+ * `getNextPageParam` for an RTK Query infinite query over a paged endpoint
+ * (pull-to-load lists): the next page number, or `undefined` on the last page.
+ */
+export declare const getNextPageParam: (lastPage: PagedDataObject<unknown>) => number | undefined;
+/** `getPreviousPageParam` for the same infinite query. */
+export declare const getPreviousPageParam: (firstPage: PagedDataObject<unknown>) => number | undefined;
+//# sourceMappingURL=paging.d.ts.map

package/lib/typescript/module/query/tags.d.ts

@@ -0,0 +1,31 @@
+import type { PagedDataObject } from './paging.js';
+/**
+ * The fleet tag convention. A list read provides `{ type, id: 'LIST' }` plus one
+ * tag per row; a create invalidates `LIST`, an update or delete invalidates the
+ * row's tag (and `LIST` when it changes membership or order). Row ids are the
+ * public ids the API returns (D-039), never an internal key.
+ */
+export declare const LIST_TAG_ID = "LIST";
+export type TagId = string | number;
+export interface ApiTag<TagType extends string> {
+    type: TagType;
+    id: TagId;
+}
+type IdSelector<T> = (item: T) => TagId;
+export declare const listTag: <TagType extends string>(type: TagType) => ApiTag<TagType>;
+export declare const itemTag: <TagType extends string>(type: TagType, id: TagId) => ApiTag<TagType>;
+/** Tags for a list response. A failed read still provides `LIST`, so the next write refetches it. */
+export declare function providesList<TagType extends string, T extends {
+    publicId: string;
+}>(type: TagType, items: readonly T[] | undefined): ApiTag<TagType>[];
+export declare function providesList<TagType extends string, T>(type: TagType, items: readonly T[] | undefined, selectId: IdSelector<T>): ApiTag<TagType>[];
+/**
+ * `providesTags` for an endpoint returning `PagedDataObject<T>`:
+ * `providesTags: providesPagedList('Project')`.
+ */
+export declare function providesPagedList<TagType extends string, T extends {
+    publicId: string;
+}>(type: TagType): (result: PagedDataObject<T> | undefined) => ApiTag<TagType>[];
+export declare function providesPagedList<TagType extends string, T>(type: TagType, selectId: IdSelector<T>): (result: PagedDataObject<T> | undefined) => ApiTag<TagType>[];
+export {};
+//# sourceMappingURL=tags.d.ts.map

package/lib/typescript/module/redux/errorToastMiddleware.d.ts

@@ -0,0 +1,51 @@
+import type { Middleware, MiddlewareAPI, UnknownAction } from '@reduxjs/toolkit';
+import { type ApiError } from '../errors/extractApiError.js';
+/**
+ * Toasts every rejected thunk and every failed RTK Query call, so no screen has to remember
+ * to surface a failure and none words it differently. Identical source in web-core and
+ * mobile-core; the toast itself comes in through `showToast`, so there is no UI dependency.
+ *
+ * Opt out with `silent: true` (decision 42), wherever the caller can put it:
+ *   - a thunk: `rejectWithValue(extractApiError(e), { silent: true })`, or `{ silent: true }`
+ *     in the thunk's object argument;
+ *   - an RTK Query call: `{ silent: true }` in the call's argument object;
+ *   - an RTK Query endpoint: `extraOptions: { silent: true }`, which the base query copies
+ *     onto its meta.
+ *
+ * Never toasted: an aborted thunk or a cancelled request (a screen unmounting), an RTK Query
+ * condition skip (the data is already cached), a 401 by default (the auth layer owns a dead
+ * session). Identical messages are de-duplicated for `dedupeMs`, because a screen that fires
+ * four fetches and loses the network would otherwise stack four copies of one sentence.
+ *
+ * `onRejected` is the product's say over one rejection, run before the default rules:
+ * `'toast'` shows it even where `ignoreCodes` or `ignoreStatuses` would not (a 401 that names a
+ * code is a refused sign-in, not a dead session), `'silent'` drops it, and nothing at all leaves
+ * the default rules to decide. It runs for silent rejections too, so a side effect (a
+ * read-only workspace notice, a profile refetch) fires whichever screen asked; `silent: true`
+ * still keeps the default toast off, because the screen said it answers the failure itself.
+ */
+export type ShowErrorToast = (message: string, error: ApiError) => void;
+/** What `onRejected` decides for one rejection: `'toast'`, `'silent'`, or nothing for the default rules. */
+export type RejectionDecision = 'toast' | 'silent' | undefined;
+/**
+ * The product's hook into every rejection the middleware sees. `api` is the store's
+ * `dispatch` and `getState`, for a side effect that reads or updates state.
+ */
+export type OnRejected = (action: UnknownAction, error: ApiError, api: MiddlewareAPI) => RejectionDecision;
+export interface ErrorToastOptions {
+    showToast: ShowErrorToast;
+    /** Server `code` values a screen answers in its own way (a paywall, a terms gate). */
+    ignoreCodes?: readonly string[];
+    /** HTTP statuses never toasted. Default `[401]`. */
+    ignoreStatuses?: readonly number[];
+    /** Window in which an identical message is shown once. Default 4000 ms; 0 disables. */
+    dedupeMs?: number;
+    /** Decides one rejection before the default rules; see the module comment. */
+    onRejected?: OnRejected;
+}
+type Dict = Record<string, unknown>;
+/** Is this a rejected createAsyncThunk or RTK Query action that asked not to be toasted? */
+export declare const isSilentRejection: (meta: Dict) => boolean;
+export declare function errorToastMiddleware(options: ErrorToastOptions): Middleware;
+export {};
+//# sourceMappingURL=errorToastMiddleware.d.ts.map

package/lib/typescript/module/redux/index.d.ts

@@ -0,0 +1,6 @@
+export type { ErrorToastOptions, OnRejected, RejectionDecision, ShowErrorToast } from './errorToastMiddleware.js';
+export { errorToastMiddleware, isSilentRejection } from './errorToastMiddleware.js';
+export type { RootReducerOptions } from './rootReducer.js';
+export { createRootReducer, resetState } from './rootReducer.js';
+export { SERIALIZABLE_IGNORED_ACTION_PATHS } from './serializableCheck.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/redux/rootReducer.d.ts

@@ -0,0 +1,19 @@
+import { type ActionFromReducersMapObject, type Reducer, type ReducersMapObject, type StateFromReducersMapObject } from '@reduxjs/toolkit';
+/**
+ * Clears every slice, the RTK Query cache included, in one dispatch. Dispatch it on logout
+ * (decision 22). Not a tidy-up: a slice left behind paints the previous user's data on the
+ * next sign-in before fresh fetches land, which on a shared device is a data leak.
+ */
+export declare const resetState: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"app/resetState">;
+export interface RootReducerOptions<K extends string> {
+    /** Slices that survive a reset because they belong to the device, not the user (theme, onboarding seen). */
+    preserve?: readonly K[];
+}
+/**
+ * `combineReducers(reducers)` that answers `resetState` by handing every slice `undefined`,
+ * so each returns its initial state. The RTK Query api reducer is in `reducers`, so its
+ * cache empties too, and a request still in flight is dropped when it lands because its
+ * cache entry no longer exists.
+ */
+export declare function createRootReducer<M extends ReducersMapObject>(reducers: M, options?: RootReducerOptions<Extract<keyof M, string>>): Reducer<StateFromReducersMapObject<M>, ActionFromReducersMapObject<M>>;
+//# sourceMappingURL=rootReducer.d.ts.map

package/lib/typescript/module/redux/serializableCheck.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Action paths the serializable check skips in every Webority store (decision 22: the check
+ * stays on and ignores named paths only). Setting `ignoredActionPaths` replaces Redux
+ * Toolkit's default list, so an app spreads this constant and appends its own paths, each
+ * with a one-line reason:
+ *
+ *   serializableCheck: { ignoredActionPaths: [...SERIALIZABLE_IGNORED_ACTION_PATHS, 'payload.at'] }
+ *
+ * `meta.arg`: a thunk's or RTK Query call's own argument, which may hold a File, a Blob or
+ * an AbortSignal and is never stored. `meta.baseQueryMeta`: the base query's request and
+ * response metadata, never stored. `ApiError` itself is plain data and needs no exemption.
+ */
+export declare const SERIALIZABLE_IGNORED_ACTION_PATHS: readonly string[];
+//# sourceMappingURL=serializableCheck.d.ts.map

package/lib/typescript/module/secureScreen/index.d.ts

@@ -0,0 +1,25 @@
+export interface SecureScreenOptions {
+    /**
+     * Whether the screen is the one on show. Pass React Navigation's
+     * `useIsFocused()`, so a secure screen left underneath a pushed screen stops
+     * blocking. Default `true`: block for as long as the component is mounted.
+     */
+    focused?: boolean;
+}
+/**
+ * Blocks capture while the calling screen is focused and releases it on blur
+ * or unmount. Each call holds its own claim, so two secure screens on the stack
+ * never release each other's protection.
+ *
+ * ```tsx
+ * import { useIsFocused } from '@react-navigation/native';
+ * import { useSecureScreen } from '@webority/mobile-core/secureScreen';
+ *
+ * const SignInScreen = () => {
+ *   useSecureScreen({ focused: useIsFocused() });
+ *   // ...
+ * };
+ * ```
+ */
+export declare const useSecureScreen: (options?: SecureScreenOptions) => void;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/versionCheck/buildNumber.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Build-number arithmetic for the server-driven update check, shared word for
+ * word by web-core and mobile-core.
+ *
+ * The API's `X-Min-App-Version` is the lowest internal build number it still
+ * supports for the calling client kind, and the app's own build number is an
+ * integer too (`VERSION_INTERNAL` on mobile, `appBuild` on web). The comparison
+ * is integer against integer, never semver against semver.
+ */
+/** A non-negative integer from a config or native value, or `null` when it is not one. */
+export declare const parseBuildNumber: (value: string | number | null | undefined) => number | null;
+/** True only when a minimum is known and the build is strictly below it. */
+export declare const isBuildBelowMinimum: (build: number, minimum: number | null) => boolean;
+//# sourceMappingURL=buildNumber.d.ts.map

package/lib/typescript/module/versionCheck/index.d.ts

@@ -2,31 +2,39 @@ import { type Environment } from '../config/index.js';
 /**
  * Minimal device-info shape we depend on.
  *
- * This is a LAST RESORT, not the primary path. `Platform.OS` already gives the
- * platform, and every Webority app carries its own store id and version in
- * `appsettings.Compiled.json` — so `setConfig({ appId, appVersion })` covers
- * both remaining values without a native module. The injector below exists for
- * apps that would rather hand us a `react-native-device-info` instance than
- * wire two config keys.
+ * This is a LAST RESORT, not the primary path. Every Webority app carries its
+ * store id and build number in `appsettings.Compiled.json`, so
+ * `setConfig({ appId, appBuild })` covers both without a native module, and
+ * expo-application covers an app that wires neither. `getBuildNumber` is
+ * optional so an injector written before the server-driven check still fits;
+ * without it the build number comes from expo-application.
  */
 interface DeviceInfoLike {
     getBundleId: () => string;
     getVersion: () => string;
+    getBuildNumber?: () => string;
 }
 /**
  * Supply the app identity from a native module instead of config.
- * Prefer `setConfig({ appId, appVersion })` — it needs no native dependency.
+ * Prefer `setConfig({ appId, appBuild })` — it needs no native dependency.
  * Pass `null` to clear.
  */
 export declare const setDeviceInfoImplementation: (impl: DeviceInfoLike | null) => void;
 export type Platform = 'ios' | 'android' | string;
+/**
+ * A required update always reports `'major'`: the server states a minimum
+ * build, not the size of the change, and `'major'` is the value consumers
+ * already treat as "must update".
+ */
 export type UpdateType = 'major' | 'minor' | 'patch' | 'prerelease' | null;
+/** @deprecated Store versions are no longer parsed; the minimum is a build number. */
 export interface ParsedVersion {
     major: number;
     minor: number;
     patch: number;
     prerelease: string;
 }
+/** @deprecated The store is no longer read; the minimum comes from `X-Min-App-Version`. */
 export interface VersionData {
     version: string | null;
     released?: string | null;
@@ -36,6 +44,7 @@ export interface VersionData {
     country?: string;
     lastChecked: string;
 }
+/** @deprecated The store is no longer read; the minimum comes from `X-Min-App-Version`. */
 export interface VersionComparison {
     needsUpdate: boolean;
     updateType: UpdateType;
@@ -52,29 +61,31 @@ export interface UpdateInfo {
 }
 export interface VersionCheckType {
     /**
-     * Check if a new version is available.
-     * Includes retry logic and proper error handling.
+     * Whether this build is below the minimum the API last sent in
+     * `X-Min-App-Version`. Resolves "no update" until a reply carried one, and
+     * rejects only when the app's build number is unknown.
      */
     isNewVersionAvailable: () => Promise<VersionCheckResult>;
     /**
      * Opens the appropriate store URL to update the app.
-     * Uses the provided URL or falls back to direct store URLs.
+     * Uses the provided URL or falls back to the direct store URL.
      */
     openUpdateUrl: (url?: string | null) => Promise<boolean>;
-    /**
-     * Get the fallback store URL.
-     * Useful when URL from version check fails.
-     */
+    /** The store URL for this app on this platform. */
     getFallbackStoreUrl: () => string;
 }
 export declare const VersionCheck: VersionCheckType;
 /**
- * Custom hook to check for required app updates.
+ * Whether this build must update, from the minimum the API sends in
+ * `X-Min-App-Version`. Re-renders the moment a reply raises the minimum, so a
+ * minimum raised mid-session opens the ForceUpdateDialog without a restart.
  *
- * @param isAppReady - Whether the app is ready to perform the check
- * @param environment - The app environment (defaults to the one in config)
+ * @param isAppReady - Whether the app is ready to show the prompt
+ * @param environment - The app environment (defaults to the one in config); the
+ *   check runs in `'Production'` only
  */
 export declare const useVersionCheck: (isAppReady: boolean, environment?: Environment) => UpdateInfo;
 export default VersionCheck;
+export { isBuildBelowMinimum, parseBuildNumber } from './buildNumber.js';
 export type { DeviceInfoLike };
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webority/mobile-core",
-  "version": "0.0.29",
+  "version": "0.2.0",
   "description": "Platform layer for Webority React Native apps: HTTP clients, auth/token storage, config, logging, formatters, validators, network status, permissions, storage and version checks. No UI.",
   "keywords": [
     "react-native",
@@ -161,6 +161,16 @@
         "default": "./lib/commonjs/share/index.js"
       }
     },
+    "./secureScreen": {
+      "import": {
+        "types": "./lib/typescript/module/secureScreen/index.d.ts",
+        "default": "./lib/module/secureScreen/index.js"
+      },
+      "require": {
+        "types": "./lib/typescript/commonjs/secureScreen/index.d.ts",
+        "default": "./lib/commonjs/secureScreen/index.js"
+      }
+    },
     "./push": {
       "import": {
         "types": "./lib/typescript/module/push/index.d.ts",
@@ -191,6 +201,16 @@
         "default": "./lib/commonjs/smsRetriever/index.js"
       }
     },
+    "./query": {
+      "import": {
+        "types": "./lib/typescript/module/query/index.d.ts",
+        "default": "./lib/module/query/index.js"
+      },
+      "require": {
+        "types": "./lib/typescript/commonjs/query/index.d.ts",
+        "default": "./lib/commonjs/query/index.js"
+      }
+    },
     "./phone/countries": {
       "import": {
         "types": "./lib/typescript/module/phone/countries.d.ts",
@@ -201,6 +221,16 @@
         "default": "./lib/commonjs/phone/countries.js"
       }
     },
+    "./redux": {
+      "import": {
+        "types": "./lib/typescript/module/redux/index.d.ts",
+        "default": "./lib/module/redux/index.js"
+      },
+      "require": {
+        "types": "./lib/typescript/commonjs/redux/index.d.ts",
+        "default": "./lib/commonjs/redux/index.js"
+      }
+    },
     "./package.json": "./package.json"
   },
   "main": "./lib/commonjs/index.js",
@@ -211,6 +241,9 @@
     "lib",
     "src/specs",
     "android",
+    "!android/build",
+    "!android/.gradle",
+    "!android/.cxx",
     "!**/__tests__",
     "!**/*.test.*",
     "!**/*.spec.*",
@@ -225,7 +258,7 @@
     }
   },
   "scripts": {
-    "build": "bob build",
+    "build": "bob build && node ../../scripts/minify-lib.mjs",
     "clean": "rimraf lib",
     "lint": "biome lint ./src",
     "lint:fix": "biome lint --write ./src",
@@ -237,6 +270,7 @@
     "libphonenumber-js": "^1.12.41"
   },
   "peerDependencies": {
+    "@reduxjs/toolkit": "^2.12.0",
     "expo": ">=57.0.0",
     "expo-application": ">=57.0.0",
     "expo-calendar": ">=57.0.0",
@@ -249,14 +283,19 @@
     "expo-media-library": ">=57.0.0",
     "expo-network": ">=57.0.0",
     "expo-notifications": ">=57.0.0",
+    "expo-screen-capture": ">=57.0.0",
     "expo-secure-store": ">=57.0.0",
     "expo-sharing": ">=57.0.0",
     "expo-sqlite": ">=57.0.0",
     "expo-task-manager": ">=57.0.0",
     "react": "^19.1.0",
-    "react-native": ">=0.81.0"
+    "react-native": ">=0.81.0",
+    "react-redux": "^9.3.0"
   },
   "peerDependenciesMeta": {
+    "@reduxjs/toolkit": {
+      "optional": true
+    },
     "expo-calendar": {
       "optional": true
     },
@@ -284,11 +323,17 @@
     "expo-notifications": {
       "optional": true
     },
+    "expo-screen-capture": {
+      "optional": true
+    },
     "expo-sharing": {
       "optional": true
     },
     "expo-task-manager": {
       "optional": true
+    },
+    "react-redux": {
+      "optional": true
     }
   },
   "publishConfig": {
@@ -302,13 +347,15 @@
       [
         "commonjs",
         {
-          "esm": true
+          "esm": true,
+          "sourceMaps": false
         }
       ],
       [
         "module",
         {
-          "esm": true
+          "esm": true,
+          "sourceMaps": false
         }
       ],
       [