@webority/mobile-core 0.1.0 → 0.2.0

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/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.1.0",
+  "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",
@@ -201,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",
@@ -211,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",
@@ -250,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",
@@ -268,9 +289,13 @@
     "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
     },
@@ -306,6 +331,9 @@
     },
     "expo-task-manager": {
       "optional": true
+    },
+    "react-redux": {
+      "optional": true
     }
   },
   "publishConfig": {