@holoscript/plugin-fitness-wellness 2.0.1

package/src/traits/RepCounterTrait.ts

@@ -0,0 +1,26 @@
+/** @rep_counter Trait — Repetition counting and form tracking. @trait rep_counter */
+import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
+
+export interface RepCounterConfig { targetReps: number; exerciseName: string; formCheckEnabled: boolean; tempoUp: number; tempoDown: number; }
+export interface RepCounterState { currentReps: number; goodFormReps: number; badFormReps: number; isTracking: boolean; }
+
+const defaultConfig: RepCounterConfig = { targetReps: 10, exerciseName: '', formCheckEnabled: true, tempoUp: 2, tempoDown: 3 };
+
+export function createRepCounterHandler(): TraitHandler<RepCounterConfig> {
+  return { name: 'rep_counter', defaultConfig,
+    onAttach(n: HSPlusNode, _c: RepCounterConfig, ctx: TraitContext) { n.__repState = { currentReps: 0, goodFormReps: 0, badFormReps: 0, isTracking: false }; ctx.emit?.('rep:ready'); },
+    onDetach(n: HSPlusNode, _c: RepCounterConfig, ctx: TraitContext) { delete n.__repState; ctx.emit?.('rep:stopped'); },
+    onUpdate() {},
+    onEvent(n: HSPlusNode, c: RepCounterConfig, ctx: TraitContext, e: TraitEvent) {
+      const s = n.__repState as RepCounterState | undefined; if (!s) return;
+      if (e.type === 'rep:start') { s.isTracking = true; s.currentReps = 0; s.goodFormReps = 0; s.badFormReps = 0; ctx.emit?.('rep:tracking'); }
+      if (e.type === 'rep:count' && s.isTracking) {
+        s.currentReps++;
+        const goodForm = (e.payload?.goodForm as boolean) ?? true;
+        if (goodForm) s.goodFormReps++; else s.badFormReps++;
+        ctx.emit?.('rep:counted', { reps: s.currentReps, target: c.targetReps, formRate: s.goodFormReps / s.currentReps });
+        if (s.currentReps >= c.targetReps) { s.isTracking = false; ctx.emit?.('rep:target_reached', { total: s.currentReps, goodForm: s.goodFormReps }); }
+      }
+    },
+  };
+}

package/src/traits/WorkoutTrait.ts

@@ -0,0 +1,23 @@
+/** @workout Trait — Workout session definition. @trait workout */
+import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
+
+export type WorkoutType = 'strength' | 'cardio' | 'hiit' | 'yoga' | 'pilates' | 'crossfit' | 'swimming' | 'cycling' | 'running';
+export interface ExerciseSet { exerciseId: string; reps: number; weightKg?: number; durationS?: number; restS: number; }
+export interface WorkoutConfig { name: string; type: WorkoutType; exercises: ExerciseSet[]; estimatedDurationMin: number; difficulty: 'beginner' | 'intermediate' | 'advanced'; calorieTarget?: number; }
+export interface WorkoutState { isActive: boolean; currentExercise: number; elapsedS: number; caloriesBurned: number; completedSets: number; }
+
+const defaultConfig: WorkoutConfig = { name: '', type: 'strength', exercises: [], estimatedDurationMin: 30, difficulty: 'intermediate' };
+
+export function createWorkoutHandler(): TraitHandler<WorkoutConfig> {
+  return { name: 'workout', defaultConfig,
+    onAttach(n: HSPlusNode, _c: WorkoutConfig, ctx: TraitContext) { n.__workoutState = { isActive: false, currentExercise: 0, elapsedS: 0, caloriesBurned: 0, completedSets: 0 }; ctx.emit?.('workout:ready'); },
+    onDetach(n: HSPlusNode, _c: WorkoutConfig, ctx: TraitContext) { delete n.__workoutState; ctx.emit?.('workout:ended'); },
+    onUpdate(n: HSPlusNode, _c: WorkoutConfig, _ctx: TraitContext, delta: number) { const s = n.__workoutState as WorkoutState | undefined; if (s?.isActive) { s.elapsedS += delta / 1000; s.caloriesBurned += (delta / 1000) * 0.15; } },
+    onEvent(n: HSPlusNode, c: WorkoutConfig, ctx: TraitContext, e: TraitEvent) {
+      const s = n.__workoutState as WorkoutState | undefined; if (!s) return;
+      if (e.type === 'workout:start') { s.isActive = true; ctx.emit?.('workout:started', { type: c.type }); }
+      if (e.type === 'workout:complete_set') { s.completedSets++; if (s.completedSets >= c.exercises.length) { s.isActive = false; ctx.emit?.('workout:completed', { calories: Math.round(s.caloriesBurned), duration: Math.round(s.elapsedS) }); } else { s.currentExercise++; ctx.emit?.('workout:next_exercise', { index: s.currentExercise }); } }
+      if (e.type === 'workout:pause') { s.isActive = false; ctx.emit?.('workout:paused'); }
+    },
+  };
+}

package/src/traits/types.ts

@@ -0,0 +1,4 @@
+export interface HSPlusNode { id?: string; properties?: Record<string, unknown>; [key: string]: unknown; }
+export interface TraitContext { emit?: (event: string, payload?: unknown) => void; [key: string]: unknown; }
+export interface TraitEvent { type: string; payload?: Record<string, unknown>; [key: string]: unknown; }
+export interface TraitHandler<T = unknown> { name: string; defaultConfig: T; onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void; onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void; onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void; onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void; }

package/tsconfig.json

@@ -0,0 +1 @@
+{ "extends": "../../../tsconfig.json", "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true }, "include": ["src"] }

package/vitest.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vitest/config';
+import { resolve } from 'path';
+
+// resolve.alias is REQUIRED: without it, `@holoscript/core/runtime` resolves to
+// the STALE built dist and registerPluginTraits is missing ("not a function").
+// Point the subpath imports at core/engine source so the runtime barrel
+// (core/src/runtime.ts) and shared registrar resolve from source. Mirrors
+// government-civic-plugin/vitest.config.ts.
+export default defineConfig({
+  resolve: {
+    alias: {
+      '@holoscript/engine': resolve(__dirname, '../../engine/src'),
+      '@holoscript/core': resolve(__dirname, '../../core/src'),
+    },
+  },
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.test.ts'],
+    passWithNoTests: true,
+  },
+});