@mmapp/react-compiler 0.1.0-alpha.1 → 0.1.0-alpha.3

package/src/__tests__/model-transitions.test.ts

@@ -1,183 +0,0 @@
-/**
- * Model Transitions Tests — validates transition extraction with guards, roles, auto.
- */
-
-import { describe, it, expect } from 'vitest';
-import { transformSync } from '@babel/core';
-import babelPlugin from '../babel';
-import type { IRWorkflowDefinition } from '@mindmatrix/player-core';
-
-function compileModel(code: string): IRWorkflowDefinition {
-  const result = transformSync(code, {
-    filename: 'models/test.ts',
-    plugins: [[babelPlugin, { mode: 'strict' }]],
-    parserOpts: { plugins: ['typescript'], attachComment: true },
-  });
-  return (result as any)?.metadata?.mindmatrixIR;
-}
-
-describe('Model Transitions', () => {
-  it('should extract transitions with from/to', () => {
-    const ir = compileModel(`
-      export interface Task {
-        status: 'todo' | 'done';
-      }
-      export const transitions = {
-        complete: { from: 'todo', to: 'done' },
-      };
-    `);
-
-    expect(ir.transitions).toHaveLength(1);
-    expect(ir.transitions[0].name).toBe('complete');
-    expect(ir.transitions[0].from).toEqual(['todo']);
-    expect(ir.transitions[0].to).toBe('done');
-  });
-
-  it('should extract transitions with from as array', () => {
-    const ir = compileModel(`
-      export interface Item {
-        status: 'draft' | 'review' | 'published';
-      }
-      export const transitions = {
-        publish: { from: ['draft', 'review'], to: 'published' },
-      };
-    `);
-
-    expect(ir.transitions[0].from).toEqual(['draft', 'review']);
-  });
-
-  it('should extract guard as condition expression', () => {
-    const ir = compileModel(`
-      export interface Doc {
-        status: 'draft' | 'published';
-      }
-      export const transitions = {
-        publish: { from: 'draft', to: 'published', guard: '$user.role == "admin"' },
-      };
-    `);
-
-    const conditions = ir.transitions[0].conditions;
-    expect(conditions).toBeDefined();
-    expect(conditions!.length).toBeGreaterThan(0);
-    // Guard parsed into condition
-    const cond = conditions![0];
-    expect(cond.field).toBe('$user.role');
-    expect(cond.operator).toBe('eq');
-    expect(cond.value).toBe('admin');
-  });
-
-  it('should extract roles', () => {
-    const ir = compileModel(`
-      export interface Chan {
-        status: 'active' | 'archived';
-      }
-      export const transitions = {
-        archive: { from: 'active', to: 'archived', roles: ['admin', 'owner'] },
-      };
-    `);
-
-    expect(ir.transitions[0].roles).toEqual(['admin', 'owner']);
-  });
-
-  it('should extract auto flag', () => {
-    const ir = compileModel(`
-      export interface Msg {
-        status: 'sent' | 'delivered';
-      }
-      export const transitions = {
-        deliver: { from: 'sent', to: 'delivered', auto: true },
-      };
-    `);
-
-    expect(ir.transitions[0].auto).toBe(true);
-  });
-
-  it('should extract required_fields', () => {
-    const ir = compileModel(`
-      export interface Form {
-        status: 'draft' | 'submitted';
-      }
-      export const transitions = {
-        submit: { from: 'draft', to: 'submitted', required_fields: ['name', 'email'] },
-      };
-    `);
-
-    expect(ir.transitions[0].required_fields).toEqual(['name', 'email']);
-  });
-
-  it('should extract description', () => {
-    const ir = compileModel(`
-      export interface Flow {
-        status: 'a' | 'b';
-      }
-      export const transitions = {
-        advance: { from: 'a', to: 'b', description: 'Move to next stage' },
-      };
-    `);
-
-    expect(ir.transitions[0].description).toBe('Move to next stage');
-  });
-
-  it('should create states referenced by transitions', () => {
-    const ir = compileModel(`
-      export interface Process {
-        status: 'start' | 'end';
-      }
-      export const transitions = {
-        finish: { from: 'start', to: 'end' },
-      };
-    `);
-
-    const stateNames = ir.states.map((s) => s.name);
-    expect(stateNames).toContain('start');
-    expect(stateNames).toContain('end');
-  });
-
-  it('should handle multiple transitions', () => {
-    const ir = compileModel(`
-      export interface Pipeline {
-        status: 'draft' | 'review' | 'approved' | 'rejected';
-      }
-      export const transitions = {
-        submit: { from: 'draft', to: 'review' },
-        approve: { from: 'review', to: 'approved', roles: ['reviewer'] },
-        reject: { from: 'review', to: 'rejected', roles: ['reviewer'] },
-        revise: { from: ['approved', 'rejected'], to: 'draft' },
-      };
-    `);
-
-    expect(ir.transitions).toHaveLength(4);
-    const names = ir.transitions.map((t) => t.name);
-    expect(names).toEqual(['submit', 'approve', 'reject', 'revise']);
-  });
-
-  it('should handle guard with non-equality operators', () => {
-    const ir = compileModel(`
-      export interface Quota {
-        status: 'open' | 'full';
-      }
-      export const transitions = {
-        fill: { from: 'open', to: 'full', guard: '$instance.memberCount >= 100' },
-      };
-    `);
-
-    const cond = ir.transitions[0].conditions![0];
-    expect(cond.field).toBe('$instance.memberCount');
-    expect(cond.operator).toBe('gte');
-    expect(cond.value).toBe(100);
-  });
-
-  it('should fall back to expression for complex guards', () => {
-    const ir = compileModel(`
-      export interface Complex {
-        status: 'a' | 'b';
-      }
-      export const transitions = {
-        advance: { from: 'a', to: 'b', guard: 'canAdvance($instance, $user)' },
-      };
-    `);
-
-    const cond = ir.transitions[0].conditions![0];
-    expect(cond.expression).toBe('canAdvance($instance, $user)');
-  });
-});

package/src/__tests__/nrt-action-trace.test.ts

@@ -1,391 +0,0 @@
-/**
- * NRT & Action Trace Tests — validates testing architecture types and utilities.
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  createEmptyNRT,
-  findNode,
-  findVisibleNodes,
-  findInteractiveNodes,
-  countNodes,
-  compareNRT,
-  createActionRecorder,
-  getTransitionPath,
-  getFinalState,
-  countByKind,
-  hasTransition,
-} from '@mindmatrix/player-core';
-import type { NRT, NRTNode } from '@mindmatrix/player-core';
-
-// =============================================================================
-// NRT Tests
-// =============================================================================
-
-describe('NRT (Normalized Render Trace)', () => {
-  function createTestNRT(): NRT {
-    return {
-      version: 1,
-      root: {
-        id: 'root',
-        type: 'Stack',
-        visible: true,
-        children: [
-          {
-            id: 'heading',
-            type: 'Heading',
-            text: 'Welcome',
-            visible: true,
-            children: [],
-          },
-          {
-            id: 'input',
-            type: 'TextInput',
-            value: '',
-            visible: true,
-            enabled: true,
-            binding: 'name',
-            children: [],
-          },
-          {
-            id: 'submit-btn',
-            type: 'Button',
-            text: 'Submit',
-            visible: true,
-            enabled: true,
-            events: {
-              click: {
-                kind: 'transition',
-                target: { workflow: 'form', transition: 'submit' },
-              },
-            },
-            children: [],
-          },
-          {
-            id: 'hidden-section',
-            type: 'Section',
-            visible: false,
-            children: [
-              {
-                id: 'hidden-text',
-                type: 'Text',
-                text: 'Hidden',
-                visible: false,
-                children: [],
-              },
-            ],
-          },
-        ],
-      },
-    };
-  }
-
-  it('should create an empty NRT', () => {
-    const nrt = createEmptyNRT();
-    expect(nrt.version).toBe(1);
-    expect(nrt.root.type).toBe('Root');
-    expect(nrt.root.children).toHaveLength(0);
-  });
-
-  it('should find a node by ID', () => {
-    const nrt = createTestNRT();
-    const node = findNode(nrt, 'submit-btn');
-    expect(node).toBeDefined();
-    expect(node!.type).toBe('Button');
-    expect(node!.text).toBe('Submit');
-  });
-
-  it('should return undefined for non-existent node', () => {
-    const nrt = createTestNRT();
-    expect(findNode(nrt, 'nonexistent')).toBeUndefined();
-  });
-
-  it('should find visible nodes', () => {
-    const nrt = createTestNRT();
-    const visible = findVisibleNodes(nrt);
-    // root + heading + input + submit-btn = 4 (hidden section and text excluded)
-    expect(visible.length).toBe(4);
-  });
-
-  it('should find interactive nodes', () => {
-    const nrt = createTestNRT();
-    const interactive = findInteractiveNodes(nrt);
-    expect(interactive).toHaveLength(1);
-    expect(interactive[0].id).toBe('submit-btn');
-  });
-
-  it('should count all nodes', () => {
-    const nrt = createTestNRT();
-    expect(countNodes(nrt)).toBe(6); // root + 4 children + 1 nested
-  });
-});
-
-describe('NRT Comparator', () => {
-  it('should detect no changes for identical snapshots', () => {
-    const nrt: NRT = {
-      version: 1,
-      root: {
-        id: 'root',
-        type: 'Stack',
-        visible: true,
-        children: [
-          { id: 'text', type: 'Text', text: 'Hello', visible: true, children: [] },
-        ],
-      },
-    };
-
-    const diff = compareNRT(nrt, nrt);
-    expect(diff.equal).toBe(true);
-    expect(diff.changes).toHaveLength(0);
-  });
-
-  it('should detect text changes', () => {
-    const before: NRT = {
-      version: 1,
-      root: {
-        id: 'root',
-        type: 'Stack',
-        visible: true,
-        children: [
-          { id: 'text', type: 'Text', text: 'Hello', visible: true, children: [] },
-        ],
-      },
-    };
-
-    const after: NRT = {
-      version: 1,
-      root: {
-        id: 'root',
-        type: 'Stack',
-        visible: true,
-        children: [
-          { id: 'text', type: 'Text', text: 'World', visible: true, children: [] },
-        ],
-      },
-    };
-
-    const diff = compareNRT(before, after);
-    expect(diff.equal).toBe(false);
-    expect(diff.changes.some((c) => c.field === 'text')).toBe(true);
-  });
-
-  it('should detect visibility changes', () => {
-    const before: NRT = {
-      version: 1,
-      root: {
-        id: 'root',
-        type: 'Stack',
-        visible: true,
-        children: [
-          { id: 'section', type: 'Section', visible: true, children: [] },
-        ],
-      },
-    };
-
-    const after: NRT = {
-      version: 1,
-      root: {
-        id: 'root',
-        type: 'Stack',
-        visible: true,
-        children: [
-          { id: 'section', type: 'Section', visible: false, children: [] },
-        ],
-      },
-    };
-
-    const diff = compareNRT(before, after);
-    expect(diff.equal).toBe(false);
-    expect(diff.changes.some((c) => c.field === 'visible')).toBe(true);
-  });
-
-  it('should detect added nodes', () => {
-    const before: NRT = {
-      version: 1,
-      root: {
-        id: 'root',
-        type: 'Stack',
-        visible: true,
-        children: [],
-      },
-    };
-
-    const after: NRT = {
-      version: 1,
-      root: {
-        id: 'root',
-        type: 'Stack',
-        visible: true,
-        children: [
-          { id: 'new', type: 'Text', text: 'New', visible: true, children: [] },
-        ],
-      },
-    };
-
-    const diff = compareNRT(before, after);
-    expect(diff.equal).toBe(false);
-    expect(diff.changes.some((c) => c.type === 'added')).toBe(true);
-  });
-
-  it('should detect removed nodes', () => {
-    const before: NRT = {
-      version: 1,
-      root: {
-        id: 'root',
-        type: 'Stack',
-        visible: true,
-        children: [
-          { id: 'old', type: 'Text', text: 'Old', visible: true, children: [] },
-        ],
-      },
-    };
-
-    const after: NRT = {
-      version: 1,
-      root: {
-        id: 'root',
-        type: 'Stack',
-        visible: true,
-        children: [],
-      },
-    };
-
-    const diff = compareNRT(before, after);
-    expect(diff.equal).toBe(false);
-    expect(diff.changes.some((c) => c.type === 'removed')).toBe(true);
-  });
-
-  it('should detect workflow state changes', () => {
-    const before: NRT = {
-      version: 1,
-      workflowState: 'draft',
-      root: { id: 'root', type: 'Root', visible: true, children: [] },
-    };
-
-    const after: NRT = {
-      version: 1,
-      workflowState: 'active',
-      root: { id: 'root', type: 'Root', visible: true, children: [] },
-    };
-
-    const diff = compareNRT(before, after);
-    expect(diff.equal).toBe(false);
-    expect(diff.changes.some((c) => c.field === 'workflowState')).toBe(true);
-  });
-});
-
-// =============================================================================
-// Action Trace Tests
-// =============================================================================
-
-describe('Action Trace', () => {
-  it('should create a recorder', () => {
-    const recorder = createActionRecorder('counter');
-    expect(recorder).toBeDefined();
-    expect(recorder.getTrace().workflowSlug).toBe('counter');
-  });
-
-  it('should record transitions', () => {
-    const recorder = createActionRecorder('counter');
-    recorder.recordTransition('increment', 'idle', 'counting');
-    recorder.recordTransition('reset', 'counting', 'idle');
-
-    const trace = recorder.getTrace();
-    expect(trace.ticks).toHaveLength(2);
-    expect(trace.ticks[0].kind).toBe('transition');
-    expect(trace.ticks[0].name).toBe('increment');
-    expect(trace.ticks[0].fromState).toBe('idle');
-    expect(trace.ticks[0].toState).toBe('counting');
-  });
-
-  it('should auto-increment tick numbers', () => {
-    const recorder = createActionRecorder('test');
-    recorder.recordAction('first');
-    recorder.recordAction('second');
-    recorder.recordAction('third');
-
-    const trace = recorder.getTrace();
-    expect(trace.ticks[0].tick).toBe(0);
-    expect(trace.ticks[1].tick).toBe(1);
-    expect(trace.ticks[2].tick).toBe(2);
-  });
-
-  it('should record different action kinds', () => {
-    const recorder = createActionRecorder('test');
-    recorder.recordTransition('t1', 'a', 'b');
-    recorder.recordAction('a1');
-    recorder.recordTimer('timer1');
-    recorder.recordQuery('q1');
-    recorder.recordMutation('m1');
-    recorder.recordEvent('e1');
-    recorder.recordError('err1');
-
-    const counts = countByKind(recorder.getTrace());
-    expect(counts.transition).toBe(1);
-    expect(counts.action).toBe(1);
-    expect(counts.timer).toBe(1);
-    expect(counts.query).toBe(1);
-    expect(counts.mutation).toBe(1);
-    expect(counts.event).toBe(1);
-    expect(counts.error).toBe(1);
-  });
-
-  it('should get transition path', () => {
-    const recorder = createActionRecorder('test');
-    recorder.recordTransition('start', 'draft', 'active');
-    recorder.recordAction('notify');
-    recorder.recordTransition('archive', 'active', 'archived');
-
-    const path = getTransitionPath(recorder.getTrace());
-    expect(path).toEqual(['draft → active', 'active → archived']);
-  });
-
-  it('should get final state', () => {
-    const recorder = createActionRecorder('test');
-    recorder.recordTransition('start', 'draft', 'active');
-    recorder.recordTransition('archive', 'active', 'archived');
-
-    expect(getFinalState(recorder.getTrace())).toBe('archived');
-  });
-
-  it('should check for specific transitions', () => {
-    const recorder = createActionRecorder('test');
-    recorder.recordTransition('start', 'draft', 'active');
-
-    expect(hasTransition(recorder.getTrace(), 'draft', 'active')).toBe(true);
-    expect(hasTransition(recorder.getTrace(), 'active', 'archived')).toBe(false);
-  });
-
-  it('should finalize trace with endedAt', () => {
-    const recorder = createActionRecorder('test');
-    recorder.recordAction('work');
-    const trace = recorder.finalize();
-
-    expect(trace.endedAt).toBeDefined();
-    expect(trace.startedAt).toBeDefined();
-  });
-
-  it('should reset recorder', () => {
-    const recorder = createActionRecorder('test');
-    recorder.recordAction('work');
-    recorder.recordAction('more');
-    expect(recorder.getTrace().ticks).toHaveLength(2);
-
-    recorder.reset();
-    expect(recorder.getTrace().ticks).toHaveLength(0);
-  });
-
-  it('should include instance ID', () => {
-    const recorder = createActionRecorder('counter', 'instance-123');
-    expect(recorder.getTrace().instanceId).toBe('instance-123');
-  });
-
-  it('should include detail in ticks', () => {
-    const recorder = createActionRecorder('test');
-    recorder.recordTransition('submit', 'draft', 'review', { user: 'admin', reason: 'ready' });
-
-    const tick = recorder.getTrace().ticks[0];
-    expect(tick.detail.user).toBe('admin');
-    expect(tick.detail.reason).toBe('ready');
-  });
-});