@rnzeus/atlas 0.1.0

package/dist/README.md

@@ -0,0 +1,21 @@
+# `@rnzeus/atlas`
+
+✨ A shared toolkit of services, utilities, helpers, and hooks.
+
+## Documentation
+
+- [`Services`](./services/README.md)
+- [`Hooks`](./hooks/README.md)
+- [`Utilities`](./utils/README.md)
+- [`UI`](./ui/README.md)
+
+## Installation
+
+This package has peer dependencies that should be present in your app.
+
+Install missing peers:
+
+```sh
+# yarn
+yarn add @react-navigation/native qs
+```

package/dist/config/internal.d.ts

@@ -0,0 +1 @@
+export * from './navigation';

package/dist/config/internal.js

@@ -0,0 +1 @@
+export * from './navigation';

package/dist/config/navigation/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/config/navigation/index.js

@@ -0,0 +1 @@
+export * from './types';

package/dist/config/navigation/types.d.ts

@@ -0,0 +1,55 @@
+import type { LinkingOptions, NavigationContainerRef, ParamListBase } from '@react-navigation/native';
+export type NavigationStrict = boolean;
+export type NavigationErrorCtx = {
+    type: 'build';
+    route: RouteDef<any, any>;
+    input: unknown;
+} | {
+    type: 'query';
+    route: RouteDef<any, any>;
+    input: unknown;
+};
+export type NavigationOnError = (error: Error, ctx: NavigationErrorCtx) => void;
+export type ConfigureNavigationOptions = {
+    ref: NavigationContainerRef<ParamListBase>;
+    linking: LinkingOptions<ParamListBase>;
+    strict?: NavigationStrict;
+    onError?: NavigationOnError;
+};
+export type SchemaLike<T> = {
+    safeParse: (input: unknown) => {
+        success: true;
+        data: T;
+    } | {
+        success: false;
+        error: unknown;
+    };
+};
+export type RouteDef<P = undefined, Q = undefined> = {
+    path: string;
+    name: string;
+    linking: string;
+    key?: string;
+    __params?: P;
+    __query?: Q;
+    paramsSchema?: SchemaLike<P>;
+    querySchema?: SchemaLike<Q>;
+};
+export type RouteParams<R> = R extends RouteDef<infer P, any> ? P : never;
+export type RouteQuery<R> = R extends RouteDef<any, infer Q> ? Q : never;
+export type BuiltPath<R extends RouteDef<any, any> = RouteDef<any, any>> = string & {
+    readonly __brand: 'BuiltPath';
+    readonly __route?: R;
+};
+export type QueryOptions = Partial<{
+    encode: boolean;
+    nested: 'json';
+    debug: boolean;
+    /**
+     * Keep `null` values in the output query string.
+     *
+     * When enabled, `null` is serialized as the string `"null"`,
+     * which can be safely round-tripped with `JSON.parse`.
+     */
+    nullable: boolean;
+}>;

package/dist/config/navigation/types.js

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

package/dist/config/navigation.types.d.ts

@@ -0,0 +1,25 @@
+export type RouteDef<P = undefined, Q = undefined> = {
+    path: string;
+    name: string;
+    linking: string;
+    key?: string;
+    __params?: P;
+    __query?: Q;
+};
+export type RouteParams<R> = R extends RouteDef<infer P, any> ? P : never;
+export type RouteQuery<R> = R extends RouteDef<any, infer Q> ? Q : never;
+export type BuiltPath<R extends RouteDef<any, any> = RouteDef<any, any>> = string & {
+    readonly __brand: 'BuiltPath';
+    readonly __route?: R;
+};
+export type StrictMode = 'off' | 'warn' | 'throw';
+export type ValidationResult = {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};
+export type NavigationValidator = {
+    validateBuild?: <R extends RouteDef<any, any>>(route: R, params: unknown) => ValidationResult;
+    validateQuery?: <R extends RouteDef<any, any>>(route: R, query: unknown) => ValidationResult;
+};

package/dist/config/navigation.types.js

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

package/dist/hooks/README.md

@@ -0,0 +1,11 @@
+# `@rnzeus/atlas/hooks`
+
+← [`@rnzeus/atlas`](../README.md)
+
+## Documentation
+
+- **[`use-path-navigation`](./use-path-navigation/README.md)** — navigate by path strings using the Navigation service.
+
+```ts
+import {usePathNavigation} from '@rnzeus/atlas/hooks';
+```

package/dist/hooks/index.d.ts

@@ -0,0 +1 @@
+export { usePathNavigation } from './use-path-navigation';

package/dist/hooks/index.js

@@ -0,0 +1 @@
+export { usePathNavigation } from './use-path-navigation';

package/dist/hooks/internal.d.ts

@@ -0,0 +1 @@
+export * from './use-path-navigation';

package/dist/hooks/internal.js

@@ -0,0 +1 @@
+export * from './use-path-navigation';

package/dist/hooks/use-path-navigation/README.md

@@ -0,0 +1,66 @@
+# `@rnzeus/atlas/hooks/use-path-navigation`
+
+← [`@rnzeus/atlas/hooks`](../README.md)
+
+## Purpose
+
+Navigate using **typed branded paths** from inside React components (React Navigation), powered by the Atlas `Navigation` service.
+
+## Import
+
+```ts
+import {usePathNavigation} from '@rnzeus/atlas/hooks';
+```
+
+## API (public surface)
+
+`usePathNavigation<N extends NavigationProp<ParamListBase>>()` returns:
+
+- Navigation (safe, path-based)
+  - `navigate(path: BuiltPath): void`
+  - `push(path: BuiltPath): void`
+  - `replace(path: BuiltPath): void`
+  - `popTo(path: BuiltPath): void`
+  - `reset(path: BuiltPath): void`
+  - `popToTop(): void`
+  - `goBack(): void`
+- Builders
+  - `build(route, params?)` → `BuiltPath`
+  - `query(builtPath, query?, opts?)` → `BuiltPath`
+  - `chain(route, params?)` → `ChainBuilder` (fluent `query().navigate()/push()/reset()`)
+- Raw (whitelist from React Navigation)
+  - `setParams(...)`
+  - `setOptions(...)` (typed based on `N`)
+  - `getState?()`, `addListener?()`, `removeListener?()`, `isFocused?()`, `canGoBack?()`, `getParent?()`, `dispatch?()`
+
+## Usage (minimal)
+
+```tsx
+import {usePathNavigation} from '@rnzeus/atlas/hooks';
+import {defineRoute} from '@rnzeus/atlas/utils';
+
+export function GoToBooking() {
+  const nav = usePathNavigation();
+
+  const BOOKING = defineRoute()({
+    name: 'Booking',
+    path: 'non-tabbar/booking/:id',
+    linking: 'booking',
+  });
+
+  return <Button title="Go" onPress={() => nav.navigate(nav.build(BOOKING, {id: 42}))} />;
+}
+```
+
+## Notes
+
+- **Requirements**:
+  - must be used inside a React Navigation tree (`useNavigation()` must work)
+  - `Navigation.linkingConfig` must be configured once at app bootstrap (path parsing depends on it)
+- **How it works**: the hook dispatches actions via local `navigation`, so it does not require a global `navRef`.
+- **Builders**: `build` / `query` / `chain` are built on top of the `Navigation` service. Prefer branded paths (`BuiltPath`) over raw strings.
+
+## Sources
+
+- [`hook`](./hook.js)
+- [`index`](./index.js)

package/dist/hooks/use-path-navigation/hook.d.ts

@@ -0,0 +1,119 @@
+import type { NavigationProp, ParamListBase } from '@react-navigation/native';
+import type { BuiltPath, QueryOptions, RouteDef, RouteParams, RouteQuery } from '../../config/internal';
+import { ChainBuilder } from '../../services/internal';
+/**
+ * N is the navigation type (NavigationProp / NativeStackNavigationProp / etc),
+ * so the consumer can pass the "correct" nav type and get the setOptions type.
+ */
+declare const usePathNavigation: <N extends NavigationProp<ParamListBase> = NavigationProp<ParamListBase>>() => {
+    getState: () => Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[];
+        routes: import("@react-navigation/routers").NavigationRoute<ParamListBase, string>[];
+        type: string;
+        stale: false;
+    }>;
+    addListener: <EventName extends keyof import("@react-navigation/core").EventMapCore<Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[];
+        routes: import("@react-navigation/routers").NavigationRoute<ParamListBase, string>[];
+        type: string;
+        stale: false;
+    }>>>(type: EventName, callback: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/core").EventMapCore<Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[];
+        routes: import("@react-navigation/routers").NavigationRoute<ParamListBase, string>[];
+        type: string;
+        stale: false;
+    }>>, EventName, import("@react-navigation/core").EventMapCore<Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[];
+        routes: import("@react-navigation/routers").NavigationRoute<ParamListBase, string>[];
+        type: string;
+        stale: false;
+    }>>[EventName]["canPreventDefault"]>) => () => void;
+    removeListener: <EventName extends keyof import("@react-navigation/core").EventMapCore<Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[];
+        routes: import("@react-navigation/routers").NavigationRoute<ParamListBase, string>[];
+        type: string;
+        stale: false;
+    }>>>(type: EventName, callback: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/core").EventMapCore<Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[];
+        routes: import("@react-navigation/routers").NavigationRoute<ParamListBase, string>[];
+        type: string;
+        stale: false;
+    }>>, EventName, import("@react-navigation/core").EventMapCore<Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[];
+        routes: import("@react-navigation/routers").NavigationRoute<ParamListBase, string>[];
+        type: string;
+        stale: false;
+    }>>[EventName]["canPreventDefault"]>) => void;
+    isFocused: () => boolean;
+    canGoBack: () => boolean;
+    getParent: <T = NavigationProp<ParamListBase, string, string | undefined, Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[];
+        routes: import("@react-navigation/routers").NavigationRoute<ParamListBase, string>[];
+        type: string;
+        stale: false;
+    }>, {}, {}> | undefined>(id?: string | undefined) => T;
+    dispatch: (action: Readonly<{
+        type: string;
+        payload?: object;
+        source?: string;
+        target?: string;
+    }> | ((state: Readonly<Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[];
+        routes: import("@react-navigation/routers").NavigationRoute<ParamListBase, string>[];
+        type: string;
+        stale: false;
+    }>>) => Readonly<{
+        type: string;
+        payload?: object;
+        source?: string;
+        target?: string;
+    }>)) => void;
+    setParams: N["setParams"];
+    replaceParams: N["replaceParams"];
+    setOptions: N extends {
+        setOptions: infer F;
+    } ? F : never;
+    navigate: (path: BuiltPath) => void;
+    push: (path: BuiltPath) => void;
+    replace: (path: BuiltPath) => void;
+    popTo: (path: BuiltPath) => void;
+    reset: (path: BuiltPath) => void;
+    popToTop: () => void;
+    goBack: () => void;
+    build: <R extends RouteDef<any, any>>(route: R, ...args: RouteParams<R> extends undefined ? [] : [params: RouteParams<R>]) => BuiltPath<R>;
+    query: {
+        <R extends RouteDef<any, undefined>>(url: BuiltPath<R>): BuiltPath<R>;
+        <R extends RouteDef<any, undefined>>(url: BuiltPath<R>, q: undefined, opts?: QueryOptions): BuiltPath<R>;
+        <R extends RouteDef<any, any>>(url: BuiltPath<R>, q: RouteQuery<R>, opts?: QueryOptions): BuiltPath<R>;
+        <R extends RouteDef<any, any>>(url: BuiltPath<R>, q?: RouteQuery<R>, opts?: QueryOptions): BuiltPath<R>;
+    };
+    chain: <R extends RouteDef<any, any>>(route: R, ...args: RouteParams<R> extends undefined ? [] : [params: RouteParams<R>]) => ChainBuilder<R>;
+};
+export default usePathNavigation;

package/dist/hooks/use-path-navigation/hook.js

@@ -0,0 +1,52 @@
+import { useNavigation } from '@react-navigation/native';
+import { ChainBuilder, Navigation } from '../../services/internal';
+/**
+ * N is the navigation type (NavigationProp / NativeStackNavigationProp / etc),
+ * so the consumer can pass the "correct" nav type and get the setOptions type.
+ */
+const usePathNavigation = () => {
+    const navigation = useNavigation();
+    const build = (route, ...args) => {
+        if (args.length === 0)
+            return Navigation.build(route);
+        return Navigation.build(route, args[0]);
+    };
+    const query = ((url, q, opts) => Navigation.query(url, q, opts));
+    // chaining
+    const chain = (route, ...args) => {
+        const base = build(route, ...args);
+        return new ChainBuilder(base, navigation, query);
+    };
+    const raw = {
+        // state + events
+        getState: navigation.getState?.bind(navigation),
+        addListener: navigation.addListener?.bind(navigation),
+        removeListener: navigation.removeListener?.bind(navigation),
+        isFocused: navigation.isFocused?.bind(navigation),
+        canGoBack: navigation.canGoBack?.bind(navigation),
+        getParent: navigation.getParent?.bind(navigation),
+        // advanced
+        dispatch: navigation.dispatch?.bind(navigation),
+        // params/options (type depends on N)
+        setParams: navigation.setParams?.bind(navigation),
+        replaceParams: navigation.replaceParams?.bind(navigation),
+        setOptions: navigation.setOptions?.bind(navigation),
+    };
+    return {
+        // navigation (safe, path-based)
+        navigate: (path) => Navigation.navigate(path, navigation),
+        push: (path) => Navigation.push(path),
+        replace: (path) => Navigation.replace(path),
+        popTo: (path) => Navigation.popTo(path, navigation),
+        reset: (path) => Navigation.reset(path),
+        popToTop: () => Navigation.popToTop(navigation),
+        goBack: () => Navigation.goBack(),
+        // builders
+        build,
+        query,
+        chain,
+        // raw (whitelist)
+        ...raw,
+    };
+};
+export default usePathNavigation;

package/dist/hooks/use-path-navigation/index.d.ts

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

package/dist/hooks/use-path-navigation/index.js

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

package/dist/services/README.md

@@ -0,0 +1,17 @@
+# `@rnzeus/atlas/services`
+
+← [`@rnzeus/atlas`](../README.md)
+
+## Documentation
+
+- **[`Transport`](./transport/README.md)** — a base `fetch` transport with query params, default headers, error normalization, and `get/post/put/delete`. Instantiate with base URL and defaults, then call verb methods from modules that own API paths.
+
+```ts
+import {Transport} from '@rnzeus/atlas/services';
+```
+
+- **[`Navigation`](./navigation/README.md)** — programmatic path-based navigation on top of React Navigation (navigate/push/replace/popTo/reset + URL helpers). Call `configureNavigation()` once with a ref and linking config, then use `Navigation` (or `usePathNavigation`) with `defineRoute()` and `BuiltPath` for type-safe paths.
+
+```ts
+import {Navigation, configureNavigation} from '@rnzeus/atlas/services';
+```

package/dist/services/index.d.ts

@@ -0,0 +1,4 @@
+export { Navigation } from './navigation';
+export { configureNavigation } from './navigation';
+export type { TransportOptions } from './transport';
+export { Transport, TransportErrorException } from './transport';

package/dist/services/index.js

@@ -0,0 +1,3 @@
+export { Navigation } from './navigation';
+export { configureNavigation } from './navigation';
+export { Transport, TransportErrorException } from './transport';

package/dist/services/internal.d.ts

@@ -0,0 +1 @@
+export * from './navigation';

package/dist/services/internal.js

@@ -0,0 +1 @@
+export * from './navigation';

package/dist/services/navigation/README.md

@@ -0,0 +1,131 @@
+# `@rnzeus/atlas/services/navigation`
+
+← [`@rnzeus/atlas/services`](../README.md)
+
+## Purpose
+
+Programmatic path-based navigation on top of React Navigation. Supports nested stacks, safe `popTo()` behavior, **branded typed paths** (`BuiltPath`), and optional runtime validation (schema-based, e.g. Zod).
+
+## Import
+
+```ts
+import {Navigation, configureNavigation} from '@rnzeus/atlas/services';
+```
+
+## API (public surface)
+
+- Configuration (required for path parsing)
+  - `Navigation.linkingConfig = linking`
+- Optional (required for “global” navigation outside React tree)
+  - `Navigation.navRef = navRef`
+- Convenience configuration
+  - `configureNavigation({ ref, linking, strict?, onError? })`
+- Navigation actions
+  - **Safe (preferred)**:
+    - `navigate(path: BuiltPath, navigation?)`
+    - `push(path: BuiltPath, navigation?)`
+    - `replace(path: BuiltPath, navigation?)`
+    - `popTo(path: BuiltPath, navigation?)`
+    - `reset(path: BuiltPath)`
+  - **Unsafe (strings)**:
+    - `navigateUnsafe(path: string, navigation?)`
+    - `pushUnsafe(path: string, navigation?)`
+    - `replaceUnsafe(path: string, navigation?)`
+    - `popToUnsafe(path: string, navigation?)`
+    - `resetUnsafe(path: string)`
+  - `popToTop(navigation?)`
+  - `goBack()`
+- Helpers
+  - `getCurrentPath()`
+  - `build(route, params?)` → `BuiltPath`
+  - `query(url: BuiltPath, query?, opts?)` → `BuiltPath` (see `QueryOptions`)
+
+## Usage (minimal)
+
+```ts
+import {Navigation, configureNavigation} from '@rnzeus/atlas/services';
+import {defineRoute} from '@rnzeus/atlas/utils';
+
+// Configure once at app bootstrap (must include full nesting config).
+configureNavigation({ref: navRef, linking, strict: false});
+
+const BOOKING = defineRoute<{id: number}, {step?: string}>()({
+  name: 'Booking',
+  path: 'non-tabbar/booking/:id',
+  linking: 'booking',
+});
+
+const url = Navigation.query(Navigation.build(BOOKING, {id: 42}), {step: 'seats'});
+Navigation.navigate(url);
+```
+
+## Usage (optional validation: Zod)
+
+```ts
+import {Navigation} from '@rnzeus/atlas/services';
+import {defineRoute} from '@rnzeus/atlas/utils';
+import {z} from 'zod';
+
+const SCHEDULE_DETAIL = defineRoute<{id: string}>()({
+  name: 'ScheduleDetail',
+  path: 'schedule/:id',
+  linking: 'schedule-detail',
+  paramsSchema: z.object({id: z.string().min(1)}),
+});
+
+const SCHEDULE_LIST = defineRoute<undefined, {direction: 'inbound' | 'outbound'}>()({
+  name: 'ScheduleList',
+  path: 'schedule',
+  linking: 'schedule-list',
+  querySchema: z.object({direction: z.enum(['inbound', 'outbound'])}),
+});
+
+// strict=true is recommended only for development/test.
+// In production builds prefer strict=false and report via onError.
+Navigation.strict = true;
+Navigation.onError = (error, ctx) => {
+  // send to your logger/sentry and decide how to handle it
+};
+
+const url = Navigation.query(Navigation.build(SCHEDULE_LIST), {direction: 'inbound'});
+Navigation.navigate(url);
+```
+
+Then, inside the target screen/component you can access the parsed values via React Navigation `route.params`:
+
+```tsx
+import {useRoute} from '@react-navigation/native';
+
+export function BookingScreen() {
+  const route = useRoute<any>();
+  const id = route.params?.id;
+  const step = route.params?.step;
+
+  return null;
+}
+```
+
+## Notes
+
+- **Linking is required**: all path-based methods rely on `linking.config` to parse a path into navigation state.
+- **Inside vs outside React tree**:
+  - if you pass a `navigation` object (local navigation), `navRef` is not required
+  - if you do not pass `navigation`, `navRef` must be set and ready
+- **`popTo(path)` behavior**: tries to pop within the current stack when possible, otherwise navigates to the nearest existing parent and then to the leaf.
+- **URL helpers**:
+  - `build(route, params?)` replaces `:param` tokens in `route.path` and returns a **branded** `BuiltPath` tied to the route definition.
+  - `query(builtPath, query)` merges with existing query and drops empty values; returns `BuiltPath` again.
+  - `QueryOptions`: `{ encode?: boolean; nested?: 'json'; debug?: boolean; nullable?: boolean }`
+- **Validation (optional)**:
+  - By default, the service validates using `route.paramsSchema` / `route.querySchema` if present (any schema with `safeParse()`).
+  - Validation is invoked inside `build()` and `query()` (when a route can be recovered from the branded `BuiltPath`).
+  - In **strict mode** (`strict=true`) validation failures throw; in non-strict mode they only call `onError` and log warnings.
+- **Errors**: navigation methods do not throw for missing `linking`/`navRef` (they log warnings). Validation errors throw only when `strict=true`.
+
+## Sources
+
+- [`service`](./service.js)
+- [`api`](./api.js)
+- [`chain-builder`](./chain-builder.js)
+- [`types`](./types.js)
+- [`index`](./index.js)

package/dist/services/navigation/api.d.ts

@@ -0,0 +1,5 @@
+import type { ConfigureNavigationOptions } from '../../config/internal';
+/**
+ * Configure the global Navigation service.
+ */
+export default function configureNavigation({ ref, linking, strict, onError }: ConfigureNavigationOptions): void;

package/dist/services/navigation/api.js

@@ -0,0 +1,11 @@
+import Navigation from './service';
+/**
+ * Configure the global Navigation service.
+ */
+export default function configureNavigation({ ref, linking, strict = false, onError }) {
+    Navigation.navRef = ref;
+    Navigation.linkingConfig = linking;
+    Navigation.strict = strict;
+    if (onError)
+        Navigation.onError = onError;
+}

package/dist/services/navigation/chain-builder.d.ts

@@ -0,0 +1,16 @@
+import type { NavigationProp } from '@react-navigation/native';
+import type { BuiltPath, QueryOptions, RouteDef, RouteQuery } from '../../config/internal';
+declare class ChainBuilder<R extends RouteDef<any, any>> {
+    private path;
+    private navigation;
+    private queryFn;
+    constructor(path: BuiltPath<R>, navigation: NavigationProp<any>, queryFn: <RR extends RouteDef<any, any>>(url: BuiltPath<RR>, q?: any, opts?: QueryOptions) => BuiltPath<RR>);
+    query(...args: RouteQuery<R> extends undefined ? [q?: undefined, opts?: QueryOptions] : [q: RouteQuery<R>, opts?: QueryOptions]): this;
+    value(): BuiltPath<R>;
+    navigate(): void;
+    push(): void;
+    replace(): void;
+    popTo(): void;
+    reset(): void;
+}
+export default ChainBuilder;

package/dist/services/navigation/chain-builder.js

@@ -0,0 +1,31 @@
+import Navigation from './service';
+class ChainBuilder {
+    constructor(path, navigation, queryFn) {
+        this.path = path;
+        this.navigation = navigation;
+        this.queryFn = queryFn;
+    }
+    query(...args) {
+        this.path = this.queryFn(this.path, args[0], args[1]);
+        return this;
+    }
+    value() {
+        return this.path;
+    }
+    navigate() {
+        Navigation.navigate(this.path, this.navigation);
+    }
+    push() {
+        Navigation.push(this.path);
+    }
+    replace() {
+        Navigation.replace(this.path);
+    }
+    popTo() {
+        Navigation.popTo(this.path, this.navigation);
+    }
+    reset() {
+        Navigation.reset(this.path);
+    }
+}
+export default ChainBuilder;

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

@@ -0,0 +1,3 @@
+export { default as configureNavigation } from './api';
+export { default as ChainBuilder } from './chain-builder';
+export { default as Navigation } from './service';

package/dist/services/navigation/index.js

@@ -0,0 +1,3 @@
+export { default as configureNavigation } from './api';
+export { default as ChainBuilder } from './chain-builder';
+export { default as Navigation } from './service';