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

package/src/__tests__/during-extractor.test.ts

@@ -1,152 +0,0 @@
-/**
- * During Extractor Tests — validates useWhileIn extraction to IRDuringAction.
- */
-
-import { describe, it, expect } from 'vitest';
-import { transformSync } from '@babel/core';
-import babelPlugin from '../babel';
-import type { IRWorkflowDefinition } from '@mindmatrix/player-core';
-
-function compile(code: string): IRWorkflowDefinition {
-  const result = transformSync(code, {
-    filename: 'test.workflow.tsx',
-    plugins: [[babelPlugin, { mode: 'infer' }]],
-    parserOpts: { plugins: ['jsx', 'typescript'], attachComment: true },
-  });
-  return (result as any)?.metadata?.mindmatrixIR;
-}
-
-describe('During Extractor (useWhileIn)', () => {
-  it('should extract useWhileIn as IRDuringAction on target state', () => {
-    const ir = compile(`
-      export function Counter() {
-        const [count, setCount] = useState(0);
-        useWhileIn('counting', 1000, () => {
-          setCount(prev => prev + 1);
-        });
-        return <div>{count}</div>;
-      }
-    `);
-
-    const countingState = ir.states.find((s) => s.name === 'counting');
-    expect(countingState).toBeDefined();
-    expect(countingState!.during).toHaveLength(1);
-
-    const during = countingState!.during[0];
-    expect(during.id).toMatch(/^during_/);
-    expect(during.type).toBe('interval');
-    expect(during.interval_ms).toBe(1000);
-    expect(during.actions).toHaveLength(1);
-    expect(during.actions[0].type).toBe('set_field');
-    expect(during.actions[0].config.field).toBe('count');
-  });
-
-  it('should handle different interval values', () => {
-    const ir = compile(`
-      export function Timer() {
-        const [ticks, setTicks] = useState(0);
-        useWhileIn('active', 5000, () => {
-          setTicks(prev => prev + 1);
-        });
-        return <div>{ticks}</div>;
-      }
-    `);
-
-    const activeState = ir.states.find((s) => s.name === 'active');
-    expect(activeState!.during[0].interval_ms).toBe(5000);
-  });
-
-  it('should extract multiple actions from callback', () => {
-    const ir = compile(`
-      export function MultiAction() {
-        const [count, setCount] = useState(0);
-        const [log, setLog] = useState('');
-        useWhileIn('running', 2000, () => {
-          setCount(prev => prev + 1);
-          console.log('tick');
-        });
-        return <div>{count}</div>;
-      }
-    `);
-
-    const state = ir.states.find((s) => s.name === 'running');
-    expect(state!.during[0].actions).toHaveLength(2);
-    expect(state!.during[0].actions[0].type).toBe('set_field');
-    expect(state!.during[0].actions[1].type).toBe('log_event');
-  });
-
-  it('should support setField and setMemory in callbacks', () => {
-    const ir = compile(`
-      export function FieldSetter() {
-        const [x, setX] = useState(0);
-        useWhileIn('active', 1000, () => {
-          setField('counter', 42);
-          setMemory('lastTick', 'now');
-        });
-        return <div />;
-      }
-    `);
-
-    const state = ir.states.find((s) => s.name === 'active');
-    const actions = state!.during[0].actions;
-    expect(actions).toHaveLength(2);
-    expect(actions[0].type).toBe('set_field');
-    expect(actions[0].config).toEqual({ field: 'counter', value: 42 });
-    expect(actions[1].type).toBe('set_memory');
-    expect(actions[1].config).toEqual({ key: 'lastTick', value: 'now' });
-  });
-
-  it('should create state if not previously declared', () => {
-    const ir = compile(`
-      export function AutoState() {
-        useWhileIn('polling', 3000, () => {
-          console.log('poll');
-        });
-        return <div />;
-      }
-    `);
-
-    const pollingState = ir.states.find((s) => s.name === 'polling');
-    expect(pollingState).toBeDefined();
-    expect(pollingState!.during).toHaveLength(1);
-  });
-
-  it('should support multiple useWhileIn on same state', () => {
-    const ir = compile(`
-      export function MultiDuring() {
-        const [a, setA] = useState(0);
-        const [b, setB] = useState(0);
-        useWhileIn('active', 1000, () => {
-          setA(prev => prev + 1);
-        });
-        useWhileIn('active', 5000, () => {
-          setB(prev => prev + 1);
-        });
-        return <div />;
-      }
-    `);
-
-    const state = ir.states.find((s) => s.name === 'active');
-    expect(state!.during).toHaveLength(2);
-    expect(state!.during[0].interval_ms).toBe(1000);
-    expect(state!.during[1].interval_ms).toBe(5000);
-  });
-
-  it('should have unique IDs across multiple during actions', () => {
-    const ir = compile(`
-      export function UniqueIds() {
-        useWhileIn('a', 1000, () => { console.log('a'); });
-        useWhileIn('b', 2000, () => { console.log('b'); });
-        return <div />;
-      }
-    `);
-
-    const aState = ir.states.find((s) => s.name === 'a');
-    const bState = ir.states.find((s) => s.name === 'b');
-    const ids = [
-      aState!.during[0].id,
-      bState!.during[0].id,
-    ];
-    expect(new Set(ids).size).toBe(2);
-  });
-});

package/src/__tests__/effect-extractor.test.ts

@@ -1,107 +0,0 @@
-/**
- * Effect Extractor Tests — validates useOnEnter/useOnExit → IRActionDefinition extraction.
- */
-
-import { describe, it, expect } from 'vitest';
-import { transformSync } from '@babel/core';
-import babelPlugin from '../babel';
-
-function compileWorkflow(code: string) {
-  const result = transformSync(code, {
-    filename: 'test.workflow.tsx',
-    plugins: [[babelPlugin, { mode: 'infer' }]],
-    parserOpts: { plugins: ['jsx', 'typescript'] },
-  });
-
-  return (result as any)?.metadata?.mindmatrixIR;
-}
-
-describe('Effect Extractor', () => {
-  it('should extract useOnEnter with setField action', () => {
-    const code = `
-      export function TestWorkflow() {
-        const [count, setCount] = useState(0);
-
-        useOnEnter('active', () => {
-          setCount(1);
-        });
-
-        return <div>{count}</div>;
-      }
-    `;
-
-    const ir = compileWorkflow(code);
-    const activeState = ir.states.find((s: any) => s.name === 'active');
-    expect(activeState).toBeDefined();
-    expect(activeState.on_enter).toHaveLength(1);
-    expect(activeState.on_enter[0]).toMatchObject({
-      type: 'set_field',
-      mode: 'auto',
-      config: { field: 'count', value: 1 },
-    });
-  });
-
-  it('should extract useOnExit with log action', () => {
-    const code = `
-      export function TestWorkflow() {
-        useOnExit('done', () => {
-          console.log('Workflow complete');
-        });
-
-        return <div>Done</div>;
-      }
-    `;
-
-    const ir = compileWorkflow(code);
-    const doneState = ir.states.find((s: any) => s.name === 'done');
-    expect(doneState).toBeDefined();
-    expect(doneState.on_exit).toHaveLength(1);
-    expect(doneState.on_exit[0]).toMatchObject({
-      type: 'log_event',
-      mode: 'auto',
-      config: { message: 'Workflow complete' },
-    });
-  });
-
-  it('should extract multiple actions in one callback', () => {
-    const code = `
-      export function TestWorkflow() {
-        const [count, setCount] = useState(0);
-        const [status, setStatus] = useState('pending');
-
-        useOnEnter('processing', () => {
-          setCount(10);
-          setStatus('active');
-        });
-
-        return <div>{status}</div>;
-      }
-    `;
-
-    const ir = compileWorkflow(code);
-    const processingState = ir.states.find((s: any) => s.name === 'processing');
-    expect(processingState).toBeDefined();
-    expect(processingState.on_enter).toHaveLength(2);
-    expect(processingState.on_enter[0].config.field).toBe('count');
-    expect(processingState.on_enter[1].config.field).toBe('status');
-  });
-
-  it('should extract setMemory action', () => {
-    const code = `
-      export function TestWorkflow() {
-        useOnEnter('complete', () => {
-          setMemory('completed_at', new Date());
-        });
-
-        return <div>Complete</div>;
-      }
-    `;
-
-    const ir = compileWorkflow(code);
-    const completeState = ir.states.find((s: any) => s.name === 'complete');
-    expect(completeState).toBeDefined();
-    expect(completeState.on_enter).toHaveLength(1);
-    expect(completeState.on_enter[0].type).toBe('set_memory');
-    expect(completeState.on_enter[0].config.key).toBe('completed_at');
-  });
-});

package/src/__tests__/event-emission.test.ts

@@ -1,127 +0,0 @@
-/**
- * Event Emission Tests — validates that extracted events appear in compiled output.
- *
- * This tests the critical bug fix: events were extracted by event-extractor
- * but silently dropped by the emitter. Both state-scoped and global events
- * must appear in the final IR.
- */
-
-import { describe, it, expect } from 'vitest';
-import { transformSync } from '@babel/core';
-import babelPlugin from '../babel';
-import type { IRWorkflowDefinition } from '@mindmatrix/player-core';
-
-function compile(code: string): IRWorkflowDefinition {
-  const result = transformSync(code, {
-    filename: 'test.workflow.tsx',
-    plugins: [[babelPlugin, { mode: 'infer' }]],
-    parserOpts: { plugins: ['jsx', 'typescript'], attachComment: true },
-  });
-  return (result as any)?.metadata?.mindmatrixIR;
-}
-
-function compileDefinition(code: string): Record<string, unknown> {
-  const result = transformSync(code, {
-    filename: 'test.workflow.tsx',
-    plugins: [[babelPlugin, { mode: 'infer' }]],
-    parserOpts: { plugins: ['jsx', 'typescript'], attachComment: true },
-  });
-  return (result as any)?.metadata?.mindmatrixDefinition;
-}
-
-describe('Event Emission', () => {
-  it('should emit state-scoped events on target state on_event', () => {
-    const ir = compile(`
-      export function EventHandler() {
-        const [count, setCount] = useState(0);
-        useOnEvent('message.received', (event) => {
-          setField('count', 1);
-        }, { while: 'active' });
-        return <div />;
-      }
-    `);
-
-    const activeState = ir.states.find((s) => s.name === 'active');
-    expect(activeState).toBeDefined();
-    expect(activeState!.on_event).toBeDefined();
-    expect(activeState!.on_event).toHaveLength(1);
-    expect(activeState!.on_event![0].match).toBe('message.received');
-    expect(activeState!.on_event![0].actions).toHaveLength(1);
-    expect(activeState!.on_event![0].actions[0].type).toBe('set_field');
-    expect(activeState!.on_event![0].actions[0].field).toBe('count');
-  });
-
-  it('should emit global events at workflow level on_event', () => {
-    const ir = compile(`
-      export function GlobalHandler() {
-        const [count, setCount] = useState(0);
-        useOnEvent('system.shutdown', () => {
-          console.log('shutting down');
-        });
-        return <div />;
-      }
-    `);
-
-    // Global events go to workflow-level on_event
-    expect(ir.on_event).toBeDefined();
-    expect(ir.on_event).toHaveLength(1);
-    expect(ir.on_event![0].match).toBe('system.shutdown');
-    expect(ir.on_event![0].actions).toHaveLength(1);
-    expect(ir.on_event![0].actions[0].type).toBe('log_event');
-  });
-
-  it('should handle both state-scoped and global events', () => {
-    const ir = compile(`
-      export function MixedEvents() {
-        useOnEvent('state.event', () => { setField('a', 1); }, { while: 'running' });
-        useOnEvent('global.event', () => { setField('b', 2); });
-        return <div />;
-      }
-    `);
-
-    // State-scoped
-    const running = ir.states.find((s) => s.name === 'running');
-    expect(running!.on_event).toHaveLength(1);
-    expect(running!.on_event![0].match).toBe('state.event');
-
-    // Global
-    expect(ir.on_event).toHaveLength(1);
-    expect(ir.on_event![0].match).toBe('global.event');
-  });
-
-  it('should preserve events in engine-compatible definition', () => {
-    const def = compileDefinition(`
-      export function EngineEvents() {
-        useOnEvent('test.event', () => { setField('x', 1); }, { while: 'active' });
-        useOnEvent('global.ping', () => { console.log('pong'); });
-        return <div />;
-      }
-    `);
-
-    // State-level on_event
-    const states = def.states as any[];
-    const active = states.find((s) => s.name === 'active');
-    expect(active.on_event).toHaveLength(1);
-    expect(active.on_event[0].match).toBe('test.event');
-
-    // Workflow-level on_event
-    const on_event = def.on_event as any[];
-    expect(on_event).toHaveLength(1);
-    expect(on_event[0].match).toBe('global.ping');
-  });
-
-  it('should handle setMemory in event actions', () => {
-    const ir = compile(`
-      export function MemoryEvent() {
-        useOnEvent('data.update', () => {
-          setMemory('lastUpdate', 'now');
-        }, { while: 'listening' });
-        return <div />;
-      }
-    `);
-
-    const listening = ir.states.find((s) => s.name === 'listening');
-    expect(listening!.on_event![0].actions[0].type).toBe('set_memory');
-    expect(listening!.on_event![0].actions[0].key).toBe('lastUpdate');
-  });
-});

package/src/__tests__/examples.test.ts

@@ -1,236 +0,0 @@
-/**
- * Examples Compilation Test — verifies that all example .workflow.tsx files
- * compile successfully through the Babel plugin and produce valid IR.
- */
-
-import { describe, it, expect } from 'vitest';
-import { transformSync } from '@babel/core';
-import { readFileSync } from 'fs';
-import { resolve } from 'path';
-import babelPlugin from '../babel';
-import type { IRWorkflowDefinition } from '@mindmatrix/player-core';
-
-function compileFile(relativePath: string): IRWorkflowDefinition {
-  const filePath = resolve(__dirname, '../../examples', relativePath);
-  const code = readFileSync(filePath, 'utf-8');
-  const result = transformSync(code, {
-    filename: filePath,
-    plugins: [[babelPlugin]],
-    parserOpts: { plugins: ['typescript', 'jsx'], attachComment: true },
-  });
-  const ir = (result as any)?.metadata?.mindmatrixIR;
-  if (!ir) throw new Error(`No IR produced for ${relativePath}`);
-  return ir;
-}
-
-describe('Example: counter.workflow.tsx', () => {
-  const ir = compileFile('counter.workflow.tsx');
-
-  it('should extract metadata from JSDoc', () => {
-    expect(ir.slug).toBe('counter');
-    expect(ir.version).toBe('1.0.0');
-    expect(ir.category).toBe('workflow');
-    expect(ir.description).toContain('simple counter');
-  });
-
-  it('should extract 3 fields from useState', () => {
-    expect(ir.fields).toHaveLength(3);
-    expect(ir.fields.find((f) => f.name === 'count')?.type).toBe('number');
-    expect(ir.fields.find((f) => f.name === 'status')?.type).toBe('text');
-    expect(ir.fields.find((f) => f.name === 'lastAction')?.type).toBe('text');
-  });
-
-  it('should extract states with enter hooks', () => {
-    expect(ir.states.length).toBeGreaterThanOrEqual(1);
-    const counting = ir.states.find((s) => s.name === 'counting');
-    expect(counting).toBeDefined();
-    expect(counting!.on_enter.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('should extract 4 transitions', () => {
-    expect(ir.transitions).toHaveLength(4);
-    const names = ir.transitions.map((t) => t.name);
-    expect(names).toContain('start');
-    expect(names).toContain('increment');
-    expect(names).toContain('decrement');
-    expect(names).toContain('reset');
-  });
-
-  it('should extract field watchers from useOnChange', () => {
-    const watchers = (ir.metadata as any)?.fieldWatchers;
-    expect(watchers).toBeDefined();
-    expect(watchers.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('should extract experience tree from JSX', () => {
-    expect(ir.metadata?.experience).toBeDefined();
-  });
-
-  it('should have no compilation errors', () => {
-    expect((ir.metadata as any)?.errors).toBeUndefined();
-  });
-});
-
-describe('Example: todo-app.workflow.tsx', () => {
-  const ir = compileFile('todo-app.workflow.tsx');
-
-  it('should extract metadata from JSDoc', () => {
-    expect(ir.slug).toBe('todo-app');
-    expect(ir.version).toBe('1.0.0');
-    expect(ir.category).toBe('data');
-    expect(ir.description).toContain('Todo list');
-  });
-
-  it('should extract 3 fields from useState', () => {
-    expect(ir.fields).toHaveLength(3);
-    expect(ir.fields.find((f) => f.name === 'title')?.type).toBe('text');
-    expect(ir.fields.find((f) => f.name === 'filter')?.type).toBe('text');
-    expect(ir.fields.find((f) => f.name === 'itemCount')?.type).toBe('number');
-  });
-
-  it('should extract 2 data sources from useQuery', () => {
-    const sources = (ir.metadata as any)?.dataSources;
-    expect(sources).toBeDefined();
-    expect(sources).toHaveLength(2);
-    expect(sources[0].slug).toBe('todo-item');
-    expect(sources[0].pageSize).toBe(100);
-    expect(sources[0].sort).toBe('created_at');
-    expect(sources[1].slug).toBe('todo-item');
-    expect(sources[1].pageSize).toBe(50);
-  });
-
-  it('should extract mutation target from useMutation', () => {
-    const targets = (ir.metadata as any)?.mutationTargets;
-    expect(targets).toBeDefined();
-    expect(targets).toContain('todo-item');
-  });
-
-  it('should extract role dependencies from useRole', () => {
-    const roles = (ir.metadata as any)?.roleDependencies;
-    expect(roles).toBeDefined();
-    expect(roles).toContain('editor');
-    expect(roles).toContain('admin');
-  });
-
-  it('should extract 3 transitions', () => {
-    expect(ir.transitions).toHaveLength(3);
-    const names = ir.transitions.map((t) => t.name);
-    expect(names).toContain('activate');
-    expect(names).toContain('archive');
-    expect(names).toContain('restore');
-  });
-
-  it('should extract states with enter/exit/during hooks', () => {
-    const active = ir.states.find((s) => s.name === 'active');
-    expect(active).toBeDefined();
-    expect(active!.on_enter.length).toBeGreaterThanOrEqual(1);
-    expect(active!.on_exit.length).toBeGreaterThanOrEqual(1);
-    if (active!.during) {
-      expect(active!.during.length).toBeGreaterThanOrEqual(1);
-    }
-  });
-
-  it('should extract experience tree with conditional and list rendering', () => {
-    expect(ir.metadata?.experience).toBeDefined();
-  });
-
-  it('should have no compilation errors', () => {
-    expect((ir.metadata as any)?.errors).toBeUndefined();
-  });
-});
-
-describe('Example: dashboard.workflow.tsx', () => {
-  const ir = compileFile('dashboard.workflow.tsx');
-
-  it('should extract metadata from JSDoc', () => {
-    expect(ir.slug).toBe('dashboard');
-    expect(ir.version).toBe('1.0.0');
-    expect(ir.category).toBe('blueprint');
-    expect(ir.description).toContain('dashboard blueprint');
-  });
-
-  it('should extract 8 fields from useState', () => {
-    expect(ir.fields).toHaveLength(8);
-    expect(ir.fields.find((f) => f.name === 'activeRoute')?.type).toBe('text');
-    expect(ir.fields.find((f) => f.name === 'sidebarOpen')?.type).toBe('boolean');
-    expect(ir.fields.find((f) => f.name === 'searchQuery')?.type).toBe('text');
-    expect(ir.fields.find((f) => f.name === 'notificationCount')?.type).toBe('number');
-    expect(ir.fields.find((f) => f.name === 'selectedRecordId')?.type).toBe('text');
-    expect(ir.fields.find((f) => f.name === 'theme')?.type).toBe('text');
-    expect(ir.fields.find((f) => f.name === 'refreshInterval')?.type).toBe('number');
-    expect(ir.fields.find((f) => f.name === 'lastRefreshed')?.type).toBe('text');
-  });
-
-  it('should extract 5 data sources from useQuery', () => {
-    const sources = (ir.metadata as any)?.dataSources;
-    expect(sources).toBeDefined();
-    expect(sources).toHaveLength(5);
-    const slugs = sources.map((s: any) => s.slug);
-    expect(slugs).toContain('dashboard-metric');
-    expect(slugs).toContain('activity-log');
-    expect(slugs).toContain('workflow-definition');
-    expect(slugs).toContain('notification');
-    expect(slugs).toContain('user-setting');
-  });
-
-  it('should extract 2 mutation targets from useMutation', () => {
-    const targets = (ir.metadata as any)?.mutationTargets;
-    expect(targets).toBeDefined();
-    expect(targets).toContain('user-setting');
-    expect(targets).toContain('activity-log');
-  });
-
-  it('should extract 3 role dependencies from useRole', () => {
-    const roles = (ir.metadata as any)?.roleDependencies;
-    expect(roles).toBeDefined();
-    expect(roles).toContain('admin');
-    expect(roles).toContain('viewer');
-    expect(roles).toContain('editor');
-  });
-
-  it('should extract 7 transitions', () => {
-    expect(ir.transitions).toHaveLength(7);
-    const names = ir.transitions.map((t) => t.name);
-    expect(names).toContain('initialize');
-    expect(names).toContain('suspend');
-    expect(names).toContain('resume');
-    expect(names).toContain('deactivate');
-    expect(names).toContain('navigate');
-    expect(names).toContain('open-settings');
-    expect(names).toContain('close-settings');
-  });
-
-  it('should extract states with enter/exit/during hooks', () => {
-    const active = ir.states.find((s) => s.name === 'active');
-    expect(active).toBeDefined();
-    expect(active!.on_enter.length).toBeGreaterThanOrEqual(1);
-    expect(active!.on_exit.length).toBeGreaterThanOrEqual(1);
-    if (active!.during) {
-      expect(active!.during.length).toBeGreaterThanOrEqual(1);
-    }
-
-    const settings = ir.states.find((s) => s.name === 'settings');
-    expect(settings).toBeDefined();
-    expect(settings!.on_enter.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('should extract field watchers from useOnChange', () => {
-    const watchers = (ir.metadata as any)?.fieldWatchers;
-    expect(watchers).toBeDefined();
-    expect(watchers.length).toBeGreaterThanOrEqual(2);
-  });
-
-  it('should extract event subscriptions from useOnEvent', () => {
-    const events = ir.on_event;
-    expect(events).toBeDefined();
-    expect(events!.length).toBeGreaterThanOrEqual(2);
-  });
-
-  it('should extract experience tree with complex conditional rendering', () => {
-    expect(ir.metadata?.experience).toBeDefined();
-  });
-
-  it('should have no compilation errors', () => {
-    expect((ir.metadata as any)?.errors).toBeUndefined();
-  });
-});