@powfix/core-js 0.20.5 → 0.21.0

package/dist/esm/shared/utils/global/flat.mjs

@@ -0,0 +1,113 @@
+// flat.ts
+function isBuffer(obj) {
+    return !!(obj &&
+        obj.constructor &&
+        typeof obj.constructor.isBuffer === 'function' &&
+        obj.constructor.isBuffer(obj));
+}
+function keyIdentity(key) {
+    return key;
+}
+export function flatten(target, opts = {}) {
+    const delimiter = opts.delimiter || '.';
+    const maxDepth = opts.maxDepth;
+    const transformKey = opts.transformKey || keyIdentity;
+    const output = {};
+    function step(object, prev, currentDepth = 1) {
+        Object.keys(object).forEach((key) => {
+            const value = object[key];
+            const isarray = opts.safe && Array.isArray(value);
+            const type = Object.prototype.toString.call(value);
+            const isbuffer = isBuffer(value);
+            const isobject = type === '[object Object]' || type === '[object Array]';
+            const newKey = prev
+                ? `${prev}${delimiter}${transformKey(key)}`
+                : transformKey(key);
+            if (!isarray &&
+                !isbuffer &&
+                isobject &&
+                Object.keys(value).length &&
+                (!maxDepth || currentDepth < maxDepth)) {
+                return step(value, newKey, currentDepth + 1);
+            }
+            output[newKey] = value;
+        });
+    }
+    step(target);
+    return output;
+}
+export function unflatten(target, opts = {}) {
+    const delimiter = opts.delimiter || '.';
+    const overwrite = opts.overwrite || false;
+    const transformKey = opts.transformKey || keyIdentity;
+    const result = {};
+    if (isBuffer(target) ||
+        Object.prototype.toString.call(target) !== '[object Object]') {
+        return target;
+    }
+    function getkey(key) {
+        const parsedKey = Number(key);
+        return isNaN(parsedKey) || key.indexOf('.') !== -1 || opts.object
+            ? key
+            : parsedKey;
+    }
+    function addKeys(keyPrefix, recipient, target) {
+        return Object.keys(target).reduce((res, key) => {
+            res[`${keyPrefix}${delimiter}${key}`] = target[key];
+            return res;
+        }, recipient);
+    }
+    function isEmpty(val) {
+        const type = Object.prototype.toString.call(val);
+        const isArray = type === '[object Array]';
+        const isObject = type === '[object Object]';
+        if (!val) {
+            return true;
+        }
+        else if (isArray) {
+            return !val.length;
+        }
+        else if (isObject) {
+            return !Object.keys(val).length;
+        }
+        return false;
+    }
+    const target2 = Object.keys(target).reduce((res, key) => {
+        const value = target[key];
+        const type = Object.prototype.toString.call(value);
+        const isObject = type === '[object Object]' || type === '[object Array]';
+        if (!isObject || isEmpty(value)) {
+            res[key] = value;
+            return res;
+        }
+        else {
+            return addKeys(key, res, flatten(value, opts));
+        }
+    }, {});
+    Object.keys(target2).forEach((key) => {
+        const split = key.split(delimiter).map(transformKey);
+        let key1 = getkey(split.shift());
+        let key2 = getkey(split[0]);
+        let recipient = result;
+        while (key2 !== undefined) {
+            if (key1 === '__proto__')
+                return;
+            const type = Object.prototype.toString.call(recipient[key1]);
+            const isobject = type === '[object Object]' || type === '[object Array]';
+            if (!overwrite && !isobject && typeof recipient[key1] !== 'undefined') {
+                return;
+            }
+            if ((overwrite && !isobject) || (!overwrite && recipient[key1] == null)) {
+                recipient[key1] =
+                    typeof key2 === 'number' && !opts.object ? [] : {};
+            }
+            recipient = recipient[key1];
+            if (split.length > 0) {
+                key1 = getkey(split.shift());
+                key2 = getkey(split[0]);
+            }
+        }
+        recipient[key1] = unflatten(target2[key], opts);
+    });
+    return result;
+}

package/dist/esm/shared/utils/global/index.mjs

@@ -0,0 +1,15 @@
+export * from './atob.mjs';
+export * from './base64.mjs';
+export * from './between.mjs';
+export * from './btoa.mjs';
+export * from './castArray.mjs';
+export * from './circularDistance.mjs';
+export * from './sleep.mjs';
+export * from './fallbackIfMatch.mjs';
+export * from './fallbackIfNull.mjs';
+export * from './fallbackIfNullish.mjs';
+export * from './fallbackIfUndefined.mjs';
+export * from './firstNonNullish.mjs';
+export * from './flat.mjs';
+export * from './processFirstNonNullish.mjs';
+export * from './pureEnum.mjs';

package/dist/esm/shared/utils/global/processFirstNonNullish.mjs

@@ -0,0 +1,8 @@
+import { firstNonNullish } from "./firstNonNullish.mjs";
+export function processFirstNonNullish(processor, ...args) {
+    const fallback = firstNonNullish(...args);
+    if (fallback == null) {
+        return undefined;
+    }
+    return processor(fallback);
+}

package/dist/esm/shared/utils/global/pureEnum.mjs

@@ -0,0 +1,18 @@
+/**
+ * @deprecated Use Enum instead.
+ */
+export function pureEnum(e) {
+    return Object.entries(e).filter(([key, value]) => !/^-?\d+$/g.test(key) && typeof value !== 'function');
+}
+/**
+ * @deprecated Use Enum instead.
+ */
+export function pureEnumKeys(e) {
+    return pureEnum(e).map(([key]) => key);
+}
+/**
+ * @deprecated Use Enum instead.
+ */
+export function pureEnumValues(e) {
+    return pureEnum(e).map(([, value]) => value);
+}

package/dist/esm/shared/utils/global/sleep.mjs

@@ -0,0 +1 @@
+export const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

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

@@ -0,0 +1,23 @@
+export * from './global/index.mjs';
+export * from './ArrayUtils.mjs';
+export * from './AxiosUtils.mjs';
+export * from './StringUtils.mjs';
+export * from './Uint8ArrayUtils.mjs';
+export * from './UUID.mjs';
+export * from './UUID.types.mjs';
+export * from './UuidUtils.mjs';
+export * from './BooleanUtils.mjs';
+export * from './Calc.mjs';
+export * from './CoordinateUtils.mjs';
+export * from './DateUtils.mjs';
+export * from './Enum.mjs';
+export * from './Enum.types.mjs';
+export * from './I18nUtils.mjs';
+export * from './NumberUtils.mjs';
+export * from './ObjectIdUtils.mjs';
+export * from './Point3Utils.mjs';
+export * from './RandomUtils.mjs';
+export * from './Validator.mjs';
+export * from './JuminNumberUtils.mjs';
+export * from './Sequencer.mjs';
+export * from './try-catch/index.mjs';

package/dist/esm/shared/utils/try-catch/TryCatch.mjs

@@ -0,0 +1,74 @@
+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());
+    });
+};
+/**
+ * Provides a utility class for handling synchronous and asynchronous operations with a consistent try-catch pattern.
+ * It returns a tuple where the first element is the error (or null on success) and the second element is the result (or undefined on error).
+ */
+export class TryCatch {
+    /**
+     * Executes a synchronous function within a try-catch block.
+     * @template T The return type of the function.
+     * @template E The type of the error that might be thrown (defaults to Error).
+     * @param fn The synchronous function to execute.
+     *@param disableLogging console.error is default way of logging on error. You can disable it by setting it true
+     * @returns A tuple containing the result of the function and an error (null if successful).
+     */
+    static function(fn, disableLogging) {
+        try {
+            return [
+                null,
+                fn(),
+            ];
+        }
+        catch (e) {
+            if (!disableLogging) {
+                console.error("ERROR in TryCatch: ", e);
+            }
+            if (e == null) {
+                e = new Error("Unknown error");
+            }
+            return [
+                e,
+                undefined,
+            ];
+        }
+    }
+    /**
+     * Executes an asynchronous function (Promise) within a try-catch block.
+     * @template T The resolved value type of the Promise.
+     * @template E The type of the error that might be rejected (defaults to Error).
+     * @param fn The Promise to await.
+     * @param disableLogging console.error is default way of logging on error. You can disable it by setting it true
+     * @returns A tuple containing the resolved value of the Promise and an error (null if successful).
+     */
+    static asyncFunction(fn, disableLogging) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield fn;
+                return [
+                    null,
+                    data,
+                ];
+            }
+            catch (e) {
+                if (!disableLogging) {
+                    console.error("ERROR in TryCatch: ", e);
+                }
+                if (e == null) {
+                    e = new Error("Unknown error");
+                }
+                return [
+                    e,
+                    undefined,
+                ];
+            }
+        });
+    }
+}

package/dist/esm/shared/utils/try-catch/index.mjs

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

package/dist/node/cjs/index.nodejs.js

@@ -14,5 +14,8 @@ 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 });
+exports.UUID = void 0;
 __exportStar(require("./shared"), exports);
 __exportStar(require("./nodejs"), exports);
+var nodejs_1 = require("./nodejs");
+Object.defineProperty(exports, "UUID", { enumerable: true, get: function () { return nodejs_1.UUID; } });

package/dist/node/cjs/shared/utils/index.js

@@ -19,7 +19,7 @@ __exportStar(require("./ArrayUtils"), exports);
 __exportStar(require("./AxiosUtils"), exports);
 __exportStar(require("./StringUtils"), exports);
 __exportStar(require("./Uint8ArrayUtils"), exports);
-// export * from './UUID';
+__exportStar(require("./UUID"), exports);
 __exportStar(require("./UUID.types"), exports);
 __exportStar(require("./UuidUtils"), exports);
 __exportStar(require("./BooleanUtils"), exports);

package/dist/node/esm/index.nodejs.mjs

@@ -1,2 +1,3 @@
 export * from './shared/index.mjs';
 export * from './nodejs/index.mjs';
+export { UUID } from "./nodejs/index.mjs";

package/dist/node/esm/shared/utils/index.mjs

@@ -3,7 +3,7 @@ export * from './ArrayUtils.mjs';
 export * from './AxiosUtils.mjs';
 export * from './StringUtils.mjs';
 export * from './Uint8ArrayUtils.mjs';
-// export * from './UUID';
+export * from './UUID.mjs';
 export * from './UUID.types.mjs';
 export * from './UuidUtils.mjs';
 export * from './BooleanUtils.mjs';

package/dist/node/types/index.nodejs.d.ts

@@ -1,2 +1,3 @@
 export * from './shared';
 export * from './nodejs';
+export { UUID } from "./nodejs";

package/dist/node/types/shared/utils/index.d.ts

@@ -3,6 +3,7 @@ export * from './ArrayUtils';
 export * from './AxiosUtils';
 export * from './StringUtils';
 export * from './Uint8ArrayUtils';
+export * from './UUID';
 export * from './UUID.types';
 export * from './UuidUtils';
 export * from './BooleanUtils';

package/dist/types/index.d.ts

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

package/dist/types/shared/constants/COORDINATE.d.ts

@@ -0,0 +1,7 @@
+export declare class COORDINATE {
+    static LATITUDE_MIN_LENGTH: number;
+    static LATITUDE_MAX_LENGTH: number;
+    static LONGITUDE_MIN_LENGTH: number;
+    static LONGITUDE_MAX_LENGTH: number;
+}
+export declare namespace COORDINATE { }

package/dist/types/shared/constants/CRUD.d.ts

@@ -0,0 +1,9 @@
+export declare enum CRUD {
+    CREATE = 1,
+    READ = 2,
+    UPDATE = 3,
+    DELETE = 4
+}
+export declare namespace CRUD {
+    function toString(crud: CRUD): string;
+}

package/dist/types/shared/constants/DATE.d.ts

@@ -0,0 +1,13 @@
+export declare class DATE {
+}
+export declare namespace DATE {
+    enum FORMAT {
+        UNIX = 1,
+        SECONDS = 2,
+        MILLISECONDS = 3,
+        ISO_8601 = 4
+    }
+    namespace FORMAT {
+        function toString(format: FORMAT): string;
+    }
+}

package/dist/types/shared/constants/DISTANCE.d.ts

@@ -0,0 +1,13 @@
+export declare class DISTANCE {
+}
+export declare namespace DISTANCE {
+    enum UNIT {
+        FEET = "FEET",
+        KILOMETERS = "KILOMETERS",
+        MILLIMETERS = "MILLIMETERS",
+        CENTIMETERS = "CENTIMETERS",
+        METERS = "METERS",
+        MILES = "MILES",
+        YARDS = "YARDS"
+    }
+}

package/dist/types/shared/constants/DURATION.d.ts

@@ -0,0 +1,16 @@
+export declare class DURATION {
+}
+export declare namespace DURATION {
+    enum UNIT {
+        NANOSECONDS = "NANOSECONDS",
+        MICROSECONDS = "MICROSECONDS",
+        MILLISECONDS = "MILLISECONDS",
+        SECONDS = "SECONDS",
+        MINUTES = "MINUTES",
+        HOURS = "HOURS",
+        DAYS = "DAYS",
+        YEARS = "YEARS",
+        DECADES = "DECADES",
+        CENTURIES = "CENTURIES"
+    }
+}

package/dist/types/shared/constants/NOT_NULL.d.ts

@@ -0,0 +1 @@
+export declare const NOT_NULL: unique symbol;

package/dist/types/shared/constants/index.d.ts

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

package/dist/types/shared/index.d.ts

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

package/dist/types/shared/interfaces/Coordinate.d.ts

@@ -0,0 +1,8 @@
+export interface Coordinate {
+    latitude: number;
+    longitude: number;
+}
+export interface CoordinateM {
+    lat: number;
+    lon: number;
+}

package/dist/types/shared/interfaces/Point2.d.ts

@@ -0,0 +1,4 @@
+export interface Point2 {
+    x: number;
+    y: number;
+}

package/dist/types/shared/interfaces/Point3.d.ts

@@ -0,0 +1,4 @@
+import { Point2 } from "./Point2";
+export interface Point3 extends Point2 {
+    z: number;
+}

package/dist/types/shared/interfaces/StorageProvider.d.ts

@@ -0,0 +1,7 @@
+export interface StorageProvider {
+    key?: () => string;
+    set: (key: string, value: string) => Promise<void> | void;
+    get: (key: string) => Promise<string | null> | (string | null);
+    remove: (key: string) => Promise<void> | void;
+    clear?: () => Promise<void> | void;
+}

package/dist/types/shared/interfaces/index.d.ts

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

package/dist/types/shared/managers/SessionManager.d.ts

@@ -0,0 +1,15 @@
+import { AxiosInstance } from "axios";
+import { StorageProvider } from "../interfaces/StorageProvider";
+import EventEmitter from 'eventemitter3';
+import { SessionManagerEvent, SessionManagerOptions } from "./SessionManager.type";
+export declare class SessionManager extends EventEmitter<SessionManagerEvent> {
+    private static readonly DEFAULT_AUTHORIZATION_STORAGE_KEY;
+    protected api: AxiosInstance;
+    protected storageProvider: StorageProvider;
+    constructor(options: SessionManagerOptions);
+    private get key();
+    hasAuthorization(): Promise<boolean>;
+    getAuthorization(): Promise<string | null>;
+    setAuthorization(authorization?: string | null): Promise<string | null>;
+    removeAuthorization(): Promise<void>;
+}

package/dist/types/shared/managers/SessionManager.type.d.ts

@@ -0,0 +1,9 @@
+import { AxiosInstance } from "axios";
+import { StorageProvider } from "../interfaces/StorageProvider";
+export interface SessionManagerOptions {
+    api: AxiosInstance;
+    storageProvider: StorageProvider;
+}
+export type SessionManagerEvent = {
+    AUTHORIZATION_CHANGED: (authorization: string | null) => void;
+};

package/dist/types/shared/managers/index.d.ts

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

package/dist/types/shared/scripts/base64Polyfill.d.ts

@@ -0,0 +1 @@
+export declare const base64Polyfill: () => void;

package/dist/types/shared/scripts/index.d.ts

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

package/dist/types/shared/services/index.d.ts

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

package/dist/types/shared/services/time/TimeService.d.ts

@@ -0,0 +1,31 @@
+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 syncedAt?;
+    protected syncInterval?: number | null;
+    protected clientTimeProvider?: TimeServiceClientTimeProvider;
+    protected serverTimeProvider?: TimeServiceServerTimeProvider;
+    static calculateNTPResultOffset(ntpResult: TimeServiceNtpResult): TimeServiceOffset;
+    constructor(options?: 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 | 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<TimeServiceOffset | null>;
+    startSync(): void;
+    stopSync(): void;
+}

package/dist/types/shared/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/types/shared/services/time/index.d.ts

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

package/dist/types/shared/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/types/shared/types/PartialExcept.d.ts

@@ -0,0 +1 @@
+export type PartialExcept<T, K extends keyof T> = Pick<T, K> & Partial<Omit<T, K>>;

package/dist/types/shared/types/index.d.ts

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

package/dist/types/shared/utils/ArrayUtils.d.ts

@@ -0,0 +1,12 @@
+export declare class ArrayUtils {
+    static castArray<T>(value: T | T[]): T[];
+    /**
+     * 객체를 요소로 가지는 배열에서 가장 큰 값(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[];
+    static allValuesEqual<T>(...values: T[]): boolean;
+}

package/dist/types/shared/utils/AxiosUtils.d.ts

@@ -0,0 +1,5 @@
+import { AxiosHeaderValue } from "axios";
+export declare class AxiosUtils {
+    static headerValue2String(value: AxiosHeaderValue | undefined): string | null;
+    static headerValue2Number(value: AxiosHeaderValue | undefined): number | null;
+}

package/dist/types/shared/utils/BooleanUtils.d.ts

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

package/dist/types/shared/utils/Calc.d.ts

@@ -0,0 +1,4 @@
+export declare class Calc {
+    static average(...values: number[]): number;
+    static median(...values: number[]): number;
+}

package/dist/types/shared/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/types/shared/utils/DateUtils.d.ts

@@ -0,0 +1,24 @@
+import { MomentInput, RelativeTimeSpec } from "moment";
+import { DATE } from "../constants/DATE";
+export declare class DateUtils {
+    static isPositiveInteger(value: unknown, strict?: boolean): boolean;
+    static isMilliseconds(value: unknown, strict?: boolean): boolean;
+    static isSeconds(value: unknown, strict?: boolean): boolean;
+    static isUnix(value: unknown, strict?: boolean): boolean;
+    static isISO8601(value: unknown): boolean;
+    static isValid(value: unknown, format?: DATE.FORMAT, strict?: boolean): boolean;
+    static from(value: unknown, format?: DATE.FORMAT, strict?: boolean): Date;
+    static fromUnix(value: unknown, strict?: boolean): Date;
+    static fromSeconds(value: unknown, strict?: boolean): Date;
+    static fromMilliseconds(value: unknown, strict?: boolean): Date;
+    static fromISO8601(value: string): Date;
+    static relativeDate: (input: MomentInput, base?: MomentInput) => string;
+    static setLocale: (language: DateUtils.Locale) => void;
+    private static getRelativeTimeSpec;
+}
+export declare namespace DateUtils {
+    type Locale = string;
+    const relativeTimeSpecs: {
+        [key: Locale]: RelativeTimeSpec;
+    };
+}

package/dist/types/shared/utils/Enum.d.ts

@@ -0,0 +1,16 @@
+import type { EnumEntries } from "./Enum.types";
+export declare class Enum<E extends object> {
+    static entries<E extends object>(e: E): EnumEntries<E>;
+    static keys<E extends object>(e: E): ({ [K in keyof E]: E[K] extends Function ? never : K; }[keyof E] extends infer R ? R extends never ? never : R : never)[];
+    static values<E extends object>(e: E): ({ [K in keyof E]: E[K] extends Function ? never : E[K]; }[keyof E] extends infer R ? R extends never ? never : R : never)[];
+    static from<E extends object>(e: E): Enum<E>;
+    private readonly _e;
+    private readonly _entries;
+    private readonly _keys;
+    private readonly _values;
+    constructor(e: E);
+    value(): E;
+    entries(): EnumEntries<E>;
+    keys(): ({ [K in keyof E]: E[K] extends Function ? never : K; }[keyof E] extends infer R ? R extends never ? never : R : never)[];
+    values(): ({ [K in keyof E]: E[K] extends Function ? never : E[K]; }[keyof E] extends infer R ? R extends never ? never : R : never)[];
+}

package/dist/types/shared/utils/Enum.types.d.ts

@@ -0,0 +1,6 @@
+type NonFunction<T, Type extends "keys" | "values"> = {
+    [K in keyof T]: T[K] extends Function ? never : Type extends "keys" ? K : T[K];
+}[keyof T] extends infer R ? (R extends never ? never : R) : never;
+export type EnumEntry<E extends object> = [NonFunction<E, "keys">, NonFunction<E, "values">];
+export type EnumEntries<E extends object> = EnumEntry<E>[];
+export {};