@critical-path/core 0.35.0 → 0.36.1

package/src/domain/cpm.ts

@@ -1,258 +0,0 @@
-import type {
-  Task,
-  TaskDependency,
-  TaskCriticalPathSchedule,
-  CriticalPathAnalysis,
-  WorkSchedule
-} from '../types/index.js';
-import { DEFAULT_WORK_SCHEDULE, addWorkingHours, parseDate } from './calendar.js';
-
-export function getTaskDurationHours(task: Task): number {
-  if (typeof task.estimatedHours === 'number' && task.estimatedHours >= 0) {
-    return task.estimatedHours;
-  }
-  if (typeof task.estimatedDurationMinutes === 'number' && task.estimatedDurationMinutes >= 0) {
-    return task.estimatedDurationMinutes / 60;
-  }
-  if (typeof task.actualHours === 'number' && task.actualHours > 0) {
-    return task.actualHours;
-  }
-  // Default to 1 hour for non-empty tasks without explicit estimate
-  return 1;
-}
-
-export interface CPMOptions {
-  projectStartDate?: string | Date;
-  schedule?: WorkSchedule;
-}
-
-/**
- * Calculates the Critical Path Method (CPM) schedule for a set of tasks and their dependencies.
- * - Forward Pass: computes earlyStart and earlyFinish (in working hours and calendar dates)
- * - Backward Pass: computes lateStart, lateFinish, and totalSlack
- * - Respects working days, working hours, and holidays via WorkSchedule
- * - Identifies critical tasks (totalSlack === 0) that dictate the minimum project duration.
- */
-export function calculateCPM(
-  projectId: string,
-  tasks: Task[],
-  dependencies: TaskDependency[],
-  options: CPMOptions = {}
-): CriticalPathAnalysis {
-  const calculatedAt = new Date().toISOString();
-  const schedule = options.schedule || DEFAULT_WORK_SCHEDULE;
-  const projectStartDate = options.projectStartDate ? parseDate(options.projectStartDate) : undefined;
-
-  if (tasks.length === 0) {
-    return {
-      projectId,
-      calculatedAt,
-      totalDurationHours: 0,
-      totalWorkingHours: 0,
-      projectStartDate: projectStartDate ? projectStartDate.toISOString() : undefined,
-      projectEndDate: projectStartDate ? projectStartDate.toISOString() : undefined,
-      criticalTaskIds: [],
-      tasks: []
-    };
-  }
-
-  const taskMap = new Map<string, Task>(tasks.map((t) => [t.id, t]));
-  const taskIds = Array.from(taskMap.keys());
-
-  // Build adjacency graph:
-  // prerequisites[v] = tasks that v depends on (must finish before v starts)
-  // successors[u] = tasks that depend on u (can only start after u finishes)
-  const prerequisites = new Map<string, Set<string>>();
-  const successors = new Map<string, Set<string>>();
-
-  for (const id of taskIds) {
-    prerequisites.set(id, new Set<string>());
-    successors.set(id, new Set<string>());
-  }
-
-  for (const dep of dependencies) {
-    let sourceId: string | null = null;
-    let targetId: string | null = null;
-
-    if (dep.type === 'blocking') {
-      // taskId depends on dependsOnTaskId (dependsOnTaskId -> taskId)
-      sourceId = dep.dependsOnTaskId;
-      targetId = dep.taskId;
-    } else if (dep.type === 'blocked_by') {
-      // dependsOnTaskId is blocked by taskId (taskId -> dependsOnTaskId)
-      sourceId = dep.taskId;
-      targetId = dep.dependsOnTaskId;
-    }
-
-    if (sourceId && targetId && taskMap.has(sourceId) && taskMap.has(targetId) && sourceId !== targetId) {
-      prerequisites.get(targetId)!.add(sourceId);
-      successors.get(sourceId)!.add(targetId);
-    }
-  }
-
-  // Topological sorting via Kahn's algorithm
-  const inDegree = new Map<string, number>();
-  for (const id of taskIds) {
-    inDegree.set(id, prerequisites.get(id)!.size);
-  }
-
-  const queue: string[] = [];
-  for (const [id, deg] of inDegree.entries()) {
-    if (deg === 0) {
-      queue.push(id);
-    }
-  }
-
-  const topoOrder: string[] = [];
-  while (queue.length > 0) {
-    const current = queue.shift()!;
-    topoOrder.push(current);
-
-    for (const next of successors.get(current)!) {
-      const updatedDeg = inDegree.get(next)! - 1;
-      inDegree.set(next, updatedDeg);
-      if (updatedDeg === 0) {
-        queue.push(next);
-      }
-    }
-  }
-
-  // If there's a cycle or disconnected nodes not processed in topoOrder, append them
-  if (topoOrder.length < taskIds.length) {
-    for (const id of taskIds) {
-      if (!topoOrder.includes(id)) {
-        topoOrder.push(id);
-      }
-    }
-  }
-
-  // --- FORWARD PASS ---
-  const earlyStart = new Map<string, number>();
-  const earlyFinish = new Map<string, number>();
-
-  for (const id of topoOrder) {
-    const task = taskMap.get(id)!;
-    const duration = getTaskDurationHours(task);
-    const prereqs = prerequisites.get(id) || new Set();
-
-    let maxPrereqFinish = 0;
-    for (const p of prereqs) {
-      const pFinish = earlyFinish.get(p) ?? 0;
-      if (pFinish > maxPrereqFinish) {
-        maxPrereqFinish = pFinish;
-      }
-    }
-
-    const es = maxPrereqFinish;
-    const ef = es + duration;
-
-    earlyStart.set(id, es);
-    earlyFinish.set(id, ef);
-  }
-
-  // Total project duration
-  let totalDurationHours = 0;
-  for (const ef of earlyFinish.values()) {
-    if (ef > totalDurationHours) {
-      totalDurationHours = ef;
-    }
-  }
-
-  // --- BACKWARD PASS ---
-  const lateStart = new Map<string, number>();
-  const lateFinish = new Map<string, number>();
-
-  // Process in reverse topological order
-  for (let i = topoOrder.length - 1; i >= 0; i--) {
-    const id = topoOrder[i];
-    const task = taskMap.get(id)!;
-    const duration = getTaskDurationHours(task);
-    const succs = successors.get(id) || new Set();
-
-    let minSuccLateStart = totalDurationHours;
-    if (succs.size > 0) {
-      minSuccLateStart = Infinity;
-      for (const s of succs) {
-        const sLateStart = lateStart.get(s);
-        if (sLateStart !== undefined && sLateStart < minSuccLateStart) {
-          minSuccLateStart = sLateStart;
-        }
-      }
-      if (!Number.isFinite(minSuccLateStart)) {
-        minSuccLateStart = totalDurationHours;
-      }
-    }
-
-    const lf = minSuccLateStart;
-    const ls = lf - duration;
-
-    lateFinish.set(id, lf);
-    lateStart.set(id, ls);
-  }
-
-  // --- SLACK & CRITICAL PATH ---
-  const schedules: TaskCriticalPathSchedule[] = [];
-  const criticalTaskIds: string[] = [];
-
-  for (const id of taskIds) {
-    const es = earlyStart.get(id) ?? 0;
-    const ef = earlyFinish.get(id) ?? 0;
-    const ls = lateStart.get(id) ?? 0;
-    const lf = lateFinish.get(id) ?? 0;
-
-    const rawSlack = lf - ef;
-    const totalSlack = Math.round(rawSlack * 100) / 100;
-    const isCritical = totalSlack <= 0.001;
-
-    if (isCritical) {
-      criticalTaskIds.push(id);
-    }
-
-    const task = taskMap.get(id)!;
-    const duration = getTaskDurationHours(task);
-
-    const earlyStartDate = projectStartDate
-      ? addWorkingHours(projectStartDate, es, schedule).toISOString()
-      : undefined;
-    const earlyFinishDate = projectStartDate
-      ? addWorkingHours(projectStartDate, ef, schedule).toISOString()
-      : undefined;
-    const lateStartDate = projectStartDate
-      ? addWorkingHours(projectStartDate, ls, schedule).toISOString()
-      : undefined;
-    const lateFinishDate = projectStartDate
-      ? addWorkingHours(projectStartDate, lf, schedule).toISOString()
-      : undefined;
-
-    schedules.push({
-      taskId: id,
-      earlyStart: Math.round(es * 100) / 100,
-      earlyFinish: Math.round(ef * 100) / 100,
-      lateStart: Math.round(ls * 100) / 100,
-      lateFinish: Math.round(lf * 100) / 100,
-      totalSlack,
-      isCritical,
-      durationHours: duration,
-      slackWorkingHours: totalSlack,
-      earlyStartDate,
-      earlyFinishDate,
-      lateStartDate,
-      lateFinishDate
-    });
-  }
-
-  const projectEndDate = projectStartDate
-    ? addWorkingHours(projectStartDate, totalDurationHours, schedule).toISOString()
-    : undefined;
-
-  return {
-    projectId,
-    calculatedAt,
-    totalDurationHours: Math.round(totalDurationHours * 100) / 100,
-    totalWorkingHours: Math.round(totalDurationHours * 100) / 100,
-    projectStartDate: projectStartDate ? projectStartDate.toISOString() : undefined,
-    projectEndDate,
-    criticalTaskIds,
-    tasks: schedules
-  };
-}

package/src/domain/custom-fields.ts

@@ -1,172 +0,0 @@
-import type { CustomFieldDefinition, CustomFieldType } from '../types/index.js';
-import { BUILT_IN_CUSTOM_FIELD_TYPES } from '../plugins/index.js';
-
-export class CustomFieldValidationError extends Error {
-  public readonly fieldKey: string;
-  public readonly expectedType?: string;
-  public readonly receivedValue?: unknown;
-
-  constructor(message: string, fieldKey: string, expectedType?: string, receivedValue?: unknown) {
-    super(message);
-    this.name = 'CustomFieldValidationError';
-    this.fieldKey = fieldKey;
-    this.expectedType = expectedType;
-    this.receivedValue = receivedValue;
-  }
-}
-
-export function validateCustomFieldValues(
-  definitions: CustomFieldDefinition[] | undefined,
-  values: Record<string, unknown> | undefined,
-  customTypes?: ReadonlyMap<string, CustomFieldType>
-): void {
-  if (!definitions || definitions.length === 0) return;
-  const customValues = values || {};
-
-  for (const def of definitions) {
-    const value = customValues[def.key];
-
-    // Check required invariant
-    if (def.required && (value === undefined || value === null || value === '')) {
-      throw new CustomFieldValidationError(
-        `Custom field "${def.label || def.key}" (${def.key}) is required.`,
-        def.key,
-        def.type,
-        value
-      );
-    }
-
-    if (value === undefined || value === null) {
-      continue;
-    }
-
-    // Type and schema validation
-    switch (def.type) {
-      case 'number':
-        if (typeof value !== 'number' || isNaN(value)) {
-          throw new CustomFieldValidationError(
-            `Custom field "${def.label || def.key}" must be a valid number. Received: ${typeof value}`,
-            def.key,
-            'number',
-            value
-          );
-        }
-        break;
-
-      case 'text':
-      case 'user':
-        if (typeof value !== 'string') {
-          throw new CustomFieldValidationError(
-            `Custom field "${def.label || def.key}" must be a string. Received: ${typeof value}`,
-            def.key,
-            def.type,
-            value
-          );
-        }
-        break;
-
-      case 'boolean':
-        if (typeof value !== 'boolean') {
-          throw new CustomFieldValidationError(
-            `Custom field "${def.label || def.key}" must be a boolean. Received: ${typeof value}`,
-            def.key,
-            'boolean',
-            value
-          );
-        }
-        break;
-
-      case 'date':
-        if (typeof value !== 'string' || isNaN(new Date(value).getTime())) {
-          throw new CustomFieldValidationError(
-            `Custom field "${def.label || def.key}" must be a valid ISO date string. Received: ${JSON.stringify(value)}`,
-            def.key,
-            'date',
-            value
-          );
-        }
-        break;
-
-      case 'single_select':
-        if (typeof value !== 'string') {
-          throw new CustomFieldValidationError(
-            `Custom field "${def.label || def.key}" must be a string option. Received: ${typeof value}`,
-            def.key,
-            'single_select',
-            value
-          );
-        }
-        if (def.options && def.options.length > 0 && !def.options.includes(value)) {
-          throw new CustomFieldValidationError(
-            `Custom field "${def.label || def.key}" value "${value}" is not an allowed option [${def.options.join(', ')}].`,
-            def.key,
-            'single_select',
-            value
-          );
-        }
-        break;
-
-      case 'multi_select':
-        if (!Array.isArray(value)) {
-          throw new CustomFieldValidationError(
-            `Custom field "${def.label || def.key}" must be an array of string options. Received: ${typeof value}`,
-            def.key,
-            'multi_select',
-            value
-          );
-        }
-        if (def.options && def.options.length > 0) {
-          for (const item of value) {
-            if (typeof item !== 'string' || !def.options.includes(item)) {
-              throw new CustomFieldValidationError(
-                `Custom field "${def.label || def.key}" option "${item}" is not allowed in [${def.options.join(', ')}].`,
-                def.key,
-                'multi_select',
-                item
-              );
-            }
-          }
-        }
-        break;
-      default: {
-        const custom = customTypes?.get(def.type);
-        if (!custom) {
-          throw new CustomFieldValidationError(
-            `Custom field "${def.label || def.key}" has unknown type "${def.type}". Register it with a plugin's customFieldTypes.`,
-            def.key,
-            def.type,
-            value
-          );
-        }
-        const problem = custom.validate(value, def);
-        if (problem) {
-          throw new CustomFieldValidationError(
-            `Custom field "${def.label || def.key}" ${problem}`,
-            def.key,
-            def.type,
-            value
-          );
-        }
-      }
-    }
-  }
-}
-
-/**
- * Checks that every definition uses a built-in type or one registered by a plugin, so projects
- * cannot be configured with fields that would reject every value.
- */
-export function validateCustomFieldDefinitions(
-  definitions: CustomFieldDefinition[] | undefined,
-  customTypes?: ReadonlyMap<string, CustomFieldType>
-): void {
-  for (const def of definitions ?? []) {
-    if (!(BUILT_IN_CUSTOM_FIELD_TYPES as readonly string[]).includes(def.type) && !customTypes?.has(def.type)) {
-      throw new CustomFieldValidationError(
-        `Custom field "${def.label || def.key}" has unknown type "${def.type}". Register it with a plugin's customFieldTypes.`,
-        def.key,
-        def.type
-      );
-    }
-  }
-}