@powfix/core-js 0.20.5 → 0.21.0

package/dist/esm/shared/constants/COORDINATE.mjs

@@ -0,0 +1,6 @@
+export class COORDINATE {
+}
+COORDINATE.LATITUDE_MIN_LENGTH = 1;
+COORDINATE.LATITUDE_MAX_LENGTH = 10;
+COORDINATE.LONGITUDE_MIN_LENGTH = 1;
+COORDINATE.LONGITUDE_MAX_LENGTH = 11;

package/dist/esm/shared/constants/CRUD.mjs

@@ -0,0 +1,19 @@
+export var CRUD;
+(function (CRUD) {
+    CRUD[CRUD["CREATE"] = 1] = "CREATE";
+    CRUD[CRUD["READ"] = 2] = "READ";
+    CRUD[CRUD["UPDATE"] = 3] = "UPDATE";
+    CRUD[CRUD["DELETE"] = 4] = "DELETE";
+})(CRUD || (CRUD = {}));
+(function (CRUD) {
+    function toString(crud) {
+        switch (crud) {
+            case CRUD.CREATE: return 'Create';
+            case CRUD.READ: return 'Read';
+            case CRUD.UPDATE: return 'Update';
+            case CRUD.DELETE: return 'Delete';
+            default: throw new Error('Unknown crud: ' + crud);
+        }
+    }
+    CRUD.toString = toString;
+})(CRUD || (CRUD = {}));

package/dist/esm/shared/constants/DATE.mjs

@@ -0,0 +1,22 @@
+export class DATE {
+}
+(function (DATE) {
+    let FORMAT;
+    (function (FORMAT) {
+        FORMAT[FORMAT["UNIX"] = 1] = "UNIX";
+        FORMAT[FORMAT["SECONDS"] = 2] = "SECONDS";
+        FORMAT[FORMAT["MILLISECONDS"] = 3] = "MILLISECONDS";
+        FORMAT[FORMAT["ISO_8601"] = 4] = "ISO_8601";
+    })(FORMAT = DATE.FORMAT || (DATE.FORMAT = {}));
+    (function (FORMAT) {
+        function toString(format) {
+            switch (format) {
+                case FORMAT.UNIX: return 'UNIX';
+                case FORMAT.SECONDS: return 'SECONDS';
+                case FORMAT.MILLISECONDS: return 'MILLISECONDS';
+                case FORMAT.ISO_8601: return 'ISO_8601';
+            }
+        }
+        FORMAT.toString = toString;
+    })(FORMAT = DATE.FORMAT || (DATE.FORMAT = {}));
+})(DATE || (DATE = {}));

package/dist/esm/shared/constants/DISTANCE.mjs

@@ -0,0 +1,14 @@
+export class DISTANCE {
+}
+(function (DISTANCE) {
+    let UNIT;
+    (function (UNIT) {
+        UNIT["FEET"] = "FEET";
+        UNIT["KILOMETERS"] = "KILOMETERS";
+        UNIT["MILLIMETERS"] = "MILLIMETERS";
+        UNIT["CENTIMETERS"] = "CENTIMETERS";
+        UNIT["METERS"] = "METERS";
+        UNIT["MILES"] = "MILES";
+        UNIT["YARDS"] = "YARDS";
+    })(UNIT = DISTANCE.UNIT || (DISTANCE.UNIT = {}));
+})(DISTANCE || (DISTANCE = {}));

package/dist/esm/shared/constants/DURATION.mjs

@@ -0,0 +1,17 @@
+export class DURATION {
+}
+(function (DURATION) {
+    let UNIT;
+    (function (UNIT) {
+        UNIT["NANOSECONDS"] = "NANOSECONDS";
+        UNIT["MICROSECONDS"] = "MICROSECONDS";
+        UNIT["MILLISECONDS"] = "MILLISECONDS";
+        UNIT["SECONDS"] = "SECONDS";
+        UNIT["MINUTES"] = "MINUTES";
+        UNIT["HOURS"] = "HOURS";
+        UNIT["DAYS"] = "DAYS";
+        UNIT["YEARS"] = "YEARS";
+        UNIT["DECADES"] = "DECADES";
+        UNIT["CENTURIES"] = "CENTURIES";
+    })(UNIT = DURATION.UNIT || (DURATION.UNIT = {}));
+})(DURATION || (DURATION = {}));

package/dist/esm/shared/constants/NOT_NULL.mjs

@@ -0,0 +1 @@
+export const NOT_NULL = Symbol('!null');

package/dist/esm/shared/constants/index.mjs

@@ -0,0 +1,6 @@
+export * from './COORDINATE.mjs';
+export * from './CRUD.mjs';
+export * from './DATE.mjs';
+export * from './DISTANCE.mjs';
+export * from './DURATION.mjs';
+export * from './NOT_NULL.mjs';

package/dist/esm/shared/index.mjs

@@ -0,0 +1,7 @@
+export * from './constants/index.mjs';
+export * from './interfaces/index.mjs';
+export * from './managers/index.mjs';
+export * from './scripts/index.mjs';
+export * from './services/index.mjs';
+export * from './types/index.mjs';
+export * from './utils/index.mjs';

package/dist/esm/shared/interfaces/Coordinate.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/interfaces/Point2.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/interfaces/Point3.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/interfaces/StorageProvider.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/interfaces/index.mjs

@@ -0,0 +1,4 @@
+export * from './Coordinate.mjs';
+export * from './Point2.mjs';
+export * from './Point3.mjs';
+export * from './StorageProvider.mjs';

package/dist/esm/shared/managers/SessionManager.mjs

@@ -0,0 +1,127 @@
+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());
+    });
+};
+import { jwtDecode } from "jwt-decode";
+import moment from "moment";
+import EventEmitter from 'eventemitter3';
+export class SessionManager extends EventEmitter {
+    constructor(options) {
+        super();
+        // Init service parameters
+        this.api = options.api;
+        this.storageProvider = options.storageProvider;
+        // Logging
+        console.log('SessionManager initialized', Date.now(), options.api);
+    }
+    get key() {
+        try {
+            if (this.storageProvider.key) {
+                return this.storageProvider.key();
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return SessionManager.DEFAULT_AUTHORIZATION_STORAGE_KEY;
+    }
+    hasAuthorization() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return !!(yield this.getAuthorization());
+        });
+    }
+    getAuthorization() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storageProvider.get(this.key);
+        });
+    }
+    setAuthorization(authorization) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (authorization === null) {
+                yield this.removeAuthorization();
+                return null;
+            }
+            let nextAuthorization = yield (() => __awaiter(this, void 0, void 0, function* () {
+                if (authorization === undefined) {
+                    return yield this.getAuthorization();
+                }
+                return authorization;
+            }))();
+            if (!nextAuthorization) {
+                console.log('nextAuthorization is null or undefined');
+                return null;
+            }
+            try {
+                // Replace Bearer prefix
+                nextAuthorization = nextAuthorization.replace(/^Bearer\s+/, '');
+                const decoded = jwtDecode(nextAuthorization);
+                if (!decoded) {
+                    console.warn('JWT decode failed');
+                    return null;
+                }
+                console.log('Session:JWT decoded');
+                (() => {
+                    console.log(' - User', decoded.uuid);
+                    console.log(' - IAT', ...(() => {
+                        if (!decoded.iat) {
+                            return [decoded.iat];
+                        }
+                        const iat = moment.unix(decoded.iat);
+                        if (!iat.isValid()) {
+                            return [decoded.iat];
+                        }
+                        return [decoded.iat, iat.format(), iat.diff(Date.now(), 'days'), 'days left'];
+                    })());
+                    console.log(' - NBF', ...(() => {
+                        if (!decoded.nbf) {
+                            return [decoded.nbf];
+                        }
+                        const nbf = moment.unix(decoded.nbf);
+                        if (!nbf.isValid()) {
+                            return [decoded.nbf];
+                        }
+                        return [decoded.nbf, nbf.format(), nbf.diff(Date.now(), 'days'), 'days left'];
+                    })());
+                    console.log(' - EXP', ...(() => {
+                        if (!decoded.exp) {
+                            return [decoded.exp];
+                        }
+                        const exp = moment.unix(decoded.exp);
+                        if (!exp.isValid()) {
+                            return [decoded.exp];
+                        }
+                        return [decoded.exp, exp.format(), exp.diff(Date.now(), 'days'), 'days left'];
+                    })());
+                })();
+                // AsyncStorage 에 토큰 저장
+                yield this.storageProvider.set(this.key, nextAuthorization);
+                // API Instance header 설정
+                this.api.defaults.headers.common.Authorization = `Bearer ${nextAuthorization}`;
+                // Emit
+                this.emit('AUTHORIZATION_CHANGED', nextAuthorization);
+                // Return
+                return nextAuthorization;
+            }
+            catch (e) {
+                console.error(e);
+            }
+            return null;
+        });
+    }
+    removeAuthorization() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // API Instance header 에서 토큰 제거
+            delete this.api.defaults.headers.common.Authorization;
+            // 스토리지에서 authorization 제거
+            yield this.storageProvider.remove(this.key);
+            // Emit
+            this.emit('AUTHORIZATION_CHANGED', null);
+        });
+    }
+}
+SessionManager.DEFAULT_AUTHORIZATION_STORAGE_KEY = 'AUTHORIZATION';

package/dist/esm/shared/managers/SessionManager.type.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/managers/index.mjs

@@ -0,0 +1,2 @@
+export * from './SessionManager.mjs';
+export * from './SessionManager.type.mjs';

package/dist/esm/shared/scripts/base64Polyfill.mjs

@@ -0,0 +1,11 @@
+import base64 from 'base-64';
+const { decode, encode } = base64;
+export const base64Polyfill = () => {
+    if (!global.btoa) {
+        global.btoa = encode;
+    }
+    if (!global.atob) {
+        global.atob = decode;
+    }
+    console.log('base64-polyfill initialized', Date.now());
+};

package/dist/esm/shared/scripts/index.mjs

@@ -0,0 +1 @@
+export * from './base64Polyfill.mjs';

package/dist/esm/shared/services/index.mjs

@@ -0,0 +1 @@
+export * from './time/index.mjs';

package/dist/esm/shared/services/time/TimeService.mjs

@@ -0,0 +1,173 @@
+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());
+    });
+};
+import EventEmitter from 'eventemitter3';
+const LOG_TAG = 'TimeService';
+export class TimeService extends EventEmitter {
+    static calculateNTPResultOffset(ntpResult) {
+        const { t1, t2, t3, t4 } = ntpResult;
+        return ((t2 - t1) + (t3 - t4)) / 2;
+    }
+    constructor(options) {
+        super();
+        // Options
+        this.syncInterval = options === null || options === void 0 ? void 0 : options.syncInterval;
+        this.clientTimeProvider = options === null || options === void 0 ? void 0 : options.clientTimeProvider;
+        this.serverTimeProvider = options === null || options === void 0 ? void 0 : options.serverTimeProvider;
+        // Bind
+        this.sync = this.sync.bind(this);
+        this.fetchServerNTPResult = this.fetchServerNTPResult.bind(this);
+    }
+    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) {
+        return (this.syncedAt = syncedAt);
+    }
+    getSyncInterval() {
+        return this.syncInterval;
+    }
+    setSyncInterval(interval) {
+        this.syncInterval = interval;
+        // Emit
+        this.emit('SYNC_INTERVAL_CHANGED', interval);
+        if (this.syncHandler !== undefined) {
+            this.stopSync();
+            this.startSync();
+        }
+    }
+    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 == null) {
+            return offset;
+        }
+        const clientTime = this.getClientTime();
+        if (clientTime == null) {
+            return clientTime;
+        }
+        return clientTime + offset;
+    }
+    getTime() {
+        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 {
+                const provider = this.getServerTimeProvider();
+                if (typeof provider === 'function') {
+                    return yield provider(t1);
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+            return null;
+        });
+    }
+    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
+                const syncedAt = Date.now();
+                this.setSyncedAt(syncedAt);
+                this.emit('SYNCED', offset, syncedAt);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            return null;
+        });
+    }
+    startSync() {
+        if (this.syncHandler != null) {
+            console.warn('sync is already started');
+            return;
+        }
+        const syncInterval = this.getSyncInterval();
+        if (syncInterval == null || syncInterval <= 0) {
+            console.warn('sync is not started', 'syncInterval', syncInterval);
+            return;
+        }
+        this.syncHandler = setInterval(this.sync.bind(this), syncInterval);
+    }
+    ;
+    stopSync() {
+        if (this.syncHandler != null) {
+            clearInterval(this.syncHandler);
+            this.syncHandler = undefined;
+        }
+    }
+    ;
+}

package/dist/esm/shared/services/time/TimeService.type.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/services/time/index.mjs

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

package/dist/esm/shared/types/IntRage.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/types/PartialExcept.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/types/index.mjs

@@ -0,0 +1,2 @@
+export * from './IntRage.mjs';
+export * from './PartialExcept.mjs';

package/dist/esm/shared/utils/ArrayUtils.mjs

@@ -0,0 +1,26 @@
+import { castArray } from "./global/index.mjs";
+export class ArrayUtils {
+    static castArray(value) {
+        return castArray(value);
+    }
+    /**
+     * 객체를 요소로 가지는 배열에서 가장 큰 값(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]))));
+    }
+    static allValuesEqual(...values) {
+        if (values.length === 0) {
+            return true;
+        }
+        return values.every((value) => value === values[0]);
+    }
+}

package/dist/esm/shared/utils/AxiosUtils.mjs

@@ -0,0 +1,49 @@
+export class AxiosUtils {
+    static headerValue2String(value) {
+        if (value === undefined) {
+            return null;
+        }
+        if (value === null || typeof value === 'string') {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            if (value.length > 0) {
+                for (const e of value) {
+                    if (typeof e === 'string') {
+                        return e;
+                    }
+                }
+                // There is no any values having string type
+                return null;
+            }
+            else {
+                return null;
+            }
+        }
+        return String(value);
+    }
+    static headerValue2Number(value) {
+        if (value === undefined) {
+            return null;
+        }
+        if (value === null || typeof value === 'number') {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            if (value.length > 0) {
+                for (const e of value) {
+                    if (typeof e === 'number') {
+                        return e;
+                    }
+                }
+                // There is no any values having string type
+                return null;
+            }
+            else {
+                return null;
+            }
+        }
+        const result = Number(value);
+        return isNaN(result) ? null : result;
+    }
+}

package/dist/esm/shared/utils/BooleanUtils.mjs

@@ -0,0 +1,5 @@
+export function parseBoolean(value, defaultValue) {
+    if (value === undefined || value === null)
+        return defaultValue;
+    return (value === 'true' || value === true) || (value === 1 || value === '1');
+}

package/dist/esm/shared/utils/Calc.mjs

@@ -0,0 +1,23 @@
+export class Calc {
+    static average(...values) {
+        const length = values.length;
+        if (length === 0) {
+            return NaN;
+        }
+        let sum = 0;
+        for (let i = 0; i < length; ++i) {
+            sum += values[i];
+        }
+        return sum / length;
+    }
+    static median(...values) {
+        const len = values.length;
+        if (len === 0)
+            return NaN;
+        const sorted = values.slice().sort((a, b) => a - b); // O(n log n)
+        const mid = len >> 1;
+        return len % 2 === 0
+            ? (sorted[mid - 1] + sorted[mid]) / 2
+            : sorted[mid];
+    }
+}

package/dist/esm/shared/utils/CoordinateUtils.mjs

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