@critical-path/svelte 0.14.0 → 0.15.1

package/dist/workload-state.svelte.d.ts

@@ -0,0 +1,26 @@
+import type { CriticalPathClient } from '@critical-path/client';
+import type { WorkloadDistribution, WorkloadDistributionOptions, WorkloadInterval, WorkloadGroupBy, WorkloadMetric, WorkloadBucket } from '@critical-path/core';
+export declare class WorkloadState {
+    private client;
+    projectId?: string | undefined;
+    initialOptions?: WorkloadDistributionOptions | undefined;
+    data: WorkloadDistribution | null;
+    interval: WorkloadInterval;
+    groupBy: WorkloadGroupBy;
+    metric: WorkloadMetric;
+    loading: boolean;
+    error: Error | null;
+    buckets: WorkloadBucket[];
+    seriesKeys: string[];
+    seriesLabels: Record<string, string>;
+    totalHours: number;
+    totalCapacity: number;
+    averageUtilization: number | undefined;
+    constructor(client: CriticalPathClient, projectId?: string | undefined, initialOptions?: WorkloadDistributionOptions | undefined);
+    setInterval(newInterval: WorkloadInterval): Promise<void>;
+    setGroupBy(newGroupBy: WorkloadGroupBy): Promise<void>;
+    setMetric(newMetric: WorkloadMetric): Promise<void>;
+    fetch(options?: WorkloadDistributionOptions): Promise<void>;
+}
+export declare function createWorkloadState(client: CriticalPathClient, projectId?: string, initialOptions?: WorkloadDistributionOptions): WorkloadState;
+//# sourceMappingURL=workload-state.svelte.d.ts.map

package/dist/workload-state.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workload-state.svelte.d.ts","sourceRoot":"","sources":["../src/workload-state.svelte.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EACV,oBAAoB,EACpB,2BAA2B,EAC3B,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,cAAc,EACf,MAAM,qBAAqB,CAAC;AAE7B,qBAAa,aAAa;IAgBtB,OAAO,CAAC,MAAM;IACP,SAAS,CAAC,EAAE,MAAM;IAClB,cAAc,CAAC,EAAE,2BAA2B;IAjBrD,IAAI,8BAA6C;IACjD,QAAQ,mBAAoC;IAC5C,OAAO,kBAAuC;IAC9C,MAAM,iBAAqC;IAC3C,OAAO,UAA0B;IACjC,KAAK,eAA8B;IAEnC,OAAO,mBAAwD;IAC/D,UAAU,WAAmD;IAC7D,YAAY,yBAAmE;IAC/E,UAAU,SAAgD;IAC1D,aAAa,SAAmD;IAChE,kBAAkB,qBAA+D;gBAGvE,MAAM,EAAE,kBAAkB,EAC3B,SAAS,CAAC,EAAE,MAAM,YAAA,EAClB,cAAc,CAAC,EAAE,2BAA2B,YAAA;IAa/C,WAAW,CAAC,WAAW,EAAE,gBAAgB;IAKzC,UAAU,CAAC,UAAU,EAAE,eAAe;IAKtC,SAAS,CAAC,SAAS,EAAE,cAAc;IAKnC,KAAK,CAAC,OAAO,CAAC,EAAE,2BAA2B;CAiBlD;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,kBAAkB,EAC1B,SAAS,CAAC,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,2BAA2B,GAC3C,aAAa,CAEf"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@critical-path/svelte",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "description": "Svelte 5 Runes state and reactive integrations for Critical Path headless project management framework",
   "author": "Jack James",
   "license": "MIT",
@@ -18,9 +18,9 @@
     }
   },
   "dependencies": {
-    "@critical-path/client": "0.11.0",
-    "@critical-path/mcp": "0.4.0",
-    "@critical-path/core": "0.17.0"
+    "@critical-path/core": "0.19.0",
+    "@critical-path/client": "0.12.1",
+    "@critical-path/mcp": "0.6.0"
   },
   "peerDependencies": {
     "svelte": "^5.0.0"

package/src/index.test.ts

@@ -28,7 +28,9 @@ import {
   TimelineLadderState,
   createTimelineLadderState,
   TaskMetricsState,
-  createTaskMetricsState
+  createTaskMetricsState,
+  WorkloadState,
+  createWorkloadState
 } from './index.js';
 import type { CriticalPathClient } from '@critical-path/client';
 import type {
@@ -40,7 +42,8 @@ import type {
   Deliverable,
   DeliverableSummary,
   CriticalPathAnalysis,
-  TimelineLadder
+  TimelineLadder,
+  WorkloadDistribution
 } from '@critical-path/core';
 
 describe('@critical-path/svelte Svelte 5 Runes Test Suite', () => {
@@ -735,6 +738,86 @@ describe('@critical-path/svelte Svelte 5 Runes Test Suite', () => {
       expect(state.curveProfile).toBe('linear');
     });
   });
+
+  describe('WorkloadState & createWorkloadState', () => {
+    it('initializes with default options and fetches workload distribution', async () => {
+      const mockDistribution: WorkloadDistribution = {
+        projectId: 'proj_wl',
+        startDate: '2026-09-01',
+        endDate: '2026-09-14',
+        interval: 'week',
+        groupBy: 'assignee',
+        metric: 'blended',
+        seriesKeys: ['u1', 'u2'],
+        seriesLabels: { u1: 'Alice', u2: 'Bob' },
+        buckets: [
+          {
+            date: '2026-09-01',
+            timestamp: 1788220800000,
+            totalHours: 40,
+            values: { u1: 25, u2: 15 },
+            capacity: { u1: 35, u2: 40 },
+            totalCapacity: 75,
+            utilizationRatio: 0.533
+          }
+        ],
+        totalHours: 40,
+        totalCapacity: 75,
+        averageUtilization: 0.533
+      };
+
+      const mockClient = {
+        getWorkloadDistribution: vi.fn().mockResolvedValue(mockDistribution)
+      } as unknown as CriticalPathClient;
+
+      const state = createWorkloadState(mockClient, 'proj_wl', {
+        interval: 'week',
+        groupBy: 'assignee',
+        metric: 'blended'
+      });
+
+      expect(state.data).toBeNull();
+      expect(state.buckets).toEqual([]);
+      expect(state.seriesKeys).toEqual([]);
+      expect(state.totalHours).toBe(0);
+
+      await state.fetch();
+
+      expect(mockClient.getWorkloadDistribution).toHaveBeenCalledWith('proj_wl', {
+        interval: 'week',
+        groupBy: 'assignee',
+        metric: 'blended'
+      });
+      expect(state.data).toEqual(mockDistribution);
+      expect(state.buckets).toHaveLength(1);
+      expect(state.seriesKeys).toEqual(['u1', 'u2']);
+      expect(state.totalHours).toBe(40);
+      expect(state.totalCapacity).toBe(75);
+      expect(state.averageUtilization).toBe(0.533);
+    });
+
+    it('updates interval and re-fetches', async () => {
+      const mockClient = {
+        getWorkloadDistribution: vi.fn().mockResolvedValue({
+          buckets: [],
+          seriesKeys: [],
+          seriesLabels: {},
+          totalHours: 0,
+          totalCapacity: 0
+        })
+      } as unknown as CriticalPathClient;
+
+      const state = new WorkloadState(mockClient, 'proj_wl');
+      expect(state.interval).toBe('week');
+
+      await state.setInterval('day');
+      expect(state.interval).toBe('day');
+      expect(mockClient.getWorkloadDistribution).toHaveBeenCalledWith(
+        'proj_wl',
+        expect.objectContaining({ interval: 'day' })
+      );
+    });
+  });
 });
 
 

package/src/index.ts

@@ -18,5 +18,6 @@ export * from './webmcp-state.svelte.js';
 export * from './critical-path-state.svelte.js';
 export * from './timeline-ladder-state.svelte.js';
 export * from './task-metrics-state.svelte.js';
+export * from './workload-state.svelte.js';
 
 

package/src/workload-state.svelte.ts

@@ -0,0 +1,83 @@
+/// <reference types="svelte" />
+import type { CriticalPathClient } from '@critical-path/client';
+import type {
+  WorkloadDistribution,
+  WorkloadDistributionOptions,
+  WorkloadInterval,
+  WorkloadGroupBy,
+  WorkloadMetric,
+  WorkloadBucket
+} from '@critical-path/core';
+
+export class WorkloadState {
+  data = $state<WorkloadDistribution | null>(null);
+  interval = $state<WorkloadInterval>('week');
+  groupBy = $state<WorkloadGroupBy>('assignee');
+  metric = $state<WorkloadMetric>('blended');
+  loading = $state<boolean>(false);
+  error = $state<Error | null>(null);
+
+  buckets = $derived<WorkloadBucket[]>(this.data?.buckets ?? []);
+  seriesKeys = $derived<string[]>(this.data?.seriesKeys ?? []);
+  seriesLabels = $derived<Record<string, string>>(this.data?.seriesLabels ?? {});
+  totalHours = $derived<number>(this.data?.totalHours ?? 0);
+  totalCapacity = $derived<number>(this.data?.totalCapacity ?? 0);
+  averageUtilization = $derived<number | undefined>(this.data?.averageUtilization);
+
+  constructor(
+    private client: CriticalPathClient,
+    public projectId?: string,
+    public initialOptions?: WorkloadDistributionOptions
+  ) {
+    if (initialOptions?.interval) {
+      this.interval = initialOptions.interval;
+    }
+    if (initialOptions?.groupBy) {
+      this.groupBy = initialOptions.groupBy;
+    }
+    if (initialOptions?.metric) {
+      this.metric = initialOptions.metric;
+    }
+  }
+
+  async setInterval(newInterval: WorkloadInterval) {
+    this.interval = newInterval;
+    await this.fetch();
+  }
+
+  async setGroupBy(newGroupBy: WorkloadGroupBy) {
+    this.groupBy = newGroupBy;
+    await this.fetch();
+  }
+
+  async setMetric(newMetric: WorkloadMetric) {
+    this.metric = newMetric;
+    await this.fetch();
+  }
+
+  async fetch(options?: WorkloadDistributionOptions) {
+    this.loading = true;
+    this.error = null;
+    try {
+      this.data = await this.client.getWorkloadDistribution(this.projectId, {
+        ...this.initialOptions,
+        interval: this.interval,
+        groupBy: this.groupBy,
+        metric: this.metric,
+        ...options
+      });
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      this.loading = false;
+    }
+  }
+}
+
+export function createWorkloadState(
+  client: CriticalPathClient,
+  projectId?: string,
+  initialOptions?: WorkloadDistributionOptions
+): WorkloadState {
+  return new WorkloadState(client, projectId, initialOptions);
+}