@powfix/core-js 0.20.5 → 0.21.0

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

@@ -0,0 +1,4 @@
+import type { Resource } from 'i18next';
+export declare class I18nUtils {
+    static mergeResources(...resources: Resource[]): Resource;
+}

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

@@ -0,0 +1,4 @@
+export declare class JuminNumberUtils {
+    static calculateX(juminNumber: string): number;
+    static isValid(juminNumber: string): boolean;
+}

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

@@ -0,0 +1,4 @@
+export declare class NumberUtils {
+    static formatWithThousandsSeparator(value: number, separator?: string): string;
+    static formatBigNumber(value: number, precision?: number): string;
+}

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

@@ -0,0 +1,4 @@
+export declare class ObjectIdUtils {
+    static toUuid(objectId: string, pad?: 'start' | 'end'): string;
+    static fromUuid(uuid: string, pad?: 'start' | 'end'): string;
+}

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

@@ -0,0 +1,4 @@
+import { Point3 } from "../interfaces/Point3";
+export declare class Point3Utils {
+    static distance(p1: Point3, p2: Point3): number;
+}

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

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

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

@@ -0,0 +1,38 @@
+import EventEmitter3 from 'eventemitter3';
+export interface Sequence {
+    key: string;
+    required?: boolean;
+    minimumExecutionTime?: number;
+    task: Function;
+    description?: string;
+}
+export declare enum SequencerStatus {
+    IDLE = 0,
+    RUNNING = 1,
+    ERROR = 2,
+    DONE = 3
+}
+export interface SequencerOption {
+    sequences?: Sequence[];
+    minimumExecutionTime?: number;
+}
+export declare enum SequencerEvent {
+    START = "START",
+    END = "END",
+    SEQUENCE_START = "SEQUENCE_START",
+    SEQUENCE_END = "SEQUENCE_END"
+}
+export declare class Sequencer {
+    protected readonly sequences: Sequence[];
+    protected status: SequencerStatus;
+    protected minimumExecutionTime: number;
+    currentSequence: Sequence | null;
+    startTimestamp: number | null;
+    endTimestamp: number | null;
+    eventEmitter: EventEmitter3<string | symbol, any>;
+    constructor(option?: SequencerOption);
+    get getCurrentTimeStamp(): number;
+    get executionTime(): number | null;
+    pushSequence: (sequence: Sequence) => void;
+    start: () => Promise<undefined>;
+}

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

@@ -0,0 +1,5 @@
+export declare class StringUtils {
+    static numberWithCommas(x: string | any): string;
+    static getByte(s: string): number;
+    static levenshteinDistance: (str1?: string, str2?: string) => number;
+}

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

@@ -0,0 +1,147 @@
+import { UuidInput } from "./UUID.types";
+/**
+ * Represents a UUID (Universally Unique Identifier) and provides various utility
+ * methods for validation, conversion, comparison and creation.
+ */
+export declare class UUID {
+    /** Matches a 32‑character hexadecimal representation of a UUID without hyphens. */
+    private static REGEX_HEX;
+    /** Matches the RFC 4122 canonical UUID format with hyphens. */
+    private static REGEX_RFC4122;
+    /** Number of bytes that represent a UUID. */
+    private static BYTE_LENGTH;
+    /** Total length of an RFC 4122 UUID string (including hyphens). */
+    private static STR_LENGTH;
+    /** Length of a UUID represented as a plain hexadecimal string. */
+    private static HEX_STR_LENGTH;
+    /**
+     * Checks if the supplied value is a valid hex representation of a UUID.
+     * @param hex - The string to validate.
+     * @returns true if the string matches {@link REGEX_HEX}.
+     */
+    static isValidHex(hex: string): boolean;
+    /**
+     * Checks if the supplied value is a valid RFC 4122 UUID string.
+     * @param str - The string to validate.
+     * @returns true if the string matches {@link REGEX_RFC4122}.
+     */
+    static isValidString(str: string): boolean;
+    /**
+     * Checks whether an ArrayBufferView contains exactly {@link BYTE_LENGTH} bytes.
+     * @param bytes - The view to check.
+     * @returns true if the byte length is correct.
+     */
+    static isValidBytes(bytes: ArrayBufferView): boolean;
+    /**
+     * Generic validation that accepts either a string (hex or RFC 4122 format)
+     * or an ArrayBufferView containing the raw bytes.
+     * @param input - The value to validate.
+     * @returns true if the input is a valid representation of a UUID.
+     */
+    static isValid(input: UuidInput): boolean;
+    static version(input: UuidInput): number;
+    /**
+     * Inserts hyphens into a 32‑character hex string to produce an RFC 4122 string.
+     * @param hex - The plain hexadecimal UUID.
+     * @returns The formatted RFC 4122 string.
+     */
+    private static formatHex;
+    /** Removes all hyphens from a UUID string. */
+    private static stripHyphens;
+    /**
+     * Converts a plain hexadecimal UUID into a Uint8Array.
+     * @param hex - The hex string to parse.
+     * @returns A Uint8Array containing the raw bytes.
+     */
+    private static parseHex;
+    /**
+     * Parses an RFC 4122 string into a Uint8Array.
+     * @param str - The formatted UUID string.
+     * @returns A Uint8Array containing the raw bytes.
+     */
+    private static parseString;
+    /**
+     * Parses an ArrayBufferView into a Uint8Array ensuring the correct byte length.
+     * @param bytes - The view to parse.
+     * @returns A Uint8Array containing the raw bytes.
+     */
+    private static parseBytes;
+    /**
+     * Creates a UUID instance from a plain hexadecimal string.
+     * @param hex - The hex representation of the UUID.
+     * @returns A new {@link UUID} object.
+     */
+    static fromHex<T extends typeof UUID>(hex: string): InstanceType<T>;
+    /**
+     * Creates a UUID instance from an RFC 4122 formatted string.
+     * @param str - The UUID string with hyphens.
+     * @returns A new {@link UUID} object.
+     */
+    static fromString<T extends typeof UUID>(str: string): InstanceType<T>;
+    /**
+     * Creates a UUID instance from raw bytes.
+     * @param bytes - An ArrayBufferView containing 16 bytes.
+     * @returns A new {@link UUID} object.
+     */
+    static fromBytes<T extends typeof UUID>(bytes: ArrayBufferView): InstanceType<T>;
+    /**
+     * Parses any supported input (string or bytes) and returns the raw byte array.
+     * @param input - The value to parse.
+     * @returns A Uint8Array of length {@link BYTE_LENGTH}.
+     */
+    private static parse;
+    /**
+     * Creates a UUID from any supported input type.
+     * @param input - The value to parse.
+     * @returns A new {@link UUID} object.
+     */
+    static from<T extends typeof UUID>(this: T, input: UuidInput): InstanceType<T>;
+    /** Returns the nil (all zero) UUID. */
+    static nil<T extends typeof UUID>(this: T): InstanceType<T>;
+    /** Returns a UUID consisting of all 0xFF bytes. */
+    static max<T extends typeof UUID>(this: T): InstanceType<T>;
+    /**
+     * Compares multiple UUIDs for strict equality.
+     * @param inputs - The UUIDs to compare (at least two required).
+     * @returns true if all provided UUIDs are identical.
+     */
+    static equals(...inputs: UuidInput[]): boolean;
+    /**
+     * Lexicographically compares two UUIDs.
+     * @param uuid1 - The first UUID.
+     * @param uuid2 - The second UUID.
+     * @returns -1 if uuid1 < uuid2, 1 if uuid1 > uuid2, 0 otherwise.
+     */
+    static compare(uuid1: UuidInput, uuid2: UuidInput): number;
+    /** Raw byte representation of the UUID. */
+    protected readonly bytes: Uint8Array;
+    private _str?;
+    private _hex?;
+    /**
+     * Constructs a new {@link UUID} instance from any supported input type.
+     * @param input - The value to parse (string or ArrayBufferView).
+     */
+    constructor(input: UuidInput);
+    /** Instance wrapper for {@link equals}. */
+    equals(...inputs: UuidInput[]): boolean;
+    /** Instance wrapper for {@link compare}. */
+    compare(other: UuidInput): number;
+    version(): number;
+    /**
+     * Returns the RFC 4122 string representation of this UUID.
+     * @returns The formatted UUID string.
+     */
+    toString(): string;
+    /**
+     * Returns the plain hexadecimal representation of this UUID.
+     * @returns A 32‑character hex string.
+     */
+    toHex(): string;
+    /**
+     * Returns a copy of the raw byte array.
+     * @returns A new Uint8Array containing the UUID bytes.
+     */
+    toBytes(): Uint8Array;
+    /** JSON serialization helper – returns the RFC 4122 string. */
+    toJSON(): string;
+}

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

@@ -0,0 +1,2 @@
+import { UUID } from "./UUID";
+export type UuidInput = string | ArrayBufferView | UUID;

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

@@ -0,0 +1,4 @@
+export declare class Uint8ArrayUtils {
+    static fromHex(hex: string): Uint8Array;
+    static toHex(bytes: Uint8Array): string;
+}

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

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

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

@@ -0,0 +1,48 @@
+export declare class Validator {
+    static validate(value: string | null | undefined, options: Validator.Options): {
+        result: boolean;
+        validations: Validator.VALIDATION[];
+        passes: Validator.VALIDATION[];
+        errors: Validator.VALIDATION[];
+    };
+}
+export 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;
+    }
+}

package/dist/types/shared/utils/global/atob.d.ts

@@ -0,0 +1,2 @@
+import base64 from "base-64";
+export declare const atob: typeof base64.decode;

package/dist/types/shared/utils/global/base64.d.ts

@@ -0,0 +1,2 @@
+export declare function encodeBase64(str: string): string;
+export declare function decodeBase64(base64: string): string;

package/dist/types/shared/utils/global/between.d.ts

@@ -0,0 +1 @@
+export declare const between: (value: number, from: number, to: number) => boolean;

package/dist/types/shared/utils/global/btoa.d.ts

@@ -0,0 +1,2 @@
+import base64 from "base-64";
+export declare const btoa: typeof base64.encode;

package/dist/types/shared/utils/global/castArray.d.ts

@@ -0,0 +1 @@
+export declare function castArray<T>(value: T | T[]): T[];

package/dist/types/shared/utils/global/circularDistance.d.ts

@@ -0,0 +1 @@
+export declare function circularDistance(value: number, target: number, min: number, max: number): number;

package/dist/types/shared/utils/global/fallbackIfMatch.d.ts

@@ -0,0 +1 @@
+export declare function fallbackIfMatch<V, C, F>(value: V, condition: C, fallback: F): V | F;

package/dist/types/shared/utils/global/fallbackIfNull.d.ts

@@ -0,0 +1 @@
+export declare function fallbackIfNull<V, F>(value: V, fallback: F): V | F;

package/dist/types/shared/utils/global/fallbackIfNullish.d.ts

@@ -0,0 +1 @@
+export declare function fallbackIfNullish<T, F>(value: T | null | undefined, fallback: F): T | F;

package/dist/types/shared/utils/global/fallbackIfUndefined.d.ts

@@ -0,0 +1 @@
+export declare function fallbackIfUndefined<V, F>(value: V, fallback: F): V | F;

package/dist/types/shared/utils/global/firstNonNullish.d.ts

@@ -0,0 +1 @@
+export declare function firstNonNullish<T>(...args: T[]): NonNullable<T> | undefined;

package/dist/types/shared/utils/global/flat.d.ts

@@ -0,0 +1,14 @@
+export interface FlattenOptions {
+    delimiter?: string;
+    maxDepth?: number;
+    safe?: boolean;
+    transformKey?: (key: string) => string;
+}
+export interface UnflattenOptions {
+    delimiter?: string;
+    object?: boolean;
+    overwrite?: boolean;
+    transformKey?: (key: string) => string;
+}
+export declare function flatten<T extends object>(target: T, opts?: FlattenOptions): Record<string, any>;
+export declare function unflatten<T extends object>(target: T, opts?: UnflattenOptions): any;

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

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

package/dist/types/shared/utils/global/processFirstNonNullish.d.ts

@@ -0,0 +1 @@
+export declare function processFirstNonNullish<T, R>(processor: (nonNullish: NonNullable<T>) => R, ...args: T[]): R | undefined;

package/dist/types/shared/utils/global/pureEnum.d.ts

@@ -0,0 +1,17 @@
+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 PureEnumReturnType<E extends object> = [NonFunction<E, "keys">, NonFunction<E, "values">][];
+/**
+ * @deprecated Use Enum instead.
+ */
+export declare function pureEnum<E extends object>(e: E): PureEnumReturnType<E>;
+/**
+ * @deprecated Use Enum instead.
+ */
+export declare function pureEnumKeys<E extends object>(e: E): NonFunction<E, "keys">[];
+/**
+ * @deprecated Use Enum instead.
+ */
+export declare function pureEnumValues<E extends object>(e: E): NonFunction<E, "values">[];
+export {};

package/dist/types/shared/utils/global/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms: number) => Promise<unknown>;

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

@@ -0,0 +1,23 @@
+export * from './global';
+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';
+export * from './Calc';
+export * from './CoordinateUtils';
+export * from './DateUtils';
+export * from './Enum';
+export * from './Enum.types';
+export * from './I18nUtils';
+export * from './NumberUtils';
+export * from './ObjectIdUtils';
+export * from './Point3Utils';
+export * from './RandomUtils';
+export * from './Validator';
+export * from './JuminNumberUtils';
+export * from './Sequencer';
+export * from './try-catch';

package/dist/types/shared/utils/try-catch/TryCatch.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 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]>;
+}

package/dist/types/shared/utils/try-catch/index.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@powfix/core-js",
-	"version": "0.20.5",
+	"version": "0.21.0",
 	"description": "core package",
 	"author": "Kwon Kyung-Min <powfix@gmail.com>",
 	"private": false,
@@ -16,6 +16,12 @@
 	"homepage": "https://github.com/powfix/core-js",
 	"license": "MIT",
 	"exports": {
+		".": {
+			"require": "./dist/cjs/index.js",
+			"import": "./dist/esm/index.mjs",
+			"default": "./dist/cjs/index.js",
+			"types": "./dist/types/index.d.ts"
+		},
 		"./browser": {
 			"require": "./dist/browser/cjs/index.browser.js",
 			"import": "./dist/browser/esm/index.browser.mjs",
@@ -33,9 +39,9 @@
 		"clean": "rm -rf dist | wc -l",
 		"esmfix": "tsc-esm-fix --ext='.mjs'",
 		"prebuild": "yarn clean",
-		"build:esm": "tsc -p tsconfig.browser.esm.json && tsc -p tsconfig.node.esm.json && yarn esmfix",
-		"build:cjs": "tsc -p tsconfig.browser.cjs.json && tsc -p tsconfig.node.cjs.json",
-		"build:types": "tsc -p tsconfig.browser.types.json && tsc -p tsconfig.node.types.json",
+		"build:esm": "tsc -p tsconfig.index.esm.json && tsc -p tsconfig.browser.esm.json && tsc -p tsconfig.node.esm.json && yarn esmfix",
+		"build:cjs": "tsc -p tsconfig.index.cjs.json && tsc -p tsconfig.browser.cjs.json && tsc -p tsconfig.node.cjs.json",
+		"build:types": "tsc -p tsconfig.index.types.json && tsc -p tsconfig.browser.types.json && tsc -p tsconfig.node.types.json",
 		"build": "yarn build:esm && yarn build:cjs && yarn build:types",
 		"deploy": "yarn deploy:patch",
 		"deploy:patch": "npm version patch && npm publish",