@assistant-ui/core 0.1.0 → 0.1.1

package/src/store/types/index.ts

@@ -1,23 +0,0 @@
-export type {
-  ClientMethods,
-  ClientSchema,
-  ScopeRegistry,
-  ClientOutput,
-  ClientNames,
-  ClientEvents,
-  ClientMeta,
-  ClientElement,
-  Unsubscribe,
-  AssistantState,
-  AssistantClientAccessor,
-  AssistantClient,
-} from "./client";
-
-export {
-  normalizeEventSelector,
-  type AssistantEventPayload,
-  type AssistantEventName,
-  type AssistantEventScope,
-  type AssistantEventSelector,
-  type AssistantEventCallback,
-} from "./events";

package/src/store/utils/attach-transform-scopes.ts

@@ -1,38 +0,0 @@
-import type { ResourceElement } from "@assistant-ui/tap";
-import type {
-  AssistantClient,
-  ClientElement,
-  ClientNames,
-} from "../types/client";
-import type { DerivedElement } from "./derived";
-
-const TRANSFORM_SCOPES = Symbol("assistant-ui.transform-scopes");
-
-export type ScopesConfig = {
-  [K in ClientNames]?: ClientElement<K> | DerivedElement<K>;
-};
-
-type TransformScopesFn = (
-  scopes: ScopesConfig,
-  parent: AssistantClient,
-) => ScopesConfig;
-
-type ResourceWithTransformScopes = {
-  [TRANSFORM_SCOPES]?: TransformScopesFn;
-};
-
-export function attachTransformScopes<
-  T extends (...args: any[]) => ResourceElement<any>,
->(resource: T, transform: TransformScopesFn): void {
-  const r = resource as T & ResourceWithTransformScopes;
-  if (r[TRANSFORM_SCOPES]) {
-    throw new Error("transformScopes is already attached to this resource");
-  }
-  r[TRANSFORM_SCOPES] = transform;
-}
-
-export function getTransformScopes<
-  T extends (...args: any[]) => ResourceElement<any>,
->(resource: T): TransformScopesFn | undefined {
-  return (resource as T & ResourceWithTransformScopes)[TRANSFORM_SCOPES];
-}

package/src/store/utils/base-proxy-handler.ts

@@ -1,50 +0,0 @@
-const INTROSPECTION_PROPS = new Set(["$$typeof", "nodeType", "then"]);
-
-/**
- * Handles common proxy introspection properties.
- * Returns the appropriate value for toStringTag, toJSON, and props that should return undefined.
- * Returns `false` if the prop should be handled by the subclass.
- */
-export const handleIntrospectionProp = (
-  prop: string | symbol,
-  name: string,
-): unknown | false => {
-  if (prop === Symbol.toStringTag) return name;
-  if (typeof prop === "symbol") return undefined;
-  if (prop === "toJSON") return () => name;
-  if (INTROSPECTION_PROPS.has(prop)) return undefined;
-  return false;
-};
-
-export abstract class BaseProxyHandler implements ProxyHandler<object> {
-  abstract get(_: unknown, prop: string | symbol, receiver?: unknown): unknown;
-  abstract ownKeys(): ArrayLike<string | symbol>;
-  abstract has(_: unknown, prop: string | symbol): boolean;
-
-  getOwnPropertyDescriptor(_: unknown, prop: string | symbol) {
-    const value = this.get(_, prop);
-    if (value === undefined) return undefined;
-    return {
-      value,
-      writable: false,
-      enumerable: true,
-      configurable: false,
-    };
-  }
-
-  set() {
-    return false;
-  }
-  setPrototypeOf() {
-    return false;
-  }
-  defineProperty() {
-    return false;
-  }
-  deleteProperty() {
-    return false;
-  }
-  preventExtensions(): boolean {
-    return false;
-  }
-}

package/src/store/utils/derived.ts

@@ -1,46 +0,0 @@
-import { resource, ResourceElement } from "@assistant-ui/tap";
-import type {
-  AssistantClient,
-  ClientNames,
-  AssistantClientAccessor,
-  ClientMeta,
-} from "../types/client";
-
-/**
- * Creates a derived client field that references a client from a parent scope.
- * The get callback always calls the most recent version (useEffectEvent pattern).
- *
- * IMPORTANT: The `get` callback must return a client that was created via
- * `tapClientResource` (or `tapClientLookup`/`tapClientList` which use it internally).
- * This is required for event scoping to work correctly.
- *
- * @example
- * ```typescript
- * const aui = useAui({
- *   message: Derived({
- *     source: "thread",
- *     query: { index: 0 },
- *     get: (aui) => aui.thread().message({ index: 0 }),
- *   }),
- * });
- * ```
- */
-export const Derived = resource(
-  <K extends ClientNames>(_config: Derived.Props<K>): null => {
-    return null;
-  },
-);
-
-export type DerivedElement<K extends ClientNames> = ResourceElement<
-  null,
-  Derived.Props<K>
->;
-
-export namespace Derived {
-  /**
-   * Props passed to a derived client resource element.
-   */
-  export type Props<K extends ClientNames> = {
-    get: (client: AssistantClient) => ReturnType<AssistantClientAccessor<K>>;
-  } & (ClientMeta<K> | { getMeta: (client: AssistantClient) => ClientMeta<K> });
-}

package/src/store/utils/index.ts

@@ -1,28 +0,0 @@
-export {
-  BaseProxyHandler,
-  handleIntrospectionProp,
-} from "./base-proxy-handler";
-export {
-  SYMBOL_CLIENT_INDEX,
-  getClientIndex,
-  type ClientStack,
-  tapClientStack,
-  tapWithClientStack,
-} from "./tap-client-stack-context";
-export {
-  type AssistantTapContextValue,
-  withAssistantTapContextProvider,
-  tapAssistantClientRef,
-  tapAssistantEmit,
-} from "./tap-assistant-context";
-export { NotificationManager } from "./notification-manager";
-export {
-  PROXIED_ASSISTANT_STATE_SYMBOL,
-  createProxiedAssistantState,
-  getProxiedAssistantState,
-} from "./proxied-assistant-state";
-export {
-  type RootClients,
-  type DerivedClients,
-  tapSplitClients,
-} from "./split-clients";

package/src/store/utils/notification-manager.ts

@@ -1,114 +0,0 @@
-import { resource } from "@assistant-ui/tap";
-import type { ClientStack } from "./tap-client-stack-context";
-import type {
-  AssistantEventName,
-  AssistantEventPayload,
-} from "../types/events";
-import { Unsubscribe } from "../types/client";
-import { tapConst } from "@assistant-ui/tap";
-
-type InternalCallback = (payload: unknown, clientStack: ClientStack) => void;
-
-export type NotificationManager = {
-  on<TEvent extends AssistantEventName>(
-    event: TEvent,
-    callback: (
-      payload: AssistantEventPayload[TEvent],
-      clientStack: ClientStack,
-    ) => void,
-  ): Unsubscribe;
-  emit<TEvent extends Exclude<AssistantEventName, "*">>(
-    event: TEvent,
-    payload: AssistantEventPayload[TEvent],
-    clientStack: ClientStack,
-  ): void;
-  subscribe(callback: () => void): Unsubscribe;
-  notifySubscribers(): void;
-};
-
-export const NotificationManager = resource((): NotificationManager => {
-  return tapConst(() => {
-    const listeners = new Map<string, Set<InternalCallback>>();
-    const wildcardListeners = new Set<InternalCallback>();
-    const subscribers = new Set<() => void>();
-
-    return {
-      on(event, callback) {
-        const cb = callback as InternalCallback;
-        if (event === "*") {
-          wildcardListeners.add(cb);
-          return () => wildcardListeners.delete(cb);
-        }
-
-        let set = listeners.get(event);
-        if (!set) {
-          set = new Set();
-          listeners.set(event, set);
-        }
-        set.add(cb);
-
-        return () => {
-          set!.delete(cb);
-          if (set!.size === 0) listeners.delete(event);
-        };
-      },
-
-      emit(event, payload, clientStack) {
-        const eventListeners = listeners.get(event);
-        if (!eventListeners && wildcardListeners.size === 0) return;
-
-        queueMicrotask(() => {
-          const errors = [];
-          if (eventListeners) {
-            for (const cb of eventListeners) {
-              try {
-                cb(payload, clientStack);
-              } catch (e) {
-                errors.push(e);
-              }
-            }
-          }
-          if (wildcardListeners.size > 0) {
-            const wrapped = { event, payload };
-            for (const cb of wildcardListeners) {
-              try {
-                cb(wrapped, clientStack);
-              } catch (e) {
-                errors.push(e);
-              }
-            }
-          }
-
-          if (errors.length > 0) {
-            if (errors.length === 1) {
-              throw errors[0];
-            } else {
-              for (const error of errors) {
-                console.error(error);
-              }
-              throw new AggregateError(
-                errors,
-                "Errors occurred during event emission",
-              );
-            }
-          }
-        });
-      },
-
-      subscribe(callback) {
-        subscribers.add(callback);
-        return () => subscribers.delete(callback);
-      },
-
-      notifySubscribers() {
-        for (const cb of subscribers) {
-          try {
-            cb();
-          } catch (e) {
-            console.error("NotificationManager: subscriber callback error", e);
-          }
-        }
-      },
-    };
-  }, []);
-});

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

@@ -1,55 +0,0 @@
-import { getClientState } from "./tap-client-resource";
-import type { AssistantClient, AssistantState } from "../types/client";
-import {
-  BaseProxyHandler,
-  handleIntrospectionProp,
-} from "./base-proxy-handler";
-
-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/store/utils/split-clients.ts

@@ -1,82 +0,0 @@
-import { Derived, DerivedElement } from "./derived";
-import type {
-  AssistantClient,
-  ClientElement,
-  ClientNames,
-} from "../types/client";
-import {
-  getTransformScopes,
-  type ScopesConfig,
-} from "./attach-transform-scopes";
-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: ScopesConfig, 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: ScopesConfig,
-  baseClient: AssistantClient,
-) => {
-  const { rootClients, derivedClients } = splitClients(clients, baseClient);
-
-  return {
-    rootClients: tapShallowMemoObject(rootClients),
-    derivedClients: tapShallowMemoObject(derivedClients),
-  };
-};

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

@@ -1,58 +0,0 @@
-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/store/utils/tap-client-list.ts

@@ -1,121 +0,0 @@
-import { tapConst, tapState, withKey } from "@assistant-ui/tap";
-import type { ContravariantResource } from "@assistant-ui/tap";
-import { tapClientLookup } from "./tap-client-lookup";
-import type { ClientMethods } from "../types/client";
-
-type InferClientState<TMethods> = TMethods extends {
-  getState: () => infer S;
-}
-  ? S
-  : unknown;
-
-type DataHandle<TData> = { data: TData | undefined; hasData: boolean };
-
-const createProps = <TData>(
-  key: string,
-  data: DataHandle<TData>,
-  remove: () => void,
-): tapClientList.ResourceProps<TData> => {
-  return {
-    key,
-    getInitialData: () => {
-      if (!data.hasData) {
-        throw new Error(
-          "getInitialData may only be called during initial render",
-        );
-      }
-      return data.data!;
-    },
-    remove,
-  };
-};
-
-export const tapClientList = <TData, TMethods extends ClientMethods>(
-  props: tapClientList.Props<TData, TMethods>,
-): {
-  state: InferClientState<TMethods>[];
-  get: (lookup: { index: number } | { key: string }) => TMethods;
-  add: (initialData: TData) => void;
-} => {
-  const { initialValues, getKey, resource: Resource } = props;
-
-  type Props = tapClientList.ResourceProps<TData>;
-
-  const initialDataHandles: DataHandle<TData>[] = tapConst(() => [], []);
-
-  const [items, setItems] = tapState<Record<string, Props>>(() => {
-    const entries: [string, Props][] = [];
-    for (const data of initialValues) {
-      const key = getKey(data);
-      const handle = { data, hasData: true };
-      entries.push([
-        key,
-        createProps(key, handle, () => {
-          setItems((items) => {
-            const newItems = { ...items };
-            delete newItems[key];
-            return newItems;
-          });
-        }),
-      ]);
-      initialDataHandles.push(handle);
-    }
-    return Object.fromEntries(entries);
-  });
-
-  const lookup = tapClientLookup<TMethods>(
-    () =>
-      Object.values(items).map((props) => withKey(props.key, Resource(props))),
-    [items, Resource],
-  );
-
-  initialDataHandles.forEach((handle) => {
-    handle.data = undefined;
-    handle.hasData = false;
-  });
-
-  const add = (data: TData) => {
-    const key = getKey(data);
-    setItems((items) => {
-      if (key in items) {
-        throw new Error(
-          `Tried to add item with a key ${key} that already exists`,
-        );
-      }
-
-      const handle = { data, hasData: true };
-      initialDataHandles.push(handle);
-
-      return {
-        ...items,
-        [key]: createProps(key, handle, () => {
-          setItems((items) => {
-            const newItems = { ...items };
-            delete newItems[key];
-            return newItems;
-          });
-        }),
-      };
-    });
-  };
-
-  return {
-    state: lookup.state,
-    get: lookup.get,
-    add,
-  };
-};
-
-export namespace tapClientList {
-  export type ResourceProps<TData> = {
-    key: string;
-    getInitialData: () => TData;
-    remove: () => void;
-  };
-
-  export type Props<TData, TMethods extends ClientMethods> = {
-    initialValues: TData[];
-    getKey: (data: TData) => string;
-    resource: ContravariantResource<TMethods, ResourceProps<TData>>;
-  };
-}

package/src/store/utils/tap-client-lookup.ts

@@ -1,79 +0,0 @@
-import {
-  tapMemo,
-  tapResource,
-  tapResources,
-  type ResourceElement,
-} from "@assistant-ui/tap";
-import type { ClientMethods } from "../types/client";
-import { ClientResource } from "./tap-client-resource";
-import { wrapperResource } from "./wrapper-resource";
-
-type InferClientState<TMethods> = TMethods extends {
-  getState: () => infer S;
-}
-  ? S
-  : unknown;
-
-const ClientResourceWithKey = wrapperResource(
-  <TMethods extends ClientMethods>(el: ResourceElement<TMethods>) => {
-    if (el.key === undefined) {
-      throw new Error("tapClientResource: Element has no key");
-    }
-    return tapResource(ClientResource(el)) as {
-      methods: TMethods;
-      state: InferClientState<TMethods>;
-      key: string | number;
-    };
-  },
-);
-
-export function tapClientLookup<TMethods extends ClientMethods>(
-  getElements: () => readonly ResourceElement<TMethods>[],
-  getElementsDeps: readonly unknown[],
-): {
-  state: InferClientState<TMethods>[];
-  get: (lookup: { index: number } | { key: string }) => TMethods;
-} {
-  const resources = tapResources(
-    () => getElements().map((el) => ClientResourceWithKey(el)),
-    // biome-ignore lint/correctness/useExhaustiveDependencies: getElementsDeps is passed through from caller
-    getElementsDeps,
-  );
-
-  const keys = tapMemo(() => Object.keys(resources), [resources]);
-
-  // For arrays, track element key -> index mapping
-  const keyToIndex = tapMemo(() => {
-    return resources.reduce(
-      (acc, resource, index) => {
-        acc[resource.key] = index;
-        return acc;
-      },
-      {} as Record<string, number>,
-    );
-  }, [resources]);
-
-  const state = tapMemo(() => {
-    return resources.map((r) => r.state);
-  }, [resources]);
-
-  return {
-    state,
-    get: (lookup: { index: number } | { key: string }) => {
-      if ("index" in lookup) {
-        if (lookup.index < 0 || lookup.index >= keys.length) {
-          throw new Error(
-            `tapClientLookup: Index ${lookup.index} out of bounds (length: ${keys.length})`,
-          );
-        }
-        return resources[lookup.index]!.methods;
-      }
-
-      const index = keyToIndex[lookup.key];
-      if (index === undefined) {
-        throw new Error(`tapClientLookup: Key "${lookup.key}" not found`);
-      }
-      return resources[index]!.methods;
-    },
-  };
-}