jordy 0.12.0

package/esm5/util/envCheck.js

@@ -0,0 +1,55 @@
+var bIsStorageAvailable = typeof localStorage !== 'undefined';
+var bIsServer = typeof window === 'undefined';
+export var isServer = function () { return bIsServer; };
+export var setIsServer = function (val) {
+    bIsServer = val;
+};
+export var isStorageAvailable = function () { return bIsStorageAvailable; };
+export var setIsStorageAvailable = function (val) {
+    bIsStorageAvailable = val;
+};
+var userAgent = isServer() ? '' : window.navigator.userAgent;
+export function setUserAgent(ua) {
+    if (isServer() && ua) {
+        userAgent = ua;
+    }
+}
+export function getUserAgent() {
+    return userAgent;
+}
+export function isMobile() {
+    var ua = userAgent;
+    if (!ua) {
+        return false;
+    }
+    return /iPhone|iPod|Android/.test(ua);
+}
+export function isTablet() {
+    var ua = userAgent;
+    if (!ua) {
+        return false;
+    }
+    return /iPad/.test(ua);
+}
+export function isIOS() {
+    var ua = userAgent;
+    if (!ua) {
+        return false;
+    }
+    return /iPad|iPhone|iPad/.test(ua);
+}
+var nativeAppKeyword = '';
+var bIsNativeApp = null;
+export function setNativeAppKeyword(keyword) {
+    nativeAppKeyword = keyword;
+}
+export function isNativeApp() {
+    var ua = userAgent;
+    if (!ua) {
+        return false;
+    }
+    if (bIsNativeApp === null) {
+        bIsNativeApp = ua.indexOf(nativeAppKeyword) >= 0;
+    }
+    return bIsNativeApp;
+}

package/esm5/util/etc.js

@@ -0,0 +1,12 @@
+export function timeout(time, value, stopCallback) {
+    return new Promise(function (resolve, reject) {
+        var t = setTimeout(function () { return resolve(value); }, time);
+        if (stopCallback) {
+            stopCallback(function () {
+                clearTimeout(t);
+                reject(new Error('timeout stopped.'));
+            });
+        }
+    });
+}
+export function noop() { }

package/esm5/util/filter.js

@@ -0,0 +1,10 @@
+import _throttle from 'lodash-es/throttle';
+import _debounce from 'lodash-es/debounce';
+export function throttle(func, wait) {
+    if (wait === void 0) { wait = 300; }
+    return _throttle(func, wait, { trailing: false });
+}
+export function debounce(func, wait) {
+    if (wait === void 0) { wait = 300; }
+    return _debounce(func, wait);
+}

package/esm5/util/format.js

@@ -0,0 +1,8 @@
+import { isNumber } from './typeCheck';
+export function numberFormat(value, def) {
+    if (def === void 0) { def = '0'; }
+    if (!value || !isNumber(value)) {
+        return def;
+    }
+    return value.toLocaleString();
+}

package/esm5/util/index.js

@@ -0,0 +1,15 @@
+export * from './collection';
+import * as envCheck from './envCheck';
+export * from './typeCheck';
+export * from './etc';
+export * from './filter';
+export * from './format';
+export * from './josa';
+export * from './json';
+export * from './path';
+export * from './queryString';
+export * from './redux';
+export * from './template';
+export * from './libLoader';
+var isServer = envCheck.isServer;
+export { envCheck, isServer };

package/esm5/util/josa.js

@@ -0,0 +1,57 @@
+function _hasJong(string) {
+    var str = string.charCodeAt(string.length - 1);
+    return (str - 0xac00) % 28 > 0;
+}
+var _f = [
+    function (string) {
+        return _hasJong(string) ? '을' : '를';
+    },
+    function (string) {
+        return _hasJong(string) ? '은' : '는';
+    },
+    function (string) {
+        return _hasJong(string) ? '이' : '가';
+    },
+    function (string) {
+        return _hasJong(string) ? '과' : '와';
+    },
+    function (string) {
+        return _hasJong(string) ? '으로' : '로';
+    },
+    function (string) {
+        return _hasJong(string) ? '이' : '';
+    },
+];
+var _formats = {
+    '을/를': _f[0],
+    을: _f[0],
+    를: _f[0],
+    을를: _f[0],
+    '은/는': _f[1],
+    은: _f[1],
+    는: _f[1],
+    은는: _f[1],
+    '이/가': _f[2],
+    이: _f[2],
+    가: _f[2],
+    이가: _f[2],
+    '와/과': _f[3],
+    와: _f[3],
+    과: _f[3],
+    와과: _f[3],
+    '으로/로': _f[4],
+    으로: _f[4],
+    로: _f[4],
+    으로로: _f[4],
+    '이/': _f[5],
+};
+export var josa = {
+    c: function (word, format) {
+        if (typeof _formats[format] === 'undefined')
+            throw 'Invalid format!';
+        return _formats[format](word);
+    },
+    r: function (word, format) {
+        return word + josa.c(word, format);
+    },
+};

package/esm5/util/json.js

@@ -0,0 +1,19 @@
+export function marshalJson(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+export function unmarshalJson(raw) {
+    if (raw) {
+        if (/(^\{.*\}$|^\[.*\]$)/.test(raw)) {
+            try {
+                return JSON.parse(raw);
+            }
+            catch (error) {
+                return null;
+            }
+        }
+    }
+    return raw;
+}

package/esm5/util/libLoader.js

@@ -0,0 +1,27 @@
+import { __awaiter, __generator } from "tslib";
+var libSet = new Set();
+export function loadOuterScript(url) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            if (libSet.has(url)) {
+                return [2, true];
+            }
+            return [2, new Promise(function (resolve, reject) {
+                    var script = document.createElement('script');
+                    try {
+                        script.src = url;
+                        script.type = 'text/javascript';
+                        script.async = true;
+                        document.body.appendChild(script);
+                        script.onload = function () {
+                            libSet.add(url);
+                            resolve(true);
+                        };
+                    }
+                    catch (error) {
+                        reject(false);
+                    }
+                })];
+        });
+    });
+}

package/esm5/util/path.js

@@ -0,0 +1,16 @@
+import { qs } from './queryString';
+export function getFileName(url) {
+    try {
+        return url.substring(url.lastIndexOf('/') + 1).split('?')[0];
+    }
+    catch (error) {
+        return url;
+    }
+}
+export function parseQueryString(url) {
+    return qs.parse(url);
+}
+export function serializeToQueryString(params, withQuestionMark) {
+    if (withQuestionMark === void 0) { withQuestionMark = false; }
+    return qs.serialize(params, withQuestionMark);
+}

package/esm5/util/queryString.js

@@ -0,0 +1,62 @@
+import { isNullable, isObject } from './typeCheck';
+function _serialize(params, parentKey) {
+    if (parentKey === void 0) { parentKey = ''; }
+    return Object.entries(params).reduce(function (acc, _a) {
+        var oriKey = _a[0], value = _a[1];
+        var key = parentKey ? "".concat(parentKey, "%5B").concat(oriKey, "%5D") : oriKey;
+        var ret = acc + (acc.length > 1 ? '&' : '');
+        if (isObject(value)) {
+            ret += _serialize(value, key);
+        }
+        else {
+            ret =
+                ret +
+                    key +
+                    '=' +
+                    encodeURIComponent(isNullable(value) || Number.isNaN(value) ? '' : value);
+        }
+        return ret;
+    }, '');
+}
+var cache = new Map();
+export var qs = {
+    parse: function (url) {
+        var _a;
+        if (cache.has(url)) {
+            return cache.get(url);
+        }
+        cache.clear();
+        var result = {};
+        try {
+            var queryString = url.split('?')[1];
+            var splittedQueries = queryString.split('&');
+            var len = splittedQueries.length;
+            var key = '';
+            var value = '';
+            for (var i = 0; i < len; i++) {
+                _a = splittedQueries[i].split('='), key = _a[0], value = _a[1];
+                result[key] = decodeURIComponent(value);
+            }
+        }
+        catch (error) {
+        }
+        cache.set(url, result);
+        return result;
+    },
+    serialize: function (params, withQuestionMark) {
+        if (withQuestionMark === void 0) { withQuestionMark = false; }
+        if (!isObject(params)) {
+            throw new Error("serializeToQueryString: params is not object.\n".concat(params ? JSON.stringify(params) : params));
+        }
+        return (withQuestionMark ? '?' : '') + _serialize(params);
+    },
+    append: function (search, data) {
+        if (!search) {
+            return qs.serialize(data, true);
+        }
+        if (search.length >= 1 && search[0] === '?') {
+            return "".concat(search, "&").concat(qs.serialize(data));
+        }
+        throw new Error("qs.append : \"".concat(search, "\" is invalid search string."));
+    },
+};

package/esm5/util/redux.js

@@ -0,0 +1,6 @@
+import { __assign } from "tslib";
+export function clearMessageBy(errorMessages, name) {
+    var result = __assign({}, errorMessages);
+    delete result[name];
+    return result;
+}

package/esm5/util/template.js

@@ -0,0 +1,65 @@
+import { isEmptyObject } from './typeCheck';
+import { josa } from './josa';
+function getJosaRegexp() {
+    return /^(을\/를|을|를|을를|은\/는|은|는|은는|이\/가|이|가|이가|와\/과|와|과|와과|으로\/로|으로|로|으로로|이\/)$/;
+}
+function parse(value) {
+    var arr = [];
+    var template = value;
+    var result = /{(.*?)}/g.exec(template);
+    var firstPos = -1;
+    while (result) {
+        firstPos = result.index;
+        if (firstPos !== 0) {
+            arr.push(template.substring(0, firstPos));
+            template = template.slice(firstPos);
+        }
+        arr.push(result[0]);
+        template = template.slice(result[0].length);
+        result = /{(.*?)}/g.exec(template);
+    }
+    if (template) {
+        arr.push(template);
+    }
+    return arr;
+}
+function compileToString(arr) {
+    var result = ['\'\''];
+    result = arr.reduce(function (acc, tmp) {
+        var subTmp = '';
+        if (tmp.startsWith('{') && tmp.endsWith('}')) {
+            subTmp = tmp.split(/\{|\}/).filter(Boolean)[0].trim();
+            if (getJosaRegexp().test(subTmp) && acc.latestTmp) {
+                acc.result.push("+j.c(d.".concat(acc.latestTmp, ",'").concat(subTmp, "')"));
+            }
+            else {
+                acc.result.push("+d.".concat(subTmp));
+                acc.latestTmp = subTmp;
+            }
+        }
+        else {
+            acc.result.push("+'".concat(tmp.replace(/\n/gm, '\\n'), "'"));
+        }
+        return acc;
+    }, { result: result, latestTmp: '' }).result;
+    return result.join('');
+}
+var compiledFns = {};
+export function messageTemplate(tmplText, data) {
+    if (!tmplText || !data || isEmptyObject(data)) {
+        return '';
+    }
+    if (Array.isArray(data)) {
+        throw new Error('messageTemplate: The "data" argument cannot be an array.');
+    }
+    var fn = compiledFns[tmplText];
+    if (!fn) {
+        fn = new Function('d', 'j', "return ".concat(compileToString(messageTemplate.parse(tmplText))));
+        compiledFns[tmplText] = fn;
+    }
+    return fn(data, josa);
+}
+messageTemplate.parse = parse;
+messageTemplate.clear = function () {
+    compiledFns = {};
+};

package/esm5/util/typeCheck.js

@@ -0,0 +1,33 @@
+export function isUndefined(val) {
+    return typeof val === 'undefined';
+}
+export function isString(val) {
+    return Object.prototype.toString.call(val) === '[object String]';
+}
+export function isNullable(val) {
+    return (isUndefined(val) || val === null || val === 'undefined' || val === 'null');
+}
+export function isEmptyArray(val) {
+    return !Array.isArray(val) || val.length === 0;
+}
+export function isNumber(val) {
+    return Object.prototype.toString.call(val) === '[object Number]';
+}
+export function isNumberLike(val) {
+    if (isNumber(val)) {
+        return true;
+    }
+    if (isString(val)) {
+        return /^[0-9]+$/.test(val);
+    }
+    return false;
+}
+export function isEmptyObject(val) {
+    return val && Object.keys(val).length === 0 && val.constructor === Object;
+}
+export function isFunction(val) {
+    return Object.prototype.toString.call(val) === '[object Function]';
+}
+export function isObject(val) {
+    return Object.prototype.toString.call(val) === '[object Object]';
+}

package/esm5/validate/fn.js

@@ -0,0 +1,66 @@
+import { isNullable } from '../util/typeCheck';
+function required(val) {
+    return !isNullable(val) && !!val;
+}
+var length = function (min, max) { return function (val) {
+    return required(val) && val.length >= min && val.length <= max;
+}; };
+function email(val) {
+    return (length(7, 100)(val) && /^(\w|-|\.)+@\w+([.-]?\w+)*(\.\w{2,5})+$/.test(val));
+}
+function passwordWeak(val) {
+    return /^(?=.*[A-z])(?=.*[0-9])(?=.{6,20})/.test(val);
+}
+function password(val) {
+    return /^(?=.*[A-z])(?=.*[~!@#$%^&*()\-=+_';<>/.`:"\\,[\]?|{}])(?=.*[0-9]).{6,32}$/.test(val);
+}
+function lowercase(val) {
+    return /^(?=.*[a-z])/.test(val);
+}
+function uppercase(val) {
+    return /^(?=.*[A-Z])/.test(val);
+}
+function numbers(val) {
+    return /^(?=.*\d)/.test(val);
+}
+function symbols(val) {
+    return /^(?=.*[~!@#$%^&*()\-=+_';<>/.`:"\\,[\]?|{}])/.test(val);
+}
+function korAndEng(val) {
+    return /^([A-Za-z]|[가-힣]){2,100}$/.test(val);
+}
+function numberOnly(val) {
+    return /^[0-9]{1,}$/.test(val);
+}
+function range(min, max) {
+    return function innerRange(val) {
+        var num = Number(val);
+        return num >= min && num <= max;
+    };
+}
+function phoneWithDash(val) {
+    return /^(\d{4}-\d{4}|\d{2,3}-\d{3,4}-\d{3,4})$/.test(val);
+}
+function phone(val) {
+    return length(8, 11)(val) && numbers(val);
+}
+function companyRegNumber(val) {
+    return /^\d{3}-\d{2}-\d{5}$/.test(val);
+}
+export default {
+    required: required,
+    email: email,
+    passwordWeak: passwordWeak,
+    password: password,
+    lowercase: lowercase,
+    uppercase: uppercase,
+    numbers: numbers,
+    symbols: symbols,
+    korAndEng: korAndEng,
+    numberOnly: numberOnly,
+    range: range,
+    phoneWithDash: phoneWithDash,
+    phone: phone,
+    companyRegNumber: companyRegNumber,
+    length: length,
+};

package/esm5/validate/index.js

@@ -0,0 +1,7 @@
+import { validate } from './validate';
+import fn from './fn';
+var validateFn = validate;
+validateFn.fn = fn;
+export default validateFn;
+export * from './mergeValidates';
+export * from './validate.type';

package/esm5/validate/mergeValidates.js

@@ -0,0 +1,22 @@
+import { __assign } from "tslib";
+import { validateSubUtils } from './validateSubUtils';
+export function mergeValidates() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    if (args.length === 1) {
+        return args[0];
+    }
+    return args.reduce(function (acc, arg) {
+        acc.errorMessages = __assign(__assign({}, acc.errorMessages), arg.errorMessages);
+        if (arg.firstMessage && !acc.firstMessage) {
+            acc.firstMessage = arg.firstMessage;
+        }
+        Array.prototype.push.apply(acc.invalidKeys, arg.invalidKeys);
+        acc.isValid = acc.isValid && arg.isValid;
+        acc.results = __assign(__assign({}, acc.results), arg.results);
+        Array.prototype.push.apply(acc.validKeys, arg.validKeys);
+        return acc;
+    }, validateSubUtils.createValidateBulkResultModel());
+}

package/esm5/validate/validate.js

@@ -0,0 +1,22 @@
+import { validateSubUtils } from './validateSubUtils';
+var createValidateBulkResultModel = validateSubUtils.createValidateBulkResultModel, validateBulk = validateSubUtils.validateBulk;
+export function validate(state, opt) {
+    return Object.keys(opt).reduce(function (acc, key) {
+        var val = state[key];
+        var items = opt[key];
+        var _mRet = validateBulk(val, items);
+        acc.results[key] = _mRet;
+        acc.isValid = acc.isValid && _mRet.result;
+        if (_mRet.result) {
+            acc.validKeys.push(key);
+        }
+        else {
+            acc.invalidKeys.push(key);
+            acc.errorMessages[key] = _mRet.message;
+            if (!acc.firstMessage) {
+                acc.firstMessage = _mRet.message;
+            }
+        }
+        return acc;
+    }, createValidateBulkResultModel());
+}

package/esm5/validate/validate.type.js

@@ -0,0 +1 @@
+export {};

package/esm5/validate/validateSubUtils.js

@@ -0,0 +1,67 @@
+function createValidateBulkResultModel() {
+    var result = {
+        isValid: true,
+        results: {},
+        validKeys: [],
+        invalidKeys: [],
+        firstMessage: '',
+        errorMessages: {},
+    };
+    return result;
+}
+function validateSingle(val, _a) {
+    var check = _a.check, message = _a.message;
+    var result = check(val);
+    var msg = !result ? message : '';
+    return {
+        result: result,
+        message: msg,
+    };
+}
+function checkIgnore(ignore, val) {
+    if (!ignore) {
+        return false;
+    }
+    return ignore === true || ignore(val);
+}
+function createValidateResultModel() {
+    return {
+        result: true,
+        message: '',
+    };
+}
+function validateBulk(val, opt) {
+    var mRes;
+    if (Array.isArray(opt)) {
+        if (opt.length > 0 && checkIgnore(opt[0].ignore, val)) {
+            return createValidateResultModel();
+        }
+        opt.every(function (_opt) {
+            var _mRes = validateSingle(val, _opt);
+            if (!_mRes.result) {
+                mRes = _mRes;
+            }
+            return _mRes.result;
+        });
+    }
+    else if (typeof opt === 'function') {
+        var tmpRes = opt(val);
+        mRes = {
+            result: tmpRes.isValid,
+            message: tmpRes.firstMessage,
+        };
+    }
+    else {
+        if (checkIgnore(opt.ignore, val)) {
+            return createValidateResultModel();
+        }
+        mRes = validateSingle(val, opt);
+    }
+    return mRes || createValidateResultModel();
+}
+export var validateSubUtils = {
+    createValidateBulkResultModel: createValidateBulkResultModel,
+    validateSingle: validateSingle,
+    validateBulk: validateBulk,
+    checkIgnore: checkIgnore,
+};

package/libs/adaptive-render/AdaptiveRender.d.ts

@@ -0,0 +1,25 @@
+import React, { ReactElement, ReactNode } from 'react';
+interface Props {
+    /**
+     * 데스크탑에서만 보여질 컴포넌트
+     */
+    desktop?: ReactElement | ReactNode | boolean;
+    /**
+     * 모바일 에서만 보이는지의 여부. 기본 false
+     */
+    mobile?: boolean;
+    /**
+     * 태블릿일 때는 보이지 않음 여부. 기본 false
+     */
+    notTablet?: boolean;
+}
+/**
+ * 적응형으로 렌더링 할 때 쓰인다.
+ *
+ * 이 컴포넌트의 자식 요소는 기본적으로 모바일일 경우 렌더링 되지 않는다.
+ *
+ * 모바일일 경우에만 보이게 할 때는 mobile 프로퍼티를 적용 시키면 된다.
+ * @param props
+ */
+export declare const AdaptiveRender: React.FC<Props>;
+export {};

package/libs/adaptive-render/DeviceDetectContext.d.ts

@@ -0,0 +1,16 @@
+import React, { FC } from 'react';
+export declare const DeviceDetectContext: React.Context<boolean[]>;
+/**
+ * 컨텍스트: UserAgent 및 Resizing 여부에 따른 태블릿/모바일 여부를 판별 해 준다.
+ *
+ * 지정된 곳 이외에서는 사용치 않는다.
+ *
+ * 내부적으로 window.mediaQuery API를 사용한다.
+ *
+ * @see https://stackoverflow.com/questions/29046324/whats-the-most-reliable-way-to-integrate-javascript-with-media-queries
+ * @see https://jsperf.com/matchmedia-vs-resize/3
+ */
+export declare const DeviceDetectProvider: FC;
+export declare const useIsMobile: () => boolean;
+export declare const useIsTablet: () => boolean;
+export declare const useIsNative: () => boolean;