@assistant-ui/store 0.2.0 → 0.2.1

package/src/utils/proxied-assistant-state.ts

@@ -0,0 +1,53 @@
+"use client";
+import { getClientState } from "../tapClientResource";
+import type { AssistantClient, AssistantState } from "../types/client";
+import { BaseProxyHandler, handleIntrospectionProp } from "./BaseProxyHandler";
+
+export const PROXIED_ASSISTANT_STATE_SYMBOL = Symbol(
+  "assistant-ui.store.proxiedAssistantState",
+);
+
+const isIgnoredKey = (key: string | symbol): key is "on" | "subscribe" => {
+  return key === "on" || key === "subscribe" || typeof key === "symbol";
+};
+
+/**
+ * Proxied state that lazily accesses scope states
+ */
+export const createProxiedAssistantState = (
+  client: AssistantClient,
+): AssistantState => {
+  class ProxiedAssistantStateProxyHandler
+    extends BaseProxyHandler
+    implements ProxyHandler<AssistantState>
+  {
+    get(_: unknown, prop: string | symbol) {
+      const introspection = handleIntrospectionProp(prop, "AssistantState");
+      if (introspection !== false) return introspection;
+      const scope = prop as keyof AssistantClient;
+      if (isIgnoredKey(scope)) return undefined;
+      return getClientState(client[scope]());
+    }
+
+    ownKeys(): ArrayLike<string | symbol> {
+      return Object.keys(client).filter((key) => !isIgnoredKey(key));
+    }
+
+    has(_: unknown, prop: string | symbol): boolean {
+      return !isIgnoredKey(prop) && prop in client;
+    }
+  }
+
+  return new Proxy<AssistantState>(
+    {} as AssistantState,
+    new ProxiedAssistantStateProxyHandler(),
+  );
+};
+
+export const getProxiedAssistantState = (
+  client: AssistantClient,
+): AssistantState => {
+  return (
+    client as unknown as { [PROXIED_ASSISTANT_STATE_SYMBOL]: AssistantState }
+  )[PROXIED_ASSISTANT_STATE_SYMBOL];
+};

package/src/utils/react-assistant-context.tsx

@@ -1,14 +1,10 @@
 import React, { createContext, useContext } from "react";
-import type {
-  AssistantClient,
-  AssistantClientAccessor,
-} from "@assistant-ui/core/store";
+import type { AssistantClient, AssistantClientAccessor } from "../types/client";
 import {
   createProxiedAssistantState,
   PROXIED_ASSISTANT_STATE_SYMBOL,
-  BaseProxyHandler,
-  handleIntrospectionProp,
-} from "@assistant-ui/core/store/internal";
+} from "./proxied-assistant-state";
+import { BaseProxyHandler, handleIntrospectionProp } from "./BaseProxyHandler";
 
 const NO_OP_SUBSCRIBE = () => () => {};
 

package/src/utils/splitClients.ts

@@ -0,0 +1,80 @@
+import { Derived, DerivedElement } from "../Derived";
+import type {
+  AssistantClient,
+  ClientElement,
+  ClientNames,
+} from "../types/client";
+import { getTransformScopes } from "../attachTransformScopes";
+import type { useAui } from "../useAui";
+import { tapMemo } from "@assistant-ui/tap";
+
+export type RootClients = Partial<
+  Record<ClientNames, ClientElement<ClientNames>>
+>;
+export type DerivedClients = Partial<
+  Record<ClientNames, DerivedElement<ClientNames>>
+>;
+
+/**
+ * Splits a clients object into root clients and derived clients,
+ * applying transformScopes from root client elements.
+ */
+function splitClients(clients: useAui.Props, baseClient: AssistantClient) {
+  // 1. Collect transforms from root elements and run them iteratively
+  let scopes = { ...clients } as Record<
+    string,
+    ClientElement<ClientNames> | DerivedElement<ClientNames>
+  >;
+  const visited = new Set<(...args: any[]) => any>();
+
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const clientElement of Object.values(scopes)) {
+      if (clientElement.type === (Derived as unknown)) continue;
+      if (visited.has(clientElement.type)) continue;
+      visited.add(clientElement.type);
+
+      const transform = getTransformScopes(clientElement.type);
+      if (transform) {
+        scopes = transform(scopes, baseClient) as typeof scopes;
+        changed = true;
+        break; // restart iteration since scopes may have new root elements
+      }
+    }
+  }
+
+  // 2. Split result into root/derived
+  const rootClients: RootClients = {};
+  const derivedClients: DerivedClients = {};
+
+  for (const [key, clientElement] of Object.entries(scopes) as [
+    ClientNames,
+    ClientElement<ClientNames> | DerivedElement<ClientNames>,
+  ][]) {
+    if (clientElement.type === (Derived as unknown)) {
+      derivedClients[key] = clientElement as DerivedElement<ClientNames>;
+    } else {
+      rootClients[key] = clientElement as ClientElement<ClientNames>;
+    }
+  }
+
+  return { rootClients, derivedClients };
+}
+
+const tapShallowMemoObject = <T extends object>(object: T) => {
+  // biome-ignore lint/correctness/useExhaustiveDependencies: shallow memo
+  return tapMemo(() => object, [...Object.entries(object).flat()]);
+};
+
+export const tapSplitClients = (
+  clients: useAui.Props,
+  baseClient: AssistantClient,
+) => {
+  const { rootClients, derivedClients } = splitClients(clients, baseClient);
+
+  return {
+    rootClients: tapShallowMemoObject(rootClients),
+    derivedClients: tapShallowMemoObject(derivedClients),
+  };
+};

package/src/utils/tap-assistant-context.ts

@@ -0,0 +1,58 @@
+import {
+  createResourceContext,
+  tap,
+  withContextProvider,
+  tapEffectEvent,
+} from "@assistant-ui/tap";
+import type {
+  AssistantEventName,
+  AssistantEventPayload,
+} from "../types/events";
+import type { AssistantClient } from "../types/client";
+import { tapClientStack, type ClientStack } from "./tap-client-stack-context";
+
+type EmitFn = <TEvent extends Exclude<AssistantEventName, "*">>(
+  event: TEvent,
+  payload: AssistantEventPayload[TEvent],
+  clientStack: ClientStack,
+) => void;
+
+export type AssistantTapContextValue = {
+  clientRef: { parent: AssistantClient; current: AssistantClient | null };
+  emit: EmitFn;
+};
+
+const AssistantTapContext =
+  createResourceContext<AssistantTapContextValue | null>(null);
+
+export const withAssistantTapContextProvider = <TResult>(
+  value: AssistantTapContextValue,
+  fn: () => TResult,
+) => {
+  return withContextProvider(AssistantTapContext, value, fn);
+};
+
+const tapAssistantTapContext = () => {
+  const ctx = tap(AssistantTapContext);
+  if (!ctx) throw new Error("AssistantTapContext is not available");
+
+  return ctx;
+};
+
+export const tapAssistantClientRef = () => {
+  return tapAssistantTapContext().clientRef;
+};
+
+export const tapAssistantEmit = () => {
+  const { emit } = tapAssistantTapContext();
+  const clientStack = tapClientStack();
+
+  return tapEffectEvent(
+    <TEvent extends Exclude<AssistantEventName, "*">>(
+      event: TEvent,
+      payload: AssistantEventPayload[TEvent],
+    ) => {
+      emit(event, payload, clientStack);
+    },
+  );
+};

package/src/utils/tap-client-stack-context.ts

@@ -0,0 +1,51 @@
+import {
+  createResourceContext,
+  tap,
+  withContextProvider,
+  tapMemo,
+} from "@assistant-ui/tap";
+import type { ClientMethods } from "../types/client";
+
+/**
+ * Symbol used to get the client index from a ClientProxy.
+ */
+export const SYMBOL_CLIENT_INDEX = Symbol("assistant-ui.store.clientIndex");
+
+/**
+ * Get the index of a client (its position in the client stack when created).
+ */
+export const getClientIndex = (client: ClientMethods): number => {
+  return (client as unknown as { [SYMBOL_CLIENT_INDEX]: number })[
+    SYMBOL_CLIENT_INDEX
+  ];
+};
+
+/**
+ * The client stack - an array of clients representing the current hierarchy.
+ */
+export type ClientStack = readonly ClientMethods[];
+
+const ClientStackContext = createResourceContext<ClientStack>([]);
+
+/**
+ * Get the current client stack inside a tap resource.
+ */
+export const tapClientStack = (): ClientStack => {
+  return tap(ClientStackContext);
+};
+
+/**
+ * Execute a callback with a client pushed onto the stack.
+ * The stack is duplicated, not mutated.
+ */
+export const tapWithClientStack = <T>(
+  client: ClientMethods,
+  callback: () => T,
+): T => {
+  const currentStack = tapClientStack();
+  const newStack = tapMemo(
+    () => [...currentStack, client],
+    [currentStack, client],
+  );
+  return withContextProvider(ClientStackContext, newStack, callback);
+};

package/src/wrapperResource.ts

@@ -0,0 +1,17 @@
+import {
+  type ResourceElement,
+  Resource,
+  resource,
+  withKey,
+} from "@assistant-ui/tap";
+
+export const wrapperResource = <R, P>(
+  fn: (props: ResourceElement<P>) => R,
+): Resource<R, ResourceElement<P>> => {
+  const res = resource(fn);
+  return (props: ResourceElement<P>) => {
+    const el = res(props);
+    if (props.key === undefined) return el;
+    return withKey(props.key, el);
+  };
+};

package/dist/scope-registry-forward.d.ts

@@ -1,6 +0,0 @@
-import type { ScopeRegistry as StoreScopeRegistry } from "./scope-registry.js";
-declare module "@assistant-ui/core/store" {
-    interface ScopeRegistry extends StoreScopeRegistry {
-    }
-}
-//# sourceMappingURL=scope-registry-forward.d.ts.map

package/dist/scope-registry-forward.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scope-registry-forward.d.ts","sourceRoot":"","sources":["../src/scope-registry-forward.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,IAAI,kBAAkB,EAAE,4BAAyB;AAG5E,OAAO,QAAQ,0BAA0B,CAAC;IACxC,UAAU,aAAc,SAAQ,kBAAkB;KAAG;CACtD"}

package/dist/scope-registry-forward.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=scope-registry-forward.js.map

package/dist/scope-registry-forward.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scope-registry-forward.js","sourceRoot":"","sources":["../src/scope-registry-forward.ts"],"names":[],"mappings":""}

package/dist/scope-registry.d.ts

@@ -1,17 +0,0 @@
-/**
- * Module augmentation interface for assistant-ui store type extensions.
- *
- * Users augment this interface to register custom scopes:
- * ```typescript
- * declare module "@assistant-ui/store" {
- *   interface ScopeRegistry {
- *     myScope: { methods: { getState: () => MyState } };
- *   }
- * }
- * ```
- *
- * Augmentations are automatically forwarded to `@assistant-ui/core/store`.
- */
-export interface ScopeRegistry {
-}
-//# sourceMappingURL=scope-registry.d.ts.map

package/dist/scope-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scope-registry.d.ts","sourceRoot":"","sources":["../src/scope-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,aAAa;CAAG"}

package/dist/scope-registry.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=scope-registry.js.map

package/dist/scope-registry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scope-registry.js","sourceRoot":"","sources":["../src/scope-registry.ts"],"names":[],"mappings":""}

package/src/scope-registry-forward.ts

@@ -1,6 +0,0 @@
-import type { ScopeRegistry as StoreScopeRegistry } from "./scope-registry";
-
-// Forward user augmentations on @assistant-ui/store to @assistant-ui/core/store
-declare module "@assistant-ui/core/store" {
-  interface ScopeRegistry extends StoreScopeRegistry {}
-}

package/src/scope-registry.ts

@@ -1,15 +0,0 @@
-/**
- * Module augmentation interface for assistant-ui store type extensions.
- *
- * Users augment this interface to register custom scopes:
- * ```typescript
- * declare module "@assistant-ui/store" {
- *   interface ScopeRegistry {
- *     myScope: { methods: { getState: () => MyState } };
- *   }
- * }
- * ```
- *
- * Augmentations are automatically forwarded to `@assistant-ui/core/store`.
- */
-export interface ScopeRegistry {}