@powfix/core-js 0.21.6 → 0.22.1

package/dist/index.browser.d.ts

@@ -0,0 +1,484 @@
+import { AxiosInstance, AxiosHeaderValue } from 'axios';
+import EventEmitter from 'eventemitter3';
+import base64 from 'base-64';
+import { MomentInput, RelativeTimeSpec } from 'moment';
+import { Resource } from 'i18next';
+
+declare class COORDINATE {
+    static LATITUDE_MIN_LENGTH: number;
+    static LATITUDE_MAX_LENGTH: number;
+    static LONGITUDE_MIN_LENGTH: number;
+    static LONGITUDE_MAX_LENGTH: number;
+}
+declare namespace COORDINATE { }
+
+declare enum CRUD {
+    CREATE = 1,
+    READ = 2,
+    UPDATE = 3,
+    DELETE = 4
+}
+declare namespace CRUD {
+    function toString(crud: CRUD): string;
+}
+
+declare class DATE {
+}
+declare namespace DATE {
+    enum FORMAT {
+        UNIX = 1,
+        SECONDS = 2,
+        MILLISECONDS = 3,
+        ISO_8601 = 4
+    }
+    namespace FORMAT {
+        function toString(format: FORMAT): string;
+    }
+}
+
+declare class DISTANCE {
+}
+declare namespace DISTANCE {
+    enum UNIT {
+        FEET = "FEET",
+        KILOMETERS = "KILOMETERS",
+        MILLIMETERS = "MILLIMETERS",
+        CENTIMETERS = "CENTIMETERS",
+        METERS = "METERS",
+        MILES = "MILES",
+        YARDS = "YARDS"
+    }
+}
+
+declare class DURATION {
+}
+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"
+    }
+}
+
+declare const NOT_NULL: unique symbol;
+
+interface Coordinate {
+    latitude: number;
+    longitude: number;
+}
+interface CoordinateM {
+    lat: number;
+    lon: number;
+}
+
+interface Point2 {
+    x: number;
+    y: number;
+}
+
+interface Point3 extends Point2 {
+    z: number;
+}
+
+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;
+}
+
+interface SessionManagerOptions {
+    api: AxiosInstance;
+    storageProvider: StorageProvider;
+}
+type SessionManagerEvent = {
+    AUTHORIZATION_CHANGED: (authorization: string | null) => void;
+};
+
+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>;
+}
+
+declare const base64Polyfill: () => void;
+
+type TimeServiceOffset = number;
+type TimeServiceTimeStamp = number;
+interface TimeServiceNtpResult {
+    t1: TimeServiceTimeStamp;
+    t2: TimeServiceTimeStamp;
+    t3: TimeServiceTimeStamp;
+    t4: TimeServiceTimeStamp;
+}
+interface TimeServiceServerNtpResult extends Pick<TimeServiceNtpResult, 't2' | 't3'> {
+}
+type TimeServiceClientTimeProvider = () => TimeServiceTimeStamp;
+type TimeServiceServerTimeProvider = (t1: TimeServiceNtpResult['t1']) => (TimeServiceServerNtpResult | null) | (Promise<TimeServiceServerNtpResult | null>);
+type TimeServiceEvent = {
+    SYNCED: (offset: TimeServiceOffset, syncedAt: TimeServiceTimeStamp) => void;
+    SYNC_INTERVAL_CHANGED: (interval: number | undefined) => void;
+};
+interface TimeServiceOptions {
+    syncInterval?: number;
+    clientTimeProvider?: TimeServiceClientTimeProvider;
+    serverTimeProvider?: TimeServiceServerTimeProvider;
+}
+
+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;
+}
+
+type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N ? Acc[number] : Enumerate<N, [...Acc, Acc['length']]>;
+type IntRange<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>> | T;
+
+type PartialExcept<T, K extends keyof T> = Pick<T, K> & Partial<Omit<T, K>>;
+
+declare const atob: typeof base64.decode;
+
+declare function encodeBase64(str: string): string;
+declare function decodeBase64(base64: string): string;
+
+declare const between: (value: number, from: number, to: number) => boolean;
+
+declare const btoa: typeof base64.encode;
+
+declare function castArray<T>(value: T | T[]): T[];
+
+declare function circularDistance(value: number, target: number, min: number, max: number): number;
+
+declare const sleep: (ms: number) => Promise<unknown>;
+
+declare function fallbackIfMatch<V, C, F>(value: V, condition: C, fallback: F): V | F;
+
+declare function fallbackIfNull<V, F>(value: V, fallback: F): V | F;
+
+declare function fallbackIfNullish<T, F>(value: T | null | undefined, fallback: F): T | F;
+
+declare function fallbackIfUndefined<V, F>(value: V, fallback: F): V | F;
+
+declare function firstNonNullish<T>(...args: T[]): NonNullable<T> | undefined;
+
+interface FlattenOptions {
+    delimiter?: string;
+    maxDepth?: number;
+    safe?: boolean;
+    transformKey?: (key: string) => string;
+}
+interface UnflattenOptions {
+    delimiter?: string;
+    object?: boolean;
+    overwrite?: boolean;
+    transformKey?: (key: string) => string;
+}
+declare function flatten<T extends object>(target: T, opts?: FlattenOptions): Record<string, any>;
+declare function unflatten<T extends object>(target: T, opts?: UnflattenOptions): any;
+
+declare function processFirstNonNullish<T, R>(processor: (nonNullish: NonNullable<T>) => R, ...args: T[]): R | undefined;
+
+type NonFunction$1<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;
+type PureEnumReturnType<E extends object> = [NonFunction$1<E, "keys">, NonFunction$1<E, "values">][];
+/**
+ * @deprecated Use Enum instead.
+ */
+declare function pureEnum<E extends object>(e: E): PureEnumReturnType<E>;
+/**
+ * @deprecated Use Enum instead.
+ */
+declare function pureEnumKeys<E extends object>(e: E): NonFunction$1<E, "keys">[];
+/**
+ * @deprecated Use Enum instead.
+ */
+declare function pureEnumValues<E extends object>(e: E): NonFunction$1<E, "values">[];
+
+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;
+}
+
+declare class AxiosUtils {
+    static headerValue2String(value: AxiosHeaderValue | undefined): string | null;
+    static headerValue2Number(value: AxiosHeaderValue | undefined): number | null;
+}
+
+declare class StringUtils {
+    static numberWithCommas(x: string | any): string;
+    static getByte(s: string): number;
+    static levenshteinDistance: (str1?: string, str2?: string) => number;
+}
+
+declare class Uint8ArrayUtils {
+    static fromHex(hex: string): Uint8Array;
+    static toHex(bytes: Uint8Array): string;
+}
+
+declare class UuidUtils {
+    static v4(): string;
+    static format(uuid: string): string;
+    /**
+     * (UUID: Buffer) to (UUID: string)
+     * @param binary UUID
+     * @returns {string|null} When binary not exists return null
+     */
+    static toString(binary: Uint8Array): string;
+    /** (UUID: string) to (UUID: Buffer) */
+    static toBuffer(uuid: string): Buffer;
+    static toBuffer(uuid: string | null | undefined): Buffer | null;
+    static isValidUUID(uuid: string): boolean;
+}
+
+declare function parseBoolean(value: any, defaultValue: boolean): boolean;
+
+declare class Calc {
+    static average(...values: number[]): number;
+    static median(...values: number[]): number;
+}
+
+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;
+}
+
+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;
+}
+declare namespace DateUtils {
+    type Locale = string;
+    const relativeTimeSpecs: {
+        [key: Locale]: RelativeTimeSpec;
+    };
+}
+
+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;
+type EnumEntry<E extends object> = [NonFunction<E, "keys">, NonFunction<E, "values">];
+type EnumEntries<E extends object> = EnumEntry<E>[];
+
+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)[];
+}
+
+declare class I18nUtils {
+    static mergeResources(...resources: Resource[]): Resource;
+}
+
+declare class NumberUtils {
+    static formatWithThousandsSeparator(value: number, separator?: string): string;
+    static formatBigNumber(value: number, precision?: number): string;
+}
+
+declare class ObjectIdUtils {
+    static toUuid(objectId: string, pad?: 'start' | 'end'): string;
+    static fromUuid(uuid: string, pad?: 'start' | 'end'): string;
+}
+
+declare class Point3Utils {
+    static distance(p1: Point3, p2: Point3): number;
+}
+
+declare class RandomUtils {
+    static randomNumber(min: number, max: number): number;
+    static randomLatinStrings(length: number): string;
+    static randomLatinLowercaseStrings(length: number): string;
+    static randomLatinUppercaseStrings(length: number): string;
+    static randomNumberStrings(length: number): string;
+    static randomStrings(length: number): string;
+}
+
+declare class Validator {
+    static validate(value: string | null | undefined, options: Validator.Options): {
+        result: boolean;
+        validations: Validator.VALIDATION[];
+        passes: Validator.VALIDATION[];
+        errors: Validator.VALIDATION[];
+    };
+}
+declare namespace Validator {
+    enum VALIDATION {
+        MIN_LENGTH = "MIN_LENGTH",
+        MAX_LENGTH = "MAX_LENGTH",
+        SPACE_MIN_COUNT = "SPACE_MIN_COUNT",
+        SPACE_MAX_COUNT = "SPACE_MAX_COUNT",
+        NUMBER_MIN_COUNT = "NUMBER_MIN_COUNT",
+        NUMBER_MAX_COUNT = "NUMBER_MAX_COUNT",
+        ALPHABET_MIN_COUNT = "ALPHABET_MIN_COUNT",
+        ALPHABET_MAX_COUNT = "ALPHABET_MAX_COUNT",
+        ALPHABET_LOWER_CASE_MIN_COUNT = "ALPHABET_LOWER_CASE_MIN_COUNT",
+        ALPHABET_LOWER_CASE_MAX_COUNT = "ALPHABET_LOWER_CASE_MAX_COUNT",
+        ALPHABET_UPPER_CASE_MIN_COUNT = "ALPHABET_UPPER_CASE_MIN_COUNT",
+        ALPHABET_UPPER_CASE_MAX_COUNT = "ALPHABET_UPPER_CASE_MAX_COUNT",
+        SPECIAL_CHARACTER_MIN_COUNT = "SPECIAL_CHARACTER_MIN_COUNT",
+        SPECIAL_CHARACTER_MAX_COUNT = "SPECIAL_CHARACTER_MAX_COUNT",
+        STARTS_WITH_ALPHABET = "STARTS_WITH_ALPHABET",
+        STARTS_WITH_NUMBER = "STARTS_WITH_NUMBER",
+        STARTS_WITH_SPECIAL_CHARACTER = "STARTS_WITH_SPECIAL_CHARACTER"
+    }
+    interface Options {
+        minLength?: number;
+        maxLength?: number;
+        spaceMinCount?: number;
+        spaceMaxCount?: number;
+        numberMinCount?: number;
+        numberMaxCount?: number;
+        alphabetMinCount?: number;
+        alphabetMaxCount?: number;
+        alphabetLowerCaseMinCount?: number;
+        alphabetLowerCaseMaxCount?: number;
+        alphabetUpperCaseMinCount?: number;
+        alphabetUpperCaseMaxCount?: number;
+        specialCharacterMinCount?: number;
+        specialCharacterMaxCount?: number;
+        startsWithNumber?: boolean;
+        startsWithAlphabet?: boolean;
+        startsWithSpecialCharacter?: boolean;
+    }
+}
+
+declare class JuminNumberUtils {
+    static calculateX(juminNumber: string): number;
+    static isValid(juminNumber: string): boolean;
+}
+
+interface Sequence {
+    key: string;
+    required?: boolean;
+    minimumExecutionTime?: number;
+    task: Function;
+    description?: string;
+}
+declare enum SequencerStatus {
+    IDLE = 0,
+    RUNNING = 1,
+    ERROR = 2,
+    DONE = 3
+}
+interface SequencerOption {
+    sequences?: Sequence[];
+    minimumExecutionTime?: number;
+}
+declare enum SequencerEvent {
+    START = "START",
+    END = "END",
+    SEQUENCE_START = "SEQUENCE_START",
+    SEQUENCE_END = "SEQUENCE_END"
+}
+declare class Sequencer {
+    protected readonly sequences: Sequence[];
+    protected status: SequencerStatus;
+    protected minimumExecutionTime: number;
+    currentSequence: Sequence | null;
+    startTimestamp: number | null;
+    endTimestamp: number | null;
+    eventEmitter: EventEmitter<string | symbol, any>;
+    constructor(option?: SequencerOption);
+    get getCurrentTimeStamp(): number;
+    get executionTime(): number | null;
+    pushSequence: (sequence: Sequence) => void;
+    start: () => Promise<undefined>;
+}
+
+/**
+ * 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).
+ */
+declare 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<T, E = Error>(fn: () => T, disableLogging?: boolean): readonly [null, T] | readonly [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<T, E = Error>(fn: Promise<T>, disableLogging?: boolean): Promise<readonly [null, Awaited<T>] | readonly [E, undefined]>;
+}
+
+export { ArrayUtils, AxiosUtils, COORDINATE, CRUD, Calc, type Coordinate, type CoordinateM, CoordinateUtils, DATE, DISTANCE, DURATION, DateUtils, Enum, type EnumEntries, type EnumEntry, type FlattenOptions, I18nUtils, type IntRange, JuminNumberUtils, NOT_NULL, NumberUtils, ObjectIdUtils, type PartialExcept, type Point2, type Point3, Point3Utils, RandomUtils, type Sequence, Sequencer, SequencerEvent, type SequencerOption, SequencerStatus, SessionManager, type SessionManagerEvent, type SessionManagerOptions, type StorageProvider, StringUtils, TimeService, type TimeServiceClientTimeProvider, type TimeServiceEvent, type TimeServiceNtpResult, type TimeServiceOffset, type TimeServiceOptions, type TimeServiceServerNtpResult, type TimeServiceServerTimeProvider, type TimeServiceTimeStamp, TryCatch, Uint8ArrayUtils, type UnflattenOptions, UuidUtils, Validator, atob, base64Polyfill, between, btoa, castArray, circularDistance, decodeBase64, encodeBase64, fallbackIfMatch, fallbackIfNull, fallbackIfNullish, fallbackIfUndefined, firstNonNullish, flatten, parseBoolean, processFirstNonNullish, pureEnum, pureEnumKeys, pureEnumValues, sleep, unflatten };