@rnzeus/atlas 0.1.0

package/dist/services/transport/README.md

@@ -0,0 +1,79 @@
+# `@rnzeus/atlas/services/transport`
+
+← [`@rnzeus/atlas/services`](../README.md)
+
+## Purpose
+
+Base `fetch` transport with query params, default headers, response parsing, and normalized errors. Provides `get/post/put/delete` helpers on top of a single request pipeline.
+
+## Import
+
+```ts
+import {Transport} from '@rnzeus/atlas/services';
+```
+
+## API (public surface)
+
+- `class Transport` (abstract)
+  - **required**: `protected get baseURL(): string`
+  - **required**: `protected formatErrorMessage(data: unknown, status: number): string`
+  - **optional**: `protected notify(message: string): void` (default: no-op)
+  - `headers: HeadersInit_` (get/set, merges with defaults)
+  - `get<T>(url, params?, options?)`
+  - `post<T>(url, body, options?)`
+  - `put<T>(url, body, options?)`
+  - `delete<T>(url, params?, options?)`
+- `class TransportErrorException extends Error`
+  - `status: number`
+  - `data: unknown`
+  - `isServerError()`
+  - `isClientError()`
+- `type TransportOptions`
+  - `RequestInit` + `headers?: HeadersInit_` + `responseType?: 'arrayBuffer' | 'json'`
+
+## Usage (minimal)
+
+```ts
+import {Transport} from '@rnzeus/atlas/services';
+
+class ApiTransport extends Transport {
+  protected get baseURL() {
+    return 'https://api.example.com/';
+  }
+
+  protected formatErrorMessage(data: unknown, status: number) {
+    const msg = typeof data === 'object' && data && (data as any).message;
+    return msg ? String(msg) : `HTTP ${status}`;
+  }
+}
+
+const api = new ApiTransport();
+api.headers = {Authorization: 'Bearer token'};
+
+const user = await api.get<User>('/v1/user', {id: '42'});
+```
+
+## Notes
+
+- **Relative vs absolute URLs**: relative paths are resolved against `baseURL`; absolute (`http(s)://`) are used as-is.
+- **Trailing slash**: the final resolved URL has a trailing `/` removed.
+- **Query params**: `params` are serialized with `qs` using `arrayFormat: 'brackets'`.
+- **Headers**: default headers are merged with per-request headers; `Content-Type` is removed automatically for `FormData`.
+- **Response parsing**:
+  - `options.responseType === 'arrayBuffer'` forces `arrayBuffer()`
+  - otherwise parses by `content-type` (`json`, `formData`, `text`), with a JSON→text fallback
+- **Errors**:
+  - non-OK responses throw `TransportErrorException(status, message, data)`
+  - 5xx triggers `notify(message)` before throwing
+  - `AbortError` is rethrown as-is
+  - unknown errors are wrapped into `TransportErrorException(0, message)`
+
+## Sources
+
+- [`service`](./service.js)
+- [`types`](./types.js)
+- [`error-exception`](./error-exception.js)
+- [`create-transport-methods`](./create-transport-methods.js)
+- [`read-response-body`](./read-response-body.js)
+- [`build-query`](./build-query.js)
+- [`index`](./index.js)

package/dist/services/transport/build-query.d.ts

@@ -0,0 +1,2 @@
+declare const buildTransportQuery: (params?: Record<string, unknown> | null) => string;
+export default buildTransportQuery;

package/dist/services/transport/build-query.js

@@ -0,0 +1,3 @@
+import qs from 'qs';
+const buildTransportQuery = (params) => params ? qs.stringify(params, { arrayFormat: 'brackets', encode: true }) : '';
+export default buildTransportQuery;

package/dist/services/transport/create-transport-methods.d.ts

@@ -0,0 +1,8 @@
+import type { TransportOptions } from './types';
+declare const createTransportMethods: (requestFn: <T>(url: string, options: TransportOptions, paramsOrBody?: Record<string, unknown> | null) => Promise<T>) => {
+    get<T>(url: string, params?: Record<string, unknown> | null, options?: TransportOptions): Promise<T>;
+    post<T>(url: string, body: unknown, options?: TransportOptions): Promise<T>;
+    put<T>(url: string, body: unknown, options?: TransportOptions): Promise<T>;
+    delete<T>(url: string, params?: Record<string, unknown> | null, options?: TransportOptions): Promise<T>;
+};
+export default createTransportMethods;

package/dist/services/transport/create-transport-methods.js

@@ -0,0 +1,34 @@
+function isBodyFormData(v) {
+    return typeof FormData !== 'undefined' && v instanceof FormData;
+}
+function buildRequestInitWithBody(options, method, body) {
+    const init = { ...options, method };
+    if (body === undefined || body === null)
+        return init;
+    if (isBodyFormData(body)) {
+        init.body = body;
+    }
+    else {
+        init.body = JSON.stringify(body);
+    }
+    return init;
+}
+const createTransportMethods = (requestFn) => {
+    return {
+        get(url, params = null, options = {}) {
+            return requestFn(url, { ...options, method: 'GET' }, params);
+        },
+        post(url, body, options = {}) {
+            const init = buildRequestInitWithBody(options, 'POST', body);
+            return requestFn(url, init);
+        },
+        put(url, body, options = {}) {
+            const init = buildRequestInitWithBody(options, 'PUT', body);
+            return requestFn(url, init);
+        },
+        delete(url, params = null, options = {}) {
+            return requestFn(url, { ...options, method: 'DELETE' }, params);
+        },
+    };
+};
+export default createTransportMethods;

package/dist/services/transport/error-exception.d.ts

@@ -0,0 +1,8 @@
+declare class TransportErrorException extends Error {
+    readonly status: number;
+    readonly data: unknown;
+    constructor(status: number, message: string, data?: unknown);
+    isServerError(): boolean;
+    isClientError(): boolean;
+}
+export default TransportErrorException;

package/dist/services/transport/error-exception.js

@@ -0,0 +1,16 @@
+class TransportErrorException extends Error {
+    constructor(status, message, data) {
+        super(message);
+        this.name = 'TransportErrorException';
+        this.status = status;
+        this.data = data;
+        Object.setPrototypeOf(this, TransportErrorException.prototype);
+    }
+    isServerError() {
+        return this.status >= 500;
+    }
+    isClientError() {
+        return this.status >= 400 && this.status < 500;
+    }
+}
+export default TransportErrorException;

package/dist/services/transport/index.d.ts

@@ -0,0 +1,3 @@
+export { default as TransportErrorException } from './error-exception';
+export { default as Transport } from './service';
+export type { TransportOptions } from './types';

package/dist/services/transport/index.js

@@ -0,0 +1,2 @@
+export { default as TransportErrorException } from './error-exception';
+export { default as Transport } from './service';

package/dist/services/transport/read-response-body.d.ts

@@ -0,0 +1,3 @@
+import type { TransportOptions } from './types';
+declare const readTransportResponseBody: (response: Response, options?: TransportOptions, contentType?: string) => Promise<unknown>;
+export default readTransportResponseBody;

package/dist/services/transport/read-response-body.js

@@ -0,0 +1,27 @@
+const readTransportResponseBody = async (response, options = {}, contentType) => {
+    try {
+        if (options.responseType === 'arrayBuffer') {
+            return await response.arrayBuffer();
+        }
+        if (contentType?.includes('application/json')) {
+            return await response.json();
+        }
+        if (contentType?.includes('multipart/form-data')) {
+            return await response.formData();
+        }
+        if (contentType?.includes('text/')) {
+            return await response.text();
+        }
+        try {
+            return await response.json();
+        }
+        catch {
+            return await response.text();
+        }
+    }
+    catch (error) {
+        console.error('Error reading response body:', error);
+        return await response.text();
+    }
+};
+export default readTransportResponseBody;

package/dist/services/transport/service.d.ts

@@ -0,0 +1,22 @@
+import type { TransportOptions } from './types';
+export default abstract class Transport {
+    private headersDefault;
+    protected abstract get baseURL(): string;
+    protected abstract formatErrorMessage(data: unknown, status: number): string;
+    protected notify(_message: string): void;
+    get headers(): HeadersInit_;
+    set headers(next: HeadersInit_);
+    protected request<T>(url: string, options?: TransportOptions, params?: Record<string, unknown> | null): Promise<T>;
+    protected transportMethods: {
+        get<T>(url: string, params?: Record<string, unknown> | null, options?: TransportOptions): Promise<T>;
+        post<T>(url: string, body: unknown, options?: TransportOptions): Promise<T>;
+        put<T>(url: string, body: unknown, options?: TransportOptions): Promise<T>;
+        delete<T>(url: string, params?: Record<string, unknown> | null, options?: TransportOptions): Promise<T>;
+    };
+    get: <T>(url: string, params?: Record<string, unknown> | null, options?: TransportOptions) => Promise<T>;
+    post: <T>(url: string, body: unknown, options?: TransportOptions) => Promise<T>;
+    put: <T>(url: string, body: unknown, options?: TransportOptions) => Promise<T>;
+    delete: <T>(url: string, params?: Record<string, unknown> | null, options?: TransportOptions) => Promise<T>;
+    private headersToRecord;
+    private withoutContentType;
+}

package/dist/services/transport/service.js

@@ -0,0 +1,102 @@
+import buildTransportQuery from './build-query';
+import createTransportMethods from './create-transport-methods';
+import TransportErrorException from './error-exception';
+import readTransportResponseBody from './read-response-body';
+export default class Transport {
+    constructor() {
+        this.headersDefault = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        };
+        this.transportMethods = createTransportMethods(this.request.bind(this));
+        this.get = this.transportMethods.get.bind(this.transportMethods);
+        this.post = this.transportMethods.post.bind(this.transportMethods);
+        this.put = this.transportMethods.put.bind(this.transportMethods);
+        this.delete = this.transportMethods.delete.bind(this.transportMethods);
+    }
+    notify(_message) {
+        /* no-op */
+    }
+    get headers() {
+        return this.headersDefault;
+    }
+    set headers(next) {
+        this.headersDefault = {
+            ...this.headersDefault,
+            ...this.headersToRecord(next),
+        };
+    }
+    async request(url, options = {}, params) {
+        const search = buildTransportQuery(params);
+        const urlWithQuery = `${url}${search ? `?${search}` : ''}`;
+        const optionHeaders = this.headersToRecord(options.headers);
+        let mergedHeaders = {
+            ...this.headersDefault,
+            ...optionHeaders,
+        };
+        if (options.body instanceof FormData) {
+            mergedHeaders = this.withoutContentType(mergedHeaders);
+        }
+        const isAbsolute = urlWithQuery.startsWith('http://') || urlWithQuery.startsWith('https://');
+        const base = this.baseURL;
+        let finalUrl = isAbsolute ? urlWithQuery : new URL(urlWithQuery, base).toString();
+        if (finalUrl.endsWith('/'))
+            finalUrl = finalUrl.slice(0, -1);
+        try {
+            const response = await fetch(finalUrl, { ...options, headers: mergedHeaders });
+            const contentType = response.headers.get('content-type') ?? undefined;
+            const responseData = await readTransportResponseBody(response, options, contentType);
+            if (!response.ok) {
+                const message = this.formatErrorMessage(responseData, response.status);
+                const transportErrorException = new TransportErrorException(response.status, message, responseData);
+                if (transportErrorException.isServerError()) {
+                    this.notify(message);
+                }
+                throw transportErrorException;
+            }
+            return responseData;
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                console.warn('⚠️ [Transport] Fetch aborted:', url);
+                throw error;
+            }
+            if (error instanceof TransportErrorException) {
+                throw error;
+            }
+            console.error('❌ [Transport] Fetch error:', error);
+            throw new TransportErrorException(0, error instanceof Error ? error.message : 'Unknown error');
+        }
+    }
+    headersToRecord(input) {
+        if (!input)
+            return {};
+        if (typeof Headers !== 'undefined' && input instanceof Headers) {
+            const out = {};
+            input.forEach((v, k) => (out[k] = v));
+            return out;
+        }
+        if (Array.isArray(input)) {
+            const out = {};
+            for (const pair of input) {
+                if (Array.isArray(pair) && typeof pair[0] === 'string' && typeof pair[1] === 'string') {
+                    out[pair[0]] = pair[1];
+                }
+            }
+            return out;
+        }
+        if (typeof input === 'object') {
+            const out = {};
+            for (const [k, v] of Object.entries(input)) {
+                if (typeof k === 'string' && typeof v === 'string')
+                    out[k] = v;
+            }
+            return out;
+        }
+        return {};
+    }
+    withoutContentType(h) {
+        const { ['Content-Type']: _omit, ...rest } = h;
+        return rest;
+    }
+}

package/dist/services/transport/types.d.ts

@@ -0,0 +1,4 @@
+export type TransportOptions = Omit<RequestInit, 'headers'> & {
+    headers?: HeadersInit_;
+    responseType?: 'arrayBuffer' | 'json';
+};

package/dist/services/transport/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/README.md

@@ -0,0 +1,17 @@
+# `@rnzeus/atlas/ui`
+
+← [`@rnzeus/atlas`](../README.md)
+
+## Documentation
+
+- **[`toast`](./toast/README.md)** — toast notifications: mount `ToastProvider` once near the app root, then call `useToast().show()` from screens or hooks. Provider owns the queue, viewport, and plate animations.
+
+```ts
+import {ToastProvider, useToast} from '@rnzeus/atlas/ui';
+```
+
+- **[`debug-dock`](./debug-dock/README.md)** — a dev-oriented floating strip docked to the right edge with a draggable peek drawer; wrap debug tools or secondary actions and disable in production with `enabled={false}` or conditional render.
+
+```ts
+import {DebugDock} from '@rnzeus/atlas/ui';
+```

package/dist/ui/debug-dock/README.md

@@ -0,0 +1,58 @@
+# `@rnzeus/atlas/ui/debug-dock`
+
+← [`@rnzeus/atlas/ui`](../README.md)
+
+## Purpose
+
+Floating debug UI anchored to the top-right: a slim vertical drawer handle and a horizontal strip for shortcuts or dev-only controls. Uses Reanimated and Gesture Handler for vertical drag (reposition) and tap-to-toggle expand/peek along the X axis.
+
+## Import
+
+```ts
+import {DebugDock} from '@rnzeus/atlas/ui';
+```
+
+## API (public surface)
+
+- `DebugDock` — layout wrapper component.
+- `DebugDockProps`:
+  - `children` — main strip content (laid out in a row).
+  - `enabled` — default `true`; when `false`, the component renders nothing.
+  - `height` — strip height in px (default `60`).
+  - `drawerWidth` — width of the left handle area in px (default `20`).
+  - `drawerPeek` — how many px of the dock stay visible when “closed” on the X axis; defaults to `drawerWidth + 3`.
+  - `drawerContent` — optional node for the handle (default is a chevron `Text`).
+
+## Usage (minimal)
+
+```tsx
+import type {ReactNode} from 'react';
+import {DebugDock} from '@rnzeus/atlas/ui';
+import {Text} from 'react-native';
+
+export function AppWithDebugShell({children}: {children: ReactNode}) {
+  const showDock = __DEV__;
+
+  return (
+    <>
+      {children}
+      <DebugDock enabled={showDock} drawerContent={<Text style={{color: '#fff'}}>⋮</Text>}>
+        <Text style={{color: '#fff'}}>Open menu</Text>
+      </DebugDock>
+    </>
+  );
+}
+```
+
+## Notes
+
+- Positioning is `absolute` at the top; vertical position respects device height and safe-area insets via `useDebugDock` (internal).
+- Depends on `react-native-reanimated`, `react-native-gesture-handler`, and `react-native-safe-area-context` (peer expectations match a typical RN app with gesture + safe area already set up).
+- Intended for **development / internal builds**; avoid shipping `enabled={true}` in production or gate with `__DEV__` / build flags.
+
+## Sources
+
+- [`index`](./index.js)
+- [`debug-dock`](./debug-dock.js)
+- [`use-debug-dock`](./use-debug-dock.js)
+- [`styles`](./styles.js)

package/dist/ui/debug-dock/debug-dock.d.ts

@@ -0,0 +1,13 @@
+import type { JSX, ReactNode } from 'react';
+export type DebugDockProps = {
+    children: ReactNode;
+    enabled?: boolean;
+    height?: number;
+    drawerWidth?: number;
+    drawerPeek?: number;
+    drawerContent?: ReactNode;
+};
+export declare function DebugDock({ children, enabled, height, drawerWidth, drawerPeek, drawerContent, }: DebugDockProps): JSX.Element | null;
+export declare namespace DebugDock {
+    var displayName: string;
+}

package/dist/ui/debug-dock/debug-dock.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { GestureDetector } from 'react-native-gesture-handler';
+import Animated from 'react-native-reanimated';
+import { Text, View } from 'react-native';
+import { displayName } from '../../utils';
+import { styles } from './styles';
+import { useDebugDock } from './use-debug-dock';
+export function DebugDock({ children, enabled = true, height = 60, drawerWidth = 20, drawerPeek, drawerContent, }) {
+    const resolvedDrawerPeek = useMemo(() => drawerPeek ?? drawerWidth + 3, [drawerPeek, drawerWidth]);
+    const { containerAnimatedStyle, panGesture, onContainerLayout } = useDebugDock({
+        height,
+        drawerWidth,
+        drawerPeek: resolvedDrawerPeek,
+    });
+    if (!enabled)
+        return null;
+    return (_jsxs(Animated.View, { onLayout: onContainerLayout, style: [styles.container, { height }, containerAnimatedStyle], children: [_jsx(GestureDetector, { gesture: panGesture, children: _jsx(View, { style: [styles.drawer, { width: drawerWidth }], children: drawerContent ?? _jsx(Text, { style: styles.drawerIcon, children: "\u276E" }) }) }), _jsx(View, { style: styles.content, children: children })] }));
+}
+DebugDock.displayName = displayName('ui', 'debug-dock');

package/dist/ui/debug-dock/index.d.ts

@@ -0,0 +1,2 @@
+export type { DebugDockProps } from './debug-dock';
+export { DebugDock } from './debug-dock';

package/dist/ui/debug-dock/index.js

@@ -0,0 +1 @@
+export { DebugDock } from './debug-dock';

package/dist/ui/debug-dock/styles.d.ts

@@ -0,0 +1,8 @@
+import type { TextStyle, ViewStyle } from 'react-native';
+export type DebugDockStyles = {
+    readonly container: ViewStyle;
+    readonly drawer: ViewStyle;
+    readonly drawerIcon: TextStyle;
+    readonly content: ViewStyle;
+};
+export declare const styles: DebugDockStyles;

package/dist/ui/debug-dock/styles.js

@@ -0,0 +1,25 @@
+import { StyleSheet } from 'react-native';
+export const styles = StyleSheet.create({
+    container: {
+        alignItems: 'center',
+        backgroundColor: '#444444',
+        borderBottomLeftRadius: 10,
+        borderTopLeftRadius: 10,
+        flexDirection: 'row',
+        height: 60,
+        justifyContent: 'center',
+        paddingRight: 20,
+        position: 'absolute',
+        top: 0,
+    },
+    content: { flexDirection: 'row', gap: 20 },
+    drawer: {
+        alignItems: 'center',
+        borderBottomLeftRadius: 10,
+        borderTopLeftRadius: 10,
+        height: '100%',
+        justifyContent: 'center',
+        width: 20,
+    },
+    drawerIcon: { color: 'white', fontSize: 30 },
+});

package/dist/ui/debug-dock/use-debug-dock.d.ts

@@ -0,0 +1,20 @@
+import type { LayoutChangeEvent } from 'react-native';
+export type UseDebugDockOptions = {
+    height: number;
+    drawerWidth: number;
+    drawerPeek: number;
+};
+export declare function useDebugDock({ height, drawerWidth, drawerPeek }: UseDebugDockOptions): {
+    containerAnimatedStyle: {
+        left: number;
+        transform: ({
+            translateY: number;
+            translateX?: undefined;
+        } | {
+            translateX: number;
+            translateY?: undefined;
+        })[];
+    };
+    panGesture: import("react-native-gesture-handler/lib/typescript/handlers/gestures/panGesture").PanGesture;
+    onContainerLayout: (event: LayoutChangeEvent) => void;
+};

package/dist/ui/debug-dock/use-debug-dock.js

@@ -0,0 +1,71 @@
+import { useCallback, useMemo } from 'react';
+import { Gesture } from 'react-native-gesture-handler';
+import { cancelAnimation, interpolate, ReduceMotion, useAnimatedStyle, useSharedValue, withDecay, withTiming, } from 'react-native-reanimated';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+import { useWindowDimensions } from 'react-native';
+export function useDebugDock({ height, drawerWidth, drawerPeek }) {
+    const insets = useSafeAreaInsets();
+    const { height: windowHeight, width: windowWidth } = useWindowDimensions();
+    const containerWidth = useSharedValue(0);
+    const dockLevel = useSharedValue(0);
+    const isDragging = useSharedValue(false);
+    const translateY = useSharedValue(Math.max(insets.top, windowHeight - height - insets.bottom));
+    const clampY = useMemo(() => {
+        const min = insets.top;
+        const max = Math.max(insets.top, windowHeight - height - insets.bottom);
+        return { min, max };
+    }, [height, insets.bottom, insets.top, windowHeight]);
+    const onContainerLayout = useCallback((event) => {
+        const width = event.nativeEvent.layout.width;
+        if (width <= 0)
+            return;
+        containerWidth.value = width;
+        if (dockLevel.value === 0) {
+            dockLevel.value = 1;
+        }
+    }, [containerWidth, dockLevel]);
+    const panGesture = useMemo(() => {
+        return Gesture.Pan()
+            .onTouchesUp(() => {
+            'worklet';
+            if (isDragging.value)
+                return;
+            if (dockLevel.value === 0)
+                return;
+            dockLevel.value = withTiming(dockLevel.value === 1 ? 2 : 1, { duration: 300 });
+        })
+            .onStart(() => {
+            isDragging.value = true;
+            cancelAnimation(translateY);
+        })
+            .onChange((event) => {
+            translateY.value = Math.min(Math.max(Math.abs(translateY.value) + event.changeY, clampY.min), clampY.max);
+        })
+            .onFinalize((event) => {
+            translateY.value = withDecay({
+                velocity: event.velocityY,
+                velocityFactor: 0.25,
+                reduceMotion: ReduceMotion.System,
+                clamp: [clampY.min, clampY.max],
+            }, () => {
+                isDragging.value = false;
+            });
+        });
+    }, [clampY.max, clampY.min]);
+    const containerAnimatedStyle = useAnimatedStyle(() => {
+        const openX = -containerWidth.value;
+        const peekX = -(drawerPeek > 0 ? drawerPeek : drawerWidth);
+        return {
+            left: windowWidth,
+            transform: [
+                { translateY: translateY.value },
+                { translateX: interpolate(dockLevel.value, [0, 1, 2], [0, peekX, openX]) },
+            ],
+        };
+    }, [drawerPeek, drawerWidth, windowWidth]);
+    return {
+        containerAnimatedStyle,
+        panGesture,
+        onContainerLayout,
+    };
+}

package/dist/ui/index.d.ts

@@ -0,0 +1,2 @@
+export * from './debug-dock';
+export * from './toast';

package/dist/ui/index.js

@@ -0,0 +1,2 @@
+export * from './debug-dock';
+export * from './toast';

package/dist/ui/toast/README.md

@@ -0,0 +1,62 @@
+# `@rnzeus/atlas/ui/toast`
+
+← [`@rnzeus/atlas/ui`](../README.md)
+
+## Purpose
+
+Toast system for React Native: global toast API (`useToast`), provider-managed queue, and animated viewport/plates.
+
+## Import
+
+```ts
+import {ToastProvider, useToast} from '@rnzeus/atlas/ui';
+```
+
+## API (public surface)
+
+- `ToastProvider`
+- `useToast() -> { show, dismiss, clear }`
+
+## Usage (minimal)
+
+```tsx
+import {ToastProvider, useToast} from '@rnzeus/atlas/ui';
+
+function SaveButton() {
+  const toast = useToast();
+  return (
+    <Button
+      title="Save"
+      onPress={() =>
+        toast.show({
+          render: () => <Text>Saved</Text>,
+        })
+      }
+    />
+  );
+}
+
+export function App() {
+  return (
+    <ToastProvider>
+      <SaveButton />
+    </ToastProvider>
+  );
+}
+```
+
+## Notes
+
+- `ToastProvider` renders `ToastViewport` internally; usually you only mount the provider once near app root.
+- `show()` supports dedupe via `uuid` and limits concurrent toasts by `maxToasts`.
+- `autoHide` defaults to `true`; default `visibilityTime` is `3000`.
+
+## Sources
+
+- [`index`](./index.js)
+- [`toast-provider`](./toast-provider.js)
+- [`context`](./context.js)
+- [`use-toast`](./use-toast.js)
+- [`types`](./types.js)
+- [`toast-viewport`](./toast-viewport/toast-viewport.js)
+- [`toast-plate`](./toast-plate/toast-plate.js)

package/dist/ui/toast/context.d.ts

@@ -0,0 +1,7 @@
+import type { ToastId, ToastOptions } from './types';
+export type ToastApi = {
+    show: (options: ToastOptions) => ToastId;
+    dismiss: (id: ToastId) => void;
+    clear: () => void;
+};
+export declare const ToastContext: import("react").Context<ToastApi>;