@plures/praxis 1.0.2 → 1.1.0

package/src/__tests__/state-docs-integration.test.ts

@@ -2,296 +2,313 @@
  * State-Docs Integration Tests
  */
 
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from 'vitest';
 import {
   createStateDocsGenerator,
   generateDocs,
   StateDocsGenerator,
-} from "../integrations/state-docs.js";
-import type { PraxisSchema } from "../core/schema/types.js";
+} from '../integrations/state-docs.js';
+import type { PraxisSchema } from '../core/schema/types.js';
 
-describe("State-Docs Integration", () => {
+describe('State-Docs Integration', () => {
   const testSchema: PraxisSchema = {
-    version: "1.0.0",
-    name: "TestProject",
-    description: "A test project for documentation generation",
+    version: '1.0.0',
+    name: 'TestProject',
+    description: 'A test project for documentation generation',
     models: [
       {
-        name: "User",
-        description: "User model",
+        name: 'User',
+        description: 'User model',
         fields: [
-          { name: "id", type: "string", description: "User ID" },
-          { name: "name", type: "string", description: "User name" },
-          { name: "email", type: "string", description: "Email address", optional: true },
+          { name: 'id', type: 'string', description: 'User ID' },
+          { name: 'name', type: 'string', description: 'User name' },
+          { name: 'email', type: 'string', description: 'Email address', optional: true },
         ],
       },
       {
-        name: "Post",
-        description: "Blog post model",
+        name: 'Post',
+        description: 'Blog post model',
         fields: [
-          { name: "id", type: "string" },
-          { name: "title", type: "string" },
-          { name: "content", type: "string" },
-          { name: "authorId", type: "string" },
+          { name: 'id', type: 'string' },
+          { name: 'title', type: 'string' },
+          { name: 'content', type: 'string' },
+          { name: 'authorId', type: 'string' },
         ],
       },
     ],
     components: [
       {
-        name: "UserProfile",
-        type: "display",
-        description: "User profile display component",
-        model: "User",
+        name: 'UserProfile',
+        type: 'display',
+        description: 'User profile display component',
+        model: 'User',
       },
       {
-        name: "PostEditor",
-        type: "form",
-        description: "Post editing form",
-        model: "Post",
+        name: 'PostEditor',
+        type: 'form',
+        description: 'Post editing form',
+        model: 'Post',
       },
     ],
     logic: [
       {
-        id: "auth-logic",
-        description: "Authentication logic module",
+        id: 'auth-logic',
+        description: 'Authentication logic module',
         events: [
-          { tag: "Login", payload: { username: "string", password: "string" }, description: "User login event" },
-          { tag: "Logout", payload: { userId: "string" }, description: "User logout event" },
+          {
+            tag: 'Login',
+            payload: { username: 'string', password: 'string' },
+            description: 'User login event',
+          },
+          { tag: 'Logout', payload: { userId: 'string' }, description: 'User logout event' },
         ],
         facts: [
-          { tag: "UserLoggedIn", payload: { userId: "string", timestamp: "number" }, description: "User is logged in" },
+          {
+            tag: 'UserLoggedIn',
+            payload: { userId: 'string', timestamp: 'number' },
+            description: 'User is logged in',
+          },
         ],
         rules: [
-          { id: "process-login", description: "Process login request", then: "validateCredentials()" },
+          {
+            id: 'process-login',
+            description: 'Process login request',
+            then: 'validateCredentials()',
+          },
         ],
         constraints: [
-          { id: "valid-session", description: "Session must be valid", check: "session.isValid()", message: "Invalid session" },
+          {
+            id: 'valid-session',
+            description: 'Session must be valid',
+            check: 'session.isValid()',
+            message: 'Invalid session',
+          },
         ],
       },
     ],
   };
 
-  describe("createStateDocsGenerator", () => {
-    it("should create a generator with default config", () => {
+  describe('createStateDocsGenerator', () => {
+    it('should create a generator with default config', () => {
       const generator = createStateDocsGenerator({
-        projectTitle: "Test Project",
+        projectTitle: 'Test Project',
       });
-      
+
       expect(generator).toBeInstanceOf(StateDocsGenerator);
     });
-    
-    it("should create a generator with custom config", () => {
+
+    it('should create a generator with custom config', () => {
       const generator = createStateDocsGenerator({
-        projectTitle: "Test Project",
-        target: "./custom-docs",
+        projectTitle: 'Test Project',
+        target: './custom-docs',
         visualization: {
-          format: "mermaid",
-          theme: "dark",
+          format: 'mermaid',
+          theme: 'dark',
         },
         template: {
           toc: true,
           timestamp: false,
         },
       });
-      
+
       expect(generator).toBeInstanceOf(StateDocsGenerator);
     });
   });
 
-  describe("generateFromSchema", () => {
-    it("should generate documentation from schema", () => {
+  describe('generateFromSchema', () => {
+    it('should generate documentation from schema', () => {
       const generator = createStateDocsGenerator({
-        projectTitle: "Test Project",
+        projectTitle: 'Test Project',
       });
-      
+
       const docs = generator.generateFromSchema(testSchema);
-      
+
       expect(docs).toBeDefined();
       expect(docs.length).toBeGreaterThan(0);
     });
-    
-    it("should generate README", () => {
+
+    it('should generate README', () => {
       const generator = createStateDocsGenerator({
-        projectTitle: "Test Project",
+        projectTitle: 'Test Project',
       });
-      
+
       const docs = generator.generateFromSchema(testSchema);
-      const readme = docs.find(d => d.path.endsWith("README.md"));
-      
+      const readme = docs.find((d) => d.path.endsWith('README.md'));
+
       expect(readme).toBeDefined();
-      expect(readme?.type).toBe("markdown");
-      expect(readme?.content).toContain("TestProject");
+      expect(readme?.type).toBe('markdown');
+      expect(readme?.content).toContain('TestProject');
     });
-    
-    it("should generate models documentation", () => {
+
+    it('should generate models documentation', () => {
       const generator = createStateDocsGenerator({
-        projectTitle: "Test Project",
+        projectTitle: 'Test Project',
       });
-      
+
       const docs = generator.generateFromSchema(testSchema);
-      const modelsDocs = docs.find(d => d.path.endsWith("models.md"));
-      
+      const modelsDocs = docs.find((d) => d.path.endsWith('models.md'));
+
       expect(modelsDocs).toBeDefined();
-      expect(modelsDocs?.content).toContain("User");
-      expect(modelsDocs?.content).toContain("Post");
+      expect(modelsDocs?.content).toContain('User');
+      expect(modelsDocs?.content).toContain('Post');
     });
-    
-    it("should generate components documentation", () => {
+
+    it('should generate components documentation', () => {
       const generator = createStateDocsGenerator({
-        projectTitle: "Test Project",
+        projectTitle: 'Test Project',
       });
-      
+
       const docs = generator.generateFromSchema(testSchema);
-      const componentsDocs = docs.find(d => d.path.endsWith("components.md"));
-      
+      const componentsDocs = docs.find((d) => d.path.endsWith('components.md'));
+
       expect(componentsDocs).toBeDefined();
-      expect(componentsDocs?.content).toContain("UserProfile");
-      expect(componentsDocs?.content).toContain("PostEditor");
+      expect(componentsDocs?.content).toContain('UserProfile');
+      expect(componentsDocs?.content).toContain('PostEditor');
     });
-    
-    it("should generate logic documentation", () => {
+
+    it('should generate logic documentation', () => {
       const generator = createStateDocsGenerator({
-        projectTitle: "Test Project",
+        projectTitle: 'Test Project',
       });
-      
+
       const docs = generator.generateFromSchema(testSchema);
-      const logicDocs = docs.find(d => d.path.includes("auth-logic.md"));
-      
+      const logicDocs = docs.find((d) => d.path.includes('auth-logic.md'));
+
       expect(logicDocs).toBeDefined();
-      expect(logicDocs?.content).toContain("Login");
-      expect(logicDocs?.content).toContain("Logout");
+      expect(logicDocs?.content).toContain('Login');
+      expect(logicDocs?.content).toContain('Logout');
     });
-    
-    it("should generate Mermaid diagrams", () => {
+
+    it('should generate Mermaid diagrams', () => {
       const generator = createStateDocsGenerator({
-        projectTitle: "Test Project",
+        projectTitle: 'Test Project',
       });
-      
+
       const docs = generator.generateFromSchema(testSchema);
-      const mermaidDocs = docs.filter(d => d.type === "mermaid");
-      
+      const mermaidDocs = docs.filter((d) => d.type === 'mermaid');
+
       expect(mermaidDocs.length).toBeGreaterThan(0);
-      expect(mermaidDocs[0].content).toContain("stateDiagram-v2");
+      expect(mermaidDocs[0].content).toContain('stateDiagram-v2');
     });
-    
-    it("should include table of contents when enabled", () => {
+
+    it('should include table of contents when enabled', () => {
       const generator = createStateDocsGenerator({
-        projectTitle: "Test Project",
+        projectTitle: 'Test Project',
         template: { toc: true },
       });
-      
+
       const docs = generator.generateFromSchema(testSchema);
-      const readme = docs.find(d => d.path.endsWith("README.md"));
-      
-      expect(readme?.content).toContain("Table of Contents");
+      const readme = docs.find((d) => d.path.endsWith('README.md'));
+
+      expect(readme?.content).toContain('Table of Contents');
     });
-    
-    it("should include timestamp when enabled", () => {
+
+    it('should include timestamp when enabled', () => {
       const generator = createStateDocsGenerator({
-        projectTitle: "Test Project",
+        projectTitle: 'Test Project',
         template: { timestamp: true },
       });
-      
+
       const docs = generator.generateFromSchema(testSchema);
-      const readme = docs.find(d => d.path.endsWith("README.md"));
-      
-      expect(readme?.content).toContain("Generated on");
+      const readme = docs.find((d) => d.path.endsWith('README.md'));
+
+      expect(readme?.content).toContain('Generated on');
     });
-    
-    it("should include statistics", () => {
+
+    it('should include statistics', () => {
       const generator = createStateDocsGenerator({
-        projectTitle: "Test Project",
+        projectTitle: 'Test Project',
       });
-      
+
       const docs = generator.generateFromSchema(testSchema);
-      const readme = docs.find(d => d.path.endsWith("README.md"));
-      
-      expect(readme?.content).toContain("Statistics");
-      expect(readme?.content).toContain("Models");
-      expect(readme?.content).toContain("Components");
+      const readme = docs.find((d) => d.path.endsWith('README.md'));
+
+      expect(readme?.content).toContain('Statistics');
+      expect(readme?.content).toContain('Models');
+      expect(readme?.content).toContain('Components');
     });
   });
 
-  describe("generateDocs (convenience function)", () => {
-    it("should generate docs directly from schema", () => {
+  describe('generateDocs (convenience function)', () => {
+    it('should generate docs directly from schema', () => {
       const docs = generateDocs(testSchema, {
-        projectTitle: "Quick Project",
+        projectTitle: 'Quick Project',
       });
-      
+
       expect(docs).toBeDefined();
       expect(docs.length).toBeGreaterThan(0);
     });
   });
 
-  describe("generateFromModule", () => {
-    it("should generate documentation from a Praxis module", () => {
+  describe('generateFromModule', () => {
+    it('should generate documentation from a Praxis module', () => {
       const generator = createStateDocsGenerator({
-        projectTitle: "Test Project",
+        projectTitle: 'Test Project',
       });
-      
+
       const docs = generator.generateFromModule({
         rules: [
           {
-            id: "test-rule",
-            description: "A test rule",
+            id: 'test-rule',
+            description: 'A test rule',
             impl: () => [],
           },
         ],
         constraints: [
           {
-            id: "test-constraint",
-            description: "A test constraint",
+            id: 'test-constraint',
+            description: 'A test constraint',
             impl: () => true,
           },
         ],
       });
-      
+
       expect(docs.length).toBe(3); // rules.md, constraints.md, state-diagram.mmd
     });
-    
-    it("should generate rules documentation from module", () => {
+
+    it('should generate rules documentation from module', () => {
       const generator = createStateDocsGenerator({
-        projectTitle: "Test Project",
+        projectTitle: 'Test Project',
       });
-      
+
       const docs = generator.generateFromModule({
         rules: [
           {
-            id: "auth.login",
-            description: "Process user login",
+            id: 'auth.login',
+            description: 'Process user login',
             impl: () => [],
           },
         ],
         constraints: [],
       });
-      
-      const rulesDocs = docs.find(d => d.path.endsWith("rules.md"));
+
+      const rulesDocs = docs.find((d) => d.path.endsWith('rules.md'));
       expect(rulesDocs).toBeDefined();
-      expect(rulesDocs?.content).toContain("auth.login");
-      expect(rulesDocs?.content).toContain("Process user login");
+      expect(rulesDocs?.content).toContain('auth.login');
+      expect(rulesDocs?.content).toContain('Process user login');
     });
-    
-    it("should generate constraints documentation from module", () => {
+
+    it('should generate constraints documentation from module', () => {
       const generator = createStateDocsGenerator({
-        projectTitle: "Test Project",
+        projectTitle: 'Test Project',
       });
-      
+
       const docs = generator.generateFromModule({
         rules: [],
         constraints: [
           {
-            id: "user.valid",
-            description: "User must be valid",
+            id: 'user.valid',
+            description: 'User must be valid',
             impl: () => true,
-            meta: { errorMessage: "User is invalid" },
+            meta: { errorMessage: 'User is invalid' },
           },
         ],
       });
-      
-      const constraintsDocs = docs.find(d => d.path.endsWith("constraints.md"));
+
+      const constraintsDocs = docs.find((d) => d.path.endsWith('constraints.md'));
       expect(constraintsDocs).toBeDefined();
-      expect(constraintsDocs?.content).toContain("user.valid");
-      expect(constraintsDocs?.content).toContain("User must be valid");
+      expect(constraintsDocs?.content).toContain('user.valid');
+      expect(constraintsDocs?.content).toContain('User must be valid');
     });
   });
 });

package/src/__tests__/svelte-integration.test.ts

@@ -1,6 +1,6 @@
 /**
  * Tests for Svelte 5 Integration
- * 
+ *
  * Tests the enhanced Svelte integration with runes support,
  * history state pattern, and snapshot functionality.
  */
@@ -35,7 +35,7 @@ const Increment = defineEvent<'INCREMENT', { amount?: number }>('INCREMENT');
 
 function createTestEngine() {
   const registry = new PraxisRegistry<CounterContext>();
-  
+
   registry.registerRule(
     defineRule<CounterContext>({
       id: 'counter.increment',
@@ -43,11 +43,11 @@ function createTestEngine() {
       impl: (state, events) => {
         const event = findEvent(events, Increment);
         if (!event) return [];
-        
+
         const amount = event.payload.amount ?? 1;
         state.context.count += amount;
         state.context.history.push(state.context.count);
-        
+
         return [CountIncremented.create({ amount })];
       },
     })
@@ -78,7 +78,7 @@ describe('Svelte Integration - Store API', () => {
 
     // Dispatch event
     store.dispatch([Increment.create({ amount: 5 })]);
-    
+
     expect(states.length).toBe(2);
     expect(states[1].context.count).toBe(5);
 
@@ -98,7 +98,7 @@ describe('Svelte Integration - Store API', () => {
     expect(contexts[0].count).toBe(0);
 
     store.dispatch([Increment.create({ amount: 3 })]);
-    
+
     expect(contexts.length).toBe(2);
     expect(contexts[1].count).toBe(3);
 
@@ -258,7 +258,7 @@ describe('Svelte Integration - Runes API', () => {
 describe('History State Manager', () => {
   it('should record and navigate history', () => {
     const manager = new HistoryStateManager<CounterContext>(10);
-    
+
     // Record initial state
     const state1 = {
       context: { count: 0, history: [0] },
@@ -300,19 +300,19 @@ describe('History State Manager', () => {
 
   it('should truncate future history when recording from past', () => {
     const manager = new HistoryStateManager<CounterContext>(10);
-    
+
     const state1 = {
       context: { count: 0, history: [0] },
       facts: [],
       meta: {},
       protocolVersion: '1.0.0',
     };
-    
+
     // Record 3 states
     manager.record(state1, []);
     manager.record({ ...state1, context: { count: 1, history: [0, 1] } }, []);
     manager.record({ ...state1, context: { count: 2, history: [0, 1, 2] } }, []);
-    
+
     expect(manager.getHistory().length).toBe(3);
 
     // Go back to first state
@@ -322,14 +322,14 @@ describe('History State Manager', () => {
 
     // Record new state - should truncate
     manager.record({ ...state1, context: { count: 10, history: [0, 10] } }, []);
-    
+
     expect(manager.getHistory().length).toBe(2);
     expect(manager.getCurrentIndex()).toBe(1);
   });
 
   it('should limit history size', () => {
     const manager = new HistoryStateManager<CounterContext>(3);
-    
+
     const state = {
       context: { count: 0, history: [0] },
       facts: [],
@@ -339,10 +339,7 @@ describe('History State Manager', () => {
 
     // Record 5 states
     for (let i = 0; i < 5; i++) {
-      manager.record(
-        { ...state, context: { count: i, history: [i] } },
-        []
-      );
+      manager.record({ ...state, context: { count: i, history: [i] } }, []);
     }
 
     // Should only keep last 3
@@ -352,7 +349,7 @@ describe('History State Manager', () => {
 
   it('should clear history', () => {
     const manager = new HistoryStateManager<CounterContext>(10);
-    
+
     const state = {
       context: { count: 0, history: [0] },
       facts: [],
@@ -362,11 +359,11 @@ describe('History State Manager', () => {
 
     manager.record(state, []);
     manager.record({ ...state, context: { count: 1, history: [0, 1] } }, []);
-    
+
     expect(manager.getHistory().length).toBe(2);
 
     manager.clear();
-    
+
     expect(manager.getHistory().length).toBe(0);
     expect(manager.getCurrentIndex()).toBe(-1);
     expect(manager.current()).toBeNull();