@powfix/core-js 0.13.39 → 0.14.1

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

@@ -1,60 +1,31 @@
-import EventEmitter3 from 'eventemitter3';
-export declare enum TimeServiceStatus {
-    STOPPED = 0,
-    RUNNING = 1
-}
-export declare class TimeService {
-    private static readonly DEFAULT_SYNC_INTERVAL;
-    protected status: TimeServiceStatus;
+import EventEmitter from 'eventemitter3';
+import type { TimeServiceClientTimeProvider, TimeServiceEvent, TimeServiceNtpResult, TimeServiceOffset, TimeServiceOptions, TimeServiceServerTimeProvider, TimeServiceTimeStamp } from "./TimeService.type";
+export declare class TimeService extends EventEmitter<TimeServiceEvent> {
+    private syncHandler?;
     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;
+    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 | null;
-    setSyncInterval(interval: TimeService.Option['syncInterval']): void;
-    getClientTime(defaultValue?: TimeService.TimeStamp): TimeService.TimeStamp;
-    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;
-    getStatus(): TimeServiceStatus;
-    start(): void;
-    stop(): void;
-    sync(): Promise<TimeService.Offset | null>;
-    private syncHandler?;
+    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 {
-        autoStart?: boolean;
-        syncInterval?: number | null | undefined;
-        clientTimeProvider?: ClientTimeProvider | undefined;
-        serverTimeProvider?: ServerTimeProvider | undefined;
-    }
-}

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

@@ -12,42 +12,24 @@ 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 {
+class TimeService extends eventemitter3_1.default {
     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;
@@ -64,60 +46,57 @@ class TimeService {
         return this.syncedAt;
     }
     setSyncedAt(syncedAt) {
-        this.syncedAt = syncedAt;
-        // Emit
-        this.emit('SYNCED', syncedAt);
-        return syncedAt;
+        return (this.syncedAt = 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;
+        return this.syncInterval;
     }
     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();
         }
     }
-    getClientTime(defaultValue = Date.now()) {
-        try {
-            if (typeof this.option.clientTimeProvider === 'function') {
-                return this.option.clientTimeProvider();
-            }
-        }
-        catch (e) {
-            console.error(e);
-        }
-        return defaultValue;
+    getClientTimeProvider() {
+        return this.clientTimeProvider;
+    }
+    setClientTimeProvider(provider) {
+        this.clientTimeProvider = provider !== null && provider !== void 0 ? provider : undefined;
+    }
+    getClientTime() {
+        var _a;
+        return (_a = this.getClientTimeProvider()) === null || _a === void 0 ? void 0 : _a();
+    }
+    getServerTimeProvider() {
+        return this.serverTimeProvider;
+    }
+    setServerTimeProvider(provider) {
+        this.serverTimeProvider = provider !== null && provider !== void 0 ? provider : undefined;
     }
     getServerTime() {
         const offset = this.getOffset();
-        if (offset === undefined) {
-            return null;
+        if (offset == 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* () {
             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 +105,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 {
@@ -196,7 +146,9 @@ class TimeService {
                 // 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);
@@ -205,25 +157,24 @@ 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;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powfix/core-js",
-  "version": "0.13.39",
+  "version": "0.14.1",
   "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"
   }
 }