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

package/src/__tests__/ts-to-expression.test.ts

@@ -1,462 +0,0 @@
-/**
- * TS → mm-compute Expression Transpiler Tests
- *
- * Tests the transpilation of Babel AST Expression nodes into mm-compute
- * expression strings. Uses @babel/parser to parse JS/TS expressions
- * into AST nodes, then transpiles them.
- */
-
-import { describe, it, expect } from 'vitest';
-import { parse } from '@babel/parser';
-import type * as t from '@babel/types';
-import { transpileExpression, transpile } from '../babel/transpilers/ts-to-expression';
-
-/**
- * Parse a JS expression string into a Babel AST Expression node.
- */
-function parseExpr(code: string): t.Expression {
-  const ast = parse(`(${code})`, {
-    sourceType: 'module',
-    plugins: ['typescript', 'jsx'],
-  });
-  const stmt = ast.program.body[0];
-  if (stmt.type !== 'ExpressionStatement') {
-    throw new Error(`Expected ExpressionStatement, got ${stmt.type}`);
-  }
-  return stmt.expression;
-}
-
-/**
- * Transpile a JS expression string to mm-compute and return the result.
- */
-function tx(code: string): string {
-  return transpile(parseExpr(code));
-}
-
-/**
- * Transpile and check purity.
- */
-function txFull(code: string) {
-  return transpileExpression(parseExpr(code));
-}
-
-// =============================================================================
-// String Methods
-// =============================================================================
-
-describe('String method transpilation', () => {
-  it('str.toLowerCase() → lower(str)', () => {
-    expect(tx('name.toLowerCase()')).toBe('lower(name)');
-  });
-
-  it('str.toUpperCase() → upper(str)', () => {
-    expect(tx('name.toUpperCase()')).toBe('upper(name)');
-  });
-
-  it('str.trim() → trim(str)', () => {
-    expect(tx('input.trim()')).toBe('trim(input)');
-  });
-
-  it('str.startsWith(s) → starts_with(str, s)', () => {
-    expect(tx('name.startsWith("Dr")')).toBe('starts_with(name, "Dr")');
-  });
-
-  it('str.endsWith(s) → ends_with(str, s)', () => {
-    expect(tx('file.endsWith(".pdf")')).toBe('ends_with(file, ".pdf")');
-  });
-
-  it('str.includes(sub) → contains(str, sub)', () => {
-    expect(tx('msg.includes("error")')).toBe('contains(msg, "error")');
-  });
-
-  it('str.split(sep) → split(str, sep)', () => {
-    expect(tx('csv.split(",")')).toBe('split(csv, ",")');
-  });
-
-  it('str.indexOf(sub) → indexof(str, sub)', () => {
-    expect(tx('name.indexOf("@")')).toBe('indexof(name, "@")');
-  });
-
-  it('str.replace(a, b) → replace(str, a, b)', () => {
-    expect(tx('name.replace("-", "_")')).toBe('replace(name, "-", "_")');
-  });
-
-  it('str.substring(start, end) → substring(str, start, end)', () => {
-    expect(tx('name.substring(0, 5)')).toBe('substring(name, 0, 5)');
-  });
-
-  it('str.slice(start) → substring(str, start)', () => {
-    expect(tx('name.slice(3)')).toBe('substring(name, 3)');
-  });
-
-  it('str.toString() → to_string(str)', () => {
-    expect(tx('value.toString()')).toBe('to_string(value)');
-  });
-});
-
-// =============================================================================
-// Array Methods
-// =============================================================================
-
-describe('Array method transpilation', () => {
-  it('arr.length → length(arr)', () => {
-    expect(tx('items.length')).toBe('length(items)');
-  });
-
-  it('arr.includes(val) → contains(arr, val)', () => {
-    expect(tx('roles.includes("admin")')).toBe('contains(roles, "admin")');
-  });
-
-  it('arr.filter(x => x.active) → filter(arr, x => x.active)', () => {
-    expect(tx('items.filter(x => x.active)')).toBe('filter(items, x => x.active)');
-  });
-
-  it('arr.map(x => x.name) → map(arr, x => x.name)', () => {
-    expect(tx('items.map(x => x.name)')).toBe('map(items, x => x.name)');
-  });
-
-  it('arr.find(x => x.id === val) → find(arr, x => (x.id == val))', () => {
-    expect(tx('items.find(x => x.id === val)')).toBe('find(items, x => (x.id == val))');
-  });
-
-  it('arr.join(sep) → join(arr, sep)', () => {
-    expect(tx('tags.join(", ")')).toBe('join(tags, ", ")');
-  });
-
-  it('arr.reverse() → reverse(arr)', () => {
-    expect(tx('items.reverse()')).toBe('reverse(items)');
-  });
-
-  it('arr.sort() → sort(arr)', () => {
-    expect(tx('items.sort()')).toBe('sort(items)');
-  });
-
-  it('arr.flat() → flat(arr)', () => {
-    expect(tx('nested.flat()')).toBe('flat(nested)');
-  });
-
-  it('arr.reduce((acc, x) => acc + x, 0) → reduce(arr, (acc, x) => (acc + x), 0)', () => {
-    expect(tx('nums.reduce((acc, x) => acc + x, 0)')).toBe('reduce(nums, (acc, x) => (acc + x), 0)');
-  });
-});
-
-// =============================================================================
-// Math Methods
-// =============================================================================
-
-describe('Math method transpilation', () => {
-  it('Math.max(a, b) → max(a, b)', () => {
-    expect(tx('Math.max(a, b)')).toBe('max(a, b)');
-  });
-
-  it('Math.min(a, b) → min(a, b)', () => {
-    expect(tx('Math.min(a, b)')).toBe('min(a, b)');
-  });
-
-  it('Math.round(n) → round(n)', () => {
-    expect(tx('Math.round(x)')).toBe('round(x)');
-  });
-
-  it('Math.floor(n) → floor(n)', () => {
-    expect(tx('Math.floor(x)')).toBe('floor(x)');
-  });
-
-  it('Math.ceil(n) → ceil(n)', () => {
-    expect(tx('Math.ceil(x)')).toBe('ceil(x)');
-  });
-
-  it('Math.abs(n) → abs(n)', () => {
-    expect(tx('Math.abs(x)')).toBe('abs(x)');
-  });
-
-  it('Math.pow(a, b) → power(a, b)', () => {
-    expect(tx('Math.pow(2, 10)')).toBe('power(2, 10)');
-  });
-
-  it('Math.sqrt(n) → sqrt(n)', () => {
-    expect(tx('Math.sqrt(x)')).toBe('sqrt(x)');
-  });
-});
-
-// =============================================================================
-// JSON Methods
-// =============================================================================
-
-describe('JSON method transpilation', () => {
-  it('JSON.stringify(v) → to_string(v)', () => {
-    expect(tx('JSON.stringify(obj)')).toBe('to_string(obj)');
-  });
-
-  it('JSON.parse(s) → from_json(s)', () => {
-    expect(tx('JSON.parse(text)')).toBe('from_json(text)');
-  });
-});
-
-// =============================================================================
-// Date Methods
-// =============================================================================
-
-describe('Date transpilation', () => {
-  it('new Date() → now()', () => {
-    expect(tx('new Date()')).toBe('now()');
-  });
-
-  it('Date.now() → now_ms()', () => {
-    expect(tx('Date.now()')).toBe('now_ms()');
-  });
-});
-
-// =============================================================================
-// Operators
-// =============================================================================
-
-describe('Operator transpilation', () => {
-  it('a === b → (a == b)', () => {
-    expect(tx('a === b')).toBe('(a == b)');
-  });
-
-  it('a !== b → (a != b)', () => {
-    expect(tx('a !== b')).toBe('(a != b)');
-  });
-
-  it('a ? b : c → if(a, b, c)', () => {
-    expect(tx('active ? "yes" : "no"')).toBe('if(active, "yes", "no")');
-  });
-
-  it('a && b → (a && b)', () => {
-    expect(tx('a && b')).toBe('(a && b)');
-  });
-
-  it('a || b → (a || b)', () => {
-    expect(tx('a || b')).toBe('(a || b)');
-  });
-
-  it('!a → not(a)', () => {
-    expect(tx('!active')).toBe('not(active)');
-  });
-
-  it('a ?? b → coalesce(a, b)', () => {
-    expect(tx('name ?? "unknown"')).toBe('coalesce(name, "unknown")');
-  });
-
-  it('arithmetic operators pass through', () => {
-    expect(tx('a + b')).toBe('(a + b)');
-    expect(tx('a - b')).toBe('(a - b)');
-    expect(tx('a * b')).toBe('(a * b)');
-    expect(tx('a / b')).toBe('(a / b)');
-    expect(tx('a % b')).toBe('(a % b)');
-  });
-
-  it('comparison operators pass through', () => {
-    expect(tx('a < b')).toBe('(a < b)');
-    expect(tx('a > b')).toBe('(a > b)');
-    expect(tx('a <= b')).toBe('(a <= b)');
-    expect(tx('a >= b')).toBe('(a >= b)');
-  });
-
-  it('unary minus on literal → negative number', () => {
-    expect(tx('-5')).toBe('-5');
-  });
-
-  it('unary minus on expression → (0 - expr)', () => {
-    expect(tx('-x')).toBe('(0 - x)');
-  });
-
-  it('typeof → typeof()', () => {
-    expect(tx('typeof x')).toBe('typeof(x)');
-  });
-});
-
-// =============================================================================
-// Template Literals
-// =============================================================================
-
-describe('Template literal transpilation', () => {
-  it('`hello ${name}` → concat("hello ", to_string(name))', () => {
-    expect(tx('`hello ${name}`')).toBe('concat("hello ", to_string(name))');
-  });
-
-  it('`${a}-${b}` → concat(to_string(a), "-", to_string(b))', () => {
-    expect(tx('`${a}-${b}`')).toBe('concat(to_string(a), "-", to_string(b))');
-  });
-
-  it('`plain string` → "plain string"', () => {
-    expect(tx('`plain string`')).toBe('"plain string"');
-  });
-
-  it('`${value}` → to_string(value)', () => {
-    expect(tx('`${value}`')).toBe('to_string(value)');
-  });
-});
-
-// =============================================================================
-// Optional Chaining
-// =============================================================================
-
-describe('Optional chaining transpilation', () => {
-  it('a?.b → if(a != null, a.b, null)', () => {
-    expect(tx('a?.b')).toBe('if(a != null, a.b, null)');
-  });
-
-  it('a?.length → if(a != null, length(a), null)', () => {
-    expect(tx('a?.length')).toBe('if(a != null, length(a), null)');
-  });
-});
-
-// =============================================================================
-// Literals & Identifiers
-// =============================================================================
-
-describe('Literals and identifiers', () => {
-  it('string literal', () => {
-    expect(tx('"hello"')).toBe('"hello"');
-  });
-
-  it('number literal', () => {
-    expect(tx('42')).toBe('42');
-  });
-
-  it('boolean literals', () => {
-    expect(tx('true')).toBe('true');
-    expect(tx('false')).toBe('false');
-  });
-
-  it('null literal', () => {
-    expect(tx('null')).toBe('null');
-  });
-
-  it('undefined → null', () => {
-    expect(tx('undefined')).toBe('null');
-  });
-
-  it('identifier passes through', () => {
-    expect(tx('state_data')).toBe('state_data');
-  });
-
-  it('dot path passes through', () => {
-    expect(tx('state_data.name')).toBe('state_data.name');
-  });
-
-  it('array literal', () => {
-    expect(tx('[1, 2, 3]')).toBe('[1, 2, 3]');
-  });
-
-  it('object literal', () => {
-    expect(tx('({name: "Alice", age: 30})')).toBe('{"name": "Alice", "age": 30}');
-  });
-});
-
-// =============================================================================
-// Purity Tracking
-// =============================================================================
-
-describe('Purity tracking', () => {
-  it('pure expressions are marked pure', () => {
-    const result = txFull('a + b');
-    expect(result.pure).toBe(true);
-  });
-
-  it('translatable method calls are pure', () => {
-    const result = txFull('name.toLowerCase()');
-    expect(result.pure).toBe(true);
-  });
-
-  it('unknown methods are marked impure', () => {
-    const result = txFull('obj.unknownMethod()');
-    expect(result.pure).toBe(false);
-    expect(result.expression).toContain('$expr(');
-  });
-});
-
-// =============================================================================
-// Complex / Nested Expressions
-// =============================================================================
-
-describe('Complex expression transpilation', () => {
-  it('chained string methods', () => {
-    expect(tx('name.trim().toLowerCase()')).toBe('lower(trim(name))');
-  });
-
-  it('nested ternary', () => {
-    expect(tx('a ? b : c ? d : e')).toBe('if(a, b, if(c, d, e))');
-  });
-
-  it('Math in ternary', () => {
-    expect(tx('x > 0 ? Math.floor(x) : Math.ceil(x)')).toBe(
-      'if((x > 0), floor(x), ceil(x))',
-    );
-  });
-
-  it('filter + map chain', () => {
-    expect(tx('items.filter(x => x.active).map(x => x.name)')).toBe(
-      'map(filter(items, x => x.active), x => x.name)',
-    );
-  });
-
-  it('complex filter predicate', () => {
-    expect(tx('items.filter(x => x.age > 18 && x.active)')).toBe(
-      'filter(items, x => ((x.age > 18) && x.active))',
-    );
-  });
-
-  it('template literal with method call', () => {
-    expect(tx('`Hello ${name.toUpperCase()}`')).toBe(
-      'concat("Hello ", to_string(upper(name)))',
-    );
-  });
-
-  it('nullish coalescing with method', () => {
-    expect(tx('name?.toLowerCase() ?? "unknown"')).toBe(
-      'coalesce(lower(name), "unknown")',
-    );
-  });
-
-  it('TS type assertion is stripped', () => {
-    expect(tx('(x as string).toLowerCase()')).toBe('lower(x)');
-  });
-
-  it('TS non-null assertion is stripped', () => {
-    expect(tx('x!.toLowerCase()')).toBe('lower(x)');
-  });
-
-  it('array length in comparison', () => {
-    expect(tx('items.length > 0')).toBe('(length(items) > 0)');
-  });
-});
-
-// =============================================================================
-// Context options (localFieldMap, etc.)
-// =============================================================================
-
-describe('TranspileOptions context', () => {
-  it('localFieldMap rewrites identifiers to $local paths', () => {
-    const result = transpile(parseExpr('sidebarOpen'), {
-      localFieldMap: new Map([['sidebarOpen', 'sidebar_open']]),
-    });
-    expect(result).toBe('$local.sidebar_open');
-  });
-
-  it('localFieldMap works inside expressions', () => {
-    const result = transpile(parseExpr('count + 1'), {
-      localFieldMap: new Map([['count', 'count']]),
-    });
-    expect(result).toBe('($local.count + 1)');
-  });
-});
-
-// =============================================================================
-// Opaque Fallback
-// =============================================================================
-
-describe('Opaque fallback for untranslatable expressions', () => {
-  it('unknown method call produces $expr() wrapper', () => {
-    const result = tx('foo.customMethod(1, 2)');
-    expect(result).toContain('$expr(');
-    expect(result).toContain('customMethod');
-  });
-
-  it('await expression produces $expr() wrapper', () => {
-    const result = tx('await fetch("/api")');
-    expect(result).toContain('$expr(');
-  });
-});

package/src/__tests__/type-generator.test.ts

@@ -1,201 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { generateTypeDeclaration, generateFullSource } from '../cli/type-generator';
-import type { WorkflowDefinitionResponse } from '../cli/registry-client';
-
-const sampleDef: WorkflowDefinitionResponse = {
-  slug: 'mod-authentication',
-  name: 'Authentication Module',
-  version: '2.0.0',
-  description: 'Handles user authentication flows',
-  category: 'module',
-  fields: [
-    { name: 'appName', type: 'string', default_value: '' },
-    {
-      name: 'layout',
-      type: 'string',
-      default_value: 'card',
-      validation: { enum: ['card', 'split', 'minimal'] },
-    },
-    { name: 'maxRetries', type: 'number', default_value: 3 },
-    { name: 'rememberMe', type: 'boolean', default_value: true },
-    { name: 'email', type: 'email', required: true },
-  ],
-  states: [
-    { name: 'unauthenticated', type: 'initial' },
-    { name: 'authenticating', type: 'normal' },
-    { name: 'authenticated', type: 'normal' },
-    { name: 'error', type: 'normal' },
-    { name: 'locked', type: 'final' },
-  ],
-  transitions: [
-    { name: 'login', from: ['unauthenticated'], to: 'authenticating' },
-    { name: 'success', from: ['authenticating'], to: 'authenticated' },
-    { name: 'fail', from: ['authenticating'], to: 'error' },
-    { name: 'retry', from: ['error'], to: 'authenticating' },
-    { name: 'logout', from: ['authenticated'], to: 'unauthenticated' },
-    { name: 'lockout', from: ['error', 'authenticating'], to: 'locked' },
-  ],
-};
-
-describe('type-generator', () => {
-  describe('generateTypeDeclaration', () => {
-    it('produces valid .d.ts output with defineModel', () => {
-      const output = generateTypeDeclaration(sampleDef);
-
-      expect(output).toContain("import { defineModel } from '@mindmatrix/react'");
-      expect(output).toContain('declare const _default: ReturnType<typeof defineModel<{');
-      expect(output).toContain("readonly slug: 'mod-authentication'");
-      expect(output).toContain("readonly version: '2.0.0'");
-      expect(output).toContain('export default _default;');
-    });
-
-    it('includes all fields with readonly types', () => {
-      const output = generateTypeDeclaration(sampleDef);
-
-      expect(output).toContain("readonly appName: { readonly type: 'string'; readonly default: '' }");
-      expect(output).toContain("readonly maxRetries: { readonly type: 'number'; readonly default: 3 }");
-      expect(output).toContain("readonly rememberMe: { readonly type: 'boolean'; readonly default: true }");
-    });
-
-    it('includes enum fields with readonly tuple', () => {
-      const output = generateTypeDeclaration(sampleDef);
-
-      expect(output).toContain("readonly layout:");
-      expect(output).toContain("readonly enum: readonly ['card', 'split', 'minimal']");
-    });
-
-    it('marks required fields', () => {
-      const output = generateTypeDeclaration(sampleDef);
-
-      expect(output).toContain("readonly email:");
-      expect(output).toContain('readonly required: true');
-    });
-
-    it('includes all states with type annotations', () => {
-      const output = generateTypeDeclaration(sampleDef);
-
-      expect(output).toContain("readonly unauthenticated: { readonly type: 'initial' }");
-      expect(output).toContain("readonly locked: { readonly type: 'final' }");
-      // Normal states have no type annotation
-      expect(output).toContain('readonly authenticating: {  }');
-    });
-
-    it('includes all transitions with from/to', () => {
-      const output = generateTypeDeclaration(sampleDef);
-
-      expect(output).toContain("readonly login: { readonly from: 'unauthenticated'; readonly to: 'authenticating' }");
-      expect(output).toContain("readonly logout: { readonly from: 'authenticated'; readonly to: 'unauthenticated' }");
-    });
-
-    it('handles multi-from transitions as union type', () => {
-      const output = generateTypeDeclaration(sampleDef);
-
-      // lockout has from: ['error', 'authenticating']
-      expect(output).toContain("readonly lockout: { readonly from: 'error' | 'authenticating'; readonly to: 'locked' }");
-    });
-
-    it('exports State and Transition union types', () => {
-      const output = generateTypeDeclaration(sampleDef);
-
-      expect(output).toContain("export type States = 'unauthenticated' | 'authenticating' | 'authenticated' | 'error' | 'locked'");
-      expect(output).toContain("export type Transitions = 'login' | 'success' | 'fail' | 'retry' | 'logout' | 'lockout'");
-    });
-
-    it('exports a Fields interface with TypeScript types', () => {
-      const output = generateTypeDeclaration(sampleDef);
-
-      expect(output).toContain('export interface Fields {');
-      expect(output).toContain('appName: string;');
-      expect(output).toContain('layout: string;');
-      expect(output).toContain('maxRetries: number;');
-      expect(output).toContain('rememberMe: boolean;');
-      expect(output).toContain('email: string;');
-    });
-
-    it('handles empty definition gracefully', () => {
-      const emptyDef: WorkflowDefinitionResponse = {
-        slug: 'empty-workflow',
-        name: 'Empty',
-        version: '1.0.0',
-        category: 'workflow',
-        fields: [],
-        states: [],
-        transitions: [],
-      };
-
-      const output = generateTypeDeclaration(emptyDef);
-
-      expect(output).toContain("readonly slug: 'empty-workflow'");
-      expect(output).toContain('readonly fields: {};');
-      expect(output).toContain('readonly states: {};');
-      expect(output).toContain('readonly transitions: {};');
-      // Should NOT export union types for empty arrays
-      expect(output).not.toContain('export type States');
-      expect(output).not.toContain('export type Transitions');
-    });
-
-    it('escapes special characters in string literals', () => {
-      const defWithSpecial: WorkflowDefinitionResponse = {
-        slug: "o'malley-app",
-        name: "O'Malley's App",
-        version: '1.0.0',
-        category: 'workflow',
-        fields: [{ name: 'note', type: 'string', default_value: "it's a test" }],
-        states: [{ name: 'start', type: 'initial' }],
-        transitions: [],
-      };
-
-      const output = generateTypeDeclaration(defWithSpecial);
-
-      expect(output).toContain("readonly slug: 'o\\'malley-app'");
-      expect(output).toContain("readonly default: 'it\\'s a test'");
-    });
-  });
-
-  describe('generateFullSource', () => {
-    it('produces valid TypeScript source with defineModel', () => {
-      const output = generateFullSource(sampleDef);
-
-      expect(output).toContain("import { defineModel } from '@mindmatrix/react'");
-      expect(output).toContain('export default defineModel({');
-      expect(output).toContain("slug: 'mod-authentication'");
-      expect(output).toContain("version: '2.0.0'");
-      expect(output).toContain('} as const);');
-    });
-
-    it('includes fields with type and default', () => {
-      const output = generateFullSource(sampleDef);
-
-      expect(output).toContain("appName: { type: 'string', default: '' },");
-      expect(output).toContain("layout: { type: 'string', default: 'card'");
-      expect(output).toContain("maxRetries: { type: 'number', default: 3 }");
-    });
-
-    it('includes enum as const assertion', () => {
-      const output = generateFullSource(sampleDef);
-
-      expect(output).toContain("enum: ['card', 'split', 'minimal'] as const");
-    });
-
-    it('includes states with type annotations', () => {
-      const output = generateFullSource(sampleDef);
-
-      expect(output).toContain("unauthenticated: { type: 'initial' }");
-      expect(output).toContain("locked: { type: 'final' }");
-      expect(output).toContain('authenticating: {},');
-    });
-
-    it('includes transitions', () => {
-      const output = generateFullSource(sampleDef);
-
-      expect(output).toContain("login: { from: 'unauthenticated', to: 'authenticating' }");
-      expect(output).toContain("logout: { from: 'authenticated', to: 'unauthenticated' }");
-    });
-
-    it('handles multi-from as array', () => {
-      const output = generateFullSource(sampleDef);
-
-      expect(output).toContain("lockout: { from: ['error', 'authenticating'], to: 'locked' }");
-    });
-  });
-});