@plures/praxis 1.0.2 → 1.1.0

package/src/integrations/svelte.ts

@@ -1,9 +1,9 @@
 /**
  * Svelte v5 Integration
- * 
+ *
  * Provides reactive bindings for Praxis logic engines in Svelte v5 applications.
  * Supports both traditional stores and modern Svelte 5 runes ($state, $derived, $effect).
- * 
+ *
  * Features:
  * - Store-based API for backward compatibility
  * - Runes-based composables for Svelte 5
@@ -12,8 +12,8 @@
  * - Automatic cleanup and subscription management
  */
 
-import type { LogicEngine } from "../core/engine.js";
-import type { PraxisEvent, PraxisState } from "../core/protocol.js";
+import type { LogicEngine } from '../core/engine.js';
+import type { PraxisEvent, PraxisState } from '../core/protocol.js';
 
 /**
  * Writable store interface (Svelte-compatible)
@@ -33,16 +33,16 @@ export interface Readable<T> {
 
 /**
  * Create a reactive Svelte store from a Praxis engine.
- * 
+ *
  * The store tracks the engine's state and provides methods to dispatch events.
- * 
+ *
  * @example
  * const engine = createPraxisEngine({ ... });
  * const store = createPraxisStore(engine);
- * 
+ *
  * // In Svelte component:
  * $: state = $store;
- * 
+ *
  * // Dispatch events:
  * store.dispatch([Login.create({ username: "alice", password: "secret" })]);
  */
@@ -76,11 +76,11 @@ export function createPraxisStore<TContext = unknown>(
 
 /**
  * Create a derived store that extracts the context from the engine state.
- * 
+ *
  * @example
  * const engine = createPraxisEngine({ ... });
  * const contextStore = createContextStore(engine);
- * 
+ *
  * // In Svelte component:
  * $: context = $contextStore;
  */
@@ -114,11 +114,11 @@ export function createContextStore<TContext = unknown>(
 
 /**
  * Create a derived store that extracts specific data from the context.
- * 
+ *
  * @example
  * const engine = createPraxisEngine<{ count: number }>({ ... });
  * const countStore = createDerivedStore(engine, (ctx) => ctx.count);
- * 
+ *
  * // In Svelte component:
  * $: count = $countStore;
  */
@@ -207,34 +207,34 @@ export interface PraxisEngineBinding<TContext = unknown> {
 
 /**
  * Create a reactive binding to a Praxis engine with Svelte 5 runes support.
- * 
+ *
  * This composable provides a runes-compatible API for integrating Praxis
  * with Svelte 5 components. The returned state is reactive and will
  * automatically update the component when the engine state changes.
- * 
+ *
  * Note: The history/snapshot feature tracks state snapshots but doesn't
  * restore the engine to previous states. When you navigate history (undo/redo),
  * you're viewing past snapshots, but new events are still applied to the
  * current engine state. For true undo/redo, use createHistoryEngine or
  * implement state restoration in your application logic.
- * 
+ *
  * @example
  * <script>
  *   import { usePraxisEngine } from '@plures/praxis/svelte';
  *   import { createMyEngine } from './my-engine';
- *   
+ *
  *   const engine = createMyEngine();
  *   const { context, dispatch, undo, canUndo } = usePraxisEngine(engine, {
  *     enableHistory: true
  *   });
  * </script>
- * 
+ *
  * <div>
  *   <p>Count: {context.count}</p>
  *   <button onclick={() => dispatch([Increment.create({})])}>+</button>
  *   <button onclick={() => undo()} disabled={!canUndo}>Undo</button>
  * </div>
- * 
+ *
  * @param engine The Praxis logic engine
  * @param options Configuration options
  * @returns Reactive binding with state, context, and control methods
@@ -277,7 +277,7 @@ export function usePraxisEngine<TContext = unknown>(
         state: currentState,
         events,
       });
-      
+
       // Limit history size
       if (snapshots.length > maxHistorySize) {
         snapshots.shift();
@@ -292,7 +292,7 @@ export function usePraxisEngine<TContext = unknown>(
       console.warn('History is not enabled for this engine');
       return;
     }
-    
+
     if (index < 0 || index >= snapshots.length) {
       console.warn(`Invalid snapshot index: ${index}`);
       return;
@@ -345,20 +345,20 @@ export function usePraxisEngine<TContext = unknown>(
 
 /**
  * Create a reactive derived value from engine context with Svelte 5 runes.
- * 
+ *
  * This composable extracts and tracks a specific value from the engine context.
  * The returned value is reactive and will update when the selected value changes.
- * 
+ *
  * @example
  * <script>
  *   import { usePraxisContext } from '@plures/praxis/svelte';
- *   
+ *
  *   const engine = createMyEngine();
  *   const count = usePraxisContext(engine, (ctx) => ctx.count);
  * </script>
- * 
+ *
  * <p>Count: {count}</p>
- * 
+ *
  * @param engine The Praxis logic engine
  * @param selector Function to extract value from context
  * @returns Reactive derived value
@@ -373,21 +373,21 @@ export function usePraxisContext<TContext = unknown, TDerived = unknown>(
 
 /**
  * Subscribe to engine state changes with automatic cleanup.
- * 
+ *
  * This composable sets up a subscription to engine state changes and
  * automatically cleans up when the component is destroyed.
- * 
+ *
  * @example
  * <script>
  *   import { usePraxisSubscription } from '@plures/praxis/svelte';
- *   
+ *
  *   const engine = createMyEngine();
- *   
+ *
  *   usePraxisSubscription(engine, (state) => {
  *     console.log('State changed:', state);
  *   });
  * </script>
- * 
+ *
  * @param engine The Praxis logic engine
  * @param callback Function to call when state changes
  */
@@ -543,20 +543,20 @@ export class HistoryStateManager<TContext = unknown> {
 
 /**
  * Create a Praxis engine with history tracking.
- * 
+ *
  * This utility wraps an engine with automatic history recording,
  * providing undo/redo functionality.
- * 
+ *
  * @example
  * const engine = createPraxisEngine({ ... });
  * const { dispatch, undo, redo, canUndo, canRedo } = createHistoryEngine(engine);
- * 
+ *
  * // Use normally
  * dispatch([Login.create({ username: "alice" })]);
- * 
+ *
  * // Undo the login
  * undo();
- * 
+ *
  * @param engine The base Praxis engine
  * @param options History configuration
  * @returns Enhanced engine with history methods

package/src/integrations/tauri.ts

@@ -1,21 +1,21 @@
 /**
  * Tauri Integration
- * 
+ *
  * Integration with plures/svelte-tauri-template for cross-platform desktop applications.
  * Provides Praxis engine integration with Tauri 2 for native desktop capabilities.
- * 
+ *
  * Features:
  * - Cross-Platform: Windows, macOS, Linux, Android, iOS
  * - Native Integration: File system, system tray, notifications
  * - IPC Bridge: Type-safe communication between Rust and TypeScript
  * - Auto-Updates: Built-in update system
  * - Code Signing: Support for signed releases
- * 
+ *
  * @see https://github.com/plures/svelte-tauri-template
  */
 
-import type { LogicEngine } from "../core/engine.js";
-import type { PraxisEvent } from "../core/protocol.js";
+import type { LogicEngine } from '../core/engine.js';
+import type { PraxisEvent } from '../core/protocol.js';
 
 /**
  * Tauri app configuration
@@ -233,7 +233,7 @@ export interface TauriNotificationOptions {
 
 /**
  * Tauri bridge for Praxis integration
- * 
+ *
  * Provides type-safe access to Tauri APIs from Praxis applications.
  */
 export interface TauriBridge {
@@ -243,25 +243,25 @@ export interface TauriBridge {
     version: string;
     tauriVersion: string;
   };
-  
+
   /** File system operations */
   fs: TauriFS;
-  
+
   /** System tray operations */
   tray: TauriTray;
-  
+
   /** Notification operations */
   notification: TauriNotification;
-  
+
   /** Invoke a Tauri command */
   invoke<T = unknown>(cmd: string, payload?: unknown): Promise<T>;
-  
+
   /** Listen to a Tauri event */
   listen<T = unknown>(event: string, handler: (event: TauriEvent<T>) => void): Promise<() => void>;
-  
+
   /** Emit a Tauri event */
   emit(event: string, payload?: unknown): Promise<void>;
-  
+
   /** Get window operations */
   window: {
     /** Minimize window */
@@ -283,10 +283,10 @@ export interface TauriBridge {
     /** Focus window */
     focus(): Promise<void>;
   };
-  
+
   /** Check for updates */
   checkForUpdates(): Promise<TauriUpdateInfo | null>;
-  
+
   /** Install update */
   installUpdate(): Promise<void>;
 }
@@ -311,75 +311,75 @@ export interface TauriUpdateInfo {
 export interface TauriPraxisAdapter<TContext = unknown> {
   /** Save engine state to file */
   saveState(state: TContext): Promise<void>;
-  
+
   /** Load engine state from file */
   loadState(): Promise<TContext | null>;
-  
+
   /** Save events to file */
   saveEvents(events: PraxisEvent[]): Promise<void>;
-  
+
   /** Load events from file */
   loadEvents(): Promise<PraxisEvent[]>;
-  
+
   /** Watch for file changes */
   watchStateFile(handler: (state: TContext) => void): Promise<() => void>;
-  
+
   /** Get state file path */
   getStatePath(): string;
-  
+
   /** Get events file path */
   getEventsPath(): string;
 }
 
 /**
  * Create a mock Tauri bridge for development/testing
- * 
+ *
  * This provides a mock implementation that works without Tauri runtime.
  */
 export function createMockTauriBridge(): TauriBridge {
   const eventHandlers = new Map<string, Set<(event: TauriEvent) => void>>();
   const storage = new Map<string, unknown>();
-  
+
   return {
     app: {
       name: 'Mock App',
       version: '0.0.0',
       tauriVersion: 'mock',
     },
-    
+
     fs: {
       async readFile(path: string): Promise<Uint8Array> {
         const data = storage.get(path);
         if (data instanceof Uint8Array) return data;
         throw new Error(`File not found: ${path}`);
       },
-      
+
       async readTextFile(path: string): Promise<string> {
         const data = storage.get(path);
         if (typeof data === 'string') return data;
         throw new Error(`File not found: ${path}`);
       },
-      
+
       async writeFile(path: string, data: Uint8Array): Promise<void> {
         storage.set(path, data);
       },
-      
+
       async writeTextFile(path: string, data: string): Promise<void> {
         storage.set(path, data);
       },
-      
+
       async exists(path: string): Promise<boolean> {
         return storage.has(path);
       },
-      
+
       async mkdir(_path: string, _options?: { recursive?: boolean }): Promise<void> {
         // No-op for mock
       },
-      
+
       async remove(path: string, _options?: { recursive?: boolean }): Promise<void> {
         storage.delete(path);
       },
-      
+
       async rename(oldPath: string, newPath: string): Promise<void> {
         const data = storage.get(oldPath);
         if (data !== undefined) {
@@ -387,12 +387,12 @@ export function createMockTauriBridge(): TauriBridge {
           storage.delete(oldPath);
         }
       },
-      
+
       async readDir(_path: string): Promise<TauriFileEntry[]> {
         return [];
       },
     },
-    
+
     tray: {
       async setIcon(_icon: string | Uint8Array): Promise<void> {},
       async setTooltip(_tooltip: string): Promise<void> {},
@@ -400,7 +400,7 @@ export function createMockTauriBridge(): TauriBridge {
       async show(): Promise<void> {},
       async hide(): Promise<void> {},
     },
-    
+
     notification: {
       async send(options: TauriNotificationOptions): Promise<void> {
         console.log('Mock notification:', options.title, options.body);
@@ -412,31 +412,34 @@ export function createMockTauriBridge(): TauriBridge {
         return 'granted';
       },
     },
-    
+
     async invoke<T = unknown>(cmd: string, payload?: unknown): Promise<T> {
       console.log('Mock invoke:', cmd, payload);
       return null as T;
     },
-    
-    async listen<T = unknown>(event: string, handler: (event: TauriEvent<T>) => void): Promise<() => void> {
+
+    async listen<T = unknown>(
+      event: string,
+      handler: (event: TauriEvent<T>) => void
+    ): Promise<() => void> {
       if (!eventHandlers.has(event)) {
         eventHandlers.set(event, new Set());
       }
       eventHandlers.get(event)!.add(handler as (event: TauriEvent) => void);
-      
+
       return () => {
         eventHandlers.get(event)?.delete(handler as (event: TauriEvent) => void);
       };
     },
-    
+
     async emit(event: string, payload?: unknown): Promise<void> {
       const handlers = eventHandlers.get(event);
       if (handlers) {
         const tauriEvent: TauriEvent = { event, payload };
-        handlers.forEach(h => h(tauriEvent));
+        handlers.forEach((h) => h(tauriEvent));
       }
     },
-    
+
     window: {
       async minimize(): Promise<void> {},
       async maximize(): Promise<void> {},
@@ -448,31 +451,31 @@ export function createMockTauriBridge(): TauriBridge {
       async hide(): Promise<void> {},
       async focus(): Promise<void> {},
     },
-    
+
     async checkForUpdates(): Promise<TauriUpdateInfo | null> {
       return null;
     },
-    
+
     async installUpdate(): Promise<void> {},
   };
 }
 
 /**
  * Create a Tauri-Praxis adapter for engine persistence
- * 
+ *
  * @example
  * ```typescript
  * import { createTauriPraxisAdapter } from '@plures/praxis/integrations/tauri';
- * 
+ *
  * const adapter = createTauriPraxisAdapter({
  *   bridge: tauriBridge,
  *   statePath: 'app-state.json',
  *   eventsPath: 'app-events.json',
  * });
- * 
+ *
  * // Save state
  * await adapter.saveState(engine.getContext());
- * 
+ *
  * // Load state
  * const savedState = await adapter.loadState();
  * ```
@@ -483,53 +486,53 @@ export function createTauriPraxisAdapter<TContext = unknown>(options: {
   eventsPath?: string;
 }): TauriPraxisAdapter<TContext> {
   const { bridge, statePath = 'praxis-state.json', eventsPath = 'praxis-events.json' } = options;
-  
+
   return {
     async saveState(state: TContext): Promise<void> {
       const json = JSON.stringify(state, null, 2);
       await bridge.fs.writeTextFile(statePath, json);
     },
-    
+
     async loadState(): Promise<TContext | null> {
       try {
         const exists = await bridge.fs.exists(statePath);
         if (!exists) return null;
-        
+
         const json = await bridge.fs.readTextFile(statePath);
         return JSON.parse(json) as TContext;
       } catch {
         return null;
       }
     },
-    
+
     async saveEvents(events: PraxisEvent[]): Promise<void> {
       const json = JSON.stringify(events, null, 2);
       await bridge.fs.writeTextFile(eventsPath, json);
     },
-    
+
     async loadEvents(): Promise<PraxisEvent[]> {
       try {
         const exists = await bridge.fs.exists(eventsPath);
         if (!exists) return [];
-        
+
         const json = await bridge.fs.readTextFile(eventsPath);
         return JSON.parse(json) as PraxisEvent[];
       } catch {
         return [];
       }
     },
-    
+
     async watchStateFile(_handler: (state: TContext) => void): Promise<() => void> {
       // In a real implementation, this would use Tauri's fs watch API
       // For now, we'll just return a no-op cleanup function
       console.log('File watching not implemented in mock');
       return () => {};
     },
-    
+
     getStatePath(): string {
       return statePath;
     },
-    
+
     getEventsPath(): string {
       return eventsPath;
     },
@@ -538,16 +541,16 @@ export function createTauriPraxisAdapter<TContext = unknown>(options: {
 
 /**
  * Attach Tauri bridge to a Praxis engine for auto-save
- * 
+ *
  * @example
  * ```typescript
  * import { attachTauriToEngine } from '@plures/praxis/integrations/tauri';
- * 
+ *
  * const cleanup = attachTauriToEngine(engine, adapter, {
  *   autoSave: true,
  *   saveInterval: 5000,
  * });
- * 
+ *
  * // Later, cleanup subscriptions
  * cleanup();
  * ```
@@ -562,15 +565,15 @@ export function attachTauriToEngine<TContext>(
 ): () => void {
   const { autoSave = true, saveInterval = 5000 } = options;
   const cleanupFns: Array<() => void> = [];
-  
+
   if (autoSave) {
     let saveTimer: ReturnType<typeof setTimeout> | null = null;
     let pendingSave = false;
-    
+
     const debouncedSave = async () => {
       pendingSave = true;
       if (saveTimer) clearTimeout(saveTimer);
-      
+
       saveTimer = setTimeout(async () => {
         if (pendingSave) {
           await adapter.saveState(engine.getContext());
@@ -578,22 +581,22 @@ export function attachTauriToEngine<TContext>(
         }
       }, saveInterval);
     };
-    
+
     // Note: In a future implementation, this would hook into engine state changes
     // For now, we provide manual save on interval if state is dirty
     // The caller can trigger debouncedSave manually after engine.step() calls
-    
+
     // Initial save setup - clean up timer on dispose
     cleanupFns.push(() => {
       if (saveTimer) clearTimeout(saveTimer);
     });
-    
+
     // Expose a way to trigger save (for future use)
     void debouncedSave;
   }
-  
+
   return () => {
-    cleanupFns.forEach(fn => fn());
+    cleanupFns.forEach((fn) => fn());
   };
 }
 
@@ -602,7 +605,8 @@ export function attachTauriToEngine<TContext>(
  */
 export function generateTauriConfig(config: TauriAppConfig): Record<string, unknown> {
   return {
-    $schema: "https://raw.githubusercontent.com/tauri-apps/tauri/tauri-v2.0.0/core/tauri-config-schema/schema.json",
+    $schema:
+      'https://raw.githubusercontent.com/tauri-apps/tauri/tauri-v2.0.0/core/tauri-config-schema/schema.json',
     productName: config.name,
     version: config.version,
     identifier: config.identifier,
@@ -628,11 +632,9 @@ export function generateTauriConfig(config: TauriAppConfig): Record<string, unkn
       },
     },
     build: {
-      devUrl: "http://localhost:5173",
-      frontendDist: "../dist",
+      devUrl: 'http://localhost:5173',
+      frontendDist: '../dist',
     },
-    plugins: Object.fromEntries(
-      (config.plugins || []).map(p => [p.name, p.config || {}])
-    ),
+    plugins: Object.fromEntries((config.plugins || []).map((p) => [p.name, p.config || {}])),
   };
 }