@powfix/core-js 0.9.22

package/src/services/redis/RedisSubscriber.ts

@@ -0,0 +1,49 @@
+import {RedisClient} from "./RedisClient";
+import {PubSubListener} from "@redis/client/dist/lib/client/pub-sub";
+
+export class RedisSubscriber extends RedisClient {
+  public constructor(options?: RedisClient.RedisClientOptions) {
+    super(options);
+    console.log(Date.now(), 'Subscriber', 'initialized');
+  }
+
+  public subscribe = async <T extends boolean = false>(channels: string | string[], listener: PubSubListener<T>, bufferMode?: T | undefined) => {
+    for (const channel of Array.isArray(channels) ? channels : [channels]) {
+      if ((/\*/g).test(channel)) {
+        await this.client.pSubscribe(channel, listener, bufferMode);
+      } else {
+        await this.client.subscribe(channel, listener, bufferMode);
+      }
+    }
+  };
+
+  public unsubscribe = async <T extends boolean = false>(channels: string | string[], listener?: PubSubListener<T> | undefined, bufferMode?: T | undefined): Promise<void> => {
+    for (const channel of Array.isArray(channels) ? channels : [channels]) {
+      if ((/\*/g).test(channel)) {
+        await this.client.pUnsubscribe(channel, listener, bufferMode);
+      } else {
+        await this.client.unsubscribe(channel, listener, bufferMode);
+      }
+    }
+  };
+
+  public async start(): Promise<RedisClient.Status> {
+    const status = await super.start();
+    await this.registerListeners();
+    return status;
+  }
+
+  public async stop(): Promise<RedisClient.Status> {
+    const status = await super.stop();
+    await this.unregisterListeners();
+    return status;
+  }
+
+  protected async registerListeners() {
+
+  }
+
+  protected async unregisterListeners() {
+
+  }
+}

package/src/services/redis/index.ts

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

package/src/services/time/TimeService.ts

@@ -0,0 +1,304 @@
+import EventEmitter from "events";
+
+const LOG_TAG: string = 'TimeService';
+
+export class TimeService {
+  protected status: TimeService.Status = TimeService.Status.STOPPED;
+  private offset?: TimeService.Offset | undefined;
+  private option: TimeService.Option;
+  private syncedAt?: TimeService.TimeStamp | undefined;
+
+  // Emitter
+  private emitter = new EventEmitter({});
+  public readonly on = this.emitter.on;
+  public readonly off = this.emitter.off;
+  private readonly emit = this.emitter.emit;
+
+  public static calculateNTPResultOffset(ntpResult: TimeService.NTPResult): TimeService.Offset {
+    const {t1, t2, t3, t4} = ntpResult;
+    return ((t2 - t1) + (t3 - t4)) / 2;
+  }
+
+  constructor(option: TimeService.Option) {
+    this.option = option;
+
+    if (option.autoStart) {
+      this.start();
+    }
+
+    // Binding
+    this.start = this.start.bind(this);
+    this.stop = this.stop.bind(this);
+    this.sync = this.sync.bind(this);
+    this.getOption = this.getOption.bind(this);
+    this.setOption = this.setOption.bind(this);
+  }
+
+  public getOption(): TimeService.Option {
+    return this.option;
+  }
+
+  public setOption(option: TimeService.Option): TimeService.Option {
+    return this.option = option;
+  }
+
+  public getOffset(defaultValue: TimeService.Offset): TimeService.Offset;
+  public getOffset(): TimeService.Offset | undefined;
+  public getOffset(defaultValue?: TimeService.Offset): TimeService.Offset | undefined {
+    if (this.offset !== undefined) {
+      return this.offset;
+    }
+    if (defaultValue !== undefined) {
+      return defaultValue;
+    }
+    return undefined;
+  }
+
+  public setOffset(offset: TimeService.Offset): TimeService.Offset
+  public setOffset(offset: TimeService.Offset | undefined): TimeService.Offset
+  public setOffset(offset?: TimeService.Offset): TimeService.Offset | undefined {
+    return this.offset = offset;
+  }
+
+  public getSyncedAt(): TimeService.TimeStamp | undefined {
+    return this.syncedAt;
+  }
+
+  private setSyncedAt(syncedAt: TimeService.TimeStamp | undefined): TimeService.TimeStamp | undefined {
+    this.syncedAt = syncedAt;
+
+    // Emit
+    this.emit(TimeService.EVENT.SYNCED, syncedAt);
+
+    return syncedAt;
+  }
+
+  public getSyncInterval(): number | null {
+    if (this.option.syncInterval === undefined) {
+      // If option is undefined using default value
+      return TimeService.DEFAULT_SYNC_INTERVAL;
+    }
+
+    if (this.option.syncInterval === null || this.option.syncInterval === -1) {
+      // If option is null, do not sync automatically
+      return null;
+    }
+
+    return this.option.syncInterval;
+  }
+
+  public setSyncInterval(interval: TimeService.Option['syncInterval']) {
+    this.option.syncInterval = interval;
+
+    // Emit
+    this.emit(TimeService.EVENT.SYNC_INTERVAL_CHANGED, interval);
+
+    if (this.status === TimeService.Status.RUNNING) {
+      if (this.syncHandler !== undefined) {
+        this.stopSync();
+        this.startSync();
+      }
+    }
+  }
+
+  public getClientTime(defaultValue: TimeService.TimeStamp = Date.now()): TimeService.TimeStamp {
+    try {
+      if (typeof this.option.clientTimeProvider === 'function') {
+        return this.option.clientTimeProvider();
+      }
+    } catch (e) {
+      console.error(e);
+    }
+    return defaultValue;
+  }
+
+  public getServerTime(): TimeService.TimeStamp | null {
+    const offset = this.getOffset();
+    if (offset === undefined) {
+      return null;
+    }
+
+    const clientTime = this.getClientTime();
+    return clientTime + offset;
+  }
+
+  public getTime(): number {
+    return this.getServerTime() || this.getClientTime();
+  }
+
+  private readonly fetchServerNTPResult = async (t1: TimeService.NTPResult['t1']): Promise<TimeService.ServerNTPResult | null> => {
+    try {
+      if (typeof this.option.serverTimeProvider === 'function') {
+        return await this.option.serverTimeProvider(t1);
+      }
+    } catch (e) {
+      console.error(e);
+    }
+    return null;
+  }
+
+  public getStatus(): TimeService.Status {
+    return this.status;
+  }
+
+  public start() {
+    if (this.status !== TimeService.Status.STOPPED) {
+      console.warn(LOG_TAG, 'service is not stopped');
+      return;
+    }
+
+    // Change status
+    this.status = TimeService.Status.RUNNING;
+
+    // Sync immediately
+    this.sync().finally(() => {});
+
+    // Start sync
+    this.startSync();
+  }
+
+  public stop() {
+    if (this.status !== TimeService.Status.RUNNING) {
+      console.warn(LOG_TAG, 'service is not running');
+      return;
+    }
+
+    // Change status
+    this.status = TimeService.Status.RUNNING;
+
+    // Stop sync
+    this.stopSync();
+
+    // Reset offset
+    this.setOffset(undefined);
+
+    // Reset synced at
+    this.setSyncedAt(undefined);
+  }
+
+  public async sync(): Promise<TimeService.Offset | null> {
+    try {
+      // T1 (Client Request Time)
+      const requestedAt: number = Date.now();
+
+      // Fetch server time from server
+      const serverNtpResult = await 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: number = Date.now();
+
+      const ntpResult: TimeService.NTPResult = {
+        t1: requestedAt,
+        t2: t2,
+        t3: t3,
+        t4: receivedAt,
+      };
+
+      // Calculate offset
+      const offset = TimeService.calculateNTPResultOffset(ntpResult);
+
+      // Save calculated offset
+      this.setOffset(offset);
+
+      // Mark synced timestamp
+      this.setSyncedAt(Date.now());
+    } catch (e) {
+      console.error(e);
+    }
+
+    return null;
+  }
+
+  private syncHandler?: ReturnType<typeof setInterval> | undefined;
+  private startSync() {
+    if (this.syncHandler !== undefined) {
+      console.warn('sync handler is not undefined', this.syncHandler);
+      return;
+    }
+
+    const syncInterval = this.getSyncInterval();
+    if (syncInterval === null) {
+      return;
+    }
+
+    this.syncHandler = setInterval(this.sync, syncInterval);
+  };
+
+  private stopSync() {
+    if (this.syncHandler === undefined) {
+      return;
+    }
+    clearInterval(this.syncHandler);
+    this.syncHandler = undefined;
+  };
+}
+
+export namespace TimeService {
+  export const DEFAULT_SYNC_INTERVAL: number = 60000;
+
+  export enum Status {
+    STOPPED = 0,
+    RUNNING = 1,
+  }
+
+  export type Offset = number;
+  export type TimeStamp = number;
+
+  export interface NTPResult {
+    // T1 (Client Request Time)
+    t1: TimeStamp;
+
+    // T2 (Server Receive Time)
+    t2: TimeStamp;
+
+    // T3 (Server Transmit Time)
+    t3: TimeStamp;
+
+    // T4 (Client Receive Time)
+    t4: TimeStamp;
+  }
+
+  export interface ServerNTPResult extends Pick<NTPResult, 't2' | 't3'> {}
+
+  export type ClientTimeProvider = () => TimeStamp;
+  // export type ServerTimeProvider = ((t1: NTPResult['t1']) => ServerNTPResult) | ((t1: NTPResult['t1']) => Promise<ServerNTPResult>);
+  export type ServerTimeProvider = (t1: NTPResult['t1']) => (ServerNTPResult | null) | (Promise<ServerNTPResult | null>);
+
+  export interface Option {
+    autoStart?: boolean;
+    syncInterval?: number | null | undefined;                            // Sync interval in milliseconds
+    clientTimeProvider?: ClientTimeProvider | undefined;
+    serverTimeProvider?: ServerTimeProvider | undefined;
+  }
+
+  export enum EVENT {
+    SYNCED = 'SYNCED',
+    SYNC_INTERVAL_CHANGED = 'SYNC_INTERVAL_CHANGED',
+  }
+}

package/src/services/time/index.ts

@@ -0,0 +1 @@
+export * from "./TimeService";

package/src/types/IntRage.ts

@@ -0,0 +1,5 @@
+type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N
+  ? Acc[number]
+  : Enumerate<N, [...Acc, Acc['length']]>
+
+export type IntRange<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>> | T;

package/src/utils/ArrayUtils.ts

@@ -0,0 +1,25 @@
+export class ArrayUtils {
+
+  /**
+   * 객체를 요소로 가지는 배열에서 가장 큰 값(Property)를 가지는 객체를 반환한다
+   * @param e 객체 배열
+   * @param key 값을 비교할 Property 키
+   */
+  static getGreatestObject(e: any[], key: string) {
+    return e.reduce((prev, current) => (
+      (prev[key] > current[key] ? prev : current)
+    ));
+  }
+
+  static removeDuplicate<T>(arr: T[]): T[] {
+    return [...new Set(arr)]
+  }
+
+  static removeObjectDuplicate(arr: any[], key: string) {
+    return arr.filter((v, i, self) => (
+      i === self.findIndex(e => (
+        e[key] === v[key]
+      ))
+    ))
+  }
+}

package/src/utils/BooleanUtils.ts

@@ -0,0 +1,4 @@
+export function parseBoolean(value: any, defaultValue: boolean): boolean {
+	if (value === undefined || value === null) return defaultValue;
+	return (value === 'true' || value === true) || (value === 1 || value === '1');
+}

package/src/utils/CoordinateUtils.ts

@@ -0,0 +1,50 @@
+import {Coordinate} from "../interfaces/Coordinate";
+
+export class CoordinateUtils {
+  public static isValidLatitude(latitude: Coordinate['latitude'] | string) {
+    return /^-?([0-8]?[0-9]|90)(\.[0-9]{1,15})$/.test(latitude.toString());
+  }
+
+  public static isValidLongitude(longitude: Coordinate['longitude'] | string) {
+    return /^-?([0-9]{1,2}|1[0-7][0-9]|180)(\.[0-9]{1,14})$/.test(longitude.toString());
+  }
+
+  public static isValidLatitudeLongitude(latitude: Coordinate['latitude'] | string, longitude: Coordinate['longitude'] | string) {
+    return CoordinateUtils.isValidLatitude(latitude) && CoordinateUtils.isValidLongitude(longitude);
+  }
+
+  public static isValidCoordinate(coordinate: Coordinate): boolean {
+    return this.isValidLatitudeLongitude(coordinate.latitude, coordinate.longitude);
+  }
+
+  public static crowDistance(...coordinates: Coordinate[]): number {
+    if (coordinates.length <= 2) {
+      const toRad = (value: number) => value * Math.PI / 180;
+
+      const c1 = coordinates[0];
+      const c2 = coordinates[1];
+      if (!c1 || !c2) {
+        return 0;
+      }
+
+      const R = 6371e3;
+      const dLat = toRad(c2.latitude - c1.latitude);
+      const dLon = toRad(c2.longitude - c1.longitude);
+      const lat1 = toRad(c1.latitude);
+      const lat2 = toRad(c2.latitude);
+
+      const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.sin(dLon / 2) * Math.sin(dLon / 2) * Math.cos(lat1) * Math.cos(lat2);
+      const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+      return R * c;
+    }
+
+    let totalDistance: number = 0;
+    for (let i = 0; i < coordinates.length - 1; ++i) {
+      totalDistance += this.crowDistance(coordinates[i], coordinates[i + 1]);
+    }
+
+    return totalDistance;
+  }
+}

package/src/utils/DateUtils.ts

@@ -0,0 +1,213 @@
+import moment, {Moment, MomentInput, RelativeTimeSpec} from "moment";
+
+export class DateUtils {
+  public static relativeDate = (input: MomentInput, from: MomentInput = Date.now()): string => {
+    // 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);
+      return '<INVALID DATE>';
+    }
+
+    return datetime.from(from);
+  };
+
+  public static setLocale = (language: DateUtils.Locale) => {
+    const relativeTime = DateUtils.getRelativeTimeSpec(language);
+    if (relativeTime !== undefined) {
+      moment.updateLocale(language, {relativeTime});
+    }
+    moment.locale(language);
+  };
+
+  private static getRelativeTimeSpec = (locale: DateUtils.Locale): RelativeTimeSpec | undefined => {
+    if (locale in DateUtils.relativeTimeSpecs) {
+      return DateUtils.relativeTimeSpecs[locale];
+    }
+    return undefined;
+  };
+}
+
+export namespace DateUtils {
+  export type Locale = string;
+
+  export const relativeTimeSpecs: {[key: Locale]: RelativeTimeSpec} = {
+    ko: {
+      future: "%s 후",
+      past: "%s 전",
+      s: number => `${number}초`,
+      ss: number => `${number}초`,
+      m: number => `${number}분`,
+      mm: number => `${number}분`,
+      h: number => `${number}시간`,
+      hh: number => `${number}시간`,
+      d: number => `${number}일`,
+      dd: number => `${number}일`,
+      M: number => `${number}개월`,
+      MM: number => `${number}개월`,
+      y: number => `${number}년`,
+      yy: number => `${number}년`
+    } as RelativeTimeSpec,
+    en: {
+      future: "in %s",
+      past: "%s ago",
+      s: number => number === 1 ? `${number} second`: `${number} seconds`,
+      ss: number => `${number} seconds`,
+      m: number => number === 1 ? `${number} minute`: `${number} minutes`,
+      mm: number => `${number} minutes`,
+      h: number => number === 1 ? `${number} hour`: `${number} hours`,
+      hh: number => `${number} hours`,
+      d: number => number === 1 ? `${number} day`: `${number} days`,
+      dd: number => `${number} days`,
+      M: number => number === 1 ? `${number} month`: `${number} months`,
+      MM: number => `${number} months`,
+      y: number => number === 1 ? `${number} year`: `${number} years`,
+      yy: number => `${number} years`
+    } as RelativeTimeSpec,
+    ja: {
+      future: "%s後",
+      past: "%s前",
+      s: number => `${number}秒`,
+      ss: number => `${number}秒`,
+      m: number => `${number}分`,
+      mm: number => `${number}分`,
+      h: number => `${number}時`,
+      hh: number => `${number}時`,
+      d: number => `${number}日`,
+      dd: number => `${number}日`,
+      M: number => `${number}月`,
+      MM: number => `${number}月`,
+      y: number => `${number}年`,
+      yy: number => `${number}年`
+    } as RelativeTimeSpec,
+    zh: {
+      future: "%s后",
+      past: "%s前",
+      s: number => `${number}秒`,
+      ss: number => `${number}秒`,
+      m: number => `${number}分钟`,
+      mm: number => `${number}分钟`,
+      h: number => `${number}个小时`,
+      hh: number => `${number}个小时`,
+      d: number => `${number}天`,
+      dd: number => `${number}天`,
+      M: number => `${number}个月`,
+      MM: number => `${number}个月`,
+      y: number => `${number}年`,
+      yy: number => `${number}年`
+    } as RelativeTimeSpec,
+    ru: {
+      future: "через %s",
+      past: "%s назад",
+      s: number => `${number} секунд`,
+      ss: number => `${number} секунд`,
+      m: number => `${number} минута`,
+      mm: number => `${number} минут`,
+      h: number => `${number} час`,
+      hh: number => `${number} часов`,
+      d: number => `${number} день`,
+      dd: number => `${number} дней`,
+      M: number => `${number} месяц`,
+      MM: number => `${number} месяцев`,
+      y: number => `${number} год`,
+      yy: number => `${number} лет`
+    } as RelativeTimeSpec,
+    uz: {
+      future: "%sdan keyin",
+      past: "%s avval",
+      s: number => `${number} soniya`,
+      ss: number => `${number} soniya`,
+      m: number => `${number} daqiqa`,
+      mm: number => `${number} daqiqa`,
+      h: number => `${number} soat`,
+      hh: number => `${number} soat`,
+      d: number => `${number} kun`,
+      dd: number => `${number} kun`,
+      M: number => `${number} oy`,
+      MM: number => `${number} oy`,
+      y: number => `${number} yil`,
+      yy: number => `${number} yil`
+    } as RelativeTimeSpec,
+    de: {
+      future: "in %s",
+      past: "vor %s",
+      s: number => `${number === 1 ? "einer" : number} Sekunde${number === 1 ? "" : "n"}`,
+      ss: number => `${number} Sekunde${number === 1 ? "" : "n"}`,
+      m: number => `${number === 1 ? "einer" : number} Minute${number === 1 ? "" : "n"}`,
+      mm: number => `${number} Minute${number === 1 ? "" : "n"}`,
+      h: number => `${number === 1 ? "einer" : number} Stunde${number === 1 ? "" : "n"}`,
+      hh: number => `${number} Stunde${number === 1 ? "" : "n"}`,
+      d: number => `${number === 1 ? "einem" : number} Tag${number === 1 ? "" : "en"}`,
+      dd: number => `${number} Tag${number === 1 ? "" : "en"}`,
+      M: number => `${number === 1 ? "einem" : number} Monat${number === 1 ? "" : "en"}`,
+      MM: number => `${number} Monat${number === 1 ? "" : "en"}`,
+      y: number => `${number === 1 ? "einem" : number} Jahr${number === 1 ? "" : "en"}`,
+      yy: number => `${number} Jahr${number === 1 ? "" : "en"}`
+    } as RelativeTimeSpec,
+    fr: {
+      future: "dans %s",
+      past: "il y a %s",
+      s: number => `quelques secondes`,
+      ss: number => `${number} secondes`,
+      m: number => `une minute`,
+      mm: number => `${number} minutes`,
+      h: number => `une heure`,
+      hh: number => `${number} heures`,
+      d: number => `un jour`,
+      dd: number => `${number} jours`,
+      M: number => `un mois`,
+      MM: number => `${number} mois`,
+      y: number => `un an`,
+      yy: number => `${number} ans`
+    } as RelativeTimeSpec,
+    vi: {
+      future: "sau %s",
+      past: "%s trước",
+      s: number => `${number} giây`,
+      ss: number => `${number} giây`,
+      m: number => `${number} phút`,
+      mm: number => `${number} phút`,
+      h: number => `${number} giờ`,
+      hh: number => `${number} giờ`,
+      d: number => `${number} ngày`,
+      dd: number => `${number} ngày`,
+      M: number => `${number} tháng`,
+      MM: number => `${number} tháng`,
+      y: number => `${number} năm`,
+      yy: number => `${number} năm`
+    } as RelativeTimeSpec,
+    th: {
+      future: "ใน %s",
+      past: "%s ที่แล้ว",
+      s: number => `${number} วินาที`,
+      ss: number => `${number} วินาที`,
+      m: number => `${number} นาที`,
+      mm: number => `${number} นาที`,
+      h: number => `${number} ชั่วโมง`,
+      hh: number => `${number} ชั่วโมง`,
+      d: number => `${number} วัน`,
+      dd: number => `${number} วัน`,
+      M: number => `${number} เดือน`,
+      MM: number => `${number} เดือน`,
+      y: number => `${number} ปี`,
+      yy: number => `${number} ปี`
+    } as RelativeTimeSpec,
+    fil: {
+      future: "sa loob ng %s",
+      past: "%s ang nakalipas",
+      s: number => `${number} segundo`,
+      ss: number => `${number} segundo`,
+      m: number => `${number} minuto`,
+      mm: number => `${number} minuto`,
+      h: number => `${number} oras`,
+      hh: number => `${number} oras`,
+      d: number => `${number} araw`,
+      dd: number => `${number} araw`,
+      M: number => `${number} buwan`,
+      MM: number => `${number} buwan`,
+      y: number => `${number} taon`,
+      yy: number => `${number} taon`
+    } as RelativeTimeSpec,
+  };
+}