ct-gantt-core 1.0.4 → 1.0.6

package/README.md

@@ -0,0 +1,83 @@
+# ct-gantt-core
+
+框架无关的甘特图数据、布局、依赖排程和命令式引擎。该包不包含界面，可用于 Vue、React、原生 JavaScript、服务端计算或自定义渲染器。
+
+## 安装
+
+```bash
+pnpm add ct-gantt-core
+```
+
+也可以使用 `npm install ct-gantt-core` 或 `yarn add ct-gantt-core`。
+
+## 最小示例
+
+```ts
+import { GanttEngine, type GanttTask } from "ct-gantt-core"
+
+const tasks: GanttTask[] = [
+  {
+    id: "task-1",
+    name: "需求分析",
+    type: "task",
+    plan: { start: "2026-07-01", end: "2026-07-05" },
+    actual: { start: "2026-07-01", end: "2026-07-06", progress: 60 }
+  }
+]
+
+const engine = new GanttEngine({
+  tasks,
+  config: { viewMode: "day", columnWidth: 30 }
+})
+
+const layout = engine.getLayout()
+if (layout.ok) {
+  console.log(layout.data)
+}
+
+engine.setTask("task-1", { progress: 80 })
+engine.destroy()
+```
+
+## 依赖排程
+
+```ts
+import { scheduleByDependencies, type GanttLink } from "ct-gantt-core"
+
+const links: GanttLink[] = [
+  { id: "design-to-dev", sourceId: "design", targetId: "dev", type: "FS" }
+]
+
+const result = scheduleByDependencies(tasks, links)
+if (result.ok) {
+  console.log(result.data)
+}
+```
+
+支持 `FS`、`SS`、`FF`、`SF` 四种依赖类型，以及自然日或工作日间隔。
+
+## 主要导出
+
+| API | 用途 |
+| --- | --- |
+| `GanttEngine` | 管理任务、依赖、折叠、预览、布局和视口命令 |
+| `computeLayout` | 计算任务条位置和尺寸 |
+| `computeTimeScale` | 计算时间刻度（day/week/month/quarter/year） |
+| `computeHourScale` | 计算小时级时间刻度（每天 24 个小时列，顶行日期 + 底部整点小时） |
+| `computeResourceLayout` | 资源视图布局：资源行 + 占用色条（支持 day/hour 粒度与车道堆叠） |
+| `resolveUsageTimes` | 将资源占用解析为布局用起止时间（hour 粒度下纯日期占用含结束日整天） |
+| `scheduleByDependencies` | 按依赖关系调整任务日期 |
+| `computeImpact` | 分析任务变更的影响和约束冲突 |
+| `checkCyclicDependency` | 检查循环依赖 |
+| `normalizeLinks` | 统一任务内依赖与独立依赖数据 |
+| `flattenTasks` | 将阶段树转换为可渲染行 |
+| `toDate`、`toDateTime`、`addDays`、`addHours`、`diffDays`、`diffHours`、`formatDate`、`formatDateTime` | 日期工具（`toDateTime`/`diffHours` 保留时间，用于小时级计算） |
+
+## 数据说明
+
+- `plan` 表示计划日期。
+- `actual` 表示实际日期和完成进度。
+- `summary` 表示阶段，`task` 表示普通任务，`milestone` 表示任务型里程碑。
+- Core 不负责绘制界面；需要现成 Vue 界面时请安装 `ct-gantt-vue`。
+
+完整类型、配置和示例请查看[项目文档](https://github.com/moonlight-219/ganttu#readme)。

package/dist/index.cjs

@@ -22,25 +22,37 @@ var index_exports = {};
 __export(index_exports, {
   DAY_MS: () => DAY_MS,
   GanttEngine: () => GanttEngine,
+  HOUR_MS: () => HOUR_MS,
+  RESOURCE_COLOR_PALETTE: () => RESOURCE_COLOR_PALETTE,
   addDays: () => addDays,
+  addHours: () => addHours,
   checkCyclicDependency: () => checkCyclicDependency,
+  computeHourScale: () => computeHourScale,
   computeImpact: () => computeImpact,
   computeLayout: () => computeLayout,
+  computeResourceLayout: () => computeResourceLayout,
   computeTimeScale: () => computeTimeScale,
   createGanttEngine: () => createGanttEngine,
   defaultConfig: () => defaultConfig,
   diffDays: () => diffDays,
+  diffHours: () => diffHours,
   flattenTasks: () => flattenTasks,
   formatDate: () => formatDate,
+  formatDateTime: () => formatDateTime,
+  hasTimeComponent: () => hasTimeComponent,
   inclusiveDays: () => inclusiveDays,
   isValidDate: () => isValidDate,
   mergeTaskPatch: () => mergeTaskPatch,
   normalizeLinks: () => normalizeLinks,
+  resolveResourceColor: () => resolveResourceColor,
+  resolveUsageColor: () => resolveUsageColor,
+  resolveUsageTimes: () => resolveUsageTimes,
   resultInvalidDate: () => resultInvalidDate,
   scheduleByDependencies: () => scheduleByDependencies,
   shiftTask: () => shiftTask,
   startOfDay: () => startOfDay,
-  toDate: () => toDate
+  toDate: () => toDate,
+  toDateTime: () => toDateTime
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -71,6 +83,8 @@ var defaultConfig = {
     plan: "#cbd5e1",
     progress: "#0f766e"
   },
+  timeUnit: "day",
+  hourWidth: 12,
   autoSchedule: true,
   editable: true
 };
@@ -211,6 +225,7 @@ function flattenTasks(tasks, collapsedIds = /* @__PURE__ */ new Set()) {
 
 // src/utils/date.ts
 var DAY_MS = 24 * 60 * 60 * 1e3;
+var HOUR_MS = 60 * 60 * 1e3;
 function toDate(value) {
   if (value instanceof Date) {
     return startOfDay(value);
@@ -221,6 +236,21 @@ function toDate(value) {
   }
   return startOfDay(new Date(value));
 }
+function hasTimeComponent(value) {
+  return typeof value === "string" && /T\d|:\d/.test(value);
+}
+function toDateTime(value) {
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (hasTimeComponent(value)) {
+    const date = new Date(value.replace(" ", "T"));
+    if (!Number.isNaN(date.getTime())) {
+      return date;
+    }
+  }
+  return toDate(value);
+}
 function startOfDay(date) {
   return new Date(date.getFullYear(), date.getMonth(), date.getDate());
 }
@@ -232,6 +262,12 @@ function addDays(date, days) {
 function diffDays(start, end) {
   return Math.round((toDate(end).getTime() - toDate(start).getTime()) / DAY_MS);
 }
+function addHours(date, hours) {
+  return new Date(toDateTime(date).getTime() + hours * HOUR_MS);
+}
+function diffHours(start, end) {
+  return (toDateTime(end).getTime() - toDateTime(start).getTime()) / HOUR_MS;
+}
 function inclusiveDays(start, end) {
   return Math.max(0, diffDays(start, end) + 1);
 }
@@ -246,6 +282,12 @@ function formatDate(date) {
   const day = String(value.getDate()).padStart(2, "0");
   return `${year}-${month}-${day}`;
 }
+function formatDateTime(date) {
+  const value = toDateTime(date);
+  const hours = String(value.getHours()).padStart(2, "0");
+  const minutes = String(value.getMinutes()).padStart(2, "0");
+  return `${formatDate(value)} ${hours}:${minutes}`;
+}
 function resultInvalidDate(message, details) {
   return {
     ok: false,
@@ -309,6 +351,34 @@ function nextUnit(date, viewMode) {
   return addDays(date, 1);
 }
 
+// src/services/computeHourScale.ts
+function computeHourScale(start, end, hourWidth) {
+  const rangeStart = startOfDay(start);
+  const rangeEnd = startOfDay(end);
+  const totalDays = Math.max(1, inclusiveDays(rangeStart, rangeEnd));
+  const days = [];
+  const hours = [];
+  for (let d = 0; d < totalDays; d += 1) {
+    const dayStart = addDays(rangeStart, d);
+    days.push({
+      start: dayStart,
+      end: addHours(dayStart, 24),
+      left: d * 24 * hourWidth,
+      width: 24 * hourWidth
+    });
+    for (let h = 0; h < 24; h += 1) {
+      const hourStart = addHours(dayStart, h);
+      hours.push({
+        start: hourStart,
+        end: addHours(hourStart, 1),
+        left: (d * 24 + h) * hourWidth,
+        width: hourWidth
+      });
+    }
+  }
+  return { days, hours, start: rangeStart, end: rangeEnd };
+}
+
 // src/engines/scheduling.ts
 function scheduleByDependencies(tasks, links) {
   const cycle = checkCyclicDependency(links);
@@ -550,6 +620,153 @@ function computeImpact(taskId, patch, tasks, links, config) {
   return { ok: true, data: { changed, conflicts } };
 }
 
+// src/engines/computeResourceLayout.ts
+var RESOURCE_COLOR_PALETTE = ["#d85f87", "#9b63d9", "#47b987", "#d58a5f", "#4f83d8"];
+function colorHash(source) {
+  return [...source].reduce((sum, char) => sum + (char.codePointAt(0) ?? 0), 0);
+}
+function resolveResourceColor(resource, resourceColors) {
+  if (resource.color) {
+    return resource.color;
+  }
+  if (resourceColors?.[resource.id]) {
+    return resourceColors[resource.id];
+  }
+  const source = resource.name || resource.id;
+  return RESOURCE_COLOR_PALETTE[colorHash(source) % RESOURCE_COLOR_PALETTE.length];
+}
+function resolveUsageColor(usage, resource, resourceColors) {
+  return usage.color || resolveResourceColor(resource, resourceColors);
+}
+function resolveUsageTimes(usage, timeUnit) {
+  if (timeUnit === "hour") {
+    const start = toDateTime(usage.start);
+    const endRaw = toDateTime(usage.end);
+    return { start, end: hasTimeComponent(usage.end) ? endRaw : addHours(endRaw, 24) };
+  }
+  return { start: toDate(usage.start), end: toDate(usage.end) };
+}
+function computeResourceLayout(resources, usages, config, viewport) {
+  const mergedConfig = { ...defaultConfig, ...config };
+  const timeUnit = mergedConfig.timeUnit ?? "day";
+  const hourMode = timeUnit === "hour";
+  const hourW = mergedConfig.hourWidth ?? 12;
+  for (const usage of usages) {
+    const { start, end } = resolveUsageTimes(usage, timeUnit);
+    if (!isValidDate(start) || !isValidDate(end)) {
+      return {
+        ok: false,
+        error: {
+          code: "INVALID_DATE",
+          message: `Resource usage ${usage.id} has invalid dates.`
+        }
+      };
+    }
+  }
+  const orderedIds = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const resource of resources) {
+    if (!seen.has(resource.id)) {
+      seen.add(resource.id);
+      orderedIds.push(resource.id);
+    }
+  }
+  for (const usage of usages) {
+    if (!seen.has(usage.resourceId)) {
+      seen.add(usage.resourceId);
+      orderedIds.push(usage.resourceId);
+    }
+  }
+  const resourceById = new Map(resources.map((resource) => [resource.id, resource]));
+  const usagesByResource = /* @__PURE__ */ new Map();
+  for (const usage of usages) {
+    usagesByResource.set(usage.resourceId, [...usagesByResource.get(usage.resourceId) ?? [], usage]);
+  }
+  const rows = [];
+  const usageLayouts = [];
+  const laneIndexByUsage = /* @__PURE__ */ new Map();
+  orderedIds.forEach((resourceId, rowIndex) => {
+    const resource = resourceById.get(resourceId) ?? {
+      id: resourceId,
+      name: resourceId
+    };
+    const grouped = [...usagesByResource.get(resourceId) ?? []].sort((a, b) => {
+      const as = resolveUsageTimes(a, timeUnit);
+      const bs = resolveUsageTimes(b, timeUnit);
+      return as.start.getTime() - bs.start.getTime() || as.end.getTime() - bs.end.getTime();
+    });
+    const laneEnds = [];
+    for (const usage of grouped) {
+      const { start, end } = resolveUsageTimes(usage, timeUnit);
+      let laneIndex = -1;
+      for (let k = 0; k < laneEnds.length; k += 1) {
+        const laneEnd = laneEnds[k];
+        if (laneEnd === null || isLaneFree(laneEnd, start, hourMode)) {
+          laneIndex = k;
+          break;
+        }
+      }
+      if (laneIndex === -1) {
+        laneIndex = laneEnds.length;
+        laneEnds.push(null);
+      }
+      laneEnds[laneIndex] = end;
+      laneIndexByUsage.set(usage.id, laneIndex);
+    }
+    rows.push({
+      resourceId,
+      rowIndex,
+      laneCount: laneEnds.length,
+      color: resolveResourceColor(resource, mergedConfig.resourceColors),
+      usageIds: grouped.map((usage) => usage.id)
+    });
+  });
+  const usageById = new Map(usages.map((usage) => [usage.id, usage]));
+  const visibleStart = viewport ? Math.max(0, Math.floor(viewport.scrollTop / mergedConfig.rowHeight) - 8) : 0;
+  const visibleEnd = viewport ? Math.ceil((viewport.scrollTop + viewport.clientHeight) / mergedConfig.rowHeight) + 8 : Number.POSITIVE_INFINITY;
+  const firstDate = hourMode ? startOfDay(
+    mergedConfig.visibleRange ? toDateTime(mergedConfig.visibleRange.start) : usages.length ? minDate2(usages.map((usage) => resolveUsageTimes(usage, "hour").start)) : toDateTime(/* @__PURE__ */ new Date())
+  ) : mergedConfig.visibleRange ? toDate(mergedConfig.visibleRange.start) : usages.length ? minDate2(usages.map((usage) => toDate(usage.start))) : toDate(/* @__PURE__ */ new Date());
+  for (const row of rows) {
+    if (row.rowIndex < visibleStart || row.rowIndex > visibleEnd) {
+      continue;
+    }
+    const resource = resourceById.get(row.resourceId) ?? { id: row.resourceId, name: row.resourceId };
+    const laneCount = Math.max(1, row.laneCount);
+    const slot = mergedConfig.rowHeight / laneCount;
+    const barHeight = Math.max(6, Math.min(14, slot - 4));
+    for (const usageId of row.usageIds) {
+      const usage = usageById.get(usageId);
+      if (!usage) {
+        continue;
+      }
+      const { start, end } = resolveUsageTimes(usage, timeUnit);
+      const laneIndex = laneIndexByUsage.get(usageId) ?? 0;
+      const laneTop = laneIndex * slot + (slot - barHeight) / 2;
+      const left = hourMode ? diffHours(firstDate, start) * hourW : diffDays(firstDate, start) * mergedConfig.columnWidth;
+      const width = hourMode ? Math.max(hourW, diffHours(start, end) * hourW) : Math.max(mergedConfig.columnWidth, inclusiveDays(start, end) * mergedConfig.columnWidth);
+      usageLayouts.push({
+        usageId,
+        resourceId: row.resourceId,
+        rowIndex: row.rowIndex,
+        laneIndex,
+        laneCount,
+        left,
+        width,
+        top: mergedConfig.headerHeight + row.rowIndex * mergedConfig.rowHeight + laneTop,
+        height: barHeight
+      });
+    }
+  }
+  return { ok: true, data: { rows, usages: usageLayouts } };
+}
+function isLaneFree(laneEnd, start, hourMode) {
+  return hourMode ? diffHours(laneEnd, start) >= 0 : diffDays(laneEnd, start) > 0;
+}
+function minDate2(dates) {
+  return new Date(Math.min(...dates.map((date) => date.getTime())));
+}
+
 // src/engine/GanttEngine.ts
 function mergeTaskPatch(task, patch) {
   return {
@@ -920,24 +1137,36 @@ function createGanttEngine(options = {}) {
 0 && (module.exports = {
   DAY_MS,
   GanttEngine,
+  HOUR_MS,
+  RESOURCE_COLOR_PALETTE,
   addDays,
+  addHours,
   checkCyclicDependency,
+  computeHourScale,
   computeImpact,
   computeLayout,
+  computeResourceLayout,
   computeTimeScale,
   createGanttEngine,
   defaultConfig,
   diffDays,
+  diffHours,
   flattenTasks,
   formatDate,
+  formatDateTime,
+  hasTimeComponent,
   inclusiveDays,
   isValidDate,
   mergeTaskPatch,
   normalizeLinks,
+  resolveResourceColor,
+  resolveUsageColor,
+  resolveUsageTimes,
   resultInvalidDate,
   scheduleByDependencies,
   shiftTask,
   startOfDay,
-  toDate
+  toDate,
+  toDateTime
 });
 //# sourceMappingURL=index.cjs.map