@powfix/core-js 0.14.0 → 0.14.2

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

@@ -1,56 +1,31 @@
 import EventEmitter from 'eventemitter3';
-export declare enum TimeServiceStatus {
-    STOPPED = 0,
-    RUNNING = 1
-}
-export declare class TimeService extends EventEmitter<TimeService.Event> {
-    private static readonly DEFAULT_SYNC_INTERVAL;
-    private static DEFAULT_CLIENT_TIME_PROVIDER;
+import type { TimeServiceClientTimeProvider, TimeServiceEvent, TimeServiceNtpResult, TimeServiceOffset, TimeServiceOptions, TimeServiceServerTimeProvider, TimeServiceTimeStamp } from "./TimeService.type";
+export declare class TimeService extends EventEmitter<TimeServiceEvent> {
     private syncHandler?;
-    private syncInterval?;
-    private clientTimeProvider?;
-    private serverTimeProvider?;
     private offset?;
     private syncedAt?;
-    static calculateNTPResultOffset(ntpResult: TimeService.NTPResult): TimeService.Offset;
-    constructor(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;
+    protected syncInterval?: number | null;
+    protected clientTimeProvider?: TimeServiceClientTimeProvider;
+    protected serverTimeProvider?: TimeServiceServerTimeProvider;
+    static calculateNTPResultOffset(ntpResult: TimeServiceNtpResult): TimeServiceOffset;
+    constructor(option: TimeServiceOptions);
+    getOffset(defaultValue: TimeServiceOffset): TimeServiceOffset;
+    getOffset(): TimeServiceOffset | undefined;
+    setOffset(offset: TimeServiceOffset): TimeServiceOffset;
+    setOffset(offset: TimeServiceOffset | undefined): TimeServiceOffset;
+    getSyncedAt(): TimeServiceTimeStamp | undefined;
     private setSyncedAt;
-    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;
+    getSyncInterval(): number | null | undefined;
+    setSyncInterval(interval: TimeServiceOptions['syncInterval']): void;
+    getClientTimeProvider(): TimeServiceClientTimeProvider | undefined;
+    setClientTimeProvider(provider: TimeServiceClientTimeProvider | null | undefined): void;
+    getClientTime(): number | undefined;
+    getServerTimeProvider(): TimeServiceServerTimeProvider | undefined;
+    setServerTimeProvider(provider: TimeServiceServerTimeProvider | null | undefined): void;
+    getServerTime(): number | undefined;
     getTime(): number;
     private fetchServerNTPResult;
-    sync(): Promise<TimeService.Offset | null>;
+    sync(): Promise<TimeServiceOffset | null>;
     private startSync;
     private stopSync;
 }
-export declare namespace TimeService {
-    type Offset = number;
-    type TimeStamp = number;
-    interface NTPResult {
-        t1: TimeStamp;
-        t2: TimeStamp;
-        t3: TimeStamp;
-        t4: TimeStamp;
-    }
-    type Event = 'SYNCED' | 'SYNC_INTERVAL_CHANGED';
-    interface ServerNTPResult extends Pick<NTPResult, 't2' | 't3'> {
-    }
-    type ClientTimeProvider = () => TimeStamp;
-    type ServerTimeProvider = (t1: NTPResult['t1']) => (ServerNTPResult | null) | (Promise<ServerNTPResult | null>);
-    interface Option {
-        syncInterval?: number;
-        clientTimeProvider?: ClientTimeProvider;
-        serverTimeProvider?: ServerTimeProvider;
-    }
-}

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

@@ -12,18 +12,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimeService = exports.TimeServiceStatus = void 0;
+exports.TimeService = 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 = {}));
 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;
@@ -54,14 +46,10 @@ class TimeService extends eventemitter3_1.default {
         return this.syncedAt;
     }
     setSyncedAt(syncedAt) {
-        this.syncedAt = syncedAt;
-        // Emit
-        this.emit('SYNCED', syncedAt);
-        return syncedAt;
+        return (this.syncedAt = syncedAt);
     }
     getSyncInterval() {
-        var _a;
-        return (_a = this.syncInterval) !== null && _a !== void 0 ? _a : TimeService.DEFAULT_SYNC_INTERVAL;
+        return this.syncInterval;
     }
     setSyncInterval(interval) {
         this.syncInterval = interval;
@@ -73,31 +61,35 @@ class TimeService extends eventemitter3_1.default {
         }
     }
     getClientTimeProvider() {
-        var _a;
-        return (_a = this.clientTimeProvider) !== null && _a !== void 0 ? _a : TimeService.DEFAULT_CLIENT_TIME_PROVIDER;
+        return this.clientTimeProvider;
     }
     setClientTimeProvider(provider) {
-        this.clientTimeProvider = provider;
+        this.clientTimeProvider = provider !== null && provider !== void 0 ? provider : undefined;
     }
-    getClientTime(defaultValue = Date.now()) {
-        return this.getClientTimeProvider()();
+    getClientTime() {
+        var _a;
+        return (_a = this.getClientTimeProvider()) === null || _a === void 0 ? void 0 : _a();
     }
     getServerTimeProvider() {
         return this.serverTimeProvider;
     }
     setServerTimeProvider(provider) {
-        this.serverTimeProvider = provider;
+        this.serverTimeProvider = provider !== null && provider !== void 0 ? provider : undefined;
     }
     getServerTime() {
         const offset = this.getOffset();
         if (offset == null) {
-            return null;
+            return offset;
         }
         const clientTime = this.getClientTime();
+        if (clientTime == null) {
+            return clientTime;
+        }
         return clientTime + offset;
     }
     getTime() {
-        return this.getServerTime() || this.getClientTime();
+        var _a, _b;
+        return (_b = (_a = this.getServerTime()) !== null && _a !== void 0 ? _a : this.getClientTime()) !== null && _b !== void 0 ? _b : Date.now();
     }
     fetchServerNTPResult(t1) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -154,7 +146,9 @@ class TimeService extends eventemitter3_1.default {
                 // Save calculated offset
                 this.setOffset(offset);
                 // Mark synced timestamp
-                this.setSyncedAt(Date.now());
+                const syncedAt = Date.now();
+                this.setSyncedAt(syncedAt);
+                this.emit('SYNCED', offset, syncedAt);
             }
             catch (e) {
                 console.error(e);
@@ -184,4 +178,3 @@ class TimeService extends eventemitter3_1.default {
     ;
 }
 exports.TimeService = TimeService;
-TimeService.DEFAULT_SYNC_INTERVAL = 60 * 1000;

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

@@ -0,0 +1,21 @@
+export type TimeServiceOffset = number;
+export type TimeServiceTimeStamp = number;
+export interface TimeServiceNtpResult {
+    t1: TimeServiceTimeStamp;
+    t2: TimeServiceTimeStamp;
+    t3: TimeServiceTimeStamp;
+    t4: TimeServiceTimeStamp;
+}
+export interface TimeServiceServerNtpResult extends Pick<TimeServiceNtpResult, 't2' | 't3'> {
+}
+export type TimeServiceClientTimeProvider = () => TimeServiceTimeStamp;
+export type TimeServiceServerTimeProvider = (t1: TimeServiceNtpResult['t1']) => (TimeServiceServerNtpResult | null) | (Promise<TimeServiceServerNtpResult | null>);
+export type TimeServiceEvent = {
+    SYNCED: (offset: TimeServiceOffset, syncedAt: TimeServiceTimeStamp) => void;
+    SYNC_INTERVAL_CHANGED: (interval: number | undefined) => void;
+};
+export interface TimeServiceOptions {
+    syncInterval?: number;
+    clientTimeProvider?: TimeServiceClientTimeProvider;
+    serverTimeProvider?: TimeServiceServerTimeProvider;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./TimeService"), exports);
+__exportStar(require("./TimeService.type"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powfix/core-js",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "description": "core package",
   "author": "Kwon Kyung-Min <powfix@gmail.com>",
   "private": false,