@assistant-ui/react 0.11.0 → 0.11.1

package/src/legacy-runtime/runtime/ThreadListRuntime.ts

@@ -0,0 +1,226 @@
+import { LazyMemoizeSubject } from "./subscribable/LazyMemoizeSubject";
+import { ThreadListRuntimeCore } from "../runtime-cores/core/ThreadListRuntimeCore";
+import { Unsubscribe } from "../../types";
+import {
+  ThreadListItemRuntime,
+  ThreadListItemRuntimeImpl,
+  ThreadListItemState,
+} from "./ThreadListItemRuntime";
+import { SKIP_UPDATE } from "./subscribable/SKIP_UPDATE";
+import { ShallowMemoizeSubject } from "./subscribable/ShallowMemoizeSubject";
+import {
+  ThreadListItemRuntimeBinding,
+  ThreadRuntime,
+  ThreadRuntimeCoreBinding,
+  ThreadRuntimeImpl,
+} from "./ThreadRuntime";
+import { NestedSubscriptionSubject } from "./subscribable/NestedSubscriptionSubject";
+
+export type ThreadListState = {
+  readonly mainThreadId: string;
+  readonly newThread: string | undefined;
+  readonly threads: readonly string[];
+  readonly archivedThreads: readonly string[];
+  readonly isLoading: boolean;
+  readonly threadItems: Readonly<
+    Record<string, Omit<ThreadListItemState, "isMain" | "threadId">>
+  >;
+};
+
+export type ThreadListRuntime = {
+  getState(): ThreadListState;
+
+  subscribe(callback: () => void): Unsubscribe;
+
+  readonly main: ThreadRuntime;
+  getById(threadId: string): ThreadRuntime;
+
+  readonly mainItem: ThreadListItemRuntime;
+  getItemById(threadId: string): ThreadListItemRuntime;
+  getItemByIndex(idx: number): ThreadListItemRuntime;
+  getArchivedItemByIndex(idx: number): ThreadListItemRuntime;
+
+  switchToThread(threadId: string): Promise<void>;
+  switchToNewThread(): Promise<void>;
+};
+
+const getThreadListState = (
+  threadList: ThreadListRuntimeCore,
+): ThreadListState => {
+  return {
+    mainThreadId: threadList.mainThreadId,
+    newThread: threadList.newThreadId,
+    threads: threadList.threadIds,
+    archivedThreads: threadList.archivedThreadIds,
+    isLoading: threadList.isLoading,
+    threadItems: threadList.threadData,
+  };
+};
+
+const getThreadListItemState = (
+  threadList: ThreadListRuntimeCore,
+  threadId: string | undefined,
+): ThreadListItemState | SKIP_UPDATE => {
+  if (threadId === undefined) return SKIP_UPDATE;
+
+  const threadData = threadList.getItemById(threadId);
+  if (!threadData) return SKIP_UPDATE;
+  return {
+    id: threadData.id,
+    threadId: threadData.id, // TODO remove in 0.8.0
+    remoteId: threadData.remoteId,
+    externalId: threadData.externalId,
+    title: threadData.title,
+    status: threadData.status,
+    isMain: threadData.id === threadList.mainThreadId,
+  };
+};
+
+export type ThreadListRuntimeCoreBinding = ThreadListRuntimeCore;
+
+export class ThreadListRuntimeImpl implements ThreadListRuntime {
+  private _getState;
+  constructor(
+    private _core: ThreadListRuntimeCoreBinding,
+    private _runtimeFactory: new (
+      binding: ThreadRuntimeCoreBinding,
+      threadListItemBinding: ThreadListItemRuntimeBinding,
+    ) => ThreadRuntime = ThreadRuntimeImpl,
+  ) {
+    const stateBinding = new LazyMemoizeSubject({
+      path: {},
+      getState: () => getThreadListState(_core),
+      subscribe: (callback) => _core.subscribe(callback),
+    });
+
+    this._getState = stateBinding.getState.bind(stateBinding);
+
+    this._mainThreadListItemRuntime = new ThreadListItemRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ref: `threadItems[main]`,
+          threadSelector: { type: "main" },
+        },
+        getState: () => {
+          return getThreadListItemState(this._core, this._core.mainThreadId);
+        },
+        subscribe: (callback) => this._core.subscribe(callback),
+      }),
+      this._core,
+    );
+
+    this.main = new _runtimeFactory(
+      new NestedSubscriptionSubject({
+        path: {
+          ref: "threads.main",
+          threadSelector: { type: "main" },
+        },
+        getState: () => _core.getMainThreadRuntimeCore(),
+        subscribe: (callback) => _core.subscribe(callback),
+      }),
+      this._mainThreadListItemRuntime, // TODO capture "main" threadListItem from context around useLocalRuntime / useExternalStoreRuntime
+    );
+
+    this.__internal_bindMethods();
+  }
+
+  protected __internal_bindMethods() {
+    this.switchToThread = this.switchToThread.bind(this);
+    this.switchToNewThread = this.switchToNewThread.bind(this);
+    this.getState = this.getState.bind(this);
+    this.subscribe = this.subscribe.bind(this);
+    this.getById = this.getById.bind(this);
+    this.getItemById = this.getItemById.bind(this);
+    this.getItemByIndex = this.getItemByIndex.bind(this);
+    this.getArchivedItemByIndex = this.getArchivedItemByIndex.bind(this);
+  }
+
+  public switchToThread(threadId: string): Promise<void> {
+    return this._core.switchToThread(threadId);
+  }
+
+  public switchToNewThread(): Promise<void> {
+    return this._core.switchToNewThread();
+  }
+
+  public getState(): ThreadListState {
+    return this._getState();
+  }
+
+  public subscribe(callback: () => void): Unsubscribe {
+    return this._core.subscribe(callback);
+  }
+
+  private _mainThreadListItemRuntime;
+
+  public readonly main: ThreadRuntime;
+
+  public get mainItem() {
+    return this._mainThreadListItemRuntime;
+  }
+
+  public getById(threadId: string) {
+    return new this._runtimeFactory(
+      new NestedSubscriptionSubject({
+        path: {
+          ref: "threads[threadId=" + JSON.stringify(threadId) + "]",
+          threadSelector: { type: "threadId", threadId },
+        },
+        getState: () => this._core.getThreadRuntimeCore(threadId),
+        subscribe: (callback) => this._core.subscribe(callback),
+      }),
+      this.mainItem, // TODO capture "main" threadListItem from context around useLocalRuntime / useExternalStoreRuntime
+    );
+  }
+
+  public getItemByIndex(idx: number) {
+    return new ThreadListItemRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ref: `threadItems[${idx}]`,
+          threadSelector: { type: "index", index: idx },
+        },
+        getState: () => {
+          return getThreadListItemState(this._core, this._core.threadIds[idx]);
+        },
+        subscribe: (callback) => this._core.subscribe(callback),
+      }),
+      this._core,
+    );
+  }
+
+  public getArchivedItemByIndex(idx: number) {
+    return new ThreadListItemRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ref: `archivedThreadItems[${idx}]`,
+          threadSelector: { type: "archiveIndex", index: idx },
+        },
+        getState: () => {
+          return getThreadListItemState(
+            this._core,
+            this._core.archivedThreadIds[idx],
+          );
+        },
+        subscribe: (callback) => this._core.subscribe(callback),
+      }),
+      this._core,
+    );
+  }
+
+  public getItemById(threadId: string) {
+    return new ThreadListItemRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ref: `threadItems[threadId=${threadId}]`,
+          threadSelector: { type: "threadId", threadId },
+        },
+        getState: () => {
+          return getThreadListItemState(this._core, threadId);
+        },
+        subscribe: (callback) => this._core.subscribe(callback),
+      }),
+      this._core,
+    );
+  }
+}