Skip to content

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

7.1 KB
Raw Blame
import { isNil, tryCatchSync } from '@activepieces/core-utils';
import dayjs from 'dayjs';
import duration from 'dayjs/plugin/duration';
dayjs.extend(duration);
import i18next, { t } from 'i18next';

const emailRegex =
  /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;

export const formatUtils = {
  emailRegex,
  convertEnumToHumanReadable(str: string) {
    const words = str.split(/[_.]/);
    return words
      .map(
        (word) =>
          word.charAt(0).toUpperCase() + word.slice(1).toLocaleLowerCase(),
      )
      .join(' ');
  },
  convertEnumToReadable(value: string): string {
    return (
      value.charAt(0).toUpperCase() +
      value.slice(1).toLowerCase().replace(/_/g, ' ')
    );
  },
  formatNumber(number: number) {
    return new Intl.NumberFormat(i18next.language).format(number);
  },
  formatNumberCompact(number: number) {
    return new Intl.NumberFormat(i18next.language, {
      notation: 'compact',
      maximumFractionDigits: 1,
    }).format(number);
  },
  formatDateOnlyOrFail(date: Date, fallback: string) {
    try {
      return this.formatDateOnly(date);
    } catch (error) {
      return fallback;
    }
  },
  formatDateOnly(date: Date) {
    return Intl.DateTimeFormat(i18next.language, {
      month: 'numeric',
      day: 'numeric',
      year: 'numeric',
    }).format(date);
  },
  formatDateTime(date: Date) {
    return Intl.DateTimeFormat(i18next.language, {
      month: 'numeric',
      day: 'numeric',
      year: 'numeric',
      hour: 'numeric',
      minute: 'numeric',
      hour12: true,
    }).format(date);
  },
  formatDateWithTime(date: Date, hideCurrentYear: boolean) {
    const now = dayjs();
    const inputDate = dayjs(date);
    const isToday = inputDate.isSame(now, 'day');
    const isYesterday = inputDate.isSame(now.subtract(1, 'day'), 'day');
    const isSameYear = inputDate.isSame(now, 'year');

    const timeFormat = new Intl.DateTimeFormat(i18next.language, {
      hour: 'numeric',
      minute: 'numeric',
      hour12: true,
    });

    if (isToday) {
      return `${t('Today')}, ${timeFormat.format(date)}`;
    } else if (isYesterday) {
      return `${t('Yesterday')}, ${timeFormat.format(date)}`;
    }

    if (isSameYear && !hideCurrentYear) {
      return Intl.DateTimeFormat(i18next.language, {
        month: 'short',
        day: 'numeric',
        hour: 'numeric',
        minute: 'numeric',
        hour12: true,
      }).format(date);
    }

    return Intl.DateTimeFormat(i18next.language, {
      month: 'short',
      day: 'numeric',
      year: 'numeric',
      hour: 'numeric',
      minute: 'numeric',
      hour12: true,
    }).format(date);
  },
  formatDate(date: Date) {
    const now = dayjs();
    const inputDate = dayjs(date);
    const isToday = inputDate.isSame(now, 'day');
    const isYesterday = inputDate.isSame(now.subtract(1, 'day'), 'day');
    const isSameYear = inputDate.isSame(now, 'year');

    if (isToday) {
      const diffInSeconds = now.diff(inputDate, 'second');
      const diffInMinutes = now.diff(inputDate, 'minute');
      const diffInHours = now.diff(inputDate, 'hour');
      if (diffInSeconds < 60) {
        return t('Just now');
      }
      if (diffInMinutes < 60) {
        return diffInMinutes === 1
          ? t('1 min ago')
          : t('{count} mins ago', { count: diffInMinutes });
      }
      return diffInHours === 1
        ? t('1 hour ago')
        : t('{count} hours ago', { count: diffInHours });
    }

    if (isYesterday) {
      return t('Yesterday');
    }

    if (isSameYear) {
      return Intl.DateTimeFormat(i18next.language, {
        month: 'short',
        day: 'numeric',
      }).format(date);
    }

    return Intl.DateTimeFormat(i18next.language, {
      month: 'short',
      day: 'numeric',
      year: 'numeric',
    }).format(date);
  },
  formatToHoursAndMinutes(seconds: number) {
    const d = dayjs.duration(Math.round(seconds), 'seconds');
    const h = Math.floor(d.asHours());
    const m = d.minutes();
    const s = d.seconds();

    if (h > 0 && m > 0) return `${h}h ${m}m`;
    if (h > 0) return `${h}h`;
    if (m > 0 && s > 0) return `${m}m ${s}s`;
    if (m > 0) return `${m}m`;
    return `${s}s`;
  },
  formatDateToAgo(date: Date) {
    const now = dayjs();
    const inputDate = dayjs(date);
    const diffInSeconds = now.diff(inputDate, 'second');
    const diffInMinutes = now.diff(inputDate, 'minute');
    const diffInHours = now.diff(inputDate, 'hour');
    const diffInDays = now.diff(inputDate, 'day');

    if (diffInSeconds < 60) {
      return `${diffInSeconds}s ago`;
    }
    if (diffInMinutes < 60) {
      return `${diffInMinutes}m ago`;
    }
    if (diffInHours < 24) {
      return `${diffInHours}h ago`;
    }
    if (diffInDays < 30) {
      return `${diffInDays}d ago`;
    }
    return inputDate.format('MMM D, YYYY');
  },
  formatDuration(durationMs: number | undefined, short?: boolean): string {
    if (durationMs === undefined) {
      return '-';
    }
    if (durationMs < 1000) {
      const durationMsFormatted = Math.floor(durationMs);
      return short
        ? `${durationMsFormatted} ms`
        : `${durationMsFormatted} milliseconds`;
    }
    const seconds = Math.floor(durationMs / 1000);
    const minutes = Math.floor(seconds / 60);

    if (seconds < 60) {
      return short ? `${seconds} s` : `${seconds} seconds`;
    }

    if (minutes > 0) {
      const remainingSeconds = seconds % 60;
      return short
        ? `${minutes} min ${
            remainingSeconds > 0 ? `${remainingSeconds} s` : ''
          }`
        : `${minutes} minutes${
            remainingSeconds > 0 ? ` ${remainingSeconds} seconds` : ''
          }`;
    }
    return short ? `${seconds} s` : `${seconds} seconds`;
  },
  formatStorageSize(bytes: number): string {
    if (bytes < 1024) {
      return `${bytes} B`;
    }
    if (bytes < 1024 * 1024) {
      return `${(bytes / 1024).toFixed(1)} KB`;
    }
    if (bytes < 1024 * 1024 * 1024) {
      return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
    }
    return `${(bytes / 1024 / 1024 / 1024).toFixed(1)} GB`;
  },
  urlIsPubliclyReachable(url: string): boolean {
    const { data: parsed } = tryCatchSync(() => new URL(url));
    if (isNil(parsed) || parsed.protocol !== 'https:') {
      return false;
    }
    const hostname = parsed.hostname.toLowerCase().replace(/^\[|\]$/g, '');
    if (hostname === 'localhost' || hostname.endsWith('.localhost')) {
      return false;
    }
    if (hostname.includes(':')) {
      return !/^(::1$|f[cd]|fe[89ab])/.test(hostname);
    }
    return !isPrivateIpv4(hostname);
  },
};

function isPrivateIpv4(hostname: string): boolean {
  const octets = hostname.split('.').map(Number);
  const isIpv4 =
    octets.length === 4 &&
    octets.every(
      (octet) => Number.isInteger(octet) && octet >= 0 && octet <= 255,
    );
  if (!isIpv4) {
    return false;
  }
  const [first, second] = octets;
  return (
    first === 0 ||
    first === 10 ||
    first === 127 ||
    (first === 100 && second >= 64 && second <= 127) ||
    (first === 169 && second === 254) ||
    (first === 172 && second >= 16 && second <= 31) ||
    (first === 192 && second === 168)
  );
}