@powfix/core-js 0.14.5 → 0.15.0-beta-2

package/dist/{src → server}/utils/ArrayUtils.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArrayUtils = void 0;
-const global_1 = require("./global");
+const index_js_1 = require("./global/index.js");
 class ArrayUtils {
     static castArray(value) {
-        return (0, global_1.castArray)(value);
+        return (0, index_js_1.castArray)(value);
     }
     /**
      * 객체를 요소로 가지는 배열에서 가장 큰 값(Property)를 가지는 객체를 반환한다

package/dist/server/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/server/utils/BooleanUtils.d.ts

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

package/dist/server/utils/Calc.d.ts

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

package/dist/server/utils/CoordinateUtils.d.ts

@@ -0,0 +1,8 @@
+import { Coordinate } from "../interfaces/Coordinate.js";
+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/server/utils/DateUtils.d.ts

@@ -0,0 +1,24 @@
+import { MomentInput, RelativeTimeSpec } from "moment";
+import { DATE } from "../constants/DATE.js";
+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/{src → server}/utils/DateUtils.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DateUtils = void 0;
 const moment_1 = __importDefault(require("moment"));
-const DATE_1 = require("../constants/DATE");
+const DATE_js_1 = require("../constants/DATE.js");
 class DateUtils {
     static isPositiveInteger(value, strict) {
         if (strict) {
@@ -55,12 +55,12 @@ class DateUtils {
         }
         else {
             switch (format) {
-                case DATE_1.DATE.FORMAT.UNIX: return DateUtils.isUnix(value, strict);
-                case DATE_1.DATE.FORMAT.SECONDS: return DateUtils.isSeconds(value, strict);
-                case DATE_1.DATE.FORMAT.MILLISECONDS: return DateUtils.isMilliseconds(value, strict);
-                case DATE_1.DATE.FORMAT.ISO_8601: return DateUtils.isISO8601(value);
+                case DATE_js_1.DATE.FORMAT.UNIX: return DateUtils.isUnix(value, strict);
+                case DATE_js_1.DATE.FORMAT.SECONDS: return DateUtils.isSeconds(value, strict);
+                case DATE_js_1.DATE.FORMAT.MILLISECONDS: return DateUtils.isMilliseconds(value, strict);
+                case DATE_js_1.DATE.FORMAT.ISO_8601: return DateUtils.isISO8601(value);
                 default: {
-                    throw new Error(`unknown format: ${format}(${(_a = DATE_1.DATE.FORMAT.toString(format)) !== null && _a !== void 0 ? _a : 'unknown'})`);
+                    throw new Error(`unknown format: ${format}(${(_a = DATE_js_1.DATE.FORMAT.toString(format)) !== null && _a !== void 0 ? _a : 'unknown'})`);
                 }
             }
         }
@@ -75,34 +75,34 @@ class DateUtils {
         }
         if (format === undefined) {
             if (DateUtils.isMilliseconds(value, strict)) {
-                return DateUtils.from(value, DATE_1.DATE.FORMAT.MILLISECONDS);
+                return DateUtils.from(value, DATE_js_1.DATE.FORMAT.MILLISECONDS);
             }
             if (DateUtils.isISO8601(value)) {
-                return DateUtils.from(value, DATE_1.DATE.FORMAT.ISO_8601);
+                return DateUtils.from(value, DATE_js_1.DATE.FORMAT.ISO_8601);
             }
             throw new Error(`no option to convert value to date`);
         }
         switch (format) {
-            case DATE_1.DATE.FORMAT.UNIX: return new Date(Number(value) * 1000);
-            case DATE_1.DATE.FORMAT.SECONDS: return new Date(Number(value) * 1000);
-            case DATE_1.DATE.FORMAT.MILLISECONDS: return new Date(Number(value));
-            case DATE_1.DATE.FORMAT.ISO_8601: return new Date(value);
+            case DATE_js_1.DATE.FORMAT.UNIX: return new Date(Number(value) * 1000);
+            case DATE_js_1.DATE.FORMAT.SECONDS: return new Date(Number(value) * 1000);
+            case DATE_js_1.DATE.FORMAT.MILLISECONDS: return new Date(Number(value));
+            case DATE_js_1.DATE.FORMAT.ISO_8601: return new Date(value);
             default: {
-                throw new Error(`unknown format: ${format}(${(_a = DATE_1.DATE.FORMAT.toString(format)) !== null && _a !== void 0 ? _a : 'unknown'})`);
+                throw new Error(`unknown format: ${format}(${(_a = DATE_js_1.DATE.FORMAT.toString(format)) !== null && _a !== void 0 ? _a : 'unknown'})`);
             }
         }
     }
     static fromUnix(value, strict) {
-        return DateUtils.from(value, DATE_1.DATE.FORMAT.UNIX, strict);
+        return DateUtils.from(value, DATE_js_1.DATE.FORMAT.UNIX, strict);
     }
     static fromSeconds(value, strict) {
-        return DateUtils.from(value, DATE_1.DATE.FORMAT.SECONDS, strict);
+        return DateUtils.from(value, DATE_js_1.DATE.FORMAT.SECONDS, strict);
     }
     static fromMilliseconds(value, strict) {
-        return DateUtils.from(value, DATE_1.DATE.FORMAT.MILLISECONDS, strict);
+        return DateUtils.from(value, DATE_js_1.DATE.FORMAT.MILLISECONDS, strict);
     }
     static fromISO8601(value) {
-        return DateUtils.from(value, DATE_1.DATE.FORMAT.ISO_8601);
+        return DateUtils.from(value, DATE_js_1.DATE.FORMAT.ISO_8601);
     }
 }
 exports.DateUtils = DateUtils;

package/dist/server/utils/JuminNumberUtils.d.ts

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

package/dist/{src → server}/utils/JuminNumberUtils.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JuminNumberUtils = void 0;
-const between_1 = require("./global/between");
+const between_js_1 = require("./global/between.js");
 class JuminNumberUtils {
     static calculateX(juminNumber) {
         const replacedJuminNumber = juminNumber.replace(/\D/g, '');
-        if (!(0, between_1.between)(replacedJuminNumber.length, 12, 13)) {
+        if (!(0, between_js_1.between)(replacedJuminNumber.length, 12, 13)) {
             throw new Error('Jumin number length must be 12 to 13(without dash)');
         }
         const numbers = replacedJuminNumber.split('').map(e => parseInt(e, 10));

package/dist/server/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/server/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/{src → server}/utils/ObjectIdUtils.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectIdUtils = void 0;
-const UuidUtils_1 = require("./UuidUtils");
+const UuidUtils_js_1 = require("./UuidUtils.js");
 class ObjectIdUtils {
     static toUuid(objectId, pad = 'start') {
         const result = Buffer.alloc(16);
         Buffer.from(objectId, 'hex').copy(result, pad === 'start' ? 4 : 0);
-        return UuidUtils_1.UuidUtils.toString(result);
+        return UuidUtils_js_1.UuidUtils.toString(result);
     }
     static fromUuid(uuid, pad) {
-        const buffer = UuidUtils_1.UuidUtils.toBuffer(uuid);
+        const buffer = UuidUtils_js_1.UuidUtils.toBuffer(uuid);
         const isPadEnd = buffer.subarray(buffer.length - 4).every(byte => byte === 0);
         if (isPadEnd || pad === 'end') {
             return buffer.subarray(0, buffer.length - 4).toString('hex');

package/dist/server/utils/Point3Utils.d.ts

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

package/dist/server/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/server/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/{src → server}/utils/Sequencer.js

@@ -13,7 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sequencer = exports.SequencerEvent = exports.SequencerStatus = void 0;
-const moment_1 = __importDefault(require("moment/moment"));
+const moment_js_1 = __importDefault(require("moment/moment.js"));
 const eventemitter3_1 = __importDefault(require("eventemitter3"));
 var SequencerStatus;
 (function (SequencerStatus) {
@@ -130,7 +130,7 @@ class Sequencer {
         }
     }
     get getCurrentTimeStamp() {
-        return parseInt((0, moment_1.default)().format('x'), 10);
+        return parseInt((0, moment_js_1.default)().format('x'), 10);
     }
     get executionTime() {
         if (this.status === SequencerStatus.IDLE) {

package/dist/server/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/server/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: Buffer): 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/server/utils/UuidUtils.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UuidUtils = void 0;
+const uuid = __importStar(require("uuid"));
+function binaryToString(binary) {
+    return Buffer.from(binary).toString('hex');
+}
+class UuidUtils {
+    static v4() {
+        return uuid.v4();
+    }
+    static format(uuid) {
+        if (uuid.length === 32) {
+            // Without dash: ca23c587d7f84c76be59f53bbc9f91f8
+            return `${uuid.substring(0, 8)}-${uuid.substring(8, 12)}-${uuid.substring(12, 16)}-${uuid.substring(16, 20)}-${uuid.substring(20, 32)}`.toUpperCase();
+        }
+        else if (uuid.length === 36) {
+            // With dash: ca23c587-d7f8-4c76-be59-f53bbc9f91f8
+            return uuid.toUpperCase();
+        }
+        else {
+            // Unexpected uuid
+            console.warn('Unexpected uuid length', uuid);
+            return uuid;
+        }
+    }
+    static toString(binary) {
+        if (!binary)
+            return null;
+        return UuidUtils.format(binaryToString(binary));
+    }
+    static toBuffer(uuid) {
+        if (!uuid) {
+            return null;
+        }
+        return Buffer.from(uuid.replace(/-/g, ''), 'hex');
+    }
+    static isValidUUID(uuid) {
+        if (!uuid)
+            return false;
+        if (typeof uuid !== 'string')
+            return false;
+        return RegExp(/^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/i).test(uuid);
+    }
+}
+exports.UuidUtils = UuidUtils;

package/dist/server/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/server/utils/global/between.d.ts

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

package/dist/server/utils/global/castArray.d.ts

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

package/dist/server/utils/global/circularDistance.d.ts

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

package/dist/server/utils/global/fallbackIfEqual.d.ts

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

package/dist/server/utils/global/fallbackIfNull.d.ts

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

package/dist/{src → server}/utils/global/fallbackIfNull.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fallbackIfNull = fallbackIfNull;
-const fallbackIfEqual_1 = require("./fallbackIfEqual");
+const fallbackIfEqual_js_1 = require("./fallbackIfEqual.js");
 function fallbackIfNull(value, fallback) {
-    return (0, fallbackIfEqual_1.fallbackIfEqual)(value, null, fallback);
+    return (0, fallbackIfEqual_js_1.fallbackIfEqual)(value, null, fallback);
 }

package/dist/server/utils/global/fallbackIfUndefined.d.ts

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

package/dist/{src → server}/utils/global/fallbackIfUndefined.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fallbackIfUndefined = fallbackIfUndefined;
-const fallbackIfEqual_1 = require("./fallbackIfEqual");
+const fallbackIfEqual_js_1 = require("./fallbackIfEqual.js");
 function fallbackIfUndefined(value, fallback) {
-    return (0, fallbackIfEqual_1.fallbackIfEqual)(value, undefined, fallback);
+    return (0, fallbackIfEqual_js_1.fallbackIfEqual)(value, undefined, fallback);
 }

package/dist/server/utils/global/firstNonNullish.d.ts

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

package/dist/server/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/server/utils/global/index.d.ts

@@ -0,0 +1,11 @@
+export * from './between.js';
+export * from './castArray.js';
+export * from './circularDistance.js';
+export * from './sleep.js';
+export * from './fallbackIfEqual.js';
+export * from './fallbackIfNull.js';
+export * from './fallbackIfUndefined.js';
+export * from './firstNonNullish.js';
+export * from './flat.js';
+export * from './processFirstNonNullish.js';
+export * from './pureEnum.js';

package/dist/server/utils/global/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./between.js"), exports);
+__exportStar(require("./castArray.js"), exports);
+__exportStar(require("./circularDistance.js"), exports);
+__exportStar(require("./sleep.js"), exports);
+__exportStar(require("./fallbackIfEqual.js"), exports);
+__exportStar(require("./fallbackIfNull.js"), exports);
+__exportStar(require("./fallbackIfUndefined.js"), exports);
+__exportStar(require("./firstNonNullish.js"), exports);
+__exportStar(require("./flat.js"), exports);
+__exportStar(require("./processFirstNonNullish.js"), exports);
+__exportStar(require("./pureEnum.js"), exports);

package/dist/server/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/{src → server}/utils/global/processFirstNonNullish.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processFirstNonNullish = processFirstNonNullish;
-const firstNonNullish_1 = require("./firstNonNullish");
+const firstNonNullish_js_1 = require("./firstNonNullish.js");
 function processFirstNonNullish(processor, ...args) {
-    const fallback = (0, firstNonNullish_1.firstNonNullish)(...args);
+    const fallback = (0, firstNonNullish_js_1.firstNonNullish)(...args);
     if (fallback == null) {
         return undefined;
     }

package/dist/server/utils/global/pureEnum.d.ts

@@ -0,0 +1,8 @@
+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">][];
+export declare function pureEnum<E extends object>(e: E): PureEnumReturnType<E>;
+export declare function pureEnumKeys<E extends object>(e: E): NonFunction<E, "keys">[];
+export declare function pureEnumValues<E extends object>(e: E): NonFunction<E, "values">[];
+export {};

package/dist/server/utils/global/sleep.d.ts

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

package/dist/server/utils/index.browser.d.ts

@@ -0,0 +1,17 @@
+export * from './global/index.js';
+export * from './ArrayUtils.js';
+export * from './AxiosUtils.js';
+export * from './StringUtils.js';
+export * from './UuidUtils.js';
+export * from './BooleanUtils.js';
+export * from './Calc.js';
+export * from './CoordinateUtils.js';
+export * from './DateUtils.js';
+export * from './NumberUtils.js';
+export * from './ObjectIdUtils.js';
+export * from './Point3Utils.js';
+export * from './RandomUtils.js';
+export * from './Validator.js';
+export * from './JuminNumberUtils.js';
+export * from './Sequencer.js';
+export * from './try-catch/index.js';

package/dist/server/utils/index.browser.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./global/index.js"), exports);
+__exportStar(require("./ArrayUtils.js"), exports);
+__exportStar(require("./AxiosUtils.js"), exports);
+__exportStar(require("./StringUtils.js"), exports);
+__exportStar(require("./UuidUtils.js"), exports);
+__exportStar(require("./BooleanUtils.js"), exports);
+__exportStar(require("./Calc.js"), exports);
+__exportStar(require("./CoordinateUtils.js"), exports);
+__exportStar(require("./DateUtils.js"), exports);
+__exportStar(require("./NumberUtils.js"), exports);
+__exportStar(require("./ObjectIdUtils.js"), exports);
+__exportStar(require("./Point3Utils.js"), exports);
+__exportStar(require("./RandomUtils.js"), exports);
+__exportStar(require("./Validator.js"), exports);
+__exportStar(require("./JuminNumberUtils.js"), exports);
+__exportStar(require("./Sequencer.js"), exports);
+__exportStar(require("./try-catch/index.js"), exports);

package/dist/server/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './index.browser.js';
+export * from './nodejs/index.js';

package/dist/server/utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./index.browser.js"), exports);
+__exportStar(require("./nodejs/index.js"), exports);

package/dist/{src → server}/utils/nodejs/HookUtils.d.ts

@@ -1,4 +1,4 @@
-import { Hook, HookFn } from "../../interfaces";
+import { Hook, HookFn } from "../../interfaces/index.js";
 import { ModelCtor } from "sequelize-typescript";
 export declare class HookUtils {
     static getFkChanges<T>(pFkValue: T | null | undefined, cFkValue: T | null | undefined): {

package/dist/server/utils/nodejs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './HookUtils.js';
+export { SequelizeUtils } from './sequelize-utils/index.js';