@nocobase/plugin-gantt 2.1.0-beta.36 → 2.1.0-beta.38

package/dist/shared/helpers/bar-helper.js

@@ -0,0 +1,415 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bar_helper_exports = {};
+__export(bar_helper_exports, {
+  convertToBarTasks: () => convertToBarTasks,
+  getProgressPoint: () => getProgressPoint,
+  handleTaskBySVGMouseEvent: () => handleTaskBySVGMouseEvent,
+  progressByProgressWidth: () => progressByProgressWidth,
+  progressWithByParams: () => progressWithByParams
+});
+module.exports = __toCommonJS(bar_helper_exports);
+const convertToBarTasks = (tasks, dates, columnWidth, rowHeight, taskHeight, barCornerRadius, handleWidth, rtl, barProgressColor, barProgressSelectedColor, barBackgroundColor, barBackgroundSelectedColor, projectProgressColor, projectProgressSelectedColor, projectBackgroundColor, projectBackgroundSelectedColor, milestoneBackgroundColor, milestoneBackgroundSelectedColor) => {
+  let barTasks = tasks.map((t, i) => {
+    return convertToBarTask(
+      t,
+      i,
+      dates,
+      columnWidth,
+      rowHeight,
+      taskHeight,
+      barCornerRadius,
+      handleWidth,
+      rtl,
+      barProgressColor,
+      barProgressSelectedColor,
+      barBackgroundColor,
+      barBackgroundSelectedColor,
+      projectProgressColor,
+      projectProgressSelectedColor,
+      projectBackgroundColor,
+      projectBackgroundSelectedColor,
+      milestoneBackgroundColor,
+      milestoneBackgroundSelectedColor
+    );
+  });
+  barTasks = barTasks.map((task) => {
+    const dependencies = task.dependencies || [];
+    for (let j = 0; j < dependencies.length; j++) {
+      const dependence = barTasks.findIndex((value) => value.id === dependencies[j]);
+      if (dependence !== -1) barTasks[dependence].barChildren.push(task);
+    }
+    return task;
+  });
+  return barTasks;
+};
+const convertToBarTask = (task, index, dates, columnWidth, rowHeight, taskHeight, barCornerRadius, handleWidth, rtl, barProgressColor, barProgressSelectedColor, barBackgroundColor, barBackgroundSelectedColor, projectProgressColor, projectProgressSelectedColor, projectBackgroundColor, projectBackgroundSelectedColor, milestoneBackgroundColor, milestoneBackgroundSelectedColor) => {
+  let barTask;
+  switch (task.type) {
+    case "milestone":
+      barTask = convertToMilestone(
+        task,
+        index,
+        dates,
+        columnWidth,
+        rowHeight,
+        taskHeight,
+        barCornerRadius,
+        handleWidth,
+        milestoneBackgroundColor,
+        milestoneBackgroundSelectedColor
+      );
+      break;
+    case "project":
+      barTask = convertToBar(
+        task,
+        index,
+        dates,
+        columnWidth,
+        rowHeight,
+        taskHeight * 0.5,
+        barCornerRadius,
+        handleWidth,
+        rtl,
+        projectProgressColor,
+        projectProgressSelectedColor,
+        projectBackgroundColor,
+        projectBackgroundSelectedColor
+      );
+      break;
+    default:
+      barTask = convertToBar(
+        task,
+        index,
+        dates,
+        columnWidth,
+        rowHeight,
+        taskHeight,
+        barCornerRadius,
+        handleWidth,
+        rtl,
+        barProgressColor,
+        barProgressSelectedColor,
+        barBackgroundColor,
+        barBackgroundSelectedColor
+      );
+      break;
+  }
+  return barTask;
+};
+const convertToBar = (task, index, dates, columnWidth, rowHeight, taskHeight, barCornerRadius, handleWidth, rtl, barProgressColor, barProgressSelectedColor, barBackgroundColor, barBackgroundSelectedColor) => {
+  let x1;
+  let x2;
+  if (rtl) {
+    x2 = taskXCoordinateRTL(task.start, dates, columnWidth);
+    x1 = taskXCoordinateRTL(task.end, dates, columnWidth);
+  } else {
+    x1 = taskXCoordinate(task.start, dates, columnWidth);
+    x2 = taskXCoordinate(task.end, dates, columnWidth);
+  }
+  let typeInternal = task.type;
+  if (typeInternal === "task" && x2 - x1 < handleWidth * 2) {
+    typeInternal = "smalltask";
+    x2 = x1 > 0 ? x1 + handleWidth * 2 : x1;
+  }
+  const [progressWidth, progressX] = progressWithByParams(x1, x2, task.progress, rtl);
+  const y = task.type === "project" ? taskYCoordinate(index, rowHeight, taskHeight) + 8 : taskYCoordinate(index, rowHeight, taskHeight);
+  const hideChildren = task.type === "project" ? task.hideChildren : void 0;
+  const styles = {
+    backgroundColor: barBackgroundColor,
+    backgroundSelectedColor: barBackgroundSelectedColor,
+    progressColor: barProgressColor,
+    progressSelectedColor: barProgressSelectedColor,
+    ...task.styles
+  };
+  return {
+    ...task,
+    typeInternal,
+    x1,
+    x2,
+    y,
+    index,
+    progressX,
+    progressWidth,
+    barCornerRadius,
+    handleWidth,
+    hideChildren,
+    height: taskHeight,
+    barChildren: [],
+    styles
+  };
+};
+const convertToMilestone = (task, index, dates, columnWidth, rowHeight, taskHeight, barCornerRadius, handleWidth, milestoneBackgroundColor, milestoneBackgroundSelectedColor) => {
+  const x = taskXCoordinate(task.start, dates, columnWidth);
+  const y = taskYCoordinate(index, rowHeight, taskHeight);
+  const x1 = x - taskHeight * 0.5;
+  const x2 = x + taskHeight * 0.5;
+  const rotatedHeight = taskHeight / 1.414;
+  const styles = {
+    backgroundColor: milestoneBackgroundColor,
+    backgroundSelectedColor: milestoneBackgroundSelectedColor,
+    progressColor: "",
+    progressSelectedColor: "",
+    ...task.styles
+  };
+  return {
+    ...task,
+    end: task.start,
+    x1,
+    x2,
+    y,
+    index,
+    progressX: 0,
+    progressWidth: 0,
+    barCornerRadius,
+    handleWidth,
+    typeInternal: task.type,
+    progress: 0,
+    height: rotatedHeight,
+    hideChildren: void 0,
+    barChildren: [],
+    styles
+  };
+};
+const taskXCoordinate = (xDate, dates, columnWidth) => {
+  var _a, _b, _c;
+  const index = dates.findIndex((d) => (d == null ? void 0 : d.getTime()) >= (xDate == null ? void 0 : xDate.getTime())) - 1;
+  const remainderMillis = (xDate == null ? void 0 : xDate.getTime()) - ((_a = dates[index]) == null ? void 0 : _a.getTime());
+  const percentOfInterval = remainderMillis / (((_b = dates[index + 1]) == null ? void 0 : _b.getTime()) - ((_c = dates[index]) == null ? void 0 : _c.getTime()));
+  const x = index * columnWidth + percentOfInterval * columnWidth;
+  return isNaN(x) ? 0 : x;
+};
+const taskXCoordinateRTL = (xDate, dates, columnWidth) => {
+  let x = taskXCoordinate(xDate, dates, columnWidth);
+  x += columnWidth;
+  return isNaN(x) ? 0 : x;
+};
+const taskYCoordinate = (index, rowHeight, taskHeight) => {
+  const y = index * rowHeight + (rowHeight - taskHeight) / 2;
+  return isNaN(y) ? 0 : y;
+};
+const progressWithByParams = (taskX1, taskX2, progress, rtl) => {
+  const progressWidth = (taskX2 - taskX1) * progress * 0.01;
+  let progressX;
+  if (rtl) {
+    progressX = taskX2 - progressWidth;
+  } else {
+    progressX = taskX1;
+  }
+  return [progressWidth, progressX];
+};
+const progressByProgressWidth = (progressWidth, barTask) => {
+  const barWidth = barTask.x2 - barTask.x1;
+  const progressPercent = Math.round(progressWidth * 100 / barWidth);
+  if (progressPercent >= 100) return 100;
+  else if (progressPercent <= 0) return 0;
+  else return progressPercent;
+};
+const progressByX = (x, task) => {
+  if (x >= task.x2) return 100;
+  else if (x <= task.x1) return 0;
+  else {
+    const barWidth = task.x2 - task.x1;
+    const progressPercent = Math.round((x - task.x1) * 100 / barWidth);
+    return progressPercent;
+  }
+};
+const progressByXRTL = (x, task) => {
+  if (x >= task.x2) return 0;
+  else if (x <= task.x1) return 100;
+  else {
+    const barWidth = task.x2 - task.x1;
+    const progressPercent = Math.round((task.x2 - x) * 100 / barWidth);
+    return progressPercent;
+  }
+};
+const getProgressPoint = (progressX, taskY, taskHeight) => {
+  const point = [
+    progressX - 5,
+    taskY + taskHeight,
+    progressX + 5,
+    taskY + taskHeight,
+    progressX,
+    taskY + taskHeight - 8.66
+  ];
+  return point.join(",");
+};
+const startByX = (x, xStep, task) => {
+  if (x >= task.x2 - task.handleWidth * 2) {
+    x = task.x2 - task.handleWidth * 2;
+  }
+  const steps = Math.round((x - task.x1) / xStep);
+  const additionalXValue = steps * xStep;
+  const newX = task.x1 + additionalXValue;
+  return newX;
+};
+const endByX = (x, xStep, task) => {
+  if (x <= task.x1 + task.handleWidth * 2) {
+    x = task.x1 + task.handleWidth * 2;
+  }
+  const steps = Math.round((x - task.x2) / xStep);
+  const additionalXValue = steps * xStep;
+  const newX = task.x2 + additionalXValue;
+  return newX;
+};
+const moveByX = (x, xStep, task) => {
+  const steps = Math.round((x - task.x1) / xStep);
+  const additionalXValue = steps * xStep;
+  const newX1 = task.x1 + additionalXValue;
+  const newX2 = newX1 + task.x2 - task.x1;
+  return [newX1, newX2];
+};
+const dateByX = (x, taskX, taskDate, xStep, timeStep) => {
+  var _a, _b;
+  let newDate = new Date((x - taskX) / xStep * timeStep + ((_a = taskDate == null ? void 0 : taskDate.getTime) == null ? void 0 : _a.call(taskDate)));
+  newDate = new Date(((_b = newDate == null ? void 0 : newDate.getTime) == null ? void 0 : _b.call(newDate)) + ((newDate == null ? void 0 : newDate.getTimezoneOffset()) - (taskDate == null ? void 0 : taskDate.getTimezoneOffset())) * 6e4);
+  return newDate;
+};
+const handleTaskBySVGMouseEvent = (svgX, action, selectedTask, xStep, timeStep, initEventX1Delta, rtl) => {
+  let result;
+  switch (selectedTask.type) {
+    case "milestone":
+      result = handleTaskBySVGMouseEventForMilestone(svgX, action, selectedTask, xStep, timeStep, initEventX1Delta);
+      break;
+    default:
+      result = handleTaskBySVGMouseEventForBar(svgX, action, selectedTask, xStep, timeStep, initEventX1Delta, rtl);
+      break;
+  }
+  return result;
+};
+const handleTaskBySVGMouseEventForBar = (svgX, action, selectedTask, xStep, timeStep, initEventX1Delta, rtl) => {
+  const changedTask = { ...selectedTask };
+  let isChanged = false;
+  switch (action) {
+    case "progress":
+      if (rtl) {
+        changedTask.progress = progressByXRTL(svgX, selectedTask);
+      } else {
+        changedTask.progress = progressByX(svgX, selectedTask);
+      }
+      isChanged = changedTask.progress !== selectedTask.progress;
+      if (isChanged) {
+        const [progressWidth, progressX] = progressWithByParams(
+          changedTask.x1,
+          changedTask.x2,
+          changedTask.progress,
+          rtl
+        );
+        changedTask.progressWidth = progressWidth;
+        changedTask.progressX = progressX;
+      }
+      break;
+    case "start": {
+      const newX1 = startByX(svgX, xStep, selectedTask);
+      changedTask.x1 = newX1;
+      isChanged = changedTask.x1 !== selectedTask.x1;
+      if (isChanged) {
+        if (rtl) {
+          changedTask.end = dateByX(newX1, selectedTask.x1, selectedTask.end, xStep, timeStep);
+        } else {
+          changedTask.start = dateByX(newX1, selectedTask.x1, selectedTask.start, xStep, timeStep);
+        }
+        const [progressWidth, progressX] = progressWithByParams(
+          changedTask.x1,
+          changedTask.x2,
+          changedTask.progress,
+          rtl
+        );
+        changedTask.progressWidth = progressWidth;
+        changedTask.progressX = progressX;
+      }
+      break;
+    }
+    case "end": {
+      const newX2 = endByX(svgX, xStep, selectedTask);
+      changedTask.x2 = newX2;
+      isChanged = changedTask.x2 !== selectedTask.x2;
+      if (isChanged) {
+        if (rtl) {
+          changedTask.start = dateByX(newX2, selectedTask.x2, selectedTask.start, xStep, timeStep);
+        } else {
+          changedTask.end = dateByX(newX2, selectedTask.x2, selectedTask.end, xStep, timeStep);
+        }
+        const [progressWidth, progressX] = progressWithByParams(
+          changedTask.x1,
+          changedTask.x2,
+          changedTask.progress,
+          rtl
+        );
+        changedTask.progressWidth = progressWidth;
+        changedTask.progressX = progressX;
+      }
+      break;
+    }
+    case "move": {
+      const [newMoveX1, newMoveX2] = moveByX(svgX - initEventX1Delta, xStep, selectedTask);
+      isChanged = newMoveX1 !== selectedTask.x1;
+      if (isChanged) {
+        changedTask.start = dateByX(newMoveX1, selectedTask.x1, selectedTask.start, xStep, timeStep);
+        changedTask.end = dateByX(newMoveX2, selectedTask.x2, selectedTask.end, xStep, timeStep);
+        changedTask.x1 = newMoveX1;
+        changedTask.x2 = newMoveX2;
+        const [progressWidth, progressX] = progressWithByParams(
+          changedTask.x1,
+          changedTask.x2,
+          changedTask.progress,
+          rtl
+        );
+        changedTask.progressWidth = progressWidth;
+        changedTask.progressX = progressX;
+      }
+      break;
+    }
+  }
+  return { isChanged, changedTask };
+};
+const handleTaskBySVGMouseEventForMilestone = (svgX, action, selectedTask, xStep, timeStep, initEventX1Delta) => {
+  const changedTask = { ...selectedTask };
+  let isChanged = false;
+  switch (action) {
+    case "move": {
+      const [newMoveX1, newMoveX2] = moveByX(svgX - initEventX1Delta, xStep, selectedTask);
+      isChanged = newMoveX1 !== selectedTask.x1;
+      if (isChanged) {
+        changedTask.start = dateByX(newMoveX1, selectedTask.x1, selectedTask.start, xStep, timeStep);
+        changedTask.end = changedTask.start;
+        changedTask.x1 = newMoveX1;
+        changedTask.x2 = newMoveX2;
+      }
+      break;
+    }
+  }
+  return { isChanged, changedTask };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertToBarTasks,
+  getProgressPoint,
+  handleTaskBySVGMouseEvent,
+  progressByProgressWidth,
+  progressWithByParams
+});

package/dist/shared/helpers/date-helper.d.ts

@@ -0,0 +1,27 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Task, ViewMode } from '../types/public-types';
+declare const DateTimeFormat: {
+    (locales?: string | string[], options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
+    new (locales?: string | string[], options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
+    supportedLocalesOf(locales: string | string[], options?: Intl.DateTimeFormatOptions): string[];
+    readonly prototype: Intl.DateTimeFormat;
+};
+type DateTimeFormat = typeof DateTimeFormat;
+type DateHelperScales = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
+export declare const getCachedDateTimeFormat: (locString: string | string[], opts?: any) => DateTimeFormat;
+export declare const addToDate: (date: Date, quantity: number, scale: DateHelperScales) => Date;
+export declare const startOfDate: (date: Date, scale: DateHelperScales) => Date;
+export declare const ganttDateRange: (tasks: Task[], viewMode: ViewMode, preStepsCount: number) => Date[];
+export declare const seedDates: (startDate: Date, endDate: Date, viewMode: ViewMode) => Date[];
+export declare const getLocaleMonth: (date: Date, locale: string) => any;
+export declare const getLocalDayOfWeek: (date: Date, locale: string, format?: 'long' | 'short' | 'narrow' | undefined) => any;
+export declare const getWeekNumberISO8601: (date: Date) => string;
+export declare const getDaysInMonth: (month: number, year: number) => number;
+export {};

package/dist/shared/helpers/date-helper.js

@@ -0,0 +1,231 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var date_helper_exports = {};
+__export(date_helper_exports, {
+  addToDate: () => addToDate,
+  ganttDateRange: () => ganttDateRange,
+  getCachedDateTimeFormat: () => getCachedDateTimeFormat,
+  getDaysInMonth: () => getDaysInMonth,
+  getLocalDayOfWeek: () => getLocalDayOfWeek,
+  getLocaleMonth: () => getLocaleMonth,
+  getWeekNumberISO8601: () => getWeekNumberISO8601,
+  seedDates: () => seedDates,
+  startOfDate: () => startOfDate
+});
+module.exports = __toCommonJS(date_helper_exports);
+var import_public_types = require("../types/public-types");
+const DateTimeFormat = Intl.DateTimeFormat;
+const DateTimeFormatOptions = Intl.DateTimeFormatOptions;
+const intlDTCache = {};
+const getCachedDateTimeFormat = (locString, opts = {}) => {
+  const key = JSON.stringify([locString, opts]);
+  let dtf = intlDTCache[key];
+  if (!dtf) {
+    dtf = new Intl.DateTimeFormat(locString, opts);
+    intlDTCache[key] = dtf;
+  }
+  return dtf;
+};
+const addToDate = (date, quantity, scale) => {
+  const newDate = new Date(
+    date.getFullYear() + (scale === "year" ? quantity : 0),
+    date.getMonth() + (scale === "month" ? quantity : 0),
+    date.getDate() + (scale === "day" ? quantity : 0),
+    date.getHours() + (scale === "hour" ? quantity : 0),
+    date.getMinutes() + (scale === "minute" ? quantity : 0),
+    date.getSeconds() + (scale === "second" ? quantity : 0),
+    date.getMilliseconds() + (scale === "millisecond" ? quantity : 0)
+  );
+  return newDate;
+};
+const startOfDate = (date, scale) => {
+  const scores = ["millisecond", "second", "minute", "hour", "day", "month", "year"];
+  const shouldReset = (_scale) => {
+    const maxScore = scores.indexOf(scale);
+    return scores.indexOf(_scale) <= maxScore;
+  };
+  const newDate = new Date(
+    date == null ? void 0 : date.getFullYear(),
+    shouldReset("year") ? 0 : date.getMonth(),
+    shouldReset("month") ? 1 : date.getDate(),
+    shouldReset("day") ? 0 : date.getHours(),
+    shouldReset("hour") ? 0 : date.getMinutes(),
+    shouldReset("minute") ? 0 : date.getSeconds(),
+    shouldReset("second") ? 0 : date.getMilliseconds()
+  );
+  return newDate;
+};
+const ganttDateRange = (tasks, viewMode, preStepsCount) => {
+  var _a, _b;
+  let newStartDate = ((_a = tasks[0]) == null ? void 0 : _a.start) || /* @__PURE__ */ new Date();
+  let newEndDate = ((_b = tasks[0]) == null ? void 0 : _b.start) || /* @__PURE__ */ new Date();
+  for (const task of tasks) {
+    if (task.start < newStartDate) {
+      newStartDate = task.start;
+    }
+    if (task.end > newEndDate) {
+      newEndDate = task.end;
+    }
+  }
+  switch (viewMode) {
+    case import_public_types.ViewMode.Year:
+      newStartDate = addToDate(newStartDate, -1, "year");
+      newStartDate = startOfDate(newStartDate, "year");
+      newEndDate = addToDate(newEndDate, 1, "year");
+      newEndDate = startOfDate(newEndDate, "year");
+      break;
+    case import_public_types.ViewMode.QuarterYear:
+      newStartDate = addToDate(newStartDate, -3, "month");
+      newStartDate = startOfDate(newStartDate, "month");
+      newEndDate = addToDate(newEndDate, 3, "year");
+      newEndDate = startOfDate(newEndDate, "year");
+      break;
+    case import_public_types.ViewMode.Month:
+      newStartDate = addToDate(newStartDate, -1 * preStepsCount, "month");
+      newStartDate = startOfDate(newStartDate, "month");
+      newEndDate = addToDate(newEndDate, 1, "year");
+      newEndDate = startOfDate(newEndDate, "year");
+      break;
+    case import_public_types.ViewMode.Week:
+      newStartDate = startOfDate(newStartDate, "day");
+      newStartDate = addToDate(getMonday(newStartDate), -7 * preStepsCount, "day");
+      newEndDate = startOfDate(newEndDate, "day");
+      newEndDate = addToDate(newEndDate, 1.5, "month");
+      break;
+    case import_public_types.ViewMode.Day:
+      newStartDate = startOfDate(newStartDate, "day");
+      newStartDate = addToDate(newStartDate, -1 * preStepsCount, "day");
+      newEndDate = startOfDate(newEndDate, "day");
+      newEndDate = addToDate(newEndDate, 19, "day");
+      break;
+    case import_public_types.ViewMode.QuarterDay:
+      newStartDate = startOfDate(newStartDate, "day");
+      newStartDate = addToDate(newStartDate, -1 * preStepsCount, "day");
+      newEndDate = startOfDate(newEndDate, "day");
+      newEndDate = addToDate(newEndDate, 66, "hour");
+      break;
+    case import_public_types.ViewMode.HalfDay:
+      newStartDate = startOfDate(newStartDate, "day");
+      newStartDate = addToDate(newStartDate, -1 * preStepsCount, "day");
+      newEndDate = startOfDate(newEndDate, "day");
+      newEndDate = addToDate(newEndDate, 108, "hour");
+      break;
+    case import_public_types.ViewMode.Hour:
+      newStartDate = startOfDate(newStartDate, "hour");
+      newStartDate = addToDate(newStartDate, -1 * preStepsCount, "hour");
+      newEndDate = startOfDate(newEndDate, "day");
+      newEndDate = addToDate(newEndDate, 1, "day");
+      break;
+  }
+  return [newStartDate, newEndDate];
+};
+const seedDates = (startDate, endDate, viewMode) => {
+  let currentDate = new Date(startDate);
+  const dates = [currentDate];
+  while (currentDate < endDate) {
+    switch (viewMode) {
+      case import_public_types.ViewMode.Year:
+        currentDate = addToDate(currentDate, 1, "year");
+        break;
+      case import_public_types.ViewMode.QuarterYear:
+        currentDate = addToDate(currentDate, 3, "month");
+        break;
+      case import_public_types.ViewMode.Month:
+        currentDate = addToDate(currentDate, 1, "month");
+        break;
+      case import_public_types.ViewMode.Week:
+        currentDate = addToDate(currentDate, 7, "day");
+        break;
+      case import_public_types.ViewMode.Day:
+        currentDate = addToDate(currentDate, 1, "day");
+        break;
+      case import_public_types.ViewMode.HalfDay:
+        currentDate = addToDate(currentDate, 12, "hour");
+        break;
+      case import_public_types.ViewMode.QuarterDay:
+        currentDate = addToDate(currentDate, 6, "hour");
+        break;
+      case import_public_types.ViewMode.Hour:
+        currentDate = addToDate(currentDate, 1, "hour");
+        break;
+    }
+    dates.push(currentDate);
+  }
+  return dates;
+};
+const getLocaleMonth = (date, locale) => {
+  let bottomValue = getCachedDateTimeFormat(locale, {
+    month: "long"
+    //@ts-ignore
+  }).format(date);
+  bottomValue = bottomValue.replace(bottomValue[0], bottomValue[0].toLocaleUpperCase());
+  return bottomValue;
+};
+const getLocalDayOfWeek = (date, locale, format) => {
+  let bottomValue = getCachedDateTimeFormat(locale, {
+    weekday: format
+    //@ts-ignore
+  }).format(date);
+  bottomValue = bottomValue.replace(bottomValue[0], bottomValue[0].toLocaleUpperCase());
+  return bottomValue;
+};
+const getMonday = (date) => {
+  const day = date.getDay();
+  const diff = date.getDate() - day + (day === 0 ? -6 : 1);
+  return new Date(date.setDate(diff));
+};
+const getWeekNumberISO8601 = (date) => {
+  const tmpDate = new Date(date.valueOf());
+  const dayNumber = (tmpDate.getDay() + 6) % 7;
+  tmpDate.setDate(tmpDate.getDate() - dayNumber + 3);
+  const firstThursday = tmpDate.valueOf();
+  tmpDate.setMonth(0, 1);
+  if (tmpDate.getDay() !== 4) {
+    tmpDate.setMonth(0, 1 + (4 - tmpDate.getDay() + 7) % 7);
+  }
+  const weekNumber = (1 + Math.ceil((firstThursday - tmpDate.valueOf()) / 6048e5)).toString();
+  if (weekNumber.length === 1) {
+    return `0${weekNumber}`;
+  } else {
+    return weekNumber;
+  }
+};
+const getDaysInMonth = (month, year) => {
+  return new Date(year, month + 1, 0).getDate();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addToDate,
+  ganttDateRange,
+  getCachedDateTimeFormat,
+  getDaysInMonth,
+  getLocalDayOfWeek,
+  getLocaleMonth,
+  getWeekNumberISO8601,
+  seedDates,
+  startOfDate
+});

package/dist/shared/helpers/other-helper.d.ts

@@ -0,0 +1,17 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+/// <reference types="react" />
+import { BarTask } from '../types/bar-task';
+import { Task } from '../types/public-types';
+export declare function isKeyboardEvent(event: React.MouseEvent | React.KeyboardEvent | React.FocusEvent): event is React.KeyboardEvent;
+export declare function isMouseEvent(event: React.MouseEvent | React.KeyboardEvent | React.FocusEvent): event is React.MouseEvent;
+export declare function isBarTask(task: Task | BarTask): task is BarTask;
+export declare function removeHiddenTasks(tasks: Task[]): Task[];
+export declare const sortTasks: (taskA: Task, taskB: Task) => 0 | 1 | -1;
+export declare const getYmd: (date: Date) => string | 0;