@powfix/core-js 0.9.22

package/dist/src/services/redis/RedisPublisher.d.ts

@@ -0,0 +1,13 @@
+import { RedisClient } from "./RedisClient";
+export declare class RedisPublisher extends RedisClient {
+    private logging;
+    constructor(options?: RedisClient.RedisClientOptions);
+    start(): Promise<RedisClient.Status>;
+    stop(): Promise<RedisClient.Status>;
+    setLogging(logging: RedisPublisher.LOGGING): void;
+    getLogging(): RedisPublisher.LOGGING;
+    publish: (channel: string, data: string | object) => Promise<void>;
+}
+export declare namespace RedisPublisher {
+    type LOGGING = 'none' | 'length' | 'data';
+}

package/dist/src/services/redis/RedisPublisher.js

@@ -0,0 +1,61 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisPublisher = void 0;
+const RedisClient_1 = require("./RedisClient");
+class RedisPublisher extends RedisClient_1.RedisClient {
+    constructor(options) {
+        super(options);
+        this.logging = 'length';
+        // Make public method
+        this.publish = (channel, data) => __awaiter(this, void 0, void 0, function* () {
+            const stringifyData = typeof data !== 'string' ? JSON.stringify(data) : data;
+            switch (this.logging) {
+                case "none": {
+                    break;
+                }
+                case "length": {
+                    console.log(Date.now(), 'Server ---> Redis', channel, stringifyData.length);
+                    break;
+                }
+                case "data": {
+                    console.log(Date.now(), 'Server ---> Redis', channel, stringifyData);
+                    break;
+                }
+            }
+            yield this.client.publish(channel, stringifyData);
+        });
+        console.log(Date.now(), "RedisPublisher", 'initialized');
+    }
+    start() {
+        const _super = Object.create(null, {
+            start: { get: () => super.start }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.start.call(this);
+        });
+    }
+    stop() {
+        const _super = Object.create(null, {
+            stop: { get: () => super.stop }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _super.stop.call(this);
+        });
+    }
+    setLogging(logging) {
+        this.logging = logging;
+    }
+    getLogging() {
+        return this.logging;
+    }
+}
+exports.RedisPublisher = RedisPublisher;

package/dist/src/services/redis/RedisSubscriber.d.ts

@@ -0,0 +1,11 @@
+import { RedisClient } from "./RedisClient";
+import { PubSubListener } from "@redis/client/dist/lib/client/pub-sub";
+export declare class RedisSubscriber extends RedisClient {
+    constructor(options?: RedisClient.RedisClientOptions);
+    subscribe: <T extends boolean = false>(channels: string | string[], listener: PubSubListener<T>, bufferMode?: T | undefined) => Promise<void>;
+    unsubscribe: <T extends boolean = false>(channels: string | string[], listener?: PubSubListener<T> | undefined, bufferMode?: T | undefined) => Promise<void>;
+    start(): Promise<RedisClient.Status>;
+    stop(): Promise<RedisClient.Status>;
+    protected registerListeners(): Promise<void>;
+    protected unregisterListeners(): Promise<void>;
+}

package/dist/src/services/redis/RedisSubscriber.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisSubscriber = void 0;
+const RedisClient_1 = require("./RedisClient");
+class RedisSubscriber extends RedisClient_1.RedisClient {
+    constructor(options) {
+        super(options);
+        this.subscribe = (channels, listener, bufferMode) => __awaiter(this, void 0, void 0, function* () {
+            for (const channel of Array.isArray(channels) ? channels : [channels]) {
+                if ((/\*/g).test(channel)) {
+                    yield this.client.pSubscribe(channel, listener, bufferMode);
+                }
+                else {
+                    yield this.client.subscribe(channel, listener, bufferMode);
+                }
+            }
+        });
+        this.unsubscribe = (channels, listener, bufferMode) => __awaiter(this, void 0, void 0, function* () {
+            for (const channel of Array.isArray(channels) ? channels : [channels]) {
+                if ((/\*/g).test(channel)) {
+                    yield this.client.pUnsubscribe(channel, listener, bufferMode);
+                }
+                else {
+                    yield this.client.unsubscribe(channel, listener, bufferMode);
+                }
+            }
+        });
+        console.log(Date.now(), 'Subscriber', 'initialized');
+    }
+    start() {
+        const _super = Object.create(null, {
+            start: { get: () => super.start }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const status = yield _super.start.call(this);
+            yield this.registerListeners();
+            return status;
+        });
+    }
+    stop() {
+        const _super = Object.create(null, {
+            stop: { get: () => super.stop }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const status = yield _super.stop.call(this);
+            yield this.unregisterListeners();
+            return status;
+        });
+    }
+    registerListeners() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    unregisterListeners() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+}
+exports.RedisSubscriber = RedisSubscriber;

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Files
+__exportStar(require("./RedisClient"), exports);
+__exportStar(require("./RedisPublisher"), exports);
+__exportStar(require("./RedisSubscriber"), exports);

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

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import EventEmitter from "events";
+export declare class TimeService {
+    protected status: TimeService.Status;
+    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;
+    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;
+    setSyncInterval(interval: TimeService.Option['syncInterval']): void;
+    getClientTime(defaultValue?: TimeService.TimeStamp): TimeService.TimeStamp;
+    getServerTime(): TimeService.TimeStamp | null;
+    getTime(): number;
+    private readonly fetchServerNTPResult;
+    getStatus(): TimeService.Status;
+    start(): void;
+    stop(): void;
+    sync(): Promise<TimeService.Offset | null>;
+    private syncHandler?;
+    private startSync;
+    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 {
+        t1: TimeStamp;
+        t2: TimeStamp;
+        t3: TimeStamp;
+        t4: TimeStamp;
+    }
+    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;
+    }
+    enum EVENT {
+        SYNCED = "SYNCED",
+        SYNC_INTERVAL_CHANGED = "SYNC_INTERVAL_CHANGED"
+    }
+}

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

@@ -0,0 +1,235 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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"));
+const LOG_TAG = 'TimeService';
+class TimeService {
+    static calculateNTPResultOffset(ntpResult) {
+        const { t1, t2, t3, t4 } = ntpResult;
+        return ((t2 - t1) + (t3 - t4)) / 2;
+    }
+    constructor(option) {
+        this.status = TimeService.Status.STOPPED;
+        // Emitter
+        this.emitter = new events_1.default({});
+        this.on = this.emitter.on;
+        this.off = this.emitter.off;
+        this.emit = this.emitter.emit;
+        this.fetchServerNTPResult = (t1) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (typeof this.option.serverTimeProvider === 'function') {
+                    return yield this.option.serverTimeProvider(t1);
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+            return null;
+        });
+        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);
+    }
+    getOption() {
+        return this.option;
+    }
+    setOption(option) {
+        return this.option = option;
+    }
+    getOffset(defaultValue) {
+        if (this.offset !== undefined) {
+            return this.offset;
+        }
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        return undefined;
+    }
+    setOffset(offset) {
+        return this.offset = offset;
+    }
+    getSyncedAt() {
+        return this.syncedAt;
+    }
+    setSyncedAt(syncedAt) {
+        this.syncedAt = syncedAt;
+        // Emit
+        this.emit(TimeService.EVENT.SYNCED, syncedAt);
+        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;
+    }
+    setSyncInterval(interval) {
+        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();
+            }
+        }
+    }
+    getClientTime(defaultValue = Date.now()) {
+        try {
+            if (typeof this.option.clientTimeProvider === 'function') {
+                return this.option.clientTimeProvider();
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return defaultValue;
+    }
+    getServerTime() {
+        const offset = this.getOffset();
+        if (offset === undefined) {
+            return null;
+        }
+        const clientTime = this.getClientTime();
+        return clientTime + offset;
+    }
+    getTime() {
+        return this.getServerTime() || this.getClientTime();
+    }
+    getStatus() {
+        return this.status;
+    }
+    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();
+    }
+    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);
+    }
+    sync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // T1 (Client Request Time)
+                const requestedAt = Date.now();
+                // Fetch server time from server
+                const serverNtpResult = yield 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 = Date.now();
+                const 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;
+        });
+    }
+    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);
+    }
+    ;
+    stopSync() {
+        if (this.syncHandler === undefined) {
+            return;
+        }
+        clearInterval(this.syncHandler);
+        this.syncHandler = undefined;
+    }
+    ;
+}
+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 = {}));

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./TimeService"), exports);

package/dist/src/types/IntRage.d.ts

@@ -0,0 +1,3 @@
+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;
+export {};

package/dist/src/types/IntRage.js

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

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

@@ -0,0 +1,10 @@
+export declare class ArrayUtils {
+    /**
+     * 객체를 요소로 가지는 배열에서 가장 큰 값(Property)를 가지는 객체를 반환한다
+     * @param e 객체 배열
+     * @param key 값을 비교할 Property 키
+     */
+    static getGreatestObject(e: any[], key: string): any;
+    static removeDuplicate<T>(arr: T[]): T[];
+    static removeObjectDuplicate(arr: any[], key: string): any[];
+}

package/dist/src/utils/ArrayUtils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayUtils = void 0;
+class ArrayUtils {
+    /**
+     * 객체를 요소로 가지는 배열에서 가장 큰 값(Property)를 가지는 객체를 반환한다
+     * @param e 객체 배열
+     * @param key 값을 비교할 Property 키
+     */
+    static getGreatestObject(e, key) {
+        return e.reduce((prev, current) => ((prev[key] > current[key] ? prev : current)));
+    }
+    static removeDuplicate(arr) {
+        return [...new Set(arr)];
+    }
+    static removeObjectDuplicate(arr, key) {
+        return arr.filter((v, i, self) => (i === self.findIndex(e => (e[key] === v[key]))));
+    }
+}
+exports.ArrayUtils = ArrayUtils;

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

@@ -0,0 +1 @@
+export declare function parseBoolean(value: any, defaultValue: boolean): boolean;

package/dist/src/utils/BooleanUtils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBoolean = void 0;
+function parseBoolean(value, defaultValue) {
+    if (value === undefined || value === null)
+        return defaultValue;
+    return (value === 'true' || value === true) || (value === 1 || value === '1');
+}
+exports.parseBoolean = parseBoolean;

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

@@ -0,0 +1,8 @@
+import { Coordinate } from "../interfaces/Coordinate";
+export declare class CoordinateUtils {
+    static isValidLatitude(latitude: Coordinate['latitude'] | string): boolean;
+    static isValidLongitude(longitude: Coordinate['longitude'] | string): boolean;
+    static isValidLatitudeLongitude(latitude: Coordinate['latitude'] | string, longitude: Coordinate['longitude'] | string): boolean;
+    static isValidCoordinate(coordinate: Coordinate): boolean;
+    static crowDistance(...coordinates: Coordinate[]): number;
+}

package/dist/src/utils/CoordinateUtils.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoordinateUtils = void 0;
+class CoordinateUtils {
+    static isValidLatitude(latitude) {
+        return /^-?([0-8]?[0-9]|90)(\.[0-9]{1,15})$/.test(latitude.toString());
+    }
+    static isValidLongitude(longitude) {
+        return /^-?([0-9]{1,2}|1[0-7][0-9]|180)(\.[0-9]{1,14})$/.test(longitude.toString());
+    }
+    static isValidLatitudeLongitude(latitude, longitude) {
+        return CoordinateUtils.isValidLatitude(latitude) && CoordinateUtils.isValidLongitude(longitude);
+    }
+    static isValidCoordinate(coordinate) {
+        return this.isValidLatitudeLongitude(coordinate.latitude, coordinate.longitude);
+    }
+    static crowDistance(...coordinates) {
+        if (coordinates.length <= 2) {
+            const toRad = (value) => 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 = 0;
+        for (let i = 0; i < coordinates.length - 1; ++i) {
+            totalDistance += this.crowDistance(coordinates[i], coordinates[i + 1]);
+        }
+        return totalDistance;
+    }
+}
+exports.CoordinateUtils = CoordinateUtils;

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

@@ -0,0 +1,12 @@
+import { MomentInput, RelativeTimeSpec } from "moment";
+export declare class DateUtils {
+    static relativeDate: (input: MomentInput, from?: MomentInput) => string;
+    static setLocale: (language: DateUtils.Locale) => void;
+    private static getRelativeTimeSpec;
+}
+export declare namespace DateUtils {
+    type Locale = string;
+    const relativeTimeSpecs: {
+        [key: Locale]: RelativeTimeSpec;
+    };
+}