@webority/mobile-core 0.0.29 → 0.2.0

package/lib/typescript/module/errors/extractApiError.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Normalizes any failure a thunk, a service or the RTK Query base query can see into one
+ * `ApiError`. Identical source in @webority/web-core and @webority/mobile-core.
+ *
+ * Bodies read, newest first: the fleet body `{ code, message, traceId, errors }` (D-077),
+ * where `errors` is a ModelState dictionary (`{ Field: ["msg"] }`) or a list of
+ * `{ field, message, reference }` (a refusal that names its fields),
+ * ProblemDetails `{ title, detail, errors }` from APIs not yet moved, legacy `{ error }` and
+ * `{ message }`, and a plain-text body.
+ *
+ * Message precedence is fixed (react.md): first field error, then `message`, `detail`, a
+ * legacy `error`, `title`, then `Request failed (<status>)`. `title` is last because it is
+ * the ProblemDetails category ("Bad Request"), not the curated sentence.
+ *
+ * Two things never become `message`: a 5xx body (our failure, nothing the user can act on)
+ * and anything that reads like an exception dump. The server's text goes on `detail` for
+ * the logger instead.
+ */
+export interface ApiError {
+    /** Stable snake_case branch key from the server (`not_found`, `validation_failed`). Branch on it, never render it. */
+    code: string | null;
+    /** The only user-facing string. */
+    message: string;
+    /** camelCase field path to its first message, ready for react-hook-form `setError`. */
+    fieldErrors: Record<string, string>;
+    /** HTTP status, or 0 when no response arrived. */
+    status: number;
+    /** True when no answer arrived (offline, network drop, timeout): a retry is worth offering. */
+    offline: boolean;
+    /** The server's trace id, for a support reference. */
+    traceId: string | null;
+    /** What the server or runtime actually said. For the logger, never for the screen. */
+    detail: string | null;
+}
+export declare const SERVER_FAILURE_MESSAGE = "Something went wrong on our side. Please try again in a moment.";
+export declare const OFFLINE_MESSAGE = "You appear to be offline. Check your connection and try again.";
+export declare const TIMEOUT_MESSAGE = "That took too long to respond. Check your connection and try again.";
+export declare const UNEXPECTED_MESSAGE = "Something went wrong. Please try again.";
+/** `code` for a request the caller cancelled (axios `CanceledError`). Never toasted. */
+export declare const REQUEST_CANCELED_CODE = "request_canceled";
+/** `code` for a response that failed schema validation at the service boundary. */
+export declare const CONTRACT_ERROR_CODE = "contract_error";
+/** `code` for a request that got no answer in time (axios `ECONNABORTED` / `ETIMEDOUT`). `offline` is true. */
+export declare const TIMEOUT_CODE = "timeout";
+/** `code` for a request that never reached the server (offline, DNS, CORS, a dropped connection). `offline` is true. */
+export declare const NETWORK_CODE = "network";
+/** `Items[0].UnitPrice` -> `items[0].unitPrice`; `$.email` (System.Text.Json path) -> `email`. */
+export declare const toFieldPath: (key: string) => string;
+export declare const isApiError: (value: unknown) => value is ApiError;
+export declare function extractApiError(error: unknown): ApiError;
+/**
+ * True when no answer arrived (offline, a dropped connection, a timeout), so the caller cannot
+ * tell what the server did. The same as `extractApiError(error).offline`.
+ */
+export declare const isNoResponse: (error: unknown) => boolean;
+/**
+ * The sentence a screen shows for a failure: the server's own curated message when it sent one,
+ * otherwise the screen's `fallback` ("We couldn't save the project."), otherwise the library's
+ * generic sentence. A lost answer always reads as the connection message, because "check your
+ * connection" is more accurate than any screen's fallback. A 5xx, a cancelled request and a body
+ * with no usable sentence count as "the server said nothing usable".
+ *
+ * `fallback: null` is the "say nothing" mode, for a screen that shows only what the server
+ * curated (a live panel that keeps its last result): it returns null when the server said
+ * nothing usable, and still the connection message for a lost answer.
+ */
+export declare function apiErrorMessage(error: unknown, fallback?: string): string;
+export declare function apiErrorMessage(error: unknown, fallback: string | null): string | null;
+//# sourceMappingURL=extractApiError.d.ts.map

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

@@ -0,0 +1,3 @@
+export type { ApiError } from './extractApiError.js';
+export { apiErrorMessage, CONTRACT_ERROR_CODE, extractApiError, isApiError, isNoResponse, NETWORK_CODE, OFFLINE_MESSAGE, REQUEST_CANCELED_CODE, SERVER_FAILURE_MESSAGE, TIMEOUT_CODE, TIMEOUT_MESSAGE, toFieldPath, UNEXPECTED_MESSAGE } from './extractApiError.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/formatters/currency.d.ts

@@ -1,24 +1,39 @@
-export interface FormatCurrencyOptions {
+/**
+ * The currency keys plus any other `Intl.NumberFormatOptions` (`currencyDisplay`, `notation`,
+ * `signDisplay`, ...), passed through to Intl.NumberFormat.
+ */
+export interface FormatCurrencyOptions extends Omit<Intl.NumberFormatOptions, 'style' | 'currency'> {
     /** ISO 4217 currency code. Defaults to `'INR'`. */
     currency?: string;
-    /** BCP-47 locale tag. Defaults to `'en-IN'` (Indian numbering system). */
+    /** BCP-47 locale tag. Defaults to the configured locale, else `'en-IN'` (Indian numbering system). */
     locale?: string;
-    /** Minimum fraction digits. Defaults to 0 for whole amounts, 2 otherwise. */
+    /** Minimum fraction digits. Defaults to 0 for whole amounts, else the currency's own (2 for INR, 0 for JPY). */
     minimumFractionDigits?: number;
-    /** Maximum fraction digits. Defaults to 2. */
+    /** Maximum fraction digits. Defaults to the currency's own. */
     maximumFractionDigits?: number;
     /** Strip the currency symbol — useful when the symbol is rendered separately. */
     stripSymbol?: boolean;
+    /**
+     * What a missing amount prints. Defaults to the configured placeholder once the app has
+     * configured a locale or an `empty` (`configureFormatters`), else `''`.
+     */
+    empty?: string;
 }
 /**
  * Format an amount as currency. Defaults to **INR** with Indian numbering (`en-IN`),
- * which matches the standard convention across Webority projects.
+ * which matches the standard convention across Webority projects. Called with no
+ * options: "₹1,50,000" for 150000, "₹1,234.50" for 1234.5, and `''` for a missing amount.
+ * Once the app configures a locale (`configureFormatters({ locale })`), the amount is
+ * written in that locale and a missing amount prints the configured placeholder ("-").
+ * A numeric string reads as its number. For money the API carries in minor units (paise),
+ * use `formatMinor`.
  *
  * @example
  * formatCurrency(150000)            // ₹1,50,000
  * formatCurrency(1234.5)            // ₹1,234.50
- * formatCurrency(99, { currency: 'USD', locale: 'en-US' }) // $99.00
+ * formatCurrency(99, { currency: 'USD', locale: 'en-US' }) // $99
  * formatCurrency(150000, { stripSymbol: true })            // 1,50,000
+ * formatCurrency(1500000, { notation: 'compact' })         // ₹15L
  */
-export declare const formatCurrency: (amount: number | null | undefined, options?: FormatCurrencyOptions) => string;
+export declare const formatCurrency: (amount: number | string | null | undefined, options?: FormatCurrencyOptions) => string;
 //# sourceMappingURL=currency.d.ts.map

package/lib/typescript/module/formatters/date.d.ts

@@ -1,19 +1,19 @@
+import { type DateValue, type FormatDateOptions, type FormatDateTimeOptions, type FormatTimeOptions } from './house.js';
 export type DateInput = Date | string | number;
 export type DateStyle = 'short' | 'medium' | 'long' | 'full';
 export type TimeStyle = 'short' | 'medium' | 'long';
-/**
- * Locale-aware date formatter. Defaults to `'medium'` style and `'en-IN'` locale,
- * matching the Indian-locale convention used across Webority apps.
- */
-export declare const formatDate: (value: DateInput, style?: DateStyle, locale?: string) => string;
-/**
- * Locale-aware time formatter (24-hour fallback when Intl is unavailable).
- */
-export declare const formatTime: (value: DateInput, style?: TimeStyle, locale?: string) => string;
-/**
- * Combined date + time formatter.
- */
-export declare const formatDateTime: (value: DateInput, dateStyle?: DateStyle, timeStyle?: TimeStyle, locale?: string) => string;
+/** "08-Apr-2026" in the configured zone; a bare calendar date stays that day. */
+export declare function formatDate(value: DateValue, options?: FormatDateOptions): string;
+/** Intl `dateStyle` output, `'en-IN'` by default. */
+export declare function formatDate(value: DateInput, style: DateStyle, locale?: string): string;
+/** "8:05 PM" in IST, labelled in any other zone. */
+export declare function formatTime(value: DateValue, options?: FormatTimeOptions): string;
+/** Intl `timeStyle` output (24-hour fallback when Intl is unavailable). */
+export declare function formatTime(value: DateInput, style: TimeStyle, locale?: string): string;
+/** "08-Apr-2026, 8:05 PM" in IST, labelled in any other zone. */
+export declare function formatDateTime(value: DateValue, options?: FormatDateTimeOptions): string;
+/** Intl `dateStyle` + `timeStyle` output. */
+export declare function formatDateTime(value: DateInput, dateStyle: DateStyle, timeStyle?: TimeStyle, locale?: string): string;
 /**
  * Returns a humanized relative-time string (e.g. "5 minutes ago", "in 3 days").
  * Uses `Intl.RelativeTimeFormat` when available; otherwise a sensible English fallback.

package/lib/typescript/module/formatters/dateMath.d.ts

@@ -21,9 +21,11 @@ export declare const diffMs: (a: DateInput, b: DateInput) => number;
 export declare const startOfDay: (value: DateInput) => Date | null;
 /**
  * Adds (or, with a negative count, subtracts) whole calendar days in the
- * device's local timezone. Returns null for unparseable input.
+ * device's local timezone. Returns null for a missing or unparseable date or
+ * count, so the result can go straight to `formatDate`. Same name and meaning
+ * as `@webority/web-core`'s `addDays`.
  */
-export declare const addDays: (value: DateInput, count: number) => Date | null;
+export declare const addDays: (value: DateInput | null | undefined, count: number) => Date | null;
 /**
  * Small dayjs/moment-style token formatter — YYYY/YY, MMMM/MMM/MM/M,
  * DD/D, dddd/ddd, HH/H (24h), hh/h (12h), mm/m, ss/s, A/a (upper/lower AM/PM).

package/lib/typescript/module/formatters/formatConfig.d.ts

@@ -0,0 +1,48 @@
+/**
+ * App-wide settings for the house formatters. This file is byte-identical in
+ * @webority/mobile-core and @webority/web-core, so a screen formats the same
+ * instant the same way on a phone and in a browser.
+ *
+ * Zone policy: an India-market product shows every instant in IST, unlabelled
+ * (the default). A product whose users span time zones opts into the viewer's
+ * own zone; times then carry a zone label so an instant is never ambiguous.
+ *
+ * Text policy: with no locale configured, every formatter prints the house
+ * text, assembled here so it reads the same on every engine ("08-Apr-2026",
+ * "8:05 PM", "1,23,456.79"). Configuring a locale hands the words and
+ * separators to Intl for that locale: month names, digit separators, the
+ * 12- or 24-hour clock and its AM/PM casing, zone names and relative phrases.
+ * The date order stays DD-MMM-YYYY either way.
+ */
+/** `'IST'`: every instant in India Standard Time. `'viewer'`: the device or browser zone, labelled. */
+export type ZoneMode = 'IST' | 'viewer';
+/** How the integer part of a number is grouped. */
+export type NumberGrouping = 'indian' | 'international' | 'none';
+export interface FormatterConfig {
+    /** Default zone for every date and time formatter. */
+    zone: ZoneMode;
+    /**
+     * BCP-47 locale. Left at its default (en-IN), it only picks the house digit
+     * grouping. Configured (`configureFormatters({ locale })`), it switches every
+     * formatter to Intl's text for that locale: en-IN gives "08-Sept-2026" and
+     * "IST", de-DE gives "1.234,5" and "20:05".
+     */
+    locale: string;
+    /** What every formatter returns for a missing or unreadable value. */
+    empty: string;
+}
+/**
+ * Set the zone mode, locale or empty placeholder for the whole app. Call it
+ * once at startup; a key left out (or undefined) keeps its current value.
+ * Passing nothing restores the defaults (IST, en-IN, "-", house text).
+ */
+export declare const configureFormatters: (config?: Partial<FormatterConfig>) => void;
+/** The settings in force, as a copy. */
+export declare const getFormatterConfig: () => FormatterConfig;
+/** Whether the app set `key` through `configureFormatters`, rather than leaving the default. */
+export declare const isFormatterConfigured: (key: keyof FormatterConfig) => boolean;
+/** The configured locale when the app set one (Intl text), else null (house text). */
+export declare const configuredLocale: () => string | null;
+/** The grouping a locale implies: Indian for a locale whose region is IN. */
+export declare const groupingForLocale: (locale: string) => NumberGrouping;
+//# sourceMappingURL=formatConfig.d.ts.map

package/lib/typescript/module/formatters/house.d.ts

@@ -0,0 +1,143 @@
+/**
+ * The house formatters: DD-MMM-YYYY dates, IST by default or the viewer's own
+ * zone with a label, Indian digit grouping by default, money in minor units,
+ * and one empty placeholder. Byte-identical in @webority/mobile-core and
+ * @webority/web-core.
+ *
+ * Same output on Hermes and in every browser is the design constraint, so the
+ * text is assembled here rather than by Intl. Engines disagree on month
+ * abbreviations ("Sep" or "Sept"), on the space before AM/PM (a plain or a
+ * narrow no-break space), on zone names ("IST" or "GMT+5:30") and on which
+ * Intl options exist at all (Hermes has no RelativeTimeFormat and no
+ * trailingZeroDisplay). IST and the viewer's zone are therefore computed with
+ * plain Date arithmetic; Intl is used only to read the wall clock of an
+ * explicitly named IANA zone, through formatToParts with numeric fields, to
+ * read the locale's 12- or 24-hour clock, and where a caller asks for Intl
+ * output itself (Intl number options, `formatRelative({ intl: true })`).
+ *
+ * Called with no options (house defaults: zone IST, locale en-IN, empty "-"):
+ * - formatDate(v) "08-Apr-2026"; formatTime(v) "8:05 PM"; formatDateTime(v) "08-Apr-2026, 8:05 PM";
+ * - formatRelative(v) "5 minutes ago", "in 3 days", "just now";
+ * - formatNumber(v) "1,23,456.789" (Indian grouping, up to 3 decimals);
+ * - formatPercent(0.42) "42%"; formatMinor(15000000) "₹1,50,000.00";
+ * - a missing or unreadable value "-".
+ *
+ * With a configured locale (`configureFormatters({ locale })`), the words and separators come
+ * from Intl for that locale and the date order stays DD-MMM-YYYY. For en-IN in the viewer zone:
+ * "08-Sept-2026", "08:05 pm", "08-Sept-2026, 08:05 pm IST", "yesterday", "12,34,567.891",
+ * "₹1,50,000". For de-DE: "08-Sept-2026", "20:05", "1.234.567,891".
+ */
+import { type NumberGrouping, type ZoneMode } from './formatConfig.js';
+/** A date the house formatters accept; null, undefined and "" read as missing. */
+export type DateValue = Date | string | number | null | undefined;
+/** A zone mode, `'UTC'`, or any IANA zone name such as `'America/New_York'`. */
+export type ZoneOption = ZoneMode | 'UTC' | (string & {});
+export interface FormatDateOptions {
+    /** Overrides the configured zone mode for this call. */
+    zone?: ZoneOption;
+    /** Overrides the configured empty placeholder for this call. */
+    empty?: string;
+}
+export interface FormatTimeOptions extends FormatDateOptions {
+    /**
+     * 12 gives "8:05 PM", 24 gives "20:05". Defaults to 12 for the house text, and to the
+     * configured locale's own clock once a locale is configured (12 for en-IN and en-US,
+     * 24 for en-GB, de-DE and most of Europe).
+     */
+    hourCycle?: 12 | 24;
+    /**
+     * Append the zone label ("IST", "UTC", "GMT-4"; Intl's short zone name for a
+     * configured locale). Defaults to on for every zone except IST, so the viewer
+     * mode always says which clock it shows.
+     */
+    zoneLabel?: boolean;
+}
+export type FormatDateTimeOptions = FormatTimeOptions;
+export interface FormatRelativeOptions {
+    /** The instant to measure from. Defaults to now. */
+    now?: Date | string | number;
+    empty?: string;
+    /**
+     * Intl's own phrasing ("yesterday", "in 2 days", "now") instead of the house phrase
+     * ("1 day ago"). Always on once a locale is configured. Intl phrases count in rounded
+     * years, months, days, hours, minutes and seconds, with no week unit, so 36 hours ahead reads
+     * "in 2 days". An engine without Intl.RelativeTimeFormat (older Hermes) prints the house phrase.
+     */
+    intl?: boolean;
+}
+/**
+ * The house keys, plus any `Intl.NumberFormatOptions`. With house keys only, the text is
+ * assembled here (same on every engine). With any other Intl key (`style`, `unit`,
+ * `notation`, `signDisplay`, `useGrouping`, ...), the number goes to `Intl.NumberFormat` in
+ * `locale` with every option passed through, so it reads as that engine's Intl reads it.
+ */
+export interface FormatNumberOptions extends Intl.NumberFormatOptions {
+    /**
+     * Defaults to the locale's grouping (Indian for en-IN). An explicit `'indian'` or
+     * `'international'` prints the house text even with a configured locale; `'none'` drops
+     * the separators either way.
+     */
+    grouping?: NumberGrouping;
+    /** Defaults to 0. */
+    minimumFractionDigits?: number;
+    /** Defaults to 3 for formatNumber and 0 for formatPercent. */
+    maximumFractionDigits?: number;
+    /** Overrides the configured locale for this call. */
+    locale?: string;
+    empty?: string;
+}
+export interface FormatPercentOptions extends FormatNumberOptions {
+    /** `'ratio'` (the default) reads 0.42 as 42%; `'percent'` reads 42 as 42%. */
+    scale?: 'ratio' | 'percent';
+}
+export interface FormatMinorOptions {
+    /** ISO 4217 code. Defaults to `'INR'`. */
+    currency?: string;
+    /** Defaults to Indian grouping for INR and international grouping for every other currency. */
+    grouping?: NumberGrouping;
+    /** Print a whole amount without its zero decimals: "₹1,500" instead of "₹1,500.00". */
+    dropZeroDecimals?: boolean;
+    /** `false` prints the digits alone, for a field that draws the symbol itself. */
+    symbol?: boolean;
+    empty?: string;
+}
+/**
+ * "08-Apr-2026". A bare calendar date ("2026-04-08") always shows as that day;
+ * an instant shows its day in the configured zone.
+ */
+export declare const formatDate: (value: DateValue, options?: FormatDateOptions) => string;
+/** "8:05 PM" in IST, "8:05 PM GMT-4" in the viewer's zone; "20:05" for a configured locale with a 24-hour clock. */
+export declare const formatTime: (value: DateValue, options?: FormatTimeOptions) => string;
+/** "08-Apr-2026, 8:05 PM" in IST, "08-Apr-2026, 10:35 AM GMT-4" in the viewer's zone. */
+export declare const formatDateTime: (value: DateValue, options?: FormatDateTimeOptions) => string;
+/**
+ * "just now", "5 minutes ago", "in 3 days". English on every engine: Hermes
+ * has no Intl.RelativeTimeFormat. Counts are whole units, rounded down, so
+ * 59 minutes never reads as "60 minutes". With a configured locale, or
+ * `{ intl: true }`, the phrase is Intl's in that locale instead, with numeric
+ * "auto" and rounded counts: "yesterday", "in 2 days" at 36 hours ahead, "10 days ago",
+ * "30 seconds ago", "now".
+ */
+export declare const formatRelative: (value: DateValue, options?: FormatRelativeOptions) => string;
+/**
+ * "1,23,456.79" by default; a string holding a number is read as that number. Any Intl option
+ * beyond the house keys (`{ style: 'unit', unit: 'meter' }`, `{ notation: 'compact' }`) hands
+ * the number to Intl.NumberFormat with every option passed through. With a configured locale,
+ * the separators are that locale's ("1.234,5" for de-DE).
+ */
+export declare const formatNumber: (value: number | string | null | undefined, options?: FormatNumberOptions) => string;
+/**
+ * "42%" from 0.42, or from 42 with `scale: 'percent'`. Whole percent unless fraction digits are asked for.
+ * Any Intl option beyond the house keys goes to Intl.NumberFormat with `style: 'percent'`.
+ */
+export declare const formatPercent: (value: number | string | null | undefined, options?: FormatPercentOptions) => string;
+/**
+ * Money held in minor units (paise, cents), which is how every API carries
+ * it: formatMinor(15000000) gives "₹1,50,000.00". The split into whole and
+ * fractional units is done on the integer's digits, so no floating-point
+ * division can shift a paisa. A fractional input is rounded to the nearest
+ * minor unit. A currency without a known symbol prints its code: "AED 1,000.00".
+ * With a configured locale, Intl writes it in that locale ("150.000,00 €" for de-DE).
+ */
+export declare const formatMinor: (amountMinor: number | string | null | undefined, options?: FormatMinorOptions) => string;
+//# sourceMappingURL=house.d.ts.map

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

@@ -3,6 +3,10 @@ export { formatCurrency } from './currency.js';
 export type { DateInput, DateStyle, TimeStyle } from './date.js';
 export { formatDate, formatDateTime, formatRelativeTime, formatTime } from './date.js';
 export { addDays, diffMs, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, isDateAfter, isDateBefore, isSameDay, startOfDay } from './dateMath.js';
+export type { FormatterConfig, NumberGrouping, ZoneMode } from './formatConfig.js';
+export { configureFormatters, getFormatterConfig } from './formatConfig.js';
+export type { DateValue, FormatDateOptions, FormatDateTimeOptions, FormatMinorOptions, FormatNumberOptions, FormatPercentOptions, FormatRelativeOptions, FormatTimeOptions, ZoneOption } from './house.js';
+export { formatMinor, formatRelative } from './house.js';
 export { getInitials } from './initials.js';
 export { formatCompactNumber, formatNumber, formatPercent } from './number.js';
 export type { FormatPhoneOptions, PhoneCountry, PhoneCountryEntry, PhoneNumber, PhoneNumberType, PhoneParts, PhoneValidationKind } from './phone.js';

package/lib/typescript/module/formatters/number.d.ts

@@ -1,12 +1,22 @@
+import { type FormatNumberOptions, type FormatPercentOptions } from './house.js';
 /**
- * Locale-aware number formatter. Defaults to `'en-IN'` (Indian grouping).
+ * Two forms share each name. With an options object, or nothing, the house
+ * formatter runs (`./house`: no Intl, the configured grouping and empty
+ * placeholder, a numeric string read as its number). With positional
+ * arguments the original Intl formatter runs, unchanged, returning '' for
+ * missing input.
  */
-export declare const formatNumber: (value: number | null | undefined, fractionDigits?: number, locale?: string) => string;
+/** "1,23,456.79": the configured grouping, up to three decimals by default. */
+export declare function formatNumber(value: number | string | null | undefined, options?: FormatNumberOptions): string;
+/** Intl output for `locale` (default `'en-IN'`), with exactly `fractionDigits` decimals when given. */
+export declare function formatNumber(value: number | null | undefined, fractionDigits: number | undefined, locale?: string): string;
+/** "42%" from 0.42 (or from 42 with `scale: 'percent'`), whole percent by default. */
+export declare function formatPercent(value: number | string | null | undefined, options?: FormatPercentOptions): string;
 /**
- * Format a 0–1 ratio (or 0–100 percent) as a percent string.
- * Pass `asRatio: false` if your input is already on the 0–100 scale.
+ * Intl percent output. Pass `asRatio: false` if the input is already on the
+ * 0–100 scale.
  */
-export declare const formatPercent: (value: number | null | undefined, fractionDigits?: number, asRatio?: boolean, locale?: string) => string;
+export declare function formatPercent(value: number | null | undefined, fractionDigits: number | undefined, asRatio?: boolean, locale?: string): string;
 /**
  * Format a number compactly (1.2K, 3.4M, 1.5L, 2.3Cr).
  * Defaults to Indian compact notation via `'en-IN'` locale (lakh / crore).

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

@@ -11,7 +11,14 @@
  *   @webority/mobile-core/sqlite       expo-sqlite
  *   @webority/mobile-core/download     a filesystem module
  *   @webority/mobile-core/share        expo-sharing
+ *   @webority/mobile-core/secureScreen expo-screen-capture
  *   @webority/mobile-core/smsRetriever Android only, own TurboModule
+ *   @webority/mobile-core/query        RTK Query base query and createApi preset
+ *                                      (@reduxjs/toolkit and react-redux)
+ *
+ * `@webority/mobile-core/redux` (errorToastMiddleware, createRootReducer, resetState,
+ * SERIALIZABLE_IGNORED_ACTION_PATHS) is separate too: it needs @reduxjs/toolkit, an optional
+ * peer.
  *
  * One more path is separate for size, not for a native package:
  *
@@ -21,36 +28,47 @@
  * client reads the bearer token. It needs no optional peer: the backend is
  * expo-secure-store, and `expo` is required anyway.
  */
+export type { AccountIdProvider, ClientKind } from './api/clientHeaders.js';
+export { ACCOUNT_ID_HEADER, CLIENT_BUILD_HEADER, CLIENT_KIND, CLIENT_KIND_HEADER, getClientBuild } from './api/clientHeaders.js';
 export { buildCurl, logCurl } from './api/curl.js';
+export type { MinAppVersionListener } from './api/minAppVersion.js';
+export { addMinAppVersionListener, getMinAppVersion, MIN_APP_VERSION_HEADER } from './api/minAppVersion.js';
 export { default as publicClient } from './api/publicClient.js';
+export { applyRequestDefaults, newCorrelationId } from './api/requestDefaults.js';
 export type { RetryPolicy } from './api/retry.js';
-export { attachRetry, isRetryableStatus } from './api/retry.js';
+export { attachRetry, IDEMPOTENCY_KEY_HEADER, isNeverSentError, isRetryableFailure, isRetryableStatus, retryAfterMs } from './api/retry.js';
 export { refreshAccessToken } from './api/tokenRefresh.js';
 export type { RefreshableStore, SessionTerminationCode } from './api/userClient.js';
-export { default as userClient, injectStore, injectUserAuth, RequestOfflineError, resetRefreshState, SESSION_TERMINATION_CODES } from './api/userClient.js';
-export type { KeychainLike, SecureCredentials, StoredToken } from './auth/authStore.js';
-export { ACCESS_TOKEN_KEY, getToken, REFRESH_TOKEN_KEY, removeToken, setKeychainImplementation, storeToken } from './auth/authStore.js';
+export { default as userClient, injectStore, injectUserAuth, RequestOfflineError, resetRefreshState, SESSION_TERMINATION_CODES, SIGN_OUT_REASON_HEADER } from './api/userClient.js';
+export type { KeychainLike, LegacyTokenKeys, SecureCredentials, SessionEndDetail, SessionEndedListener, SessionEndReason, StoredToken } from './auth/authStore.js';
+export { ACCESS_TOKEN_KEY, addSessionEndedListener, clearSession, getSessionUser, getToken, LEGACY_REFRESH_TOKEN_LIFETIME_MS, REFRESH_TOKEN_KEY, removeSessionUser, removeToken, SESSION_USER_KEY, setKeychainImplementation, setLegacyTokenKeys, storeSessionUser, storeToken } from './auth/authStore.js';
 export type { JwtClaims } from './auth/jwt.js';
 export { decodeJWT, getJWTExpiry, isJWTExpired } from './auth/jwt.js';
 export type { Config, Environment, LogLevel } from './config/index.js';
 export { getConfig, getConfigValue, resetConfig, setConfig } from './config/index.js';
 export type { DeepLinkConfig, DeepLinkRoute, ParsedLink } from './deepLink/index.js';
 export { DeepLink, parseDeepLink, useDeepLink } from './deepLink/index.js';
-export type { DateInput, DateStyle, FormatCurrencyOptions, FormatPhoneOptions, PhoneCountry, PhoneCountryEntry, PhoneNumber, PhoneNumberType, PhoneParts, PhoneValidationKind, TimeStyle } from './formatters/index.js';
-export { AsYouType, addDays, clampNationalNumber, countryFlagEmoji, detectPhoneCountry, diffMs, formatCompactNumber, formatCurrency, formatDate, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatDateTime, formatNumber, formatPercent, formatPhone, formatPhoneAsTyped, formatRelativeTime, formatTime, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, getCountries, getCountryCallingCode, getInitials, getPhoneCountries, isDateAfter, isDateBefore, isSameDay, isSupportedCountry, isValidNationalNumber, isValidPhoneNumber, maxNationalNumberLength, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString, splitPhoneNumber, startOfDay, validatePhoneNumberLength } from './formatters/index.js';
+export type { ApiError } from './errors/index.js';
+export { apiErrorMessage, CONTRACT_ERROR_CODE, extractApiError, isApiError, isNoResponse, NETWORK_CODE, OFFLINE_MESSAGE, REQUEST_CANCELED_CODE, SERVER_FAILURE_MESSAGE, TIMEOUT_CODE, TIMEOUT_MESSAGE, toFieldPath, UNEXPECTED_MESSAGE } from './errors/index.js';
+export type { DateInput, DateStyle, DateValue, FormatCurrencyOptions, FormatDateOptions, FormatDateTimeOptions, FormatMinorOptions, FormatNumberOptions, FormatPercentOptions, FormatPhoneOptions, FormatRelativeOptions, FormatTimeOptions, FormatterConfig, NumberGrouping, PhoneCountry, PhoneCountryEntry, PhoneNumber, PhoneNumberType, PhoneParts, PhoneValidationKind, TimeStyle, ZoneMode, ZoneOption } from './formatters/index.js';
+export { AsYouType, addDays, clampNationalNumber, configureFormatters, countryFlagEmoji, detectPhoneCountry, diffMs, formatCompactNumber, formatCurrency, formatDate, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatDateTime, formatMinor, formatNumber, formatPercent, formatPhone, formatPhoneAsTyped, formatRelative, formatRelativeTime, formatTime, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, getCountries, getCountryCallingCode, getFormatterConfig, getInitials, getPhoneCountries, isDateAfter, isDateBefore, isSameDay, isSupportedCountry, isValidNationalNumber, isValidPhoneNumber, maxNationalNumberLength, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString, splitPhoneNumber, startOfDay, validatePhoneNumberLength } from './formatters/index.js';
 export type { InitConfig } from './initSDK.js';
 export { initWebority } from './initSDK.js';
 export type { TokenRefreshConfig, TokenRefreshResult, UserAuthOptions } from './initUserAuth.js';
 export { initUserAuth } from './initUserAuth.js';
-export type { DeviceContext, LoggerOptions, LoggerType, RemoteLogger } from './logger/index.js';
+export type { DeviceContext, LoggerOptions, LoggerType, RemoteLogger, RequestFailedContext } from './logger/index.js';
 export { configureLogger, getDeviceContext, Logger, setDeviceContext, setRemoteLogger } from './logger/index.js';
+export type { CrashlyticsModule } from './logger/crashlytics.js';
+export { crashlyticsRemoteLogger } from './logger/crashlytics.js';
 export type { NetworkConnectionType, NetworkStatus, NetworkStatusLike, NetworkStatusListener } from './network/index.js';
 export { addNetworkStatusListener, getNetworkStatus, setNetworkStatusImplementation, useNetworkStatus } from './network/index.js';
+export type { PushStatus } from './push/status.js';
+export { PUSH_STATUS } from './push/status.js';
 export type { AsyncStorageLike, StorageApi } from './storage/index.js';
 export { isStorageAvailable, Storage, setStorageImplementation } from './storage/index.js';
 export { encodeBase64 } from './utils/base64.js';
 export type { PasswordRules } from './validators/index.js';
 export { isAadhaar, isAlphanumeric, isBetween, isEmail, isGstin, isHexColor, isIfsc, isIndianMobile, isIndianPincode, isInteger, isNonEmpty, isNumeric, isPan, isPhone, isStrongPassword, isUrl, maxLength, minLength } from './validators/index.js';
 export type { DeviceInfoLike, ParsedVersion, Platform, UpdateInfo, UpdateType, VersionCheckResult, VersionCheckType, VersionComparison, VersionData } from './versionCheck/index.js';
-export { setDeviceInfoImplementation, useVersionCheck, VersionCheck } from './versionCheck/index.js';
+export { isBuildBelowMinimum, parseBuildNumber, setDeviceInfoImplementation, useVersionCheck, VersionCheck } from './versionCheck/index.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -16,23 +16,35 @@ export interface InitConfig {
     /** Environment. Defaults to `'Development'`. */
     environment?: Environment;
     /**
-     * ISO 3166-1 alpha-2 country code (lowercase) used for App Store / Play Store
-     * version checks. Defaults to `'in'`.
+     * ISO 3166-1 alpha-2 country code (lowercase) used in the App Store / Play
+     * Store link of the update prompt. Defaults to `'in'`.
      */
     country?: string;
     /**
-     * The app's store identifier (Android package name / iOS bundle id) and its
-     * user-visible version, both needed by the version-check module. Every
-     * Webority app already has them in `appsettings.Compiled.json`, which is why
-     * they come from config rather than across the native bridge.
+     * The app's store identifier (Android package name / iOS bundle id), its
+     * user-visible version and its internal build number (`VERSION_INTERNAL`).
+     * Every Webority app already has them in `appsettings.Compiled.json`, which
+     * is why they come from config rather than across the native bridge. The
+     * version check compares `appBuild` with the API's `X-Min-App-Version`.
      */
     appId?: string;
     appVersion?: string;
+    appBuild?: number;
+    /** The numeric Apple App Store id; the iOS update button needs it. */
+    appStoreId?: string;
+    /** The build's short git sha (`COMMIT` in appsettings); sent as `X-Client-Build: <appVersion>+<commit>`. */
+    commit?: string;
     /**
      * Log a redacted curl line per request. Off by default; it is a debugging
      * aid, not something to leave on.
      */
     logCurl?: boolean;
+    /** Request timeout in milliseconds. Defaults to 30000; a request's own `timeout` wins. */
+    timeoutMs?: number;
+    /** Retries under the retry rule. Defaults to 3; 0 turns retrying off. */
+    retries?: number;
+    /** Header for the per-request correlation id. Defaults to `'X-Correlation-Id'`; `null` sends none. */
+    correlationIdHeader?: string | null;
     /**
      * The native modules that fill the seams the library does not import.
      *

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

@@ -1,3 +1,5 @@
+import type { AccountIdProvider } from './api/clientHeaders.js';
+import { type LegacyTokenKeys } from './auth/authStore.js';
 /** The tokens a refresh response carries, with their expiry timestamps. */
 export interface TokenRefreshResult {
     accessToken: string;
@@ -17,6 +19,12 @@ export interface TokenRefreshConfig {
         accessToken: string | null;
         refreshToken: string;
     }) => unknown;
+    /**
+     * Extra headers for the refresh call, read on every refresh; may return a promise. For a
+     * value the API must see as a header, such as `X-Installation-Id` for a rate limiter that
+     * cannot read the body.
+     */
+    headers?: () => Record<string, string> | Promise<Record<string, string>>;
     /**
      * Reads the new tokens from the response body. Defaults to the Webority API's
      * `{ accessToken, accessTokenExpiration, refreshToken, refreshTokenExpiration }`.
@@ -27,12 +35,33 @@ export interface UserAuthOptions {
     /** Action creator dispatched when the session is over. */
     logout: () => unknown;
     refresh: TokenRefreshConfig;
+    /**
+     * The account the signed-in user is working in, sent as `X-Account-Id` on
+     * every userClient request. Read on every send, so a switch applies at once.
+     * Omit it in a product whose API takes the account from the token alone.
+     */
+    accountId?: AccountIdProvider;
+    /**
+     * The response header in which the API names why it ended a session. A 401 carrying it is a
+     * revoked session: no refresh is tried, the session is cleared as `terminated`, and the
+     * value reaches every `addSessionEndedListener` listener as `detail.signOutReason`. It is
+     * read from a refused refresh too. Default `'X-Sign-Out-Reason'`; `null` turns it off.
+     */
+    signOutReasonHeader?: string | null;
+    /**
+     * The secure-store keys the app kept its session under before this library. The first token
+     * read that finds the library's keys empty moves a session found there and deletes the old
+     * keys, so the release that adopts the library signs nobody out.
+     */
+    legacyKeys?: LegacyTokenKeys;
 }
 /**
  * Wire the user client to the app: the Redux store it dispatches `logout` to,
  * and the refresh endpoint it calls when an access token expires or a request
  * answers 401. Only a 400 or 401 from that endpoint, or a missing or expired
  * refresh token, logs out; a network error, timeout or 5xx keeps the session.
+ * Logging out clears the session first (`clearSession('rejected' | 'terminated')`),
+ * so the tokens are gone and the session-ended listeners hear it, then dispatches `logout`.
  *
  * @example
  * initUserAuth(store, { logout, refresh: { path: '/Account/RefreshToken' } });

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

@@ -0,0 +1,31 @@
+import type { RemoteLogger } from './index.js';
+/**
+ * The part of `@react-native-firebase/crashlytics`'s modular API the adapter
+ * calls. Typed here, never imported, so the library carries no Firebase
+ * dependency: the app passes the module it already installs.
+ */
+export interface CrashlyticsModule<Instance = unknown> {
+    getCrashlytics: () => Instance;
+    log: (crashlytics: Instance, message: string) => void;
+    recordError: (crashlytics: Instance, error: Error, jsErrorName?: string) => void;
+    setUserId: (crashlytics: Instance, userId: string) => Promise<unknown>;
+    setAttribute: (crashlytics: Instance, name: string, value: string) => Promise<unknown>;
+}
+/**
+ * Builds the `setRemoteLogger` adapter for Firebase Crashlytics:
+ *
+ * ```ts
+ * import * as crashlytics from '@react-native-firebase/crashlytics';
+ * import { crashlyticsRemoteLogger, setRemoteLogger } from '@webority/mobile-core';
+ *
+ * setRemoteLogger(crashlyticsRemoteLogger(crashlytics));
+ * ```
+ *
+ * Breadcrumbs and log lines become Crashlytics log lines, errors become
+ * non-fatals with their context logged just before, and the user id and
+ * attributes are set as given. Every call swallows its own failure, sync or
+ * async: the adapter runs inside `Logger.error`, so a throw would recurse, and
+ * a build without its Firebase config files has no Firebase app to report to.
+ */
+export declare const crashlyticsRemoteLogger: <Instance>(crashlytics: CrashlyticsModule<Instance>) => RemoteLogger;
+//# sourceMappingURL=crashlytics.d.ts.map