react

Every export of kitr/react, read from the published type definitions. The guide shows them in use.

kitr/react

createApp

function createApp(options?: CreateAppOptions): KitrApp;

KitrBoot

function KitrBoot({ app, children, fallback }: KitrProviderProps & {
  fallback?: ReactNode;
}): import("react").JSX.Element;

Boot an app inside React. Renders fallback until boot completes. Use in client-only apps; server-rendered apps boot before rendering.

KitrProvider

function KitrProvider({ app, children }: KitrProviderProps): import("react").JSX.Element;

Puts the app in context and renders every provider's wrap() around children. Boot the app first (await app.boot()) when you can; otherwise it suspends until boot completes.

useApp

function useApp(): KitrApp;

useConfig

function useConfig<K extends Parameters<KitrApp['config']['get']>[0]>(key: K): import("@kitr/core").ConfigOf<K>;

useService

function useService<K extends Parameters<KitrApp['container']['use']>[0]>(key: K): import("@kitr/core").Binding<K>;

Read a container binding from a component. The binding must be resolved (it is after boot).

KitrApp

class KitrApp {
  readonly container: Container;
  readonly config: ConfigStore;
  readonly environment: AppEnvironment;
  readonly mode: AppMode;
  readonly env: Record<string, unknown>;
  readonly providers: KitrProvider[];
  /** Native drivers registered by platform providers, resolved by capability packages. */
  readonly drivers: DriverRegistry;
  /** The platform name from kitrrc.ts this bundle runs as, when known. */
  readonly platform: string | undefined;
  private inputs;
  private phase;
  private readying;
  private booting?;
  constructor(options?: CreateAppOptions);
  get isClient(): boolean;
  get isServer(): boolean;
  get isDevelopment(): boolean;
  get isProduction(): boolean;
  /** Add a provider before boot. */
  use(provider: ProviderInput): this;
  /** register → boot. Idempotent: concurrent callers share one boot. */
  boot(): Promise<this>;
  /** Server only: tell providers the server is serving. Idempotent: runs each `ready` once. */
  ready(): Promise<this>;
  /** Server only: run providers' `shutdown` in reverse order. */
  shutdown(): Promise<void>;
  /** Compose every provider's `wrap`, outermost first. */
  wrap(children: KitrNode): KitrNode;
  /** A request- or test-scoped app that shares providers and config but has its own instances. */
  fork(): KitrApp;
  get status(): Phase;
}

The app object every provider sees. One per client, one per server process, one per test. It owns the container, the config and the provider list.

CreateAppOptions

interface CreateAppOptions {
  providers?: ProviderInput[];
  /** Per-package config, keyed the way `config/<name>.ts` files are. */
  config?: Record<string, unknown>;
  environment?: AppEnvironment;
  /** development | production | test. Default: from Vite's `import.meta.env.MODE` or `NODE_ENV`. */
  mode?: AppMode;
  /** Validated env object (from `createEnv`). Exposed as `app.env`. */
  env?: Record<string, unknown>;
  /** The platform name this bundle was built for (`kitr dev site` → `site`). Default: from `import.meta.env.KITR_PLATFORM`. */
  platform?: string;
}

KitrProviderProps

interface KitrProviderProps {
  app: KitrApp;
  children: ReactNode;
}