@rnzeus/atlas 0.1.0

package/dist/ui/toast/context.js

@@ -0,0 +1,6 @@
+import { createContext } from 'react';
+export const ToastContext = createContext({
+    show: () => '',
+    dismiss: () => { },
+    clear: () => { },
+});

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

@@ -0,0 +1,5 @@
+export type { ToastApi } from './context';
+export type { ToastProviderProps } from './toast-provider';
+export { ToastProvider } from './toast-provider';
+export type { ToastId, ToastOptions, ToastRender, ToastRenderContext } from './types';
+export { useToast } from './use-toast';

package/dist/ui/toast/index.js

@@ -0,0 +1,2 @@
+export { ToastProvider } from './toast-provider';
+export { useToast } from './use-toast';

package/dist/ui/toast/toast-plate/README.md

@@ -0,0 +1,38 @@
+# `@rnzeus/atlas/ui/toast/toast-plate`
+
+← [`@rnzeus/atlas/ui/toast`](../README.md)
+
+## Purpose
+
+Animated wrapper for a single toast item. Handles entry/exit transitions and auto-hide timing.
+
+## Import
+
+```ts
+import {ToastPlate} from '@rnzeus/atlas/ui';
+```
+
+## API (public surface)
+
+- `ToastPlate(props)`
+  - `toast: ToastItem`
+
+## Usage (minimal)
+
+```tsx
+import {ToastPlate} from '@rnzeus/atlas/ui';
+
+<ToastPlate toast={toast} />;
+```
+
+## Notes
+
+- Uses Reanimated transitions (`SlideInUp`, `FadeOut`, `LinearTransition`).
+- `useToastPlate()` schedules auto-hide after enter animation when `toast.autoHide` is enabled.
+- Usually consumed indirectly via `ToastViewport`.
+
+## Sources
+
+- [`toast-plate`](./toast-plate.js)
+- [`use-toast-plate`](./use-toast-plate.js)
+- [`index`](./index.js)

package/dist/ui/toast/toast-plate/index.d.ts

@@ -0,0 +1,2 @@
+export type { ToastPlateProps } from './toast-plate';
+export { ToastPlate } from './toast-plate';

package/dist/ui/toast/toast-plate/index.js

@@ -0,0 +1 @@
+export { ToastPlate } from './toast-plate';

package/dist/ui/toast/toast-plate/toast-plate.d.ts

@@ -0,0 +1,9 @@
+import type { JSX } from 'react';
+import type { ToastItem } from '../types';
+export type ToastPlateProps = {
+    toast: ToastItem;
+};
+export declare function ToastPlate({ toast }: ToastPlateProps): JSX.Element;
+export declare namespace ToastPlate {
+    var displayName: string;
+}

package/dist/ui/toast/toast-plate/toast-plate.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import Animated, { FadeOut, LinearTransition, ReduceMotion, SlideInUp } from 'react-native-reanimated';
+import { displayName } from '../../../utils';
+import { useToast } from '../use-toast';
+import { useToastPlate } from './use-toast-plate';
+export function ToastPlate({ toast }) {
+    const { dismiss } = useToast();
+    const { handleEnteringEnd } = useToastPlate(toast);
+    return (_jsx(Animated.View, { entering: SlideInUp.withCallback(handleEnteringEnd), exiting: FadeOut, layout: LinearTransition.reduceMotion(ReduceMotion.System), children: toast.render({ id: toast.id, dismiss: () => dismiss(toast.id) }) }, `toast-${toast.id}`));
+}
+ToastPlate.displayName = displayName('ui', 'toast-plate');

package/dist/ui/toast/toast-plate/use-toast-plate.d.ts

@@ -0,0 +1,4 @@
+import type { ToastItem } from '../types';
+export declare function useToastPlate(toast: ToastItem): {
+    handleEnteringEnd: () => void;
+};

package/dist/ui/toast/toast-plate/use-toast-plate.js

@@ -0,0 +1,33 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { scheduleOnRN } from 'react-native-worklets';
+import { useToast } from '../use-toast';
+export function useToastPlate(toast) {
+    const { dismiss } = useToast();
+    const timer = useRef(null);
+    useEffect(() => {
+        return () => {
+            if (timer.current) {
+                clearTimeout(timer.current);
+                timer.current = null;
+            }
+        };
+    }, []);
+    const startAutoHide = useCallback(() => {
+        if (!toast.autoHide)
+            return;
+        if (timer.current)
+            return;
+        timer.current = setTimeout(() => {
+            dismiss(toast.id);
+            if (timer.current) {
+                clearTimeout(timer.current);
+                timer.current = null;
+            }
+        }, toast.visibilityTime);
+    }, [dismiss, toast.autoHide, toast.id, toast.visibilityTime]);
+    const handleEnteringEnd = useCallback(() => {
+        'worklet';
+        scheduleOnRN(startAutoHide);
+    }, [startAutoHide]);
+    return { handleEnteringEnd };
+}

package/dist/ui/toast/toast-provider.d.ts

@@ -0,0 +1,10 @@
+import type { JSX, ReactNode } from 'react';
+export type ToastProviderProps = {
+    children: ReactNode;
+    maxToasts?: number;
+    zIndex?: number;
+};
+export declare function ToastProvider({ children, maxToasts, zIndex }: ToastProviderProps): JSX.Element;
+export declare namespace ToastProvider {
+    var displayName: string;
+}

package/dist/ui/toast/toast-provider.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useMemo, useRef, useState } from 'react';
+import { displayName } from '../../utils';
+import { ToastContext } from './context';
+import { ToastViewport } from './toast-viewport';
+function createToastIdFactory() {
+    let seq = 0;
+    return () => {
+        seq = (seq + 1) % 1000000;
+        return `${Date.now()}-${seq}`;
+    };
+}
+export function ToastProvider({ children, maxToasts = 3, zIndex }) {
+    const nextId = useMemo(() => createToastIdFactory(), []);
+    const [toasts, setToasts] = useState([]);
+    const toastsRef = useRef([]);
+    toastsRef.current = toasts;
+    const dismiss = useCallback((id) => {
+        requestAnimationFrame(() => {
+            setToasts(state => state.filter(t => t.id !== id));
+        });
+    }, []);
+    const clear = useCallback(() => {
+        requestAnimationFrame(() => {
+            setToasts([]);
+        });
+    }, []);
+    const show = useCallback((options) => {
+        const id = options.id ?? nextId();
+        requestAnimationFrame(() => {
+            setToasts(state => {
+                if (options.uuid) {
+                    const existing = state.find(t => t.uuid === options.uuid);
+                    if (existing)
+                        return state;
+                }
+                const item = {
+                    id,
+                    uuid: options.uuid,
+                    render: options.render,
+                    autoHide: options.autoHide ?? true,
+                    visibilityTime: options.visibilityTime ?? 3000,
+                };
+                const next = [item, ...state];
+                return next.slice(0, maxToasts);
+            });
+        });
+        return id;
+    }, [maxToasts, nextId]);
+    const value = useMemo(() => ({ show, dismiss, clear }), [clear, dismiss, show]);
+    return (_jsxs(ToastContext.Provider, { value: value, children: [children, _jsx(ToastViewport, { toasts: toastsRef.current, zIndex: zIndex })] }));
+}
+ToastProvider.displayName = displayName('ui', 'toast-provider');

package/dist/ui/toast/toast-viewport/README.md

@@ -0,0 +1,38 @@
+# `@rnzeus/atlas/ui/toast/toast-viewport`
+
+← [`@rnzeus/atlas/ui/toast`](../README.md)
+
+## Purpose
+
+Render layer for active toasts. Positions toast list at the top, applies safe-area offset, and renders each item through `ToastPlate`.
+
+## Import
+
+```ts
+import {ToastViewport} from '@rnzeus/atlas/ui';
+```
+
+## API (public surface)
+
+- `ToastViewport(props)`
+  - `toasts: ToastItem[]`
+  - `zIndex?: number` (default `10`)
+
+## Usage (minimal)
+
+```tsx
+import {ToastViewport} from '@rnzeus/atlas/ui';
+
+<ToastViewport toasts={toasts} zIndex={20} />;
+```
+
+## Notes
+
+- Uses `useSafeAreaInsets()` and adds top padding (`insets.top + 10`).
+- `ToastProvider` already renders this component internally.
+
+## Sources
+
+- [`toast-viewport`](./toast-viewport.js)
+- [`index`](./index.js)
+- [`styles`](./styles.js)

package/dist/ui/toast/toast-viewport/index.d.ts

@@ -0,0 +1,2 @@
+export type { ToastViewportProps } from './toast-viewport';
+export { ToastViewport } from './toast-viewport';

package/dist/ui/toast/toast-viewport/index.js

@@ -0,0 +1 @@
+export { ToastViewport } from './toast-viewport';

package/dist/ui/toast/toast-viewport/styles.d.ts

@@ -0,0 +1,5 @@
+import type { ViewStyle } from 'react-native';
+export type ToastViewportStyles = {
+    readonly container: ViewStyle;
+};
+export declare const styles: ToastViewportStyles;

package/dist/ui/toast/toast-viewport/styles.js

@@ -0,0 +1,10 @@
+import { StyleSheet } from 'react-native';
+export const styles = StyleSheet.create({
+    container: {
+        gap: 10,
+        left: 0,
+        position: 'absolute',
+        right: 0,
+        top: 0,
+    },
+});

package/dist/ui/toast/toast-viewport/toast-viewport.d.ts

@@ -0,0 +1,10 @@
+import type { JSX } from 'react';
+import type { ToastItem } from '../types';
+export type ToastViewportProps = {
+    toasts: ToastItem[];
+    zIndex?: number;
+};
+export declare function ToastViewport({ toasts, zIndex }: ToastViewportProps): JSX.Element;
+export declare namespace ToastViewport {
+    var displayName: string;
+}

package/dist/ui/toast/toast-viewport/toast-viewport.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+import { View } from 'react-native';
+import { displayName } from '../../../utils';
+import { ToastPlate } from '../toast-plate';
+import { styles } from './styles';
+export function ToastViewport({ toasts, zIndex = 10 }) {
+    const insets = useSafeAreaInsets();
+    const containerExtraStyles = useMemo(() => ({ paddingTop: insets.top + 10, zIndex }), [insets.top, zIndex]);
+    return (_jsx(View, { style: [styles.container, containerExtraStyles], pointerEvents: "box-none", children: toasts.map(toast => (_jsx(ToastPlate, { toast: toast }, toast.id))) }));
+}
+ToastViewport.displayName = displayName('ui', 'toast-viewport');

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

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+export type ToastId = string;
+export type ToastRenderContext = {
+    id: ToastId;
+    dismiss: () => void;
+};
+export type ToastRender = (ctx: ToastRenderContext) => ReactNode;
+export type ToastOptions = {
+    id?: ToastId;
+    /**
+     * Optional dedupe key.
+     * If a toast with the same uuid already exists, show() becomes a no-op.
+     */
+    uuid?: string;
+    render: ToastRender;
+    autoHide?: boolean;
+    visibilityTime?: number;
+};
+export type ToastItem = {
+    id: ToastId;
+    uuid?: string;
+    render: ToastRender;
+    autoHide: boolean;
+    visibilityTime: number;
+};

package/dist/ui/toast/types.js

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

package/dist/ui/toast/use-toast.d.ts

@@ -0,0 +1 @@
+export declare function useToast(): import("./context").ToastApi;

package/dist/ui/toast/use-toast.js

@@ -0,0 +1,5 @@
+import { useContext } from 'react';
+import { ToastContext } from './context';
+export function useToast() {
+    return useContext(ToastContext);
+}

package/dist/utils/README.md

@@ -0,0 +1,23 @@
+# `@rnzeus/atlas/utils`
+
+← [`@rnzeus/atlas`](../README.md)
+
+## Documentation
+
+- **[`display-name`](./display-name/README.md)** — generate stable component display names using a layer prefix (`A/P/W/F/E/S`) and a PascalCased name.
+
+```ts
+import {displayName} from '@rnzeus/atlas/utils';
+```
+
+- **[`create-typography`](./create-typography/README.md)** — build a typed typography map and a `createTextTypography()` helper (with optional scaling and platform lineHeight handling).
+
+```ts
+import {createTypography} from '@rnzeus/atlas/utils';
+```
+
+- **[`define-route`](./define-route/README.md)** — define typed route objects (`RouteDef<P>`) for `Navigation.build()`.
+
+```ts
+import {defineRoute} from '@rnzeus/atlas/utils';
+```

package/dist/utils/create-typography/README.md

@@ -0,0 +1,71 @@
+# `@rnzeus/atlas/utils/create-typography`
+
+← [`@rnzeus/atlas/utils`](../README.md)
+
+## Purpose
+
+Create a typed typography registry and a helper that returns React Native `TextStyle` objects with optional scaling and platform-specific `lineHeight` handling.
+
+## Import
+
+```ts
+import {createTypography} from '@rnzeus/atlas/utils';
+```
+
+## API (public surface)
+
+`createTypography(cfg)` returns:
+
+- `TYPOGRAPHY`: a typed map of your entries (key → config)
+- `createTextTypography(key)`: returns a `TextStyle` for the given key
+
+Config:
+
+- `entries`: `[key, typographyConfig][]`
+- `scale?`: `(n: number) => number` (e.g. `sw`)
+- `platform?`: `'ios' | 'android'` (or any `PlatformOSType`)
+- `iosZeroLineHeightIfEqual?`: if `true`, sets `lineHeight: 0` on iOS when `fontSize === lineHeight`
+- `debug?`: if `true`, logs registry details (keys, count, platform, scale, fallback)
+- `strict?`: if `true`, throws on invalid runtime keys (instead of falling back)
+- `fallback?`: key used when `strict=false` and a runtime key is invalid (defaults to the first entry key)
+- `onError?`: `(error, context?) => void` (called when `strict=false` and a runtime key is invalid)
+
+## Usage (minimal)
+
+```ts
+import {createTypography} from '@rnzeus/atlas/utils';
+
+const {createTextTypography} = createTypography({
+  platform: 'ios',
+  entries: [
+    [
+      'title',
+      {
+        fontFamily: 'Inter',
+        fontSize: 20,
+        lineHeight: 24,
+        fontWeight: '600',
+        letterSpacing: 0,
+        textTransform: 'none',
+      },
+    ],
+  ] as const,
+});
+
+const title = createTextTypography('title');
+```
+
+## Notes
+
+- **Typing**: use `as const` on `entries` to keep keys strongly typed.
+- **Scaling**: if `scale` is provided, both `fontSize` and `lineHeight` are scaled.
+- **Platform lineHeight**: when `platform` is not provided, it uses a “safe” cross-platform behavior.
+- **Runtime key safety**:
+  - `createTextTypography` is typed, but invalid keys can still happen at runtime (e.g. when a key comes from remote config)
+  - use `strict: true` to fail fast
+  - keep `strict: false` + `fallback` + `onError` for safe production behavior
+
+## Sources
+
+- [`helper`](./helper.js)
+- [`index`](./index.js)

package/dist/utils/create-typography/helper.d.ts

@@ -0,0 +1,23 @@
+import type { PlatformOSType, TextStyle } from 'react-native';
+type ExtraTypographyStyle = 'fontSize' | 'lineHeight' | 'fontFamily' | 'fontWeight' | 'letterSpacing' | 'textTransform';
+type TypographyConfig = Required<Pick<TextStyle, ExtraTypographyStyle>>;
+type TypographyEntry<K extends string = string> = readonly [K, TypographyConfig];
+export type TypographyErrorContext = {
+    where: string;
+    key?: string;
+};
+type CreateTypographyConfig<E extends readonly TypographyEntry[]> = {
+    entries: E;
+    scale?: (n: number) => number;
+    platform?: PlatformOSType | 'ios' | 'android';
+    iosZeroLineHeightIfEqual?: boolean;
+    debug?: boolean;
+    strict?: boolean;
+    onError?: (error: Error, context?: TypographyErrorContext) => void;
+    fallback?: E[number][0];
+};
+declare const createTypography: <const E extends readonly TypographyEntry[]>(cfg: CreateTypographyConfig<E>) => {
+    readonly TYPOGRAPHY: { [K in E[number][0]]: Extract<E[number], readonly [K, Required<Pick<TextStyle, ExtraTypographyStyle>>]>[1]; };
+    readonly createTextTypography: (typography: E[number][0]) => TextStyle;
+};
+export default createTypography;

package/dist/utils/create-typography/helper.js

@@ -0,0 +1,72 @@
+const createTypography = (cfg) => {
+    if (!cfg.entries.length) {
+        throw new Error('[Typography] entries must not be empty');
+    }
+    const TYPOGRAPHY = Object.fromEntries(cfg.entries);
+    const keys = cfg.entries.map(e => e[0]);
+    const strict = cfg.strict ?? false;
+    const onError = cfg.onError;
+    const debug = cfg.debug ?? false;
+    const platform = cfg.platform;
+    const scale = cfg.scale;
+    // fallback key: explicit or first entry key
+    const fallbackKey = (cfg.fallback ?? keys[0]);
+    const errorValue = (message, context) => {
+        const err = new Error(message);
+        if (strict)
+            throw err;
+        try {
+            onError?.(err, context);
+        }
+        catch {
+            // ignore logging errors
+        }
+        return TYPOGRAPHY[fallbackKey];
+    };
+    const getConfig = (key) => {
+        const v = TYPOGRAPHY[key];
+        if (!v) {
+            return errorValue(`Unknown typography key: ${key}`, { where: 'getConfig', key });
+        }
+        return v;
+    };
+    const createTextTypography = (typography) => {
+        const v = getConfig(String(typography));
+        const fz = v.fontSize;
+        const lh = v.lineHeight;
+        const s = (n) => (scale ? scale(n) : n);
+        return {
+            fontFamily: v.fontFamily,
+            fontSize: s(fz),
+            ...(platform === 'ios'
+                ? { lineHeight: cfg.iosZeroLineHeightIfEqual && fz === lh ? 0 : s(lh) }
+                : { lineHeight: s(lh) }),
+            fontWeight: v.fontWeight,
+            letterSpacing: v.letterSpacing,
+            textTransform: v.textTransform,
+        };
+    };
+    if (debug) {
+        // eslint-disable-next-line no-console
+        console.groupCollapsed?.('[Typography]');
+        // eslint-disable-next-line no-console
+        console.log('Strict:', strict);
+        // eslint-disable-next-line no-console
+        console.log('Platform:', platform ?? '(auto)');
+        // eslint-disable-next-line no-console
+        console.log('Scale:', scale ? 'on' : 'off');
+        // eslint-disable-next-line no-console
+        console.log('Fallback:', fallbackKey);
+        // eslint-disable-next-line no-console
+        console.log('Keys:', [...keys].sort());
+        // eslint-disable-next-line no-console
+        console.log('Count:', keys.length);
+        // eslint-disable-next-line no-console
+        console.groupEnd?.();
+    }
+    return {
+        TYPOGRAPHY,
+        createTextTypography,
+    };
+};
+export default createTypography;

package/dist/utils/create-typography/index.d.ts

@@ -0,0 +1 @@
+export { default as createTypography } from './helper';

package/dist/utils/create-typography/index.js

@@ -0,0 +1 @@
+export { default as createTypography } from './helper';

package/dist/utils/define-route/README.md

@@ -0,0 +1,50 @@
+# `@rnzeus/atlas/utils/define-route`
+
+← [`@rnzeus/atlas/utils`](../README.md)
+
+## Purpose
+
+Define typed route objects (`RouteDef<P, Q>`) to be used with Atlas navigation helpers (e.g. `Navigation.build(route, params)`), keeping route params/query strongly typed.
+
+## Import
+
+```ts
+import {defineRoute} from '@rnzeus/atlas/utils';
+```
+
+## API (public surface)
+
+`defineRoute<P = undefined, Q = undefined>()(def) => RouteDef<P, Q> & def`
+
+- `P` is the type of route params (e.g. `{id: number}`)
+- `Q` is the type of route query (e.g. `{step?: 'seats' | 'payment'}`)
+- `def` is a route definition object (`name`, `path`, `linking`, optional `key`)
+- optional schemas:
+  - `paramsSchema?: { safeParse(input): ... }` (e.g. a Zod schema)
+  - `querySchema?: { safeParse(input): ... }` (e.g. a Zod schema)
+
+## Usage (minimal)
+
+```ts
+import {Navigation} from '@rnzeus/atlas/services';
+import {defineRoute} from '@rnzeus/atlas/utils';
+
+const BOOKING = defineRoute<{id: number}>()({
+  name: 'Booking',
+  path: 'non-tabbar/booking/:id',
+  linking: 'booking',
+});
+
+const path = Navigation.build(BOOKING, {id: 42});
+```
+
+## Notes
+
+- This is a **type helper**: at runtime it returns the same object you pass in.
+- `RouteDef<P, Q>` includes internal `__params` / `__query` fields used only for typing.
+- Schema fields (`paramsSchema` / `querySchema`) are used by `Navigation.build()` / `Navigation.query()` when validation is enabled.
+
+## Sources
+
+- [`helper`](./helper.js)
+- [`index`](./index.js)

package/dist/utils/define-route/helper.d.ts

@@ -0,0 +1,2 @@
+import type { RouteDef } from '../../config/internal';
+export declare const defineRoute: <P = undefined, Q = undefined>() => <const D extends Omit<RouteDef<P, Q>, "__params" | "__query">>(def: D) => RouteDef<P, Q> & D;

package/dist/utils/define-route/helper.js

@@ -0,0 +1 @@
+export const defineRoute = () => (def) => def;

package/dist/utils/define-route/index.d.ts

@@ -0,0 +1 @@
+export { defineRoute } from './helper';

package/dist/utils/define-route/index.js

@@ -0,0 +1 @@
+export { defineRoute } from './helper';

package/dist/utils/display-name/README.md

@@ -0,0 +1,46 @@
+# `@rnzeus/atlas/utils/display-name`
+
+← [`@rnzeus/atlas/utils`](../README.md)
+
+## Purpose
+
+Generate stable component display names for logging/debugging. The name is built as:
+
+- a **layer prefix** (`A/P/W/F/E/S`)
+- a **PascalCased** component name
+
+## Import
+
+```ts
+import {displayName} from '@rnzeus/atlas/utils';
+```
+
+## API (public surface)
+
+`displayName(layerOrPath: string, nameMaybe?: string): string`
+
+Overloads:
+
+- `displayName('features', 'logger-button')` → `FLoggerButton`
+- `displayName('src/features/logger/ui/logger-button/button.tsx')` → `FButton`
+
+## Usage (minimal)
+
+```ts
+import {displayName} from '@rnzeus/atlas/utils';
+
+const name = displayName('features', 'logger-button'); // "FLoggerButton"
+```
+
+## Notes
+
+- **Layer detection**: when you pass a path, the layer is inferred from folder names (`app/pages/widgets/features/entities/shared`). If no layer is detected, it falls back to `shared` (`S`).
+- **Normalization**:
+  - paths are normalized to `/` separators
+  - `@` and leading `./` are stripped before matching
+- **PascalCase**: the base name is derived from the file name (without extension) and converted to PascalCase.
+
+## Sources
+
+- [`helper`](./helper.js)
+- [`index`](./index.js)

package/dist/utils/display-name/helper.d.ts

@@ -0,0 +1,2 @@
+declare const displayName: (layerOrPath: string, nameMaybe?: string) => string;
+export default displayName;