@inploi/plugin-chatbot 2.1.0 → 2.1.1

package/src/chatbot.utils.ts

@@ -1,56 +0,0 @@
-import { FlowNode } from '@inploi/core/flows';
-
-import { ApplicationSubmission, KeyToSubmissionMap, StartedJobApplication } from './chatbot.state';
-
-export type DistributivePick<T, K extends keyof T> = T extends unknown ? Pick<T, K> : never;
-
-export const getHeadOrThrow = (nodes: FlowNode[]) => {
-	const head = nodes.find(n => n.isHead);
-	if (!head) throw new Error('No head node found');
-	return head;
-};
-
-export const submissionsToPayload = ({
-	application,
-	submissions,
-}: {
-	application: StartedJobApplication;
-	submissions: KeyToSubmissionMap;
-}) => {
-	const payload = {
-		flowId: application.flow.id,
-		jobId: application.job.id,
-		submissions: Object.entries(submissions).reduce(
-			(acc, [key, submission]) => {
-				acc[key] = submission.value;
-				return acc;
-			},
-			{} as Record<string, ApplicationSubmission['value']>,
-		),
-	};
-
-	return payload;
-};
-
-export const isSubmissionOfType =
-	<T extends ApplicationSubmission['type']>(type: T) =>
-	(submission?: ApplicationSubmission): submission is Extract<ApplicationSubmission, { type: T }> => {
-		if (!submission) return false;
-		return submission.type === type;
-	};
-
-export function gzip(string: string) {
-	if (!('CompressionStream' in window)) return string;
-	const byteArray = new TextEncoder().encode(string);
-	const cs = new CompressionStream('gzip');
-	const writer = cs.writable.getWriter();
-	writer.write(byteArray);
-	writer.close();
-	return new Response(cs.readable).text();
-}
-
-export class AbortedError extends Error {
-	constructor() {
-		super('Aborted');
-	}
-}

package/src/index.cdn.ts

@@ -1,12 +0,0 @@
-import { chatbotPlugin } from './chatbot';
-
-declare global {
-	interface Window {
-		inploi?: {
-			chatbotPlugin?: typeof chatbotPlugin;
-		};
-	}
-}
-
-if (!window.inploi) throw new Error('Please insert the SDK script tag above the plugins.');
-window.inploi.chatbotPlugin = chatbotPlugin;

package/src/index.dev.ts

@@ -1,31 +0,0 @@
-/** This file is only used for dev mode. The build output is index.ts */
-import { initialiseSdk, 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(() => {
-	const sdk = initialiseSdk({
-		env: 'sandbox',
-		logger: inploiBrandedLogger,
-		publishableKey: import.meta.env.VITE_PUBLISHABLE_KEY,
-	});
-
-	// inploi’s hue: 265
-	window.chatbot = sdk.registerPlugin(chatbotPlugin({ hue: 372 }));
-	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,249 +0,0 @@
-import { FlowNode, FlowNodeType, IfBlockNode } from '@inploi/core/flows';
-import { P, match } from 'ts-pattern';
-import { AbortedError, getHeadOrThrow } from '~/chatbot.utils';
-import { ChatInput } from '~/ui/chat-input/chat-input';
-
-import { ApplicationSubmission, ChatMessage, KeyToSubmissionMap } from '../chatbot.state';
-
-export type ChatServiceSendParams = { signal?: AbortSignal; groupId?: string; message: ChatMessage };
-export type ChatService = {
-	send: (params: ChatServiceSendParams) => Promise<void>;
-	input: <TType extends ChatInput['type']>(params: {
-		input: Extract<ChatInput, { type: TType }>;
-		signal?: AbortSignal;
-	}) => 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);
-		try {
-			await interpret({
-				node,
-				submissions,
-				chat: {
-					sendMessage: async message => chatService.send({ groupId: node.id, message, signal: controller.signal }),
-					userInput: async input => chatService.input({ input, signal: controller.signal }),
-				},
-				next: () => {
-					const nextNodeId = getNextNodeId(node, getSubmissions());
-					const nextNode = flow.find(node => node.id === nextNodeId);
-					if (nextNode) {
-						return interpretNode(nextNode);
-					} else onFlowEnd?.(node);
-				},
-			});
-		} catch (e) {
-			// we let aborting the flow be silent
-			if (e instanceof AbortedError) return;
-			throw e;
-		}
-	};
-
-	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 { browserHandlers } from './handlers';
-
-export const worker = setupWorker(...browserHandlers);