@powfix/core-js 0.19.0 → 0.19.2

package/dist/node/esm/shared/services/time/TimeService.mjs

@@ -16,9 +16,11 @@ export class TimeService extends EventEmitter {
     }
     constructor(options) {
         super();
+        // Options
         this.syncInterval = options === null || options === void 0 ? void 0 : options.syncInterval;
         this.clientTimeProvider = options === null || options === void 0 ? void 0 : options.clientTimeProvider;
         this.serverTimeProvider = options === null || options === void 0 ? void 0 : options.serverTimeProvider;
+        // Bind
         this.sync = this.sync.bind(this);
         this.fetchServerNTPResult = this.fetchServerNTPResult.bind(this);
     }
@@ -45,6 +47,7 @@ export class TimeService extends EventEmitter {
     }
     setSyncInterval(interval) {
         this.syncInterval = interval;
+        // Emit
         this.emit('SYNC_INTERVAL_CHANGED', interval);
         if (this.syncHandler !== undefined) {
             this.stopSync();
@@ -99,22 +102,32 @@ export class TimeService extends EventEmitter {
     sync() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                // T1 (Client Request Time)
                 const requestedAt = Date.now();
+                // Fetch server time from server
                 const serverNtpResult = yield this.fetchServerNTPResult(requestedAt);
+                // Check is null
                 if (serverNtpResult === null) {
                     console.warn(LOG_TAG, 'Failed to get server time');
                     return null;
                 }
+                // T2 (Server Receive Time)
                 const { t2 } = serverNtpResult;
+                // Check is not a number
                 if (isNaN(Number(t2))) {
+                    // Not a Number
                     console.error(LOG_TAG, 'invalid server time(t2), not a number', t2);
                     return null;
                 }
+                // T3 (Server Transmit Time)
                 const { t3 } = serverNtpResult;
+                // Check is not a number
                 if (isNaN(Number(t3))) {
+                    // Not a Number
                     console.error(LOG_TAG, 'invalid server time(t2), not a number', t2);
                     return null;
                 }
+                // T4 (Client Receive Time)
                 const receivedAt = Date.now();
                 const ntpResult = {
                     t1: requestedAt,
@@ -122,8 +135,11 @@ export class TimeService extends EventEmitter {
                     t3: t3,
                     t4: receivedAt,
                 };
+                // Calculate offset
                 const offset = TimeService.calculateNTPResultOffset(ntpResult);
+                // Save calculated offset
                 this.setOffset(offset);
+                // Mark synced timestamp
                 const syncedAt = Date.now();
                 this.setSyncedAt(syncedAt);
                 this.emit('SYNCED', offset, syncedAt);

package/dist/node/esm/shared/utils/ArrayUtils.mjs

@@ -3,6 +3,11 @@ export class ArrayUtils {
     static castArray(value) {
         return castArray(value);
     }
+    /**
+     * 객체를 요소로 가지는 배열에서 가장 큰 값(Property)를 가지는 객체를 반환한다
+     * @param e 객체 배열
+     * @param key 값을 비교할 Property 키
+     */
     static getGreatestObject(e, key) {
         return e.reduce((prev, current) => ((prev[key] > current[key] ? prev : current)));
     }

package/dist/node/esm/shared/utils/AxiosUtils.mjs

@@ -13,6 +13,7 @@ export class AxiosUtils {
                         return e;
                     }
                 }
+                // There is no any values having string type
                 return null;
             }
             else {
@@ -35,6 +36,7 @@ export class AxiosUtils {
                         return e;
                     }
                 }
+                // There is no any values having string type
                 return null;
             }
             else {

package/dist/node/esm/shared/utils/Calc.mjs

@@ -14,7 +14,7 @@ export class Calc {
         const len = values.length;
         if (len === 0)
             return NaN;
-        const sorted = values.slice().sort((a, b) => a - b);
+        const sorted = values.slice().sort((a, b) => a - b); // O(n log n)
         const mid = len >> 1;
         return len % 2 === 0
             ? (sorted[mid - 1] + sorted[mid]) / 2

package/dist/node/esm/shared/utils/DateUtils.mjs

@@ -100,6 +100,7 @@ export class DateUtils {
     }
 }
 DateUtils.relativeDate = (input, base = Date.now()) => {
+    // Create new moment instance to apply new locale
     const datetime = moment.isMoment(input) ? moment(input.toDate()) : moment(input);
     if (!datetime.isValid()) {
         console.error('core-js:DateUtils.relativeDate() datetime is invalid', datetime);

package/dist/node/esm/shared/utils/JuminNumberUtils.mjs

@@ -16,9 +16,10 @@ export class JuminNumberUtils {
         if (replacedJuminNumber.length !== 13) {
             return false;
         }
+        // 연도에 해당하는 숫자와 성별에 해당하는 숫자 비교
         const TODAY_YEAR = parseInt(new Date().getFullYear().toString().slice(-2), 10);
         const yearNum = parseInt(replacedJuminNumber.slice(0, 2), 10);
-        const sexNum = replacedJuminNumber.slice(6, 7);
+        const sexNum = replacedJuminNumber.slice(6, 7); // 대시 있는경우 7로 변경
         if (sexNum === '1' || sexNum === '2') {
             if (yearNum < TODAY_YEAR)
                 return false;
@@ -29,9 +30,11 @@ export class JuminNumberUtils {
         }
         else
             return false;
+        // 월과 일에 해당하는 숫자 조건 검사 (정규식으로)
         const regex = /^\d{2}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|3[0-1])\d{7}$/;
         if (!regex.test(replacedJuminNumber))
             return false;
+        // Validation X
         const currentX = parseInt(replacedJuminNumber.slice(-1), 10);
         const calculatedX = JuminNumberUtils.calculateX(replacedJuminNumber);
         if (currentX !== calculatedX) {

package/dist/node/esm/shared/utils/Sequencer.mjs

@@ -28,9 +28,11 @@ export class Sequencer {
         this.sequences = [];
         this.status = SequencerStatus.IDLE;
         this.minimumExecutionTime = 0;
+        // Reset variables task is done
         this.currentSequence = null;
         this.startTimestamp = null;
         this.endTimestamp = null;
+        // Emitter
         this.eventEmitter = new EventEmitter3();
         this.pushSequence = (sequence) => {
             this.sequences.push(sequence);
@@ -49,6 +51,7 @@ export class Sequencer {
                 console.log('Currently total execution time', this.executionTime);
                 const sequenceStartTimeStamp = this.getCurrentTimeStamp;
                 this.currentSequence = sequence;
+                // Emitter
                 this.eventEmitter.emit(SequencerEvent.SEQUENCE_START, sequence);
                 try {
                     yield new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
@@ -92,6 +95,7 @@ export class Sequencer {
                         }
                     }));
                     console.log('Out of Promise');
+                    // Emitter
                     this.eventEmitter.emit(SequencerEvent.SEQUENCE_END, sequence);
                 }
                 catch (e) {
@@ -100,12 +104,14 @@ export class Sequencer {
                         this.status = SequencerStatus.ERROR;
                         this.currentSequence = null;
                         this.endTimestamp = this.currentSequence;
+                        // IMPORTANT
                         return Promise.reject({
                             sequence,
                             reason: e,
                         });
                     }
                     console.log(`Sequence ${sequence.key} failed`, e);
+                    // Emitter
                     this.eventEmitter.emit(SequencerEvent.SEQUENCE_END, sequence);
                 }
             }

package/dist/node/esm/shared/utils/StringUtils.mjs

@@ -24,7 +24,9 @@ StringUtils.levenshteinDistance = (str1 = '', str2 = '') => {
     for (let j = 1; j <= str2.length; j += 1) {
         for (let i = 1; i <= str1.length; i += 1) {
             const indicator = str1[i - 1] === str2[j - 1] ? 0 : 1;
-            track[j][i] = Math.min(track[j][i - 1] + 1, track[j - 1][i] + 1, track[j - 1][i - 1] + indicator);
+            track[j][i] = Math.min(track[j][i - 1] + 1, // deletion
+            track[j - 1][i] + 1, // insertion
+            track[j - 1][i - 1] + indicator);
         }
     }
     return track[str2.length][str1.length];

package/dist/node/esm/shared/utils/UuidUtils.mjs

@@ -6,12 +6,15 @@ export class UuidUtils {
     }
     static format(uuid) {
         if (uuid.length === 32) {
+            // Without dash: ca23c587d7f84c76be59f53bbc9f91f8
             return `${uuid.substring(0, 8)}-${uuid.substring(8, 12)}-${uuid.substring(12, 16)}-${uuid.substring(16, 20)}-${uuid.substring(20, 32)}`.toLowerCase();
         }
         else if (uuid.length === 36) {
+            // With dash: ca23c587-d7f8-4c76-be59-f53bbc9f91f8
             return uuid.toLowerCase();
         }
         else {
+            // Unexpected uuid
             console.warn('Unexpected uuid length', uuid);
             return uuid;
         }

package/dist/node/esm/shared/utils/Validator.mjs

@@ -13,12 +13,14 @@ export class Validator {
         const startsWithNumber = /^\d/.test(value);
         const startsWithAlphabet = /^[A-Za-z]/.test(value);
         const startsWithSpecialCharacter = /^[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/.test(value);
+        // 최소 길이
         if (options.minLength !== undefined && options.minLength > -1) {
             validations.push(Validator.VALIDATION.MIN_LENGTH);
             if (length < options.minLength) {
                 errors.push(Validator.VALIDATION.MIN_LENGTH);
             }
         }
+        // 최대 길이
         if (options.maxLength !== undefined && options.maxLength > -1) {
             validations.push(Validator.VALIDATION.MAX_LENGTH);
             if (length > options.maxLength) {
@@ -41,30 +43,39 @@ export class Validator {
                 }
             }
         };
+        // 공백 개수
         validateMin(options.spaceMinCount, spaceCount, Validator.VALIDATION.SPACE_MIN_COUNT);
         validateMax(options.spaceMaxCount, spaceCount, Validator.VALIDATION.SPACE_MAX_COUNT);
+        // 숫자 개수
         validateMin(options.numberMinCount, numberCount, Validator.VALIDATION.NUMBER_MIN_COUNT);
         validateMax(options.numberMaxCount, numberCount, Validator.VALIDATION.NUMBER_MAX_COUNT);
+        // 알파벳 개수
         validateMin(options.alphabetMinCount, alphabetCount, Validator.VALIDATION.ALPHABET_MIN_COUNT);
         validateMax(options.alphabetMaxCount, alphabetCount, Validator.VALIDATION.ALPHABET_MAX_COUNT);
+        // 알파벳(소문자) 개수
         validateMin(options.alphabetLowerCaseMinCount, alphabetLowerCaseCount, Validator.VALIDATION.ALPHABET_LOWER_CASE_MIN_COUNT);
         validateMax(options.alphabetLowerCaseMaxCount, alphabetLowerCaseCount, Validator.VALIDATION.ALPHABET_LOWER_CASE_MAX_COUNT);
+        // 알파벳(대문자) 개수
         validateMin(options.alphabetUpperCaseMinCount, alphabetUpperCaseCount, Validator.VALIDATION.ALPHABET_UPPER_CASE_MIN_COUNT);
         validateMax(options.alphabetUpperCaseMaxCount, alphabetUpperCaseCount, Validator.VALIDATION.ALPHABET_UPPER_CASE_MAX_COUNT);
+        // 특수문자 개수
         validateMin(options.specialCharacterMinCount, specialCount, Validator.VALIDATION.SPECIAL_CHARACTER_MIN_COUNT);
         validateMax(options.specialCharacterMaxCount, specialCount, Validator.VALIDATION.SPECIAL_CHARACTER_MAX_COUNT);
+        // 숫자로 시작
         if (options.startsWithNumber) {
             validations.push(Validator.VALIDATION.STARTS_WITH_NUMBER);
             if (!startsWithNumber) {
                 errors.push(Validator.VALIDATION.STARTS_WITH_NUMBER);
             }
         }
+        // 영문으로 시작
         if (options.startsWithAlphabet) {
             validations.push(Validator.VALIDATION.STARTS_WITH_ALPHABET);
             if (!startsWithAlphabet) {
                 errors.push(Validator.VALIDATION.STARTS_WITH_ALPHABET);
             }
         }
+        // 특수문자로 시작
         if (options.startsWithSpecialCharacter) {
             validations.push(Validator.VALIDATION.STARTS_WITH_SPECIAL_CHARACTER);
             if (!startsWithSpecialCharacter) {

package/dist/node/esm/shared/utils/global/firstNonNullish.mjs

@@ -3,6 +3,7 @@ export function firstNonNullish(...args) {
         return undefined;
     }
     if (args[0] != null) {
+        // Not Nullish
         return args[0];
     }
     return firstNonNullish(...args.slice(1));

package/dist/node/esm/shared/utils/global/flat.mjs

@@ -1,3 +1,4 @@
+// flat.ts
 function isBuffer(obj) {
     return !!(obj &&
         obj.constructor &&

package/dist/node/esm/shared/utils/global/pureEnum.mjs

@@ -1,9 +1,18 @@
+/**
+ * @deprecated Use Enum instead.
+ */
 export function pureEnum(e) {
     return Object.entries(e).filter(([key, value]) => !/^-?\d+$/g.test(key) && typeof value !== 'function');
 }
+/**
+ * @deprecated Use Enum instead.
+ */
 export function pureEnumKeys(e) {
     return pureEnum(e).map(([key]) => key);
 }
+/**
+ * @deprecated Use Enum instead.
+ */
 export function pureEnumValues(e) {
     return pureEnum(e).map(([, value]) => value);
 }

package/dist/node/esm/shared/utils/try-catch/TryCatch.mjs

@@ -7,7 +7,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+/**
+ * Provides a utility class for handling synchronous and asynchronous operations with a consistent try-catch pattern.
+ * It returns a tuple where the first element is the error (or null on success) and the second element is the result (or undefined on error).
+ */
 export class TryCatch {
+    /**
+     * Executes a synchronous function within a try-catch block.
+     * @template T The return type of the function.
+     * @template E The type of the error that might be thrown (defaults to Error).
+     * @param fn The synchronous function to execute.
+     *@param disableLogging console.error is default way of logging on error. You can disable it by setting it true
+     * @returns A tuple containing the result of the function and an error (null if successful).
+     */
     static function(fn, disableLogging) {
         try {
             return [
@@ -28,6 +40,14 @@ export class TryCatch {
             ];
         }
     }
+    /**
+     * Executes an asynchronous function (Promise) within a try-catch block.
+     * @template T The resolved value type of the Promise.
+     * @template E The type of the error that might be rejected (defaults to Error).
+     * @param fn The Promise to await.
+     * @param disableLogging console.error is default way of logging on error. You can disable it by setting it true
+     * @returns A tuple containing the resolved value of the Promise and an error (null if successful).
+     */
     static asyncFunction(fn, disableLogging) {
         return __awaiter(this, void 0, void 0, function* () {
             try {

package/dist/node/types/browser/utils/UUID.d.ts

@@ -1,35 +1,144 @@
+/**
+ * Represents a UUID (Universally Unique Identifier) and provides various utility
+ * methods for validation, conversion, comparison and creation.
+ */
 export declare class UUID {
+    /** Matches a 32‑character hexadecimal representation of a UUID without hyphens. */
     private static REGEX_HEX;
+    /** Matches the RFC 4122 canonical UUID format with hyphens. */
     private static REGEX_RFC4122;
+    /** Number of bytes that represent a UUID. */
     private static BYTE_LENGTH;
+    /** Total length of an RFC 4122 UUID string (including hyphens). */
     private static STR_LENGTH;
+    /** Length of a UUID represented as a plain hexadecimal string. */
     private static HEX_STR_LENGTH;
+    /**
+     * Checks if the supplied value is a valid hex representation of a UUID.
+     * @param hex - The string to validate.
+     * @returns true if the string matches {@link REGEX_HEX}.
+     */
     static isValidHex(hex: string): boolean;
+    /**
+     * Checks if the supplied value is a valid RFC 4122 UUID string.
+     * @param str - The string to validate.
+     * @returns true if the string matches {@link REGEX_RFC4122}.
+     */
     static isValidString(str: string): boolean;
+    /**
+     * Checks whether an ArrayBufferView contains exactly {@link BYTE_LENGTH} bytes.
+     * @param bytes - The view to check.
+     * @returns true if the byte length is correct.
+     */
     static isValidBytes(bytes: ArrayBufferView): boolean;
+    /**
+     * Generic validation that accepts either a string (hex or RFC 4122 format)
+     * or an ArrayBufferView containing the raw bytes.
+     * @param input - The value to validate.
+     * @returns true if the input is a valid representation of a UUID.
+     */
     static isValid(input: string | ArrayBufferView): boolean;
+    /**
+     * Inserts hyphens into a 32‑character hex string to produce an RFC 4122 string.
+     * @param hex - The plain hexadecimal UUID.
+     * @returns The formatted RFC 4122 string.
+     */
     private static formatHex;
+    /** Removes all hyphens from a UUID string. */
     private static stripHyphens;
+    /**
+     * Converts a plain hexadecimal UUID into a Uint8Array.
+     * @param hex - The hex string to parse.
+     * @returns A Uint8Array containing the raw bytes.
+     */
     private static parseHex;
+    /**
+     * Parses an RFC 4122 string into a Uint8Array.
+     * @param str - The formatted UUID string.
+     * @returns A Uint8Array containing the raw bytes.
+     */
     private static parseString;
+    /**
+     * Parses an ArrayBufferView into a Uint8Array ensuring the correct byte length.
+     * @param bytes - The view to parse.
+     * @returns A Uint8Array containing the raw bytes.
+     */
     private static parseBytes;
+    /**
+     * Creates a UUID instance from a plain hexadecimal string.
+     * @param hex - The hex representation of the UUID.
+     * @returns A new {@link UUID} object.
+     */
     static fromHex(hex: string): UUID;
+    /**
+     * Creates a UUID instance from an RFC 4122 formatted string.
+     * @param str - The UUID string with hyphens.
+     * @returns A new {@link UUID} object.
+     */
     static fromString(str: string): UUID;
+    /**
+     * Creates a UUID instance from raw bytes.
+     * @param bytes - An ArrayBufferView containing 16 bytes.
+     * @returns A new {@link UUID} object.
+     */
     static fromBytes(bytes: ArrayBufferView): UUID;
+    /**
+     * Parses any supported input (string or bytes) and returns the raw byte array.
+     * @param input - The value to parse.
+     * @returns A Uint8Array of length {@link BYTE_LENGTH}.
+     */
     private static parse;
+    /**
+     * Creates a UUID from any supported input type.
+     * @param input - The value to parse.
+     * @returns A new {@link UUID} object.
+     */
     static from(input: string | ArrayBufferView): UUID;
+    /** Returns the nil (all zero) UUID. */
     static nil(): UUID;
+    /** Returns a UUID consisting of all 0xFF bytes. */
     static max(): UUID;
+    /**
+     * Compares multiple UUIDs for strict equality.
+     * @param uuids - The UUIDs to compare (at least two required).
+     * @returns true if all provided UUIDs are identical.
+     */
     static equals(...uuids: UUID[]): boolean;
+    /**
+     * Lexicographically compares two UUIDs.
+     * @param uuid1 - The first UUID.
+     * @param uuid2 - The second UUID.
+     * @returns -1 if uuid1 < uuid2, 1 if uuid1 > uuid2, 0 otherwise.
+     */
     static compare(uuid1: UUID, uuid2: UUID): number;
+    /** Raw byte representation of the UUID. */
     protected readonly bytes: Uint8Array;
     private _str?;
     private _hex?;
+    /**
+     * Constructs a new {@link UUID} instance from any supported input type.
+     * @param input - The value to parse (string or ArrayBufferView).
+     */
     constructor(input: string | ArrayBufferView);
+    /** Instance wrapper for {@link equals}. */
     equals(...uuids: UUID[]): boolean;
+    /** Instance wrapper for {@link compare}. */
     compare(other: UUID): number;
+    /**
+     * Returns the RFC 4122 string representation of this UUID.
+     * @returns The formatted UUID string.
+     */
     toString(): string;
+    /**
+     * Returns the plain hexadecimal representation of this UUID.
+     * @returns A 32‑character hex string.
+     */
     toHex(): string;
+    /**
+     * Returns a copy of the raw byte array.
+     * @returns A new Uint8Array containing the UUID bytes.
+     */
     toBytes(): Uint8Array;
+    /** JSON serialization helper – returns the RFC 4122 string. */
     toJSON(): string;
 }

package/dist/node/types/shared/utils/ArrayUtils.d.ts

@@ -1,5 +1,10 @@
 export declare class ArrayUtils {
     static castArray<T>(value: T | T[]): T[];
+    /**
+     * 객체를 요소로 가지는 배열에서 가장 큰 값(Property)를 가지는 객체를 반환한다
+     * @param e 객체 배열
+     * @param key 값을 비교할 Property 키
+     */
     static getGreatestObject(e: any[], key: string): any;
     static removeDuplicate<T>(arr: T[]): T[];
     static removeObjectDuplicate(arr: any[], key: string): any[];

package/dist/node/types/shared/utils/UuidUtils.d.ts

@@ -1,7 +1,13 @@
 export declare class UuidUtils {
     static v4(): string;
     static format(uuid: string): string;
+    /**
+     * (UUID: Buffer) to (UUID: string)
+     * @param binary UUID
+     * @returns {string|null} When binary not exists return null
+     */
     static toString(binary: Uint8Array): string;
+    /** (UUID: string) to (UUID: Buffer) */
     static toBuffer(uuid: string): Buffer;
     static toBuffer(uuid: string | null | undefined): Buffer | null;
     static isValidUUID(uuid: string): boolean;

package/dist/node/types/shared/utils/global/pureEnum.d.ts

@@ -2,7 +2,16 @@ type NonFunction<T, Type extends "keys" | "values"> = {
     [K in keyof T]: T[K] extends Function ? never : Type extends "keys" ? K : T[K];
 }[keyof T] extends infer R ? (R extends never ? never : R) : never;
 type PureEnumReturnType<E extends object> = [NonFunction<E, "keys">, NonFunction<E, "values">][];
+/**
+ * @deprecated Use Enum instead.
+ */
 export declare function pureEnum<E extends object>(e: E): PureEnumReturnType<E>;
+/**
+ * @deprecated Use Enum instead.
+ */
 export declare function pureEnumKeys<E extends object>(e: E): NonFunction<E, "keys">[];
+/**
+ * @deprecated Use Enum instead.
+ */
 export declare function pureEnumValues<E extends object>(e: E): NonFunction<E, "values">[];
 export {};

package/dist/node/types/shared/utils/try-catch/TryCatch.d.ts

@@ -1,4 +1,24 @@
+/**
+ * Provides a utility class for handling synchronous and asynchronous operations with a consistent try-catch pattern.
+ * It returns a tuple where the first element is the error (or null on success) and the second element is the result (or undefined on error).
+ */
 export declare class TryCatch {
+    /**
+     * Executes a synchronous function within a try-catch block.
+     * @template T The return type of the function.
+     * @template E The type of the error that might be thrown (defaults to Error).
+     * @param fn The synchronous function to execute.
+     *@param disableLogging console.error is default way of logging on error. You can disable it by setting it true
+     * @returns A tuple containing the result of the function and an error (null if successful).
+     */
     static function<T, E = Error>(fn: () => T, disableLogging?: boolean): readonly [null, T] | readonly [E, undefined];
+    /**
+     * Executes an asynchronous function (Promise) within a try-catch block.
+     * @template T The resolved value type of the Promise.
+     * @template E The type of the error that might be rejected (defaults to Error).
+     * @param fn The Promise to await.
+     * @param disableLogging console.error is default way of logging on error. You can disable it by setting it true
+     * @returns A tuple containing the resolved value of the Promise and an error (null if successful).
+     */
     static asyncFunction<T, E = Error>(fn: Promise<T>, disableLogging?: boolean): Promise<readonly [null, Awaited<T>] | readonly [E, undefined]>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@powfix/core-js",
-	"version": "0.19.0",
+	"version": "0.19.2",
 	"description": "core package",
 	"author": "Kwon Kyung-Min <powfix@gmail.com>",
 	"private": false,