@critical-path/svelte 0.17.11 → 0.18.1

package/src/index.ts

@@ -1,23 +0,0 @@
-import { CriticalPathClient, type ClientOptions } from '@critical-path/client';
-
-export function createCriticalPathClient(options: ClientOptions): CriticalPathClient {
-  return new CriticalPathClient(options);
-}
-
-export * from './project-state.svelte.js';
-export * from './task-state.svelte.js';
-export * from './workflow-state.svelte.js';
-export * from './comment-state.svelte.js';
-export * from './attachment-state.svelte.js';
-export * from './activity-state.svelte.js';
-export * from './deliverable-state.svelte.js';
-export * from './deliverable-summary-state.svelte.js';
-export * from './kanban-state.svelte.js';
-export * from './task-transitions-state.svelte.js';
-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/kanban-state.svelte.ts

@@ -1,113 +0,0 @@
-/// <reference types="svelte" />
-import type { CreateTaskBody } from '@critical-path/core/schemas';
-import type { CriticalPathClient } from '@critical-path/client';
-import type { Task, TaskStatus, StatusDefinition, SemanticStatus } from '@critical-path/core';
-import { resolveStatusDefinition } from '@critical-path/core';
-import { TaskState } from './task-state.svelte.js';
-
-export interface KanbanStateOptions {
-  groupBy?: 'workflow' | 'semantic';
-  customDefinitions?: StatusDefinition[];
-}
-
-export class KanbanState {
-  private taskState: TaskState;
-
-  get data(): Task[] {
-    return this.taskState.data;
-  }
-
-  get tasks(): Task[] {
-    return this.taskState.data;
-  }
-
-  get loading(): boolean {
-    return this.taskState.loading;
-  }
-
-  get error(): Error | null {
-    return this.taskState.error;
-  }
-
-  columns = $derived.by<Record<string, Task[]>>(() => {
-    const tasks = this.taskState.data;
-    if (this.options?.groupBy === 'semantic') {
-      const semanticCols: Record<SemanticStatus, Task[]> = {
-        not_started: [],
-        in_progress: [],
-        completed: [],
-        canceled: []
-      };
-      for (const task of tasks) {
-        const category =
-          task.semanticStatus ||
-          resolveStatusDefinition(task.status, this.options?.customDefinitions).category;
-        if (semanticCols[category]) {
-          semanticCols[category].push(task);
-        } else {
-          semanticCols.not_started.push(task);
-        }
-      }
-      return semanticCols;
-    }
-
-    const workflowCols: Record<string, Task[]> = {};
-    if (this.options?.customDefinitions && this.options.customDefinitions.length > 0) {
-      for (const def of this.options.customDefinitions) {
-        workflowCols[def.key] = [];
-      }
-    } else {
-      workflowCols.backlog = [];
-      workflowCols.todo = [];
-      workflowCols.in_progress = [];
-      workflowCols.in_review = [];
-      workflowCols.done = [];
-      workflowCols.canceled = [];
-    }
-
-    for (const task of tasks) {
-      if (!workflowCols[task.status]) {
-        workflowCols[task.status] = [];
-      }
-      workflowCols[task.status].push(task);
-    }
-
-    return workflowCols;
-  });
-
-  constructor(
-    client: CriticalPathClient,
-    public projectId?: string,
-    public options: KanbanStateOptions = {}
-  ) {
-    this.taskState = new TaskState(client, projectId);
-  }
-
-  async fetch() {
-    return this.taskState.fetch();
-  }
-
-  async createTask(input: CreateTaskBody) {
-    return this.taskState.createTask(input);
-  }
-
-  async moveTask(taskId: string, targetStatus: TaskStatus) {
-    return this.taskState.updateTaskStatus(taskId, targetStatus);
-  }
-
-  async updateTaskStatus(taskId: string, status: TaskStatus) {
-    return this.taskState.updateTaskStatus(taskId, status);
-  }
-
-  async deleteTask(taskId: string) {
-    return this.taskState.deleteTask(taskId);
-  }
-}
-
-export function createKanbanState(
-  client: CriticalPathClient,
-  projectId?: string,
-  options?: KanbanStateOptions
-): KanbanState {
-  return new KanbanState(client, projectId, options);
-}

package/src/project-state.svelte.ts

@@ -1,54 +0,0 @@
-/// <reference types="svelte" />
-import type { CriticalPathClient } from '@critical-path/client';
-import type { Project } from '@critical-path/core';
-
-export class ProjectState {
-  data = $state<Project[]>([]);
-  loading = $state<boolean>(false);
-  error = $state<Error | null>(null);
-
-  constructor(private client: CriticalPathClient) {}
-
-  async fetch() {
-    this.loading = true;
-    this.error = null;
-    try {
-      this.data = await this.client.getProjects();
-    } catch (err) {
-      this.error = err instanceof Error ? err : new Error(String(err));
-    } finally {
-      this.loading = false;
-    }
-  }
-
-  async createProject(input: Omit<Project, 'id' | 'createdAt' | 'updatedAt'>) {
-    const tempId = `temp_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
-    const now = new Date().toISOString();
-    const tempProject: Project = {
-      ...input,
-      id: tempId,
-      createdAt: now,
-      updatedAt: now
-    };
-
-    // Optimistically add temp project
-    this.data = [...this.data, tempProject];
-
-    try {
-      const created = await this.client.createProject(input);
-      // Replace temp project with server created project
-      this.data = this.data.map((p) => (p.id === tempId ? created : p));
-      return created;
-    } catch (err) {
-      // Rollback on error
-      this.data = this.data.filter((p) => p.id !== tempId);
-      const errorObj = err instanceof Error ? err : new Error(String(err));
-      this.error = errorObj;
-      throw errorObj;
-    }
-  }
-}
-
-export function createProjectState(client: CriticalPathClient): ProjectState {
-  return new ProjectState(client);
-}

package/src/task-metrics-state.svelte.ts

@@ -1,83 +0,0 @@
-/// <reference types="svelte" />
-import type { CriticalPathClient } from '@critical-path/client';
-import type {
-  TaskMetrics,
-  TaskProgressHistory,
-  TaskInferredActuals,
-  RealityDelta,
-  TaskProgressInference,
-  TaskEVM,
-  ProgressCurveProfile
-} from '@critical-path/core';
-
-export class TaskMetricsState {
-  metrics = $state<TaskMetrics | null>(null);
-  history = $state<TaskProgressHistory | null>(null);
-  loading = $state<boolean>(false);
-  error = $state<Error | null>(null);
-
-  inferredActuals = $derived<TaskInferredActuals | null>(this.metrics?.inferredActuals ?? null);
-  realityDelta = $derived<RealityDelta | null>(this.metrics?.realityDelta ?? null);
-  progress = $derived<TaskProgressInference | null>(this.metrics?.progress ?? null);
-  evm = $derived<TaskEVM | null>(this.metrics?.evm ?? null);
-  curveProfile = $derived<ProgressCurveProfile | null>(this.history?.curveProfile ?? null);
-
-  constructor(
-    private client: CriticalPathClient,
-    public taskId: string
-  ) {}
-
-  async fetchMetrics(): Promise<TaskMetrics | null> {
-    this.loading = true;
-    this.error = null;
-    try {
-      this.metrics = await this.client.getTaskMetrics(this.taskId);
-      return this.metrics;
-    } catch (err) {
-      this.error = err instanceof Error ? err : new Error(String(err));
-      return null;
-    } finally {
-      this.loading = false;
-    }
-  }
-
-  async fetchHistory(): Promise<TaskProgressHistory | null> {
-    this.loading = true;
-    this.error = null;
-    try {
-      this.history = await this.client.getTaskProgressHistory(this.taskId);
-      return this.history;
-    } catch (err) {
-      this.error = err instanceof Error ? err : new Error(String(err));
-      return null;
-    } finally {
-      this.loading = false;
-    }
-  }
-
-  async fetchAll(): Promise<{ metrics: TaskMetrics | null; history: TaskProgressHistory | null }> {
-    this.loading = true;
-    this.error = null;
-    try {
-      const [m, h] = await Promise.all([
-        this.client.getTaskMetrics(this.taskId),
-        this.client.getTaskProgressHistory(this.taskId)
-      ]);
-      this.metrics = m;
-      this.history = h;
-      return { metrics: m, history: h };
-    } catch (err) {
-      this.error = err instanceof Error ? err : new Error(String(err));
-      return { metrics: null, history: null };
-    } finally {
-      this.loading = false;
-    }
-  }
-}
-
-export function createTaskMetricsState(
-  client: CriticalPathClient,
-  taskId: string
-): TaskMetricsState {
-  return new TaskMetricsState(client, taskId);
-}

package/src/task-state.svelte.ts

@@ -1,195 +0,0 @@
-/// <reference types="svelte" />
-import type { CreateTaskBody, UpdateTaskBody } from '@critical-path/core/schemas';
-import type { CriticalPathClient } from '@critical-path/client';
-import { type Task, type TaskStatus, isTempTaskId } from '@critical-path/core';
-
-export class TaskState {
-  data = $state<Task[]>([]);
-  loading = $state<boolean>(false);
-  error = $state<Error | null>(null);
-
-  private pendingCreations = new Map<string, Promise<Task>>();
-  private tempToRealIdMap = new Map<string, string>();
-
-  constructor(
-    private client: CriticalPathClient,
-    public projectId?: string
-  ) {}
-
-  async fetch() {
-    this.loading = true;
-    this.error = null;
-    try {
-      this.data = await this.client.getTasks(this.projectId);
-    } catch (err) {
-      this.error = err instanceof Error ? err : new Error(String(err));
-    } finally {
-      this.loading = false;
-    }
-  }
-
-  async createTask(input: CreateTaskBody) {
-    const tempId = `temp_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
-    const now = new Date().toISOString();
-    const tempTask: Task = {
-      ...input,
-      // Placeholders until the server responds with the workflow's real defaults
-      status: input.status ?? 'todo',
-      priority: input.priority ?? 'medium',
-      id: tempId,
-      createdAt: now,
-      updatedAt: now
-    };
-
-    // Optimistically add temp task
-    this.data = [...this.data, tempTask];
-
-    const promise = this.client.createTask(input);
-    this.pendingCreations.set(tempId, promise);
-
-    try {
-      const created = await promise;
-      this.tempToRealIdMap.set(tempId, created.id);
-      // Replace temp task with created task from server
-      this.data = this.data.map((t) => (t.id === tempId ? created : t));
-      return created;
-    } catch (err) {
-      // Rollback on error
-      this.data = this.data.filter((t) => t.id !== tempId);
-      const errorObj = err instanceof Error ? err : new Error(String(err));
-      this.error = errorObj;
-      throw errorObj;
-    } finally {
-      this.pendingCreations.delete(tempId);
-    }
-  }
-
-  async updateTask(taskId: string, updates: UpdateTaskBody) {
-    let targetId = taskId;
-    if (this.tempToRealIdMap.has(taskId)) {
-      targetId = this.tempToRealIdMap.get(taskId)!;
-    }
-
-    // 1. Immediately apply optimistic updates to the local task (temp or confirmed)
-    const idx = this.data.findIndex((t) => t.id === targetId || t.id === taskId);
-    let previousTask: Task | undefined;
-    if (idx !== -1) {
-      previousTask = this.data[idx];
-      const optimisticTask: Task = {
-        ...previousTask,
-        ...updates,
-        updatedAt: new Date().toISOString()
-      };
-      const newData = [...this.data];
-      newData[idx] = optimisticTask;
-      this.data = newData;
-    }
-
-    // 2. If it's a temporary task, await pending creation if in flight
-    if (isTempTaskId(targetId)) {
-      const pendingPromise =
-        this.pendingCreations.get(targetId) ||
-        (this.pendingCreations.size === 1
-          ? Array.from(this.pendingCreations.values())[0]
-          : undefined);
-
-      if (pendingPromise) {
-        try {
-          const created = await pendingPromise;
-          if (created && created.id) {
-            targetId = created.id;
-            this.tempToRealIdMap.set(taskId, targetId);
-          }
-        } catch {
-          throw new Error(`Failed to update task: task creation failed for "${taskId}"`);
-        }
-      }
-    }
-
-    // If still a temp ID, task exists purely in local client state; avoid sending unresolvable temp ID
-    if (isTempTaskId(targetId)) {
-      const currentTask = this.data.find((t) => t.id === targetId || t.id === taskId);
-      return (currentTask || { id: targetId, ...updates }) as Task;
-    }
-
-    try {
-      const updated = await this.client.updateTask(targetId, updates);
-      const currentIdx = this.data.findIndex((t) => t.id === targetId || t.id === taskId);
-      if (currentIdx !== -1) {
-        const confirmedData = [...this.data];
-        confirmedData[currentIdx] = updated;
-        this.data = confirmedData;
-      }
-      return updated;
-    } catch (err) {
-      // Rollback to previous task on error
-      if (previousTask) {
-        const rollbackIdx = this.data.findIndex((t) => t.id === targetId || t.id === taskId);
-        if (rollbackIdx !== -1) {
-          const rollbackData = [...this.data];
-          rollbackData[rollbackIdx] = previousTask;
-          this.data = rollbackData;
-        }
-      }
-      const errorObj = err instanceof Error ? err : new Error(String(err));
-      this.error = errorObj;
-      throw errorObj;
-    }
-  }
-
-  async updateTaskStatus(taskId: string, status: TaskStatus) {
-    return this.updateTask(taskId, { status });
-  }
-
-  async deleteTask(taskId: string) {
-    let targetId = taskId;
-    if (this.tempToRealIdMap.has(taskId)) {
-      targetId = this.tempToRealIdMap.get(taskId)!;
-    }
-
-    const idx = this.data.findIndex((t) => t.id === targetId || t.id === taskId);
-    const previousTask = idx !== -1 ? this.data[idx] : undefined;
-
-    // Optimistically remove task from local state
-    if (idx !== -1) {
-      this.data = this.data.filter((t) => t.id !== targetId && t.id !== taskId);
-    }
-
-    // If temporary task:
-    if (isTempTaskId(targetId)) {
-      const pendingPromise = this.pendingCreations.get(targetId);
-      if (pendingPromise) {
-        try {
-          const created = await pendingPromise;
-          if (created && created.id) {
-            await this.client.deleteTask(created.id);
-          }
-        } catch {
-          // If creation failed anyway, task is already gone
-        }
-      }
-      return;
-    }
-
-    try {
-      await this.client.deleteTask(targetId);
-    } catch (err) {
-      // Rollback on error by re-inserting at previous index
-      if (previousTask && idx !== -1) {
-        const restoredData = [...this.data];
-        restoredData.splice(idx, 0, previousTask);
-        this.data = restoredData;
-      }
-      const errorObj = err instanceof Error ? err : new Error(String(err));
-      this.error = errorObj;
-      throw errorObj;
-    }
-  }
-}
-
-export function createTaskState(
-  client: CriticalPathClient,
-  projectId?: string
-): TaskState {
-  return new TaskState(client, projectId);
-}

package/src/task-transitions-state.svelte.ts

@@ -1,36 +0,0 @@
-/// <reference types="svelte" />
-import type { CriticalPathClient } from '@critical-path/client';
-
-export class TaskTransitionsState {
-  allowedTransitions = $state<string[]>([]);
-  loading = $state<boolean>(false);
-  error = $state<Error | null>(null);
-
-  constructor(private client: CriticalPathClient, public taskId?: string) {}
-
-  async fetch(taskId?: string) {
-    const targetTaskId = taskId || this.taskId;
-    if (!targetTaskId) {
-      this.allowedTransitions = [];
-      this.loading = false;
-      return;
-    }
-    this.taskId = targetTaskId;
-    this.loading = true;
-    this.error = null;
-    try {
-      this.allowedTransitions = await this.client.getAllowedTaskTransitions(targetTaskId);
-    } catch (err) {
-      this.error = err instanceof Error ? err : new Error(String(err));
-    } finally {
-      this.loading = false;
-    }
-  }
-}
-
-export function createTaskTransitionsState(
-  client: CriticalPathClient,
-  taskId?: string
-): TaskTransitionsState {
-  return new TaskTransitionsState(client, taskId);
-}

package/src/timeline-ladder-state.svelte.ts

@@ -1,58 +0,0 @@
-/// <reference types="svelte" />
-import type { CriticalPathClient } from '@critical-path/client';
-import type {
-  TimelineLadder,
-  TimelineLadderOptions,
-  AbstractionLevel,
-  MacroTimelineSummary,
-  ConcreteTaskEvidence
-} from '@critical-path/core';
-
-export class TimelineLadderState {
-  data = $state<TimelineLadder | null>(null);
-  level = $state<AbstractionLevel>('all');
-  loading = $state<boolean>(false);
-  error = $state<Error | null>(null);
-
-  macro = $derived<MacroTimelineSummary | null>(this.data?.macro ?? null);
-  standard = $derived<TimelineLadder['standard'] | null>(this.data?.standard ?? null);
-  concrete = $derived<Record<string, ConcreteTaskEvidence> | null>(this.data?.concrete ?? null);
-
-  constructor(
-    private client: CriticalPathClient,
-    public projectId: string,
-    initialOptions?: TimelineLadderOptions
-  ) {
-    if (initialOptions?.level) {
-      this.level = initialOptions.level;
-    }
-  }
-
-  async setLevel(newLevel: AbstractionLevel) {
-    this.level = newLevel;
-    await this.fetch();
-  }
-
-  async fetch(options?: TimelineLadderOptions) {
-    this.loading = true;
-    this.error = null;
-    try {
-      this.data = await this.client.getTimelineLadder(this.projectId, {
-        level: this.level,
-        ...options
-      });
-    } catch (err) {
-      this.error = err instanceof Error ? err : new Error(String(err));
-    } finally {
-      this.loading = false;
-    }
-  }
-}
-
-export function createTimelineLadderState(
-  client: CriticalPathClient,
-  projectId: string,
-  initialOptions?: TimelineLadderOptions
-): TimelineLadderState {
-  return new TimelineLadderState(client, projectId, initialOptions);
-}

package/src/webmcp-state.svelte.ts

@@ -1,78 +0,0 @@
-import type { CriticalPathClient } from '@critical-path/client';
-import { registerWebMcpTools, type WebMcpRegistryHandle } from '@critical-path/mcp/web';
-
-export interface WebMcpStateOptions {
-  projectId?: string;
-  tools?: string[];
-  autoRegister?: boolean;
-  document?: any;
-  navigator?: any;
-  window?: any;
-  onToolExecuted?: (toolName: string, input: any, result: any) => void;
-}
-
-export class WebMcpState {
-  registered = $state<boolean>(false);
-  activeProjectId = $state<string | undefined>(undefined);
-  tools = $state<string[]>([]);
-  error = $state<Error | null>(null);
-
-  private handle: WebMcpRegistryHandle | null = null;
-  private abortController: AbortController | null = null;
-
-  constructor(private client: CriticalPathClient, private options: WebMcpStateOptions = {}) {
-    this.activeProjectId = options.projectId;
-    if (options.autoRegister ?? true) {
-      this.register();
-    }
-  }
-
-  register(): void {
-    if (this.registered) return;
-    this.error = null;
-
-    try {
-      this.abortController = new AbortController();
-      this.handle = registerWebMcpTools({
-        client: this.client,
-        projectId: this.activeProjectId,
-        tools: this.options.tools,
-        signal: this.abortController.signal,
-        document: this.options.document,
-        navigator: this.options.navigator,
-        window: this.options.window,
-        onToolExecuted: (name, input, result) => {
-          this.options.onToolExecuted?.(name, input, result);
-        }
-      });
-      this.tools = this.handle.getRegisteredTools().map((t) => t.name);
-      this.registered = true;
-    } catch (err) {
-      this.error = err instanceof Error ? err : new Error(String(err));
-      this.registered = false;
-    }
-  }
-
-  unregister(): void {
-    if (!this.registered) return;
-    this.abortController?.abort();
-    this.handle?.unregister();
-    this.handle = null;
-    this.abortController = null;
-    this.registered = false;
-    this.tools = [];
-  }
-
-  setProjectId(projectId?: string): void {
-    if (this.activeProjectId === projectId) return;
-    this.activeProjectId = projectId;
-    if (this.registered) {
-      this.unregister();
-      this.register();
-    }
-  }
-}
-
-export function createWebMcpState(client: CriticalPathClient, options?: WebMcpStateOptions): WebMcpState {
-  return new WebMcpState(client, options);
-}