@mmapp/player-core 0.1.0-alpha.1

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@mmapp/player-core",
+  "version": "0.1.0-alpha.1",
+  "description": "Framework-agnostic workflow engine for browser-side state machines, expression evaluation, and event-driven reactions",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest --watch",
+    "test:coverage": "vitest --coverage",
+    "type-check": "tsc --noEmit"
+  },
+  "keywords": [
+    "workflow",
+    "state-machine",
+    "expression-engine",
+    "player",
+    "reactive"
+  ],
+  "author": "MindMatrix Team",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/package.json.backup

@@ -0,0 +1,35 @@
+{
+  "name": "@mmapp/player-core",
+  "version": "0.1.0-alpha.1",
+  "description": "Framework-agnostic workflow engine for browser-side state machines, expression evaluation, and event-driven reactions",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest --watch",
+    "test:coverage": "vitest --coverage",
+    "type-check": "tsc --noEmit"
+  },
+  "keywords": [
+    "workflow",
+    "state-machine",
+    "expression-engine",
+    "player",
+    "reactive"
+  ],
+  "author": "MindMatrix Team",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/__tests__/actions.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ActionDispatcher } from '../actions/dispatcher';
+import { createEvaluator, WEB_FAILURE_POLICIES, clearExpressionCache } from '../expression';
+import type { Evaluator, ExpressionContext } from '../expression/types';
+import type { ActionDefinition } from '../actions/types';
+
+describe('ActionDispatcher', () => {
+  let dispatcher: ActionDispatcher;
+  let evaluator: Evaluator;
+  let ctx: ExpressionContext;
+
+  beforeEach(() => {
+    clearExpressionCache();
+    dispatcher = new ActionDispatcher();
+    evaluator = createEvaluator({
+      functions: [],
+      failurePolicy: WEB_FAILURE_POLICIES.DURING_ACTION,
+    });
+    ctx = {
+      state_data: { count: 5 },
+      memory: {},
+      current_state: 'active',
+      status: 'ACTIVE',
+      count: 5,
+    };
+  });
+
+  describe('register/unregister', () => {
+    it('registers a handler', () => {
+      dispatcher.register('log', () => {});
+      expect(dispatcher.has('log')).toBe(true);
+      expect(dispatcher.size).toBe(1);
+    });
+
+    it('unregisters a handler', () => {
+      dispatcher.register('log', () => {});
+      dispatcher.unregister('log');
+      expect(dispatcher.has('log')).toBe(false);
+    });
+
+    it('clears all handlers', () => {
+      dispatcher.register('a', () => {});
+      dispatcher.register('b', () => {});
+      dispatcher.clear();
+      expect(dispatcher.size).toBe(0);
+    });
+  });
+
+  describe('execute', () => {
+    it('executes actions with registered handlers', async () => {
+      const handler = vi.fn();
+      dispatcher.register('notify', handler);
+
+      const actions: ActionDefinition[] = [
+        { type: 'notify', config: { message: 'hello' } },
+      ];
+
+      const results = await dispatcher.execute(actions, ctx);
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(true);
+      expect(results[0].type).toBe('notify');
+      expect(handler).toHaveBeenCalledWith({ message: 'hello' }, ctx);
+    });
+
+    it('returns error result for missing handlers', async () => {
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const actions: ActionDefinition[] = [
+        { type: 'unknown', config: {} },
+      ];
+
+      const results = await dispatcher.execute(actions, ctx);
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toContain('No handler');
+      warn.mockRestore();
+    });
+
+    it('captures handler errors without throwing', async () => {
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      dispatcher.register('bad', () => { throw new Error('boom'); });
+
+      const actions: ActionDefinition[] = [
+        { type: 'bad', config: {} },
+      ];
+
+      const results = await dispatcher.execute(actions, ctx);
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toBe('boom');
+      warn.mockRestore();
+    });
+
+    it('executes actions sequentially', async () => {
+      const order: number[] = [];
+      dispatcher.register('step', async (config) => {
+        order.push(config.n as number);
+      });
+
+      const actions: ActionDefinition[] = [
+        { type: 'step', config: { n: 1 } },
+        { type: 'step', config: { n: 2 } },
+        { type: 'step', config: { n: 3 } },
+      ];
+
+      await dispatcher.execute(actions, ctx);
+      expect(order).toEqual([1, 2, 3]);
+    });
+
+    it('skips actions whose condition evaluates to false', async () => {
+      const handler = vi.fn();
+      dispatcher.register('conditional', handler);
+
+      const actions: ActionDefinition[] = [
+        { type: 'conditional', config: {}, condition: 'gt(count, 100)' },
+      ];
+
+      const results = await dispatcher.execute(actions, ctx, evaluator);
+      expect(results).toHaveLength(0); // skipped, not in results
+      expect(handler).not.toHaveBeenCalled();
+    });
+
+    it('executes actions whose condition evaluates to true', async () => {
+      const handler = vi.fn();
+      dispatcher.register('conditional', handler);
+
+      const actions: ActionDefinition[] = [
+        { type: 'conditional', config: { x: 1 }, condition: 'gt(count, 3)' },
+      ];
+
+      const results = await dispatcher.execute(actions, ctx, evaluator);
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(true);
+    });
+
+    it('skips condition check when no evaluator provided', async () => {
+      const handler = vi.fn();
+      dispatcher.register('nocond', handler);
+
+      const actions: ActionDefinition[] = [
+        { type: 'nocond', config: {}, condition: 'gt(count, 100)' },
+      ];
+
+      // Without evaluator, condition is not checked → action executes
+      const results = await dispatcher.execute(actions, ctx);
+      expect(results).toHaveLength(1);
+      expect(handler).toHaveBeenCalledOnce();
+    });
+
+    it('handles empty action list', async () => {
+      const results = await dispatcher.execute([], ctx);
+      expect(results).toHaveLength(0);
+    });
+
+    it('continues execution after one action fails', async () => {
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const good = vi.fn();
+      dispatcher.register('bad', () => { throw new Error('fail'); });
+      dispatcher.register('good', good);
+
+      const actions: ActionDefinition[] = [
+        { type: 'bad', config: {} },
+        { type: 'good', config: {} },
+      ];
+
+      const results = await dispatcher.execute(actions, ctx);
+      expect(results).toHaveLength(2);
+      expect(results[0].success).toBe(false);
+      expect(results[1].success).toBe(true);
+      expect(good).toHaveBeenCalledOnce();
+      warn.mockRestore();
+    });
+
+    it('handles async handlers', async () => {
+      dispatcher.register('async_action', async (config) => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+      });
+
+      const actions: ActionDefinition[] = [
+        { type: 'async_action', config: {} },
+      ];
+
+      const results = await dispatcher.execute(actions, ctx);
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(true);
+    });
+  });
+});