@uniai-fe/util-functions 0.0.1

package/src/functions/chart.ts

@@ -0,0 +1,304 @@
+import type { SVGAttributes } from "react";
+import { extent, quantile } from "d3-array";
+import type { GetChartYTicksProps, RechartsXAxisTickProps } from "@uniai/types";
+
+/**
+ * 차트 유틸리티; 도메인 범위 제한값
+ * @util
+ * @param {object} props
+ * @param {number | null} props.value - 값
+ * @param {number} props.gap - 갭
+ * @param {number} [props.min] - 최소값
+ * @param {number} [props.max] - 최대값
+ * @returns {number | string} - 도메인 제한값
+ */
+export const getDomainLimit = <ReturnType extends number | string>({
+  value,
+  gap,
+  min,
+  max,
+}: {
+  value: unknown;
+  gap: number;
+  min?: number;
+  max?: number;
+}): ReturnType => {
+  if (typeof value !== "number") return "auto" as ReturnType;
+
+  const amount = value + gap;
+
+  if (typeof min === "number")
+    return (amount < min ? min : amount) as ReturnType;
+  else if (typeof max === "number")
+    return (amount > max ? max : amount) as ReturnType;
+
+  return amount as ReturnType;
+};
+
+/**
+ * 차트 유틸리티; Y축 ticks 생성
+ * @util
+ * @param {object} props
+ * @param {unknown[]} props.data - 데이터
+ * @param {number} props.length - 길이
+ * @param {number} [props.pad] - 패딩 (기본값 0.5)
+ * @param {number} [props.limitMin] - 최소값 (기본값 0)
+ * @param {number} [props.limitMax] - 최대값
+ * @param {number} [props.digit] - 소수점 자리수
+ * @returns {number[] | undefined} - Y축 ticks
+ */
+export const getChartYTicks = ({
+  data,
+  length,
+  pad = 0.5,
+  limitMin = 0,
+  limitMax,
+  digit = 1,
+  outliers,
+  log,
+}: GetChartYTicksProps): number[] | undefined => {
+  if (data.length === 0) return undefined;
+  if (log) console.log("[Y Ticks]-----------------------------------");
+
+  // ---------------------------------------------------------------------------
+  // 1) 유효 숫자 배열(validArr) 확보
+  // ---------------------------------------------------------------------------
+  const validArr: number[] = data
+    .filter(v => typeof v !== "undefined" && v !== null && !isNaN(Number(v)))
+    .map(Number)
+    .filter(v => Number.isFinite(v));
+
+  if (validArr.length < 2) return undefined;
+
+  if (log) console.log("validArr", validArr);
+
+  // ---------------------------------------------------------------------------
+  // 2) 이상치(outlier) 제거 – IQR 1.5배 기준
+  // ---------------------------------------------------------------------------
+  let filtered = validArr;
+  if (outliers && validArr.length > 4) {
+    const sorted = [...validArr].sort((a, b) => a - b);
+    const q1 = quantile(sorted, 0.25) as number;
+    const q3 = quantile(sorted, 0.75) as number;
+    const iqr = q3 - q1;
+    const low = q1 - 1.5 * iqr;
+    const high = q3 + 1.5 * iqr;
+    filtered = validArr.filter(v => v >= low && v <= high);
+  }
+
+  // ---------------------------------------------------------------------------
+  // 3) 도메인(domainMin/domainMax) 계산 + 동적 pad 적용
+  // ---------------------------------------------------------------------------
+  let [min, max] = extent(filtered) as [number, number];
+  min = typeof limitMin === "number" && min < limitMin ? limitMin : min;
+  max = typeof limitMax === "number" && max > limitMax ? limitMax : max;
+
+  // --- 분포 기반 pad -------------------------------------------------
+  const sorted = [...filtered].sort((a, b) => a - b);
+  const q1 = quantile(sorted, 0.25)!;
+  const q3 = quantile(sorted, 0.75)!;
+  const iqr = q3 - q1; // IQR 폭
+  const ratio = iqr / (max - min || 1); // 분포 대비 폭
+  // pad 는 '최대 0.3, IQR 기반(0.4×ratio)' 중 더 작은 값 사용
+  // 1·5·0 규칙을 깨면 pad 를 0 으로 무시하도록 이후 로직에서 재귀 호출
+  const dynPad = Math.min(0.3, ratio * 0.4);
+  const padRatio = (max - min) * dynPad;
+  let domainMin = min - padRatio;
+  let domainMax = max + padRatio;
+
+  // 하드 클램프: ±20% 이상 확장 금지
+  const span0 = max - min;
+  domainMin = Math.max(domainMin, min - span0 * 0.2);
+  domainMax = Math.min(domainMax, max + span0 * 0.2);
+  // ------------------------------------------------------------------
+
+  if (length < 1) return undefined;
+
+  // ---------------------------------------------------------------------------
+  // 4) niceStep 선택 + tick 배열 작성
+  //    - 후보: (1|5)×10ⁿ 스텝 중 length-1 에 가장 근접
+  // ---------------------------------------------------------------------------
+  const span = Math.abs(domainMax - domainMin);
+  const rawStep = span / Math.max(length - 1, 1);
+
+  // --- niceStep 선정 로직 개선 -------------------------------------------
+  // 후보 스텝: (1 | 5) × 10^(exp-1 ... exp+1)  총 6개
+  const exp = Math.floor(Math.log10(rawStep));
+  const factors = [1, 2, 2.5, 5] as const; // 1·2·2.5·5 계열 ⇒ tick 끝 0·1·2·5
+  const candidates: number[] = [];
+
+  // exp 가 비정상(NaN, ±Infinity) 이면 기본값 0 사용
+  const expSafe = Number.isFinite(exp) ? exp : 0;
+  for (let e = expSafe - 1; e <= expSafe + 1; e++) {
+    for (const f of factors) {
+      const val = f * Math.pow(10, e);
+      if (Number.isFinite(val) && val > 0) {
+        candidates.push(val);
+      }
+    }
+  }
+
+  if (candidates.length === 0) return undefined;
+
+  // span / step ≈ length-1 인 후보를 우선 선택
+  candidates.sort(
+    (a, b) =>
+      Math.abs(span / a - (length - 1)) - Math.abs(span / b - (length - 1)),
+  );
+
+  let niceStep = candidates[0];
+  // -----------------------------------------------------------------------
+
+  // domain 을 niceStep 배수로 맞춘다
+  let niceMin = Math.floor(domainMin / niceStep) * niceStep;
+  let niceMax = Math.ceil(domainMax / niceStep) * niceStep;
+
+  const fixEdge = (v: number) => {
+    const last = Math.abs(v) % 10;
+    if (last === 1 || last === 5 || last === 0) return v;
+    return Math.round(v / niceStep) * niceStep;
+  };
+  niceMin = fixEdge(niceMin);
+  niceMax = fixEdge(niceMax);
+
+  // ---------------------------------------------------------------------------
+  // 추가 보정: 차트 데이터 최소값(min) == 도메인 하한(niceMin)일 때
+  //           → 현재 도메인 간격(span)만큼 하한을 더 내린다
+  //           (막대가 0px 로 그려지는 현상 방지)
+  // ---------------------------------------------------------------------------
+  if (min === niceMin) {
+    const digit = String(niceMin).split(".")[1]
+      ? String(niceMin).split(".")[1].length
+      : 1;
+    const corr = Math.pow(10, digit);
+    niceMin -= Math.round(niceStep * corr) / corr; // 도메인 간격만큼 하한 확장
+  }
+
+  // limitMin / limitMax 로 한번 더 clamp (배수 유지)
+  if (typeof limitMin === "number" && niceMin < limitMin) {
+    niceMin = Math.ceil(limitMin / niceStep) * niceStep;
+  }
+  if (typeof limitMax === "number" && niceMax > limitMax) {
+    niceMax = Math.floor(limitMax / niceStep) * niceStep;
+  }
+
+  // ticks 생성
+  let ticksArr: number[] = [];
+  for (let v = niceMin; v <= niceMax + 1e-8; v += niceStep) {
+    ticksArr.push(v);
+  }
+
+  // --- tick 개수 보정 루프 (과다/과소 시 step 증감) -----------------------------
+  // tick 수가 목표보다 많으면 step 을 두 배씩 늘려가며 재계산
+  while (ticksArr.length > length) {
+    niceStep *= 2;
+    ticksArr = [];
+    for (let v = niceMin; v <= niceMax + 1e-8; v += niceStep) {
+      ticksArr.push(v);
+    }
+  }
+
+  // tick 이 여전히 부족하면 step 을 반복적으로 절반으로 줄여보고,
+  // 그때마다 niceMax 를 다시 계산해 domain 을 데이터 상한에 가깝게 조정한다
+  while (ticksArr.length < length) {
+    niceStep /= 2;
+    if (niceStep < 1e-8) break; // 안전장치: 너무 작은 step 방지
+
+    // 상한을 최신 step 에 맞춰 다시 산출
+    niceMax = Math.ceil(max / niceStep) * niceStep;
+
+    // 새로운 tick 배열 생성
+    ticksArr = [];
+    for (let v = niceMin; v <= niceMax + 1e-8; v += niceStep) {
+      ticksArr.push(v);
+    }
+
+    // 과도하게 많아지면 루프 종료
+    if (ticksArr.length > length * 2) break;
+  }
+
+  // ---------------------------------------------------------------------------
+  // 5) 자리수 반올림 및 중복 제거
+  // ---------------------------------------------------------------------------
+  // 자리수(digit) 반올림
+  if (typeof digit === "number") {
+    const pow = Math.pow(10, digit);
+    ticksArr = ticksArr.map(v => Math.round(v * pow) / pow);
+    // 동일 값 중복 제거
+    ticksArr = [...new Set(ticksArr)];
+  }
+
+  // 1·5·0 검증: 실패하면 pad=0 으로 한번 더 시도
+  const bad = ticksArr.some(t => {
+    const d = Math.abs(t) % 10;
+    return d !== 1 && d !== 5 && d !== 0;
+  });
+  // 규칙 검증 실패 시 pad=0 으로 한 번 더 계산
+  if (bad && pad !== 0) {
+    return getChartYTicks({
+      data,
+      length,
+      pad: 0,
+      limitMin,
+      limitMax,
+      digit,
+      outliers,
+      log,
+    });
+  }
+
+  return ticksArr;
+};
+
+/**
+ * 차트 유틸리티; 소숫점 자리수 추출
+ * @util
+ * @param {unknown} v - 값
+ * @returns {number} - 소숫점 자리수
+ */
+export const getDecimalIndex = (v: unknown): number =>
+  !isNaN(Number(v)) && String(v).includes(".")
+    ? String(v)
+        .split(".")[1]
+        .split("")
+        .findIndex(d => Number(d) !== 0) + 1
+    : 0;
+
+/**
+ * 차트 유틸리티; X축 텍스트 속성
+ * @util
+ * @param {RechartsXAxisTickProps} props - X축 속성
+ * @returns {SVGAttributes<SVGTextElement>} - X축 텍스트 속성
+ */
+export const getXAxisTextAttr = (
+  props: RechartsXAxisTickProps,
+): SVGAttributes<SVGTextElement> => {
+  const {
+    width,
+    height,
+    x,
+    y,
+    stroke,
+    fill,
+    orientation,
+    textAnchor,
+    transform,
+    // verticalAnchor,
+    // 추가 기본 정보; index, visibleTicksCount,
+    // index,
+    // payload - 각 x의 y 데이터; coordinate, value, index, offset, tickCoord, isShow
+  } = props;
+
+  // <text> 기본 속성
+  return {
+    width,
+    height,
+    x,
+    y,
+    stroke,
+    fill,
+    textAnchor,
+    orientation,
+    transform,
+  };
+};

package/src/functions/convert.ts

@@ -0,0 +1,229 @@
+import { isValidDateType } from "./validation";
+import { dateFormat } from "./format";
+import { consoleLog } from "./log";
+
+/**
+ * 데이터를 스트링으로 변환
+ * @util
+ * @param {unknown} value
+ * @return {string}
+ */
+export const string = (value: unknown): string => {
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+};
+
+/**
+ * 세션/로컬 스토리지 데이터 parsing
+ * @util
+ * @param {string} data 세션/로컬 스토리지 데이터
+ * @return {unknown}
+ */
+export const parseData = (data: string): unknown => {
+  // 괄호 여부 -> object | array
+  if (/^(\{|\[)/.test(data)) return JSON.parse(data);
+  // 숫자 여부 -> number
+  else if (!isNaN(Number(data))) return Number(data);
+  // 불리언 여부 -> boolean
+  else if (data === "true" || data === "false") return JSON.parse(data);
+  // undefined
+  else if (data === "undefined") return undefined;
+
+  return data; // string
+};
+
+/**
+ * 키체인에 해당하는 데이터 추출
+ * @util
+ * @param {unknown} data 세션/로컬 스토리지 데이터
+ * @param {string} keyChain 키체인
+ * @return {unknown}
+ */
+export const getValueByKeyChain = (
+  data: unknown,
+  keyChain: string,
+): unknown => {
+  // 객체 여부 판단
+  const isObject = (targetData: unknown): boolean =>
+    typeof targetData === "object" &&
+    !Array.isArray(targetData) &&
+    targetData !== null &&
+    typeof targetData !== "function"
+      ? true
+      : false;
+
+  // 프로퍼티를 가진 객체인지 확인
+  if (isObject(data)) {
+    // 키 체인이 남았는지 확인
+    const firstChainIndex: number = keyChain.indexOf(".");
+    if (firstChainIndex === -1)
+      return (data as Record<string, unknown>)[keyChain];
+
+    // 키 체인이 끝나지 않은 경우
+    const currentKey: string = keyChain.slice(0, firstChainIndex);
+    const remainKeyChain: string = keyChain.slice(firstChainIndex + 1);
+    const foundData = (data as Record<string, unknown>)[currentKey];
+    return isObject(foundData)
+      ? getValueByKeyChain(foundData, remainKeyChain)
+      : undefined;
+  }
+
+  return data;
+};
+
+/**
+ * object -> URLSearchParams 데이터 변환
+ * @param {unknown} data
+ * @return {URLSearchParams | string}
+ */
+export const convertObjectToSearchParams = (data: unknown): URLSearchParams => {
+  if (!data) {
+    consoleLog("[convertObjectToSearchParams] 데이터가 유효하지 않음", {
+      data,
+    });
+    return new URLSearchParams();
+  }
+  // searchParams 여부 체크
+  const isSearchParams = data instanceof URLSearchParams;
+  if (isSearchParams) {
+    // consoleLog(
+    //   "[convertObjectToSearchParams] 이미 URLSearchParams 상태로 확인됨",
+    //   {
+    //     data,
+    //   },
+    // );
+    return data;
+  }
+
+  // 객체 여부 판단
+  const isObject =
+    typeof data === "object" &&
+    !Array.isArray(data) &&
+    Object.keys(data).length > 0;
+
+  if (isObject) {
+    const d = Object.fromEntries(
+      Object.entries(data as Record<string, unknown>).map(([key, value]) => [
+        key,
+        string(value),
+      ]),
+    );
+    return new URLSearchParams(d);
+  }
+
+  consoleLog("[convertObjectToSearchParams] 데이터가 객체가 아님", {
+    data,
+    type: typeof data,
+    key: Object.keys(data),
+    array: Array.isArray(data),
+  });
+  return new URLSearchParams();
+};
+
+// /**
+//  * 배열 추가형 입력 테이블 register rule 필터링
+//  * @util
+//  * @param {RegisterOptionsType} ruleCollection
+//  * @param {boolean} isActive
+//  * @return {RegisterOptionsType}
+//  */
+// export function getFieldArrayValidOptions(
+//   ruleCollection: RegisterOptionsType,
+//   isActive: boolean,
+// ): RegisterOptionsType {
+//   const entries = Object.entries(ruleCollection);
+//   const filtered = entries.map(([dataName, rule]) => {
+//     const ruleEntries = Object.entries(rule).filter(
+//       ([ruleKey]) => ruleKey !== "required",
+//     );
+//     return [dataName, Object.fromEntries(ruleEntries)];
+//   });
+
+//   return isActive ? ruleCollection : Object.fromEntries(filtered);
+// }
+
+/**
+ * 텍스트 capitalize 첫글자 대문자 변환
+ * @util
+ * @param {string} value 텍스트
+ * @return {string}
+ */
+export const capitalize = (value: string): string => {
+  const first = value.charAt(0).toUpperCase();
+  const others = value.slice(1);
+  return `${first}${others}`;
+};
+
+/**
+ * kg -> g 변환
+ * @util
+ * @param {number | string} kg
+ * @return {number} gram
+ */
+export const covertGram = (kg: number | string): number => Number(kg) * 1000;
+
+/**
+ * g -> kg 변환
+ * @util
+ * @param {number | string} gram
+ * @return {number} kg
+ */
+export const covertKilogram = (gram: number | string): number =>
+  Number(gram) / 1000;
+
+/**
+ * ml -> L 변환
+ * @util
+ * @param {number | string} ml
+ * @return {number} liter
+ */
+export const convertLiter = (ml: number | string): number => Number(ml) / 1000;
+
+/**
+ * L -> ml 변환
+ * @util
+ * @param {number | string} liter
+ * @return {number} ml
+ */
+export const convertMilliliter = (liter: number | string): number =>
+  Number(liter) * 1000;
+
+/**
+ * 데이터 가공
+ * @util
+ * @param {unknown} value
+ * @return {unknown}
+ * @desc
+ * - 빈칸 또는 줄바꿈 텍스트 모두 제거
+ * - 날짜 데이터 yyyy-mm-ddTHH:MM:SS 변환
+ */
+export function extractCoreValue<TOriginType>(value: TOriginType): TOriginType {
+  if (isValidDateType(value)) return dateFormat(value) as TOriginType;
+  if (typeof value === "string")
+    return value.replace(/[\s\n\t]+/g, "") as TOriginType;
+  return value;
+}
+
+/**
+ * 자연수로 된 숫자를, 지정된 자리수만큼 0을 채워서 반환
+ * @util
+ * @param {number} v 소수점 제외
+ * @param {number} [digitLength] 자릿수 (기본값 2)
+ * @return {string}
+ */
+export function convertDigit(v: number, digitLength: number = 2): string {
+  const valueLength = String(Math.floor(v)).length;
+  const restLength = digitLength - valueLength;
+  const fill = Array(restLength).fill(0).join("");
+
+  return `${fill}${v}`;
+}
+
+/**
+ * 날짜 시간을 2-digit으로 맞춤
+ * @util
+ * @param {number} date_time
+ * @return {string}
+ */
+export const convert2Digit = (date_time: number): string =>
+  date_time < 10 ? `0${date_time}` : String(date_time);

package/src/functions/crypto.ts

@@ -0,0 +1,44 @@
+// import CryptoJS from "crypto-js";
+// import { parseData } from "./convert";
+
+// /**
+//  * CryptoJS; 암호화
+//  * @util
+//  * @param {unknown} value 암호화할 데이터
+//  * @return {string | Error} 암호화 데이터 | 키 정보 없음
+//  */
+// export const encrypt = (value: unknown): string | Error => {
+//   const kluchi = process.env.NEXT_PUBLIC_KLUCHI ?? undefined;
+//   if (!kluchi) return new Error("환경변수를 확인하세요.");
+
+//   // 데이터 stringify
+//   const stringified =
+//     typeof value === "object" ? JSON.stringify(value) : String(value);
+
+//   // 데이터 암호화
+//   return CryptoJS.AES.encrypt(stringified, kluchi).toString();
+// };
+
+// /**
+//  * CryptoJS; 복호화
+//  * @util
+//  * @param {string} value 암호화된 데이터
+//  * @return {unknown} 복호화 데이터
+//  */
+// export function decrypt<ExpectType>(value: string): ExpectType | Error {
+//   const kluchi = process.env.NEXT_PUBLIC_KLUCHI ?? undefined;
+//   if (!kluchi) return new Error("환경변수를 확인하세요.");
+//   if (typeof value !== "string") return new Error("데이터를 찾을 수 없습니다.");
+
+//   try {
+//     // 데이터 복호화
+//     const decrypted = CryptoJS.AES.decrypt(value, kluchi).toString(
+//       CryptoJS.enc.Utf8,
+//     );
+
+//     // 데이터 파싱을 통해 복원
+//     return parseData(decrypted) as ExpectType;
+//   } catch (error) {
+//     throw new Error(`데이터 복호화에 실패하였습니다. (${error})`);
+//   }
+// }