@dxos/halo-react 0.0.0

package/src/HaloProvider.tsx

@@ -0,0 +1,47 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Context from 'effect/Context';
+import React, { type PropsWithChildren, createContext, useContext } from 'react';
+
+import { type Identity, type Space } from '@dxos/halo';
+
+/**
+ * The HALO services, as the tag union carried in an Effect service {@link Context.Context}.
+ */
+export type HaloServices = Identity.Service | Space.Service;
+
+/**
+ * React context carrying the HALO services. Hooks read it, provide it into a service stream, and
+ * surface the result through the default {@link Atom} runtime.
+ */
+const HaloServicesContext = createContext<Context.Context<HaloServices> | undefined>(undefined);
+
+export type HaloProviderProps = PropsWithChildren<{
+  /**
+   * The HALO services context. Build it from a concrete backing — e.g. the client adapter's
+   * `makeIdentityService` / `makeSpaceService` from `@dxos/halo-adapter-client` — and pass it
+   * here.
+   */
+  services: Context.Context<HaloServices>;
+}>;
+
+/**
+ * Provides the HALO services to the hook library. Wrap the application (or the subtree that uses
+ * the hooks) in this provider. Replaces `ClientProvider` for HALO concerns.
+ */
+export const HaloProvider = ({ services, children }: HaloProviderProps) => (
+  <HaloServicesContext.Provider value={services}>{children}</HaloServicesContext.Provider>
+);
+
+/**
+ * Returns the HALO services context. Throws if no {@link HaloProvider} is above in the tree.
+ */
+export const useHaloServices = (): Context.Context<HaloServices> => {
+  const services = useContext(HaloServicesContext);
+  if (!services) {
+    throw new Error('Missing HaloProvider.');
+  }
+  return services;
+};

package/src/index.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './HaloProvider';
+export * from './useCredentials';
+export * from './useDevices';
+export * from './useIdentity';
+export * from './useInvitations';
+export * from './useMembers';
+export * from './useSpaces';

package/src/useCredentials.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom, Result, useAtomValue } from '@effect-atom/atom-react';
+import * as Stream from 'effect/Stream';
+import { useMemo } from 'react';
+
+import { Identity } from '@dxos/halo';
+
+import { useHaloServices } from './HaloProvider';
+
+const EMPTY: readonly Identity.Credential[] = [];
+
+/**
+ * Returns the local identity's HALO credentials. Reactive: re-renders when credentials are
+ * written. Replaces `@dxos/react-client`'s `useCredentials`.
+ */
+export const useCredentials = (): readonly Identity.Credential[] => {
+  const services = useHaloServices();
+  const atom = useMemo(() => Atom.make(Identity.credentials.pipe(Stream.provideContext(services))), [services]);
+  return Result.getOrElse(useAtomValue(atom), () => EMPTY);
+};

package/src/useDevices.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom, Result, useAtomValue } from '@effect-atom/atom-react';
+import * as Stream from 'effect/Stream';
+import { useMemo } from 'react';
+
+import { Identity } from '@dxos/halo';
+
+import { useHaloServices } from './HaloProvider';
+
+const EMPTY: readonly Identity.DeviceInfo[] = [];
+
+/**
+ * Returns the devices belonging to the local identity. Reactive. Replaces
+ * `@dxos/react-client`'s `useDevices`.
+ */
+export const useDevices = (): readonly Identity.DeviceInfo[] => {
+  const services = useHaloServices();
+  const atom = useMemo(() => Atom.make(Identity.devices.pipe(Stream.provideContext(services))), [services]);
+  return Result.getOrElse(useAtomValue(atom), () => EMPTY);
+};

package/src/useIdentity.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom, Result, useAtomValue } from '@effect-atom/atom-react';
+import * as Option from 'effect/Option';
+import * as Stream from 'effect/Stream';
+import { useMemo } from 'react';
+
+import { Identity } from '@dxos/halo';
+
+import { useHaloServices } from './HaloProvider';
+
+/**
+ * Returns the local identity, or `undefined` if none exists. Reactive: re-renders when the
+ * identity is created or its profile changes. Replaces `@dxos/react-client`'s `useIdentity`.
+ */
+export const useIdentity = (): Identity.Info | undefined => {
+  const services = useHaloServices();
+  const atom = useMemo(
+    () => Atom.make(Identity.identity.pipe(Stream.provideContext(services), Stream.map(Option.getOrUndefined))),
+    [services],
+  );
+  return Result.getOrElse(useAtomValue(atom), () => undefined);
+};

package/src/useInvitations.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom, Result, useAtomValue } from '@effect-atom/atom-react';
+import * as Stream from 'effect/Stream';
+import { useMemo } from 'react';
+
+import { Identity, type Invitation, Space } from '@dxos/halo';
+import { type SpaceId } from '@dxos/keys';
+
+import { useHaloServices } from './HaloProvider';
+
+const EMPTY: readonly Invitation.Flow[] = [];
+
+/**
+ * Returns the active (host-created) invitation flows for a space. Reactive. Replaces
+ * `@dxos/react-client`'s `useSpaceInvitations`. Drive an individual flow through the
+ * `Invitation` verbs (`events` / `authenticate` / `cancel` / `code`).
+ */
+export const useSpaceInvitations = (spaceId?: SpaceId): readonly Invitation.Flow[] => {
+  const services = useHaloServices();
+  const atom = useMemo(
+    () => Atom.make((spaceId ? Space.invitations(spaceId) : Stream.empty).pipe(Stream.provideContext(services))),
+    [services, spaceId],
+  );
+  return Result.getOrElse(useAtomValue(atom), () => EMPTY);
+};
+
+/**
+ * Returns the active device-invitation flows for the local identity. Reactive. Replaces
+ * `useHaloInvitations`.
+ */
+export const useHaloInvitations = (): readonly Invitation.Flow[] => {
+  const services = useHaloServices();
+  const atom = useMemo(() => Atom.make(Identity.invitations.pipe(Stream.provideContext(services))), [services]);
+  return Result.getOrElse(useAtomValue(atom), () => EMPTY);
+};

package/src/useMembers.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom, Result, useAtomValue } from '@effect-atom/atom-react';
+import * as Stream from 'effect/Stream';
+import { useMemo } from 'react';
+
+import { Space } from '@dxos/halo';
+import { type SpaceId } from '@dxos/keys';
+
+import { useHaloServices } from './HaloProvider';
+
+const EMPTY: readonly Space.Member[] = [];
+
+/**
+ * Returns the membership of a space. Reactive: re-renders on join/leave/role/presence changes.
+ * Replaces `@dxos/react-client`'s `useMembers` (which took a `PublicKey`; this takes a
+ * {@link SpaceId}).
+ */
+export const useMembers = (spaceId?: SpaceId): readonly Space.Member[] => {
+  const services = useHaloServices();
+  const atom = useMemo(
+    () => Atom.make((spaceId ? Space.members(spaceId) : Stream.empty).pipe(Stream.provideContext(services))),
+    [services, spaceId],
+  );
+  return Result.getOrElse(useAtomValue(atom), () => EMPTY);
+};

package/src/useSpaces.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom, Result, useAtomValue } from '@effect-atom/atom-react';
+import * as Stream from 'effect/Stream';
+import { useMemo } from 'react';
+
+import { Space } from '@dxos/halo';
+import { type SpaceId } from '@dxos/keys';
+
+import { useHaloServices } from './HaloProvider';
+
+const EMPTY: readonly Space.Info[] = [];
+
+export type UseSpacesOptions = {
+  /** Include spaces that are not yet `ready` (default: only `ready` spaces). */
+  all?: boolean;
+};
+
+/**
+ * Returns the spaces known to the local identity. By default only `ready` spaces are returned;
+ * pass `{ all: true }` for every space. Reactive. Replaces `@dxos/react-client`'s `useSpaces`.
+ */
+export const useSpaces = ({ all = false }: UseSpacesOptions = {}): readonly Space.Info[] => {
+  const services = useHaloServices();
+  const atom = useMemo(() => Atom.make(Space.spaces.pipe(Stream.provideContext(services))), [services]);
+  const spaces = Result.getOrElse(useAtomValue(atom), () => EMPTY);
+  return useMemo(() => (all ? spaces : spaces.filter((space) => space.state === 'ready')), [spaces, all]);
+};
+
+/**
+ * Resolves a single space by id, or `undefined`. Reactive. Replaces `useSpace`. Unlike the
+ * legacy hook this takes a {@link SpaceId} only (no `PublicKey`).
+ */
+export const useSpace = (spaceId?: SpaceId): Space.Info | undefined => {
+  const spaces = useSpaces({ all: true });
+  return useMemo(() => (spaceId ? spaces.find((space) => space.id === spaceId) : undefined), [spaces, spaceId]);
+};