@powfix/core-js 0.18.2 → 0.19.0

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

@@ -7,19 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 [
@@ -40,14 +28,6 @@ export class TryCatch {
             ];
         }
     }
-    /**
-     * 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 {

package/dist/node/types/browser/utils/UUID.d.ts

@@ -1,16 +1,28 @@
 export declare class UUID {
+    private static REGEX_HEX;
+    private static REGEX_RFC4122;
     private static BYTE_LENGTH;
+    private static STR_LENGTH;
     private static HEX_STR_LENGTH;
+    static isValidHex(hex: string): boolean;
+    static isValidString(str: string): boolean;
+    static isValidBytes(bytes: ArrayBufferView): boolean;
+    static isValid(input: string | ArrayBufferView): boolean;
     private static formatHex;
     private static stripHyphens;
+    private static parseHex;
     private static parseString;
-    static fromString(str: string): UUID;
     private static parseBytes;
+    static fromHex(hex: string): UUID;
+    static fromString(str: string): UUID;
     static fromBytes(bytes: ArrayBufferView): UUID;
+    private static parse;
+    static from(input: string | ArrayBufferView): UUID;
     static nil(): UUID;
+    static max(): UUID;
     static equals(...uuids: UUID[]): boolean;
     static compare(uuid1: UUID, uuid2: UUID): number;
-    private readonly bytes;
+    protected readonly bytes: Uint8Array;
     private _str?;
     private _hex?;
     constructor(input: string | ArrayBufferView);

package/dist/node/types/nodejs/services/redis/RedisClient.d.ts

@@ -1,8 +1,8 @@
-import redis, { RedisClientType, RedisDefaultModules, RedisFunctions, RedisModules, RedisScripts } from 'redis';
+import redis, { createClient } from 'redis';
 export declare class RedisClient {
     private readonly options;
     private status;
-    readonly client: RedisClientType<RedisDefaultModules & RedisModules, RedisFunctions, RedisScripts>;
+    readonly client: ReturnType<typeof createClient>;
     constructor(options?: RedisClient.RedisClientOptions);
     getStatus(): RedisClient.Status;
     start(): Promise<RedisClient.Status>;

package/dist/node/types/nodejs/utils/UUID.d.ts

@@ -1,3 +1,4 @@
 import { UUID as BaseUUID } from "../../browser/utils/UUID";
 export declare class UUID extends BaseUUID {
+    toBuffer(): Buffer;
 }

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

@@ -1,10 +1,5 @@
 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[];

package/dist/node/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/node/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 {};

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

@@ -1,13 +1,7 @@
 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/node/types/shared/utils/index.d.ts

@@ -8,6 +8,8 @@ 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';

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

@@ -1,24 +1,4 @@
-/**
- * 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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@powfix/core-js",
-	"version": "0.18.2",
+	"version": "0.19.0",
 	"description": "core package",
 	"author": "Kwon Kyung-Min <powfix@gmail.com>",
 	"private": false,
@@ -49,7 +49,6 @@
 		"base-64": "^1.0.0",
 		"eventemitter3": "^5.0.1",
 		"jwt-decode": "^4.0.0",
-		"redis": "4.7.0",
 		"uuid": "9.0.1"
 	},
 	"devDependencies": {
@@ -60,6 +59,7 @@
 		"deepmerge": "^4.3.1",
 		"i18next": "25.4.2",
 		"moment": "^2.30.1",
+		"redis": "^5.8.2",
 		"sequelize": "6.37.7",
 		"sequelize-typescript": "^2.1.6",
 		"ts-node": "^10.9.2",