@tuturuuu/utils 0.0.2 → 0.6.0

package/src/date-helper.ts

@@ -0,0 +1,313 @@
+import moment from 'moment';
+
+export function timetzToTime(timetz: string) {
+  // Find the position of the '+' or '-' that indicates the start of the offset
+  const offsetPos = Math.max(timetz.lastIndexOf('+'), timetz.lastIndexOf('-'));
+
+  // Split the input string into the time and offset parts
+  const time = timetz.substring(0, offsetPos);
+  const offsetStr = timetz.substring(offsetPos);
+
+  // Split the time into hours and minutes
+  const [hourStr, minuteStr] = time.split(':');
+
+  // Parse the hour, minute, and offset as integers
+  const hour = parseInt(hourStr ?? '0', 10);
+  const minute = parseInt(minuteStr ?? '0', 10);
+  const offset = parseInt(offsetStr, 10);
+
+  // Get the current date and time
+  const date = new Date();
+
+  // Get the current user's timezone offset in hours
+  const currentUserOffset = -date.getTimezoneOffset() / 60;
+
+  // Calculate the difference between the user's timezone and the offset
+  const offsetDiff = currentUserOffset - offset;
+
+  // Set the hour and minute to the input time, adjusted by the offset difference
+  date.setHours(hour + offsetDiff);
+  date.setMinutes(minute);
+
+  // Format the hour and minute with leading zeros if necessary
+  const hourFormatted = date.getHours().toString().padStart(2, '0');
+  const minuteFormatted = date.getMinutes().toString().padStart(2, '0');
+
+  // Return the time in the user's timezone
+  return `${hourFormatted}:${minuteFormatted}`;
+}
+
+export function timetzToHour(timetz?: string) {
+  if (!timetz) return undefined;
+  const [hourStr] = timetzToTime(timetz).split(':');
+  return parseInt(hourStr ?? '0', 10);
+}
+
+export function compareTimetz(timetz1: string, timetz2: string) {
+  const time1 = timetzToTime(timetz1);
+  const time2 = timetzToTime(timetz2);
+  return time1.localeCompare(time2);
+}
+
+export function minTimetz(timetz1: string, timetz2: string) {
+  return compareTimetz(timetz1, timetz2) < 0 ? timetz1 : timetz2;
+}
+
+export function maxTimetz(timetz1: string, timetz2: string) {
+  return compareTimetz(timetz1, timetz2) > 0 ? timetz1 : timetz2;
+}
+
+/**
+ * Parses timezone offset from a time string and returns a formatted offset string
+ * @param timeString - String like "11:00:00+07:00" or "14:30:00-05:30"
+ * @returns Formatted offset string like "+07:00" or "-05:30"
+ */
+export function parseTimezoneOffset(timeString: string): string {
+  if (!timeString) return '';
+
+  // Find the last occurrence of '+' or '-' which indicates the timezone offset
+  const lastPlusIndex = timeString.lastIndexOf('+');
+  const lastMinusIndex = timeString.lastIndexOf('-');
+
+  // If no offset found, return empty string
+  if (lastPlusIndex === -1 && lastMinusIndex === -1) {
+    return '';
+  }
+
+  // Determine which offset to use (take the last one if both exist)
+  const offsetIndex = Math.max(lastPlusIndex, lastMinusIndex);
+
+  // Extract the offset part
+  const offsetPart = timeString.substring(offsetIndex);
+
+  // Handle cases where the offset is already in HH:MM format like "+05:30"
+  if (offsetPart.includes(':')) {
+    // Already in HH:MM format, return as-is
+    return offsetPart;
+  }
+
+  // Handle legacy decimal format like "+5.5" (for backward compatibility)
+  const offset = parseFloat(offsetPart);
+
+  // Handle NaN case
+  if (Number.isNaN(offset)) {
+    return '';
+  }
+
+  // Convert decimal hours to HH:MM format
+  const hours = Math.floor(Math.abs(offset));
+  const minutes = Math.round((Math.abs(offset) - hours) * 60);
+
+  // Format as HH:MM
+  const formattedHours = hours.toString().padStart(2, '0');
+  const formattedMinutes = minutes.toString().padStart(2, '0');
+
+  const sign = offset >= 0 ? '+' : '-';
+  return `${sign}${formattedHours}:${formattedMinutes}`;
+}
+
+/**
+ * Formats timezone offset for display in UI
+ * @param timeString - String like "11:00:00+07" or "14:30:00-05"
+ * @returns Formatted string like "UTC+07:00" or "UTC-05:30"
+ */
+export function formatTimezoneOffset(timeString: string): string {
+  if (!timeString) return '';
+
+  const offset = parseTimezoneOffset(timeString);
+  if (!offset) return '';
+
+  return `UTC${offset}`;
+}
+
+export type DateRangeOption = 'present' | 'past' | 'future';
+export type DateRangeUnit =
+  | 'day'
+  | 'week'
+  | 'month'
+  | 'year'
+  | 'all'
+  | 'custom';
+
+export type DateRange = [Date | null, Date | null];
+
+export const getDateRange = (
+  unit: DateRangeUnit,
+  option: DateRangeOption
+): DateRange => {
+  const start = moment();
+  const end = moment();
+
+  switch (unit) {
+    case 'day':
+      switch (option) {
+        case 'present':
+          start.startOf('day');
+          end.endOf('day');
+          break;
+
+        case 'past':
+          start.subtract(1, 'day').startOf('day');
+          end.subtract(1, 'day').endOf('day');
+          break;
+
+        case 'future':
+          start.add(1, 'day').startOf('day');
+          end.add(1, 'day').endOf('day');
+          break;
+      }
+      break;
+
+    case 'week':
+      switch (option) {
+        case 'present':
+          start.startOf('week');
+          end.endOf('week');
+          break;
+
+        case 'past':
+          start.subtract(1, 'week').startOf('week');
+          end.subtract(1, 'week').endOf('week');
+          break;
+
+        case 'future':
+          start.add(1, 'week').startOf('week');
+          end.add(1, 'week').endOf('week');
+          break;
+      }
+      break;
+
+    case 'month':
+      switch (option) {
+        case 'present':
+          start.startOf('month');
+          end.endOf('month');
+          break;
+
+        case 'past':
+          start.subtract(1, 'month').startOf('month');
+          end.subtract(1, 'month').endOf('month');
+          break;
+
+        case 'future':
+          start.add(1, 'month').startOf('month');
+          end.add(1, 'month').endOf('month');
+          break;
+      }
+      break;
+
+    case 'year':
+      switch (option) {
+        case 'present':
+          start.startOf('year');
+          end.endOf('year');
+          break;
+
+        case 'past':
+          start.subtract(1, 'year').startOf('year');
+          end.subtract(1, 'year').endOf('year');
+          break;
+
+        case 'future':
+          start.add(1, 'year').startOf('year');
+          end.add(1, 'year').endOf('year');
+          break;
+      }
+      break;
+
+    case 'all':
+      return [null, null];
+
+    case 'custom': {
+      throw new Error('Not implemented yet: "custom" case');
+    }
+  }
+
+  return [start.toDate(), end.toDate()];
+};
+
+export const getDateRangeUnits = (
+  t: (key: string) => string
+): {
+  label: string;
+  value: DateRangeUnit;
+}[] => {
+  return [
+    { label: t('date_helper.day'), value: 'day' },
+    { label: t('date_helper.week'), value: 'week' },
+    { label: t('date_helper.month'), value: 'month' },
+    { label: t('date_helper.year'), value: 'year' },
+    { label: t('date_helper.all'), value: 'all' },
+    { label: t('date_helper.custom'), value: 'custom' },
+  ];
+};
+
+export const getDateRangeOptions = (
+  unit: DateRangeUnit,
+  t: (key: string) => string
+): {
+  label: string;
+  value: DateRangeOption;
+}[] => {
+  switch (unit) {
+    case 'day':
+      return [
+        { label: t('date_helper.today'), value: 'present' },
+        { label: t('date_helper.yesterday'), value: 'past' },
+        { label: t('date_helper.tomorrow'), value: 'future' },
+      ];
+
+    case 'week':
+      return [
+        { label: t('date_helper.this-week'), value: 'present' },
+        { label: t('date_helper.last-week'), value: 'past' },
+        { label: t('date_helper.next-week'), value: 'future' },
+      ];
+
+    case 'month':
+      return [
+        { label: t('date_helper.this_month'), value: 'present' },
+        { label: t('date_helper.last-month'), value: 'past' },
+        { label: t('date_helper.next-month'), value: 'future' },
+      ];
+
+    case 'year':
+      return [
+        { label: t('date_helper.this-year'), value: 'present' },
+        { label: t('date_helper.last-year'), value: 'past' },
+        { label: t('date_helper.next-year'), value: 'future' },
+      ];
+
+    case 'all':
+      return [{ label: t('date_helper.all'), value: 'present' }];
+
+    default:
+      return [];
+  }
+};
+
+export function calculateDuration(startDate: Date, endDate: Date): string {
+  // Calculate the difference in milliseconds
+  const diff = endDate.getTime() - startDate.getTime();
+
+  // Convert to seconds
+  const seconds = Math.floor(diff / 1000);
+
+  if (seconds < 60) {
+    return `${seconds} seconds`;
+  }
+
+  // Calculate hours, minutes, seconds
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const remainingSeconds = seconds % 60;
+
+  // Format the result based on the duration
+  if (hours > 0) {
+    return `${hours}h ${minutes}m ${remainingSeconds}s`;
+  } else if (minutes > 0) {
+    return `${minutes}m ${remainingSeconds}s`;
+  } else {
+    return `${seconds}s`;
+  }
+}

package/src/editor/convert-to-task.ts

@@ -0,0 +1,264 @@
+import type { Editor } from '@tiptap/core';
+
+export interface ConvertToTaskOptions {
+  editor: Editor;
+  listId: string;
+  listName: string;
+  createTask: (params: { name: string; listId: string }) => Promise<{
+    id: string;
+    name: string;
+    display_number?: number;
+    priority?: string;
+    listColor?: string;
+    assignees?: string;
+    workspaceId?: string | null;
+  }>;
+  wrapInParagraph?: boolean;
+}
+
+export interface ConvertToTaskResult {
+  success: boolean;
+  taskId?: string;
+  taskName?: string;
+  error?: {
+    type: 'no_selection' | 'empty_content' | 'no_lists' | 'unknown';
+    message: string;
+    description?: string;
+  };
+}
+
+/**
+ * Converts selected text or a list item in a TipTap editor to a task and replaces it with a mention.
+ *
+ * This function supports two modes:
+ * 1. Selection mode: If text is highlighted/selected, uses the selected text as the task name
+ *    and replaces the selection with a mention to the new task.
+ * 2. List item mode (fallback): If no text is selected but cursor is in a list item,
+ *    uses the entire list item text and replaces the list item with a mention.
+ *
+ * @param options - Configuration options for the conversion
+ * @returns Result object indicating success or failure with error details
+ */
+export async function convertListItemToTask(
+  options: ConvertToTaskOptions
+): Promise<ConvertToTaskResult> {
+  const {
+    editor,
+    listId,
+    listName: _listName, // Kept for backwards compatibility but unused
+    createTask,
+    wrapInParagraph = false,
+  } = options;
+
+  const { state } = editor;
+  const { selection } = state;
+  const { from, to, empty } = selection;
+
+  // Mode 1: Text is selected - use the selected text as task name
+  if (!empty) {
+    const selectedText = state.doc.textBetween(from, to, ' ').trim();
+
+    if (!selectedText) {
+      return {
+        success: false,
+        error: {
+          type: 'empty_content',
+          message: 'Empty selection',
+          description: 'Select some text to convert to a task',
+        },
+      };
+    }
+
+    try {
+      // Create new task using the selected text
+      const newTask = await createTask({
+        name: selectedText,
+        listId,
+      });
+
+      // Replace the selected text with a mention to the new task
+      const tr = state.tr;
+
+      // Delete the selected text
+      tr.delete(from, to);
+
+      // Check if mention node exists in schema
+      if (state.schema.nodes.mention) {
+        // Create mention node with correct attributes:
+        // - displayName: ticket number (e.g., "123" for #123)
+        // - subtitle: task name
+        const mentionNode = state.schema.nodes.mention.create({
+          entityId: newTask.id,
+          entityType: 'task',
+          displayName: newTask.display_number
+            ? String(newTask.display_number)
+            : newTask.name,
+          avatarUrl: null,
+          subtitle: newTask.name,
+          // Add task-specific attributes if present
+          priority: newTask.priority || null,
+          listColor: newTask.listColor || null,
+          assignees: newTask.assignees || null,
+          workspaceId: newTask.workspaceId ?? null,
+        });
+
+        // Insert mention at the selection start position
+        tr.insert(from, mentionNode);
+
+        // Add a space after the mention for better UX
+        const spacePos = from + mentionNode.nodeSize;
+        tr.insertText(' ', spacePos);
+      }
+
+      // Apply transaction
+      editor.view.dispatch(tr);
+
+      return {
+        success: true,
+        taskId: newTask.id,
+        taskName: newTask.name,
+      };
+    } catch (error) {
+      console.error('Failed to convert selection to task:', error);
+      return {
+        success: false,
+        error: {
+          type: 'unknown',
+          message: 'Failed to create task',
+          description: 'An error occurred while creating the task',
+        },
+      };
+    }
+  }
+
+  // Mode 2: No selection - fall back to list item mode
+  const { $from } = selection;
+
+  // Get the current node (could be listItem, taskItem, or paragraph inside them)
+  let currentNode = $from.parent;
+  const depth = $from.depth;
+
+  // Safety check: depth must be at least 1 to have a valid position
+  if (depth < 1) {
+    return {
+      success: false,
+      error: {
+        type: 'no_selection',
+        message: 'No text selected',
+        description:
+          'Select some text or move your cursor to a list item to convert it to a task',
+      },
+    };
+  }
+
+  let nodePos = $from.before(depth);
+
+  // If we're inside a paragraph, get the parent list item
+  if (currentNode.type.name === 'paragraph') {
+    if (depth < 2) {
+      return {
+        success: false,
+        error: {
+          type: 'no_selection',
+          message: 'No text selected',
+          description:
+            'Select some text or move your cursor to a list item to convert it to a task',
+        },
+      };
+    }
+    currentNode = $from.node(depth - 1);
+    nodePos = $from.before(depth - 1);
+  }
+
+  // Check if we're in a list item or task item
+  const validNodeTypes = ['listItem', 'taskItem'];
+  if (!validNodeTypes.includes(currentNode.type.name)) {
+    return {
+      success: false,
+      error: {
+        type: 'no_selection',
+        message: 'No text selected',
+        description:
+          'Select some text or move your cursor to a list item to convert it to a task',
+      },
+    };
+  }
+
+  // Extract text content from the node
+  const textContent = currentNode.textContent.trim();
+  if (!textContent) {
+    return {
+      success: false,
+      error: {
+        type: 'empty_content',
+        message: 'Empty list item',
+        description: 'Add some text before converting to a task',
+      },
+    };
+  }
+
+  try {
+    // Create new task using the provided function
+    const newTask = await createTask({
+      name: textContent,
+      listId,
+    });
+
+    // Replace the list item with a mention to the new task
+    const tr = state.tr;
+
+    // Delete the list item node
+    tr.delete(nodePos, nodePos + currentNode.nodeSize);
+
+    // Check if mention node exists in schema
+    if (state.schema.nodes.mention) {
+      // Create mention node with correct attributes:
+      // - displayName: ticket number (e.g., "123" for #123)
+      // - subtitle: task name
+      const mentionNode = state.schema.nodes.mention.create({
+        entityId: newTask.id,
+        entityType: 'task',
+        displayName: newTask.display_number
+          ? String(newTask.display_number)
+          : newTask.name,
+        avatarUrl: null,
+        subtitle: newTask.name,
+        // Add task-specific attributes if present
+        priority: newTask.priority || null,
+        listColor: newTask.listColor || null,
+        assignees: newTask.assignees || null,
+        workspaceId: newTask.workspaceId ?? null,
+      });
+
+      // Wrap in paragraph if requested and paragraph node exists
+      if (wrapInParagraph && state.schema.nodes.paragraph) {
+        const paragraphNode = state.schema.nodes.paragraph.create(null, [
+          mentionNode,
+          state.schema.text(' '),
+        ]);
+        tr.insert(nodePos, paragraphNode);
+      } else {
+        tr.insert(nodePos, mentionNode);
+      }
+    }
+
+    // Apply transaction
+    editor.view.dispatch(tr);
+
+    return {
+      success: true,
+      taskId: newTask.id,
+      taskName: newTask.name,
+    };
+  } catch (error) {
+    console.error('Failed to convert item to task:', error);
+    return {
+      success: false,
+      error: {
+        type: 'unknown',
+        message: 'Failed to create task',
+        description: 'An error occurred while creating the task',
+      },
+    };
+  }
+}

package/src/editor/index.ts

@@ -0,0 +1,5 @@
+export {
+  type ConvertToTaskOptions,
+  type ConvertToTaskResult,
+  convertListItemToTask,
+} from './convert-to-task';