@powfix/core-js 0.9.22

package/src/utils/JuminNumberUtils.ts

@@ -0,0 +1,47 @@
+import {between} from "./global/between";
+
+export class JuminNumberUtils {
+  public static calculateX(juminNumber: string): number {
+    const replacedJuminNumber = juminNumber.replace(/\D/g, '');
+    if (!between(replacedJuminNumber.length, 12, 13)) {
+      throw new Error('Jumin number length must be 12 to 13(without dash)');
+    }
+
+    const numbers = replacedJuminNumber.split('').map(e => parseInt(e, 10));
+    const sum = 2 * numbers[0] + 3 * numbers[1] + 4 * numbers[2] + 5 * numbers[3]
+      + 6 * numbers[4] + 7 * numbers[5] + 8 * numbers[6] + 9 * numbers[7]
+      + 2 * numbers[8] + 3 * numbers[9] + 4 * numbers[10] + 5 * numbers[11];
+    return (11 - (sum % 11)) % 10;
+  }
+
+  public static isValid(juminNumber: string): boolean {
+    const replacedJuminNumber = juminNumber.replace(/\D/g, '');
+    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); // 대시 있는경우 7로 변경
+    if (sexNum === '1' || sexNum === '2') {
+      if (yearNum < TODAY_YEAR) return false;
+    } else if (sexNum === '3' || sexNum === '4') {
+      if (yearNum > TODAY_YEAR) return false;
+    } 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) {
+      console.log('Invalid X', currentX, calculatedX);
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/utils/NumberUtils.ts

@@ -0,0 +1,23 @@
+export class NumberUtils {
+  public static formatWithThousandsSeparator(value: number, separator: string = ','): string {
+    return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+  }
+
+  public static formatBigNumber(value: number, precision: number = 2): string {
+    const map: {suffix: string, threshold: number}[] = [
+      {suffix: 'Qi', threshold: 1e18},
+      {suffix: 'Q', threshold: 1e15},
+      {suffix: 'T', threshold: 1e12},
+      {suffix: 'B', threshold: 1e9},
+      {suffix: 'M', threshold: 1e6},
+      {suffix: 'K', threshold: 1e3},
+      {suffix: '', threshold: 1},
+    ];
+
+    const found = map.find(e => Math.abs(value) >= e.threshold);
+    if (found) {
+      return Number((value / found.threshold).toFixed(precision)) + found.suffix;
+    }
+    return value.toString();
+  }
+}

package/src/utils/Point3Utils.ts

@@ -0,0 +1,11 @@
+import {Point3} from "../interfaces/Point3";
+
+export class Point3Utils {
+  static distance(p1: Point3, p2: Point3): number {
+    const dx = p1.x - p2.x;
+    const dy = p1.y - p2.y;
+    const dz = p1.z - p2.z;
+
+    return Math.sqrt( dx * dx + dy * dy + dz * dz );
+  }
+}

package/src/utils/RandomUtils.ts

@@ -0,0 +1,62 @@
+export class RandomUtils {
+	static randomNumber(min: number, max: number): number {
+		min = Math.ceil(min);
+		max = Math.floor(max);
+		return Math.floor(Math.random() * (max - min + 1) + min);
+	}
+
+	static randomLatinStrings(length: number) {
+		const strings = [];
+		for (let i = 0; i < length; ++i) {
+			const isLowerCase = RandomUtils.randomNumber(0, 1);
+			if (isLowerCase) {
+				strings.push(String.fromCharCode(RandomUtils.randomNumber(97, 122)));
+			} else {
+				strings.push(String.fromCharCode(RandomUtils.randomNumber(65, 90)));
+			}
+		}
+		return strings.join('');
+	}
+
+	static randomLatinLowercaseStrings(length: number) {
+		const strings = [];
+		for (let i = 0; i < length; ++i) {
+			strings.push(String.fromCharCode(RandomUtils.randomNumber(97, 122)));
+		}
+		return strings.join('');
+	}
+
+	static randomLatinUppercaseStrings(length: number) {
+		const strings = [];
+		for (let i = 0; i < length; ++i) {
+			strings.push(String.fromCharCode(RandomUtils.randomNumber(65, 90)));
+		}
+		return strings.join('');
+	}
+
+	static randomNumberStrings(length: number) {
+		const strings = [];
+		for (let i = 0; i < length; ++i) {
+			strings.push(String.fromCharCode(RandomUtils.randomNumber(48, 57)));
+		}
+		return strings.join('');
+	}
+
+	static randomStrings(length: number) {
+		const strings = [];
+		for (let i = 0; i < length; ++i) {
+			const isNumber = RandomUtils.randomNumber(0, 1);
+			if (isNumber) {
+				strings.push(String.fromCharCode(RandomUtils.randomNumber(48, 57)));
+			} else {
+				const isLowerCase = RandomUtils.randomNumber(0, 1);
+				if (isLowerCase) {
+					strings.push(String.fromCharCode(RandomUtils.randomNumber(97, 122)));
+				} else {
+					strings.push(String.fromCharCode(RandomUtils.randomNumber(65, 90)));
+				}
+			}
+		}
+		return strings.join('');
+	}
+}

package/src/utils/Sequencer.ts

@@ -0,0 +1,178 @@
+import moment from "moment/moment";
+import EventEmitter from 'events';
+
+export interface Sequence {
+  key: string;                          // 고유키값
+  required?: boolean;                    // 오류를 무시할건지
+  minimumExecutionTime?: number;        // 최소실행 시간
+  task: Function;                   // Promise 작업
+  description?: string;                 // 설명
+}
+
+export enum SequencerStatus {
+  IDLE,
+  RUNNING,
+  ERROR,
+  DONE,
+}
+
+export interface SequencerOption {
+  sequences?: Sequence[];
+  minimumExecutionTime?: number;
+}
+
+export enum SequencerEvent {
+  START = 'START',
+  END = 'END',
+
+  SEQUENCE_START = 'SEQUENCE_START',
+  SEQUENCE_END = 'SEQUENCE_END',
+}
+
+export class Sequencer {
+  protected readonly sequences: Sequence[] = [];
+  protected status: SequencerStatus = SequencerStatus.IDLE;
+  protected minimumExecutionTime: number = 0;
+
+  // Reset variables task is done
+  currentSequence: Sequence | null = null;
+  startTimestamp: number | null = null;
+  endTimestamp: number | null = null;
+
+  // Emitter
+  eventEmitter = new EventEmitter();
+
+  constructor(option?: SequencerOption) {
+    if (option?.sequences) {
+      this.sequences.push(...option.sequences);
+    }
+  }
+
+  get getCurrentTimeStamp(): number {
+    return parseInt(moment().format('x'), 10);
+  }
+
+  get executionTime(): number | null {
+    if (this.status === SequencerStatus.IDLE) {
+      return null;
+    }
+
+    if (!this.startTimestamp) {
+      return null;
+    }
+
+    if (this.startTimestamp && this.endTimestamp) {
+      return this.endTimestamp - this.startTimestamp;
+    }
+
+    return this.getCurrentTimeStamp - this.startTimestamp;
+  }
+
+  pushSequence = (sequence: Sequence) => {
+    this.sequences.push(sequence);
+  }
+
+  start = async () => {
+    if (this.status === SequencerStatus.RUNNING) {
+      console.warn('Sequencer status is', this.status);
+      return;
+    }
+
+    this.status = SequencerStatus.RUNNING;
+    this.currentSequence = null;
+    this.startTimestamp = this.getCurrentTimeStamp;
+    this.endTimestamp = null;
+
+    console.log(`Sequence started, started at ${this.startTimestamp}, MINIMUM_EXECUTION_TIME is ${this.minimumExecutionTime}`);
+
+    for (let sequence of this.sequences) {
+      console.log('Currently total execution time', this.executionTime);
+
+      const sequenceStartTimeStamp = this.getCurrentTimeStamp;
+
+      this.currentSequence = sequence;
+
+      // Emitter
+      this.eventEmitter.emit(SequencerEvent.SEQUENCE_START, sequence);
+
+      try {
+        await new Promise<void>(async (resolve, reject) => {
+          try {
+            console.log(`Sequence ${sequence.key} start`);
+
+            await sequence.task?.();
+
+            const sequenceEndTimeStamp = this.getCurrentTimeStamp;
+            const sequenceExecutionTime = sequenceEndTimeStamp - sequenceStartTimeStamp;
+
+            console.log(`✅ Sequence ${sequence.key} done at`, sequenceEndTimeStamp);
+            console.log('Sequence execution time', sequenceExecutionTime, 'ms');
+
+            if (sequence.minimumExecutionTime) {
+              console.log(`Sequence has minimumExecutionTime`, sequence.minimumExecutionTime, 'ms');
+
+              if (sequenceExecutionTime < sequence.minimumExecutionTime) {
+                const delay = sequence.minimumExecutionTime - sequenceExecutionTime;
+                console.log(`Sequence will delay`, delay, 'ms');
+
+                let dotInterpreterBlocked = false;
+                const dotInterpreter = setInterval(() => {
+                  if (dotInterpreterBlocked) {
+                    console.log('!');
+                    return;
+                  }
+
+                  console.log('.');
+                }, 100);
+
+                setTimeout(() => {
+                  dotInterpreterBlocked = true;
+                  clearInterval(dotInterpreter);
+                  console.log('done');
+                  resolve();
+                }, delay);
+                return;
+              }
+
+              console.log('Sequence execution time is greater than minimum execution time');
+              resolve();
+              return;
+            }
+
+            resolve();
+          } catch (e) {
+            reject(e);
+          }
+        });
+
+        console.log('Out of Promise');
+
+        // Emitter
+        this.eventEmitter.emit(SequencerEvent.SEQUENCE_END, sequence);
+      } catch (e) {
+        if (sequence.required) {
+          console.error(`🚫 Sequence ${sequence.key} failed`, e);
+
+          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);
+      }
+    }
+
+    this.status = SequencerStatus.DONE;
+    this.currentSequence = null;
+    this.endTimestamp = this.currentSequence;
+  };
+}

package/src/utils/StringUtils.ts

@@ -0,0 +1,43 @@
+export class StringUtils {
+	public static numberWithCommas(x: string | any): string {
+		return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+	}
+
+	public static getByte(s: string): number {
+		const getByteLength = (decimal: number) => {
+			const LINE_FEED = 10;
+			return (decimal >> 7) || (LINE_FEED === decimal) ? 2 : 1
+		};
+
+		return s
+			.split('')
+			.map((s) => s.charCodeAt(0))
+			.reduce((prev, unicodeDecimalValue) => prev + getByteLength(unicodeDecimalValue), 0)
+	}
+
+	public static levenshteinDistance = (str1: string = '', str2: string = ''): number => {
+		const track = Array(str2.length + 1).fill(null).map(() =>
+			Array(str1.length + 1).fill(null));
+
+		for (let i = 0; i <= str1.length; i += 1) {
+			track[0][i] = i;
+		}
+
+		for (let j = 0; j <= str2.length; j += 1) {
+			track[j][0] = j;
+		}
+
+		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, // deletion
+					track[j - 1][i] + 1, // insertion
+					track[j - 1][i - 1] + indicator, // substitution
+				);
+			}
+		}
+
+		return track[str2.length][str1.length];
+	};
+}

package/src/utils/UuidUtils.ts

@@ -0,0 +1,46 @@
+const uuid = require('uuid');
+
+function binaryToString(binary: Buffer): string {
+	return Buffer.from(binary).toString('hex');
+}
+
+export class UuidUtils {
+	static v4(): string {
+		return uuid.v4();
+	}
+
+	static format(uuid: string) {
+		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)}`.toUpperCase();
+		} else if (uuid.length === 36) {
+			// With dash: ca23c587-d7f8-4c76-be59-f53bbc9f91f8
+			return uuid.toUpperCase();
+		} else {
+			// Unexpected uuid
+			console.warn('Unexpected uuid length', uuid);
+			return uuid;
+		}
+	}
+
+	/**
+	 * (UUID: Buffer) to (UUID: string)
+	 * @param binary UUID
+	 * @returns {string|null} When binary not exists return null
+	 */
+	static toString(binary?: Buffer): string | null {
+		if (!binary) return null;
+		return UuidUtils.format(binaryToString(binary));
+	}
+
+	/** (UUID: string) to (UUID: Buffer) */
+	static toBuffer(uuid: string): Buffer {
+		return Buffer.from(uuid.replace(/-/g, ''), 'hex');
+	}
+
+	static isValidUUID(uuid: string): boolean {
+		if (!uuid) return false;
+		if (typeof uuid !== 'string') return false;
+		return RegExp(/^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/i).test(uuid);
+	}
+}

package/src/utils/Validator.ts

@@ -0,0 +1,162 @@
+export class Validator {
+  public static validate(value: string | null | undefined, options: Validator.Options): {result: boolean, validations: Validator.VALIDATION[], passes: Validator.VALIDATION[], errors: Validator.VALIDATION[]} {
+    value = value || '';
+
+    const validations: Validator.VALIDATION[] = [];
+    const errors: Validator.VALIDATION[] = [];
+
+    const {length} = value;
+    const spaceCount = (value.match(/\s/g) || []).length;
+    const numberCount = (value.match(/\d/g) || []).length;
+    const alphabetCount = (value.match(/[A-Za-z]/g) || []).length;
+    const alphabetLowerCaseCount = (value.match(/[a-z]/g) || []).length;
+    const alphabetUpperCaseCount = (value.match(/[A-Z]/g) || []).length;
+    const specialCount = (value.match(/[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/g) || []).length;
+    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) {
+        errors.push(Validator.VALIDATION.MAX_LENGTH);
+      }
+    }
+
+    const validateMin = (option: number | undefined, value: number, validation: Validator.VALIDATION) => {
+      if (option !== undefined && option > -1) {
+        validations.push(validation);
+        if (value < option) {
+          errors.push(validation);
+        }
+      }
+    };
+
+    const validateMax = (option: number | undefined, value: number, validation: Validator.VALIDATION) => {
+      if (option !== undefined && option > -1) {
+        validations.push(validation);
+        if (value > option) {
+          errors.push(validation);
+        }
+      }
+    }
+
+    // 공백 개수
+    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) {
+        errors.push(Validator.VALIDATION.STARTS_WITH_SPECIAL_CHARACTER);
+      }
+    }
+
+    return {
+      result: errors.length === 0,
+      validations,
+      passes: validations.filter(e => !errors.includes(e)),
+      errors,
+    };
+  }
+}
+
+export namespace Validator {
+  export enum VALIDATION {
+    MIN_LENGTH = 'MIN_LENGTH',
+    MAX_LENGTH = 'MAX_LENGTH',
+
+    SPACE_MIN_COUNT = 'SPACE_MIN_COUNT',
+    SPACE_MAX_COUNT = 'SPACE_MAX_COUNT',
+
+    NUMBER_MIN_COUNT = 'NUMBER_MIN_COUNT',
+    NUMBER_MAX_COUNT = 'NUMBER_MAX_COUNT',
+
+    ALPHABET_MIN_COUNT = 'ALPHABET_MIN_COUNT',
+    ALPHABET_MAX_COUNT = 'ALPHABET_MAX_COUNT',
+
+    ALPHABET_LOWER_CASE_MIN_COUNT = 'ALPHABET_LOWER_CASE_MIN_COUNT',
+    ALPHABET_LOWER_CASE_MAX_COUNT = 'ALPHABET_LOWER_CASE_MAX_COUNT',
+
+    ALPHABET_UPPER_CASE_MIN_COUNT = 'ALPHABET_UPPER_CASE_MIN_COUNT',
+    ALPHABET_UPPER_CASE_MAX_COUNT = 'ALPHABET_UPPER_CASE_MAX_COUNT',
+
+    SPECIAL_CHARACTER_MIN_COUNT = 'SPECIAL_CHARACTER_MIN_COUNT',
+    SPECIAL_CHARACTER_MAX_COUNT = 'SPECIAL_CHARACTER_MAX_COUNT',
+
+    STARTS_WITH_ALPHABET = 'STARTS_WITH_ALPHABET',
+    STARTS_WITH_NUMBER = 'STARTS_WITH_NUMBER',
+    STARTS_WITH_SPECIAL_CHARACTER = 'STARTS_WITH_SPECIAL_CHARACTER',
+  }
+
+  export interface Options {
+    minLength?: number;                           // 최소 길이
+    maxLength?: number;                           // 최대 길이
+
+    spaceMinCount?: number;                  // 공백 최소 개수
+    spaceMaxCount?: number;                  // 공백 최대 개수
+
+    numberMinCount?: number;                      // 숫자 최소 개수
+    numberMaxCount?: number;                      // 숫자 최대 개수
+
+    alphabetMinCount?: number;                    // 알파벳 최소 개수
+    alphabetMaxCount?: number;                    // 알파벳 최대 개수
+
+    alphabetLowerCaseMinCount?: number;           // 알파벳(소문자) 최소 개수
+    alphabetLowerCaseMaxCount?: number;           // 알페벳(소문자) 최대 개수
+
+    alphabetUpperCaseMinCount?: number;           // 알파벳(대문자) 최소 개수
+    alphabetUpperCaseMaxCount?: number;           // 알파벳(대문자) 최대 개수
+
+    specialCharacterMinCount?: number;            // 특수문자 최소 개수
+    specialCharacterMaxCount?: number;            // 특수문자 최대 개수
+
+    startsWithNumber?: boolean;                   // 숫자로 시작해야하는가
+    startsWithAlphabet?: boolean;                 // 알파벳으로 시작해야하는가
+    startsWithSpecialCharacter?: boolean;         // 툭수문자로 시작해야하는가
+  }
+}

package/src/utils/global/between.ts

@@ -0,0 +1,3 @@
+export const between = (value: number, from: number, to: number): boolean => {
+  return value >= from && value <= to;
+};

package/src/utils/global/sleep.ts

@@ -0,0 +1,6 @@
+export const sleep = async (delayInMilliseconds: number, callback?: (...args: any) => void, ...args: any): Promise<any[]> => new Promise((resolve) => {
+  setTimeout(() => {
+    callback?.(...args);
+    resolve(args);
+  }, delayInMilliseconds);
+});