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

package/src/__tests__/loader.test.ts

@@ -1,159 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateExperienceWorkflow, normalizeDefinition } from '../loader';
-
-const validDef = {
-  id: 'test-1',
-  slug: 'test-workflow',
-  states: [
-    { name: 'start', type: 'START' },
-    { name: 'active', type: 'REGULAR' },
-    { name: 'done', type: 'END' },
-  ],
-  transitions: [
-    { name: 'begin', from: ['start'], to: 'active' },
-    { name: 'finish', from: ['active'], to: 'done' },
-  ],
-};
-
-describe('validateExperienceWorkflow', () => {
-  it('validates a correct definition', () => {
-    const result = validateExperienceWorkflow(validDef);
-    expect(result.valid).toBe(true);
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it('rejects non-object input', () => {
-    expect(validateExperienceWorkflow(null).valid).toBe(false);
-    expect(validateExperienceWorkflow('string').valid).toBe(false);
-    expect(validateExperienceWorkflow(42).valid).toBe(false);
-  });
-
-  it('requires id and slug', () => {
-    const result = validateExperienceWorkflow({ states: [{ name: 'x', type: 'START' }], transitions: [] });
-    expect(result.valid).toBe(false);
-    expect(result.errors.some(e => e.includes('id'))).toBe(true);
-    expect(result.errors.some(e => e.includes('slug'))).toBe(true);
-  });
-
-  it('requires at least one state', () => {
-    const result = validateExperienceWorkflow({ id: '1', slug: 's', states: [], transitions: [] });
-    expect(result.valid).toBe(false);
-    expect(result.errors.some(e => e.includes('at least one state'))).toBe(true);
-  });
-
-  it('requires a START state', () => {
-    const result = validateExperienceWorkflow({
-      id: '1', slug: 's',
-      states: [{ name: 'x', type: 'REGULAR' }],
-      transitions: [],
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errors.some(e => e.includes('START'))).toBe(true);
-  });
-
-  it('detects duplicate state names', () => {
-    const result = validateExperienceWorkflow({
-      id: '1', slug: 's',
-      states: [{ name: 'x', type: 'START' }, { name: 'x', type: 'REGULAR' }],
-      transitions: [],
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errors.some(e => e.includes('Duplicate'))).toBe(true);
-  });
-
-  it('detects unknown transition target states', () => {
-    const result = validateExperienceWorkflow({
-      id: '1', slug: 's',
-      states: [{ name: 'start', type: 'START' }],
-      transitions: [{ name: 't', from: ['start'], to: 'nonexistent' }],
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errors.some(e => e.includes('unknown state'))).toBe(true);
-  });
-
-  it('detects unknown transition from states', () => {
-    const result = validateExperienceWorkflow({
-      id: '1', slug: 's',
-      states: [{ name: 'start', type: 'START' }, { name: 'end', type: 'END' }],
-      transitions: [{ name: 't', from: ['ghost'], to: 'end' }],
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errors.some(e => e.includes('unknown "from" state'))).toBe(true);
-  });
-
-  it('validates on_event subscriptions', () => {
-    const result = validateExperienceWorkflow({
-      id: '1', slug: 's',
-      states: [{
-        name: 'start', type: 'START',
-        on_event: [{ actions: [{ type: 'log', config: {} }] }], // missing match
-      }],
-      transitions: [],
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errors.some(e => e.includes('match'))).toBe(true);
-  });
-
-  it('warns on on_event with empty actions', () => {
-    const result = validateExperienceWorkflow({
-      id: '1', slug: 's',
-      states: [{
-        name: 'start', type: 'START',
-        on_event: [{ match: 'test.*', actions: [] }],
-      }],
-      transitions: [],
-    });
-    expect(result.valid).toBe(true); // warning, not error
-    expect(result.warnings.some(w => w.includes('no actions'))).toBe(true);
-  });
-});
-
-describe('normalizeDefinition', () => {
-  it('normalizes a valid definition', () => {
-    const def = normalizeDefinition(validDef);
-    expect(def.id).toBe('test-1');
-    expect(def.slug).toBe('test-workflow');
-    expect(def.states).toHaveLength(3);
-    expect(def.transitions).toHaveLength(2);
-  });
-
-  it('defaults state type to REGULAR', () => {
-    const def = normalizeDefinition({
-      id: '1', slug: 's',
-      states: [{ name: 'x' }],
-      transitions: [],
-    });
-    expect(def.states[0].type).toBe('REGULAR');
-  });
-
-  it('coerces string "from" to array', () => {
-    const def = normalizeDefinition({
-      id: '1', slug: 's',
-      states: [{ name: 'a', type: 'START' }, { name: 'b', type: 'END' }],
-      transitions: [{ name: 't', from: 'a', to: 'b' }],
-    });
-    expect(def.transitions[0].from).toEqual(['a']);
-  });
-
-  it('normalizes on_event with "pattern" field to "match"', () => {
-    const def = normalizeDefinition({
-      id: '1', slug: 's',
-      states: [{
-        name: 'x', type: 'START',
-        on_event: [{ pattern: 'test.*', actions: [{ type: 'log', config: {} }] }],
-      }],
-      transitions: [],
-    });
-    expect(def.states[0].on_event?.[0].match).toBe('test.*');
-  });
-
-  it('preserves state_views and experience metadata', () => {
-    const def = normalizeDefinition({
-      ...validDef,
-      state_views: { active: { title: 'Active View' } },
-      experience: { default_layout: 'grid' },
-    });
-    expect(def.state_views?.active.title).toBe('Active View');
-    expect(def.experience?.default_layout).toBe('grid');
-  });
-});

package/src/__tests__/logger.test.ts

@@ -1,70 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { setPlayerDebug, isPlayerDebug, playerLog } from '../logger';
-
-describe('Player Logger', () => {
-  beforeEach(() => {
-    setPlayerDebug(false);
-  });
-
-  it('toggles debug mode', () => {
-    expect(isPlayerDebug()).toBe(false);
-    setPlayerDebug(true);
-    expect(isPlayerDebug()).toBe(true);
-  });
-
-  it('suppresses debug logs when debug is off', () => {
-    const spy = vi.spyOn(console, 'debug').mockImplementation(() => {});
-    playerLog({ level: 'debug', category: 'event_match', message: 'test' });
-    expect(spy).not.toHaveBeenCalled();
-    spy.mockRestore();
-  });
-
-  it('emits debug logs when debug is on', () => {
-    setPlayerDebug(true);
-    const spy = vi.spyOn(console, 'debug').mockImplementation(() => {});
-    playerLog({ level: 'debug', category: 'event_match', message: 'test' });
-    expect(spy).toHaveBeenCalledOnce();
-    spy.mockRestore();
-  });
-
-  it('emits warn logs regardless of debug setting', () => {
-    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    playerLog({ level: 'warn', category: 'action_dispatch', message: 'warning' });
-    expect(spy).toHaveBeenCalledOnce();
-    spy.mockRestore();
-  });
-
-  it('emits error logs', () => {
-    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    playerLog({ level: 'error', category: 'transition', message: 'error msg' });
-    expect(spy).toHaveBeenCalledOnce();
-    spy.mockRestore();
-  });
-
-  it('emits info logs', () => {
-    const spy = vi.spyOn(console, 'info').mockImplementation(() => {});
-    playerLog({ level: 'info', category: 'lifecycle', message: 'info msg' });
-    expect(spy).toHaveBeenCalledOnce();
-    spy.mockRestore();
-  });
-
-  it('includes category prefix in log message', () => {
-    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    playerLog({ level: 'warn', category: 'event_match', message: 'matched' });
-    expect(spy).toHaveBeenCalledWith(
-      expect.stringContaining('[player-web:event_match]'),
-      expect.anything(),
-    );
-    spy.mockRestore();
-  });
-
-  it('passes data object to console', () => {
-    const spy = vi.spyOn(console, 'info').mockImplementation(() => {});
-    playerLog({ level: 'info', category: 'lifecycle', message: 'test', data: { key: 'val' } });
-    expect(spy).toHaveBeenCalledWith(
-      expect.any(String),
-      { key: 'val' },
-    );
-    spy.mockRestore();
-  });
-});

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

@@ -1,160 +0,0 @@
-import { describe, it, expect, expectTypeOf } from 'vitest';
-import { defineModel } from '../config/defineModel';
-import type {
-  InferFields,
-  InferTransitions,
-  InferStates,
-  InferSlug,
-  InferFieldNames,
-} from '../types/workflow-inference';
-
-// =============================================================================
-// Test model definition
-// =============================================================================
-
-const employeeModel = defineModel({
-  slug: 'employee',
-  version: '1.0.0',
-  category: 'data',
-  fields: {
-    name: { type: 'string', required: true },
-    email: { type: 'email', required: true },
-    salary: { type: 'currency', default: 0 },
-    isActive: { type: 'boolean', default: true },
-    startDate: { type: 'date' },
-    tags: { type: 'array' },
-    metadata: { type: 'object' },
-    department: { type: 'string', enum: ['engineering', 'sales', 'hr'] as const },
-    rating: { type: 'rating' },
-  },
-  states: {
-    onboarding: { type: 'initial' },
-    active: {},
-    on_leave: {},
-    terminated: { type: 'end' },
-  },
-  transitions: {
-    activate: { from: 'onboarding', to: 'active' },
-    request_leave: { from: 'active', to: 'on_leave' },
-    return_from_leave: { from: 'on_leave', to: 'active' },
-    terminate: { from: ['active', 'on_leave'], to: 'terminated' },
-  },
-} as const);
-
-type EmployeeFields = InferFields<typeof employeeModel>;
-type EmployeeTransitions = InferTransitions<typeof employeeModel>;
-type EmployeeStates = InferStates<typeof employeeModel>;
-
-// =============================================================================
-// Type-level tests
-// =============================================================================
-
-describe('InferFields', () => {
-  it('maps string-family types to string', () => {
-    expectTypeOf<EmployeeFields['name']>().toEqualTypeOf<string>();
-    expectTypeOf<EmployeeFields['email']>().toEqualTypeOf<string>();
-    expectTypeOf<EmployeeFields['department']>().toEqualTypeOf<string>();
-    expectTypeOf<EmployeeFields['startDate']>().toEqualTypeOf<string>();
-  });
-
-  it('maps numeric types to number', () => {
-    expectTypeOf<EmployeeFields['salary']>().toEqualTypeOf<number>();
-    expectTypeOf<EmployeeFields['rating']>().toEqualTypeOf<number>();
-  });
-
-  it('maps boolean type to boolean', () => {
-    expectTypeOf<EmployeeFields['isActive']>().toEqualTypeOf<boolean>();
-  });
-
-  it('maps complex types correctly', () => {
-    expectTypeOf<EmployeeFields['tags']>().toEqualTypeOf<unknown[]>();
-    expectTypeOf<EmployeeFields['metadata']>().toEqualTypeOf<Record<string, unknown>>();
-  });
-
-  it('produces an object with all field keys', () => {
-    expectTypeOf<EmployeeFields>().toHaveProperty('name');
-    expectTypeOf<EmployeeFields>().toHaveProperty('email');
-    expectTypeOf<EmployeeFields>().toHaveProperty('salary');
-    expectTypeOf<EmployeeFields>().toHaveProperty('isActive');
-    expectTypeOf<EmployeeFields>().toHaveProperty('startDate');
-    expectTypeOf<EmployeeFields>().toHaveProperty('tags');
-    expectTypeOf<EmployeeFields>().toHaveProperty('metadata');
-    expectTypeOf<EmployeeFields>().toHaveProperty('department');
-    expectTypeOf<EmployeeFields>().toHaveProperty('rating');
-  });
-
-  it('falls back to Record<string, unknown> for non-model types', () => {
-    type NoFields = InferFields<{ slug: 'x' }>;
-    expectTypeOf<NoFields>().toEqualTypeOf<Record<string, unknown>>();
-  });
-});
-
-describe('InferTransitions', () => {
-  it('extracts transition names as a union', () => {
-    expectTypeOf<EmployeeTransitions>().toEqualTypeOf<
-      'activate' | 'request_leave' | 'return_from_leave' | 'terminate'
-    >();
-  });
-
-  it('falls back to string for non-model types', () => {
-    type NoTrans = InferTransitions<{ slug: 'x' }>;
-    expectTypeOf<NoTrans>().toEqualTypeOf<string>();
-  });
-});
-
-describe('InferStates', () => {
-  it('extracts state names as a union', () => {
-    expectTypeOf<EmployeeStates>().toEqualTypeOf<
-      'onboarding' | 'active' | 'on_leave' | 'terminated'
-    >();
-  });
-
-  it('falls back to string for non-model types', () => {
-    type NoStates = InferStates<{ slug: 'x' }>;
-    expectTypeOf<NoStates>().toEqualTypeOf<string>();
-  });
-});
-
-describe('InferSlug', () => {
-  it('extracts the literal slug type', () => {
-    expectTypeOf<InferSlug<typeof employeeModel>>().toEqualTypeOf<'employee'>();
-  });
-});
-
-describe('InferFieldNames', () => {
-  it('extracts field name union', () => {
-    expectTypeOf<InferFieldNames<typeof employeeModel>>().toEqualTypeOf<
-      'name' | 'email' | 'salary' | 'isActive' | 'startDate' | 'tags' | 'metadata' | 'department' | 'rating'
-    >();
-  });
-});
-
-describe('defineModel', () => {
-  it('returns the definition unchanged at runtime', () => {
-    expect(employeeModel.slug).toBe('employee');
-    expect(Object.keys(employeeModel.fields)).toHaveLength(9);
-    expect(Object.keys(employeeModel.states)).toHaveLength(4);
-    expect(Object.keys(employeeModel.transitions)).toHaveLength(4);
-  });
-
-  it('preserves const literal types', () => {
-    // The slug should be the literal 'employee', not string
-    expectTypeOf(employeeModel.slug).toEqualTypeOf<'employee'>();
-    // Field keys should be literal union
-    expectTypeOf<keyof typeof employeeModel.fields>().toEqualTypeOf<
-      'name' | 'email' | 'salary' | 'isActive' | 'startDate' | 'tags' | 'metadata' | 'department' | 'rating'
-    >();
-  });
-
-  it('throws in dev mode when slug is missing', () => {
-    expect(() => defineModel({ slug: '', fields: {}, states: {}, transitions: {} })).toThrow(
-      'slug is required',
-    );
-  });
-
-  it('throws in dev mode when fields is missing', () => {
-    expect(() => defineModel({ slug: 'x', fields: null as any, states: {}, transitions: {} })).toThrow(
-      'fields object is required',
-    );
-  });
-});

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

@@ -1,126 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { model, field, state, transition, TypedTransitionBuilder } from '../builders';
-import { setField, logEvent } from '../actions';
-
-describe('TypedTransitionBuilder — type-safe state references', () => {
-  it('accepts a callback that builds a typed transition', () => {
-    const result = model('invoice')
-      .state('draft', state.initial())
-      .state('sent')
-      .state('paid', state.end())
-      .transition('send', t => t.from('draft').to('sent'))
-      .build();
-
-    expect(result.transitions.send.from).toBe('draft');
-    expect(result.transitions.send.to).toBe('sent');
-  });
-
-  it('supports require, roles, and when in callback form', () => {
-    const result = model('invoice')
-      .state('draft', state.initial())
-      .state('review')
-      .state('approved', state.end())
-      .transition('submit', t =>
-        t.from('draft').to('review').require('amount', 'title')
-      )
-      .transition('approve', t =>
-        t.from('review').to('approved').roles('manager').when('state_data.amount < 10000')
-      )
-      .build();
-
-    expect(result.transitions.submit.requiredFields).toEqual(['amount', 'title']);
-    expect(result.transitions.approve.roles).toEqual(['manager']);
-    expect(result.transitions.approve.conditions).toHaveLength(1);
-  });
-
-  it('supports auto transitions in callback form', () => {
-    const result = model('pipeline')
-      .state('processing', state.initial())
-      .state('done', state.end())
-      .transition('complete', t =>
-        t.from('processing').to('done').auto()
-      )
-      .build();
-
-    expect(result.transitions.complete.auto).toBe(true);
-  });
-
-  it('supports multiple from states in callback form', () => {
-    const result = model('order')
-      .state('placed', state.initial())
-      .state('confirmed')
-      .state('cancelled', state.end())
-      .transition('cancel', t => t.from('placed', 'confirmed').to('cancelled'))
-      .build();
-
-    expect(result.transitions.cancel.from).toEqual(['placed', 'confirmed']);
-    expect(result.transitions.cancel.to).toBe('cancelled');
-  });
-
-  it('coexists with untyped transition() calls', () => {
-    const result = model('test')
-      .state('a', state.initial())
-      .state('b')
-      .state('c', state.end())
-      // typed callback
-      .transition('ab', t => t.from('a').to('b'))
-      // untyped existing API
-      .transition('bc', transition.from('b').to('c'))
-      .build();
-
-    expect(result.transitions.ab).toEqual({ from: 'a', to: 'b' });
-    expect(result.transitions.bc).toEqual({ from: 'b', to: 'c' });
-  });
-
-  it('coexists with plain object descriptors', () => {
-    const result = model('test')
-      .state('x', state.initial())
-      .state('y', state.end())
-      .transition('go', { from: 'x', to: 'y' })
-      .build();
-
-    expect(result.transitions.go.from).toBe('x');
-    expect(result.transitions.go.to).toBe('y');
-  });
-
-  it('supports description in callback form', () => {
-    const result = model('test')
-      .state('a', state.initial())
-      .state('b', state.end())
-      .transition('go', t => t.from('a').to('b').description('Move from a to b'))
-      .build();
-
-    expect(result.transitions.go.description).toBe('Move from a to b');
-  });
-
-  it('supports do() with actions in callback form', () => {
-    const result = model('test')
-      .state('a', state.initial())
-      .state('b', state.end())
-      .transition('go', t =>
-        t.from('a').to('b').do(setField('status', '"done"'), logEvent('completed'))
-      )
-      .build();
-
-    expect(result.transitions.go.actions).toHaveLength(2);
-    expect(result.transitions.go.actions![0].type).toBe('set_field');
-    expect(result.transitions.go.actions![1].type).toBe('log_event');
-  });
-});
-
-describe('TypedTransitionBuilder class standalone', () => {
-  it('builds a valid TransitionDescriptor', () => {
-    const builder = new TypedTransitionBuilder<'a' | 'b'>();
-    builder.from('a').to('b').require('name');
-    const desc = builder.build();
-
-    expect(desc.from).toBe('a');
-    expect(desc.to).toBe('b');
-    expect(desc.requiredFields).toEqual(['name']);
-  });
-
-  it('throws when from/to are missing', () => {
-    const builder = new TypedTransitionBuilder<'a'>();
-    expect(() => builder.build()).toThrow('from() is required');
-  });
-});

package/src/__tests__/useModuleConfig.test.ts

@@ -1,61 +0,0 @@
-/**
- * Tests for useModuleConfig — config merging and module lookup.
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import {
-  setInstalledModules,
-  setModuleConfigDefaults,
-  getInstalledModule,
-  getInstalledModules,
-  type InstalledModuleRef,
-} from '../hooks/useModuleConfig';
-
-describe('useModuleConfig store', () => {
-  beforeEach(() => {
-    setInstalledModules([]);
-  });
-
-  it('stores and retrieves installed modules', () => {
-    const modules: InstalledModuleRef[] = [
-      { slug: 'mod-auth', moduleId: 'auth-001', config: { layout: 'card' } },
-      { slug: 'mod-notif', moduleId: 'notif-001' },
-    ];
-
-    setInstalledModules(modules);
-
-    expect(getInstalledModules()).toHaveLength(2);
-    expect(getInstalledModule('mod-auth')?.config?.layout).toBe('card');
-    expect(getInstalledModule('mod-notif')).toBeDefined();
-    expect(getInstalledModule('mod-unknown')).toBeUndefined();
-  });
-
-  it('stores routeConfig and slotMapping on installed module', () => {
-    setInstalledModules([{
-      slug: 'mod-auth',
-      moduleId: 'auth-001',
-      routeConfig: { prefix: '/auth', routes: { '/login': '/' } },
-      slotMapping: { 'auth:profile': 'app:settings' },
-    }]);
-
-    const mod = getInstalledModule('mod-auth');
-    expect(mod?.routeConfig?.prefix).toBe('/auth');
-    expect(mod?.routeConfig?.routes?.['/login']).toBe('/');
-    expect(mod?.slotMapping?.['auth:profile']).toBe('app:settings');
-  });
-
-  it('setModuleConfigDefaults works', () => {
-    setModuleConfigDefaults('mod-auth', { layout: 'split', methods: ['email'] });
-
-    // Config defaults are stored and can be merged with install-time config
-    // (useModuleConfig hook merges them, but we test the store directly here)
-    setInstalledModules([{
-      slug: 'mod-auth',
-      moduleId: 'auth-001',
-      config: { layout: 'card' },
-    }]);
-
-    const mod = getInstalledModule('mod-auth');
-    expect(mod?.config?.layout).toBe('card'); // install-time wins
-  });
-});