@magicborn/dialogue-forge 0.1.0

package/dist/esm/lib/yarn-runner/__tests__/condition-evaluator.test.js

@@ -0,0 +1,171 @@
+import { describe, it, expect } from 'vitest';
+import { evaluateCondition, evaluateConditions } from '../condition-evaluator';
+import { CONDITION_OPERATOR } from '../../../types/constants';
+describe('condition-evaluator', () => {
+    describe('evaluateCondition', () => {
+        const variables = {
+            flag1: true,
+            flag2: false,
+            flag3: 42,
+            flag4: 'hello',
+            flag5: 0,
+        };
+        const memoryFlags = new Set(['memory1', 'memory2']);
+        it('should evaluate IS_SET correctly', () => {
+            const condition = {
+                flag: 'flag1',
+                operator: CONDITION_OPERATOR.IS_SET,
+            };
+            expect(evaluateCondition(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag2',
+                operator: CONDITION_OPERATOR.IS_SET,
+            };
+            expect(evaluateCondition(condition2, variables, memoryFlags)).toBe(false);
+            const condition3 = {
+                flag: 'memory1',
+                operator: CONDITION_OPERATOR.IS_SET,
+            };
+            expect(evaluateCondition(condition3, variables, memoryFlags)).toBe(true);
+        });
+        it('should evaluate IS_NOT_SET correctly', () => {
+            const condition = {
+                flag: 'nonexistent',
+                operator: CONDITION_OPERATOR.IS_NOT_SET,
+            };
+            expect(evaluateCondition(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag1',
+                operator: CONDITION_OPERATOR.IS_NOT_SET,
+            };
+            expect(evaluateCondition(condition2, variables, memoryFlags)).toBe(false);
+        });
+        it('should evaluate EQUALS correctly', () => {
+            const condition = {
+                flag: 'flag3',
+                operator: CONDITION_OPERATOR.EQUALS,
+                value: 42,
+            };
+            expect(evaluateCondition(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag4',
+                operator: CONDITION_OPERATOR.EQUALS,
+                value: 'hello',
+            };
+            expect(evaluateCondition(condition2, variables, memoryFlags)).toBe(true);
+            const condition3 = {
+                flag: 'flag3',
+                operator: CONDITION_OPERATOR.EQUALS,
+                value: 10,
+            };
+            expect(evaluateCondition(condition3, variables, memoryFlags)).toBe(false);
+        });
+        it('should evaluate NOT_EQUALS correctly', () => {
+            const condition = {
+                flag: 'flag3',
+                operator: CONDITION_OPERATOR.NOT_EQUALS,
+                value: 10,
+            };
+            expect(evaluateCondition(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag3',
+                operator: CONDITION_OPERATOR.NOT_EQUALS,
+                value: 42,
+            };
+            expect(evaluateCondition(condition2, variables, memoryFlags)).toBe(false);
+        });
+        it('should evaluate GREATER_THAN correctly', () => {
+            const condition = {
+                flag: 'flag3',
+                operator: CONDITION_OPERATOR.GREATER_THAN,
+                value: 40,
+            };
+            expect(evaluateCondition(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag3',
+                operator: CONDITION_OPERATOR.GREATER_THAN,
+                value: 50,
+            };
+            expect(evaluateCondition(condition2, variables, memoryFlags)).toBe(false);
+        });
+        it('should evaluate LESS_THAN correctly', () => {
+            const condition = {
+                flag: 'flag3',
+                operator: CONDITION_OPERATOR.LESS_THAN,
+                value: 50,
+            };
+            expect(evaluateCondition(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag3',
+                operator: CONDITION_OPERATOR.LESS_THAN,
+                value: 40,
+            };
+            expect(evaluateCondition(condition2, variables, memoryFlags)).toBe(false);
+        });
+        it('should evaluate GREATER_EQUAL correctly', () => {
+            const condition = {
+                flag: 'flag3',
+                operator: CONDITION_OPERATOR.GREATER_EQUAL,
+                value: 42,
+            };
+            expect(evaluateCondition(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag3',
+                operator: CONDITION_OPERATOR.GREATER_EQUAL,
+                value: 41,
+            };
+            expect(evaluateCondition(condition2, variables, memoryFlags)).toBe(true);
+        });
+        it('should evaluate LESS_EQUAL correctly', () => {
+            const condition = {
+                flag: 'flag3',
+                operator: CONDITION_OPERATOR.LESS_EQUAL,
+                value: 42,
+            };
+            expect(evaluateCondition(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag3',
+                operator: CONDITION_OPERATOR.LESS_EQUAL,
+                value: 43,
+            };
+            expect(evaluateCondition(condition2, variables, memoryFlags)).toBe(true);
+        });
+        it('should treat undefined as 0 for numeric comparisons', () => {
+            const condition = {
+                flag: 'nonexistent',
+                operator: CONDITION_OPERATOR.GREATER_THAN,
+                value: -1,
+            };
+            expect(evaluateCondition(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'nonexistent',
+                operator: CONDITION_OPERATOR.LESS_THAN,
+                value: 1,
+            };
+            expect(evaluateCondition(condition2, variables, memoryFlags)).toBe(true);
+        });
+    });
+    describe('evaluateConditions', () => {
+        const variables = {
+            flag1: true,
+            flag2: 42,
+        };
+        it('should return true when all conditions are true', () => {
+            const conditions = [
+                { flag: 'flag1', operator: CONDITION_OPERATOR.IS_SET },
+                { flag: 'flag2', operator: CONDITION_OPERATOR.EQUALS, value: 42 },
+            ];
+            expect(evaluateConditions(conditions, variables)).toBe(true);
+        });
+        it('should return false when any condition is false', () => {
+            const conditions = [
+                { flag: 'flag1', operator: CONDITION_OPERATOR.IS_SET },
+                { flag: 'flag2', operator: CONDITION_OPERATOR.EQUALS, value: 10 },
+            ];
+            expect(evaluateConditions(conditions, variables)).toBe(false);
+        });
+        it('should return true for empty conditions array', () => {
+            expect(evaluateConditions([], variables)).toBe(true);
+        });
+    });
+});

package/dist/esm/lib/yarn-runner/__tests__/node-processor.test.d.ts

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

package/dist/esm/lib/yarn-runner/__tests__/node-processor.test.js

@@ -0,0 +1,237 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { processNode, isValidNextNode } from '../node-processor';
+import { VariableManager } from '../variable-manager';
+describe('node-processor', () => {
+    let variableManager;
+    let availableNodes;
+    beforeEach(() => {
+        variableManager = new VariableManager({ flag1: true, flag2: 42 });
+        availableNodes = {
+            node1: {
+                id: 'node1',
+                type: 'npc',
+                content: 'Hello',
+                x: 0,
+                y: 0,
+            },
+            node2: {
+                id: 'node2',
+                type: 'npc',
+                content: 'World',
+                x: 0,
+                y: 0,
+            },
+        };
+    });
+    describe('processNode', () => {
+        describe('NPC nodes', () => {
+            it('should process simple NPC node', () => {
+                const node = {
+                    id: 'test',
+                    type: 'npc',
+                    content: 'Hello world',
+                    speaker: 'NPC',
+                    nextNodeId: 'node1',
+                    x: 0,
+                    y: 0,
+                };
+                const result = processNode(node, variableManager);
+                expect(result.content).toBe('Hello world');
+                expect(result.speaker).toBe('NPC');
+                expect(result.nextNodeId).toBe('node1');
+                expect(result.isEnd).toBe(false);
+                expect(result.isPlayerChoice).toBe(false);
+            });
+            it('should mark as end when no nextNodeId', () => {
+                const node = {
+                    id: 'test',
+                    type: 'npc',
+                    content: 'End',
+                    x: 0,
+                    y: 0,
+                };
+                const result = processNode(node, variableManager);
+                expect(result.isEnd).toBe(true);
+                expect(result.nextNodeId).toBeUndefined();
+            });
+        });
+        describe('Player nodes', () => {
+            it('should return choices for player node', () => {
+                const node = {
+                    id: 'test',
+                    type: 'player',
+                    content: '',
+                    choices: [
+                        {
+                            id: 'c1',
+                            text: 'Choice 1',
+                            nextNodeId: 'node1',
+                        },
+                        {
+                            id: 'c2',
+                            text: 'Choice 2',
+                            nextNodeId: 'node2',
+                        },
+                    ],
+                    x: 0,
+                    y: 0,
+                };
+                const result = processNode(node, variableManager);
+                expect(result.isPlayerChoice).toBe(true);
+                expect(result.choices).toHaveLength(2);
+                expect(result.choices?.[0].text).toBe('Choice 1');
+            });
+            it('should filter choices based on conditions', () => {
+                const node = {
+                    id: 'test',
+                    type: 'player',
+                    content: '',
+                    choices: [
+                        {
+                            id: 'c1',
+                            text: 'Choice 1',
+                            nextNodeId: 'node1',
+                            conditions: [
+                                { flag: 'flag1', operator: 'is_set' },
+                            ],
+                        },
+                        {
+                            id: 'c2',
+                            text: 'Choice 2',
+                            nextNodeId: 'node2',
+                            conditions: [
+                                { flag: 'flag3', operator: 'is_set' },
+                            ],
+                        },
+                    ],
+                    x: 0,
+                    y: 0,
+                };
+                const result = processNode(node, variableManager);
+                expect(result.choices).toHaveLength(1);
+                expect(result.choices?.[0].text).toBe('Choice 1');
+            });
+        });
+        describe('Conditional nodes', () => {
+            it('should process conditional node with matching if block', () => {
+                const node = {
+                    id: 'test',
+                    type: 'conditional',
+                    content: '',
+                    conditionalBlocks: [
+                        {
+                            id: 'b1',
+                            type: 'if',
+                            condition: [{ flag: 'flag1', operator: 'is_set' }],
+                            content: 'If content',
+                            speaker: 'Speaker',
+                            nextNodeId: 'node1',
+                        },
+                        {
+                            id: 'b2',
+                            type: 'else',
+                            content: 'Else content',
+                        },
+                    ],
+                    x: 0,
+                    y: 0,
+                };
+                const result = processNode(node, variableManager);
+                expect(result.content).toBe('If content');
+                expect(result.speaker).toBe('Speaker');
+                expect(result.nextNodeId).toBe('node1');
+            });
+            it('should process conditional node with matching elseif block', () => {
+                const node = {
+                    id: 'test',
+                    type: 'conditional',
+                    content: '',
+                    conditionalBlocks: [
+                        {
+                            id: 'b1',
+                            type: 'if',
+                            condition: [{ flag: 'flag3', operator: 'is_set' }],
+                            content: 'If content',
+                        },
+                        {
+                            id: 'b2',
+                            type: 'elseif',
+                            condition: [{ flag: 'flag1', operator: 'is_set' }],
+                            content: 'Elseif content',
+                        },
+                        {
+                            id: 'b3',
+                            type: 'else',
+                            content: 'Else content',
+                        },
+                    ],
+                    x: 0,
+                    y: 0,
+                };
+                const result = processNode(node, variableManager);
+                expect(result.content).toBe('Elseif content');
+            });
+            it('should process conditional node with else block when no conditions match', () => {
+                const node = {
+                    id: 'test',
+                    type: 'conditional',
+                    content: '',
+                    conditionalBlocks: [
+                        {
+                            id: 'b1',
+                            type: 'if',
+                            condition: [{ flag: 'flag3', operator: 'is_set' }],
+                            content: 'If content',
+                        },
+                        {
+                            id: 'b2',
+                            type: 'else',
+                            content: 'Else content',
+                        },
+                    ],
+                    x: 0,
+                    y: 0,
+                };
+                const result = processNode(node, variableManager);
+                expect(result.content).toBe('Else content');
+            });
+            it('should return end when no block matches', () => {
+                const node = {
+                    id: 'test',
+                    type: 'conditional',
+                    content: '',
+                    conditionalBlocks: [
+                        {
+                            id: 'b1',
+                            type: 'if',
+                            condition: [{ flag: 'flag3', operator: 'is_set' }],
+                            content: 'If content',
+                        },
+                    ],
+                    x: 0,
+                    y: 0,
+                };
+                const result = processNode(node, variableManager);
+                expect(result.isEnd).toBe(true);
+                expect(result.content).toBe('');
+            });
+        });
+    });
+    describe('isValidNextNode', () => {
+        it('should return true for valid node ID', () => {
+            expect(isValidNextNode('node1', availableNodes)).toBe(true);
+        });
+        it('should return false for undefined', () => {
+            expect(isValidNextNode(undefined, availableNodes)).toBe(false);
+        });
+        it('should return false for empty string', () => {
+            expect(isValidNextNode('', availableNodes)).toBe(false);
+        });
+        it('should return false for whitespace-only string', () => {
+            expect(isValidNextNode('   ', availableNodes)).toBe(false);
+        });
+        it('should return false for non-existent node', () => {
+            expect(isValidNextNode('nonexistent', availableNodes)).toBe(false);
+        });
+    });
+});

package/dist/esm/lib/yarn-runner/__tests__/variable-manager.test.d.ts

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

package/dist/esm/lib/yarn-runner/__tests__/variable-manager.test.js

@@ -0,0 +1,106 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { VariableManager } from '../variable-manager';
+describe('VariableManager', () => {
+    let manager;
+    beforeEach(() => {
+        manager = new VariableManager();
+    });
+    describe('constructor', () => {
+        it('should initialize with empty state by default', () => {
+            expect(manager.get('test')).toBeUndefined();
+            expect(manager.getAllMemoryFlags().size).toBe(0);
+        });
+        it('should initialize with provided variables', () => {
+            const vars = { flag1: true, flag2: 42 };
+            const manager2 = new VariableManager(vars);
+            expect(manager2.get('flag1')).toBe(true);
+            expect(manager2.get('flag2')).toBe(42);
+        });
+        it('should initialize with provided memory flags', () => {
+            const memoryFlags = new Set(['mem1', 'mem2']);
+            const manager2 = new VariableManager(undefined, memoryFlags);
+            expect(manager2.hasMemoryFlag('mem1')).toBe(true);
+            expect(manager2.hasMemoryFlag('mem2')).toBe(true);
+        });
+    });
+    describe('set and get', () => {
+        it('should set and get boolean values', () => {
+            manager.set('flag1', true);
+            expect(manager.get('flag1')).toBe(true);
+        });
+        it('should set and get number values', () => {
+            manager.set('flag2', 42);
+            expect(manager.get('flag2')).toBe(42);
+        });
+        it('should set and get string values', () => {
+            manager.set('flag3', 'hello');
+            expect(manager.get('flag3')).toBe('hello');
+        });
+        it('should return undefined for unset variables', () => {
+            expect(manager.get('nonexistent')).toBeUndefined();
+        });
+    });
+    describe('memory flags', () => {
+        it('should add memory flags', () => {
+            manager.addMemoryFlag('mem1');
+            expect(manager.hasMemoryFlag('mem1')).toBe(true);
+            expect(manager.get('mem1')).toBe(true);
+        });
+        it('should remove memory flags', () => {
+            manager.addMemoryFlag('mem1');
+            manager.removeMemoryFlag('mem1');
+            expect(manager.hasMemoryFlag('mem1')).toBe(false);
+        });
+        it('should return memory flags as true when getting', () => {
+            manager.addMemoryFlag('mem1');
+            expect(manager.get('mem1')).toBe(true);
+        });
+    });
+    describe('getAllVariables', () => {
+        it('should return a copy of all variables', () => {
+            manager.set('flag1', true);
+            manager.set('flag2', 42);
+            const vars = manager.getAllVariables();
+            expect(vars).toEqual({ flag1: true, flag2: 42 });
+            // Should be a copy, not a reference
+            vars.flag1 = false;
+            expect(manager.get('flag1')).toBe(true);
+        });
+    });
+    describe('getAllMemoryFlags', () => {
+        it('should return a copy of memory flags', () => {
+            manager.addMemoryFlag('mem1');
+            manager.addMemoryFlag('mem2');
+            const flags = manager.getAllMemoryFlags();
+            expect(flags.has('mem1')).toBe(true);
+            expect(flags.has('mem2')).toBe(true);
+            // Should be a copy
+            flags.delete('mem1');
+            expect(manager.hasMemoryFlag('mem1')).toBe(true);
+        });
+    });
+    describe('clearMemoryFlags', () => {
+        it('should clear all memory flags', () => {
+            manager.addMemoryFlag('mem1');
+            manager.addMemoryFlag('mem2');
+            manager.clearMemoryFlags();
+            expect(manager.getAllMemoryFlags().size).toBe(0);
+        });
+    });
+    describe('reset', () => {
+        it('should reset to initial state', () => {
+            manager.set('flag1', true);
+            manager.addMemoryFlag('mem1');
+            manager.reset();
+            expect(manager.get('flag1')).toBeUndefined();
+            expect(manager.hasMemoryFlag('mem1')).toBe(false);
+        });
+        it('should reset to provided state', () => {
+            manager.set('flag1', true);
+            manager.reset({ flag2: 42 }, new Set(['mem2']));
+            expect(manager.get('flag1')).toBeUndefined();
+            expect(manager.get('flag2')).toBe(42);
+            expect(manager.hasMemoryFlag('mem2')).toBe(true);
+        });
+    });
+});

package/dist/esm/lib/yarn-runner/condition-evaluator.d.ts

@@ -0,0 +1,12 @@
+import { Condition } from '../../types';
+export interface VariableState {
+    [key: string]: boolean | number | string | undefined;
+}
+/**
+ * Evaluates a single condition against variable state
+ */
+export declare function evaluateCondition(condition: Condition, variables: VariableState, memoryFlags?: Set<string>): boolean;
+/**
+ * Evaluates multiple conditions with AND logic
+ */
+export declare function evaluateConditions(conditions: Condition[], variables: VariableState, memoryFlags?: Set<string>): boolean;

package/dist/esm/lib/yarn-runner/condition-evaluator.js

@@ -0,0 +1,56 @@
+import { CONDITION_OPERATOR } from '../../types/constants';
+/**
+ * Evaluates a single condition against variable state
+ */
+export function evaluateCondition(condition, variables, memoryFlags) {
+    let value = variables[condition.flag];
+    // If not in variables, check memoryFlags (dialogue flags)
+    if (value === undefined && memoryFlags) {
+        value = memoryFlags.has(condition.flag) ? true : undefined;
+    }
+    // For numeric comparisons, treat undefined as 0
+    const numericOperators = [
+        CONDITION_OPERATOR.GREATER_THAN,
+        CONDITION_OPERATOR.LESS_THAN,
+        CONDITION_OPERATOR.GREATER_EQUAL,
+        CONDITION_OPERATOR.LESS_EQUAL
+    ];
+    const isNumericComparison = numericOperators.includes(condition.operator);
+    if (isNumericComparison && value === undefined) {
+        value = 0;
+    }
+    switch (condition.operator) {
+        case CONDITION_OPERATOR.IS_SET:
+            return value !== undefined && value !== false && value !== 0 && value !== '';
+        case CONDITION_OPERATOR.IS_NOT_SET:
+            return value === undefined || value === false || value === 0 || value === '';
+        case CONDITION_OPERATOR.EQUALS:
+            return value === condition.value;
+        case CONDITION_OPERATOR.NOT_EQUALS:
+            return value !== condition.value;
+        case CONDITION_OPERATOR.GREATER_THAN:
+            const numValueGT = typeof value === 'number' ? value : (typeof value === 'string' ? parseFloat(value) : 0);
+            const numCondGT = typeof condition.value === 'number' ? condition.value : parseFloat(String(condition.value));
+            return !isNaN(numValueGT) && !isNaN(numCondGT) && numValueGT > numCondGT;
+        case CONDITION_OPERATOR.LESS_THAN:
+            const numValueLT = typeof value === 'number' ? value : (typeof value === 'string' ? parseFloat(value) : 0);
+            const numCondLT = typeof condition.value === 'number' ? condition.value : parseFloat(String(condition.value));
+            return !isNaN(numValueLT) && !isNaN(numCondLT) && numValueLT < numCondLT;
+        case CONDITION_OPERATOR.GREATER_EQUAL:
+            const numValueGE = typeof value === 'number' ? value : (typeof value === 'string' ? parseFloat(value) : 0);
+            const numCondGE = typeof condition.value === 'number' ? condition.value : parseFloat(String(condition.value));
+            return !isNaN(numValueGE) && !isNaN(numCondGE) && numValueGE >= numCondGE;
+        case CONDITION_OPERATOR.LESS_EQUAL:
+            const numValueLE = typeof value === 'number' ? value : (typeof value === 'string' ? parseFloat(value) : 0);
+            const numCondLE = typeof condition.value === 'number' ? condition.value : parseFloat(String(condition.value));
+            return !isNaN(numValueLE) && !isNaN(numCondLE) && numValueLE <= numCondLE;
+        default:
+            return true;
+    }
+}
+/**
+ * Evaluates multiple conditions with AND logic
+ */
+export function evaluateConditions(conditions, variables, memoryFlags) {
+    return conditions.every(cond => evaluateCondition(cond, variables, memoryFlags));
+}

package/dist/esm/lib/yarn-runner/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Yarn Spinner Runner
+ *
+ * Modular execution engine for running Yarn Spinner dialogue trees.
+ * This module provides the core logic for processing nodes, evaluating conditions,
+ * and managing state, separate from the UI components.
+ */
+export { VariableManager } from './variable-manager';
+export { evaluateCondition, evaluateConditions } from './condition-evaluator';
+export { processNode, isValidNextNode, ProcessedNodeResult } from './node-processor';
+export { executeVariableOperation, processVariableOperationsInContent } from './variable-operations';
+export type { VariableState } from './condition-evaluator';

package/dist/esm/lib/yarn-runner/index.js

@@ -0,0 +1,11 @@
+/**
+ * Yarn Spinner Runner
+ *
+ * Modular execution engine for running Yarn Spinner dialogue trees.
+ * This module provides the core logic for processing nodes, evaluating conditions,
+ * and managing state, separate from the UI components.
+ */
+export { VariableManager } from './variable-manager';
+export { evaluateCondition, evaluateConditions } from './condition-evaluator';
+export { processNode, isValidNextNode } from './node-processor';
+export { executeVariableOperation, processVariableOperationsInContent } from './variable-operations';

package/dist/esm/lib/yarn-runner/node-processor.d.ts

@@ -0,0 +1,18 @@
+import { DialogueNode, Choice } from '../../types';
+import { VariableManager } from './variable-manager';
+export interface ProcessedNodeResult {
+    content: string;
+    speaker?: string;
+    nextNodeId?: string;
+    isEnd: boolean;
+    isPlayerChoice: boolean;
+    choices?: Choice[];
+}
+/**
+ * Processes a dialogue node and returns the result
+ */
+export declare function processNode(node: DialogueNode, variableManager: VariableManager): ProcessedNodeResult;
+/**
+ * Validates that a nextNodeId exists and is valid
+ */
+export declare function isValidNextNode(nextNodeId: string | undefined, availableNodes: Record<string, DialogueNode>): boolean;