@clt-chatbot/scenario-core 1.0.0

package/dist/engine/ChatbotEngine.d.ts

@@ -0,0 +1,12 @@
+import { ScenarioData, ScenarioNode } from '../types/index';
+export declare class ChatbotEngine {
+    private scenario;
+    constructor(scenario: ScenarioData);
+    getNodeById(nodeId: string): ScenarioNode | undefined;
+    interpolateMessage(message: string, slots: Record<string, any>): string;
+    getDeepValue(obj: any, path: string): any;
+    evaluateCondition(slotValue: any, operator: string, conditionValue: any): boolean;
+    getNextNode(currentNodeId: string, sourceHandle?: string | null, slots?: any): ScenarioNode | null;
+    isInteractiveNode(node: ScenarioNode | undefined): boolean;
+    isAutoPassthroughNode(node: ScenarioNode | undefined): boolean;
+}

package/dist/engine/ChatbotEngine.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatbotEngine = void 0;
+class ChatbotEngine {
+    constructor(scenario) {
+        this.scenario = scenario;
+    }
+    getNodeById(nodeId) {
+        return this.scenario.nodes.find(n => n.id === nodeId);
+    }
+    interpolateMessage(message, slots) {
+        if (typeof message !== 'string')
+            return String(message ?? '');
+        return message.replace(/\{\{([^}]+)\}\}/g, (_, path) => {
+            const val = this.getDeepValue(slots, path.trim());
+            return val !== undefined && val !== null ? String(val) : `{{${path}}}`;
+        });
+    }
+    getDeepValue(obj, path) {
+        if (!path)
+            return undefined;
+        const keys = path.split('.');
+        let current = obj;
+        for (const key of keys) {
+            if (current === null || current === undefined)
+                return undefined;
+            current = current[key];
+        }
+        return current;
+    }
+    evaluateCondition(slotValue, operator, conditionValue) {
+        const lowerCaseConditionValue = String(conditionValue ?? '').toLowerCase();
+        const boolConditionValue = lowerCaseConditionValue === 'true';
+        const boolSlotValue = String(slotValue ?? '').toLowerCase() === 'true';
+        if (lowerCaseConditionValue === 'true' || lowerCaseConditionValue === 'false') {
+            switch (operator) {
+                case '==': return boolSlotValue === boolConditionValue;
+                case '!=': return boolSlotValue !== boolConditionValue;
+                default: return false;
+            }
+        }
+        const numSlotValue = slotValue !== null && slotValue !== undefined && slotValue !== '' ? parseFloat(slotValue) : NaN;
+        const numConditionValue = conditionValue !== null && conditionValue !== undefined && conditionValue !== '' ? parseFloat(conditionValue) : NaN;
+        const bothAreNumbers = !isNaN(numSlotValue) && !isNaN(numConditionValue);
+        switch (operator) {
+            case '==': return String(slotValue ?? '') == String(conditionValue ?? '');
+            case '!=': return String(slotValue ?? '') != String(conditionValue ?? '');
+            case '>': return bothAreNumbers && numSlotValue > numConditionValue;
+            case '<': return bothAreNumbers && numSlotValue < numConditionValue;
+            case '>=': return bothAreNumbers && numSlotValue >= numConditionValue;
+            case '<=': return bothAreNumbers && numSlotValue <= numConditionValue;
+            case 'contains': return slotValue != null && String(slotValue).includes(String(conditionValue ?? ''));
+            case '!contains': return slotValue == null || !String(slotValue).includes(String(conditionValue ?? ''));
+            default:
+                console.warn(`Unsupported operator used in condition: ${operator}`);
+                return false;
+        }
+    }
+    getNextNode(currentNodeId, sourceHandle = null, slots = {}) {
+        const { nodes, edges } = this.scenario;
+        const outgoingEdges = edges.filter(e => e.source === currentNodeId);
+        if (outgoingEdges.length === 0)
+            return null;
+        const sourceNode = this.getNodeById(currentNodeId);
+        // Branch node with CONDITION evaluation
+        if (sourceNode?.type === 'branch' && sourceNode.data?.evaluationType === 'CONDITION') {
+            const conditions = sourceNode.data.conditions || [];
+            for (const condition of conditions) {
+                const slotValue = this.getDeepValue(slots, condition.slot);
+                const valueToCompare = condition.valueType === 'slot' ? this.getDeepValue(slots, condition.value) : condition.value;
+                if (this.evaluateCondition(slotValue, condition.operator, valueToCompare)) {
+                    const condIdx = conditions.indexOf(condition);
+                    const handleId = sourceNode.data.replies?.[condIdx]?.value;
+                    if (handleId) {
+                        const edge = outgoingEdges.find(e => e.sourceHandle === handleId);
+                        if (edge)
+                            return this.getNodeById(edge.target) || null;
+                    }
+                }
+            }
+            const defaultEdge = outgoingEdges.find(e => e.sourceHandle === 'default');
+            if (defaultEdge)
+                return this.getNodeById(defaultEdge.target) || null;
+        }
+        // Single edge case
+        if (outgoingEdges.length === 1) {
+            return this.getNodeById(outgoingEdges[0].target) || null;
+        }
+        // Explicit sourceHandle case
+        if (sourceHandle) {
+            const selectedEdge = outgoingEdges.find(e => e.sourceHandle === sourceHandle);
+            if (selectedEdge)
+                return this.getNodeById(selectedEdge.target) || null;
+        }
+        // Fallback to first edge
+        return this.getNodeById(outgoingEdges[0].target) || null;
+    }
+    isInteractiveNode(node) {
+        if (!node)
+            return false;
+        if (node.type === 'message') {
+            return !!(node.data?.replies && node.data.replies.length > 0);
+        }
+        if (node.type === 'form')
+            return true;
+        if (node.type === 'branch') {
+            const evalType = node.data?.evaluationType;
+            return evalType === 'BUTTON' || evalType === 'BUTTON_CLICK';
+        }
+        return node.type === 'slotfilling';
+    }
+    isAutoPassthroughNode(node) {
+        if (!node)
+            return false;
+        return ['setSlot', 'set-slot', 'delay', 'api', 'toast', 'link'].includes(node.type);
+    }
+}
+exports.ChatbotEngine = ChatbotEngine;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './engine/ChatbotEngine';

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./engine/ChatbotEngine"), exports);

package/dist/types/index.d.ts

@@ -0,0 +1,18 @@
+export interface ScenarioNode {
+    id: string;
+    type: string;
+    data: any;
+    parentNode?: string;
+}
+export interface ScenarioEdge {
+    id: string;
+    source: string;
+    target: string;
+    sourceHandle?: string | null;
+}
+export interface ScenarioData {
+    version: string;
+    nodes: ScenarioNode[];
+    edges: ScenarioEdge[];
+    startNodeId?: string | null;
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@clt-chatbot/scenario-core",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build"
+  }
+}