@powfix/core-js 0.9.22 → 0.9.24

package/.yarnrc

@@ -0,0 +1 @@
+registry https://nexus.vhd.kr/repository/yarn-proxy/

package/dist/src/services/time/TimeService.d.ts

@@ -1,13 +1,21 @@
-/// <reference types="node" />
-import EventEmitter from "events";
+import EventEmitter3 from 'eventemitter3';
+export declare enum TimeServiceStatus {
+    STOPPED = 0,
+    RUNNING = 1
+}
+export declare enum TimeServiceEvent {
+    SYNCED = "SYNCED",
+    SYNC_INTERVAL_CHANGED = "SYNC_INTERVAL_CHANGED"
+}
 export declare class TimeService {
-    protected status: TimeService.Status;
+    private static readonly DEFAULT_SYNC_INTERVAL;
+    protected status: TimeServiceStatus;
     private offset?;
     private option;
     private syncedAt?;
     private emitter;
-    readonly on: (eventName: string | symbol, listener: (...args: any[]) => void) => EventEmitter;
-    readonly off: (eventName: string | symbol, listener: (...args: any[]) => void) => EventEmitter;
+    readonly on: <T extends string | symbol>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter3<string | symbol, any>;
+    readonly off: <T extends string | symbol>(event: T, fn?: ((...args: any[]) => void) | undefined, context?: any, once?: boolean | undefined) => EventEmitter3<string | symbol, any>;
     private readonly emit;
     static calculateNTPResultOffset(ntpResult: TimeService.NTPResult): TimeService.Offset;
     constructor(option: TimeService.Option);
@@ -25,7 +33,7 @@ export declare class TimeService {
     getServerTime(): TimeService.TimeStamp | null;
     getTime(): number;
     private readonly fetchServerNTPResult;
-    getStatus(): TimeService.Status;
+    getStatus(): TimeServiceStatus;
     start(): void;
     stop(): void;
     sync(): Promise<TimeService.Offset | null>;
@@ -34,11 +42,6 @@ export declare class TimeService {
     private stopSync;
 }
 export declare namespace TimeService {
-    const DEFAULT_SYNC_INTERVAL: number;
-    enum Status {
-        STOPPED = 0,
-        RUNNING = 1
-    }
     type Offset = number;
     type TimeStamp = number;
     interface NTPResult {
@@ -57,8 +60,4 @@ export declare namespace TimeService {
         clientTimeProvider?: ClientTimeProvider | undefined;
         serverTimeProvider?: ServerTimeProvider | undefined;
     }
-    enum EVENT {
-        SYNCED = "SYNCED",
-        SYNC_INTERVAL_CHANGED = "SYNC_INTERVAL_CHANGED"
-    }
 }

package/dist/src/services/time/TimeService.js

@@ -12,18 +12,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimeService = void 0;
-const events_1 = __importDefault(require("events"));
+exports.TimeService = exports.TimeServiceEvent = exports.TimeServiceStatus = void 0;
+const eventemitter3_1 = __importDefault(require("eventemitter3"));
 const LOG_TAG = 'TimeService';
+var TimeServiceStatus;
+(function (TimeServiceStatus) {
+    TimeServiceStatus[TimeServiceStatus["STOPPED"] = 0] = "STOPPED";
+    TimeServiceStatus[TimeServiceStatus["RUNNING"] = 1] = "RUNNING";
+})(TimeServiceStatus || (exports.TimeServiceStatus = TimeServiceStatus = {}));
+var TimeServiceEvent;
+(function (TimeServiceEvent) {
+    TimeServiceEvent["SYNCED"] = "SYNCED";
+    TimeServiceEvent["SYNC_INTERVAL_CHANGED"] = "SYNC_INTERVAL_CHANGED";
+})(TimeServiceEvent || (exports.TimeServiceEvent = TimeServiceEvent = {}));
 class TimeService {
     static calculateNTPResultOffset(ntpResult) {
         const { t1, t2, t3, t4 } = ntpResult;
         return ((t2 - t1) + (t3 - t4)) / 2;
     }
     constructor(option) {
-        this.status = TimeService.Status.STOPPED;
+        this.status = TimeServiceStatus.STOPPED;
         // Emitter
-        this.emitter = new events_1.default({});
+        this.emitter = new eventemitter3_1.default();
         this.on = this.emitter.on;
         this.off = this.emitter.off;
         this.emit = this.emitter.emit;
@@ -73,7 +83,7 @@ class TimeService {
     setSyncedAt(syncedAt) {
         this.syncedAt = syncedAt;
         // Emit
-        this.emit(TimeService.EVENT.SYNCED, syncedAt);
+        this.emit(TimeServiceEvent.SYNCED, syncedAt);
         return syncedAt;
     }
     getSyncInterval() {
@@ -90,8 +100,8 @@ class TimeService {
     setSyncInterval(interval) {
         this.option.syncInterval = interval;
         // Emit
-        this.emit(TimeService.EVENT.SYNC_INTERVAL_CHANGED, interval);
-        if (this.status === TimeService.Status.RUNNING) {
+        this.emit(TimeServiceEvent.SYNC_INTERVAL_CHANGED, interval);
+        if (this.status === TimeServiceStatus.RUNNING) {
             if (this.syncHandler !== undefined) {
                 this.stopSync();
                 this.startSync();
@@ -124,24 +134,24 @@ class TimeService {
         return this.status;
     }
     start() {
-        if (this.status !== TimeService.Status.STOPPED) {
+        if (this.status !== TimeServiceStatus.STOPPED) {
             console.warn(LOG_TAG, 'service is not stopped');
             return;
         }
         // Change status
-        this.status = TimeService.Status.RUNNING;
+        this.status = TimeServiceStatus.RUNNING;
         // Sync immediately
         this.sync().finally(() => { });
         // Start sync
         this.startSync();
     }
     stop() {
-        if (this.status !== TimeService.Status.RUNNING) {
+        if (this.status !== TimeServiceStatus.RUNNING) {
             console.warn(LOG_TAG, 'service is not running');
             return;
         }
         // Change status
-        this.status = TimeService.Status.RUNNING;
+        this.status = TimeServiceStatus.RUNNING;
         // Stop sync
         this.stopSync();
         // Reset offset
@@ -220,16 +230,4 @@ class TimeService {
     ;
 }
 exports.TimeService = TimeService;
-(function (TimeService) {
-    TimeService.DEFAULT_SYNC_INTERVAL = 60000;
-    let Status;
-    (function (Status) {
-        Status[Status["STOPPED"] = 0] = "STOPPED";
-        Status[Status["RUNNING"] = 1] = "RUNNING";
-    })(Status = TimeService.Status || (TimeService.Status = {}));
-    let EVENT;
-    (function (EVENT) {
-        EVENT["SYNCED"] = "SYNCED";
-        EVENT["SYNC_INTERVAL_CHANGED"] = "SYNC_INTERVAL_CHANGED";
-    })(EVENT = TimeService.EVENT || (TimeService.EVENT = {}));
-})(TimeService || (exports.TimeService = TimeService = {}));
+TimeService.DEFAULT_SYNC_INTERVAL = 60000;

package/dist/src/utils/Sequencer.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" />
-import EventEmitter from 'events';
+import EventEmitter3 from 'eventemitter3';
 export interface Sequence {
     key: string;
     required?: boolean;
@@ -30,7 +29,7 @@ export declare class Sequencer {
     currentSequence: Sequence | null;
     startTimestamp: number | null;
     endTimestamp: number | null;
-    eventEmitter: EventEmitter;
+    eventEmitter: EventEmitter3<string | symbol, any>;
     constructor(option?: SequencerOption);
     get getCurrentTimeStamp(): number;
     get executionTime(): number | null;

package/dist/src/utils/Sequencer.js

@@ -14,7 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sequencer = exports.SequencerEvent = exports.SequencerStatus = void 0;
 const moment_1 = __importDefault(require("moment/moment"));
-const events_1 = __importDefault(require("events"));
+const eventemitter3_1 = __importDefault(require("eventemitter3"));
 var SequencerStatus;
 (function (SequencerStatus) {
     SequencerStatus[SequencerStatus["IDLE"] = 0] = "IDLE";
@@ -39,7 +39,7 @@ class Sequencer {
         this.startTimestamp = null;
         this.endTimestamp = null;
         // Emitter
-        this.eventEmitter = new events_1.default();
+        this.eventEmitter = new eventemitter3_1.default();
         this.pushSequence = (sequence) => {
             this.sequences.push(sequence);
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powfix/core-js",
-  "version": "0.9.22",
+  "version": "0.9.24",
   "description": "core package",
   "author": "Kwon Kyung-Min <powfix@gmail.com>",
   "private": false,
@@ -23,6 +23,7 @@
   },
   "dependencies": {
     "base-64": "^1.0.0",
+    "eventemitter3": "^5.0.1",
     "jwt-decode": "^4.0.0",
     "redis": "^4.6.11",
     "uuid": "9.0.1"

package/src/services/time/TimeService.ts

@@ -1,15 +1,27 @@
-import EventEmitter from "events";
+import EventEmitter3 from 'eventemitter3';
 
 const LOG_TAG: string = 'TimeService';
 
+export enum TimeServiceStatus {
+  STOPPED = 0,
+  RUNNING = 1,
+}
+
+export enum TimeServiceEvent {
+  SYNCED = 'SYNCED',
+  SYNC_INTERVAL_CHANGED = 'SYNC_INTERVAL_CHANGED',
+}
+
 export class TimeService {
-  protected status: TimeService.Status = TimeService.Status.STOPPED;
+  private static readonly DEFAULT_SYNC_INTERVAL: number = 60000;
+
+  protected status: TimeServiceStatus = TimeServiceStatus.STOPPED;
   private offset?: TimeService.Offset | undefined;
   private option: TimeService.Option;
   private syncedAt?: TimeService.TimeStamp | undefined;
 
   // Emitter
-  private emitter = new EventEmitter({});
+  private emitter = new EventEmitter3();
   public readonly on = this.emitter.on;
   public readonly off = this.emitter.off;
   private readonly emit = this.emitter.emit;
@@ -68,7 +80,7 @@ export class TimeService {
     this.syncedAt = syncedAt;
 
     // Emit
-    this.emit(TimeService.EVENT.SYNCED, syncedAt);
+    this.emit(TimeServiceEvent.SYNCED, syncedAt);
 
     return syncedAt;
   }
@@ -91,9 +103,9 @@ export class TimeService {
     this.option.syncInterval = interval;
 
     // Emit
-    this.emit(TimeService.EVENT.SYNC_INTERVAL_CHANGED, interval);
+    this.emit(TimeServiceEvent.SYNC_INTERVAL_CHANGED, interval);
 
-    if (this.status === TimeService.Status.RUNNING) {
+    if (this.status === TimeServiceStatus.RUNNING) {
       if (this.syncHandler !== undefined) {
         this.stopSync();
         this.startSync();
@@ -137,18 +149,18 @@ export class TimeService {
     return null;
   }
 
-  public getStatus(): TimeService.Status {
+  public getStatus(): TimeServiceStatus {
     return this.status;
   }
 
   public start() {
-    if (this.status !== TimeService.Status.STOPPED) {
+    if (this.status !== TimeServiceStatus.STOPPED) {
       console.warn(LOG_TAG, 'service is not stopped');
       return;
     }
 
     // Change status
-    this.status = TimeService.Status.RUNNING;
+    this.status = TimeServiceStatus.RUNNING;
 
     // Sync immediately
     this.sync().finally(() => {});
@@ -158,13 +170,13 @@ export class TimeService {
   }
 
   public stop() {
-    if (this.status !== TimeService.Status.RUNNING) {
+    if (this.status !== TimeServiceStatus.RUNNING) {
       console.warn(LOG_TAG, 'service is not running');
       return;
     }
 
     // Change status
-    this.status = TimeService.Status.RUNNING;
+    this.status = TimeServiceStatus.RUNNING;
 
     // Stop sync
     this.stopSync();
@@ -260,13 +272,6 @@ export class TimeService {
 }
 
 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;
 
@@ -296,9 +301,4 @@ export namespace TimeService {
     clientTimeProvider?: ClientTimeProvider | undefined;
     serverTimeProvider?: ServerTimeProvider | undefined;
   }
-
-  export enum EVENT {
-    SYNCED = 'SYNCED',
-    SYNC_INTERVAL_CHANGED = 'SYNC_INTERVAL_CHANGED',
-  }
 }

package/src/utils/Sequencer.ts

@@ -1,5 +1,5 @@
 import moment from "moment/moment";
-import EventEmitter from 'events';
+import EventEmitter3 from 'eventemitter3';
 
 export interface Sequence {
   key: string;                          // 고유키값
@@ -40,7 +40,7 @@ export class Sequencer {
   endTimestamp: number | null = null;
 
   // Emitter
-  eventEmitter = new EventEmitter();
+  eventEmitter = new EventEmitter3();
 
   constructor(option?: SequencerOption) {
     if (option?.sequences) {