jordy 0.15.0 → 0.16.0

package/esm5/types/index.js

@@ -1,3 +1,4 @@
 export * from './component.type';
 export * from './etc.type';
 export * from './marshalling.type';
+export * from './time.type';

package/esm5/types/time.type.js

@@ -0,0 +1 @@
+export {};

package/esm5/util/collection.js

@@ -1,4 +1,5 @@
 import { __read, __spreadArray } from "tslib";
+import equalFn from 'fast-deep-equal/es6';
 export function reorder(list, startIndex, endIndex) {
     var result = __spreadArray([], __read(list), false);
     var _a = __read(result.splice(startIndex, 1), 1), removed = _a[0];
@@ -15,3 +16,25 @@ export function remove(list, index) {
     copied.splice(index, 1);
     return copied;
 }
+export function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+export var deepEqual = equalFn;
+export function createMemoize() {
+    var prevData = null;
+    var fn = function memorize(data) {
+        if (!prevData) {
+            prevData = data;
+            return data;
+        }
+        if (deepEqual(prevData, data)) {
+            return prevData;
+        }
+        prevData = data;
+        return data;
+    };
+    fn.clear = function () {
+        prevData = null;
+    };
+    return fn;
+}

package/esm5/util/index.js

@@ -12,5 +12,7 @@ export * from './redux';
 export * from './template';
 export * from './libLoader';
 export * from './AsyncQueue';
+export * from './refine';
+export * from './time';
 var isServer = envCheck.isServer;
 export { envCheck, isServer };

package/esm5/util/refine.js

@@ -0,0 +1,62 @@
+import { __assign } from "tslib";
+import { isValidDateStr, createDateRangeByType, addMonthsByPredefined, } from './time';
+export function createEnumRefiner(enumType, def) {
+    var enumList = Array.isArray(enumType) ? enumType : Object.values(enumType);
+    return function refineForEnum(target) {
+        if (enumList.includes(target)) {
+            return target;
+        }
+        return def;
+    };
+}
+export function createPageSizeRefiner(sizeList, defaultIndex) {
+    if (defaultIndex === void 0) { defaultIndex = 0; }
+    return createEnumRefiner(sizeList, sizeList[defaultIndex]);
+}
+export function refinePageNumber(raw) {
+    var page = Math.floor(Math.abs(Number(raw || 1)));
+    if (Number.isFinite(page) && page > 0) {
+        return page;
+    }
+    return 1;
+}
+export function refineToRestrictedDateRange(dateRange, maxType, defType) {
+    var result = __assign({}, dateRange);
+    result.gte = isValidDateStr(result.gte) ? result.gte : '';
+    result.lte = isValidDateStr(result.lte) ? result.lte : '';
+    if (!result.gte || !result.lte) {
+        if (defType) {
+            var tmp = createDateRangeByType(defType);
+            result.gte = tmp.gte;
+            result.lte = tmp.lte;
+        }
+        return result;
+    }
+    var maxMonth = addMonthsByPredefined(result.gte, maxType);
+    if (result.lte > maxMonth) {
+        result.lte = maxMonth;
+    }
+    else if (result.lte < result.gte) {
+        result.lte = result.gte;
+    }
+    return result;
+}
+function refineDate(value, def) {
+    if (!isValidDateStr(value)) {
+        return def;
+    }
+    return value;
+}
+export function refineDateRange(dateRange, preset) {
+    if (preset === void 0) { preset = 'month'; }
+    var def = createDateRangeByType(preset);
+    if (!dateRange || !dateRange.gte || !dateRange.lte) {
+        return def;
+    }
+    var gte = refineDate(dateRange.gte, def.gte);
+    var lte = refineDate(dateRange.lte, def.lte);
+    return {
+        gte: gte,
+        lte: lte,
+    };
+}

package/esm5/util/time.js

@@ -0,0 +1,217 @@
+import { isString } from './typeCheck';
+export var MAX_MONTH_LOOKUP_TABLE = {
+    month: 1,
+    threeMonths: 3,
+    sixMonths: 6,
+};
+function padZero(num) {
+    return num.toString().padStart(2, '0');
+}
+export function dateFormat(date, delimiter) {
+    if (delimiter === void 0) { delimiter = '-'; }
+    var year = date.getFullYear();
+    var month = date.getMonth() + 1;
+    var dates = date.getDate();
+    return "".concat(year).concat(delimiter).concat(padZero(month)).concat(delimiter).concat(padZero(dates));
+}
+export function getToday(todayRef) {
+    if (todayRef === void 0) { todayRef = new Date(); }
+    var dateToday = new Date(todayRef);
+    var today = dateFormat(dateToday);
+    return today;
+}
+export function getBeforeMonthAt(months, todayRef) {
+    if (months === void 0) { months = 1; }
+    if (todayRef === void 0) { todayRef = new Date(); }
+    var beforeMonth;
+    if (todayRef.getMonth() - months === 1) {
+        var dateFeb = new Date(todayRef);
+        dateFeb.setDate(1);
+        dateFeb.setMonth(2);
+        dateFeb.setDate(0);
+        if (dateFeb.getDate() < todayRef.getDate()) {
+            beforeMonth = dateFormat(dateFeb);
+            return beforeMonth;
+        }
+    }
+    var dateBeforeMonth = new Date(todayRef);
+    dateBeforeMonth.setMonth(dateBeforeMonth.getMonth() - months);
+    beforeMonth = dateFormat(dateBeforeMonth);
+    return beforeMonth;
+}
+export function addDays(date, days) {
+    if (isString(date)) {
+        return addDays(new Date(date), days);
+    }
+    var after = new Date(date);
+    after.setDate(after.getDate() + days);
+    return dateFormat(after);
+}
+function getYesterday(todayRef) {
+    if (todayRef === void 0) { todayRef = new Date(); }
+    return addDays(todayRef, -1);
+}
+function getBeforeWeek(todayRef) {
+    if (todayRef === void 0) { todayRef = new Date(); }
+    return addDays(todayRef, -7);
+}
+function getAfterTwoWeeks(todayRef) {
+    if (todayRef === void 0) { todayRef = new Date(); }
+    return addDays(todayRef, 14);
+}
+export function toPredefinedDateRangeType(gte, lte, todayRef) {
+    if (todayRef === void 0) { todayRef = new Date(); }
+    if (!gte || !lte) {
+        return '';
+    }
+    var today = getToday(todayRef);
+    if (gte === today && lte === today) {
+        return 'today';
+    }
+    var yesterday = getYesterday(todayRef);
+    if (gte === yesterday && lte === yesterday) {
+        return 'yesterday';
+    }
+    var beforeWeek = getBeforeWeek(todayRef);
+    if (gte === beforeWeek && lte === today) {
+        return 'week';
+    }
+    var beforeMonth = getBeforeMonthAt(1, todayRef);
+    if (gte === beforeMonth && lte === today) {
+        return 'month';
+    }
+    var before3Months = getBeforeMonthAt(3, todayRef);
+    if (gte === before3Months && lte === today) {
+        return 'threeMonths';
+    }
+    var before6Months = getBeforeMonthAt(6, todayRef);
+    if (gte === before6Months && lte === today) {
+        return 'sixMonths';
+    }
+    var beforeYear = getBeforeMonthAt(12, todayRef);
+    if (gte === beforeYear && lte === today) {
+        return 'year';
+    }
+    var afterTwoWeeks = getAfterTwoWeeks(todayRef);
+    if (gte === beforeMonth && lte === afterTwoWeeks) {
+        return 'calcDefRange';
+    }
+    return '';
+}
+var converter = {
+    today: function (todayRef) {
+        var today = getToday(todayRef);
+        return {
+            gte: today,
+            lte: today,
+        };
+    },
+    yesterday: function (todayRef) {
+        var yesterday = getYesterday(todayRef);
+        return {
+            gte: yesterday,
+            lte: yesterday,
+        };
+    },
+    week: function (todayRef) {
+        var today = getToday(todayRef);
+        var beforeWeek = getBeforeWeek(todayRef);
+        return {
+            gte: beforeWeek,
+            lte: today,
+        };
+    },
+    month: function (todayRef) {
+        var today = getToday(todayRef);
+        var beforeMonth = getBeforeMonthAt(1, todayRef);
+        return {
+            gte: beforeMonth,
+            lte: today,
+        };
+    },
+    threeMonths: function (todayRef) {
+        var today = getToday(todayRef);
+        var beforeMonth = getBeforeMonthAt(3, todayRef);
+        return {
+            gte: beforeMonth,
+            lte: today,
+        };
+    },
+    sixMonths: function (todayRef) {
+        var today = getToday(todayRef);
+        var beforeMonth = getBeforeMonthAt(6, todayRef);
+        return {
+            gte: beforeMonth,
+            lte: today,
+        };
+    },
+    year: function (todayRef) {
+        var today = getToday(todayRef);
+        var beforeMonth = getBeforeMonthAt(12, todayRef);
+        return {
+            gte: beforeMonth,
+            lte: today,
+        };
+    },
+    calcDefRange: function (todayRef) {
+        var beforeMonth = getBeforeMonthAt(1, todayRef);
+        var afterTwoWeeks = getAfterTwoWeeks(todayRef);
+        return {
+            gte: beforeMonth,
+            lte: afterTwoWeeks,
+        };
+    },
+    '': function () { return ({ gte: '', lte: '' }); },
+};
+export function createDateRangeByType(predefinedType, todayRef) {
+    if (todayRef === void 0) { todayRef = new Date(); }
+    if (!predefinedType) {
+        return {
+            gte: '',
+            lte: '',
+        };
+    }
+    return converter[predefinedType](todayRef);
+}
+export function addMonths(date, months) {
+    if (isString(date)) {
+        return addMonths(new Date(date), months);
+    }
+    var after = new Date(date);
+    after.setMonth(after.getMonth() + months);
+    if (after.getDate() !== date.getDate()) {
+        after.setDate(0);
+    }
+    return dateFormat(after);
+}
+export function addMonthsByPredefined(date, type) {
+    return addMonths(date, MAX_MONTH_LOOKUP_TABLE[type]);
+}
+export function isValidDateStr(value) {
+    if (!value || !isString(value) || value.length !== 10) {
+        return false;
+    }
+    if (/^[0-9]{4}-[0-1][0-9]-[0-3][0-9]$/.test(value) === false) {
+        return false;
+    }
+    try {
+        return dateFormat(new Date(value)) === value;
+    }
+    catch (error) {
+        return false;
+    }
+}
+export function changeDateFormat(dateStr, showSeconds) {
+    if (showSeconds === void 0) { showSeconds = true; }
+    if (!dateStr || dateStr.length < 19) {
+        return '';
+    }
+    return "".concat(dateStr.substring(0, 10), " ").concat(dateStr.substring(11, showSeconds ? 19 : 16));
+}
+export function changeDateTimeFormatWithOffset(value, isLessThenEqual) {
+    if (isLessThenEqual === void 0) { isLessThenEqual = false; }
+    if (isLessThenEqual) {
+        return "".concat(value, "T23:59:59+09:00");
+    }
+    return "".concat(value, "T00:00:00+09:00");
+}

package/libs/types/index.d.ts

@@ -1,3 +1,4 @@
 export * from './component.type';
 export * from './etc.type';
 export * from './marshalling.type';
+export * from './time.type';

package/libs/types/time.type.d.ts

@@ -0,0 +1,16 @@
+export declare type PredefinedMaxMonthType = 'month' | 'threeMonths' | 'sixMonths';
+export declare type PredefinedDateRangeType = '' | 'yesterday' | 'today' | 'week' | 'month' | 'threeMonths' | 'sixMonths' | 'year' | 'calcDefRange';
+export interface DateRangeDto {
+    /**
+     * 시작날짜
+     *
+     * yyyy-mm-dd 형식
+     */
+    gte: string;
+    /**
+     * 종료날짜
+     *
+     * yyyy-mm-dd 형식
+     */
+    lte: string;
+}

package/libs/util/collection.d.ts

@@ -1,3 +1,7 @@
+interface MemoizeFunction<T> {
+    (data: T): T;
+    clear(): void;
+}
 /**
  * 주어진 배열내 특정 2가지 요소에 대하여 서로 순서를 뒤바꾼다.
  *
@@ -23,3 +27,54 @@ export declare function update<T>(list: T[], index: number, item: T): T[];
  * @returns
  */
 export declare function remove<T>(list: T[], index: number): T[];
+/**
+ * 특정 객체에 제시되는 키 값이 실제 키로 쓰이는지를 검사한다.
+ * @param obj 확인 할 객체
+ * @param key 확인 할 키값
+ * @returns
+ */
+export declare function hasOwn<T extends Record<string | number | symbol, any>>(obj: T, key: string | number | symbol): key is keyof T;
+/**
+ * 두 객체가 가진 필드값을 직접 비교한다.
+ *
+ * @see https://github.com/epoberezkin/fast-deep-equal
+ */
+export declare const deepEqual: (a: any, b: any) => boolean;
+/**
+ * 특정 데이터에 대하여 깊은 비교(deep equality)를 활용하는 메모이즈 함수를 만든다.
+ *
+ * @example
+ * interface SampleDto {
+ *   name: string;
+ *   age: number;
+ * }
+ *
+ * const memoize = createMemoize<SampleDto>();
+ * const prev: SampleDto = { name: '룩핀', age: 10 };
+ * const next: SampleDto = { name: '룩핀', age: 10 };
+ *
+ * // next 와 prev 는 서로 다른 인스턴스 이므로 다르다.
+ * console.log(prev === next); // false
+ *
+ * const first = memoize(prev);
+ *
+ * console.log(first === prev); // true
+ *
+ * const second = memoize(next);
+ *
+ * // next 값이 prev 값과 완전 동일하므로 이전값을 대신 반환한다.
+ * console.log(second === next); // false
+ * console.log(second === prev); // true
+ *
+ * const third = memoize({ name: '룩핀만세', age: 7 });
+ *
+ * // 새로운 값은 이전과 동일하지 않으므로 새로운 값을 대신 반환한다.
+ * console.log(third === prev); // false
+ * console.log(third); // { name: '룩핀만세', age: 7 }
+ *
+ * @returns 메모이즈 함수
+ *
+ * @see https://github.com/epoberezkin/fast-deep-equal
+ */
+export declare function createMemoize<T>(): MemoizeFunction<T>;
+export {};

package/libs/util/index.d.ts

@@ -12,5 +12,7 @@ export * from './redux';
 export * from './template';
 export * from './libLoader';
 export * from './AsyncQueue';
+export * from './refine';
+export * from './time';
 declare const isServer: () => boolean;
 export { envCheck, isServer };

package/libs/util/refine.d.ts

@@ -0,0 +1,86 @@
+import { DateRangeDto, PredefinedMaxMonthType, PredefinedDateRangeType } from '../types';
+/**
+ * 데이터 정제기를 만든다.
+ *
+ * @example
+ * enum MyEnum {
+ *   FASHION = 'f',
+ *   STYLE = 's',
+ *   LOOK = 'look',
+ *   PIN = 'P'
+ * }
+ *
+ * const refine = createEnumRefiner(MyEnum, MyEnum.LOOK);
+ * const result = refine('anything');
+ *
+ * console.log(result); // 'look'
+ *
+ * @param enumType 열거형
+ * @param def 범위에 속하지 않을 때 내보낼 기본값
+ * @returns
+ */
+export declare function createEnumRefiner<T>(enumType: Record<string, unknown>, def: T): (target: unknown) => T;
+/**
+ * 데이터 정제기를 만든다.
+ *
+ * @example
+ * const LIST = ['가', '나', '다'];
+ *
+ * const refine = createEnumRefiner(LIST, LIST[2]);
+ * const result = refine('anything');
+ *
+ * console.log(result); // '다'
+ *
+ * @param list 상수값 배열
+ * @param def 범위에 속하지 않을 때 내보낼 기본값
+ * @returns
+ */
+export declare function createEnumRefiner<T>(list: T[], def: T): (target: unknown) => T;
+/**
+ * 페이지 사이즈에 대한 정제기를 만든다.
+ *
+ * @example
+ *
+ * const refine = createPageSizeRefiner([10, 20, 30]);
+ * let result = refine(100);
+ *
+ * console.log(result); // 10
+ *
+ * result = refine('20');
+ *
+ * console.log(result); // 20
+ *
+ * @param sizeList
+ * @param defaultIndex 기본 0
+ * @returns
+ */
+export declare function createPageSizeRefiner(sizeList: number[], defaultIndex?: number): (target: unknown) => number;
+/**
+ * 페이지 번호를 정제한다.
+ *
+ * 0보다 큰 양의 정수만 통과시킨다. (문자열 입력 가능)
+ *
+ * const result = refinePageNumber('-1');
+ *
+ * console.log(result); // 1
+ * @param raw
+ * @returns
+ */
+export declare function refinePageNumber(raw: unknown): number;
+/**
+ * 제한된 기준으로 날짜범위값을 정제한다.
+ *
+ * 범위 기준은 DateRange->gte (시작날짜) 이다.
+ * @param dateRange 정제할 날짜범위 객체
+ * @param maxType 정제 허용 최대 범위. 1달, 3달, 6달 중 1가지
+ * @param defType 날짜범위 내용 중 하나라도 비었을 경우 기본적으로 만들어 줄 날짜 범위 유형
+ * @returns
+ */
+export declare function refineToRestrictedDateRange<T extends DateRangeDto>(dateRange: T, maxType: PredefinedMaxMonthType, defType?: PredefinedDateRangeType): T;
+/**
+ * 날짜범위를 지정된 규칙에 따라 정제한다.
+ * @param dateRange 정제할 날짜범위 값.
+ * @param preset 지정할 규칙
+ * @returns
+ */
+export declare function refineDateRange(dateRange: Partial<DateRangeDto> | Record<string, string> | undefined | null, preset?: PredefinedDateRangeType): DateRangeDto;

package/libs/util/time.d.ts

@@ -0,0 +1,51 @@
+import { DateRangeDto, PredefinedDateRangeType, PredefinedMaxMonthType } from '../types';
+export declare const MAX_MONTH_LOOKUP_TABLE: Record<PredefinedMaxMonthType, number>;
+/**
+ * yyyy-MM-dd 형식의 날짜 문자열로 바꾼다.
+ * @param date
+ * @param delimiter
+ * @returns
+ */
+export declare function dateFormat(date: Date, delimiter?: string): string;
+/**
+ * yyyy-MM-dd 형식의 오늘 날짜 문자열을 가져온다.
+ * @param todayRef
+ * @returns
+ */
+export declare function getToday(todayRef?: Date): string;
+export declare function getBeforeMonthAt(months?: number, todayRef?: Date): string;
+export declare function addDays(date: Date | string, days: number): string;
+export declare function toPredefinedDateRangeType(gte: string, lte: string, todayRef?: Date): PredefinedDateRangeType;
+export declare function createDateRangeByType(predefinedType: PredefinedDateRangeType, todayRef?: Date): DateRangeDto;
+export declare function addMonths(date: Date | string, months: number): string;
+export declare function addMonthsByPredefined(date: string, type: PredefinedMaxMonthType): string;
+/**
+ * 문자열값이 날짜형식(yyyy-MM-dd)에 맞는지 검사한다.
+ * @param value
+ * @returns
+ */
+export declare function isValidDateStr(value?: unknown): value is string;
+/**
+ * UTC로 작성된 날짜 포멧을 "yyyy-MM-dd hh:mm:ss" 포멧으로 바꿔준다.
+ *
+ * showSeconds 를 false 로 줄 경우 "yyyy-MM-dd hh:mm" 포멧으로 바꾼다.
+ * @param dateStr
+ * @param showSeconds 초단위 표현 여부. 기본 true
+ * @returns
+ */
+export declare function changeDateFormat(dateStr: string, showSeconds?: boolean): string;
+/**
+ * yyyy-MM-dd 형식의 날짜에 offset 을 추가하여 datetime 포멧으로 바꾼다.
+ *
+ * - 주로 외부와 날짜 형식을 맞춰줘야 할 때 쓰인다.
+ *
+ * @example
+ *
+ * const result = changeDateTimeFormatWithOffset('2022-06-01');
+ *
+ * console.log(result); // 2022-06-01T00:00:00+09:00
+ * @param value 변경할 날짜 데이터
+ * @param isLessThenEqual true 로 줄 경우 시간을 23:59:59 로 바꿔서 준다. 기본 false.
+ * @returns
+ */
+export declare function changeDateTimeFormatWithOffset(value: string, isLessThenEqual?: boolean): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jordy",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "typescript based frontend toolkit",
   "repository": {
     "type": "git",