@uniai-fe/util-functions 0.0.1

package/src/functions/date.ts

@@ -0,0 +1,386 @@
+import { isValidDateType, isValidTimeStringFormat } from "./validation";
+import { dateFormat } from "./format";
+import type {
+  CheckDateMomentType,
+  ScheduleBYDAY,
+  ScheduleFREQ,
+  ScheduleRepeatCycleDateType,
+} from "@uniai/types";
+
+/**
+ * 오늘 날짜를 yyyy-mm-dd 포맷 string으로 추출
+ * @util
+ * @param {string} [time] HH:MM:SS
+ * @return {string} yyyy-mm-dd
+ */
+export const getToday = (time?: string): string =>
+  `${dateFormat(new Date())}${time && isValidTimeStringFormat(time) ? `T${time}` : ""}`;
+
+/**
+ * 과거 특정날짜 추출
+ * @util
+ * @param {string | Date} date
+ * @param {number} [weeks] 과거 몇 주 전
+ * @param {number} [days] 과거 며칠 전
+ * @return {Date | undefined}
+ */
+export function getPrevDay(
+  date: string | Date,
+  weeks?: number,
+  days?: number,
+): Date | undefined {
+  if (!isValidDateType(date)) return undefined;
+  const standardDate = new Date(date);
+
+  const prevWeekDay: number = typeof weeks === "undefined" ? 0 : 7 * weeks;
+  const prevDays: number = typeof days === "undefined" ? 1 : days;
+  const prevDayAmount: number = prevWeekDay !== 0 ? prevWeekDay : prevDays;
+
+  standardDate.setDate(standardDate.getDate() - prevDayAmount);
+
+  return new Date(standardDate);
+}
+
+/**
+ * 미래 특정날짜 추출
+ * @util
+ * @param {string | Date} date
+ * @param {number} [weeks] 미래 몇 주 후
+ * @param {number} [days] 미래 며칠 후
+ * @return {Date | undefined}
+ */
+export function getNextDay(
+  date: string | Date,
+  weeks?: number,
+  days?: number,
+): Date | undefined {
+  if (!isValidDateType(date)) return undefined;
+  const standardDate = new Date(date);
+
+  const nextWeekDay: number = typeof weeks === "undefined" ? 0 : 7 * weeks;
+  const nextDays: number = typeof days === "undefined" ? 1 : days;
+  const nextDayAmount: number = nextWeekDay !== 0 ? nextWeekDay : nextDays;
+
+  standardDate.setDate(standardDate.getDate() + nextDayAmount);
+
+  return new Date(standardDate);
+}
+
+/**
+ * 과거 특정시점의 주간 날짜 배열 추출
+ * @util
+ * @param {string | Date} date
+ * @param {number} weeks 과거 몇 주 전
+ * @return {Date[]}
+ */
+export function getLastWeeks(date: string | Date, weeks: number = 1): Date[] {
+  if (!isValidDateType(date)) return [];
+  const lastWeeks: Date[] = [];
+  for (let d = 1; d <= 7 * weeks; d++) {
+    const prevDate = new Date(date);
+    lastWeeks.unshift(new Date(prevDate.setDate(prevDate.getDate() - d)));
+  }
+  return lastWeeks;
+}
+
+/**
+ * 미래 특정시점의 주간 날짜 배열 추출
+ * @util
+ * @param {string | Date} date
+ * @param {number} weeks 미래 몇 주 전
+ * @return {Date[]}
+ */
+export function getNextWeeks(date: string | Date, weeks: number = 1): Date[] {
+  if (!isValidDateType(date)) return [];
+  const startDate = new Date(date);
+  return new Array(weeks * 7)
+    .fill(startDate)
+    .map((date: Date, index: number) => {
+      const nextDate = new Date(date);
+      return new Date(nextDate.setDate(nextDate.getDate() + index));
+    });
+}
+
+/**
+ * 지정된 범위 내의 모든 날짜 배열 추출
+ * @util
+ * @param {string | Date} startDate
+ * @param {string | Date} endDate
+ * @param {boolean} [isFormat] 날짜 배열을 yyyy-mm-dd string으로 생성할지 여부
+ * @return {(Date | string)[]}
+ */
+export function getDateArray(
+  startDate: string | Date,
+  endDate: string | Date,
+  isFormat?: boolean,
+): (Date | string)[] {
+  if (!isValidDateType(startDate) || !isValidDateType(endDate)) return [];
+
+  const dayUnit = 1000 * 60 * 60 * 24;
+  const start = new Date(dateFormat(startDate));
+  const end = new Date(dateFormat(endDate));
+  const array: (Date | string)[] = [];
+  for (let day = start.getTime(); day <= end.getTime(); day += dayUnit) {
+    const d = isFormat ? dateFormat(new Date(day)) : new Date(day);
+    array.push(d);
+  }
+  return array;
+}
+
+/**
+ * 현재 시점을 기준으로 한 특정 날짜의 시점 추출
+ * @util
+ * @param {string | Date} date
+ * @return {CheckDateMomentType}
+ */
+export function checkDateMoment(date: string | Date): CheckDateMomentType {
+  const res: CheckDateMomentType = {
+    isToday: false,
+    isPast: false,
+    isFuture: false,
+    moment: "",
+  };
+
+  if (!isValidDateType(date)) return res;
+
+  const standardDate = dateFormat(date);
+  const standardTime = new Date(standardDate).getTime();
+  const today = getToday();
+  const todayTime = new Date(today).getTime();
+
+  if (standardDate === today) {
+    res.isToday = true;
+    res.moment = "today";
+  } else if (standardTime < todayTime) {
+    res.isPast = true;
+    res.moment = "past";
+  } else if (standardTime > todayTime) {
+    res.isFuture = true;
+    res.moment = "future";
+  }
+
+  return res;
+}
+
+/**
+ * 특정 날짜의 해당 월 주차 수
+ * @util
+ * @param {string|Date} date
+ * @return {number} 몇주차
+ */
+export function weekOrderIndex(date: string | Date): number {
+  if (date && new Date(date) instanceof Date) {
+    const standardDate = new Date(date).getDate();
+    const firstWeekday = new Date(new Date(date).setDate(1)).getDay();
+    return Math.ceil((standardDate + firstWeekday) / 7);
+  }
+  return 0;
+}
+
+/**
+ * 반복 주기의 명칭 한글표기로 변환
+ * @util
+ * @param {ScheduleFREQ} FREQ "DAILY" | "WEEKLY" | "MONTHLY" | "YEARLY"
+ * @return {string} "일" | "주" | "개월" | "년"
+ */
+export function getRepeatCycleUnit(FREQ: ScheduleFREQ): string {
+  switch (FREQ) {
+    case "DAILY":
+      return "일";
+    case "WEEKLY":
+      return "주";
+    case "MONTHLY":
+      return "개월";
+    case "YEARLY":
+      return "년";
+    default:
+      return "주기";
+  }
+}
+
+/**
+ * weekOrderIdx()의 index값을 "N번째"로 텍스트 변환
+ * @util
+ * @param {number|string} [weekIndex] 몇주차 인덱스
+ * @return {string}
+ */
+export function weekOrderKo(weekIndex?: string | number): string {
+  if (typeof weekIndex === "undefined") return "";
+  switch (String(weekIndex)) {
+    case "1":
+      return "첫번째";
+    case "2":
+      return "두번째";
+    case "3":
+      return "세번째";
+    case "4":
+      return "네번째";
+    case "5":
+      return "다섯번째";
+    case "6":
+      return "여섯번째";
+    default:
+      return "";
+  }
+}
+
+/**
+ * 요일 인덱스에서 요일 코드 추출
+ * @util
+ * @param {number|string} weekdayIndex
+ * @return {ScheduleBYDAY} "MO"|"TU"|"WE"|"TH"|"FR"|"SA"|"SU"|""
+ */
+export function weekdayCodeByWeekdayIndex(
+  weekdayIndex?: number | string,
+): ScheduleBYDAY {
+  if (typeof weekdayIndex === "undefined") return "";
+
+  switch (String(weekdayIndex)) {
+    case "0":
+      return "SU";
+    case "1":
+      return "MO";
+    case "2":
+      return "TU";
+    case "3":
+      return "WE";
+    case "4":
+      return "TH";
+    case "5":
+      return "FR";
+    case "6":
+      return "SA";
+    default:
+      return "";
+  }
+}
+
+/**
+ * 요일 인덱스에서 "N요일" 텍스트 생성
+ * @util
+ * @param {string|number|ScheduleBYDAY} [dayCode] 요일 인덱스 또는 R-rule 요일 코드
+ * @param {boolean} [isFull] "요일"까지 붙은 전체 명칭생성 여부
+ * @return {string} "일(요일)","월(요일)", ..., "토(요일)"
+ */
+export function weekdayByDayCode(
+  dayCode?: string | number | ScheduleBYDAY,
+  isFull?: boolean,
+): string {
+  if (typeof dayCode === "undefined") return "";
+
+  const fullName = isFull ? "요일" : "";
+  const code = String(dayCode);
+
+  if (code === "0" || code.includes("SU")) return `일${fullName}`;
+  else if (code === "1" || code.includes("MO")) return `월${fullName}`;
+  else if (code === "2" || code.includes("TU")) return `화${fullName}`;
+  else if (code === "3" || code.includes("WE")) return `수${fullName}`;
+  else if (code === "4" || code.includes("TH")) return `목${fullName}`;
+  else if (code === "5" || code.includes("FR")) return `금${fullName}`;
+  else if (code === "6" || code.includes("SA")) return `토${fullName}`;
+
+  return ``;
+}
+
+/**
+ * 월간/연간 반복에 대한 지정 날짜 코드 parsing
+ * @util
+ * @param {string} cycleDateString 전체 명칭생성 여부
+ * @return {ScheduleRepeatCycleDateType | undefined}
+ */
+export function generateRepeatCycleDate(
+  cycleDateString: string,
+): ScheduleRepeatCycleDateType | undefined {
+  const isRepeatDate = cycleDateString?.startsWith("date,") || false;
+  const isRepeatWeek = cycleDateString?.startsWith("weekday,") || false;
+
+  if (cycleDateString === "" || !(isRepeatDate || isRepeatWeek))
+    return undefined;
+
+  const selected = cycleDateString.split(",");
+
+  const repeatCycleDate: ScheduleRepeatCycleDateType = {
+    cycleDateUnit: selected[0] as "date" | "weekday",
+  };
+
+  if (selected[0] === "date") {
+    const repeatDay = selected[1]?.split("_")?.[1] || "";
+    Object.assign(repeatCycleDate, { repeatDay });
+
+    if (selected[2] !== "" && selected[2]?.startsWith("month_")) {
+      const repeatMonth = selected[2].split("_")?.[1] || "";
+      Object.assign(repeatCycleDate, { repeatMonth });
+    }
+  } else if (selected[0] === "weekday") {
+    const repeatWeekOrder = selected[1]?.split("_")?.[1] || "";
+    const repeatWeekDayIndex = selected[2]?.split("_")?.[1] || "";
+    Object.assign(repeatCycleDate, { repeatWeekOrder, repeatWeekDayIndex });
+  }
+
+  return repeatCycleDate;
+}
+
+/**
+ * 반복 지정 주기/날짜/요일에 대해, 코드에서 한글로 변환
+ * @util
+ * @param {string} repeatCycleDate 반복 주기/날짜/요일 코드
+ * @return {string}
+ */
+export function repeatCycleDateKo(repeatCycleDate?: string): string {
+  if (typeof repeatCycleDate === "undefined" || repeatCycleDate === "")
+    return "";
+
+  const option = generateRepeatCycleDate(repeatCycleDate as string);
+  if (option === undefined) return "";
+
+  if (option.cycleDateUnit === "date") {
+    const repeatMonthKo = option.repeatMonth ? `${option.repeatMonth}월 ` : "";
+    const repeatDayKo = option.repeatDay ? `${option.repeatDay}일` : "";
+    return `${repeatMonthKo}${repeatDayKo}`;
+  } else if (option.cycleDateUnit === "weekday") {
+    const repeatWeekOrderKo = weekOrderKo(option.repeatWeekOrder);
+    const repeatWeekDayKo = weekdayByDayCode(option.repeatWeekDayIndex, true);
+    return `${repeatWeekOrderKo} ${repeatWeekDayKo}`;
+  }
+
+  return "";
+}
+
+/**
+ * 반복 지정 정보 전체를 한글표현으로 생성
+ * @util
+ * @param {ScheduleFREQ | undefined} repeatUnit
+ * @param {string | number | undefined} repeatCycle
+ * @param {string | undefined} repeatCycleDate
+ * @param {string | undefined} repeatWeekly
+ * @return {string}
+ */
+export function convertSelectedRepeatInfo(
+  repeatUnit: ScheduleFREQ | undefined,
+  repeatCycle: string | number | undefined,
+  repeatCycleDate: string | undefined,
+  repeatWeekly: string | undefined,
+): string {
+  const weekdayKorean: string =
+    repeatUnit === "WEEKLY" &&
+    typeof repeatWeekly !== "undefined" &&
+    repeatWeekly !== ""
+      ? String(repeatWeekly)
+          .split(",")
+          .map((dayIndex: string) => weekdayByDayCode(dayIndex as string, true))
+          .join(",")
+      : "";
+
+  switch (repeatUnit) {
+    case "DAILY":
+      return `${repeatCycle}일마다`;
+    case "WEEKLY":
+      return `매주 ${weekdayKorean}`;
+    case "MONTHLY":
+      return `${repeatCycle}개월마다 ${repeatCycleDateKo(repeatCycleDate)}`;
+    case "YEARLY":
+      return `${repeatCycle}년마다 ${repeatCycleDateKo(repeatCycleDate)}`;
+    default:
+      return "--";
+  }
+}

package/src/functions/file.ts

@@ -0,0 +1,57 @@
+import Decimal from "decimal.js";
+
+/**
+ * 파일 유틸리티; 다운로드
+ * @util
+ * @param {Object} options - 다운로드 옵션
+ * @param {string} options.url - 다운로드할 파일의 URL
+ * @param {string} options.name - 다운로드할 파일의 이름
+ */
+export const fileDownload = ({ url, name }: { url: string; name: string }) =>
+  fetch(url)
+    .then(res => {
+      const contentType = res.headers.get("content-type") || "";
+      if (!res.ok || contentType.includes("text/html")) {
+        throw new Error("파일을 찾을 수 없거나 다운로드할 수 없습니다.");
+      }
+      return res.blob();
+    })
+    .then(blob => {
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = String(name);
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      URL.revokeObjectURL(url);
+    })
+    .catch(err => {
+      console.error("Download error:", err);
+      alert("다운로드 중 오류가 발생했습니다.");
+    });
+
+/**
+ * 파일 유틸리티; 파일 크기 포맷팅
+ * @util
+ * @param {unknown} size - 파일 크기 (바이트 단위)
+ * @param {boolean} [unit=true] - 단위 표시 여부 (기본값: true)
+ * @returns {string} - 포맷된 파일 크기 문자열
+ */
+export const fileSize = (size: unknown, unit: boolean = true): string => {
+  if (typeof size !== "number" || (size && isNaN(Number(size)))) return "";
+
+  const AMOUNT = 1024;
+  const K_AMOUNT = AMOUNT * AMOUNT;
+  const M_AMOUNT = AMOUNT * AMOUNT * AMOUNT;
+
+  const byte = new Decimal(size);
+  const kb = byte.div(AMOUNT);
+  const mb = kb.div(AMOUNT);
+  const gb = mb.div(AMOUNT);
+
+  if (byte.toNumber() < AMOUNT) return `${byte.toFixed(0)}B`;
+  if (byte.toNumber() < K_AMOUNT) return `${kb.toFixed(0)}KB`;
+  if (byte.toNumber() < M_AMOUNT) return `${mb.toFixed(0)}MB`;
+  return unit ? `${gb.toFixed(0)}GB` : `${gb.toFixed(2)} GB`;
+};