@n8n/chat 0.6.0 → 0.6.1

package/{src/App.vue → App.vue}

@@ -1,10 +1,10 @@
 <script lang="ts" setup>
-import { Chat, ChatWindow } from '@/components';
+import { Chat, ChatWindow } from '@n8n/chat/components';
 import { computed, onMounted } from 'vue';
 import hljs from 'highlight.js/lib/core';
 import hljsXML from 'highlight.js/lib/languages/xml';
 import hljsJavascript from 'highlight.js/lib/languages/javascript';
-import { useOptions } from '@/composables';
+import { useOptions } from '@n8n/chat/composables';
 
 defineProps({});
 

package/README.md

@@ -1,10 +1,16 @@
 # n8n Chat
 This is an embeddable Chat widget for n8n. It allows the execution of AI-Powered Workflows through a Chat window.
 
+**Windowed Example**
+![n8n Chat Windowed](https://raw.githubusercontent.com/n8n-io/n8n/master/packages/%40n8n/chat/resources/images/windowed.png)
+
+**Fullscreen Example**
+![n8n Chat Fullscreen](https://raw.githubusercontent.com/n8n-io/n8n/master/packages/%40n8n/chat/resources/images/fullscreen.png)
+
 ## Prerequisites
-Create a n8n workflow which you want to execute via chat. The workflow has to be triggered using a **Webhook** node and return data using the **Respond to Webhook** node.
+Create a n8n workflow which you want to execute via chat. The workflow has to be triggered using a **Chat Trigger** node.
 
-Open the **Webhook** node and add your domain to the **Domain Allowlist** field. This makes sure that only requests from your domain are accepted.
+Open the **Chat Trigger** node and add your domain to the **Allowed Origins (CORS)** field. This makes sure that only requests from your domain are accepted.
 
 [See example workflow](https://github.com/n8n-io/n8n/blob/master/packages/%40n8n/chat/resources/workflow.json)
 
@@ -17,8 +23,6 @@ Each request is accompanied by an `action` query parameter, where `action` can b
 - `loadPreviousSession` - When the user opens the Chatbot again and the previous chat session should be loaded
 - `sendMessage` - When the user sends a message
 
-We use the `Switch` node to handle the different actions.
-
 ## Installation
 
 Open the **Webhook** node and replace `YOUR_PRODUCTION_WEBHOOK_URL` with your production URL. This is the URL that the Chat widget will use to send requests to.
@@ -106,6 +110,10 @@ createChat({
 	},
 	target: '#n8n-chat',
 	mode: 'window',
+	chatInputKey: 'chatInput',
+	chatSessionKey: 'sessionId',
+	metadata: {},
+	showWelcomeScreen: false,
 	defaultLanguage: 'en',
 	initialMessages: [
 		'Hi there! 👋',
@@ -148,6 +156,21 @@ createChat({
   - In `window` mode, the Chat window will be embedded in the target element as a chat toggle button and a fixed size chat window.
   - In `fullscreen` mode, the Chat will take up the entire width and height of its target container.
 
+### `showWelcomeScreen`
+- **Type**: `boolean`
+- **Default**: `false`
+- **Description**: Whether to show the welcome screen when the Chat window is opened.
+
+### `chatSessionKey`
+- **Type**: `string`
+- **Default**: `'sessionId'`
+- **Description**: The key to use for sending the chat history session ID for the AI Memory node.
+
+### `chatInputKey`
+- **Type**: `string`
+- **Default**: `'chatInput'`
+- **Description**: The key to use for sending the chat input for the AI Agent node.
+
 ### `defaultLanguage`
 - **Type**: `string`
 - **Default**: `'en'`

package/__stories__/App.stories.d.ts

@@ -0,0 +1,16 @@
+import type { StoryObj } from '@storybook/vue3';
+declare const meta: {
+    title: string;
+    render: (args: ChatOptions) => {
+        setup(): {};
+        template: string;
+    };
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Fullscreen: Story;
+export declare const Windowed: Story;

package/__stories__/App.stories.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = exports.Windowed = exports.Fullscreen = void 0;
+var _index = require("@n8n/chat/index");
+var _vue = require("vue");
+const webhookUrl = "http://localhost:5678/webhook/f406671e-c954-4691-b39a-66c90aa2f103/chat";
+const meta = {
+  title: "Chat",
+  render: args => ({
+    setup() {
+      (0, _vue.onMounted)(() => {
+        (0, _index.createChat)(args);
+      });
+      return {};
+    },
+    template: '<div id="n8n-chat" />'
+  }),
+  parameters: {
+    layout: "fullscreen"
+  },
+  tags: ["autodocs"]
+};
+module.exports = meta;
+const Fullscreen = exports.Fullscreen = {
+  args: {
+    webhookUrl,
+    mode: "fullscreen"
+  }
+};
+const Windowed = exports.Windowed = {
+  args: {
+    webhookUrl,
+    mode: "window"
+  }
+};

package/__stories__/App.stories.mjs

@@ -0,0 +1,32 @@
+import { createChat } from "@n8n/chat/index";
+import { onMounted } from "vue";
+const webhookUrl = "http://localhost:5678/webhook/f406671e-c954-4691-b39a-66c90aa2f103/chat";
+const meta = {
+  title: "Chat",
+  render: (args) => ({
+    setup() {
+      onMounted(() => {
+        createChat(args);
+      });
+      return {};
+    },
+    template: '<div id="n8n-chat" />'
+  }),
+  parameters: {
+    layout: "fullscreen"
+  },
+  tags: ["autodocs"]
+};
+export default meta;
+export const Fullscreen = {
+  args: {
+    webhookUrl,
+    mode: "fullscreen"
+  }
+};
+export const Windowed = {
+  args: {
+    webhookUrl,
+    mode: "window"
+  }
+};

package/__tests__/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/__tests__/index.spec.js

@@ -0,0 +1,146 @@
+"use strict";
+
+var _vue = require("@testing-library/vue");
+var _utils = require("@n8n/chat/__tests__/utils");
+var _index = require("@n8n/chat/index");
+describe("createChat()", () => {
+  let app;
+  afterEach(() => {
+    vi.clearAllMocks();
+    app.unmount();
+  });
+  describe("mode", () => {
+    it("should create fullscreen chat app with default options", () => {
+      const fetchSpy = vi.spyOn(window, "fetch");
+      fetchSpy.mockImplementationOnce((0, _utils.createFetchResponse)((0, _utils.createGetLatestMessagesResponse)()));
+      app = (0, _index.createChat)({
+        mode: "fullscreen"
+      });
+      expect((0, _utils.getMountingTarget)()).toBeVisible();
+      expect((0, _utils.getChatWrapper)()).toBeVisible();
+      expect((0, _utils.getChatWindowWrapper)()).not.toBeInTheDocument();
+    });
+    it("should create window chat app with default options", () => {
+      const fetchSpy = vi.spyOn(window, "fetch");
+      fetchSpy.mockImplementationOnce((0, _utils.createFetchResponse)((0, _utils.createGetLatestMessagesResponse)()));
+      app = (0, _index.createChat)({
+        mode: "window"
+      });
+      expect((0, _utils.getMountingTarget)()).toBeDefined();
+      expect((0, _utils.getChatWindowWrapper)()).toBeVisible();
+      expect((0, _utils.getChatWrapper)()).not.toBeVisible();
+    });
+    it("should open window chat app using toggle button", async () => {
+      const fetchSpy = vi.spyOn(window, "fetch");
+      fetchSpy.mockImplementationOnce((0, _utils.createFetchResponse)((0, _utils.createGetLatestMessagesResponse)()));
+      app = (0, _index.createChat)();
+      expect((0, _utils.getMountingTarget)()).toBeVisible();
+      expect((0, _utils.getChatWindowWrapper)()).toBeVisible();
+      const trigger = (0, _utils.getChatWindowToggle)();
+      await _vue.fireEvent.click(trigger);
+      expect((0, _utils.getChatWrapper)()).toBeVisible();
+    });
+  });
+  describe("loadPreviousMessages", () => {
+    it("should load previous messages on mount", async () => {
+      const fetchSpy = vi.spyOn(global, "fetch");
+      fetchSpy.mockImplementation((0, _utils.createFetchResponse)((0, _utils.createGetLatestMessagesResponse)()));
+      app = (0, _index.createChat)({
+        mode: "fullscreen",
+        showWelcomeScreen: true
+      });
+      const getStartedButton = (0, _utils.getGetStartedButton)();
+      await _vue.fireEvent.click(getStartedButton);
+      expect(fetchSpy.mock.calls[0][1]).toEqual(expect.objectContaining({
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: expect.stringContaining('"action":"loadPreviousSession"'),
+        mode: "cors",
+        cache: "no-cache"
+      }));
+    });
+  });
+  describe("initialMessages", () => {
+    it.each(["fullscreen", "window"])("should show initial default messages in %s mode", async mode => {
+      const fetchSpy = vi.spyOn(window, "fetch");
+      fetchSpy.mockImplementationOnce((0, _utils.createFetchResponse)((0, _utils.createGetLatestMessagesResponse)()));
+      const initialMessages = ["Hello tester!", "How are you?"];
+      app = (0, _index.createChat)({
+        mode,
+        initialMessages
+      });
+      if (mode === "window") {
+        const trigger = (0, _utils.getChatWindowToggle)();
+        await _vue.fireEvent.click(trigger);
+      }
+      expect((0, _utils.getChatMessages)().length).toBe(initialMessages.length);
+      expect((0, _utils.getChatMessageByText)(initialMessages[0])).toBeInTheDocument();
+      expect((0, _utils.getChatMessageByText)(initialMessages[1])).toBeInTheDocument();
+    });
+  });
+  describe("sendMessage", () => {
+    it.each(["window", "fullscreen"])("should send a message and render a text message in %s mode", async mode => {
+      const input = "Hello User World!";
+      const output = "Hello Bot World!";
+      const fetchSpy = vi.spyOn(window, "fetch");
+      fetchSpy.mockImplementationOnce((0, _utils.createFetchResponse)(_utils.createGetLatestMessagesResponse)).mockImplementationOnce((0, _utils.createFetchResponse)((0, _utils.createSendMessageResponse)(output)));
+      app = (0, _index.createChat)({
+        mode
+      });
+      if (mode === "window") {
+        const trigger = (0, _utils.getChatWindowToggle)();
+        await _vue.fireEvent.click(trigger);
+      }
+      expect((0, _utils.getChatMessageTyping)()).not.toBeInTheDocument();
+      expect((0, _utils.getChatMessages)().length).toBe(2);
+      await (0, _vue.waitFor)(() => expect((0, _utils.getChatInputTextarea)()).toBeInTheDocument());
+      const textarea = (0, _utils.getChatInputTextarea)();
+      const sendButton = (0, _utils.getChatInputSendButton)();
+      await _vue.fireEvent.update(textarea, input);
+      expect(sendButton).not.toBeDisabled();
+      await _vue.fireEvent.click(sendButton);
+      expect(fetchSpy.mock.calls[1][1]).toEqual(expect.objectContaining({
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: expect.stringMatching(/"action":"sendMessage"/),
+        mode: "cors",
+        cache: "no-cache"
+      }));
+      expect(fetchSpy.mock.calls[1][1]?.body).toContain(`"${input}"`);
+      expect((0, _utils.getChatMessages)().length).toBe(3);
+      expect((0, _utils.getChatMessageByText)(input)).toBeInTheDocument();
+      expect((0, _utils.getChatMessageTyping)()).toBeVisible();
+      await (0, _vue.waitFor)(() => expect((0, _utils.getChatMessageTyping)()).not.toBeInTheDocument());
+      expect((0, _utils.getChatMessageByText)(output)).toBeInTheDocument();
+    });
+    it.each(["fullscreen", "window"])("should send a message and render a code markdown message in %s mode", async mode => {
+      const input = "Teach me javascript!";
+      const output = '# Code\n```js\nconsole.log("Hello World!");\n```';
+      const fetchSpy = vi.spyOn(window, "fetch");
+      fetchSpy.mockImplementationOnce((0, _utils.createFetchResponse)(_utils.createGetLatestMessagesResponse)).mockImplementationOnce((0, _utils.createFetchResponse)((0, _utils.createSendMessageResponse)(output)));
+      app = (0, _index.createChat)({
+        mode
+      });
+      if (mode === "window") {
+        const trigger = (0, _utils.getChatWindowToggle)();
+        await _vue.fireEvent.click(trigger);
+      }
+      await (0, _vue.waitFor)(() => expect((0, _utils.getChatInputTextarea)()).toBeInTheDocument());
+      const textarea = (0, _utils.getChatInputTextarea)();
+      const sendButton = (0, _utils.getChatInputSendButton)();
+      await _vue.fireEvent.update(textarea, input);
+      await _vue.fireEvent.click(sendButton);
+      expect((0, _utils.getChatMessageByText)(input)).toBeInTheDocument();
+      expect((0, _utils.getChatMessages)().length).toBe(3);
+      await (0, _vue.waitFor)(() => expect((0, _utils.getChatMessageTyping)()).not.toBeInTheDocument());
+      const lastMessage = (0, _utils.getChatMessage)(-1);
+      expect(lastMessage).toBeInTheDocument();
+      expect(lastMessage.querySelector("h1")).toHaveTextContent("Code");
+      expect(lastMessage.querySelector("code")).toHaveTextContent('console.log("Hello World!");');
+    });
+  });
+});

package/__tests__/index.spec.mjs

@@ -0,0 +1,172 @@
+import { fireEvent, waitFor } from "@testing-library/vue";
+import {
+  createFetchResponse,
+  createGetLatestMessagesResponse,
+  createSendMessageResponse,
+  getChatInputSendButton,
+  getChatInputTextarea,
+  getChatMessage,
+  getChatMessageByText,
+  getChatMessages,
+  getChatMessageTyping,
+  getChatWindowToggle,
+  getChatWindowWrapper,
+  getChatWrapper,
+  getGetStartedButton,
+  getMountingTarget
+} from "@n8n/chat/__tests__/utils";
+import { createChat } from "@n8n/chat/index";
+describe("createChat()", () => {
+  let app;
+  afterEach(() => {
+    vi.clearAllMocks();
+    app.unmount();
+  });
+  describe("mode", () => {
+    it("should create fullscreen chat app with default options", () => {
+      const fetchSpy = vi.spyOn(window, "fetch");
+      fetchSpy.mockImplementationOnce(createFetchResponse(createGetLatestMessagesResponse()));
+      app = createChat({
+        mode: "fullscreen"
+      });
+      expect(getMountingTarget()).toBeVisible();
+      expect(getChatWrapper()).toBeVisible();
+      expect(getChatWindowWrapper()).not.toBeInTheDocument();
+    });
+    it("should create window chat app with default options", () => {
+      const fetchSpy = vi.spyOn(window, "fetch");
+      fetchSpy.mockImplementationOnce(createFetchResponse(createGetLatestMessagesResponse()));
+      app = createChat({
+        mode: "window"
+      });
+      expect(getMountingTarget()).toBeDefined();
+      expect(getChatWindowWrapper()).toBeVisible();
+      expect(getChatWrapper()).not.toBeVisible();
+    });
+    it("should open window chat app using toggle button", async () => {
+      const fetchSpy = vi.spyOn(window, "fetch");
+      fetchSpy.mockImplementationOnce(createFetchResponse(createGetLatestMessagesResponse()));
+      app = createChat();
+      expect(getMountingTarget()).toBeVisible();
+      expect(getChatWindowWrapper()).toBeVisible();
+      const trigger = getChatWindowToggle();
+      await fireEvent.click(trigger);
+      expect(getChatWrapper()).toBeVisible();
+    });
+  });
+  describe("loadPreviousMessages", () => {
+    it("should load previous messages on mount", async () => {
+      const fetchSpy = vi.spyOn(global, "fetch");
+      fetchSpy.mockImplementation(createFetchResponse(createGetLatestMessagesResponse()));
+      app = createChat({
+        mode: "fullscreen",
+        showWelcomeScreen: true
+      });
+      const getStartedButton = getGetStartedButton();
+      await fireEvent.click(getStartedButton);
+      expect(fetchSpy.mock.calls[0][1]).toEqual(
+        expect.objectContaining({
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: expect.stringContaining('"action":"loadPreviousSession"'),
+          mode: "cors",
+          cache: "no-cache"
+        })
+      );
+    });
+  });
+  describe("initialMessages", () => {
+    it.each(["fullscreen", "window"])(
+      "should show initial default messages in %s mode",
+      async (mode) => {
+        const fetchSpy = vi.spyOn(window, "fetch");
+        fetchSpy.mockImplementationOnce(createFetchResponse(createGetLatestMessagesResponse()));
+        const initialMessages = ["Hello tester!", "How are you?"];
+        app = createChat({
+          mode,
+          initialMessages
+        });
+        if (mode === "window") {
+          const trigger = getChatWindowToggle();
+          await fireEvent.click(trigger);
+        }
+        expect(getChatMessages().length).toBe(initialMessages.length);
+        expect(getChatMessageByText(initialMessages[0])).toBeInTheDocument();
+        expect(getChatMessageByText(initialMessages[1])).toBeInTheDocument();
+      }
+    );
+  });
+  describe("sendMessage", () => {
+    it.each(["window", "fullscreen"])(
+      "should send a message and render a text message in %s mode",
+      async (mode) => {
+        const input = "Hello User World!";
+        const output = "Hello Bot World!";
+        const fetchSpy = vi.spyOn(window, "fetch");
+        fetchSpy.mockImplementationOnce(createFetchResponse(createGetLatestMessagesResponse)).mockImplementationOnce(createFetchResponse(createSendMessageResponse(output)));
+        app = createChat({
+          mode
+        });
+        if (mode === "window") {
+          const trigger = getChatWindowToggle();
+          await fireEvent.click(trigger);
+        }
+        expect(getChatMessageTyping()).not.toBeInTheDocument();
+        expect(getChatMessages().length).toBe(2);
+        await waitFor(() => expect(getChatInputTextarea()).toBeInTheDocument());
+        const textarea = getChatInputTextarea();
+        const sendButton = getChatInputSendButton();
+        await fireEvent.update(textarea, input);
+        expect(sendButton).not.toBeDisabled();
+        await fireEvent.click(sendButton);
+        expect(fetchSpy.mock.calls[1][1]).toEqual(
+          expect.objectContaining({
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: expect.stringMatching(/"action":"sendMessage"/),
+            mode: "cors",
+            cache: "no-cache"
+          })
+        );
+        expect(fetchSpy.mock.calls[1][1]?.body).toContain(`"${input}"`);
+        expect(getChatMessages().length).toBe(3);
+        expect(getChatMessageByText(input)).toBeInTheDocument();
+        expect(getChatMessageTyping()).toBeVisible();
+        await waitFor(() => expect(getChatMessageTyping()).not.toBeInTheDocument());
+        expect(getChatMessageByText(output)).toBeInTheDocument();
+      }
+    );
+    it.each(["fullscreen", "window"])(
+      "should send a message and render a code markdown message in %s mode",
+      async (mode) => {
+        const input = "Teach me javascript!";
+        const output = '# Code\n```js\nconsole.log("Hello World!");\n```';
+        const fetchSpy = vi.spyOn(window, "fetch");
+        fetchSpy.mockImplementationOnce(createFetchResponse(createGetLatestMessagesResponse)).mockImplementationOnce(createFetchResponse(createSendMessageResponse(output)));
+        app = createChat({
+          mode
+        });
+        if (mode === "window") {
+          const trigger = getChatWindowToggle();
+          await fireEvent.click(trigger);
+        }
+        await waitFor(() => expect(getChatInputTextarea()).toBeInTheDocument());
+        const textarea = getChatInputTextarea();
+        const sendButton = getChatInputSendButton();
+        await fireEvent.update(textarea, input);
+        await fireEvent.click(sendButton);
+        expect(getChatMessageByText(input)).toBeInTheDocument();
+        expect(getChatMessages().length).toBe(3);
+        await waitFor(() => expect(getChatMessageTyping()).not.toBeInTheDocument());
+        const lastMessage = getChatMessage(-1);
+        expect(lastMessage).toBeInTheDocument();
+        expect(lastMessage.querySelector("h1")).toHaveTextContent("Code");
+        expect(lastMessage.querySelector("code")).toHaveTextContent('console.log("Hello World!");');
+      }
+    );
+  });
+});

package/__tests__/setup.js

@@ -0,0 +1,3 @@
+"use strict";
+
+require("@testing-library/jest-dom");

package/__tests__/setup.mjs

@@ -0,0 +1 @@
+import "@testing-library/jest-dom";

package/__tests__/utils/create.d.ts

@@ -0,0 +1,5 @@
+import { createChat } from '@n8n/chat/index';
+export declare function createTestChat(options?: Parameters<typeof createChat>[0]): {
+    unmount: () => void;
+    container: Element;
+};

package/__tests__/utils/create.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTestChat = createTestChat;
+var _index = require("@n8n/chat/index");
+function createTestChat(options = {}) {
+  const app = (0, _index.createChat)(options);
+  const container = app._container;
+  const unmount = () => app.unmount();
+  return {
+    unmount,
+    container
+  };
+}

package/__tests__/utils/create.mjs

@@ -0,0 +1,10 @@
+import { createChat } from "@n8n/chat/index";
+export function createTestChat(options = {}) {
+  const app = createChat(options);
+  const container = app._container;
+  const unmount = () => app.unmount();
+  return {
+    unmount,
+    container
+  };
+}

package/__tests__/utils/fetch.d.ts

@@ -0,0 +1,3 @@
+export declare function createFetchResponse<T>(data: T): () => Promise<Response>;
+export declare const createGetLatestMessagesResponse: (data?: LoadPreviousSessionResponse) => LoadPreviousSessionResponse;
+export declare const createSendMessageResponse: (output: SendMessageResponse) => SendMessageResponse;

package/__tests__/utils/fetch.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFetchResponse = createFetchResponse;
+exports.createSendMessageResponse = exports.createGetLatestMessagesResponse = void 0;
+function createFetchResponse(data) {
+  return async () => ({
+    json: async () => new Promise(resolve => resolve(data))
+  });
+}
+const createGetLatestMessagesResponse = (data = []) => ({
+  data
+});
+exports.createGetLatestMessagesResponse = createGetLatestMessagesResponse;
+const createSendMessageResponse = output => ({
+  output
+});
+exports.createSendMessageResponse = createSendMessageResponse;

package/__tests__/utils/fetch.mjs

@@ -0,0 +1,9 @@
+export function createFetchResponse(data) {
+  return async () => ({
+    json: async () => new Promise((resolve) => resolve(data))
+  });
+}
+export const createGetLatestMessagesResponse = (data = []) => ({ data });
+export const createSendMessageResponse = (output) => ({
+  output
+});

package/__tests__/utils/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _create = require("./create");
+Object.keys(_create).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _create[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _create[key];
+    }
+  });
+});
+var _fetch = require("./fetch");
+Object.keys(_fetch).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _fetch[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _fetch[key];
+    }
+  });
+});
+var _selectors = require("./selectors");
+Object.keys(_selectors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _selectors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _selectors[key];
+    }
+  });
+});

package/__tests__/utils/index.mjs

@@ -0,0 +1,3 @@
+export * from "./create.mjs";
+export * from "./fetch.mjs";
+export * from "./selectors.mjs";

package/__tests__/utils/selectors.d.ts

@@ -0,0 +1,12 @@
+export declare function getMountingTarget(target?: any): any;
+export declare function getChatWindowWrapper(): Element | null;
+export declare function getChatWindowToggle(): Element | null;
+export declare function getChatWrapper(): Element | null;
+export declare function getChatMessages(): NodeListOf<Element>;
+export declare function getChatMessage(index: number): Element;
+export declare function getChatMessageByText(text: string): HTMLElement | null;
+export declare function getChatMessageTyping(): Element | null;
+export declare function getGetStartedButton(): Element | null;
+export declare function getChatInput(): Element | null;
+export declare function getChatInputTextarea(): Element | null;
+export declare function getChatInputSendButton(): Element | null;