@gusnips/native 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gustavo Salomé
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,311 @@
-# Temporary Holding Version
+# @gusnips/native
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+What a bare React Native app needs beside `@gusnips/react`: the Metro config for a bun monorepo,
+the Tailwind build for react-native-css, streams from your API, React Query that knows when the app
+is in the background, and a theme and a language that remember what the person picked. No Expo.
+
+```bash
+bun add @gusnips/native
+```
+
+```js
+// metro.config.js
+const { getDefaultConfig } = require("@react-native/metro-config");
+const { nativeMetroConfig } = require("@gusnips/native/metro");
+
+module.exports = nativeMetroConfig(getDefaultConfig(__dirname));
+```
+
+That one line makes every `react` import in the bundle the app's own copy, and maps
+react-native-css's override module so styled components load. Both are crashes you would otherwise
+meet at launch.
+
+## What is in it
+
+| Import                     | What it does                                                   | Also needs                                            |
+| -------------------------- | -------------------------------------------------------------- | ----------------------------------------------------- |
+| `@gusnips/native`          | `openSseStream`: server-sent events over XHR                   | nothing more                                          |
+| `@gusnips/native/theme`    | `createNativeTheme`: light, dark or system, remembered         | `@react-native-async-storage/async-storage`           |
+| `@gusnips/native/network`  | `useIsOffline`, `isDeviceOffline`                              | `@react-native-community/netinfo`                     |
+| `@gusnips/native/query`    | `installQueryManagers`: React Query on app focus and network   | `@tanstack/react-query`, netinfo                      |
+| `@gusnips/native/i18n`     | `createNativeLanguage`: the phone's language, or the saved one | `react-native-localize`, async-storage, `i18next`     |
+| `@gusnips/native/supabase` | `supabaseAuthStorage`: where supabase-js keeps the session     | async-storage, `@supabase/supabase-js`                |
+| `@gusnips/native/metro`    | `nativeMetroConfig`, for `metro.config.js`                     | nothing more                                          |
+| `@gusnips/native/css`      | `buildNativeCss` and the `gusnips-native-css` command          | `@tailwindcss/cli`, `tailwindcss`, `react-native-css` |
+
+Every app needs `react`, `react-native`, `@gusnips/react` and `@gusnips/http`. The rest are
+optional: you install one only when you import the line that uses it. Most of them carry native
+code that has to be linked into the app, so an app that does not use NetInfo should not have to
+ship it.
+
+## Metro
+
+In a monorepo, tell it where the root is:
+
+```js
+module.exports = nativeMetroConfig(getDefaultConfig(__dirname), {
+  monorepoRoot: require("node:path").resolve(__dirname, "../.."),
+});
+```
+
+What it adds to the config:
+
+- **The monorepo.** `watchFolders` and `nodeModulesPaths` point at the root, so a workspace package
+  that ships TypeScript source resolves like any other. Metro does not find workspaces on its own.
+- **One React.** bun's isolated store keeps a spare `react` at its root. A package that forgets to
+  declare react as a peer finds that one instead, and the bundle has two: your screens render, and
+  that package's hooks crash with "Cannot read property 'useMemo' of null". Every `react` and
+  `react/*` import now goes to the copy your app resolves. `react-native` and `react-dom` are left
+  alone.
+- **react-native-css's override module.** `react-native-css/native` imports a module that throws
+  unless Metro maps it to the package's empty `override.js`. Without the mapping every styled
+  component fails with "Cannot read property 'useCssElement' of undefined". Skipped when the app
+  does not use react-native-css.
+
+A resolver already on the config still runs for everything else.
+
+**`metro.config.js` stays CommonJS, as the React Native template writes it.** This package is ES
+modules only, and `require()` of an ES module works without a flag on every Node version React
+Native 0.86 supports: 20.19.4 and later, 22.13 and later, 24.3 and later. Measured by loading the
+config through Metro's own `loadConfig` on Node 22.22 and 24.21.
+
+Never add `withReactNativeCSS` or NativeWind's `withNativewind` on top. Both also replace Metro's
+transformer with one that requires `@expo/metro-config`, and Metro crashes on a bare app. The CSS
+is built ahead of time instead, below.
+
+## Styles: Tailwind on React Native
+
+NativeWind v5 and react-native-css read `className` at runtime against a compiled stylesheet.
+`gusnips-native-css` builds that stylesheet from your `global.css`, with the Tailwind v4 CLI and
+then react-native-css's compiler:
+
+```bash
+gusnips-native-css   # global.css → src/generated/stylesheet.ts
+```
+
+Run it before Metro, in the same script, or a class you just added resolves to nothing:
+
+```json
+{
+  "scripts": {
+    "start": "gusnips-native-css && react-native start",
+    "ios": "gusnips-native-css && react-native run-ios",
+    "android": "gusnips-native-css && react-native run-android"
+  }
+}
+```
+
+Then load the stylesheet once, at the top of `App.tsx`:
+
+```ts
+import { StyleCollection } from "react-native-css/native-internal";
+import { stylesheet } from "./generated/stylesheet";
+
+StyleCollection.inject(stylesheet);
+```
+
+Never import `global.css` from `index.js`: NativeWind warns that it breaks Fast Refresh, and the
+compiled file is what the app reads. Add `src/generated/` to `.gitignore`.
+
+The tools come from your app, not from this package, because the stylesheet must match the
+react-native-css your bundle runs:
+
+```bash
+bun add react-native-css && bun add -d @tailwindcss/cli tailwindcss
+```
+
+Five things worth knowing:
+
+- **One `rem` is 16 pixels, as on the web.** react-native-css's own default is 14, React Native's
+  root font size, which shrinks every rem-based size by an eighth: `h-12` comes out 42 px instead
+  of 48. `--rem` changes it if you really want another value.
+- **Tailwind finds your classes by itself** in the app's folder. Tailwind v4 has no `--content`
+  flag. For a file outside the folder, add an `@source` line to `global.css`.
+- **Pin lightningcss to 1.30.1, or use a version after 1.30.2.** 1.30.2 breaks react-native-css's
+  compiler, and react-native-css's own check for it is swallowed by an empty `catch`. The build
+  refuses 1.30.2 instead. Pin it with `"overrides": { "lightningcss": "1.30.1" }` in the root
+  `package.json`: a devDependency is not enough, because react-native-css loads the copy under
+  `@expo/metro-config` first.
+- **A `className` change hot-reloads.** Only a change to `global.css` or your tokens needs the
+  build to run again.
+- **There is no global font.** react-native-css drops element and `*` selectors, so a text without
+  a `font-*` class renders in the system font.
+
+### Colours for code
+
+An icon's `color`, the navigation theme and the status bar take a hex string, not a class. Name
+the colours in a JSON file, each as a class per scheme:
+
+```json
+{
+  "text": { "light": "text-ink", "dark": "dark:text-ink-dark" },
+  "canvas": { "light": "bg-surface", "dark": "dark:bg-surface-dark" }
+}
+```
+
+`gusnips-native-css --palette palette.json` writes `colors.ts` beside the stylesheet, with the hex
+each class compiles to. The colours come from the stylesheet itself, so a change of tokens moves the
+icons with the text. Tailwind writes only classes it finds in your files, so keep each palette
+class in your source; the build stops and names any it cannot find.
+
+From a script, the same build is `buildNativeCss({ palette })` from `@gusnips/native/css`.
+
+## Streams
+
+React Native's `fetch` cannot read a response as it arrives, so `readSseStream` from
+`@gusnips/react` has nothing to read. `openSseStream` uses `XMLHttpRequest`, which can, and the
+same frame parser:
+
+```ts
+import { openSseStream } from "@gusnips/native";
+
+const stream = openSseStream({
+  url: `${API_URL}/chat/stream`,
+  body: { message },
+  session, // the SessionAdapter your createApiClient uses
+  onFrame: ({ event, data }) => handle(event, JSON.parse(data)),
+  onError: showError,
+});
+
+stream.abort(); // when the screen closes
+```
+
+- A refused stream fails with the same `ApiError` your API client throws, with the code, the
+  request id and the `Retry-After` wait. So a 402 on a stream gets the same sentence and button as
+  any other 402. A lost connection is a plain `Error`, which the describer reads as "never
+  landed".
+- It sends the session's token, and on a 401 it calls the session's `refresh()` once and opens
+  again. Pass the same adapter your API client uses: its refresh runs once for everyone, so a
+  stream and a page load do not refresh at the same time (the auth server rotates the refresh
+  token, and the loser of that race signs the person out). No token back, and the stream fails
+  with the 401; ending the session stays the API client's job. `headers` adds anything else, like
+  the client's own option.
+- `data` is raw text. Parse it the way your server writes it.
+- No reconnect. Reopen the stream from where your screen knows how to recover.
+- The whole response stays in memory until the stream ends. Fine for a chat answer; not for a feed
+  left open all day.
+
+## React Query
+
+```ts
+import { queryDefaults } from "@gusnips/react";
+import { installQueryManagers } from "@gusnips/native/query";
+
+installQueryManagers();
+export const queryClient = new QueryClient({ defaultOptions: queryDefaults() });
+```
+
+React Query's own defaults watch the browser's window and `navigator.onLine`, which a phone does
+not have. After this, retries wait while the app is in the background or offline, and stale
+queries run again when the connection returns.
+
+It does **not** refetch when the app comes back to the foreground: `queryDefaults` leaves
+`refetchOnWindowFocus` off. For an app people leave open for days, you probably want it on:
+`queryDefaults({ refetchOnWindowFocus: true })`.
+
+## Offline
+
+```ts
+import { useIsOffline } from "@gusnips/native/network";
+
+const offline = useIsOffline(); // true while the phone has no connection
+```
+
+`isDeviceOffline()` answers the same question once. React Native's `fetch` fails the same way
+whether the server is down or the phone has no signal, so ask it before you tell someone the
+service is having trouble. While NetInfo is still working it out, both say "online", so no
+offline banner flashes at launch.
+
+## Theme
+
+The same options and the same `useTheme` as `@gusnips/react/theme`, applied with
+`Appearance.setColorScheme`, which is what `useColorScheme()` and the `dark:` classes read:
+
+```ts
+import { createNativeTheme } from "@gusnips/native/theme";
+
+export const theme = createNativeTheme({ key: "app:theme" });
+
+// In the root component:
+useEffect(() => theme.start(), []);
+
+// Anywhere:
+const { mode, resolved, setMode } = theme.useTheme();
+```
+
+`start()` loads the saved choice and puts it back each time the app returns to the foreground,
+because Android drops the choice when it recreates the screen. A choice made while the saved one is
+still loading wins over it.
+
+## Language
+
+```ts
+import i18n from "i18next";
+import { initReactI18next } from "react-i18next";
+import { createNativeLanguage } from "@gusnips/native/i18n";
+
+export const language = createNativeLanguage(i18n, {
+  supported: ["pt-BR", "en"],
+  storageKey: "app:language",
+});
+
+i18n.use(language.detector).use(initReactI18next).init({ resources, fallbackLng: "pt-BR" });
+```
+
+At launch, call `language.restore()`. From your language picker, call `language.choose("en")`, or
+`language.choose(null)` to follow the phone again.
+
+- The first render is already in the phone's language. The saved choice is read after, and wins.
+- The phone's languages are read in its order: on `pt-PT, en-US` the app picks `pt-BR`, and on
+  `fr-FR, en-US` it picks `en` instead of the fallback.
+- Only `choose` saves a language. i18next hands every language change to the detector, including
+  the one it detects at launch, so a detector that saved there would treat the phone's language as
+  the person's choice, and the app would ignore the phone from then on.
+
+## Supabase
+
+```ts
+import { supabaseAuthStorage } from "@gusnips/native/supabase";
+
+export const authStorage = supabaseAuthStorage(SUPABASE_URL);
+export const supabase = createClient(SUPABASE_URL, SUPABASE_KEY, {
+  auth: { ...authStorage, detectSessionInUrl: false, flowType: "pkce" },
+});
+
+await signOutEvenOffline(supabase.auth, authStorage); // from @gusnips/react/supabase
+```
+
+The session goes in AsyncStorage, not the keychain: a session is two tokens and the user's data in
+one value, and it often passes the about 2 KB a keystore holds per value. The key is the one
+supabase-js picks itself, so moving onto this signs nobody out. Pass the same object to
+`signOutEvenOffline`, so the sign-out clears the key the client reads.
+
+Use `flowType: "pkce"`. A sign-in returns through your app's URL scheme, which any app can claim,
+and under the default flow that URL carries the refresh token.
+
+## Also worth knowing
+
+- **Do not use `react-native-css/components/react-native-safe-area-context`.** In 3.0.7 everything
+  under it loses its `className` styles. Use `SafeAreaView` from `react-native-safe-area-context`
+  with `style={{ flex: 1 }}`, and put the colours on a styled `View` inside it.
+- **`nativewind/babel` is a preset, not a plugin.** Put it in `presets` in `babel.config.js`.
+- **Keep React at one version in the whole repo**, with the root `workspaces.catalog`. The Metro
+  resolver protects the bundle from bun's store layout; the catalog stops the versions drifting in
+  the first place.
+
+## Why the dependencies are peers
+
+There are no `dependencies`. Each package here is one your app already has, or one that carries
+native code, and an app must have exactly one copy of each:
+
+- `react`, `react-native`: two copies of either breaks the app.
+- `@gusnips/react` is a peer, not a dependency, on purpose. `@gusnips/vite` depends on it, so its
+  release pins one exact version, and an app on another version gets a second copy nested inside
+  vite. A peer uses yours. Its range is `>=0.10.0 <1`, so a new minor of `@gusnips/react` does not
+  need a release of this package.
+- `@gusnips/http`: `openSseStream` reads the error envelope and `Retry-After` with it, the same
+  functions the API client uses. Same reasoning, same kind of range.
+- AsyncStorage, NetInfo and react-native-localize hold native code that autolinking compiles into
+  the app, so each is optional and behind its own import.
+- `tailwindcss`, `@tailwindcss/cli` and `react-native-css` are read from your app's folder at build
+  time, so the stylesheet matches what your bundle runs.

package/dist/device-locale.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The language we ship that the phone's list asks for first, or `null` when none of them is one.
+ *
+ * Walk the phone's list in ITS order, and for each tag take an exact match (any case), then a
+ * language with the same base subtag. So a phone set to `["pt-PT", "en-US"]` gets our `pt-BR`: the
+ * person put Portuguese first. The donor looked at the first tag only, so a phone on
+ * `["fr-FR", "en-US"]` got the fallback instead of the English the person also reads.
+ *
+ * This is `matchLocale` from `@gusnips/locale`, written again because that package is a leaf
+ * nothing in this repo depends on (AGENTS.md says why). `@gusnips/react`'s `i18nInitOptions` keeps
+ * a third copy. The test holds this one to the same table, so a reader lands on one language
+ * whichever road they come in by.
+ */
+export declare function pickDeviceLocale(deviceTags: readonly string[], supported: readonly string[]): string | null;
+//# sourceMappingURL=device-locale.d.ts.map

package/dist/device-locale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-locale.d.ts","sourceRoot":"","sources":["../src/device-locale.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,MAAM,GAAG,IAAI,CAWf"}

package/dist/device-locale.js

@@ -0,0 +1,27 @@
+/**
+ * The language we ship that the phone's list asks for first, or `null` when none of them is one.
+ *
+ * Walk the phone's list in ITS order, and for each tag take an exact match (any case), then a
+ * language with the same base subtag. So a phone set to `["pt-PT", "en-US"]` gets our `pt-BR`: the
+ * person put Portuguese first. The donor looked at the first tag only, so a phone on
+ * `["fr-FR", "en-US"]` got the fallback instead of the English the person also reads.
+ *
+ * This is `matchLocale` from `@gusnips/locale`, written again because that package is a leaf
+ * nothing in this repo depends on (AGENTS.md says why). `@gusnips/react`'s `i18nInitOptions` keeps
+ * a third copy. The test holds this one to the same table, so a reader lands on one language
+ * whichever road they come in by.
+ */
+export function pickDeviceLocale(deviceTags, supported) {
+    for (const tag of deviceTags) {
+        const lower = tag.trim().toLowerCase();
+        if (lower === "")
+            continue;
+        const base = lower.split("-")[0];
+        const found = supported.find((lng) => lng.toLowerCase() === lower) ??
+            supported.find((lng) => lng.split("-")[0]?.toLowerCase() === base);
+        if (found !== undefined)
+            return found;
+    }
+    return null;
+}
+//# sourceMappingURL=device-locale.js.map

package/dist/device-locale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-locale.js","sourceRoot":"","sources":["../src/device-locale.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAC9B,UAA6B,EAC7B,SAA4B;IAE5B,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;QAC7B,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QACvC,IAAI,KAAK,KAAK,EAAE;YAAE,SAAS;QAC3B,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACjC,MAAM,KAAK,GACT,SAAS,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC;YACpD,SAAS,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,IAAI,CAAC,CAAC;QACrE,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC;IACxC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/i18n.d.ts

@@ -0,0 +1,34 @@
+import type { i18n as I18n, LanguageDetectorModule } from "i18next";
+export interface NativeLanguageOptions {
+    /** Every language this app ships, as the exact tags its catalogs use. */
+    supported: readonly string[];
+    /** The AsyncStorage key holding the person's choice. Keep the key your app already uses. */
+    storageKey: string;
+}
+export interface NativeLanguage {
+    /** Hand to `i18n.use()` before `init`. */
+    detector: LanguageDetectorModule;
+    /** Apply the saved choice, if there is one. Call once at launch, after `init`. */
+    restore(): Promise<void>;
+    /**
+     * The person picked a language: switch to it and remember it. `null` means "follow the phone":
+     * forget the choice and switch to what the phone asks for.
+     */
+    choose(language: string | null): Promise<void>;
+}
+/**
+ * ```ts
+ * import i18n from "i18next";
+ *
+ * export const language = createNativeLanguage(i18n, {
+ *   supported: ["pt-BR", "en"],
+ *   storageKey: "app:language",
+ * });
+ * i18n.use(language.detector).use(initReactI18next).init({ resources, fallbackLng: "pt-BR" });
+ * ```
+ *
+ * A phone whose languages are none of `supported` gets `fallbackLng`: the detector answers nothing
+ * and i18next falls back on its own.
+ */
+export declare function createNativeLanguage(i18n: I18n, options: NativeLanguageOptions): NativeLanguage;
+//# sourceMappingURL=i18n.d.ts.map

package/dist/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../src/i18n.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,IAAI,IAAI,IAAI,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAIpE,MAAM,WAAW,qBAAqB;IACpC,yEAAyE;IACzE,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,4FAA4F;IAC5F,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,0CAA0C;IAC1C,QAAQ,EAAE,sBAAsB,CAAC;IACjC,kFAAkF;IAClF,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB;;;OAGG;IACH,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,qBAAqB,GAAG,cAAc,CAqC/F"}

package/dist/i18n.js

@@ -0,0 +1,63 @@
+/**
+ * The app's language on a phone: the one the person picked, else the phone's own, else your
+ * fallback.
+ *
+ * The detector reads the phone's languages with react-native-localize, synchronously, so the first
+ * render is already in a real language. A choice saved earlier is read from AsyncStorage after
+ * that (`restore`), and wins.
+ *
+ * **Only `choose` writes the saved choice.** i18next calls a detector's `cacheUserLanguage` on
+ * EVERY language change, the one it detected at launch included. The donor's detector saved there,
+ * so the first launch saved the phone's language as though the person had picked it, and when they
+ * later switched the phone to another language the app stayed in the old one for good. That is
+ * `storageWriter: "app"` in `@gusnips/react`'s `i18nInitOptions`, the same lesson from the web: one
+ * writer per key, and here the writer is your language control.
+ */
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { getLocales } from "react-native-localize";
+import { pickDeviceLocale } from "./device-locale.js";
+/**
+ * ```ts
+ * import i18n from "i18next";
+ *
+ * export const language = createNativeLanguage(i18n, {
+ *   supported: ["pt-BR", "en"],
+ *   storageKey: "app:language",
+ * });
+ * i18n.use(language.detector).use(initReactI18next).init({ resources, fallbackLng: "pt-BR" });
+ * ```
+ *
+ * A phone whose languages are none of `supported` gets `fallbackLng`: the detector answers nothing
+ * and i18next falls back on its own.
+ */
+export function createNativeLanguage(i18n, options) {
+    const { supported, storageKey } = options;
+    // A choice made while the saved one is still loading wins over it.
+    let chosen = false;
+    const fromDevice = () => pickDeviceLocale(getLocales().map((locale) => locale.languageTag), supported) ?? undefined;
+    const detector = {
+        type: "languageDetector",
+        init: () => { },
+        detect: fromDevice,
+        // Deliberately empty. See the top of this file.
+        cacheUserLanguage: () => { },
+    };
+    async function restore() {
+        const stored = await AsyncStorage.getItem(storageKey).catch(() => null);
+        if (chosen || stored === null || !supported.includes(stored))
+            return;
+        if (i18n.language !== stored)
+            await i18n.changeLanguage(stored);
+    }
+    async function choose(language) {
+        chosen = true;
+        const write = language === null
+            ? AsyncStorage.removeItem(storageKey)
+            : AsyncStorage.setItem(storageKey, language);
+        // Not remembered across launches when storage fails, and still applied for this one.
+        await write.catch(() => { });
+        await i18n.changeLanguage(language ?? fromDevice());
+    }
+    return { detector, restore, choose };
+}
+//# sourceMappingURL=i18n.js.map

package/dist/i18n.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.js","sourceRoot":"","sources":["../src/i18n.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,YAAY,MAAM,2CAA2C,CAAC;AAErE,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAqBtD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAU,EAAE,OAA8B;IAC7E,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;IAC1C,mEAAmE;IACnE,IAAI,MAAM,GAAG,KAAK,CAAC;IAEnB,MAAM,UAAU,GAAG,GAAG,EAAE,CACtB,gBAAgB,CACd,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,EAChD,SAAS,CACV,IAAI,SAAS,CAAC;IAEjB,MAAM,QAAQ,GAA2B;QACvC,IAAI,EAAE,kBAAkB;QACxB,IAAI,EAAE,GAAG,EAAE,GAAE,CAAC;QACd,MAAM,EAAE,UAAU;QAClB,gDAAgD;QAChD,iBAAiB,EAAE,GAAG,EAAE,GAAE,CAAC;KAC5B,CAAC;IAEF,KAAK,UAAU,OAAO;QACpB,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;QACxE,IAAI,MAAM,IAAI,MAAM,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC;YAAE,OAAO;QACrE,IAAI,IAAI,CAAC,QAAQ,KAAK,MAAM;YAAE,MAAM,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAClE,CAAC;IAED,KAAK,UAAU,MAAM,CAAC,QAAuB;QAC3C,MAAM,GAAG,IAAI,CAAC;QACd,MAAM,KAAK,GACT,QAAQ,KAAK,IAAI;YACf,CAAC,CAAC,YAAY,CAAC,UAAU,CAAC,UAAU,CAAC;YACrC,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QACjD,qFAAqF;QACrF,MAAM,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QAC5B,MAAM,IAAI,CAAC,cAAc,CAAC,QAAQ,IAAI,UAAU,EAAE,CAAC,CAAC;IACtD,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;AACvC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { openSseStream, type SseStream, type SseStreamOptions } from "./sse.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,aAAa,EAAE,KAAK,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+// @gusnips/native: what a bare React Native app needs beside @gusnips/react.
+//
+// The rule that picks the subpaths is the kit's invariant 15, checked by `bun run exports`: a peer
+// marked optional must not be reachable from this entry. Every subpath below needs one more package
+// with native code or a build tool in it, and an app installs that package only by importing the
+// thing that uses it:
+//
+//   @gusnips/native/theme     createNativeTheme        → @react-native-async-storage/async-storage
+//   @gusnips/native/network   useIsOffline             → @react-native-community/netinfo
+//   @gusnips/native/query     installQueryManagers     → @tanstack/react-query, netinfo
+//   @gusnips/native/i18n      createNativeLanguage     → react-native-localize, async-storage
+//   @gusnips/native/supabase  supabaseAuthStorage      → async-storage, @supabase/supabase-js
+//   @gusnips/native/metro     nativeMetroConfig        → Node, at bundle time
+//   @gusnips/native/css       buildNativeCss           → Node, tailwindcss, react-native-css
+//
+// What is left here needs only the required peers.
+export { openSseStream } from "./sse.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,EAAE;AACF,mGAAmG;AACnG,oGAAoG;AACpG,iGAAiG;AACjG,sBAAsB;AACtB,EAAE;AACF,mGAAmG;AACnG,yFAAyF;AACzF,wFAAwF;AACxF,8FAA8F;AAC9F,8FAA8F;AAC9F,8EAA8E;AAC9E,6FAA6F;AAC7F,EAAE;AACF,mDAAmD;AAEnD,OAAO,EAAE,aAAa,EAAyC,MAAM,UAAU,CAAC"}

package/dist/network.d.ts

@@ -0,0 +1,18 @@
+/**
+ * True while the phone has no connection.
+ *
+ * React Query already pauses on its own once `installQueryManagers` from `@gusnips/native/query`
+ * is running. This is for a screen that should SAY it is offline instead of showing old data as
+ * if it were current.
+ */
+export declare function useIsOffline(): boolean;
+/**
+ * Was that failure the phone, or the server?
+ *
+ * React Native's `fetch` rejects with the same bare `TypeError` when the server is down and when
+ * the phone has no signal. Ask this before telling somebody the service is having trouble: only a
+ * `false` here means the service is to blame. A NetInfo that cannot answer counts as online, so
+ * the doubt goes to the message that has a retry beside it.
+ */
+export declare function isDeviceOffline(): Promise<boolean>;
+//# sourceMappingURL=network.d.ts.map

package/dist/network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../src/network.ts"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAItC;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC,CAGxD"}

package/dist/network.js

@@ -0,0 +1,35 @@
+/**
+ * Is the phone offline? NetInfo answers, with one rule both helpers here share.
+ *
+ * `isConnected === false` is offline, and nothing else is. NetInfo reports `null` while it has not
+ * worked it out yet, which happens at every launch; reading that as offline puts an offline banner
+ * on screen for the first moment of every session.
+ */
+import NetInfo, {} from "@react-native-community/netinfo";
+import { useEffect, useState } from "react";
+const offline = (state) => state.isConnected === false;
+/**
+ * True while the phone has no connection.
+ *
+ * React Query already pauses on its own once `installQueryManagers` from `@gusnips/native/query`
+ * is running. This is for a screen that should SAY it is offline instead of showing old data as
+ * if it were current.
+ */
+export function useIsOffline() {
+    const [isOffline, setIsOffline] = useState(false);
+    useEffect(() => NetInfo.addEventListener((state) => setIsOffline(offline(state))), []);
+    return isOffline;
+}
+/**
+ * Was that failure the phone, or the server?
+ *
+ * React Native's `fetch` rejects with the same bare `TypeError` when the server is down and when
+ * the phone has no signal. Ask this before telling somebody the service is having trouble: only a
+ * `false` here means the service is to blame. A NetInfo that cannot answer counts as online, so
+ * the doubt goes to the message that has a retry beside it.
+ */
+export async function isDeviceOffline() {
+    const state = await NetInfo.fetch().catch(() => null);
+    return state !== null && offline(state);
+}
+//# sourceMappingURL=network.js.map

package/dist/network.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.js","sourceRoot":"","sources":["../src/network.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,OAAO,EAAE,EAAqB,MAAM,iCAAiC,CAAC;AAC7E,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAE5C,MAAM,OAAO,GAAG,CAAC,KAAmB,EAAE,EAAE,CAAC,KAAK,CAAC,WAAW,KAAK,KAAK,CAAC;AAErE;;;;;;GAMG;AACH,MAAM,UAAU,YAAY;IAC1B,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAClD,SAAS,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACvF,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe;IACnC,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;IACtD,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC;AAC1C,CAAC"}

package/dist/node/bin/gusnips-native-css.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=gusnips-native-css.d.ts.map

package/dist/node/bin/gusnips-native-css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gusnips-native-css.d.ts","sourceRoot":"","sources":["../../../src/node/bin/gusnips-native-css.ts"],"names":[],"mappings":""}