@powfix/core-js 0.20.4 → 0.21.0

package/dist/cjs/shared/utils/Validator.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+class Validator {
+    static validate(value, options) {
+        value = value || '';
+        const validations = [];
+        const errors = [];
+        const { length } = value;
+        const spaceCount = (value.match(/\s/g) || []).length;
+        const numberCount = (value.match(/\d/g) || []).length;
+        const alphabetCount = (value.match(/[A-Za-z]/g) || []).length;
+        const alphabetLowerCaseCount = (value.match(/[a-z]/g) || []).length;
+        const alphabetUpperCaseCount = (value.match(/[A-Z]/g) || []).length;
+        const specialCount = (value.match(/[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/g) || []).length;
+        const startsWithNumber = /^\d/.test(value);
+        const startsWithAlphabet = /^[A-Za-z]/.test(value);
+        const startsWithSpecialCharacter = /^[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/.test(value);
+        // 최소 길이
+        if (options.minLength !== undefined && options.minLength > -1) {
+            validations.push(Validator.VALIDATION.MIN_LENGTH);
+            if (length < options.minLength) {
+                errors.push(Validator.VALIDATION.MIN_LENGTH);
+            }
+        }
+        // 최대 길이
+        if (options.maxLength !== undefined && options.maxLength > -1) {
+            validations.push(Validator.VALIDATION.MAX_LENGTH);
+            if (length > options.maxLength) {
+                errors.push(Validator.VALIDATION.MAX_LENGTH);
+            }
+        }
+        const validateMin = (option, value, validation) => {
+            if (option !== undefined && option > -1) {
+                validations.push(validation);
+                if (value < option) {
+                    errors.push(validation);
+                }
+            }
+        };
+        const validateMax = (option, value, validation) => {
+            if (option !== undefined && option > -1) {
+                validations.push(validation);
+                if (value > option) {
+                    errors.push(validation);
+                }
+            }
+        };
+        // 공백 개수
+        validateMin(options.spaceMinCount, spaceCount, Validator.VALIDATION.SPACE_MIN_COUNT);
+        validateMax(options.spaceMaxCount, spaceCount, Validator.VALIDATION.SPACE_MAX_COUNT);
+        // 숫자 개수
+        validateMin(options.numberMinCount, numberCount, Validator.VALIDATION.NUMBER_MIN_COUNT);
+        validateMax(options.numberMaxCount, numberCount, Validator.VALIDATION.NUMBER_MAX_COUNT);
+        // 알파벳 개수
+        validateMin(options.alphabetMinCount, alphabetCount, Validator.VALIDATION.ALPHABET_MIN_COUNT);
+        validateMax(options.alphabetMaxCount, alphabetCount, Validator.VALIDATION.ALPHABET_MAX_COUNT);
+        // 알파벳(소문자) 개수
+        validateMin(options.alphabetLowerCaseMinCount, alphabetLowerCaseCount, Validator.VALIDATION.ALPHABET_LOWER_CASE_MIN_COUNT);
+        validateMax(options.alphabetLowerCaseMaxCount, alphabetLowerCaseCount, Validator.VALIDATION.ALPHABET_LOWER_CASE_MAX_COUNT);
+        // 알파벳(대문자) 개수
+        validateMin(options.alphabetUpperCaseMinCount, alphabetUpperCaseCount, Validator.VALIDATION.ALPHABET_UPPER_CASE_MIN_COUNT);
+        validateMax(options.alphabetUpperCaseMaxCount, alphabetUpperCaseCount, Validator.VALIDATION.ALPHABET_UPPER_CASE_MAX_COUNT);
+        // 특수문자 개수
+        validateMin(options.specialCharacterMinCount, specialCount, Validator.VALIDATION.SPECIAL_CHARACTER_MIN_COUNT);
+        validateMax(options.specialCharacterMaxCount, specialCount, Validator.VALIDATION.SPECIAL_CHARACTER_MAX_COUNT);
+        // 숫자로 시작
+        if (options.startsWithNumber) {
+            validations.push(Validator.VALIDATION.STARTS_WITH_NUMBER);
+            if (!startsWithNumber) {
+                errors.push(Validator.VALIDATION.STARTS_WITH_NUMBER);
+            }
+        }
+        // 영문으로 시작
+        if (options.startsWithAlphabet) {
+            validations.push(Validator.VALIDATION.STARTS_WITH_ALPHABET);
+            if (!startsWithAlphabet) {
+                errors.push(Validator.VALIDATION.STARTS_WITH_ALPHABET);
+            }
+        }
+        // 특수문자로 시작
+        if (options.startsWithSpecialCharacter) {
+            validations.push(Validator.VALIDATION.STARTS_WITH_SPECIAL_CHARACTER);
+            if (!startsWithSpecialCharacter) {
+                errors.push(Validator.VALIDATION.STARTS_WITH_SPECIAL_CHARACTER);
+            }
+        }
+        return {
+            result: errors.length === 0,
+            validations,
+            passes: validations.filter(e => !errors.includes(e)),
+            errors,
+        };
+    }
+}
+exports.Validator = Validator;
+(function (Validator) {
+    let VALIDATION;
+    (function (VALIDATION) {
+        VALIDATION["MIN_LENGTH"] = "MIN_LENGTH";
+        VALIDATION["MAX_LENGTH"] = "MAX_LENGTH";
+        VALIDATION["SPACE_MIN_COUNT"] = "SPACE_MIN_COUNT";
+        VALIDATION["SPACE_MAX_COUNT"] = "SPACE_MAX_COUNT";
+        VALIDATION["NUMBER_MIN_COUNT"] = "NUMBER_MIN_COUNT";
+        VALIDATION["NUMBER_MAX_COUNT"] = "NUMBER_MAX_COUNT";
+        VALIDATION["ALPHABET_MIN_COUNT"] = "ALPHABET_MIN_COUNT";
+        VALIDATION["ALPHABET_MAX_COUNT"] = "ALPHABET_MAX_COUNT";
+        VALIDATION["ALPHABET_LOWER_CASE_MIN_COUNT"] = "ALPHABET_LOWER_CASE_MIN_COUNT";
+        VALIDATION["ALPHABET_LOWER_CASE_MAX_COUNT"] = "ALPHABET_LOWER_CASE_MAX_COUNT";
+        VALIDATION["ALPHABET_UPPER_CASE_MIN_COUNT"] = "ALPHABET_UPPER_CASE_MIN_COUNT";
+        VALIDATION["ALPHABET_UPPER_CASE_MAX_COUNT"] = "ALPHABET_UPPER_CASE_MAX_COUNT";
+        VALIDATION["SPECIAL_CHARACTER_MIN_COUNT"] = "SPECIAL_CHARACTER_MIN_COUNT";
+        VALIDATION["SPECIAL_CHARACTER_MAX_COUNT"] = "SPECIAL_CHARACTER_MAX_COUNT";
+        VALIDATION["STARTS_WITH_ALPHABET"] = "STARTS_WITH_ALPHABET";
+        VALIDATION["STARTS_WITH_NUMBER"] = "STARTS_WITH_NUMBER";
+        VALIDATION["STARTS_WITH_SPECIAL_CHARACTER"] = "STARTS_WITH_SPECIAL_CHARACTER";
+    })(VALIDATION = Validator.VALIDATION || (Validator.VALIDATION = {}));
+})(Validator || (exports.Validator = Validator = {}));

package/dist/cjs/shared/utils/global/atob.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.atob = void 0;
+const base_64_1 = __importDefault(require("base-64"));
+const { decode } = base_64_1.default;
+exports.atob = decode;

package/dist/cjs/shared/utils/global/base64.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeBase64 = encodeBase64;
+exports.decodeBase64 = decodeBase64;
+const btoa_1 = require("./btoa");
+const atob_1 = require("./atob");
+function encodeBase64(str) {
+    const encoder = new TextEncoder();
+    const bytes = encoder.encode(str);
+    let binary = '';
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return (0, btoa_1.btoa)(binary);
+}
+function decodeBase64(base64) {
+    const binary = (0, atob_1.atob)(base64);
+    const binaryLength = binary.length;
+    const bytes = new Uint8Array(binaryLength);
+    for (let i = 0; i < binaryLength; ++i) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    const decoder = new TextDecoder('utf-8');
+    return decoder.decode(bytes);
+}

package/dist/cjs/shared/utils/global/between.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.between = void 0;
+const between = (value, from, to) => {
+    return value >= from && value <= to;
+};
+exports.between = between;

package/dist/cjs/shared/utils/global/btoa.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.btoa = void 0;
+const base_64_1 = __importDefault(require("base-64"));
+const { decode, encode } = base_64_1.default;
+exports.btoa = encode;

package/dist/cjs/shared/utils/global/castArray.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.castArray = castArray;
+function castArray(value) {
+    return Array.isArray(value) ? value : [value];
+}

package/dist/cjs/shared/utils/global/circularDistance.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.circularDistance = circularDistance;
+function circularDistance(value, target, min, max) {
+    const range = max - min;
+    const from = value - min;
+    const to = target - min;
+    if (to >= from) {
+        return to - from;
+    }
+    else {
+        return range - from + to;
+    }
+}

package/dist/cjs/shared/utils/global/fallbackIfMatch.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fallbackIfMatch = fallbackIfMatch;
+function fallbackIfMatch(value, condition, fallback) {
+    if (typeof value === typeof condition && value === condition) {
+        return fallback;
+    }
+    return value;
+}

package/dist/cjs/shared/utils/global/fallbackIfNull.js

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

package/dist/cjs/shared/utils/global/fallbackIfNullish.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fallbackIfNullish = fallbackIfNullish;
+function fallbackIfNullish(value, fallback) {
+    if (value == null) {
+        return fallback;
+    }
+    return value;
+}

package/dist/cjs/shared/utils/global/fallbackIfUndefined.js

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

package/dist/cjs/shared/utils/global/firstNonNullish.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstNonNullish = firstNonNullish;
+function firstNonNullish(...args) {
+    if (args == null || !Array.isArray(args) || args.length === 0) {
+        return undefined;
+    }
+    if (args[0] != null) {
+        // Not Nullish
+        return args[0];
+    }
+    return firstNonNullish(...args.slice(1));
+}

package/dist/cjs/shared/utils/global/flat.js

@@ -0,0 +1,117 @@
+"use strict";
+// flat.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatten = flatten;
+exports.unflatten = unflatten;
+function isBuffer(obj) {
+    return !!(obj &&
+        obj.constructor &&
+        typeof obj.constructor.isBuffer === 'function' &&
+        obj.constructor.isBuffer(obj));
+}
+function keyIdentity(key) {
+    return key;
+}
+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;
+}
+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/cjs/shared/utils/global/index.js

@@ -0,0 +1,31 @@
+"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("./atob"), exports);
+__exportStar(require("./base64"), exports);
+__exportStar(require("./between"), exports);
+__exportStar(require("./btoa"), exports);
+__exportStar(require("./castArray"), exports);
+__exportStar(require("./circularDistance"), exports);
+__exportStar(require("./sleep"), exports);
+__exportStar(require("./fallbackIfMatch"), exports);
+__exportStar(require("./fallbackIfNull"), exports);
+__exportStar(require("./fallbackIfNullish"), exports);
+__exportStar(require("./fallbackIfUndefined"), exports);
+__exportStar(require("./firstNonNullish"), exports);
+__exportStar(require("./flat"), exports);
+__exportStar(require("./processFirstNonNullish"), exports);
+__exportStar(require("./pureEnum"), exports);

package/dist/cjs/shared/utils/global/processFirstNonNullish.js

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

package/dist/cjs/shared/utils/global/pureEnum.js

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

package/dist/cjs/shared/utils/global/sleep.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+exports.sleep = sleep;

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

@@ -0,0 +1,39 @@
+"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"), exports);
+__exportStar(require("./ArrayUtils"), exports);
+__exportStar(require("./AxiosUtils"), exports);
+__exportStar(require("./StringUtils"), exports);
+__exportStar(require("./Uint8ArrayUtils"), exports);
+__exportStar(require("./UUID"), exports);
+__exportStar(require("./UUID.types"), exports);
+__exportStar(require("./UuidUtils"), exports);
+__exportStar(require("./BooleanUtils"), exports);
+__exportStar(require("./Calc"), exports);
+__exportStar(require("./CoordinateUtils"), exports);
+__exportStar(require("./DateUtils"), exports);
+__exportStar(require("./Enum"), exports);
+__exportStar(require("./Enum.types"), exports);
+__exportStar(require("./I18nUtils"), exports);
+__exportStar(require("./NumberUtils"), exports);
+__exportStar(require("./ObjectIdUtils"), exports);
+__exportStar(require("./Point3Utils"), exports);
+__exportStar(require("./RandomUtils"), exports);
+__exportStar(require("./Validator"), exports);
+__exportStar(require("./JuminNumberUtils"), exports);
+__exportStar(require("./Sequencer"), exports);
+__exportStar(require("./try-catch"), exports);

package/dist/cjs/shared/utils/try-catch/TryCatch.js

@@ -0,0 +1,78 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TryCatch = void 0;
+/**
+ * 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).
+ */
+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,
+                ];
+            }
+        });
+    }
+}
+exports.TryCatch = TryCatch;

package/dist/cjs/shared/utils/try-catch/index.js

@@ -0,0 +1,17 @@
+"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("./TryCatch"), exports);

package/dist/esm/index.mjs

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

package/dist/esm/shared/constants/COORDINATE.mjs

@@ -0,0 +1,6 @@
+export class COORDINATE {
+}
+COORDINATE.LATITUDE_MIN_LENGTH = 1;
+COORDINATE.LATITUDE_MAX_LENGTH = 10;
+COORDINATE.LONGITUDE_MIN_LENGTH = 1;
+COORDINATE.LONGITUDE_MAX_LENGTH = 11;

package/dist/esm/shared/constants/CRUD.mjs

@@ -0,0 +1,19 @@
+export var CRUD;
+(function (CRUD) {
+    CRUD[CRUD["CREATE"] = 1] = "CREATE";
+    CRUD[CRUD["READ"] = 2] = "READ";
+    CRUD[CRUD["UPDATE"] = 3] = "UPDATE";
+    CRUD[CRUD["DELETE"] = 4] = "DELETE";
+})(CRUD || (CRUD = {}));
+(function (CRUD) {
+    function toString(crud) {
+        switch (crud) {
+            case CRUD.CREATE: return 'Create';
+            case CRUD.READ: return 'Read';
+            case CRUD.UPDATE: return 'Update';
+            case CRUD.DELETE: return 'Delete';
+            default: throw new Error('Unknown crud: ' + crud);
+        }
+    }
+    CRUD.toString = toString;
+})(CRUD || (CRUD = {}));

package/dist/esm/shared/constants/DATE.mjs

@@ -0,0 +1,22 @@
+export class DATE {
+}
+(function (DATE) {
+    let FORMAT;
+    (function (FORMAT) {
+        FORMAT[FORMAT["UNIX"] = 1] = "UNIX";
+        FORMAT[FORMAT["SECONDS"] = 2] = "SECONDS";
+        FORMAT[FORMAT["MILLISECONDS"] = 3] = "MILLISECONDS";
+        FORMAT[FORMAT["ISO_8601"] = 4] = "ISO_8601";
+    })(FORMAT = DATE.FORMAT || (DATE.FORMAT = {}));
+    (function (FORMAT) {
+        function toString(format) {
+            switch (format) {
+                case FORMAT.UNIX: return 'UNIX';
+                case FORMAT.SECONDS: return 'SECONDS';
+                case FORMAT.MILLISECONDS: return 'MILLISECONDS';
+                case FORMAT.ISO_8601: return 'ISO_8601';
+            }
+        }
+        FORMAT.toString = toString;
+    })(FORMAT = DATE.FORMAT || (DATE.FORMAT = {}));
+})(DATE || (DATE = {}));

package/dist/esm/shared/constants/DISTANCE.mjs

@@ -0,0 +1,14 @@
+export class DISTANCE {
+}
+(function (DISTANCE) {
+    let UNIT;
+    (function (UNIT) {
+        UNIT["FEET"] = "FEET";
+        UNIT["KILOMETERS"] = "KILOMETERS";
+        UNIT["MILLIMETERS"] = "MILLIMETERS";
+        UNIT["CENTIMETERS"] = "CENTIMETERS";
+        UNIT["METERS"] = "METERS";
+        UNIT["MILES"] = "MILES";
+        UNIT["YARDS"] = "YARDS";
+    })(UNIT = DISTANCE.UNIT || (DISTANCE.UNIT = {}));
+})(DISTANCE || (DISTANCE = {}));