@assistant-ui/store Specification#

declare module "@assistant-ui/store" {
  interface ScopeRegistry {
    name: {
      methods: MethodsType; // must include getState(): StateType
      meta?: { source: ClientNames; query: QueryType };
      events?: { "name.event": PayloadType };
    };
  }
}

type ClientOutput<K> = ClientSchemas[K]["methods"] & ClientMethods;
type ClientMethods = { [key: string]: (...args: any[]) => any };
type AssistantClientAccessor<K> = (() => Methods<K>) & ({ source; query } | { source: "root"; query: {} } | { source: null; query: null });
type AssistantClient = { [K]: AssistantClientAccessor<K>; subscribe(cb): Unsubscribe; on(selector, cb): Unsubscribe };
type AssistantState = { [K]: ReturnType<ClientSchemas[K]["methods"]["getState"]> };

useAui(): AssistantClient;
useAui(clients: AuiConfig.Input): AssistantClient; // deprecated: use <AuiProvider extends={aui} config>

useAuiState<T>(selector: (state: AssistantState) => T): T;

useAuiEvent<E>(selector: E | { scope: EventScope<E>; event: E }, callback: (payload) => void): void;

AuiConfig(config: { [K]?: ClientElement<K> | DerivedElement<K> }): AuiConfig;

const aui = useAui();
const config = AuiConfig({ ... });

<AuiProvider config={config}>{children}</AuiProvider> // top-level root
<AuiProvider extends={aui} config={config}>{children}</AuiProvider> // extend parent
<AuiProvider extends={null} config={config}>{children}</AuiProvider> // isolate from parent
<AuiIf condition={(s) => boolean}>{children}</AuiIf>

Derived<K>({ source, query, get: (client) => methods });

attachTransformScopes(resource, (scopes, parent) => newScopes): void;

useAssistantClientRef(): { current: AssistantClient };
useAssistantEmit(): <E>(event: E, payload) => void; // Stable via useEffectEvent

useClientResource(element: ResourceElement<TMethods>): { state: InferClientState<TMethods>; methods: TMethods; key: string | number | undefined };

useClientLookup<TMethods extends ClientMethods>(
  getElements: () => readonly ResourceElement<TMethods>[],
  getElementsDeps: readonly unknown[]
): { state: InferClientState<TMethods>[]; get: (lookup: { index: number } | { key: string }) => TMethods };

useClientList<TData, TMethods extends ClientMethods>({
  initialValues: TData[];
  getKey: (data: TData) => string;
  resource: ContravariantResource<TMethods, ResourceProps<TData>>;
}): { state: InferClientState<TMethods>[]; get: (lookup: { index: number } | { key: string }) => TMethods; add: (data: TData) => void };

type ResourceProps<TData> = { key: string; getInitialData: () => TData; remove: () => void };

type AssistantEventName = keyof ClientEventMap | "*";
type AssistantEventScope<E> = "*" | EventSource<E> | AncestorsOf<EventSource<E>>;
type AssistantEventSelector<E> = E | { scope: Scope<E>; event: E };