@inploi/plugin-chatbot 2.0.0 → 2.1.1

package/src/index.dev.ts

@@ -1,36 +0,0 @@
-/** This file is only used for dev mode. The build output is index.ts */
-import { createApiClient, inploiBrandedLogger } from '@inploi/sdk';
-
-import { chatbotPlugin } from './chatbot';
-
-declare global {
-	interface Window {
-		chatbot: ReturnType<ReturnType<typeof chatbotPlugin>>;
-	}
-}
-
-async function enableMocking() {
-	if (import.meta.env.VITE_MOCKS === 'false') return;
-	const { worker } = await import('./mocks/browser');
-
-	// `worker.start()` returns a Promise that resolves
-	// once the Service Worker is up and ready to intercept requests.
-	return worker.start({ onUnhandledRequest: 'bypass' });
-}
-
-enableMocking().then(() => {
-	window.chatbot = chatbotPlugin({})({
-		apiClient: createApiClient({
-			baseUrl: import.meta.env.VITE_BASE_URL,
-			publishableKey: import.meta.env.VITE_PUBLISHABLE_KEY,
-		}),
-		logger: inploiBrandedLogger,
-		analytics: {
-			log: async params => {
-				inploiBrandedLogger.log('stub logging', params);
-				return { success: true, data: {} } as any;
-			},
-		},
-	});
-	window.chatbot.prepare();
-});

package/src/index.ts

@@ -1 +0,0 @@
-export { chatbotPlugin } from './chatbot';

package/src/interpreter/interpreter.test.ts

@@ -1,69 +0,0 @@
-import { FlowNode } from '@inploi/core/flows';
-import { expect, mock, test } from 'bun:test';
-
-import { ChatService, createFlowInterpreter } from './interpreter';
-
-const chatServiceStub: ChatService = {
-	input: () => new Promise(resolve => resolve({ type: 'text', value: 'lol' } as any)),
-	send: async () => void 0,
-};
-
-test('throws if no head', async () => {
-	const interpreter = createFlowInterpreter({
-		chatService: chatServiceStub,
-		flow: [],
-		getSubmissions: () => ({}),
-		onFlowEnd: () => void 0,
-	});
-
-	try {
-		await interpreter.interpret();
-		expect().toThrow();
-	} catch (error) {
-		expect(error).toBeInstanceOf(Error);
-		if (error instanceof Error) {
-			expect(error.message).toEqual('No head node found');
-		}
-	}
-});
-
-test('calls onFinish with nodeType when there are no more nodes to interpret', async () => {
-	const onFinish = mock(() => void 0);
-	const flowNode: FlowNode = { id: '1', type: 'text', isHead: true, data: { text: 'Node one' } };
-	const interpreter = createFlowInterpreter({
-		chatService: chatServiceStub,
-		flow: [flowNode],
-		getSubmissions: () => ({}),
-		onFlowEnd: onFinish,
-	});
-
-	await interpreter.interpret();
-
-	expect(onFinish).toHaveBeenCalled();
-	expect(onFinish.mock.calls[0]).toEqual([flowNode]);
-});
-
-test("moves on to next node when 'next' is called", async () => {
-	const messageFn = mock((str: string) => {
-		str;
-	});
-
-	const interpreter = createFlowInterpreter({
-		chatService: {
-			input: () => new Promise(resolve => resolve({ type: 'text', value: 'lol' } as any)),
-			send: async ({ message }) => (message.type === 'text' ? messageFn(message.text) : void 0),
-		},
-		flow: [
-			{ id: '1', type: 'text', isHead: true, nextId: '2', data: { text: 'Node one' } },
-			{ id: '2', type: 'text', data: { text: 'Node two' } },
-		],
-		getSubmissions: () => ({}),
-		onFlowEnd: () => void 0,
-	});
-
-	await interpreter.interpret();
-
-	expect(messageFn.mock.calls).toHaveLength(2);
-	expect(messageFn.mock.calls[0]).toEqual(['Node one']);
-	expect(messageFn.mock.calls[1]).toEqual(['Node two']);
-});

package/src/interpreter/interpreter.ts

@@ -1,241 +0,0 @@
-import { FlowNode, FlowNodeType, IfBlockNode } from '@inploi/core/flows';
-import { P, match } from 'ts-pattern';
-import { getHeadOrThrow } from '~/chatbot.utils';
-import { ChatInput } from '~/ui/chat-input/chat-input';
-
-import { ApplicationSubmission, ChatMessage, KeyToSubmissionMap } from '../chatbot.state';
-
-export type ChatServiceSendParams = { signal?: AbortSignal; message: ChatMessage };
-export type ChatService = {
-	send: (params: ChatServiceSendParams) => Promise<void>;
-	input: <TType extends ChatInput['type']>(
-		params: Extract<ChatInput, { type: TType }>,
-	) => Promise<Extract<ApplicationSubmission, { type: TType }>>;
-};
-
-type ChatbotInterpreterParams = {
-	flow: FlowNode[];
-	getSubmissions: () => KeyToSubmissionMap | undefined;
-	chatService: ChatService;
-	/** When interpreter starts */
-	beforeStart?: (firstNode: FlowNode) => Promise<void>;
-	/** When flow has no more nodes to interpret */
-	onFlowEnd?: (lastNode: FlowNode) => void;
-	/** When node is interpreted */
-	onInterpret?: (node: FlowNode) => void;
-};
-export const createFlowInterpreter = ({
-	flow,
-	getSubmissions,
-	chatService,
-	beforeStart,
-	onFlowEnd,
-	onInterpret,
-}: ChatbotInterpreterParams) => {
-	const controller = new AbortController();
-	const interpretNode = async (node: FlowNode) => {
-		const submissions = getSubmissions();
-		onInterpret?.(node);
-		await interpret({
-			node,
-			submissions,
-			chat: {
-				sendMessage: async message => chatService.send({ message, signal: controller.signal }),
-				userInput: async input => chatService.input(input),
-			},
-			next: () => {
-				const nextNodeId = getNextNodeId(node, getSubmissions());
-				const nextNode = flow.find(node => node.id === nextNodeId);
-				if (nextNode) {
-					return interpretNode(nextNode);
-				} else onFlowEnd?.(node);
-			},
-		});
-	};
-
-	return {
-		interpret: async (startFromNodeId?: string) => {
-			const startNode = flow.find(node => node.id === startFromNodeId) ?? getHeadOrThrow(flow);
-			await beforeStart?.(startNode);
-			return interpretNode(startNode);
-		},
-		abort: () => {
-			controller.abort();
-		},
-	};
-};
-
-type InterpretNodeParams<TNodeType extends FlowNodeType> = {
-	node: Extract<FlowNode, { type: TNodeType }>;
-	submissions?: KeyToSubmissionMap;
-	chat: {
-		sendMessage: (message: ChatMessage) => Promise<void>;
-		userInput: <TType extends ChatInput['type']>(
-			params: Extract<ChatInput, { type: TType }>,
-		) => Promise<Extract<ApplicationSubmission, { type: TType }>>;
-	};
-	next: () => void;
-};
-
-async function interpret(params: InterpretNodeParams<FlowNodeType>) {
-	return await match(params)
-		.with({ node: { type: 'text' } }, interpretTextNode)
-		.with({ node: { type: 'image' } }, interpretImageNode)
-		.with({ node: { type: 'question-text' } }, interpretQuestionTextNode)
-		.with({ node: { type: 'question-enum' } }, interpretQuestionEnumNode)
-		.with({ node: { type: 'question-number' } }, interpretQuestionNumberNode)
-		.with({ node: { type: 'question-boolean' } }, interpretQuestionBooleanNode)
-		.with({ node: { type: 'question-file' } }, interpretQuestionFileNode)
-		.with({ node: { type: 'question-address' } }, interpretQuestionAddressNode)
-		.with({ node: { type: 'abandon-flow' } }, interpretAbandonFlowNode)
-		.with({ node: { type: 'complete-flow' } }, interpretCompleteFlowNode)
-		.with({ node: { type: P.union('jump', 'if-block') } }, ({ next }) => next())
-		.exhaustive();
-}
-
-async function interpretTextNode({ chat, next, node }: InterpretNodeParams<'text'>) {
-	await chat.sendMessage({ author: 'bot', type: 'text', text: node.data.text });
-	next();
-}
-
-async function interpretImageNode({ chat, next, node }: InterpretNodeParams<'image'>) {
-	await chat.sendMessage({
-		author: 'bot',
-		type: 'image',
-		url: node.data.url,
-		height: node.data.height,
-		width: node.data.width,
-	});
-	next();
-}
-
-async function interpretQuestionTextNode({ chat, next, node }: InterpretNodeParams<'question-text'>) {
-	await chat.sendMessage({ author: 'bot', type: 'text', text: node.data.question });
-	const reply = await chat.userInput({
-		key: node.data.key,
-		type: 'text',
-		config: { placeholder: node.data.placeholder, format: node.data.format },
-	});
-	await chat.sendMessage({ author: 'user', type: 'text', text: reply.value });
-	next();
-}
-
-async function interpretQuestionNumberNode({ chat, next, node }: InterpretNodeParams<'question-number'>) {
-	await chat.sendMessage({ author: 'bot', type: 'text', text: node.data.question });
-	const reply = await chat.userInput({
-		key: node.data.key,
-		type: 'text',
-		config: { placeholder: node.data.placeholder, format: 'text' },
-	});
-	await chat.sendMessage({ author: 'user', type: 'text', text: reply.value });
-	next();
-}
-
-async function interpretQuestionEnumNode({ chat, next, node }: InterpretNodeParams<'question-enum'>) {
-	await chat.sendMessage({ author: 'bot', type: 'text', text: node.data.question });
-	const reply = await chat.userInput({
-		key: node.data.key,
-		type: 'multiple-choice',
-		config: node.data,
-	});
-	await chat.sendMessage({ author: 'user', type: 'text', text: reply.value.join(', ') });
-	next();
-}
-
-async function interpretQuestionBooleanNode({ chat, next, node }: InterpretNodeParams<'question-boolean'>) {
-	await chat.sendMessage({ author: 'bot', type: 'text', text: node.data.question });
-	const input = await chat.userInput({
-		key: node.data.key,
-		type: 'boolean',
-		config: {
-			labels: {
-				true: node.data.trueLabel,
-				false: node.data.falseLabel,
-			},
-		},
-	});
-	const reply = input.value;
-	const labelMap = {
-		true: node.data.trueLabel,
-		false: node.data.falseLabel,
-	};
-	await chat.sendMessage({ author: 'user', type: 'text', text: labelMap[reply] });
-	next();
-}
-
-async function interpretQuestionAddressNode({ chat, next }: InterpretNodeParams<'question-address'>) {
-	await chat.sendMessage({ author: 'bot', type: 'text', text: 'Address questions are not implemented yet' });
-	next();
-}
-
-async function interpretQuestionFileNode({ node, chat, next }: InterpretNodeParams<'question-file'>) {
-	await chat.sendMessage({ author: 'bot', type: 'text', text: node.data.question });
-	const files = await chat.userInput({
-		key: node.data.key,
-		type: 'file',
-		config: {
-			extensions: node.data.extensions,
-			fileSizeLimitKib: node.data.maxSizeKb,
-			allowMultiple: node.data.multiple === true,
-		},
-	});
-	for await (const file of files.value) {
-		await chat.sendMessage({ author: 'user', type: 'file', fileName: file.name, fileSizeKb: file.sizeKb });
-	}
-	next();
-}
-
-async function interpretAbandonFlowNode({ chat, next, node }: InterpretNodeParams<'abandon-flow'>) {
-	if (node.data.text) {
-		await chat.sendMessage({ author: 'bot', type: 'text', text: node.data.text });
-	}
-	next();
-}
-
-async function interpretCompleteFlowNode({ chat, next, node }: InterpretNodeParams<'complete-flow'>) {
-	if (node.data.text) {
-		await chat.sendMessage({ author: 'bot', type: 'text', text: node.data.text });
-	}
-	next();
-}
-
-const stringOrStringArray = P.union(P.string, P.array(P.string));
-
-const isIfBlockConditionMet = (ifBlock: IfBlockNode, submissions?: KeyToSubmissionMap) => {
-	const answer = submissions?.[ifBlock.data.compareKey];
-	if (!answer) return false;
-
-	return (
-		match({ ...ifBlock.data, answer })
-			.with({ compare: 'equals' }, ({ compareValue }) => {
-				if (typeof answer.value === 'string' || typeof answer.value === 'boolean')
-					return compareValue === answer.value.toString();
-				return false;
-			})
-			.with({ compare: 'notEquals' }, ({ compareValue }) => {
-				if (typeof answer.value === 'string' || typeof answer.value === 'boolean')
-					return compareValue !== answer.value.toString();
-				return false;
-			})
-			.with({ compare: 'contains', answer: { value: stringOrStringArray } }, ({ compareValue, answer }) =>
-				answer.value.includes(compareValue),
-			)
-			.with(
-				{ compare: 'notContains', answer: { value: stringOrStringArray } },
-				({ compareValue, answer }) => !answer.value.includes(compareValue),
-			)
-			// There cannot be conditions for files yet
-			.with({ answer: { type: 'file' } }, () => false)
-			.exhaustive()
-	);
-};
-
-export function getNextNodeId(fromNode: FlowNode, submissions?: KeyToSubmissionMap) {
-	return match(fromNode)
-		.with({ type: 'jump' }, jumpNode => jumpNode.data.targetId)
-		.with({ type: 'if-block' }, ifBlockNode => {
-			if (isIfBlockConditionMet(ifBlockNode, submissions)) return ifBlockNode.branchId;
-			return ifBlockNode.nextId;
-		})
-		.otherwise(node => node.nextId);
-}

package/src/mocks/browser.ts

@@ -1,5 +0,0 @@
-import { setupWorker } from 'msw/browser';
-
-import { handlers } from './handlers';
-
-export const worker = setupWorker(...handlers);