@assistant-ui/react 0.10.0 → 0.10.2

package/dist/context/react/AttachmentContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttachmentContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/AttachmentContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAIxC,MAAM,MAAM,sBAAsB,GAAG;IACnC,oBAAoB,EAAE,aAAa,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC;CACvE,CAAC;AAEF,eAAO,MAAM,iBAAiB,wDAE7B,CAAC;AAOF,wBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE;IAC7C,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,iBAAiB,CAAC;AACtB,wBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE;IAC7C,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,iBAAiB,GAAG,IAAI,CAAC;AAS7B,wBAAgB,kCAAkC,CAAC,OAAO,CAAC,EAAE;IAC3D,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;AACzC,wBAAgB,kCAAkC,CAAC,OAAO,CAAC,EAAE;IAC3D,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC;AAahD,wBAAgB,gCAAgC,CAAC,OAAO,CAAC,EAAE;IACzD,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,iBAAiB,CAAC,eAAe,CAAC,CAAC;AACvC,wBAAgB,gCAAgC,CAAC,OAAO,CAAC,EAAE;IACzD,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,iBAAiB,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC;AAc9C,wBAAgB,2BAA2B,CAAC,OAAO,CAAC,EAAE;IACpD,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAC;AACjC,wBAAgB,2BAA2B,CAAC,OAAO,CAAC,EAAE;IACpD,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,iBAAiB,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;AAaxC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAkD,CAAC;AAE7E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEvC,CAAC;AACF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAErC,CAAC;AACF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEhC,CAAC"}

package/dist/context/react/AttachmentContext.js

@@ -1,11 +1,13 @@
 "use client";
+
+// src/context/react/AttachmentContext.ts
 import { createContext } from "react";
-import { createContextHook } from "./utils/createContextHook";
-import { createStateHookForRuntime } from "./utils/createStateHookForRuntime";
-const AttachmentContext = createContext(
+import { createContextHook } from "./utils/createContextHook.js";
+import { createStateHookForRuntime } from "./utils/createStateHookForRuntime.js";
+var AttachmentContext = createContext(
   null
 );
-const useAttachmentContext = createContextHook(
+var useAttachmentContext = createContextHook(
   AttachmentContext,
   "a ComposerPrimitive.Attachments or MessagePrimitive.Attachments component"
 );
@@ -41,14 +43,14 @@ function useMessageAttachmentRuntime(options) {
     );
   return attachmentRuntime;
 }
-const useAttachment = createStateHookForRuntime(useAttachmentRuntime);
-const useThreadComposerAttachment = createStateHookForRuntime(
+var useAttachment = createStateHookForRuntime(useAttachmentRuntime);
+var useThreadComposerAttachment = createStateHookForRuntime(
   useThreadComposerAttachmentRuntime
 );
-const useEditComposerAttachment = createStateHookForRuntime(
+var useEditComposerAttachment = createStateHookForRuntime(
   useEditComposerAttachmentRuntime
 );
-const useMessageAttachment = createStateHookForRuntime(
+var useMessageAttachment = createStateHookForRuntime(
   useMessageAttachmentRuntime
 );
 export {

package/dist/context/react/AttachmentContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/context/react/AttachmentContext.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport { ReadonlyStore } from \"../ReadonlyStore\";\nimport { AttachmentRuntime } from \"../../api/AttachmentRuntime\";\nimport { UseBoundStore } from \"zustand\";\nimport { createContextHook } from \"./utils/createContextHook\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\n\nexport type AttachmentContextValue = {\n  useAttachmentRuntime: UseBoundStore<ReadonlyStore<AttachmentRuntime>>;\n};\n\nexport const AttachmentContext = createContext<AttachmentContextValue | null>(\n  null,\n);\n\nconst useAttachmentContext = createContextHook(\n  AttachmentContext,\n  \"a ComposerPrimitive.Attachments or MessagePrimitive.Attachments component\",\n);\n\nexport function useAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime;\nexport function useAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime | null;\nexport function useAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime | null {\n  const attachmentRuntime = useAttachmentContext(options);\n  if (!attachmentRuntime) return null;\n  return attachmentRuntime.useAttachmentRuntime();\n}\n\nexport function useThreadComposerAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime<\"thread-composer\">;\nexport function useThreadComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"thread-composer\"> | null;\nexport function useThreadComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"thread-composer\"> | null {\n  const attachmentRuntime = useAttachmentRuntime(options);\n  if (!attachmentRuntime) return null;\n  if (attachmentRuntime.source !== \"thread-composer\")\n    throw new Error(\n      \"This component must be used within a thread's ComposerPrimitive.Attachments component.\",\n    );\n  return attachmentRuntime as AttachmentRuntime<\"thread-composer\">;\n}\n\nexport function useEditComposerAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime<\"edit-composer\">;\nexport function useEditComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"edit-composer\"> | null;\nexport function useEditComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"edit-composer\"> | null {\n  const attachmentRuntime = useAttachmentRuntime(options);\n  if (!attachmentRuntime) return null;\n  if (attachmentRuntime.source !== \"edit-composer\")\n    throw new Error(\n      \"This component must be used within a message's ComposerPrimitive.Attachments component.\",\n    );\n\n  return attachmentRuntime as AttachmentRuntime<\"edit-composer\">;\n}\n\nexport function useMessageAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime<\"message\">;\nexport function useMessageAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"message\"> | null;\nexport function useMessageAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"message\"> | null {\n  const attachmentRuntime = useAttachmentRuntime(options);\n  if (!attachmentRuntime) return null;\n  if (attachmentRuntime.source !== \"message\")\n    throw new Error(\n      \"This component must be used within a MessagePrimitive.Attachments component.\",\n    );\n  return attachmentRuntime as AttachmentRuntime<\"message\">;\n}\n\nexport const useAttachment = createStateHookForRuntime(useAttachmentRuntime);\n\nexport const useThreadComposerAttachment = createStateHookForRuntime(\n  useThreadComposerAttachmentRuntime,\n);\nexport const useEditComposerAttachment = createStateHookForRuntime(\n  useEditComposerAttachmentRuntime,\n);\nexport const useMessageAttachment = createStateHookForRuntime(\n  useMessageAttachmentRuntime,\n);\n"],"mappings":";AAEA,SAAS,qBAAqB;AAI9B,SAAS,yBAAyB;AAClC,SAAS,iCAAiC;AAMnC,MAAM,oBAAoB;AAAA,EAC/B;AACF;AAEA,MAAM,uBAAuB;AAAA,EAC3B;AAAA,EACA;AACF;AAQO,SAAS,qBAAqB,SAER;AAC3B,QAAM,oBAAoB,qBAAqB,OAAO;AACtD,MAAI,CAAC,kBAAmB,QAAO;AAC/B,SAAO,kBAAkB,qBAAqB;AAChD;AAQO,SAAS,mCAAmC,SAEH;AAC9C,QAAM,oBAAoB,qBAAqB,OAAO;AACtD,MAAI,CAAC,kBAAmB,QAAO;AAC/B,MAAI,kBAAkB,WAAW;AAC/B,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AACF,SAAO;AACT;AAQO,SAAS,iCAAiC,SAEH;AAC5C,QAAM,oBAAoB,qBAAqB,OAAO;AACtD,MAAI,CAAC,kBAAmB,QAAO;AAC/B,MAAI,kBAAkB,WAAW;AAC/B,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAEF,SAAO;AACT;AAQO,SAAS,4BAA4B,SAEJ;AACtC,QAAM,oBAAoB,qBAAqB,OAAO;AACtD,MAAI,CAAC,kBAAmB,QAAO;AAC/B,MAAI,kBAAkB,WAAW;AAC/B,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AACF,SAAO;AACT;AAEO,MAAM,gBAAgB,0BAA0B,oBAAoB;AAEpE,MAAM,8BAA8B;AAAA,EACzC;AACF;AACO,MAAM,4BAA4B;AAAA,EACvC;AACF;AACO,MAAM,uBAAuB;AAAA,EAClC;AACF;","names":[]}
+{"version":3,"sources":["../../../src/context/react/AttachmentContext.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport { ReadonlyStore } from \"../ReadonlyStore\";\nimport { AttachmentRuntime } from \"../../api/AttachmentRuntime\";\nimport { UseBoundStore } from \"zustand\";\nimport { createContextHook } from \"./utils/createContextHook\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\n\nexport type AttachmentContextValue = {\n  useAttachmentRuntime: UseBoundStore<ReadonlyStore<AttachmentRuntime>>;\n};\n\nexport const AttachmentContext = createContext<AttachmentContextValue | null>(\n  null,\n);\n\nconst useAttachmentContext = createContextHook(\n  AttachmentContext,\n  \"a ComposerPrimitive.Attachments or MessagePrimitive.Attachments component\",\n);\n\nexport function useAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime;\nexport function useAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime | null;\nexport function useAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime | null {\n  const attachmentRuntime = useAttachmentContext(options);\n  if (!attachmentRuntime) return null;\n  return attachmentRuntime.useAttachmentRuntime();\n}\n\nexport function useThreadComposerAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime<\"thread-composer\">;\nexport function useThreadComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"thread-composer\"> | null;\nexport function useThreadComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"thread-composer\"> | null {\n  const attachmentRuntime = useAttachmentRuntime(options);\n  if (!attachmentRuntime) return null;\n  if (attachmentRuntime.source !== \"thread-composer\")\n    throw new Error(\n      \"This component must be used within a thread's ComposerPrimitive.Attachments component.\",\n    );\n  return attachmentRuntime as AttachmentRuntime<\"thread-composer\">;\n}\n\nexport function useEditComposerAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime<\"edit-composer\">;\nexport function useEditComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"edit-composer\"> | null;\nexport function useEditComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"edit-composer\"> | null {\n  const attachmentRuntime = useAttachmentRuntime(options);\n  if (!attachmentRuntime) return null;\n  if (attachmentRuntime.source !== \"edit-composer\")\n    throw new Error(\n      \"This component must be used within a message's ComposerPrimitive.Attachments component.\",\n    );\n\n  return attachmentRuntime as AttachmentRuntime<\"edit-composer\">;\n}\n\nexport function useMessageAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime<\"message\">;\nexport function useMessageAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"message\"> | null;\nexport function useMessageAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"message\"> | null {\n  const attachmentRuntime = useAttachmentRuntime(options);\n  if (!attachmentRuntime) return null;\n  if (attachmentRuntime.source !== \"message\")\n    throw new Error(\n      \"This component must be used within a MessagePrimitive.Attachments component.\",\n    );\n  return attachmentRuntime as AttachmentRuntime<\"message\">;\n}\n\nexport const useAttachment = createStateHookForRuntime(useAttachmentRuntime);\n\nexport const useThreadComposerAttachment = createStateHookForRuntime(\n  useThreadComposerAttachmentRuntime,\n);\nexport const useEditComposerAttachment = createStateHookForRuntime(\n  useEditComposerAttachmentRuntime,\n);\nexport const useMessageAttachment = createStateHookForRuntime(\n  useMessageAttachmentRuntime,\n);\n"],"mappings":";;;AAEA,SAAS,qBAAqB;AAI9B,SAAS,yBAAyB;AAClC,SAAS,iCAAiC;AAMnC,IAAM,oBAAoB;AAAA,EAC/B;AACF;AAEA,IAAM,uBAAuB;AAAA,EAC3B;AAAA,EACA;AACF;AAQO,SAAS,qBAAqB,SAER;AAC3B,QAAM,oBAAoB,qBAAqB,OAAO;AACtD,MAAI,CAAC,kBAAmB,QAAO;AAC/B,SAAO,kBAAkB,qBAAqB;AAChD;AAQO,SAAS,mCAAmC,SAEH;AAC9C,QAAM,oBAAoB,qBAAqB,OAAO;AACtD,MAAI,CAAC,kBAAmB,QAAO;AAC/B,MAAI,kBAAkB,WAAW;AAC/B,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AACF,SAAO;AACT;AAQO,SAAS,iCAAiC,SAEH;AAC5C,QAAM,oBAAoB,qBAAqB,OAAO;AACtD,MAAI,CAAC,kBAAmB,QAAO;AAC/B,MAAI,kBAAkB,WAAW;AAC/B,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAEF,SAAO;AACT;AAQO,SAAS,4BAA4B,SAEJ;AACtC,QAAM,oBAAoB,qBAAqB,OAAO;AACtD,MAAI,CAAC,kBAAmB,QAAO;AAC/B,MAAI,kBAAkB,WAAW;AAC/B,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AACF,SAAO;AACT;AAEO,IAAM,gBAAgB,0BAA0B,oBAAoB;AAEpE,IAAM,8BAA8B;AAAA,EACzC;AACF;AACO,IAAM,4BAA4B;AAAA,EACvC;AACF;AACO,IAAM,uBAAuB;AAAA,EAClC;AACF;","names":[]}

package/dist/context/react/ComposerContext.d.ts

@@ -0,0 +1,35 @@
+import { ComposerRuntime } from "../../api/ComposerRuntime";
+export declare function useComposerRuntime(options?: {
+    optional?: false | undefined;
+}): ComposerRuntime;
+export declare function useComposerRuntime(options?: {
+    optional?: boolean | undefined;
+}): ComposerRuntime | null;
+export declare const useComposer: {
+    (): import("../..").ComposerState;
+    <TSelected>(selector: (state: import("../..").ComposerState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../..").ComposerState) => TSelected) | undefined): import("../..").ComposerState | TSelected;
+    (options: {
+        optional?: false | undefined;
+    }): import("../..").ComposerState;
+    (options: {
+        optional?: boolean | undefined;
+    }): import("../..").ComposerState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: import("../..").ComposerState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: import("../..").ComposerState) => TSelected) | undefined;
+    }): import("../..").ComposerState | TSelected;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: import("../..").ComposerState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: import("../..").ComposerState) => TSelected) | undefined;
+    }): import("../..").ComposerState | TSelected | null;
+};
+//# sourceMappingURL=ComposerContext.d.ts.map

package/dist/context/react/ComposerContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComposerContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/ComposerContext.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAG5D,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE;IAC3C,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,eAAe,CAAC;AACpB,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE;IAC3C,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,eAAe,GAAG,IAAI,CAAC;AAW3B,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAC"}

package/dist/context/react/ComposerContext.js

@@ -1,13 +1,15 @@
 "use client";
-import { useMessageRuntime } from "./MessageContext";
-import { useThreadRuntime } from "./ThreadContext";
-import { createStateHookForRuntime } from "./utils/createStateHookForRuntime";
+
+// src/context/react/ComposerContext.ts
+import { useMessageRuntime } from "./MessageContext.js";
+import { useThreadRuntime } from "./ThreadContext.js";
+import { createStateHookForRuntime } from "./utils/createStateHookForRuntime.js";
 function useComposerRuntime(options) {
   const messageRuntime = useMessageRuntime({ optional: true });
   const threadRuntime = useThreadRuntime(options);
   return messageRuntime ? messageRuntime.composer : threadRuntime?.composer ?? null;
 }
-const useComposer = createStateHookForRuntime(useComposerRuntime);
+var useComposer = createStateHookForRuntime(useComposerRuntime);
 export {
   useComposer,
   useComposerRuntime

package/dist/context/react/ComposerContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/context/react/ComposerContext.ts"],"sourcesContent":["\"use client\";\n\nimport { useMessageRuntime } from \"./MessageContext\";\nimport { useThreadRuntime } from \"./ThreadContext\";\nimport { ComposerRuntime } from \"../../api/ComposerRuntime\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\n\nexport function useComposerRuntime(options?: {\n  optional?: false | undefined;\n}): ComposerRuntime;\nexport function useComposerRuntime(options?: {\n  optional?: boolean | undefined;\n}): ComposerRuntime | null;\nexport function useComposerRuntime(options?: {\n  optional?: boolean | undefined;\n}): ComposerRuntime | null {\n  const messageRuntime = useMessageRuntime({ optional: true });\n  const threadRuntime = useThreadRuntime(options);\n  return messageRuntime\n    ? messageRuntime.composer\n    : (threadRuntime?.composer ?? null);\n}\n\nexport const useComposer = createStateHookForRuntime(useComposerRuntime);\n"],"mappings":";AAEA,SAAS,yBAAyB;AAClC,SAAS,wBAAwB;AAEjC,SAAS,iCAAiC;AAQnC,SAAS,mBAAmB,SAER;AACzB,QAAM,iBAAiB,kBAAkB,EAAE,UAAU,KAAK,CAAC;AAC3D,QAAM,gBAAgB,iBAAiB,OAAO;AAC9C,SAAO,iBACH,eAAe,WACd,eAAe,YAAY;AAClC;AAEO,MAAM,cAAc,0BAA0B,kBAAkB;","names":[]}
+{"version":3,"sources":["../../../src/context/react/ComposerContext.ts"],"sourcesContent":["\"use client\";\n\nimport { useMessageRuntime } from \"./MessageContext\";\nimport { useThreadRuntime } from \"./ThreadContext\";\nimport { ComposerRuntime } from \"../../api/ComposerRuntime\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\n\nexport function useComposerRuntime(options?: {\n  optional?: false | undefined;\n}): ComposerRuntime;\nexport function useComposerRuntime(options?: {\n  optional?: boolean | undefined;\n}): ComposerRuntime | null;\nexport function useComposerRuntime(options?: {\n  optional?: boolean | undefined;\n}): ComposerRuntime | null {\n  const messageRuntime = useMessageRuntime({ optional: true });\n  const threadRuntime = useThreadRuntime(options);\n  return messageRuntime\n    ? messageRuntime.composer\n    : (threadRuntime?.composer ?? null);\n}\n\nexport const useComposer = createStateHookForRuntime(useComposerRuntime);\n"],"mappings":";;;AAEA,SAAS,yBAAyB;AAClC,SAAS,wBAAwB;AAEjC,SAAS,iCAAiC;AAQnC,SAAS,mBAAmB,SAER;AACzB,QAAM,iBAAiB,kBAAkB,EAAE,UAAU,KAAK,CAAC;AAC3D,QAAM,gBAAgB,iBAAiB,OAAO;AAC9C,SAAO,iBACH,eAAe,WACd,eAAe,YAAY;AAClC;AAEO,IAAM,cAAc,0BAA0B,kBAAkB;","names":[]}

package/dist/context/react/ContentPartContext.d.ts

@@ -0,0 +1,41 @@
+import { ReadonlyStore } from "../ReadonlyStore";
+import { UseBoundStore } from "zustand";
+import { ContentPartRuntime } from "../../api/ContentPartRuntime";
+export type ContentPartContextValue = {
+    useContentPartRuntime: UseBoundStore<ReadonlyStore<ContentPartRuntime>>;
+};
+export declare const ContentPartContext: import("react").Context<ContentPartContextValue | null>;
+export declare function useContentPartRuntime(options?: {
+    optional?: false | undefined;
+}): ContentPartRuntime;
+export declare function useContentPartRuntime(options?: {
+    optional?: boolean | undefined;
+}): ContentPartRuntime | null;
+export declare const useContentPart: {
+    (): import("../..").ContentPartState;
+    <TSelected>(selector: (state: import("../..").ContentPartState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../..").ContentPartState) => TSelected) | undefined): import("../..").ContentPartState | TSelected;
+    (options: {
+        optional?: false | undefined;
+    }): import("../..").ContentPartState;
+    (options: {
+        optional?: boolean | undefined;
+    }): import("../..").ContentPartState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: import("../..").ContentPartState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: import("../..").ContentPartState) => TSelected) | undefined;
+    }): import("../..").ContentPartState | TSelected;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: import("../..").ContentPartState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: import("../..").ContentPartState) => TSelected) | undefined;
+    }): import("../..").ContentPartState | TSelected | null;
+};
+//# sourceMappingURL=ContentPartContext.d.ts.map

package/dist/context/react/ContentPartContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContentPartContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/ContentPartContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAGlE,MAAM,MAAM,uBAAuB,GAAG;IACpC,qBAAqB,EAAE,aAAa,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC;CACzE,CAAC;AAEF,eAAO,MAAM,kBAAkB,yDAE9B,CAAC;AAOF,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE;IAC9C,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,kBAAkB,CAAC;AACvB,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE;IAC9C,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,kBAAkB,GAAG,IAAI,CAAC;AAS9B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmD,CAAC"}

package/dist/context/react/ContentPartContext.js

@@ -1,11 +1,13 @@
 "use client";
+
+// src/context/react/ContentPartContext.ts
 import { createContext } from "react";
-import { createContextHook } from "./utils/createContextHook";
-import { createStateHookForRuntime } from "./utils/createStateHookForRuntime";
-const ContentPartContext = createContext(
+import { createContextHook } from "./utils/createContextHook.js";
+import { createStateHookForRuntime } from "./utils/createStateHookForRuntime.js";
+var ContentPartContext = createContext(
   null
 );
-const useContentPartContext = createContextHook(
+var useContentPartContext = createContextHook(
   ContentPartContext,
   "a component passed to <MessagePrimitive.Content components={...}>"
 );
@@ -14,7 +16,7 @@ function useContentPartRuntime(options) {
   if (!context) return null;
   return context.useContentPartRuntime();
 }
-const useContentPart = createStateHookForRuntime(useContentPartRuntime);
+var useContentPart = createStateHookForRuntime(useContentPartRuntime);
 export {
   ContentPartContext,
   useContentPart,

package/dist/context/react/ContentPartContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/context/react/ContentPartContext.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport { ReadonlyStore } from \"../ReadonlyStore\";\nimport { createContextHook } from \"./utils/createContextHook\";\nimport { UseBoundStore } from \"zustand\";\nimport { ContentPartRuntime } from \"../../api/ContentPartRuntime\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\n\nexport type ContentPartContextValue = {\n  useContentPartRuntime: UseBoundStore<ReadonlyStore<ContentPartRuntime>>;\n};\n\nexport const ContentPartContext = createContext<ContentPartContextValue | null>(\n  null,\n);\n\nconst useContentPartContext = createContextHook(\n  ContentPartContext,\n  \"a component passed to <MessagePrimitive.Content components={...}>\",\n);\n\nexport function useContentPartRuntime(options?: {\n  optional?: false | undefined;\n}): ContentPartRuntime;\nexport function useContentPartRuntime(options?: {\n  optional?: boolean | undefined;\n}): ContentPartRuntime | null;\nexport function useContentPartRuntime(options?: {\n  optional?: boolean | undefined;\n}) {\n  const context = useContentPartContext(options);\n  if (!context) return null;\n  return context.useContentPartRuntime();\n}\n\nexport const useContentPart = createStateHookForRuntime(useContentPartRuntime);\n"],"mappings":";AAEA,SAAS,qBAAqB;AAE9B,SAAS,yBAAyB;AAGlC,SAAS,iCAAiC;AAMnC,MAAM,qBAAqB;AAAA,EAChC;AACF;AAEA,MAAM,wBAAwB;AAAA,EAC5B;AAAA,EACA;AACF;AAQO,SAAS,sBAAsB,SAEnC;AACD,QAAM,UAAU,sBAAsB,OAAO;AAC7C,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,QAAQ,sBAAsB;AACvC;AAEO,MAAM,iBAAiB,0BAA0B,qBAAqB;","names":[]}
+{"version":3,"sources":["../../../src/context/react/ContentPartContext.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport { ReadonlyStore } from \"../ReadonlyStore\";\nimport { createContextHook } from \"./utils/createContextHook\";\nimport { UseBoundStore } from \"zustand\";\nimport { ContentPartRuntime } from \"../../api/ContentPartRuntime\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\n\nexport type ContentPartContextValue = {\n  useContentPartRuntime: UseBoundStore<ReadonlyStore<ContentPartRuntime>>;\n};\n\nexport const ContentPartContext = createContext<ContentPartContextValue | null>(\n  null,\n);\n\nconst useContentPartContext = createContextHook(\n  ContentPartContext,\n  \"a component passed to <MessagePrimitive.Content components={...}>\",\n);\n\nexport function useContentPartRuntime(options?: {\n  optional?: false | undefined;\n}): ContentPartRuntime;\nexport function useContentPartRuntime(options?: {\n  optional?: boolean | undefined;\n}): ContentPartRuntime | null;\nexport function useContentPartRuntime(options?: {\n  optional?: boolean | undefined;\n}) {\n  const context = useContentPartContext(options);\n  if (!context) return null;\n  return context.useContentPartRuntime();\n}\n\nexport const useContentPart = createStateHookForRuntime(useContentPartRuntime);\n"],"mappings":";;;AAEA,SAAS,qBAAqB;AAE9B,SAAS,yBAAyB;AAGlC,SAAS,iCAAiC;AAMnC,IAAM,qBAAqB;AAAA,EAChC;AACF;AAEA,IAAM,wBAAwB;AAAA,EAC5B;AAAA,EACA;AACF;AAQO,SAAS,sBAAsB,SAEnC;AACD,QAAM,UAAU,sBAAsB,OAAO;AAC7C,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,QAAQ,sBAAsB;AACvC;AAEO,IAAM,iBAAiB,0BAA0B,qBAAqB;","names":[]}

package/dist/context/react/MessageContext.d.ts

@@ -0,0 +1,86 @@
+import { ReadonlyStore } from "../ReadonlyStore";
+import { MessageUtilsState } from "../stores/MessageUtils";
+import { UseBoundStore } from "zustand";
+import { MessageRuntime } from "../../api/MessageRuntime";
+export type MessageContextValue = {
+    useMessageRuntime: UseBoundStore<ReadonlyStore<MessageRuntime>>;
+    useMessageUtils: UseBoundStore<ReadonlyStore<MessageUtilsState>>;
+};
+export declare const MessageContext: import("react").Context<MessageContextValue | null>;
+export declare function useMessageRuntime(options?: {
+    optional?: false | undefined;
+}): MessageRuntime;
+export declare function useMessageRuntime(options?: {
+    optional?: boolean | undefined;
+}): MessageRuntime | null;
+export declare const useMessage: {
+    (): import("../..").MessageState;
+    <TSelected>(selector: (state: import("../..").MessageState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../..").MessageState) => TSelected) | undefined): import("../..").MessageState | TSelected;
+    (options: {
+        optional?: false | undefined;
+    }): import("../..").MessageState;
+    (options: {
+        optional?: boolean | undefined;
+    }): import("../..").MessageState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: import("../..").MessageState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: import("../..").MessageState) => TSelected) | undefined;
+    }): import("../..").MessageState | TSelected;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: import("../..").MessageState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: import("../..").MessageState) => TSelected) | undefined;
+    }): import("../..").MessageState | TSelected | null;
+};
+export declare const useEditComposer: {
+    (): import("../..").EditComposerState;
+    <TSelected>(selector: (state: import("../..").EditComposerState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../..").EditComposerState) => TSelected) | undefined): import("../..").EditComposerState | TSelected;
+    (options: {
+        optional?: false | undefined;
+    }): import("../..").EditComposerState;
+    (options: {
+        optional?: boolean | undefined;
+    }): import("../..").EditComposerState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: import("../..").EditComposerState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: import("../..").EditComposerState) => TSelected) | undefined;
+    }): import("../..").EditComposerState | TSelected;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: import("../..").EditComposerState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: import("../..").EditComposerState) => TSelected) | undefined;
+    }): import("../..").EditComposerState | TSelected | null;
+};
+export declare const useMessageUtils: {
+    (): MessageUtilsState;
+    <TSelected>(selector: (state: MessageUtilsState) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): MessageUtilsState | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: MessageUtilsState) => TSelected;
+    }): TSelected | null;
+}, useMessageUtilsStore: {
+    (): ReadonlyStore<MessageUtilsState>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<MessageUtilsState> | null;
+};
+//# sourceMappingURL=MessageContext.d.ts.map

package/dist/context/react/MessageContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/MessageContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAG3D,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAI1D,MAAM,MAAM,mBAAmB,GAAG;IAChC,iBAAiB,EAAE,aAAa,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC;IAChE,eAAe,EAAE,aAAa,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC;CAClE,CAAC;AAEF,eAAO,MAAM,cAAc,qDAAkD,CAAC;AAO9E,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE;IAC1C,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,cAAc,CAAC;AACnB,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE;IAC1C,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,cAAc,GAAG,IAAI,CAAC;AAS1B,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+C,CAAC;AAKvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CAE3B,CAAC;AAEF,eAAO,MAAQ,eAAe;;;;;;;;;;GAAE,oBAAoB;;;;;CAGnD,CAAC"}

package/dist/context/react/MessageContext.js

@@ -1,10 +1,12 @@
 "use client";
+
+// src/context/react/MessageContext.ts
 import { createContext } from "react";
-import { createContextHook } from "./utils/createContextHook";
-import { createContextStoreHook } from "./utils/createContextStoreHook";
-import { createStateHookForRuntime } from "./utils/createStateHookForRuntime";
-const MessageContext = createContext(null);
-const useMessageContext = createContextHook(
+import { createContextHook } from "./utils/createContextHook.js";
+import { createContextStoreHook } from "./utils/createContextStoreHook.js";
+import { createStateHookForRuntime } from "./utils/createStateHookForRuntime.js";
+var MessageContext = createContext(null);
+var useMessageContext = createContextHook(
   MessageContext,
   "a component passed to <ThreadPrimitive.Messages components={...} />"
 );
@@ -13,12 +15,12 @@ function useMessageRuntime(options) {
   if (!context) return null;
   return context.useMessageRuntime();
 }
-const useMessage = createStateHookForRuntime(useMessageRuntime);
-const useEditComposerRuntime = (opt) => useMessageRuntime(opt)?.composer ?? null;
-const useEditComposer = createStateHookForRuntime(
+var useMessage = createStateHookForRuntime(useMessageRuntime);
+var useEditComposerRuntime = (opt) => useMessageRuntime(opt)?.composer ?? null;
+var useEditComposer = createStateHookForRuntime(
   useEditComposerRuntime
 );
-const { useMessageUtils, useMessageUtilsStore } = createContextStoreHook(
+var { useMessageUtils, useMessageUtilsStore } = createContextStoreHook(
   useMessageContext,
   "useMessageUtils"
 );

package/dist/context/react/MessageContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/context/react/MessageContext.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport { ReadonlyStore } from \"../ReadonlyStore\";\nimport { MessageUtilsState } from \"../stores/MessageUtils\";\nimport { createContextHook } from \"./utils/createContextHook\";\nimport { createContextStoreHook } from \"./utils/createContextStoreHook\";\nimport { UseBoundStore } from \"zustand\";\nimport { MessageRuntime } from \"../../api/MessageRuntime\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\nimport { EditComposerRuntime } from \"../../api\";\n\nexport type MessageContextValue = {\n  useMessageRuntime: UseBoundStore<ReadonlyStore<MessageRuntime>>;\n  useMessageUtils: UseBoundStore<ReadonlyStore<MessageUtilsState>>;\n};\n\nexport const MessageContext = createContext<MessageContextValue | null>(null);\n\nconst useMessageContext = createContextHook(\n  MessageContext,\n  \"a component passed to <ThreadPrimitive.Messages components={...} />\",\n);\n\nexport function useMessageRuntime(options?: {\n  optional?: false | undefined;\n}): MessageRuntime;\nexport function useMessageRuntime(options?: {\n  optional?: boolean | undefined;\n}): MessageRuntime | null;\nexport function useMessageRuntime(options?: {\n  optional?: boolean | undefined;\n}) {\n  const context = useMessageContext(options);\n  if (!context) return null;\n  return context.useMessageRuntime();\n}\n\nexport const useMessage = createStateHookForRuntime(useMessageRuntime);\n\nconst useEditComposerRuntime = (opt: {\n  optional: boolean | undefined;\n}): EditComposerRuntime | null => useMessageRuntime(opt)?.composer ?? null;\nexport const useEditComposer = createStateHookForRuntime(\n  useEditComposerRuntime,\n);\n\nexport const { useMessageUtils, useMessageUtilsStore } = createContextStoreHook(\n  useMessageContext,\n  \"useMessageUtils\",\n);\n"],"mappings":";AAEA,SAAS,qBAAqB;AAG9B,SAAS,yBAAyB;AAClC,SAAS,8BAA8B;AAGvC,SAAS,iCAAiC;AAQnC,MAAM,iBAAiB,cAA0C,IAAI;AAE5E,MAAM,oBAAoB;AAAA,EACxB;AAAA,EACA;AACF;AAQO,SAAS,kBAAkB,SAE/B;AACD,QAAM,UAAU,kBAAkB,OAAO;AACzC,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,QAAQ,kBAAkB;AACnC;AAEO,MAAM,aAAa,0BAA0B,iBAAiB;AAErE,MAAM,yBAAyB,CAAC,QAEE,kBAAkB,GAAG,GAAG,YAAY;AAC/D,MAAM,kBAAkB;AAAA,EAC7B;AACF;AAEO,MAAM,EAAE,iBAAiB,qBAAqB,IAAI;AAAA,EACvD;AAAA,EACA;AACF;","names":[]}
+{"version":3,"sources":["../../../src/context/react/MessageContext.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport { ReadonlyStore } from \"../ReadonlyStore\";\nimport { MessageUtilsState } from \"../stores/MessageUtils\";\nimport { createContextHook } from \"./utils/createContextHook\";\nimport { createContextStoreHook } from \"./utils/createContextStoreHook\";\nimport { UseBoundStore } from \"zustand\";\nimport { MessageRuntime } from \"../../api/MessageRuntime\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\nimport { EditComposerRuntime } from \"../../api\";\n\nexport type MessageContextValue = {\n  useMessageRuntime: UseBoundStore<ReadonlyStore<MessageRuntime>>;\n  useMessageUtils: UseBoundStore<ReadonlyStore<MessageUtilsState>>;\n};\n\nexport const MessageContext = createContext<MessageContextValue | null>(null);\n\nconst useMessageContext = createContextHook(\n  MessageContext,\n  \"a component passed to <ThreadPrimitive.Messages components={...} />\",\n);\n\nexport function useMessageRuntime(options?: {\n  optional?: false | undefined;\n}): MessageRuntime;\nexport function useMessageRuntime(options?: {\n  optional?: boolean | undefined;\n}): MessageRuntime | null;\nexport function useMessageRuntime(options?: {\n  optional?: boolean | undefined;\n}) {\n  const context = useMessageContext(options);\n  if (!context) return null;\n  return context.useMessageRuntime();\n}\n\nexport const useMessage = createStateHookForRuntime(useMessageRuntime);\n\nconst useEditComposerRuntime = (opt: {\n  optional: boolean | undefined;\n}): EditComposerRuntime | null => useMessageRuntime(opt)?.composer ?? null;\nexport const useEditComposer = createStateHookForRuntime(\n  useEditComposerRuntime,\n);\n\nexport const { useMessageUtils, useMessageUtilsStore } = createContextStoreHook(\n  useMessageContext,\n  \"useMessageUtils\",\n);\n"],"mappings":";;;AAEA,SAAS,qBAAqB;AAG9B,SAAS,yBAAyB;AAClC,SAAS,8BAA8B;AAGvC,SAAS,iCAAiC;AAQnC,IAAM,iBAAiB,cAA0C,IAAI;AAE5E,IAAM,oBAAoB;AAAA,EACxB;AAAA,EACA;AACF;AAQO,SAAS,kBAAkB,SAE/B;AACD,QAAM,UAAU,kBAAkB,OAAO;AACzC,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,QAAQ,kBAAkB;AACnC;AAEO,IAAM,aAAa,0BAA0B,iBAAiB;AAErE,IAAM,yBAAyB,CAAC,QAEE,kBAAkB,GAAG,GAAG,YAAY;AAC/D,IAAM,kBAAkB;AAAA,EAC7B;AACF;AAEO,IAAM,EAAE,iBAAiB,qBAAqB,IAAI;AAAA,EACvD;AAAA,EACA;AACF;","names":[]}

package/dist/context/react/ThreadContext.d.ts

@@ -0,0 +1,75 @@
+import { ReadonlyStore } from "../ReadonlyStore";
+import { UseBoundStore } from "zustand";
+import { ThreadRuntime } from "../../api/ThreadRuntime";
+import { ModelContext } from "../../model-context";
+export type ThreadContextValue = {
+    useThreadRuntime: UseBoundStore<ReadonlyStore<ThreadRuntime>>;
+};
+export declare const ThreadContext: import("react").Context<ThreadContextValue | null>;
+export declare function useThreadRuntime(options?: {
+    optional?: false | undefined;
+}): ThreadRuntime;
+export declare function useThreadRuntime(options?: {
+    optional?: boolean | undefined;
+}): ThreadRuntime | null;
+export declare const useThread: {
+    (): import("../..").ThreadState;
+    <TSelected>(selector: (state: import("../..").ThreadState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../..").ThreadState) => TSelected) | undefined): import("../..").ThreadState | TSelected;
+    (options: {
+        optional?: false | undefined;
+    }): import("../..").ThreadState;
+    (options: {
+        optional?: boolean | undefined;
+    }): import("../..").ThreadState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: import("../..").ThreadState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: import("../..").ThreadState) => TSelected) | undefined;
+    }): import("../..").ThreadState | TSelected;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: import("../..").ThreadState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: import("../..").ThreadState) => TSelected) | undefined;
+    }): import("../..").ThreadState | TSelected | null;
+};
+export declare const useThreadComposer: {
+    (): import("../..").ThreadComposerState;
+    <TSelected>(selector: (state: import("../..").ThreadComposerState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../..").ThreadComposerState) => TSelected) | undefined): import("../..").ThreadComposerState | TSelected;
+    (options: {
+        optional?: false | undefined;
+    }): import("../..").ThreadComposerState;
+    (options: {
+        optional?: boolean | undefined;
+    }): import("../..").ThreadComposerState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: import("../..").ThreadComposerState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: import("../..").ThreadComposerState) => TSelected) | undefined;
+    }): import("../..").ThreadComposerState | TSelected;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: import("../..").ThreadComposerState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: import("../..").ThreadComposerState) => TSelected) | undefined;
+    }): import("../..").ThreadComposerState | TSelected | null;
+};
+export declare function useThreadModelContext(options?: {
+    optional?: false | undefined;
+}): ModelContext;
+export declare function useThreadModelContext(options?: {
+    optional?: boolean | undefined;
+}): ModelContext | null;
+//# sourceMappingURL=ThreadContext.d.ts.map

package/dist/context/react/ThreadContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/ThreadContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAInD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gBAAgB,EAAE,aAAa,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC;CAC/D,CAAC;AAEF,eAAO,MAAM,aAAa,oDAAiD,CAAC;AAO5E,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE;IACzC,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,aAAa,CAAC;AAClB,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE;IACzC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,aAAa,GAAG,IAAI,CAAC;AAOzB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;CAA8C,CAAC;AAKrE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;CAE7B,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE;IAC9C,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,YAAY,CAAC;AACjB,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE;IAC9C,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,YAAY,GAAG,IAAI,CAAC"}

package/dist/context/react/ThreadContext.js

@@ -1,9 +1,11 @@
 "use client";
+
+// src/context/react/ThreadContext.ts
 import { createContext, useEffect, useState } from "react";
-import { createContextHook } from "./utils/createContextHook";
-import { createStateHookForRuntime } from "./utils/createStateHookForRuntime";
-const ThreadContext = createContext(null);
-const useThreadContext = createContextHook(
+import { createContextHook } from "./utils/createContextHook.js";
+import { createStateHookForRuntime } from "./utils/createStateHookForRuntime.js";
+var ThreadContext = createContext(null);
+var useThreadContext = createContextHook(
   ThreadContext,
   "AssistantRuntimeProvider"
 );
@@ -12,9 +14,9 @@ function useThreadRuntime(options) {
   if (!context) return null;
   return context.useThreadRuntime();
 }
-const useThread = createStateHookForRuntime(useThreadRuntime);
-const useThreadComposerRuntime = (opt) => useThreadRuntime(opt)?.composer ?? null;
-const useThreadComposer = createStateHookForRuntime(
+var useThread = createStateHookForRuntime(useThreadRuntime);
+var useThreadComposerRuntime = (opt) => useThreadRuntime(opt)?.composer ?? null;
+var useThreadComposer = createStateHookForRuntime(
   useThreadComposerRuntime
 );
 function useThreadModelContext(options) {

package/dist/context/react/ThreadContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/context/react/ThreadContext.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext, useEffect, useState } from \"react\";\nimport { ReadonlyStore } from \"../ReadonlyStore\";\nimport { UseBoundStore } from \"zustand\";\nimport { createContextHook } from \"./utils/createContextHook\";\nimport { ThreadRuntime } from \"../../api/ThreadRuntime\";\nimport { ModelContext } from \"../../model-context\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\nimport { ThreadComposerRuntime } from \"../../api\";\n\nexport type ThreadContextValue = {\n  useThreadRuntime: UseBoundStore<ReadonlyStore<ThreadRuntime>>;\n};\n\nexport const ThreadContext = createContext<ThreadContextValue | null>(null);\n\nconst useThreadContext = createContextHook(\n  ThreadContext,\n  \"AssistantRuntimeProvider\",\n);\n\nexport function useThreadRuntime(options?: {\n  optional?: false | undefined;\n}): ThreadRuntime;\nexport function useThreadRuntime(options?: {\n  optional?: boolean | undefined;\n}): ThreadRuntime | null;\nexport function useThreadRuntime(options?: { optional?: boolean | undefined }) {\n  const context = useThreadContext(options);\n  if (!context) return null;\n  return context.useThreadRuntime();\n}\n\nexport const useThread = createStateHookForRuntime(useThreadRuntime);\n\nconst useThreadComposerRuntime = (opt: {\n  optional: boolean | undefined;\n}): ThreadComposerRuntime | null => useThreadRuntime(opt)?.composer ?? null;\nexport const useThreadComposer = createStateHookForRuntime(\n  useThreadComposerRuntime,\n);\n\nexport function useThreadModelContext(options?: {\n  optional?: false | undefined;\n}): ModelContext;\nexport function useThreadModelContext(options?: {\n  optional?: boolean | undefined;\n}): ModelContext | null;\nexport function useThreadModelContext(options?: {\n  optional?: boolean | undefined;\n}): ModelContext | null {\n  const [, rerender] = useState({});\n\n  const runtime = useThreadRuntime(options);\n  useEffect(() => {\n    return runtime?.unstable_on(\"model-context-update\", () => rerender({}));\n  }, [runtime]);\n\n  if (!runtime) return null;\n  return runtime?.getModelContext();\n}\n"],"mappings":";AAEA,SAAS,eAAe,WAAW,gBAAgB;AAGnD,SAAS,yBAAyB;AAGlC,SAAS,iCAAiC;AAOnC,MAAM,gBAAgB,cAAyC,IAAI;AAE1E,MAAM,mBAAmB;AAAA,EACvB;AAAA,EACA;AACF;AAQO,SAAS,iBAAiB,SAA8C;AAC7E,QAAM,UAAU,iBAAiB,OAAO;AACxC,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,QAAQ,iBAAiB;AAClC;AAEO,MAAM,YAAY,0BAA0B,gBAAgB;AAEnE,MAAM,2BAA2B,CAAC,QAEE,iBAAiB,GAAG,GAAG,YAAY;AAChE,MAAM,oBAAoB;AAAA,EAC/B;AACF;AAQO,SAAS,sBAAsB,SAEd;AACtB,QAAM,CAAC,EAAE,QAAQ,IAAI,SAAS,CAAC,CAAC;AAEhC,QAAM,UAAU,iBAAiB,OAAO;AACxC,YAAU,MAAM;AACd,WAAO,SAAS,YAAY,wBAAwB,MAAM,SAAS,CAAC,CAAC,CAAC;AAAA,EACxE,GAAG,CAAC,OAAO,CAAC;AAEZ,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,SAAS,gBAAgB;AAClC;","names":[]}
+{"version":3,"sources":["../../../src/context/react/ThreadContext.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext, useEffect, useState } from \"react\";\nimport { ReadonlyStore } from \"../ReadonlyStore\";\nimport { UseBoundStore } from \"zustand\";\nimport { createContextHook } from \"./utils/createContextHook\";\nimport { ThreadRuntime } from \"../../api/ThreadRuntime\";\nimport { ModelContext } from \"../../model-context\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\nimport { ThreadComposerRuntime } from \"../../api\";\n\nexport type ThreadContextValue = {\n  useThreadRuntime: UseBoundStore<ReadonlyStore<ThreadRuntime>>;\n};\n\nexport const ThreadContext = createContext<ThreadContextValue | null>(null);\n\nconst useThreadContext = createContextHook(\n  ThreadContext,\n  \"AssistantRuntimeProvider\",\n);\n\nexport function useThreadRuntime(options?: {\n  optional?: false | undefined;\n}): ThreadRuntime;\nexport function useThreadRuntime(options?: {\n  optional?: boolean | undefined;\n}): ThreadRuntime | null;\nexport function useThreadRuntime(options?: { optional?: boolean | undefined }) {\n  const context = useThreadContext(options);\n  if (!context) return null;\n  return context.useThreadRuntime();\n}\n\nexport const useThread = createStateHookForRuntime(useThreadRuntime);\n\nconst useThreadComposerRuntime = (opt: {\n  optional: boolean | undefined;\n}): ThreadComposerRuntime | null => useThreadRuntime(opt)?.composer ?? null;\nexport const useThreadComposer = createStateHookForRuntime(\n  useThreadComposerRuntime,\n);\n\nexport function useThreadModelContext(options?: {\n  optional?: false | undefined;\n}): ModelContext;\nexport function useThreadModelContext(options?: {\n  optional?: boolean | undefined;\n}): ModelContext | null;\nexport function useThreadModelContext(options?: {\n  optional?: boolean | undefined;\n}): ModelContext | null {\n  const [, rerender] = useState({});\n\n  const runtime = useThreadRuntime(options);\n  useEffect(() => {\n    return runtime?.unstable_on(\"model-context-update\", () => rerender({}));\n  }, [runtime]);\n\n  if (!runtime) return null;\n  return runtime?.getModelContext();\n}\n"],"mappings":";;;AAEA,SAAS,eAAe,WAAW,gBAAgB;AAGnD,SAAS,yBAAyB;AAGlC,SAAS,iCAAiC;AAOnC,IAAM,gBAAgB,cAAyC,IAAI;AAE1E,IAAM,mBAAmB;AAAA,EACvB;AAAA,EACA;AACF;AAQO,SAAS,iBAAiB,SAA8C;AAC7E,QAAM,UAAU,iBAAiB,OAAO;AACxC,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,QAAQ,iBAAiB;AAClC;AAEO,IAAM,YAAY,0BAA0B,gBAAgB;AAEnE,IAAM,2BAA2B,CAAC,QAEE,iBAAiB,GAAG,GAAG,YAAY;AAChE,IAAM,oBAAoB;AAAA,EAC/B;AACF;AAQO,SAAS,sBAAsB,SAEd;AACtB,QAAM,CAAC,EAAE,QAAQ,IAAI,SAAS,CAAC,CAAC;AAEhC,QAAM,UAAU,iBAAiB,OAAO;AACxC,YAAU,MAAM;AACd,WAAO,SAAS,YAAY,wBAAwB,MAAM,SAAS,CAAC,CAAC,CAAC;AAAA,EACxE,GAAG,CAAC,OAAO,CAAC;AAEZ,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,SAAS,gBAAgB;AAClC;","names":[]}

package/dist/context/react/ThreadListItemContext.d.ts

@@ -0,0 +1,41 @@
+import { ReadonlyStore } from "../ReadonlyStore";
+import { UseBoundStore } from "zustand";
+import { ThreadListItemRuntime } from "../../api/ThreadListItemRuntime";
+export type ThreadListItemContextValue = {
+    useThreadListItemRuntime: UseBoundStore<ReadonlyStore<ThreadListItemRuntime>>;
+};
+export declare const ThreadListItemContext: import("react").Context<ThreadListItemContextValue | null>;
+export declare function useThreadListItemRuntime(options?: {
+    optional?: false | undefined;
+}): ThreadListItemRuntime;
+export declare function useThreadListItemRuntime(options?: {
+    optional?: boolean | undefined;
+}): ThreadListItemRuntime | null;
+export declare const useThreadListItem: {
+    (): import("../..").ThreadListItemState;
+    <TSelected>(selector: (state: import("../..").ThreadListItemState) => TSelected): TSelected;
+    <TSelected>(selector: ((state: import("../..").ThreadListItemState) => TSelected) | undefined): import("../..").ThreadListItemState | TSelected;
+    (options: {
+        optional?: false | undefined;
+    }): import("../..").ThreadListItemState;
+    (options: {
+        optional?: boolean | undefined;
+    }): import("../..").ThreadListItemState | null;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: (state: import("../..").ThreadListItemState) => TSelected;
+    }): TSelected;
+    <TSelected>(options: {
+        optional?: false | undefined;
+        selector: ((state: import("../..").ThreadListItemState) => TSelected) | undefined;
+    }): import("../..").ThreadListItemState | TSelected;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: (state: import("../..").ThreadListItemState) => TSelected;
+    }): TSelected | null;
+    <TSelected>(options: {
+        optional?: boolean | undefined;
+        selector: ((state: import("../..").ThreadListItemState) => TSelected) | undefined;
+    }): import("../..").ThreadListItemState | TSelected | null;
+};
+//# sourceMappingURL=ThreadListItemContext.d.ts.map

package/dist/context/react/ThreadListItemContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadListItemContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/ThreadListItemContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAGxE,MAAM,MAAM,0BAA0B,GAAG;IACvC,wBAAwB,EAAE,aAAa,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC,CAAC;CAC/E,CAAC;AAEF,eAAO,MAAM,qBAAqB,4DACsB,CAAC;AAOzD,wBAAgB,wBAAwB,CAAC,OAAO,CAAC,EAAE;IACjD,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;CAC9B,GAAG,qBAAqB,CAAC;AAC1B,wBAAgB,wBAAwB,CAAC,OAAO,CAAC,EAAE;IACjD,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,GAAG,qBAAqB,GAAG,IAAI,CAAC;AASjC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;CAE7B,CAAC"}

package/dist/context/react/ThreadListItemContext.js

@@ -1,9 +1,11 @@
 "use client";
+
+// src/context/react/ThreadListItemContext.ts
 import { createContext } from "react";
-import { createContextHook } from "./utils/createContextHook";
-import { createStateHookForRuntime } from "./utils/createStateHookForRuntime";
-const ThreadListItemContext = createContext(null);
-const useThreadListItemContext = createContextHook(
+import { createContextHook } from "./utils/createContextHook.js";
+import { createStateHookForRuntime } from "./utils/createStateHookForRuntime.js";
+var ThreadListItemContext = createContext(null);
+var useThreadListItemContext = createContextHook(
   ThreadListItemContext,
   "a component passed to <ThreadListPrimitive.Items components={...}>"
 );
@@ -12,7 +14,7 @@ function useThreadListItemRuntime(options) {
   if (!context) return null;
   return context.useThreadListItemRuntime();
 }
-const useThreadListItem = createStateHookForRuntime(
+var useThreadListItem = createStateHookForRuntime(
   useThreadListItemRuntime
 );
 export {

package/dist/context/react/ThreadListItemContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/context/react/ThreadListItemContext.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport { ReadonlyStore } from \"../ReadonlyStore\";\nimport { createContextHook } from \"./utils/createContextHook\";\nimport { UseBoundStore } from \"zustand\";\nimport { ThreadListItemRuntime } from \"../../api/ThreadListItemRuntime\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\n\nexport type ThreadListItemContextValue = {\n  useThreadListItemRuntime: UseBoundStore<ReadonlyStore<ThreadListItemRuntime>>;\n};\n\nexport const ThreadListItemContext =\n  createContext<ThreadListItemContextValue | null>(null);\n\nconst useThreadListItemContext = createContextHook(\n  ThreadListItemContext,\n  \"a component passed to <ThreadListPrimitive.Items components={...}>\",\n);\n\nexport function useThreadListItemRuntime(options?: {\n  optional?: false | undefined;\n}): ThreadListItemRuntime;\nexport function useThreadListItemRuntime(options?: {\n  optional?: boolean | undefined;\n}): ThreadListItemRuntime | null;\nexport function useThreadListItemRuntime(options?: {\n  optional?: boolean | undefined;\n}) {\n  const context = useThreadListItemContext(options);\n  if (!context) return null;\n  return context.useThreadListItemRuntime();\n}\n\nexport const useThreadListItem = createStateHookForRuntime(\n  useThreadListItemRuntime,\n);\n"],"mappings":";AAEA,SAAS,qBAAqB;AAE9B,SAAS,yBAAyB;AAGlC,SAAS,iCAAiC;AAMnC,MAAM,wBACX,cAAiD,IAAI;AAEvD,MAAM,2BAA2B;AAAA,EAC/B;AAAA,EACA;AACF;AAQO,SAAS,yBAAyB,SAEtC;AACD,QAAM,UAAU,yBAAyB,OAAO;AAChD,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,QAAQ,yBAAyB;AAC1C;AAEO,MAAM,oBAAoB;AAAA,EAC/B;AACF;","names":[]}
+{"version":3,"sources":["../../../src/context/react/ThreadListItemContext.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport { ReadonlyStore } from \"../ReadonlyStore\";\nimport { createContextHook } from \"./utils/createContextHook\";\nimport { UseBoundStore } from \"zustand\";\nimport { ThreadListItemRuntime } from \"../../api/ThreadListItemRuntime\";\nimport { createStateHookForRuntime } from \"./utils/createStateHookForRuntime\";\n\nexport type ThreadListItemContextValue = {\n  useThreadListItemRuntime: UseBoundStore<ReadonlyStore<ThreadListItemRuntime>>;\n};\n\nexport const ThreadListItemContext =\n  createContext<ThreadListItemContextValue | null>(null);\n\nconst useThreadListItemContext = createContextHook(\n  ThreadListItemContext,\n  \"a component passed to <ThreadListPrimitive.Items components={...}>\",\n);\n\nexport function useThreadListItemRuntime(options?: {\n  optional?: false | undefined;\n}): ThreadListItemRuntime;\nexport function useThreadListItemRuntime(options?: {\n  optional?: boolean | undefined;\n}): ThreadListItemRuntime | null;\nexport function useThreadListItemRuntime(options?: {\n  optional?: boolean | undefined;\n}) {\n  const context = useThreadListItemContext(options);\n  if (!context) return null;\n  return context.useThreadListItemRuntime();\n}\n\nexport const useThreadListItem = createStateHookForRuntime(\n  useThreadListItemRuntime,\n);\n"],"mappings":";;;AAEA,SAAS,qBAAqB;AAE9B,SAAS,yBAAyB;AAGlC,SAAS,iCAAiC;AAMnC,IAAM,wBACX,cAAiD,IAAI;AAEvD,IAAM,2BAA2B;AAAA,EAC/B;AAAA,EACA;AACF;AAQO,SAAS,yBAAyB,SAEtC;AACD,QAAM,UAAU,yBAAyB,OAAO;AAChD,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,QAAQ,yBAAyB;AAC1C;AAEO,IAAM,oBAAoB;AAAA,EAC/B;AACF;","names":[]}

package/dist/context/react/ThreadViewportContext.d.ts

@@ -0,0 +1,24 @@
+import { ReadonlyStore } from "../ReadonlyStore";
+import { UseBoundStore } from "zustand";
+import { ThreadViewportState } from "../stores";
+export type ThreadViewportContextValue = {
+    useThreadViewport: UseBoundStore<ReadonlyStore<ThreadViewportState>>;
+};
+export declare const ThreadViewportContext: import("react").Context<ThreadViewportContextValue | null>;
+export declare const useThreadViewport: {
+    (): ThreadViewportState;
+    <TSelected>(selector: (state: ThreadViewportState) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): ThreadViewportState | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: ThreadViewportState) => TSelected;
+    }): TSelected | null;
+}, useThreadViewportStore: {
+    (): ReadonlyStore<ThreadViewportState>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<ThreadViewportState> | null;
+};
+//# sourceMappingURL=ThreadViewportContext.d.ts.map

package/dist/context/react/ThreadViewportContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadViewportContext.d.ts","sourceRoot":"","sources":["../../../src/context/react/ThreadViewportContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEhD,MAAM,MAAM,0BAA0B,GAAG;IACvC,iBAAiB,EAAE,aAAa,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC,CAAC;CACtE,CAAC;AAEF,eAAO,MAAM,qBAAqB,4DACsB,CAAC;AAOzD,eAAO,MAAQ,iBAAiB;;;;;;;;;;GAAE,sBAAsB;;;;;CACe,CAAC"}