@assistant-ui/react 0.11.49 → 0.11.50

package/src/utils/tap-store/derived-scopes.ts

@@ -40,7 +40,7 @@ type AssistantApiFieldNames = {
 /**
  * Configuration for a derived scope field - infers types from the actual values provided
  */
-export type DerivedScopeConfig<TSource extends string | null, TQuery, TApi> = {
+export type DerivedConfig<TSource extends string | null, TQuery, TApi> = {
   source: TSource;
   query: TQuery;
   get: () => TApi;
@@ -59,18 +59,12 @@ export type OnCallbackFn = <TEvent extends AssistantEvent>(
  */
 export type SubscribeCallbackFn = (listener: () => void) => Unsubscribe;
 
-/**
- * Type for the special `flushSync` callback function
- */
-export type FlushSyncCallbackFn = () => void;
-
 /**
  * Type for special non-field functions in AssistantApi
  */
 export type SpecialCallbacks = {
   on?: OnCallbackFn;
   subscribe?: SubscribeCallbackFn;
-  flushSync?: FlushSyncCallbackFn;
 };
 
 /**
@@ -98,7 +92,7 @@ export type DerivedScopesInput = {
  */
 export const DerivedScope = resource(
   <TSource extends string | null, TQuery, TApi>(
-    config: DerivedScopeConfig<TSource, TQuery, TApi>,
+    config: DerivedConfig<TSource, TQuery, TApi>,
   ): AssistantApiField<
     TApi,
     {
@@ -144,32 +138,28 @@ const ScopeFieldWithNameResource = resource(
  */
 export const DerivedScopes = resource(
   (scopes: DerivedScopesInput): Partial<AssistantApi> => {
-    const { on, subscribe, flushSync, ...scopeFields } = scopes;
-    const callbacksRef = tapRef({ on, subscribe, flushSync });
+    const { on, subscribe, ...scopeFields } = scopes;
+    const callbacksRef = tapRef({ on, subscribe });
     tapEffect(() => {
-      callbacksRef.current = { on, subscribe, flushSync };
+      callbacksRef.current = { on, subscribe };
     });
 
     const results = tapResources(
-      Object.entries(scopeFields).map(([fieldName, scopeElement]) =>
-        ScopeFieldWithNameResource(
-          {
-            fieldName,
-            scopeElement: scopeElement as ReturnType<typeof DerivedScope>,
-          },
-          { key: fieldName },
-        ),
-      ),
+      scopeFields as Record<string, ReturnType<typeof DerivedScope>>,
+      (scopeElement, fieldName) =>
+        ScopeFieldWithNameResource({
+          fieldName,
+          scopeElement,
+        }),
+      [],
     );
 
     return tapMemo(() => {
-      const result = Object.fromEntries(results) as Partial<AssistantApi>;
+      const result = Object.fromEntries(
+        Object.values(results),
+      ) as Partial<AssistantApi>;
 
-      const {
-        on: onCb,
-        subscribe: subCb,
-        flushSync: flushCb,
-      } = callbacksRef.current;
+      const { on: onCb, subscribe: subCb } = callbacksRef.current;
 
       if (onCb) {
         result.on = <TEvent extends AssistantEvent>(
@@ -178,9 +168,8 @@ export const DerivedScopes = resource(
         ) => onCb(selector, callback);
       }
       if (subCb) result.subscribe = (listener) => subCb(listener);
-      if (flushCb) result.flushSync = () => flushCb();
 
       return result;
-    }, [...results]);
+    }, [results]);
   },
 );

package/src/utils/tap-store/index.ts

@@ -2,10 +2,9 @@ export { type Store, asStore } from "./store";
 export { tapApi, type ApiObject } from "./tap-api";
 export {
   DerivedScope,
-  type DerivedScopeConfig,
+  type DerivedConfig,
   type OnCallbackFn,
   type SubscribeCallbackFn,
-  type FlushSyncCallbackFn,
   type SpecialCallbacks,
   type DerivedScopesInput,
 } from "./derived-scopes";

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

@@ -17,22 +17,17 @@ export interface Store<TState> {
    * Subscribe to the store.
    */
   subscribe(listener: () => void): Unsubscribe;
-
-  /**
-   * Synchronously flush all the updates to the store.
-   */
-  flushSync(): void;
 }
 
 export const asStore = resource(
   <TState, TProps>(element: ResourceElement<TState, TProps>): Store<TState> => {
     const resource = tapMemo(
-      () => createResource(element, true),
+      () => createResource(element, { mount: false }),
       [element.type],
     );
 
     tapEffect(() => {
-      resource.updateInput(element.props);
+      resource.render(element);
     });
 
     return resource;

package/src/utils/tap-store/tap-api.ts

@@ -5,33 +5,39 @@ export interface ApiObject {
 }
 
 class ReadonlyApiHandler<TApi extends ApiObject> implements ProxyHandler<TApi> {
-  constructor(private readonly getApi: () => TApi) {}
+  constructor(private readonly ref: tapRef.RefObject<TApi>) {}
 
   get(_: unknown, prop: string | symbol) {
-    return this.getApi()[prop as keyof TApi];
+    return this.ref.current[prop as keyof TApi];
   }
 
   ownKeys(): ArrayLike<string | symbol> {
-    return Object.keys(this.getApi() as object);
+    return Object.keys(this.ref.current as object);
   }
 
   has(_: unknown, prop: string | symbol) {
-    return prop in (this.getApi() as object);
+    return prop in (this.ref.current as object);
   }
 
   getOwnPropertyDescriptor(_: unknown, prop: string | symbol) {
-    return Object.getOwnPropertyDescriptor(this.getApi(), prop);
+    return Object.getOwnPropertyDescriptor(this.ref.current, prop);
   }
 
   set() {
     return false;
   }
+  setPrototypeOf() {
+    return false;
+  }
   defineProperty() {
     return false;
   }
   deleteProperty() {
     return false;
   }
+  preventExtensions(): boolean {
+    return false;
+  }
 }
 
 export const tapApi = <TApi extends ApiObject & { getState: () => any }>(
@@ -46,8 +52,7 @@ export const tapApi = <TApi extends ApiObject & { getState: () => any }>(
   });
 
   const apiProxy = tapMemo(
-    () =>
-      new Proxy<TApi>({} as TApi, new ReadonlyApiHandler(() => ref.current)),
+    () => new Proxy<TApi>({} as TApi, new ReadonlyApiHandler(ref)),
     [],
   );