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

package/src/__tests__/strict-mode.test.ts

@@ -1,227 +0,0 @@
-/**
- * Strict/Infer Mode Tests — validates compilation mode enforcement.
- *
- * Strict mode: bans useEffect, useRef, useMemo, useCallback, useLayoutEffect
- * and non-@mindmatrix imports.
- *
- * Infer mode: warns about useEffect (component becomes opaque grammar island).
- */
-
-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, mode: 'strict' | 'infer' = 'strict'): IRWorkflowDefinition {
-  const result = transformSync(code, {
-    filename: 'test.workflow.tsx',
-    plugins: [[babelPlugin, { mode }]],
-    parserOpts: { plugins: ['jsx', 'typescript'], attachComment: true },
-  });
-  return (result as any)?.metadata?.mindmatrixIR;
-}
-
-describe('Strict Mode', () => {
-  it('should emit error for useEffect in strict mode', () => {
-    const ir = compile(`
-      export function StrictComponent() {
-        useEffect(() => {}, []);
-        return <div />;
-      }
-    `, 'strict');
-
-    const errors = (ir.metadata as any)?.errors;
-    expect(errors).toBeDefined();
-    expect(errors.length).toBeGreaterThan(0);
-    const effectError = errors.find((e: any) => e.code === 'STRICT_USE_EFFECT');
-    expect(effectError).toBeDefined();
-    expect(effectError.severity).toBe('error');
-  });
-
-  it('should emit error for useRef in strict mode', () => {
-    const ir = compile(`
-      export function StrictComponent() {
-        const ref = useRef(null);
-        return <div />;
-      }
-    `, 'strict');
-
-    const errors = (ir.metadata as any)?.errors;
-    const refError = errors.find((e: any) => e.code === 'STRICT_USE_REF');
-    expect(refError).toBeDefined();
-  });
-
-  it('should emit error for useMemo in strict mode', () => {
-    const ir = compile(`
-      export function StrictComponent() {
-        const value = useMemo(() => 42, []);
-        return <div />;
-      }
-    `, 'strict');
-
-    const errors = (ir.metadata as any)?.errors;
-    const memoError = errors.find((e: any) => e.code === 'STRICT_USE_MEMO');
-    expect(memoError).toBeDefined();
-  });
-
-  it('should emit error for useCallback in strict mode', () => {
-    const ir = compile(`
-      export function StrictComponent() {
-        const fn = useCallback(() => {}, []);
-        return <div />;
-      }
-    `, 'strict');
-
-    const errors = (ir.metadata as any)?.errors;
-    const cbError = errors.find((e: any) => e.code === 'STRICT_USE_CALLBACK');
-    expect(cbError).toBeDefined();
-  });
-
-  it('should emit error for useLayoutEffect in strict mode', () => {
-    const ir = compile(`
-      export function StrictComponent() {
-        useLayoutEffect(() => {}, []);
-        return <div />;
-      }
-    `, 'strict');
-
-    const errors = (ir.metadata as any)?.errors;
-    const layoutError = errors.find((e: any) => e.code === 'STRICT_USE_LAYOUT_EFFECT');
-    expect(layoutError).toBeDefined();
-  });
-
-  it('should emit error for forbidden imports in strict mode', () => {
-    const ir = compile(`
-      import lodash from 'lodash';
-      export function StrictComponent() {
-        return <div />;
-      }
-    `, 'strict');
-
-    const errors = (ir.metadata as any)?.errors;
-    const importError = errors.find((e: any) => e.code === 'STRICT_FORBIDDEN_IMPORT');
-    expect(importError).toBeDefined();
-    expect(importError.message).toContain('lodash');
-  });
-
-  it('should allow @mindmatrix imports in strict mode', () => {
-    const ir = compile(`
-      import { useOnEnter } from '@mindmatrix/react';
-      export function StrictComponent() {
-        return <div />;
-      }
-    `, 'strict');
-
-    const errors = (ir.metadata as any)?.errors;
-    // Should not have any STRICT_FORBIDDEN_IMPORT errors
-    const importErrors = errors?.filter((e: any) => e.code === 'STRICT_FORBIDDEN_IMPORT');
-    expect(importErrors?.length || 0).toBe(0);
-  });
-
-  it('should allow react imports in strict mode', () => {
-    const ir = compile(`
-      import React from 'react';
-      export function StrictComponent() {
-        return <div />;
-      }
-    `, 'strict');
-
-    const errors = (ir.metadata as any)?.errors;
-    const importErrors = errors?.filter((e: any) => e.code === 'STRICT_FORBIDDEN_IMPORT');
-    expect(importErrors?.length || 0).toBe(0);
-  });
-
-  it('should allow relative imports in strict mode', () => {
-    const ir = compile(`
-      import { helper } from './utils';
-      import { config } from '../config';
-      export function StrictComponent() {
-        return <div />;
-      }
-    `, 'strict');
-
-    const errors = (ir.metadata as any)?.errors;
-    const importErrors = errors?.filter((e: any) => e.code === 'STRICT_FORBIDDEN_IMPORT');
-    expect(importErrors?.length || 0).toBe(0);
-  });
-
-  it('should allow useState in strict mode (it is a @mindmatrix hook)', () => {
-    const ir = compile(`
-      export function StrictComponent() {
-        const [count, setCount] = useState(0);
-        return <div>{count}</div>;
-      }
-    `, 'strict');
-
-    expect(ir.fields).toHaveLength(1);
-    // No useEffect-style errors
-    const errors = (ir.metadata as any)?.errors;
-    const hookErrors = errors?.filter((e: any) => e.code.startsWith('STRICT_'));
-    expect(hookErrors?.length || 0).toBe(0);
-  });
-});
-
-describe('Infer Mode', () => {
-  it('should emit warning for useEffect in infer mode', () => {
-    const ir = compile(`
-      export function InferComponent() {
-        useEffect(() => { document.title = 'test'; }, []);
-        return <div />;
-      }
-    `, 'infer');
-
-    const warnings = (ir.metadata as any)?.warnings;
-    expect(warnings).toBeDefined();
-    expect(warnings.length).toBeGreaterThan(0);
-    const effectWarning = warnings.find((w: any) => w.code === 'INFER_RAW_JSX');
-    expect(effectWarning).toBeDefined();
-    expect(effectWarning.severity).toBe('warning');
-  });
-
-  it('should not error for useEffect in infer mode', () => {
-    const ir = compile(`
-      export function InferComponent() {
-        useEffect(() => {}, []);
-        return <div />;
-      }
-    `, 'infer');
-
-    const errors = (ir.metadata as any)?.errors;
-    // Should have no errors, only warnings
-    expect(errors?.length || 0).toBe(0);
-  });
-
-  it('should allow all imports in infer mode', () => {
-    const ir = compile(`
-      import lodash from 'lodash';
-      export function InferComponent() {
-        return <div />;
-      }
-    `, 'infer');
-
-    const errors = (ir.metadata as any)?.errors;
-    expect(errors?.length || 0).toBe(0);
-  });
-});
-
-describe('No Mode (default)', () => {
-  it('should not enforce any restrictions without mode', () => {
-    const result = transformSync(`
-      import lodash from 'lodash';
-      export function NoMode() {
-        useEffect(() => {}, []);
-        return <div />;
-      }
-    `, {
-      filename: 'test.workflow.tsx',
-      plugins: [[babelPlugin]],  // No mode specified
-      parserOpts: { plugins: ['jsx', 'typescript'], attachComment: true },
-    });
-
-    const ir = (result as any)?.metadata?.mindmatrixIR;
-    const errors = (ir?.metadata as any)?.errors;
-    const warnings = (ir?.metadata as any)?.warnings;
-    expect(errors?.length || 0).toBe(0);
-    expect(warnings?.length || 0).toBe(0);
-  });
-});

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

@@ -1,119 +0,0 @@
-/**
- * Transition Effect Extractor Tests — validates useOnTransition extraction.
- */
-
-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('Transition Effect Extractor (useOnTransition)', () => {
-  it('should extract useOnTransition as transitionEffect in metadata', () => {
-    const ir = compile(`
-      export function TransitionLogger() {
-        useOnTransition(({ from, to }) => {
-          console.log('transitioned');
-        });
-        return <div />;
-      }
-    `);
-
-    expect(ir.metadata).toBeDefined();
-    const effects = (ir.metadata as any).transitionEffects;
-    expect(effects).toBeDefined();
-    expect(effects).toHaveLength(1);
-    expect(effects[0].id).toMatch(/^transition_effect_/);
-    expect(effects[0].actions).toHaveLength(1);
-    expect(effects[0].actions[0].type).toBe('log_event');
-  });
-
-  it('should extract setField actions', () => {
-    const ir = compile(`
-      export function TransitionUpdater() {
-        const [lastTransition, setLastTransition] = useState('');
-        useOnTransition(() => {
-          setField('lastTransition', 'updated');
-        });
-        return <div />;
-      }
-    `);
-
-    const effects = (ir.metadata as any).transitionEffects;
-    expect(effects[0].actions[0].type).toBe('set_field');
-    expect(effects[0].actions[0].config).toEqual({ field: 'lastTransition', value: 'updated' });
-  });
-
-  it('should extract setMemory actions', () => {
-    const ir = compile(`
-      export function MemoryTracker() {
-        useOnTransition(() => {
-          setMemory('transitioned', true);
-        });
-        return <div />;
-      }
-    `);
-
-    const effects = (ir.metadata as any).transitionEffects;
-    expect(effects[0].actions[0].type).toBe('set_memory');
-    expect(effects[0].actions[0].config).toEqual({ key: 'transitioned', value: true });
-  });
-
-  it('should extract derived setter calls', () => {
-    const ir = compile(`
-      export function DerivedSetter() {
-        const [count, setCount] = useState(0);
-        useOnTransition(() => {
-          setCount(0);
-        });
-        return <div />;
-      }
-    `);
-
-    const effects = (ir.metadata as any).transitionEffects;
-    expect(effects[0].actions[0].type).toBe('set_field');
-    expect(effects[0].actions[0].config.field).toBe('count');
-    expect(effects[0].actions[0].config.value).toBe(0);
-  });
-
-  it('should handle multiple transition effects', () => {
-    const ir = compile(`
-      export function MultiEffect() {
-        useOnTransition(() => { console.log('effect 1'); });
-        useOnTransition(() => { console.log('effect 2'); });
-        return <div />;
-      }
-    `);
-
-    const effects = (ir.metadata as any).transitionEffects;
-    expect(effects).toHaveLength(2);
-    expect(effects[0].id).not.toBe(effects[1].id);
-  });
-
-  it('should extract multiple actions from single callback', () => {
-    const ir = compile(`
-      export function Complex() {
-        useOnTransition(() => {
-          setField('status', 'changed');
-          setMemory('flag', true);
-          console.log('done');
-        });
-        return <div />;
-      }
-    `);
-
-    const effects = (ir.metadata as any).transitionEffects;
-    expect(effects[0].actions).toHaveLength(3);
-    expect(effects[0].actions[0].type).toBe('set_field');
-    expect(effects[0].actions[1].type).toBe('set_memory');
-    expect(effects[0].actions[2].type).toBe('log_event');
-  });
-});

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

@@ -1,68 +0,0 @@
-/**
- * Transition Extractor Tests — validates useTransition → IRTransitionDefinition 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('Transition Extractor', () => {
-  it('should extract useTransition calls', () => {
-    const code = `
-      export function TestWorkflow() {
-        const submit = useTransition('submit');
-        const cancel = useTransition('cancel');
-
-        return <div>
-          <button onClick={submit.fire}>Submit</button>
-          <button onClick={cancel.fire}>Cancel</button>
-        </div>;
-      }
-    `;
-
-    const ir = compileWorkflow(code);
-    expect(ir.transitions).toHaveLength(2);
-    expect(ir.transitions.map((t: any) => t.name)).toEqual(['submit', 'cancel']);
-  });
-
-  it('should create transition with empty from/to initially', () => {
-    const code = `
-      export function TestWorkflow() {
-        const approve = useTransition('approve');
-        return <button onClick={approve.fire}>Approve</button>;
-      }
-    `;
-
-    const ir = compileWorkflow(code);
-    expect(ir.transitions).toHaveLength(1);
-    expect(ir.transitions[0].name).toBe('approve');
-    // from/to are inferred during emitter phase
-    expect(ir.transitions[0].from).toBeDefined();
-    expect(ir.transitions[0].to).toBeDefined();
-  });
-
-  it('should not duplicate transitions', () => {
-    const code = `
-      export function TestWorkflow() {
-        const submit = useTransition('submit');
-        const submit2 = useTransition('submit'); // duplicate
-
-        return <button onClick={submit.fire}>Submit</button>;
-      }
-    `;
-
-    const ir = compileWorkflow(code);
-    expect(ir.transitions).toHaveLength(1);
-    expect(ir.transitions[0].name).toBe('submit');
-  });
-});