@powfix/core-js 0.13.39 → 0.14.0

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

@@ -1,39 +1,36 @@
-import EventEmitter3 from 'eventemitter3';
+import EventEmitter from 'eventemitter3';
 export declare enum TimeServiceStatus {
     STOPPED = 0,
     RUNNING = 1
 }
-export declare class TimeService {
+export declare class TimeService extends EventEmitter<TimeService.Event> {
     private static readonly DEFAULT_SYNC_INTERVAL;
-    protected status: TimeServiceStatus;
+    private static DEFAULT_CLIENT_TIME_PROVIDER;
+    private syncHandler?;
+    private syncInterval?;
+    private clientTimeProvider?;
+    private serverTimeProvider?;
     private offset?;
-    private option;
     private syncedAt?;
-    private emitter;
-    readonly on: <T extends TimeService.Event>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter3<TimeService.Event, any>;
-    readonly off: <T extends TimeService.Event>(event: T, fn?: ((...args: any[]) => void) | undefined, context?: any, once?: boolean) => EventEmitter3<TimeService.Event, any>;
-    private readonly emit;
     static calculateNTPResultOffset(ntpResult: TimeService.NTPResult): TimeService.Offset;
     constructor(option: TimeService.Option);
-    getOption(): TimeService.Option;
-    setOption(option: TimeService.Option): TimeService.Option;
     getOffset(defaultValue: TimeService.Offset): TimeService.Offset;
     getOffset(): TimeService.Offset | undefined;
     setOffset(offset: TimeService.Offset): TimeService.Offset;
     setOffset(offset: TimeService.Offset | undefined): TimeService.Offset;
     getSyncedAt(): TimeService.TimeStamp | undefined;
     private setSyncedAt;
-    getSyncInterval(): number | null;
+    getSyncInterval(): number;
     setSyncInterval(interval: TimeService.Option['syncInterval']): void;
+    getClientTimeProvider(): TimeService.ClientTimeProvider;
+    setClientTimeProvider(provider: TimeService.ClientTimeProvider): void;
     getClientTime(defaultValue?: TimeService.TimeStamp): TimeService.TimeStamp;
+    getServerTimeProvider(): TimeService.ServerTimeProvider | null | undefined;
+    setServerTimeProvider(provider: TimeService.ServerTimeProvider): void;
     getServerTime(): TimeService.TimeStamp | null;
     getTime(): number;
     private fetchServerNTPResult;
-    getStatus(): TimeServiceStatus;
-    start(): void;
-    stop(): void;
     sync(): Promise<TimeService.Offset | null>;
-    private syncHandler?;
     private startSync;
     private stopSync;
 }
@@ -52,9 +49,8 @@ export declare namespace TimeService {
     type ClientTimeProvider = () => TimeStamp;
     type ServerTimeProvider = (t1: NTPResult['t1']) => (ServerNTPResult | null) | (Promise<ServerNTPResult | null>);
     interface Option {
-        autoStart?: boolean;
-        syncInterval?: number | null | undefined;
-        clientTimeProvider?: ClientTimeProvider | undefined;
-        serverTimeProvider?: ServerTimeProvider | undefined;
+        syncInterval?: number;
+        clientTimeProvider?: ClientTimeProvider;
+        serverTimeProvider?: ServerTimeProvider;
     }
 }

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

@@ -20,34 +20,24 @@ var TimeServiceStatus;
     TimeServiceStatus[TimeServiceStatus["STOPPED"] = 0] = "STOPPED";
     TimeServiceStatus[TimeServiceStatus["RUNNING"] = 1] = "RUNNING";
 })(TimeServiceStatus || (exports.TimeServiceStatus = TimeServiceStatus = {}));
-class TimeService {
+class TimeService extends eventemitter3_1.default {
+    static DEFAULT_CLIENT_TIME_PROVIDER() {
+        return Date.now();
+    }
     static calculateNTPResultOffset(ntpResult) {
         const { t1, t2, t3, t4 } = ntpResult;
         return ((t2 - t1) + (t3 - t4)) / 2;
     }
     constructor(option) {
-        this.status = TimeServiceStatus.STOPPED;
-        // Emitter
-        this.emitter = new eventemitter3_1.default();
-        this.on = this.emitter.on.bind(this.emitter);
-        this.off = this.emitter.off.bind(this.emitter);
-        this.emit = this.emitter.emit.bind(this.emitter);
-        this.option = option;
-        if (option.autoStart) {
-            this.start();
-        }
+        super();
+        // Options
+        this.syncInterval = option.syncInterval;
+        this.clientTimeProvider = option.clientTimeProvider;
+        this.serverTimeProvider = option.serverTimeProvider;
         // Bind
         this.sync = this.sync.bind(this);
-        this.start = this.start.bind(this);
-        this.stop = this.stop.bind(this);
         this.fetchServerNTPResult = this.fetchServerNTPResult.bind(this);
     }
-    getOption() {
-        return this.option;
-    }
-    setOption(option) {
-        return this.option = option;
-    }
     getOffset(defaultValue) {
         if (this.offset !== undefined) {
             return this.offset;
@@ -70,41 +60,37 @@ class TimeService {
         return syncedAt;
     }
     getSyncInterval() {
-        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;
+        var _a;
+        return (_a = this.syncInterval) !== null && _a !== void 0 ? _a : TimeService.DEFAULT_SYNC_INTERVAL;
     }
     setSyncInterval(interval) {
-        this.option.syncInterval = interval;
+        this.syncInterval = interval;
         // Emit
         this.emit('SYNC_INTERVAL_CHANGED', interval);
-        if (this.status === TimeServiceStatus.RUNNING) {
-            if (this.syncHandler !== undefined) {
-                this.stopSync();
-                this.startSync();
-            }
+        if (this.syncHandler !== undefined) {
+            this.stopSync();
+            this.startSync();
         }
     }
+    getClientTimeProvider() {
+        var _a;
+        return (_a = this.clientTimeProvider) !== null && _a !== void 0 ? _a : TimeService.DEFAULT_CLIENT_TIME_PROVIDER;
+    }
+    setClientTimeProvider(provider) {
+        this.clientTimeProvider = provider;
+    }
     getClientTime(defaultValue = Date.now()) {
-        try {
-            if (typeof this.option.clientTimeProvider === 'function') {
-                return this.option.clientTimeProvider();
-            }
-        }
-        catch (e) {
-            console.error(e);
-        }
-        return defaultValue;
+        return this.getClientTimeProvider()();
+    }
+    getServerTimeProvider() {
+        return this.serverTimeProvider;
+    }
+    setServerTimeProvider(provider) {
+        this.serverTimeProvider = provider;
     }
     getServerTime() {
         const offset = this.getOffset();
-        if (offset === undefined) {
+        if (offset == null) {
             return null;
         }
         const clientTime = this.getClientTime();
@@ -116,8 +102,9 @@ class TimeService {
     fetchServerNTPResult(t1) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (typeof this.option.serverTimeProvider === 'function') {
-                    return yield this.option.serverTimeProvider(t1);
+                const provider = this.getServerTimeProvider();
+                if (typeof provider === 'function') {
+                    return yield provider(t1);
                 }
             }
             catch (e) {
@@ -126,35 +113,6 @@ class TimeService {
             return null;
         });
     }
-    getStatus() {
-        return this.status;
-    }
-    start() {
-        if (this.status !== TimeServiceStatus.STOPPED) {
-            console.warn(LOG_TAG, 'service is not stopped');
-            return;
-        }
-        // Change status
-        this.status = TimeServiceStatus.RUNNING;
-        // Sync immediately
-        this.sync().finally(() => { });
-        // Start sync
-        this.startSync();
-    }
-    stop() {
-        if (this.status !== TimeServiceStatus.RUNNING) {
-            console.warn(LOG_TAG, 'service is not running');
-            return;
-        }
-        // Change status
-        this.status = TimeServiceStatus.RUNNING;
-        // Stop sync
-        this.stopSync();
-        // Reset offset
-        this.setOffset(undefined);
-        // Reset synced at
-        this.setSyncedAt(undefined);
-    }
     sync() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -205,25 +163,25 @@ class TimeService {
         });
     }
     startSync() {
-        if (this.syncHandler !== undefined) {
-            console.warn('sync handler is not undefined', this.syncHandler);
+        if (this.syncHandler != null) {
+            console.warn('sync is already started');
             return;
         }
         const syncInterval = this.getSyncInterval();
-        if (syncInterval === null) {
+        if (syncInterval == null || syncInterval <= 0) {
+            console.warn('sync is not started', 'syncInterval', syncInterval);
             return;
         }
-        this.syncHandler = setInterval(this.sync, syncInterval);
+        this.syncHandler = setInterval(this.sync.bind(this), syncInterval);
     }
     ;
     stopSync() {
-        if (this.syncHandler === undefined) {
-            return;
+        if (this.syncHandler != null) {
+            clearInterval(this.syncHandler);
+            this.syncHandler = undefined;
         }
-        clearInterval(this.syncHandler);
-        this.syncHandler = undefined;
     }
     ;
 }
 exports.TimeService = TimeService;
-TimeService.DEFAULT_SYNC_INTERVAL = 60000;
+TimeService.DEFAULT_SYNC_INTERVAL = 60 * 1000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powfix/core-js",
-  "version": "0.13.39",
+  "version": "0.14.0",
   "description": "core package",
   "author": "Kwon Kyung-Min <powfix@gmail.com>",
   "private": false,
@@ -43,6 +43,7 @@
     "typescript": "5.8.3"
   },
   "peerDependencies": {
-    "moment": ">=2.0.0"
+    "moment": ">=2.0.0",
+    "eventemitter3": ">=5"
   }
 }