@aparte/svelte 0.2.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1344 @@
+import { SvelteComponent, init, safe_not_equal, compute_slots, ensure_array_like, create_slot, detach, transition_out, transition_in, group_outros, check_outros, update_keyed_each, outro_and_destroy_block, set_custom_element_data, update_slot_base, get_all_dirty_from_scope, get_slot_changes, attr, toggle_class, insert, append, listen, element, space, binding_callbacks, empty, noop, set_style } from "svelte/internal";
+import "svelte/internal/disclose-version";
+import { createEventDispatcher, onMount, onDestroy, tick } from "svelte";
+import { AparteChatHost, AparteClient, ConversationManager, AparteConfig, DEFAULT_UI_EVENTS, applyElementProps } from "@aparte/core";
+import { writable, derived } from "svelte/store";
+const get_footer_right_slot_changes = (dirty) => ({});
+const get_footer_right_slot_context = (ctx) => ({});
+const get_footer_center_slot_changes = (dirty) => ({});
+const get_footer_center_slot_context = (ctx) => ({});
+const get_footer_left_slot_changes = (dirty) => ({});
+const get_footer_left_slot_context = (ctx) => ({});
+const get_composer_slot_changes = (dirty) => ({});
+const get_composer_slot_context = (ctx) => ({});
+const get_above_composer_slot_changes = (dirty) => ({});
+const get_above_composer_slot_context = (ctx) => ({});
+function get_each_context(ctx, list, i) {
+  const child_ctx = ctx.slice();
+  child_ctx[51] = list[i];
+  return child_ctx;
+}
+const get_bubble_slot_changes = (dirty) => ({
+  message: dirty[0] & /*internalMessages*/
+  16
+});
+const get_bubble_slot_context = (ctx) => ({ message: (
+  /*m*/
+  ctx[51]
+) });
+const get_empty_state_slot_changes = (dirty) => ({});
+const get_empty_state_slot_context = (ctx) => ({});
+function create_if_block_1(ctx) {
+  let current;
+  const empty_state_slot_template = (
+    /*#slots*/
+    ctx[43]["empty-state"]
+  );
+  const empty_state_slot = create_slot(
+    empty_state_slot_template,
+    ctx,
+    /*$$scope*/
+    ctx[42],
+    get_empty_state_slot_context
+  );
+  return {
+    c() {
+      if (empty_state_slot) empty_state_slot.c();
+    },
+    m(target, anchor) {
+      if (empty_state_slot) {
+        empty_state_slot.m(target, anchor);
+      }
+      current = true;
+    },
+    p(ctx2, dirty) {
+      if (empty_state_slot) {
+        if (empty_state_slot.p && (!current || dirty[1] & /*$$scope*/
+        2048)) {
+          update_slot_base(
+            empty_state_slot,
+            empty_state_slot_template,
+            ctx2,
+            /*$$scope*/
+            ctx2[42],
+            !current ? get_all_dirty_from_scope(
+              /*$$scope*/
+              ctx2[42]
+            ) : get_slot_changes(
+              empty_state_slot_template,
+              /*$$scope*/
+              ctx2[42],
+              dirty,
+              get_empty_state_slot_changes
+            ),
+            get_empty_state_slot_context
+          );
+        }
+      }
+    },
+    i(local) {
+      if (current) return;
+      transition_in(empty_state_slot, local);
+      current = true;
+    },
+    o(local) {
+      transition_out(empty_state_slot, local);
+      current = false;
+    },
+    d(detaching) {
+      if (empty_state_slot) empty_state_slot.d(detaching);
+    }
+  };
+}
+function fallback_block_1(ctx) {
+  let aparte_chat_bubble;
+  let aparte_chat_bubble_message_id_value;
+  let aparte_chat_bubble_data_role_value;
+  let aparte_chat_bubble_timestamp_value;
+  let aparte_chat_bubble_content_value;
+  let aparte_chat_bubble_streaming_value;
+  return {
+    c() {
+      aparte_chat_bubble = element("aparte-chat-bubble");
+      set_custom_element_data(aparte_chat_bubble, "message-id", aparte_chat_bubble_message_id_value = /*m*/
+      ctx[51].id);
+      set_custom_element_data(aparte_chat_bubble, "data-role", aparte_chat_bubble_data_role_value = /*m*/
+      ctx[51].role);
+      set_custom_element_data(aparte_chat_bubble, "timestamp", aparte_chat_bubble_timestamp_value = /*m*/
+      ctx[51].timestamp);
+      set_custom_element_data(aparte_chat_bubble, "content", aparte_chat_bubble_content_value = /*m*/
+      ctx[51].content);
+      set_custom_element_data(aparte_chat_bubble, "streaming", aparte_chat_bubble_streaming_value = /*m*/
+      ctx[51].status === "streaming" || /*m*/
+      ctx[51].status === "pending" ? "" : null);
+    },
+    m(target, anchor) {
+      insert(target, aparte_chat_bubble, anchor);
+    },
+    p(ctx2, dirty) {
+      if (dirty[0] & /*internalMessages*/
+      16 && aparte_chat_bubble_message_id_value !== (aparte_chat_bubble_message_id_value = /*m*/
+      ctx2[51].id)) {
+        set_custom_element_data(aparte_chat_bubble, "message-id", aparte_chat_bubble_message_id_value);
+      }
+      if (dirty[0] & /*internalMessages*/
+      16 && aparte_chat_bubble_data_role_value !== (aparte_chat_bubble_data_role_value = /*m*/
+      ctx2[51].role)) {
+        set_custom_element_data(aparte_chat_bubble, "data-role", aparte_chat_bubble_data_role_value);
+      }
+      if (dirty[0] & /*internalMessages*/
+      16 && aparte_chat_bubble_timestamp_value !== (aparte_chat_bubble_timestamp_value = /*m*/
+      ctx2[51].timestamp)) {
+        set_custom_element_data(aparte_chat_bubble, "timestamp", aparte_chat_bubble_timestamp_value);
+      }
+      if (dirty[0] & /*internalMessages*/
+      16 && aparte_chat_bubble_content_value !== (aparte_chat_bubble_content_value = /*m*/
+      ctx2[51].content)) {
+        set_custom_element_data(aparte_chat_bubble, "content", aparte_chat_bubble_content_value);
+      }
+      if (dirty[0] & /*internalMessages*/
+      16 && aparte_chat_bubble_streaming_value !== (aparte_chat_bubble_streaming_value = /*m*/
+      ctx2[51].status === "streaming" || /*m*/
+      ctx2[51].status === "pending" ? "" : null)) {
+        set_custom_element_data(aparte_chat_bubble, "streaming", aparte_chat_bubble_streaming_value);
+      }
+    },
+    d(detaching) {
+      if (detaching) {
+        detach(aparte_chat_bubble);
+      }
+    }
+  };
+}
+function create_each_block(key_1, ctx) {
+  let first;
+  let current;
+  const bubble_slot_template = (
+    /*#slots*/
+    ctx[43].bubble
+  );
+  const bubble_slot = create_slot(
+    bubble_slot_template,
+    ctx,
+    /*$$scope*/
+    ctx[42],
+    get_bubble_slot_context
+  );
+  const bubble_slot_or_fallback = bubble_slot || fallback_block_1(ctx);
+  return {
+    key: key_1,
+    first: null,
+    c() {
+      first = empty();
+      if (bubble_slot_or_fallback) bubble_slot_or_fallback.c();
+      this.first = first;
+    },
+    m(target, anchor) {
+      insert(target, first, anchor);
+      if (bubble_slot_or_fallback) {
+        bubble_slot_or_fallback.m(target, anchor);
+      }
+      current = true;
+    },
+    p(new_ctx, dirty) {
+      ctx = new_ctx;
+      if (bubble_slot) {
+        if (bubble_slot.p && (!current || dirty[0] & /*internalMessages*/
+        16 | dirty[1] & /*$$scope*/
+        2048)) {
+          update_slot_base(
+            bubble_slot,
+            bubble_slot_template,
+            ctx,
+            /*$$scope*/
+            ctx[42],
+            !current ? get_all_dirty_from_scope(
+              /*$$scope*/
+              ctx[42]
+            ) : get_slot_changes(
+              bubble_slot_template,
+              /*$$scope*/
+              ctx[42],
+              dirty,
+              get_bubble_slot_changes
+            ),
+            get_bubble_slot_context
+          );
+        }
+      } else {
+        if (bubble_slot_or_fallback && bubble_slot_or_fallback.p && (!current || dirty[0] & /*internalMessages*/
+        16)) {
+          bubble_slot_or_fallback.p(ctx, !current ? [-1, -1] : dirty);
+        }
+      }
+    },
+    i(local) {
+      if (current) return;
+      transition_in(bubble_slot_or_fallback, local);
+      current = true;
+    },
+    o(local) {
+      transition_out(bubble_slot_or_fallback, local);
+      current = false;
+    },
+    d(detaching) {
+      if (detaching) {
+        detach(first);
+      }
+      if (bubble_slot_or_fallback) bubble_slot_or_fallback.d(detaching);
+    }
+  };
+}
+function create_if_block(ctx) {
+  let div;
+  let t0;
+  let t1;
+  let current;
+  const footer_left_slot_template = (
+    /*#slots*/
+    ctx[43]["footer-left"]
+  );
+  const footer_left_slot = create_slot(
+    footer_left_slot_template,
+    ctx,
+    /*$$scope*/
+    ctx[42],
+    get_footer_left_slot_context
+  );
+  const footer_center_slot_template = (
+    /*#slots*/
+    ctx[43]["footer-center"]
+  );
+  const footer_center_slot = create_slot(
+    footer_center_slot_template,
+    ctx,
+    /*$$scope*/
+    ctx[42],
+    get_footer_center_slot_context
+  );
+  const footer_right_slot_template = (
+    /*#slots*/
+    ctx[43]["footer-right"]
+  );
+  const footer_right_slot = create_slot(
+    footer_right_slot_template,
+    ctx,
+    /*$$scope*/
+    ctx[42],
+    get_footer_right_slot_context
+  );
+  return {
+    c() {
+      div = element("div");
+      if (footer_left_slot) footer_left_slot.c();
+      t0 = space();
+      if (footer_center_slot) footer_center_slot.c();
+      t1 = space();
+      if (footer_right_slot) footer_right_slot.c();
+      attr(div, "class", "aparte-composer-footer");
+    },
+    m(target, anchor) {
+      insert(target, div, anchor);
+      if (footer_left_slot) {
+        footer_left_slot.m(div, null);
+      }
+      append(div, t0);
+      if (footer_center_slot) {
+        footer_center_slot.m(div, null);
+      }
+      append(div, t1);
+      if (footer_right_slot) {
+        footer_right_slot.m(div, null);
+      }
+      current = true;
+    },
+    p(ctx2, dirty) {
+      if (footer_left_slot) {
+        if (footer_left_slot.p && (!current || dirty[1] & /*$$scope*/
+        2048)) {
+          update_slot_base(
+            footer_left_slot,
+            footer_left_slot_template,
+            ctx2,
+            /*$$scope*/
+            ctx2[42],
+            !current ? get_all_dirty_from_scope(
+              /*$$scope*/
+              ctx2[42]
+            ) : get_slot_changes(
+              footer_left_slot_template,
+              /*$$scope*/
+              ctx2[42],
+              dirty,
+              get_footer_left_slot_changes
+            ),
+            get_footer_left_slot_context
+          );
+        }
+      }
+      if (footer_center_slot) {
+        if (footer_center_slot.p && (!current || dirty[1] & /*$$scope*/
+        2048)) {
+          update_slot_base(
+            footer_center_slot,
+            footer_center_slot_template,
+            ctx2,
+            /*$$scope*/
+            ctx2[42],
+            !current ? get_all_dirty_from_scope(
+              /*$$scope*/
+              ctx2[42]
+            ) : get_slot_changes(
+              footer_center_slot_template,
+              /*$$scope*/
+              ctx2[42],
+              dirty,
+              get_footer_center_slot_changes
+            ),
+            get_footer_center_slot_context
+          );
+        }
+      }
+      if (footer_right_slot) {
+        if (footer_right_slot.p && (!current || dirty[1] & /*$$scope*/
+        2048)) {
+          update_slot_base(
+            footer_right_slot,
+            footer_right_slot_template,
+            ctx2,
+            /*$$scope*/
+            ctx2[42],
+            !current ? get_all_dirty_from_scope(
+              /*$$scope*/
+              ctx2[42]
+            ) : get_slot_changes(
+              footer_right_slot_template,
+              /*$$scope*/
+              ctx2[42],
+              dirty,
+              get_footer_right_slot_changes
+            ),
+            get_footer_right_slot_context
+          );
+        }
+      }
+    },
+    i(local) {
+      if (current) return;
+      transition_in(footer_left_slot, local);
+      transition_in(footer_center_slot, local);
+      transition_in(footer_right_slot, local);
+      current = true;
+    },
+    o(local) {
+      transition_out(footer_left_slot, local);
+      transition_out(footer_center_slot, local);
+      transition_out(footer_right_slot, local);
+      current = false;
+    },
+    d(detaching) {
+      if (detaching) {
+        detach(div);
+      }
+      if (footer_left_slot) footer_left_slot.d(detaching);
+      if (footer_center_slot) footer_center_slot.d(detaching);
+      if (footer_right_slot) footer_right_slot.d(detaching);
+    }
+  };
+}
+function fallback_block(ctx) {
+  let div1;
+  let aparte_composer_attachments;
+  let t0;
+  let div0;
+  let t3;
+  let current;
+  let if_block = (
+    /*$$slots*/
+    (ctx[9]["footer-left"] || /*$$slots*/
+    ctx[9]["footer-center"] || /*$$slots*/
+    ctx[9]["footer-right"]) && create_if_block(ctx)
+  );
+  return {
+    c() {
+      div1 = element("div");
+      aparte_composer_attachments = element("aparte-composer-attachments");
+      t0 = space();
+      div0 = element("div");
+      div0.innerHTML = `<aparte-composer-add-attachment></aparte-composer-add-attachment> <aparte-composer-input></aparte-composer-input> <aparte-composer-send></aparte-composer-send>`;
+      t3 = space();
+      if (if_block) if_block.c();
+      attr(div0, "class", "aparte-composer-row");
+      attr(div1, "class", "aparte-composer-shell");
+    },
+    m(target, anchor) {
+      insert(target, div1, anchor);
+      append(div1, aparte_composer_attachments);
+      append(div1, t0);
+      append(div1, div0);
+      append(div1, t3);
+      if (if_block) if_block.m(div1, null);
+      current = true;
+    },
+    p(ctx2, dirty) {
+      if (
+        /*$$slots*/
+        ctx2[9]["footer-left"] || /*$$slots*/
+        ctx2[9]["footer-center"] || /*$$slots*/
+        ctx2[9]["footer-right"]
+      ) {
+        if (if_block) {
+          if_block.p(ctx2, dirty);
+          if (dirty[0] & /*$$slots*/
+          512) {
+            transition_in(if_block, 1);
+          }
+        } else {
+          if_block = create_if_block(ctx2);
+          if_block.c();
+          transition_in(if_block, 1);
+          if_block.m(div1, null);
+        }
+      } else if (if_block) {
+        group_outros();
+        transition_out(if_block, 1, 1, () => {
+          if_block = null;
+        });
+        check_outros();
+      }
+    },
+    i(local) {
+      if (current) return;
+      transition_in(if_block);
+      current = true;
+    },
+    o(local) {
+      transition_out(if_block);
+      current = false;
+    },
+    d(detaching) {
+      if (detaching) {
+        detach(div1);
+      }
+      if (if_block) if_block.d();
+    }
+  };
+}
+function create_fragment$1(ctx) {
+  let div;
+  let aparte_chat_viewport;
+  let t0;
+  let each_blocks = [];
+  let each_1_lookup = /* @__PURE__ */ new Map();
+  let t1;
+  let aparte_chat_status;
+  let aparte_chat_status_visible_value;
+  let t2;
+  let t3;
+  let aparte_composer;
+  let div_data_aparte_empty_value;
+  let current;
+  let mounted;
+  let dispose;
+  let if_block = (
+    /*internalMessages*/
+    ctx[4].length === 0 && create_if_block_1(ctx)
+  );
+  let each_value = ensure_array_like(
+    /*internalMessages*/
+    ctx[4]
+  );
+  const get_key = (ctx2) => (
+    /*m*/
+    ctx2[51].id
+  );
+  for (let i = 0; i < each_value.length; i += 1) {
+    let child_ctx = get_each_context(ctx, each_value, i);
+    let key = get_key(child_ctx);
+    each_1_lookup.set(key, each_blocks[i] = create_each_block(key, child_ctx));
+  }
+  const above_composer_slot_template = (
+    /*#slots*/
+    ctx[43]["above-composer"]
+  );
+  const above_composer_slot = create_slot(
+    above_composer_slot_template,
+    ctx,
+    /*$$scope*/
+    ctx[42],
+    get_above_composer_slot_context
+  );
+  const composer_slot_template = (
+    /*#slots*/
+    ctx[43].composer
+  );
+  const composer_slot = create_slot(
+    composer_slot_template,
+    ctx,
+    /*$$scope*/
+    ctx[42],
+    get_composer_slot_context
+  );
+  const composer_slot_or_fallback = composer_slot || fallback_block(ctx);
+  return {
+    c() {
+      div = element("div");
+      aparte_chat_viewport = element("aparte-chat-viewport");
+      if (if_block) if_block.c();
+      t0 = space();
+      for (let i = 0; i < each_blocks.length; i += 1) {
+        each_blocks[i].c();
+      }
+      t1 = space();
+      aparte_chat_status = element("aparte-chat-status");
+      t2 = space();
+      if (above_composer_slot) above_composer_slot.c();
+      t3 = space();
+      aparte_composer = element("aparte-composer");
+      if (composer_slot_or_fallback) composer_slot_or_fallback.c();
+      set_custom_element_data(aparte_chat_status, "visible", aparte_chat_status_visible_value = /*typingActive*/
+      ctx[7] ? "" : null);
+      set_custom_element_data(
+        aparte_chat_status,
+        "text",
+        /*typingText*/
+        ctx[0]
+      );
+      set_custom_element_data(aparte_chat_viewport, "framework-managed", "");
+      attr(div, "class", "aparte-chat-container");
+      attr(div, "data-aparte-chat", "");
+      attr(div, "data-aparte-empty", div_data_aparte_empty_value = /*centerWhenEmpty*/
+      ctx[1] && /*internalMessages*/
+      ctx[4].length === 0 ? "" : null);
+      attr(
+        div,
+        "id",
+        /*hostId*/
+        ctx[2]
+      );
+      toggle_class(
+        div,
+        "aparte-chat-container--auto-center",
+        /*centerWhenEmpty*/
+        ctx[1]
+      );
+    },
+    m(target, anchor) {
+      insert(target, div, anchor);
+      append(div, aparte_chat_viewport);
+      if (if_block) if_block.m(aparte_chat_viewport, null);
+      append(aparte_chat_viewport, t0);
+      for (let i = 0; i < each_blocks.length; i += 1) {
+        if (each_blocks[i]) {
+          each_blocks[i].m(aparte_chat_viewport, null);
+        }
+      }
+      append(aparte_chat_viewport, t1);
+      append(aparte_chat_viewport, aparte_chat_status);
+      ctx[44](aparte_chat_viewport);
+      append(div, t2);
+      if (above_composer_slot) {
+        above_composer_slot.m(div, null);
+      }
+      append(div, t3);
+      append(div, aparte_composer);
+      if (composer_slot_or_fallback) {
+        composer_slot_or_fallback.m(aparte_composer, null);
+      }
+      ctx[45](aparte_composer);
+      ctx[46](div);
+      current = true;
+      if (!mounted) {
+        dispose = listen(
+          aparte_composer,
+          "aparte-send",
+          /*handleSend*/
+          ctx[8]
+        );
+        mounted = true;
+      }
+    },
+    p(ctx2, dirty) {
+      if (
+        /*internalMessages*/
+        ctx2[4].length === 0
+      ) {
+        if (if_block) {
+          if_block.p(ctx2, dirty);
+          if (dirty[0] & /*internalMessages*/
+          16) {
+            transition_in(if_block, 1);
+          }
+        } else {
+          if_block = create_if_block_1(ctx2);
+          if_block.c();
+          transition_in(if_block, 1);
+          if_block.m(aparte_chat_viewport, t0);
+        }
+      } else if (if_block) {
+        group_outros();
+        transition_out(if_block, 1, 1, () => {
+          if_block = null;
+        });
+        check_outros();
+      }
+      if (dirty[0] & /*internalMessages*/
+      16 | dirty[1] & /*$$scope*/
+      2048) {
+        each_value = ensure_array_like(
+          /*internalMessages*/
+          ctx2[4]
+        );
+        group_outros();
+        each_blocks = update_keyed_each(each_blocks, dirty, get_key, 1, ctx2, each_value, each_1_lookup, aparte_chat_viewport, outro_and_destroy_block, create_each_block, t1, get_each_context);
+        check_outros();
+      }
+      if (!current || dirty[0] & /*typingActive*/
+      128 && aparte_chat_status_visible_value !== (aparte_chat_status_visible_value = /*typingActive*/
+      ctx2[7] ? "" : null)) {
+        set_custom_element_data(aparte_chat_status, "visible", aparte_chat_status_visible_value);
+      }
+      if (!current || dirty[0] & /*typingText*/
+      1) {
+        set_custom_element_data(
+          aparte_chat_status,
+          "text",
+          /*typingText*/
+          ctx2[0]
+        );
+      }
+      if (above_composer_slot) {
+        if (above_composer_slot.p && (!current || dirty[1] & /*$$scope*/
+        2048)) {
+          update_slot_base(
+            above_composer_slot,
+            above_composer_slot_template,
+            ctx2,
+            /*$$scope*/
+            ctx2[42],
+            !current ? get_all_dirty_from_scope(
+              /*$$scope*/
+              ctx2[42]
+            ) : get_slot_changes(
+              above_composer_slot_template,
+              /*$$scope*/
+              ctx2[42],
+              dirty,
+              get_above_composer_slot_changes
+            ),
+            get_above_composer_slot_context
+          );
+        }
+      }
+      if (composer_slot) {
+        if (composer_slot.p && (!current || dirty[1] & /*$$scope*/
+        2048)) {
+          update_slot_base(
+            composer_slot,
+            composer_slot_template,
+            ctx2,
+            /*$$scope*/
+            ctx2[42],
+            !current ? get_all_dirty_from_scope(
+              /*$$scope*/
+              ctx2[42]
+            ) : get_slot_changes(
+              composer_slot_template,
+              /*$$scope*/
+              ctx2[42],
+              dirty,
+              get_composer_slot_changes
+            ),
+            get_composer_slot_context
+          );
+        }
+      } else {
+        if (composer_slot_or_fallback && composer_slot_or_fallback.p && (!current || dirty[0] & /*$$slots*/
+        512 | dirty[1] & /*$$scope*/
+        2048)) {
+          composer_slot_or_fallback.p(ctx2, !current ? [-1, -1] : dirty);
+        }
+      }
+      if (!current || dirty[0] & /*centerWhenEmpty, internalMessages*/
+      18 && div_data_aparte_empty_value !== (div_data_aparte_empty_value = /*centerWhenEmpty*/
+      ctx2[1] && /*internalMessages*/
+      ctx2[4].length === 0 ? "" : null)) {
+        attr(div, "data-aparte-empty", div_data_aparte_empty_value);
+      }
+      if (!current || dirty[0] & /*hostId*/
+      4) {
+        attr(
+          div,
+          "id",
+          /*hostId*/
+          ctx2[2]
+        );
+      }
+      if (!current || dirty[0] & /*centerWhenEmpty*/
+      2) {
+        toggle_class(
+          div,
+          "aparte-chat-container--auto-center",
+          /*centerWhenEmpty*/
+          ctx2[1]
+        );
+      }
+    },
+    i(local) {
+      if (current) return;
+      transition_in(if_block);
+      for (let i = 0; i < each_value.length; i += 1) {
+        transition_in(each_blocks[i]);
+      }
+      transition_in(above_composer_slot, local);
+      transition_in(composer_slot_or_fallback, local);
+      current = true;
+    },
+    o(local) {
+      transition_out(if_block);
+      for (let i = 0; i < each_blocks.length; i += 1) {
+        transition_out(each_blocks[i]);
+      }
+      transition_out(above_composer_slot, local);
+      transition_out(composer_slot_or_fallback, local);
+      current = false;
+    },
+    d(detaching) {
+      if (detaching) {
+        detach(div);
+      }
+      if (if_block) if_block.d();
+      for (let i = 0; i < each_blocks.length; i += 1) {
+        each_blocks[i].d();
+      }
+      ctx[44](null);
+      if (above_composer_slot) above_composer_slot.d(detaching);
+      if (composer_slot_or_fallback) composer_slot_or_fallback.d(detaching);
+      ctx[45](null);
+      ctx[46](null);
+      mounted = false;
+      dispose();
+    }
+  };
+}
+function toggleAttr(el, name, on, value) {
+  if (on) el.setAttribute(name, value);
+  else el.removeAttribute(name);
+}
+function instance$1($$self, $$props, $$invalidate) {
+  let { $$slots: slots = {}, $$scope } = $$props;
+  const $$slots = compute_slots(slots);
+  let { messages = [] } = $$props;
+  let { placeholder = "Type a message..." } = $$props;
+  let { disabled = false } = $$props;
+  let { isTyping = false } = $$props;
+  let { typingText = "Assistant is thinking..." } = $$props;
+  let { submitOnEnter = true } = $$props;
+  let { layoutTransitionMs = 0 } = $$props;
+  let { centerWhenEmpty = false } = $$props;
+  let { conversationId = null } = $$props;
+  let { config = void 0 } = $$props;
+  const dispatch = createEventDispatcher();
+  let hostId = "";
+  let rootRef;
+  let viewportRef;
+  let composerRef;
+  let internalMessages = [...messages];
+  let typingActive = isTyping;
+  let host = null;
+  let teardown = null;
+  let lastProp = messages;
+  let lastTyping = isTyping;
+  let lastConv = conversationId;
+  function handleSend(event) {
+    viewportRef?.requestSmoothScroll?.();
+    dispatch("messageSent", event.detail);
+  }
+  function handleAction(event) {
+    dispatch("action", event.detail);
+  }
+  onMount(() => {
+    $$invalidate(2, hostId = `aparte-chat-${crypto.randomUUID()}`);
+    if (rootRef) $$invalidate(5, rootRef.id = hostId, rootRef);
+    const binding = {
+      hostId,
+      host: rootRef,
+      viewport: viewportRef,
+      getMessages: () => internalMessages,
+      setMessages: (m) => {
+        $$invalidate(4, internalMessages = m);
+      },
+      onMessagesChange: (m) => dispatch("messagesChange", m),
+      onMessageAppended: (m) => dispatch("messageAppended", m),
+      onTypingChange: (t) => {
+        $$invalidate(7, typingActive = t);
+        dispatch("typingChange", t);
+      },
+      onStreamingChange: () => {
+      },
+      afterRender: (cb) => {
+        void tick().then(cb);
+      },
+      resetComposer: () => composerRef?.reset?.()
+    };
+    $$invalidate(38, host = new AparteChatHost(
+      binding,
+      {
+        layoutTransitionMs,
+        conversationId: conversationId ?? null,
+        onConversationCreated: (id) => dispatch("conversationCreated", id),
+        config
+      }
+    ));
+    teardown = host.bind();
+    host.syncBubbles();
+    rootRef?.addEventListener("aparte-action", handleAction);
+  });
+  onDestroy(() => {
+    rootRef?.removeEventListener("aparte-action", handleAction);
+    teardown?.();
+    teardown = null;
+    $$invalidate(38, host = null);
+  });
+  function appendMessage(m) {
+    host?.appendMessage(m);
+  }
+  function updateMessage(id, u) {
+    host?.updateMessage(id, u);
+  }
+  function updateLastMessage(content, options) {
+    host?.updateLastMessage(content, options);
+  }
+  function addSegment(segment) {
+    host?.addSegment(segment);
+  }
+  function updateSegment(segmentId, updates) {
+    host?.updateSegment(segmentId, updates);
+  }
+  function removeSegment(segmentId) {
+    host?.removeSegment(segmentId);
+  }
+  function appendToSegment(segmentId, content) {
+    host?.appendToSegment(segmentId, content);
+  }
+  function getMessages() {
+    return host?.getMessages() ?? internalMessages;
+  }
+  function clearMessages() {
+    host?.clearMessages();
+  }
+  function addBranch(messageId) {
+    return host?.addBranch(messageId) ?? 0;
+  }
+  function addSiblingOf(existingId, message) {
+    return host?.addSiblingOf(existingId, message) ?? null;
+  }
+  function truncateFrom(messageId) {
+    host?.truncateFrom(messageId);
+  }
+  function truncateResponsesAfter(userMessageId) {
+    host?.truncateResponsesAfter(userMessageId);
+  }
+  function injectTokenStream(messageId, tokens) {
+    return host?.streamTokens(messageId, tokens) ?? Promise.resolve();
+  }
+  function stopTokenStream() {
+    host?.stopTokenStream();
+  }
+  function setConversationId(id) {
+    return host?.setConversationId(id) ?? Promise.resolve();
+  }
+  function scrollToBottom() {
+    viewportRef?.scrollToBottom?.();
+  }
+  function getViewport() {
+    return viewportRef ?? null;
+  }
+  function focusInput() {
+    composerRef?.focus?.();
+  }
+  function isStreaming() {
+    return host?.isStreaming ?? false;
+  }
+  function aparte_chat_viewport_binding($$value) {
+    binding_callbacks[$$value ? "unshift" : "push"](() => {
+      viewportRef = $$value;
+      $$invalidate(6, viewportRef);
+    });
+  }
+  function aparte_composer_binding($$value) {
+    binding_callbacks[$$value ? "unshift" : "push"](() => {
+      composerRef = $$value;
+      $$invalidate(3, composerRef);
+    });
+  }
+  function div_binding($$value) {
+    binding_callbacks[$$value ? "unshift" : "push"](() => {
+      rootRef = $$value;
+      $$invalidate(5, rootRef);
+    });
+  }
+  $$self.$$set = ($$props2) => {
+    if ("messages" in $$props2) $$invalidate(10, messages = $$props2.messages);
+    if ("placeholder" in $$props2) $$invalidate(11, placeholder = $$props2.placeholder);
+    if ("disabled" in $$props2) $$invalidate(12, disabled = $$props2.disabled);
+    if ("isTyping" in $$props2) $$invalidate(13, isTyping = $$props2.isTyping);
+    if ("typingText" in $$props2) $$invalidate(0, typingText = $$props2.typingText);
+    if ("submitOnEnter" in $$props2) $$invalidate(14, submitOnEnter = $$props2.submitOnEnter);
+    if ("layoutTransitionMs" in $$props2) $$invalidate(15, layoutTransitionMs = $$props2.layoutTransitionMs);
+    if ("centerWhenEmpty" in $$props2) $$invalidate(1, centerWhenEmpty = $$props2.centerWhenEmpty);
+    if ("conversationId" in $$props2) $$invalidate(16, conversationId = $$props2.conversationId);
+    if ("config" in $$props2) $$invalidate(17, config = $$props2.config);
+    if ("$$scope" in $$props2) $$invalidate(42, $$scope = $$props2.$$scope);
+  };
+  $$self.$$.update = () => {
+    if ($$self.$$.dirty[0] & /*messages*/
+    1024 | $$self.$$.dirty[1] & /*lastProp, host*/
+    384) {
+      if (messages !== lastProp) {
+        $$invalidate(39, lastProp = messages);
+        $$invalidate(4, internalMessages = [...messages]);
+        if (messages.length === 0) host?.clearRenderCache();
+      }
+    }
+    if ($$self.$$.dirty[0] & /*isTyping*/
+    8192 | $$self.$$.dirty[1] & /*lastTyping*/
+    512) {
+      if (isTyping !== lastTyping) {
+        $$invalidate(40, lastTyping = isTyping);
+        $$invalidate(7, typingActive = isTyping);
+      }
+    }
+    if ($$self.$$.dirty[0] & /*conversationId*/
+    65536 | $$self.$$.dirty[1] & /*lastConv, host*/
+    1152) {
+      if (conversationId !== lastConv) {
+        $$invalidate(41, lastConv = conversationId);
+        void host?.setConversationId(conversationId ?? null);
+      }
+    }
+    if ($$self.$$.dirty[0] & /*internalMessages*/
+    16 | $$self.$$.dirty[1] & /*host*/
+    128) {
+      if (host && internalMessages) {
+        void tick().then(() => host?.syncBubbles());
+      }
+    }
+    if ($$self.$$.dirty[0] & /*composerRef, hostId, placeholder, disabled, submitOnEnter*/
+    22540) {
+      if (composerRef) {
+        composerRef.setAttribute("target", hostId);
+        composerRef.setAttribute("placeholder", placeholder);
+        toggleAttr(composerRef, "disabled", disabled, "");
+        toggleAttr(composerRef, "submit-on-enter", !submitOnEnter, "false");
+      }
+    }
+  };
+  return [
+    typingText,
+    centerWhenEmpty,
+    hostId,
+    composerRef,
+    internalMessages,
+    rootRef,
+    viewportRef,
+    typingActive,
+    handleSend,
+    $$slots,
+    messages,
+    placeholder,
+    disabled,
+    isTyping,
+    submitOnEnter,
+    layoutTransitionMs,
+    conversationId,
+    config,
+    appendMessage,
+    updateMessage,
+    updateLastMessage,
+    addSegment,
+    updateSegment,
+    removeSegment,
+    appendToSegment,
+    getMessages,
+    clearMessages,
+    addBranch,
+    addSiblingOf,
+    truncateFrom,
+    truncateResponsesAfter,
+    injectTokenStream,
+    stopTokenStream,
+    setConversationId,
+    scrollToBottom,
+    getViewport,
+    focusInput,
+    isStreaming,
+    host,
+    lastProp,
+    lastTyping,
+    lastConv,
+    $$scope,
+    slots,
+    aparte_chat_viewport_binding,
+    aparte_composer_binding,
+    div_binding
+  ];
+}
+class AparteChat extends SvelteComponent {
+  constructor(options) {
+    super();
+    init(
+      this,
+      options,
+      instance$1,
+      create_fragment$1,
+      safe_not_equal,
+      {
+        messages: 10,
+        placeholder: 11,
+        disabled: 12,
+        isTyping: 13,
+        typingText: 0,
+        submitOnEnter: 14,
+        layoutTransitionMs: 15,
+        centerWhenEmpty: 1,
+        conversationId: 16,
+        config: 17,
+        appendMessage: 18,
+        updateMessage: 19,
+        updateLastMessage: 20,
+        addSegment: 21,
+        updateSegment: 22,
+        removeSegment: 23,
+        appendToSegment: 24,
+        getMessages: 25,
+        clearMessages: 26,
+        addBranch: 27,
+        addSiblingOf: 28,
+        truncateFrom: 29,
+        truncateResponsesAfter: 30,
+        injectTokenStream: 31,
+        stopTokenStream: 32,
+        setConversationId: 33,
+        scrollToBottom: 34,
+        getViewport: 35,
+        focusInput: 36,
+        isStreaming: 37
+      },
+      null,
+      [-1, -1]
+    );
+  }
+  get appendMessage() {
+    return this.$$.ctx[18];
+  }
+  get updateMessage() {
+    return this.$$.ctx[19];
+  }
+  get updateLastMessage() {
+    return this.$$.ctx[20];
+  }
+  get addSegment() {
+    return this.$$.ctx[21];
+  }
+  get updateSegment() {
+    return this.$$.ctx[22];
+  }
+  get removeSegment() {
+    return this.$$.ctx[23];
+  }
+  get appendToSegment() {
+    return this.$$.ctx[24];
+  }
+  get getMessages() {
+    return this.$$.ctx[25];
+  }
+  get clearMessages() {
+    return this.$$.ctx[26];
+  }
+  get addBranch() {
+    return this.$$.ctx[27];
+  }
+  get addSiblingOf() {
+    return this.$$.ctx[28];
+  }
+  get truncateFrom() {
+    return this.$$.ctx[29];
+  }
+  get truncateResponsesAfter() {
+    return this.$$.ctx[30];
+  }
+  get injectTokenStream() {
+    return this.$$.ctx[31];
+  }
+  get stopTokenStream() {
+    return this.$$.ctx[32];
+  }
+  get setConversationId() {
+    return this.$$.ctx[33];
+  }
+  get scrollToBottom() {
+    return this.$$.ctx[34];
+  }
+  get getViewport() {
+    return this.$$.ctx[35];
+  }
+  get focusInput() {
+    return this.$$.ctx[36];
+  }
+  get isStreaming() {
+    return this.$$.ctx[37];
+  }
+}
+function createAparteChat(initial = []) {
+  const messages = writable([...initial]);
+  let comp = null;
+  return {
+    messages,
+    connect: (component) => {
+      comp = component;
+    },
+    onMessagesChange: (m) => messages.set(m),
+    appendMessage: (m) => comp?.appendMessage(m),
+    updateMessage: (id, u) => comp?.updateMessage(id, u),
+    updateLastMessage: (c, o) => comp?.updateLastMessage(c, o),
+    addSegment: (s) => comp?.addSegment(s),
+    updateSegment: (id, u) => comp?.updateSegment(id, u),
+    removeSegment: (id) => comp?.removeSegment(id),
+    appendToSegment: (id, c) => comp?.appendToSegment(id, c),
+    clearMessages: () => comp?.clearMessages(),
+    addBranch: (id) => comp?.addBranch(id) ?? 0,
+    addSiblingOf: (id, m) => comp?.addSiblingOf(id, m) ?? null,
+    truncateFrom: (id) => comp?.truncateFrom(id),
+    truncateResponsesAfter: (id) => comp?.truncateResponsesAfter(id),
+    injectTokenStream: (id, tokens) => comp?.injectTokenStream(id, tokens) ?? Promise.resolve(),
+    stopTokenStream: () => comp?.stopTokenStream(),
+    setConversationId: (id) => comp?.setConversationId(id) ?? Promise.resolve(),
+    isStreaming: () => comp?.isStreaming() ?? false
+  };
+}
+function createAparteClient(options) {
+  const client = new AparteClient(options ?? {});
+  onMount(() => {
+    client.start();
+  });
+  onDestroy(() => client.stop());
+  return { client, abort: () => client.abort() };
+}
+function createConversationManager() {
+  let manager = null;
+  let unsub = null;
+  const conversations = writable([]);
+  const activeId = writable(null);
+  const activeConversations = derived(
+    conversations,
+    ($c) => $c.filter((c) => !c.archivedAt).sort((a, b) => b.updatedAt - a.updatedAt)
+  );
+  const archivedConversations = derived(
+    conversations,
+    ($c) => $c.filter((c) => !!c.archivedAt).sort((a, b) => b.updatedAt - a.updatedAt)
+  );
+  const activeConversation = derived(
+    [conversations, activeId],
+    ([$c, $id]) => $id ? $c.find((c) => c.id === $id) ?? null : null
+  );
+  onDestroy(() => unsub?.());
+  const assert = () => {
+    if (!manager) throw new Error("[createConversationManager] Not initialised. Call init(adapter) first.");
+    return manager;
+  };
+  async function init2(adapter) {
+    const m = new ConversationManager(adapter);
+    manager = m;
+    unsub = m.subscribe((convs) => {
+      conversations.set([...convs]);
+      activeId.set(m.activeId);
+    });
+    await m.init();
+    activeId.set(m.activeId);
+    AparteConfig.setConversationManager(m);
+  }
+  return {
+    conversations,
+    activeConversations,
+    archivedConversations,
+    activeId,
+    activeConversation,
+    init: init2,
+    createNew: (title) => assert().createNew(title),
+    addMessage: (convId, message) => assert().addMessage(convId, message),
+    updateMessages: (convId, messages) => assert().updateMessages(convId, messages),
+    delete: (id) => assert().delete(id),
+    archive: (id) => assert().archive(id),
+    unarchive: (id) => assert().unarchive(id)
+  };
+}
+function create_fragment(ctx) {
+  let span;
+  return {
+    c() {
+      span = element("span");
+      set_style(span, "display", "contents");
+    },
+    m(target, anchor) {
+      insert(target, span, anchor);
+      ctx[9](span);
+    },
+    p: noop,
+    i: noop,
+    o: noop,
+    d(detaching) {
+      if (detaching) {
+        detach(span);
+      }
+      ctx[9](null);
+    }
+  };
+}
+function instance($$self, $$props, $$invalidate) {
+  let { name } = $$props;
+  let { props = {} } = $$props;
+  let { events = void 0 } = $$props;
+  const dispatch = createEventDispatcher();
+  let host;
+  let el = null;
+  let cleanups = [];
+  function applyProps() {
+    if (el) applyElementProps(el, props);
+  }
+  function create() {
+    if (!host) return;
+    $$invalidate(6, el = document.createElement(name));
+    applyProps();
+    for (const ev of events ?? DEFAULT_UI_EVENTS) {
+      const listener = (e) => dispatch("elementEvent", e);
+      el.addEventListener(ev, listener);
+      cleanups.push(() => el?.removeEventListener(ev, listener));
+    }
+    host.appendChild(el);
+  }
+  function destroy() {
+    for (const c of cleanups) c();
+    cleanups = [];
+    el?.remove();
+    $$invalidate(6, el = null);
+  }
+  onMount(create);
+  onDestroy(destroy);
+  let lastName = name;
+  let lastEvtsKey = (events ?? DEFAULT_UI_EVENTS).join("|");
+  function getElement() {
+    return el;
+  }
+  function callMethod(methodName, ...args) {
+    const fn = el?.[methodName];
+    return typeof fn === "function" ? fn.apply(el, args) : void 0;
+  }
+  function span_binding($$value) {
+    binding_callbacks[$$value ? "unshift" : "push"](() => {
+      host = $$value;
+      $$invalidate(0, host);
+    });
+  }
+  $$self.$$set = ($$props2) => {
+    if ("name" in $$props2) $$invalidate(1, name = $$props2.name);
+    if ("props" in $$props2) $$invalidate(2, props = $$props2.props);
+    if ("events" in $$props2) $$invalidate(3, events = $$props2.events);
+  };
+  $$self.$$.update = () => {
+    if ($$self.$$.dirty & /*events, el, name, lastName, lastEvtsKey*/
+    458) {
+      {
+        const evtsKey = (events ?? DEFAULT_UI_EVENTS).join("|");
+        if (el && (name !== lastName || evtsKey !== lastEvtsKey)) {
+          $$invalidate(7, lastName = name);
+          $$invalidate(8, lastEvtsKey = evtsKey);
+          destroy();
+          create();
+        }
+      }
+    }
+    if ($$self.$$.dirty & /*el, props*/
+    68) {
+      if (el && props) applyProps();
+    }
+  };
+  return [
+    host,
+    name,
+    props,
+    events,
+    getElement,
+    callMethod,
+    el,
+    lastName,
+    lastEvtsKey,
+    span_binding
+  ];
+}
+class AparteUi extends SvelteComponent {
+  constructor(options) {
+    super();
+    init(this, options, instance, create_fragment, safe_not_equal, {
+      name: 1,
+      props: 2,
+      events: 3,
+      getElement: 4,
+      callMethod: 5
+    });
+  }
+  get getElement() {
+    return this.$$.ctx[4];
+  }
+  get callMethod() {
+    return this.$$.ctx[5];
+  }
+}
+export {
+  AparteChat,
+  AparteUi,
+  createAparteChat,
+  createAparteClient,
+  createConversationManager
+};
+//# sourceMappingURL=index.js.map