@powfix/core-js 0.19.0 → 0.19.2

package/dist/node/cjs/shared/utils/Calc.js

@@ -17,7 +17,7 @@ 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/cjs/shared/utils/DateUtils.js

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

package/dist/node/cjs/shared/utils/JuminNumberUtils.js

@@ -19,9 +19,10 @@ 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;
@@ -32,9 +33,11 @@ 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/cjs/shared/utils/Sequencer.js

@@ -34,9 +34,11 @@ 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_1.default();
         this.pushSequence = (sequence) => {
             this.sequences.push(sequence);
@@ -55,6 +57,7 @@ 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* () {
@@ -98,6 +101,7 @@ class Sequencer {
                         }
                     }));
                     console.log('Out of Promise');
+                    // Emitter
                     this.eventEmitter.emit(SequencerEvent.SEQUENCE_END, sequence);
                 }
                 catch (e) {
@@ -106,12 +110,14 @@ 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/cjs/shared/utils/StringUtils.js

@@ -28,7 +28,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/cjs/shared/utils/UuidUtils.js

@@ -42,12 +42,15 @@ 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/cjs/shared/utils/Validator.js

@@ -16,12 +16,14 @@ 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) {
@@ -44,30 +46,39 @@ 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/cjs/shared/utils/global/firstNonNullish.js

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

package/dist/node/cjs/shared/utils/global/flat.js

@@ -1,4 +1,5 @@
 "use strict";
+// flat.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flatten = flatten;
 exports.unflatten = unflatten;

package/dist/node/cjs/shared/utils/global/pureEnum.js

@@ -3,12 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pureEnum = pureEnum;
 exports.pureEnumKeys = pureEnumKeys;
 exports.pureEnumValues = pureEnumValues;
+/**
+ * @deprecated Use Enum instead.
+ */
 function pureEnum(e) {
     return Object.entries(e).filter(([key, value]) => !/^-?\d+$/g.test(key) && typeof value !== 'function');
 }
+/**
+ * @deprecated Use Enum instead.
+ */
 function pureEnumKeys(e) {
     return pureEnum(e).map(([key]) => key);
 }
+/**
+ * @deprecated Use Enum instead.
+ */
 function pureEnumValues(e) {
     return pureEnum(e).map(([, value]) => value);
 }

package/dist/node/cjs/shared/utils/try-catch/TryCatch.js

@@ -10,7 +10,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TryCatch = void 0;
+/**
+ * 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).
+ */
 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 [
@@ -31,6 +43,14 @@ 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/esm/browser/utils/UUID.mjs

@@ -1,27 +1,59 @@
 import { Uint8ArrayUtils } from "../../shared/index.mjs";
+/**
+ * Represents a UUID (Universally Unique Identifier) and provides various utility
+ * methods for validation, conversion, comparison and creation.
+ */
 export 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;
@@ -34,6 +66,14 @@ export 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}`);
@@ -44,15 +84,26 @@ export 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 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}`);
@@ -66,6 +117,11 @@ export class UUID {
         }
         return 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) {
@@ -73,22 +129,47 @@ export 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}`);
@@ -101,15 +182,30 @@ export 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) {
@@ -125,6 +221,12 @@ export 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;
@@ -134,15 +236,25 @@ export 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;
@@ -151,6 +263,10 @@ export 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;
@@ -158,15 +274,31 @@ export class UUID {
         this._hex = 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();
     }
 }
+/* --------------------------------------------------------------------
+ * 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/esm/nodejs/managers/TransactionManager.mjs

@@ -12,8 +12,10 @@ import { TransactionManagerLogLevel, TransactionManagerTimeoutAction } from "../
 const LOG_TAG = '[TransactionManager]';
 export class TransactionManager {
     constructor() {
+        // Members
         this.logLevel = TransactionManagerLogLevel.VERBOSE;
         this.transactionTimeoutMap = new Map();
+        // Emitter
         this.emitter = new EventEmitter();
         if (this.logLevel <= TransactionManagerLogLevel.VERBOSE) {
             console.log(LOG_TAG, 'TransactionManager instance initialized');
@@ -53,6 +55,7 @@ export class TransactionManager {
             handler,
             action,
         });
+        // Callback
         transaction.afterCommit(this.afterCommit.bind(this));
     }
     remove(transaction) {

package/dist/node/esm/nodejs/services/redis/RedisClient.mjs

@@ -30,6 +30,7 @@ export 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');
@@ -43,6 +44,7 @@ export 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/esm/nodejs/services/redis/RedisPublisher.mjs

@@ -37,6 +37,7 @@ export class RedisPublisher extends 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/esm/nodejs/services/redis/index.mjs

@@ -1,3 +1,4 @@
+// Files
 export * from './RedisClient.mjs';
 export * from './RedisPublisher.mjs';
 export * from './RedisSubscriber.mjs';

package/dist/node/esm/shared/managers/SessionManager.mjs

@@ -13,8 +13,10 @@ import EventEmitter from 'eventemitter3';
 export class SessionManager extends EventEmitter {
     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() {
@@ -55,6 +57,7 @@ export class SessionManager extends EventEmitter {
                 return null;
             }
             try {
+                // Replace Bearer prefix
                 nextAuthorization = nextAuthorization.replace(/^Bearer\s+/, '');
                 const decoded = jwtDecode(nextAuthorization);
                 if (!decoded) {
@@ -95,9 +98,13 @@ export class SessionManager extends EventEmitter {
                         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) {
@@ -108,8 +115,11 @@ export class SessionManager extends EventEmitter {
     }
     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);
         });
     }