@powfix/core-js 0.19.0 → 0.19.2

package/dist/browser/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/browser/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/browser/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/browser/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/browser/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/dist/node/cjs/browser/utils/UUID.js

@@ -2,29 +2,61 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UUID = void 0;
 const shared_1 = require("../../shared");
+/**
+ * Represents a UUID (Universally Unique Identifier) and provides various utility
+ * methods for validation, conversion, comparison and creation.
+ */
 class UUID {
+    /* --------------------------------------------------------------------
+     * Validation helpers
+     * -------------------------------------------------------------------- */
+    /**
+     * 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) {
         if (typeof hex !== 'string') {
             return false;
         }
         return UUID.REGEX_HEX.test(hex);
     }
+    /**
+     * 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) {
         if (typeof str !== 'string') {
             return false;
         }
         return UUID.REGEX_RFC4122.test(str);
     }
+    /**
+     * 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) {
         return bytes.byteLength === UUID.BYTE_LENGTH;
     }
+    /**
+     * 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) {
         if (typeof input === 'string') {
             const length = input.length;
             switch (length) {
                 case UUID.STR_LENGTH:
+                    // RFC 4122 uuid(string)
+                    // 9e472052-a654-4693-9a8b-3ce57ada3d6c
                     return UUID.isValidString(input);
                 case UUID.HEX_STR_LENGTH:
+                    // RFC 4122 uuid(string) without hyphens
+                    // 9e472052a65446939a8b3ce57ada3d6c
                     return UUID.isValidHex(input);
                 default:
                     return false;
@@ -37,6 +69,14 @@ class UUID {
             return false;
         }
     }
+    /* --------------------------------------------------------------------
+     * Parsing / formatting helpers
+     * -------------------------------------------------------------------- */
+    /**
+     * 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.
+     */
     static formatHex(hex) {
         if (hex.length !== UUID.HEX_STR_LENGTH) {
             throw new Error(`hex length should be ${UUID.HEX_STR_LENGTH}`);
@@ -47,15 +87,26 @@ class UUID {
             hex.slice(16, 20) + '-' +
             hex.slice(20);
     }
+    /** Removes all hyphens from a UUID string. */
     static stripHyphens(str) {
         return str.replace(/-/g, "");
     }
+    /**
+     * Converts a plain hexadecimal UUID into a Uint8Array.
+     * @param hex - The hex string to parse.
+     * @returns A Uint8Array containing the raw bytes.
+     */
     static parseHex(hex) {
         if (hex.length !== UUID.HEX_STR_LENGTH) {
             throw new Error(`Invalid hex string, length should be ${UUID.HEX_STR_LENGTH}`);
         }
         return shared_1.Uint8ArrayUtils.fromHex(hex);
     }
+    /**
+     * Parses an RFC 4122 string into a Uint8Array.
+     * @param str - The formatted UUID string.
+     * @returns A Uint8Array containing the raw bytes.
+     */
     static parseString(str) {
         if (str.length !== UUID.STR_LENGTH) {
             throw new Error(`Invalid UUID string, invalid character length should be ${UUID.STR_LENGTH}`);
@@ -69,6 +120,11 @@ class UUID {
         }
         return shared_1.Uint8ArrayUtils.fromHex(hex);
     }
+    /**
+     * Parses an ArrayBufferView into a Uint8Array ensuring the correct byte length.
+     * @param bytes - The view to parse.
+     * @returns A Uint8Array containing the raw bytes.
+     */
     static parseBytes(bytes) {
         const view = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
         if (view.length !== UUID.BYTE_LENGTH) {
@@ -76,22 +132,47 @@ class UUID {
         }
         return new Uint8Array(view);
     }
+    /* --------------------------------------------------------------------
+     * Factory methods
+     * -------------------------------------------------------------------- */
+    /**
+     * 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) {
         return new UUID(UUID.parseHex(hex));
     }
+    /**
+     * 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) {
         return new UUID(UUID.parseString(str));
     }
+    /**
+     * Creates a UUID instance from raw bytes.
+     * @param bytes - An ArrayBufferView containing 16 bytes.
+     * @returns A new {@link UUID} object.
+     */
     static fromBytes(bytes) {
         return new UUID(UUID.parseBytes(bytes));
     }
+    /**
+     * 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}.
+     */
     static parse(input) {
         if (typeof input === 'string') {
             const length = input.length;
             switch (length) {
                 case UUID.STR_LENGTH:
+                    // RFC 4122 uuid(string)
                     return UUID.parseString(input);
                 case UUID.HEX_STR_LENGTH:
+                    // RFC 4122 uuid(string) without hyphens
                     return UUID.parseHex(input);
                 default:
                     throw new Error(`Invalid input string, length should be ${UUID.STR_LENGTH} or ${UUID.HEX_STR_LENGTH}`);
@@ -104,15 +185,30 @@ class UUID {
             throw new Error("Invalid input, Expected string or ArrayBufferView");
         }
     }
+    /**
+     * Creates a UUID from any supported input type.
+     * @param input - The value to parse.
+     * @returns A new {@link UUID} object.
+     */
     static from(input) {
         return UUID.fromBytes(UUID.parse(input));
     }
+    /** Returns the nil (all zero) UUID. */
     static nil() {
         return UUID.fromBytes(new Uint8Array(UUID.BYTE_LENGTH));
     }
+    /** Returns a UUID consisting of all 0xFF bytes. */
     static max() {
         return UUID.fromBytes((new Uint8Array(UUID.BYTE_LENGTH)).fill(0xFF));
     }
+    /* --------------------------------------------------------------------
+     * Equality / comparison
+     * -------------------------------------------------------------------- */
+    /**
+     * 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) {
         const n = uuids.length;
         if (n < 2) {
@@ -128,6 +224,12 @@ class UUID {
         }
         return true;
     }
+    /**
+     * 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, uuid2) {
         const a = uuid1.bytes;
         const b = uuid2.bytes;
@@ -137,15 +239,25 @@ class UUID {
         }
         return 0;
     }
+    /**
+     * Constructs a new {@link UUID} instance from any supported input type.
+     * @param input - The value to parse (string or ArrayBufferView).
+     */
     constructor(input) {
         this.bytes = UUID.parse(input);
     }
+    /** Instance wrapper for {@link equals}. */
     equals(...uuids) {
         return UUID.equals(this, ...uuids);
     }
+    /** Instance wrapper for {@link compare}. */
     compare(other) {
         return UUID.compare(this, other);
     }
+    /**
+     * Returns the RFC 4122 string representation of this UUID.
+     * @returns The formatted UUID string.
+     */
     toString() {
         if (this._str != null) {
             return this._str;
@@ -154,6 +266,10 @@ class UUID {
         this._str = UUID.formatHex(hex);
         return this._str;
     }
+    /**
+     * Returns the plain hexadecimal representation of this UUID.
+     * @returns A 32‑character hex string.
+     */
     toHex() {
         if (this._hex != null) {
             return this._hex;
@@ -161,16 +277,32 @@ class UUID {
         this._hex = shared_1.Uint8ArrayUtils.toHex(this.bytes);
         return this._hex;
     }
+    /**
+     * Returns a copy of the raw byte array.
+     * @returns A new Uint8Array containing the UUID bytes.
+     */
     toBytes() {
         return new Uint8Array(this.bytes);
     }
+    /** JSON serialization helper – returns the RFC 4122 string. */
     toJSON() {
         return this.toString();
     }
 }
 exports.UUID = UUID;
+/* --------------------------------------------------------------------
+ * Regular expressions used to validate UUIDs in different string forms
+ * -------------------------------------------------------------------- */
+/** Matches a 32‑character hexadecimal representation of a UUID without hyphens. */
 UUID.REGEX_HEX = /^[0-9a-fA-F]{8}[0-9a-fA-F]{4}[1-5][0-9a-fA-F]{3}[89abAB][0-9a-fA-F]{3}[0-9a-fA-F]{12}$/;
+/** Matches the RFC 4122 canonical UUID format with hyphens. */
 UUID.REGEX_RFC4122 = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
+/* --------------------------------------------------------------------
+ * Constant lengths used throughout the class
+ * -------------------------------------------------------------------- */
+/** Number of bytes that represent a UUID. */
 UUID.BYTE_LENGTH = 16;
+/** Total length of an RFC 4122 UUID string (including hyphens). */
 UUID.STR_LENGTH = 36;
+/** Length of a UUID represented as a plain hexadecimal string. */
 UUID.HEX_STR_LENGTH = 32;

package/dist/node/cjs/nodejs/managers/TransactionManager.js

@@ -18,8 +18,10 @@ const constants_1 = require("../constants");
 const LOG_TAG = '[TransactionManager]';
 class TransactionManager {
     constructor() {
+        // Members
         this.logLevel = constants_1.TransactionManagerLogLevel.VERBOSE;
         this.transactionTimeoutMap = new Map();
+        // Emitter
         this.emitter = new eventemitter3_1.default();
         if (this.logLevel <= constants_1.TransactionManagerLogLevel.VERBOSE) {
             console.log(LOG_TAG, 'TransactionManager instance initialized');
@@ -59,6 +61,7 @@ class TransactionManager {
             handler,
             action,
         });
+        // Callback
         transaction.afterCommit(this.afterCommit.bind(this));
     }
     remove(transaction) {

package/dist/node/cjs/nodejs/services/redis/RedisClient.js

@@ -33,6 +33,7 @@ class RedisClient {
     start() {
         return __awaiter(this, void 0, void 0, function* () {
             console.log(LOG_PREFIX, 'trying to start');
+            // register event callback
             this.client.on('connect', this.handleOnConnect);
             this.client.on('error', this.handleOnError);
             console.log('before connect');
@@ -46,6 +47,7 @@ class RedisClient {
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
             console.log(LOG_PREFIX, 'trying to stop');
+            // unregister event callback
             this.client.off('connect', this.handleOnConnect);
             this.client.off('error', this.handleOnError);
             if (this.client.isOpen) {

package/dist/node/cjs/nodejs/services/redis/RedisPublisher.js

@@ -40,6 +40,7 @@ class RedisPublisher extends RedisClient_1.RedisClient {
     getLogging() {
         return this.logging;
     }
+    // Make public method
     publish(channel, data) {
         return __awaiter(this, void 0, void 0, function* () {
             const stringifyData = typeof data !== 'string' ? JSON.stringify(data) : data;

package/dist/node/cjs/nodejs/services/redis/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+// Files
 __exportStar(require("./RedisClient"), exports);
 __exportStar(require("./RedisPublisher"), exports);
 __exportStar(require("./RedisSubscriber"), exports);

package/dist/node/cjs/shared/managers/SessionManager.js

@@ -19,8 +19,10 @@ const eventemitter3_1 = __importDefault(require("eventemitter3"));
 class SessionManager extends eventemitter3_1.default {
     constructor(options) {
         super();
+        // Init service parameters
         this.api = options.api;
         this.storageProvider = options.storageProvider;
+        // Logging
         console.log('SessionManager initialized', Date.now(), options.api);
     }
     get key() {
@@ -61,6 +63,7 @@ class SessionManager extends eventemitter3_1.default {
                 return null;
             }
             try {
+                // Replace Bearer prefix
                 nextAuthorization = nextAuthorization.replace(/^Bearer\s+/, '');
                 const decoded = (0, jwt_decode_1.jwtDecode)(nextAuthorization);
                 if (!decoded) {
@@ -101,9 +104,13 @@ class SessionManager extends eventemitter3_1.default {
                         return [decoded.exp, exp.format(), exp.diff(Date.now(), 'days'), 'days left'];
                     })());
                 })();
+                // AsyncStorage 에 토큰 저장
                 yield this.storageProvider.set(this.key, nextAuthorization);
+                // API Instance header 설정
                 this.api.defaults.headers.common.Authorization = `Bearer ${nextAuthorization}`;
+                // Emit
                 this.emit('AUTHORIZATION_CHANGED', nextAuthorization);
+                // Return
                 return nextAuthorization;
             }
             catch (e) {
@@ -114,8 +121,11 @@ class SessionManager extends eventemitter3_1.default {
     }
     removeAuthorization() {
         return __awaiter(this, void 0, void 0, function* () {
+            // API Instance header 에서 토큰 제거
             delete this.api.defaults.headers.common.Authorization;
+            // 스토리지에서 authorization 제거
             yield this.storageProvider.remove(this.key);
+            // Emit
             this.emit('AUTHORIZATION_CHANGED', null);
         });
     }

package/dist/node/cjs/shared/services/time/TimeService.js

@@ -22,9 +22,11 @@ class TimeService extends eventemitter3_1.default {
     }
     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);
     }
@@ -51,6 +53,7 @@ class TimeService extends eventemitter3_1.default {
     }
     setSyncInterval(interval) {
         this.syncInterval = interval;
+        // Emit
         this.emit('SYNC_INTERVAL_CHANGED', interval);
         if (this.syncHandler !== undefined) {
             this.stopSync();
@@ -105,22 +108,32 @@ class TimeService extends eventemitter3_1.default {
     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,
@@ -128,8 +141,11 @@ class TimeService extends eventemitter3_1.default {
                     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/cjs/shared/utils/ArrayUtils.js

@@ -6,6 +6,11 @@ class ArrayUtils {
     static castArray(value) {
         return (0, global_1.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/cjs/shared/utils/AxiosUtils.js

@@ -16,6 +16,7 @@ class AxiosUtils {
                         return e;
                     }
                 }
+                // There is no any values having string type
                 return null;
             }
             else {
@@ -38,6 +39,7 @@ class AxiosUtils {
                         return e;
                     }
                 }
+                // There is no any values having string type
                 return null;
             }
             else {