jordy 0.12.0

package/esm5/queries/buildQueryCreator.js

@@ -0,0 +1,124 @@
+import { __awaiter, __generator, __spreadArray } from "tslib";
+import { useCallback, useLayoutEffect, useRef, useState } from 'react';
+import { createStorage } from '../storage';
+import { useMakeDeps } from './useMakeDeps';
+import { clearCacheByKeyword, createCacheKey } from './utils';
+function defConverter(args) {
+    return args;
+}
+export function buildQueryCreator(store) {
+    var keyDic = {};
+    return function createRepositoryQuery(_a) {
+        var _this = this;
+        var key = _a.key, subKeysFromParams = _a.subKeysFromParams, _b = _a.cache, cacheType = _b === void 0 ? 'session' : _b, _c = _a.expired, expired = _c === void 0 ? 0 : _c, _d = _a.lazy, lazy = _d === void 0 ? false : _d, _e = _a.defaultLoading, defaultLoading = _e === void 0 ? false : _e, fetcher = _a.fetcher, defaultData = _a.defaultData, _f = _a.parameterConverter, parameterConverter = _f === void 0 ? defConverter : _f, _g = _a.resultConverter, resultConverter = _g === void 0 ? defConverter : _g;
+        if (key) {
+            if (keyDic[key]) {
+                console.warn("Query hooks key \"".concat(key, "\" already exists. Please change the key"));
+            }
+            keyDic[key] = true;
+        }
+        var resultHooks = function (requestParams) {
+            var refFetching = useRef(false);
+            var _a = useState(defaultData), data = _a[0], setData = _a[1];
+            var _b = useState(undefined), error = _b[0], setError = _b[1];
+            var _c = useState(defaultLoading), loading = _c[0], setLoading = _c[1];
+            var deps = useMakeDeps(requestParams, subKeysFromParams);
+            var loader = useCallback(function (params) { return __awaiter(_this, void 0, void 0, function () {
+                var sto, cachedValue, prm;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (refFetching.current) {
+                                return [2];
+                            }
+                            sto = key && cacheType !== false
+                                ? createStorage(cacheType, createCacheKey(key, params, subKeysFromParams), expired)
+                                : null;
+                            setError(undefined);
+                            if (sto) {
+                                cachedValue = sto.get();
+                                if (cachedValue) {
+                                    if (key) {
+                                        store.dispatch({
+                                            type: "QueryHooks/".concat(key, "/cached"),
+                                            params: params,
+                                            payload: cachedValue,
+                                        });
+                                    }
+                                    setData(cachedValue);
+                                    setLoading(false);
+                                    return [2];
+                                }
+                            }
+                            refFetching.current = true;
+                            if (key) {
+                                store.dispatch({
+                                    type: "QueryHooks/".concat(key, "/pending"),
+                                    params: params,
+                                });
+                            }
+                            setLoading(true);
+                            prm = fetcher(parameterConverter(params, store.getState));
+                            return [4, prm
+                                    .then(function (res) {
+                                    var convertedData = resultConverter(res, store.getState, params);
+                                    if (key) {
+                                        store.dispatch({
+                                            type: "QueryHooks/".concat(key, "/fulfilled"),
+                                            params: params,
+                                            payload: convertedData,
+                                        });
+                                    }
+                                    if (sto) {
+                                        sto.set(convertedData);
+                                    }
+                                    setData(convertedData);
+                                    setLoading(false);
+                                    refFetching.current = false;
+                                })
+                                    .catch(function (err) {
+                                    if (key) {
+                                        store.dispatch({
+                                            type: "QueryHooks/".concat(key, "/rejected"),
+                                            params: params,
+                                            payload: err,
+                                        });
+                                    }
+                                    setError(err);
+                                    setLoading(false);
+                                    refFetching.current = false;
+                                })];
+                        case 1:
+                            _a.sent();
+                            return [2];
+                    }
+                });
+            }); }, []);
+            var clear = useCallback(function (removeCache) {
+                if (removeCache === void 0) { removeCache = true; }
+                setData(defaultData);
+                if (!removeCache ||
+                    !key ||
+                    cacheType === false ||
+                    cacheType === 'cookie') {
+                    return;
+                }
+                clearCacheByKeyword(cacheType, key);
+            }, [setData]);
+            useLayoutEffect(function () {
+                if (lazy) {
+                    return;
+                }
+                loader(requestParams);
+            }, __spreadArray(__spreadArray([], deps, true), [lazy], false));
+            return {
+                data: data,
+                error: error,
+                loading: loading,
+                load: loader,
+                clear: clear,
+            };
+        };
+        return resultHooks;
+    };
+}

package/esm5/queries/index.js

@@ -0,0 +1,2 @@
+export * from './buildMutationCreator';
+export * from './buildQueryCreator';

package/esm5/queries/useMakeDeps.js

@@ -0,0 +1,23 @@
+import { useMemo } from 'react';
+import { isObject } from '../util';
+export function useMakeDeps(args, keys) {
+    var subKeys = useMemo(function () {
+        if (keys) {
+            return keys;
+        }
+        if (!args) {
+            return [];
+        }
+        return Object.keys(args);
+    }, [keys]);
+    var deps = useMemo(function () {
+        if (isObject(args)) {
+            return subKeys.map(function (subKey) { return args[subKey]; });
+        }
+        if (Array.isArray(args)) {
+            return args;
+        }
+        return [args];
+    }, [args]);
+    return deps;
+}

package/esm5/queries/utils/clearCacheByKeyword.js

@@ -0,0 +1,50 @@
+import { memoryStorage } from '../../storage';
+function getStorage(type) {
+    if (type === 'session') {
+        return sessionStorage;
+    }
+    if (type === 'local') {
+        return localStorage;
+    }
+    return memoryStorage;
+}
+var findRelatedKeyCurried = function (key) { return function (keyword) {
+    return key.indexOf(keyword) >= 0;
+}; };
+function findAllRelatedKeyFromStorage(sto, keyword) {
+    var key = null;
+    var keyList = [];
+    var len = sto.length;
+    if (len === 0) {
+        return keyList;
+    }
+    if (Array.isArray(keyword)) {
+        for (var keyIdx = 0; keyIdx < len; keyIdx++) {
+            key = sto.key(keyIdx);
+            if (key && keyword.find(findRelatedKeyCurried(key))) {
+                keyList.push(key);
+            }
+        }
+    }
+    else {
+        for (var keyIdx = 0; keyIdx < len; keyIdx++) {
+            key = sto.key(keyIdx);
+            if (key && key.indexOf(keyword) >= 0) {
+                keyList.push(key);
+            }
+        }
+    }
+    return keyList;
+}
+export function clearCacheByKeyword(type, keyword, storageGetter) {
+    if (storageGetter === void 0) { storageGetter = getStorage; }
+    var sto = storageGetter(type);
+    var keyList = findAllRelatedKeyFromStorage(sto, keyword);
+    if (keyList.length === 0) {
+        return 0;
+    }
+    for (var index = 0; index < keyList.length; index++) {
+        sto.removeItem(keyList[index]);
+    }
+    return keyList.length;
+}

package/esm5/queries/utils/createCacheKey.js

@@ -0,0 +1,23 @@
+import { isNumber, isObject, isString } from '../../util';
+export function createCacheKey(key, params, subKeys) {
+    if (isObject(params)) {
+        var appendedValues = void 0;
+        if (subKeys) {
+            appendedValues = subKeys.reduce(function (acc, currKey) {
+                acc.push(createCacheKey(currKey, params[currKey]));
+                return acc;
+            }, [key]);
+        }
+        else {
+            appendedValues = Object.entries(params).reduce(function (acc, item) {
+                acc.push(createCacheKey(item[0], item[1]));
+                return acc;
+            }, [key]);
+        }
+        return appendedValues.join('-');
+    }
+    if (params && (isString(params) || isNumber(params))) {
+        return "".concat(key, "-").concat(params);
+    }
+    return key;
+}

package/esm5/queries/utils/index.js

@@ -0,0 +1,2 @@
+export * from './clearCacheByKeyword';
+export * from './createCacheKey';

package/esm5/route-system/AsyncGuard.js

@@ -0,0 +1,37 @@
+import React, { useEffect, useState } from 'react';
+import { useHistory } from 'react-router';
+import { noop } from '../util';
+export var AsyncGuard = function (_a) {
+    var _b = _a.redirect, redirect = _b === void 0 ? '/' : _b, FailComp = _a.failComponent, guard = _a.guard, children = _a.children;
+    var history = useHistory();
+    var _c = useState(guard ? null : true), end = _c[0], setEnd = _c[1];
+    useEffect(function () {
+        if (end || !guard) {
+            return noop;
+        }
+        var handleAsync = function (res) {
+            if (res) {
+                setEnd(true);
+                return;
+            }
+            if (FailComp) {
+                setEnd(false);
+            }
+            else {
+                history.replace(redirect);
+            }
+        };
+        Promise.resolve(0)
+            .then(guard)
+            .then(handleAsync)
+            .catch(function () { return handleAsync(false); });
+        return noop;
+    }, [end, FailComp, history, redirect, guard]);
+    if (end === false && FailComp) {
+        return React.createElement(FailComp, null);
+    }
+    if (!end) {
+        return null;
+    }
+    return React.createElement(React.Fragment, null, children);
+};

package/esm5/route-system/index.js

@@ -0,0 +1,3 @@
+export * from './renderRouteSystem';
+export * from './moduleRoute.model';
+export * from './routeSystem.util';

package/esm5/route-system/moduleRoute.model.js

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

package/esm5/route-system/renderRouteSystem.js

@@ -0,0 +1,64 @@
+import { __spreadArray } from "tslib";
+import React, { Suspense } from 'react';
+import { Redirect, Route, Switch } from 'react-router-dom';
+import { AsyncGuard } from './AsyncGuard';
+function toPromiseList(guardList) {
+    return guardList.map(function (fn) {
+        var ret = fn();
+        if (ret instanceof Promise) {
+            return ret;
+        }
+        return Promise.resolve(ret);
+    });
+}
+function renderSubRoute(route, notFound, guardList) {
+    if (guardList === void 0) { guardList = []; }
+    var Comp = route.component;
+    var Wrap = route.wrap || React.Fragment;
+    if (route.guard) {
+        guardList.push(route.guard);
+        if (route.child) {
+            return (React.createElement(Wrap, null, renderRouteSystem(route.child, true, notFound, __spreadArray([], guardList, true))));
+        }
+        var guardResults = function () {
+            return Promise.all(toPromiseList(guardList)).then(function (items) {
+                return items.every(Boolean);
+            });
+        };
+        return (React.createElement(Wrap, null,
+            React.createElement(Suspense, { fallback: React.createElement(React.Fragment, null) },
+                React.createElement(AsyncGuard, { guard: guardResults, redirect: route.redirect, failComponent: route.failComponent }, Comp && React.createElement(Comp, null)))));
+    }
+    if (route.redirect) {
+        return React.createElement(Redirect, { to: route.redirect });
+    }
+    if (route.child) {
+        return (React.createElement(Wrap, null, renderRouteSystem(route.child, true, notFound, __spreadArray([], guardList, true))));
+    }
+    if (guardList.length > 0) {
+        var guardResults = function () {
+            return Promise.all(toPromiseList(guardList)).then(function (items) {
+                return items.every(Boolean);
+            });
+        };
+        return (React.createElement(Wrap, null,
+            React.createElement(Suspense, { fallback: React.createElement(React.Fragment, null) },
+                React.createElement(AsyncGuard, { guard: guardResults, redirect: route.redirect, failComponent: route.failComponent }, Comp && React.createElement(Comp, null)))));
+    }
+    return (React.createElement(Wrap, null,
+        React.createElement(Suspense, { fallback: React.createElement(React.Fragment, null) }, Comp && React.createElement(Comp, null))));
+}
+export var renderRouteSystem = function (routes, withSwitch, notFound, guardList) {
+    if (guardList === void 0) { guardList = []; }
+    var NotFound = notFound;
+    if (withSwitch) {
+        return (React.createElement(Switch, null,
+            routes.map(function (route) { return (React.createElement(Route, { key: route.path, path: route.path, exact: route.exact }, renderSubRoute(route, notFound, __spreadArray([], guardList, true)))); }),
+            NotFound && React.createElement(NotFound, null)));
+    }
+    var renders = routes.map(function (route) { return (React.createElement(Route, { key: route.path, path: route.path, exact: route.exact }, renderSubRoute(route, notFound, __spreadArray([], guardList, true)))); });
+    if (NotFound) {
+        renders.push(React.createElement(NotFound, { key: "%%not-found%%" }));
+    }
+    return renders;
+};

package/esm5/route-system/routeSystem.util.js

@@ -0,0 +1,23 @@
+import { __awaiter, __generator } from "tslib";
+export function createGuardDispatch(store) {
+    return function guardDispatch(effectResult) {
+        return __awaiter(this, void 0, void 0, function () {
+            var dispatch, action;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        dispatch = store.dispatch;
+                        return [4, dispatch(effectResult)];
+                    case 1:
+                        action = _a.sent();
+                        return [2, action.meta.requestStatus === 'fulfilled'];
+                }
+            });
+        });
+    };
+}
+export function createGuardSelector(store) {
+    return function guardSelector(selector) {
+        return selector(store.getState());
+    };
+}

package/esm5/storage/CookieStorageAdapter.js

@@ -0,0 +1,20 @@
+import { marshalJson, unmarshalJson } from '../util';
+var CookieStorageAdapter = (function () {
+    function CookieStorageAdapter(cookie, key, expiredTime) {
+        if (expiredTime === void 0) { expiredTime = 0; }
+        this.cookie = cookie;
+        this.key = key;
+        this.expiredTime = expiredTime;
+    }
+    CookieStorageAdapter.prototype.get = function () {
+        return unmarshalJson(this.cookie.get(this.key));
+    };
+    CookieStorageAdapter.prototype.set = function (value) {
+        this.cookie.set(this.key, marshalJson(value), this.expiredTime);
+    };
+    CookieStorageAdapter.prototype.remove = function () {
+        this.cookie.remove(this.key);
+    };
+    return CookieStorageAdapter;
+}());
+export { CookieStorageAdapter };

package/esm5/storage/ExpiableStorageAdapter.js

@@ -0,0 +1,36 @@
+var ExpiableStorageAdapter = (function () {
+    function ExpiableStorageAdapter(storage, expiredTime) {
+        if (expiredTime === void 0) { expiredTime = 0; }
+        this.storage = storage;
+        this.expiredTime = expiredTime;
+    }
+    Object.defineProperty(ExpiableStorageAdapter.prototype, "key", {
+        get: function () {
+            return this.storage.key;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ExpiableStorageAdapter.prototype.get = function () {
+        var mData = this.storage.get();
+        if (!mData) {
+            return null;
+        }
+        if (mData.expiredTime <= 0 || mData.expiredTime > Date.now()) {
+            return mData.data;
+        }
+        this.storage.remove();
+        return null;
+    };
+    ExpiableStorageAdapter.prototype.set = function (value) {
+        this.storage.set({
+            data: value,
+            expiredTime: this.expiredTime > 0 ? Date.now() + this.expiredTime * 1000 : 0,
+        });
+    };
+    ExpiableStorageAdapter.prototype.remove = function () {
+        this.storage.remove();
+    };
+    return ExpiableStorageAdapter;
+}());
+export { ExpiableStorageAdapter };

package/esm5/storage/MemorySimpleStorage.js

@@ -0,0 +1,18 @@
+import { memoryStorage } from './memoryStorage';
+var MemorySimpleStorage = (function () {
+    function MemorySimpleStorage(key) {
+        this.key = key;
+        this.storage = memoryStorage;
+    }
+    MemorySimpleStorage.prototype.get = function () {
+        return (this.storage.getItem(this.key) || null);
+    };
+    MemorySimpleStorage.prototype.set = function (value) {
+        this.storage.setItem(this.key, value);
+    };
+    MemorySimpleStorage.prototype.remove = function () {
+        this.storage.removeItem(this.key);
+    };
+    return MemorySimpleStorage;
+}());
+export { MemorySimpleStorage };

package/esm5/storage/SimpleStorageAdapter.js

@@ -0,0 +1,18 @@
+import { marshalJson, unmarshalJson } from '../util';
+var SimpleStorageAdapter = (function () {
+    function SimpleStorageAdapter(key, storage) {
+        this.key = key;
+        this.storage = storage;
+    }
+    SimpleStorageAdapter.prototype.get = function () {
+        return unmarshalJson(this.storage.getItem(this.key));
+    };
+    SimpleStorageAdapter.prototype.set = function (value) {
+        this.storage.setItem(this.key, marshalJson(value));
+    };
+    SimpleStorageAdapter.prototype.remove = function () {
+        this.storage.removeItem(this.key);
+    };
+    return SimpleStorageAdapter;
+}());
+export { SimpleStorageAdapter };

package/esm5/storage/cookie.js

@@ -0,0 +1,27 @@
+export var cookie = {
+    set: function (key, value, expireDays) {
+        if (expireDays === void 0) { expireDays = 1; }
+        var d = new Date();
+        d.setTime(d.getTime() + expireDays * 24 * 60 * 60 * 1000);
+        var expires = 'expires=' + d.toUTCString();
+        document.cookie = key + '=' + value + ';' + expires + ';path=/';
+    },
+    get: function (key) {
+        var name = key + '=';
+        var decodedCookie = decodeURIComponent(document.cookie);
+        var ca = decodedCookie.split(';');
+        for (var i = 0; i < ca.length; i++) {
+            var c = ca[i];
+            while (c.charAt(0) == ' ') {
+                c = c.substring(1);
+            }
+            if (c.indexOf(name) == 0) {
+                return c.substring(name.length, c.length);
+            }
+        }
+        return '';
+    },
+    remove: function (key) {
+        document.cookie = key + '=; expires=Thu, 01 Jan 1999 00:00:10 GMT;';
+    },
+};

package/esm5/storage/index.js

@@ -0,0 +1,4 @@
+export * from './storage.factory';
+export * from './token-provider.factory';
+export * from './storage.type';
+export * from './memoryStorage';

package/esm5/storage/memoryStorage.js

@@ -0,0 +1,35 @@
+var MemoryStorageImpl = (function () {
+    function MemoryStorageImpl() {
+        this.cacheMap = new Map();
+        this.keys = [];
+    }
+    Object.defineProperty(MemoryStorageImpl.prototype, "length", {
+        get: function () {
+            return this.cacheMap.size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MemoryStorageImpl.prototype.clear = function () {
+        this.cacheMap.clear();
+        this.keys = [];
+    };
+    MemoryStorageImpl.prototype.getItem = function (key) {
+        return this.cacheMap.get(key);
+    };
+    MemoryStorageImpl.prototype.key = function (index) {
+        return this.keys[index] || null;
+    };
+    MemoryStorageImpl.prototype.removeItem = function (key) {
+        this.cacheMap.delete(key);
+        this.keys = this.keys.filter(function (item) { return item !== key; });
+    };
+    MemoryStorageImpl.prototype.setItem = function (key, value) {
+        if (this.cacheMap.has(key) === false) {
+            this.keys.push(key);
+        }
+        this.cacheMap.set(key, value);
+    };
+    return MemoryStorageImpl;
+}());
+export var memoryStorage = new MemoryStorageImpl();

package/esm5/storage/storage.factory.js

@@ -0,0 +1,30 @@
+import { CookieStorageAdapter } from './CookieStorageAdapter';
+import { ExpiableStorageAdapter } from './ExpiableStorageAdapter';
+import { MemorySimpleStorage } from './MemorySimpleStorage';
+import { SimpleStorageAdapter } from './SimpleStorageAdapter';
+import { cookie } from './cookie';
+import { isServer, isStorageAvailable } from '../util/envCheck';
+export var createStorage = function (type, key, expiredTime) {
+    if (type === void 0) { type = 'session'; }
+    if (key === void 0) { key = '_'; }
+    if (expiredTime === void 0) { expiredTime = 0; }
+    var ret;
+    if (type !== 'cookie' && expiredTime > 0) {
+        return new ExpiableStorageAdapter(createStorage(type, key), expiredTime);
+    }
+    if (isServer() || !isStorageAvailable() || type === 'memory') {
+        ret = new MemorySimpleStorage(key);
+    }
+    else if (type === 'cookie') {
+        ret = new CookieStorageAdapter(cookie, key, expiredTime);
+    }
+    else {
+        try {
+            ret = new SimpleStorageAdapter(key, type === 'local' ? localStorage : sessionStorage);
+        }
+        catch (error) {
+            ret = new MemorySimpleStorage(key);
+        }
+    }
+    return ret;
+};

package/esm5/storage/storage.type.js

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

package/esm5/storage/token-provider.factory.js

@@ -0,0 +1,23 @@
+import { createStorage } from './storage.factory';
+var StorageTokenProvider = (function () {
+    function StorageTokenProvider(storage) {
+        this.storage = storage;
+        this._token = '';
+        this._token = this.storage.get() || '';
+    }
+    StorageTokenProvider.prototype.get = function () {
+        return this.storage.get() || '';
+    };
+    StorageTokenProvider.prototype.set = function (token) {
+        this._token = token;
+        this.storage.set(token);
+    };
+    StorageTokenProvider.prototype.clear = function () {
+        this._token = '';
+        this.storage.remove();
+    };
+    return StorageTokenProvider;
+}());
+export function createTokenProvider(type, key, expiredTime) {
+    return new StorageTokenProvider(createStorage(type, key, expiredTime));
+}

package/esm5/types/component.type.js

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

package/esm5/types/index.js

@@ -0,0 +1,2 @@
+export * from './component.type';
+export * from './marshalling.type';

package/esm5/types/marshalling.type.js

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

package/esm5/util/collection.js

@@ -0,0 +1,17 @@
+import { __spreadArray } from "tslib";
+export function reorder(list, startIndex, endIndex) {
+    var result = __spreadArray([], list, true);
+    var removed = result.splice(startIndex, 1)[0];
+    result.splice(endIndex, 0, removed);
+    return result;
+}
+export function update(list, index, item) {
+    var copied = __spreadArray([], list, true);
+    copied[index] = item;
+    return copied;
+}
+export function remove(list, index) {
+    var copied = __spreadArray([], list, true);
+    copied.splice(index, 1);
+    return copied;
+}