@rh-support/components 2.0.7 → 2.0.8

package/lib/cjs/hooks/useFetch.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 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) {
@@ -19,129 +8,64 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useFetch = void 0;
-var react_1 = require("react");
-var useIsMounted_1 = require("./useIsMounted");
-var usePrevious_1 = require("./usePrevious");
+const react_1 = require("react");
+const useIsMounted_1 = require("./useIsMounted");
+const usePrevious_1 = require("./usePrevious");
 // type IUseFetchFn = <T,A extends any[]>(fn: (...args:) => Promise<T>, options?: IUseFetchOptions<T>) => IUseFetch<T,A>;
-function useFetch(fn, _a) {
-    var _this = this;
-    var _b = _a === void 0 ? {} : _a, _c = _b.initialData, initialData = _c === void 0 ? null : _c, _d = _b.resolve, resolve = _d === void 0 ? false : _d, _e = _b.resolveCondition, resolveCondition = _e === void 0 ? [] : _e, _f = _b.isAbortable, isAbortable = _f === void 0 ? false : _f, _g = _b.propgateErrors, propgateErrors = _g === void 0 ? false : _g, _h = _b.postProcessor, postProcessor = _h === void 0 ? undefined : _h;
-    var isMounted = useIsMounted_1.useIsMounted();
-    var _j = __read(react_1.useReducer(function (s, a) { return (__assign(__assign({}, s), a)); }, { data: initialData, isFetching: resolve, error: null }), 2), _k = _j[0], data = _k.data, isFetching = _k.isFetching, error = _k.error, setState = _j[1];
-    var _l = __read(react_1.useState(null), 2), abortSignal = _l[0], setAbortSignal = _l[1];
-    var prevAbortSignal = usePrevious_1.usePrevious(abortSignal);
-    var clearResponse = function () { return setState({ data: initialData }); };
-    var request = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
+function useFetch(fn, { initialData = null, resolve = false, resolveCondition = [], isAbortable = false, propgateErrors = false, postProcessor = undefined, } = {}) {
+    const isMounted = useIsMounted_1.useIsMounted();
+    const [{ data, isFetching, error }, setState] = react_1.useReducer((s, a) => (Object.assign(Object.assign({}, s), a)), { data: initialData, isFetching: resolve, error: null });
+    const [abortSignal, setAbortSignal] = react_1.useState(null);
+    const prevAbortSignal = usePrevious_1.usePrevious(abortSignal);
+    const clearResponse = () => setState({ data: initialData });
+    const request = (...args) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        try {
+            if (isAbortable && 'AbortController' in window) {
+                if (prevAbortSignal) {
+                    prevAbortSignal.abort();
+                }
+                const controller = new AbortController();
+                setAbortSignal(controller);
+                args.push(controller.signal);
+            }
+            isMounted && setState({ isFetching: true, error: null });
+            let response = yield fn(...args);
+            response = postProcessor ? postProcessor(response) : response;
+            isMounted && setState({ data: response, isFetching: false });
+            return response;
         }
-        return __awaiter(_this, void 0, void 0, function () {
-            var controller, response, err_1, isAbortError;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 2, , 3]);
-                        if (isAbortable && 'AbortController' in window) {
-                            if (prevAbortSignal) {
-                                prevAbortSignal.abort();
-                            }
-                            controller = new AbortController();
-                            setAbortSignal(controller);
-                            args.push(controller.signal);
-                        }
-                        isMounted && setState({ isFetching: true, error: null });
-                        return [4 /*yield*/, fn.apply(void 0, __spreadArray([], __read(args)))];
-                    case 1:
-                        response = _b.sent();
-                        response = postProcessor ? postProcessor(response) : response;
-                        isMounted && setState({ data: response, isFetching: false });
-                        return [2 /*return*/, response];
-                    case 2:
-                        err_1 = _b.sent();
-                        isAbortError = ((_a = err_1) === null || _a === void 0 ? void 0 : _a.code) === 20;
-                        if (isAbortError) {
-                            // TODO handle abort error and loader behaviour
-                        }
-                        else {
-                            if (!propgateErrors) {
-                                // AlertUtil.addErrorMessage(err);
-                            }
-                        }
-                        // Don
-                        isMounted && !isAbortError && setState({ error: err_1, data: null, isFetching: false });
-                        if (propgateErrors && !isAbortError) {
-                            throw err_1;
-                        }
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
+        catch (err) {
+            const isAbortError = ((_a = err) === null || _a === void 0 ? void 0 : _a.code) === 20;
+            if (isAbortError) {
+                // TODO handle abort error and loader behaviour
+            }
+            else {
+                if (!propgateErrors) {
+                    // AlertUtil.addErrorMessage(err);
                 }
-            });
-        });
-    };
-    react_1.useEffect(function () {
+            }
+            // Don
+            isMounted && !isAbortError && setState({ error: err, data: null, isFetching: false });
+            if (propgateErrors && !isAbortError) {
+                throw err;
+            }
+        }
+    });
+    react_1.useEffect(() => {
         // if (resolve) {
         //     request();
         // }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, resolveCondition);
     return {
-        clearResponse: clearResponse,
-        data: data,
-        isFetching: isFetching,
-        request: request,
-        error: error,
+        clearResponse,
+        data,
+        isFetching,
+        request,
+        error,
     };
 }
 exports.useFetch = useFetch;

package/lib/cjs/hooks/useForceUpdate.js

@@ -1,24 +1,8 @@
 "use strict";
 // Copied from https://github.com/react-restart/hooks/blob/master/src/useForceUpdate.ts
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useForceUpdate = void 0;
-var react_1 = require("react");
+const react_1 = require("react");
 /**
  * Returns a function that triggers a component update. the hook equivalent to
  * `this.forceUpdate()` in a class component. In most cases using a state value directly
@@ -38,7 +22,7 @@ var react_1 = require("react");
 function useForceUpdate() {
     // The toggling state value is designed to defeat React optimizations for skipping
     // updates when they are stricting equal to the last state value
-    var _a = __read(react_1.useReducer(function (state) { return !state; }, false), 2), dispatch = _a[1];
+    const [, dispatch] = react_1.useReducer((state) => !state, false);
     return dispatch;
 }
 exports.useForceUpdate = useForceUpdate;

package/lib/cjs/hooks/useForkRef.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useForkRef = void 0;
-var react_1 = require("react");
+const react_1 = require("react");
 function setRef(ref, value) {
     if (typeof ref === 'function') {
         ref(value);
@@ -16,11 +16,11 @@ function useForkRef(refA, refB) {
      * This means react will call the old forkRef with `null` and the new forkRef
      * with the ref. Cleanup naturally emerges from this behavior
      */
-    return react_1.useMemo(function () {
+    return react_1.useMemo(() => {
         if (refA == null && refB == null) {
             return null;
         }
-        return function (refValue) {
+        return (refValue) => {
             setRef(refA, refValue);
             setRef(refB, refValue);
         };

package/lib/cjs/hooks/useIsMounted.js

@@ -4,12 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useIsMounted = void 0;
-var react_1 = __importDefault(require("react"));
+const react_1 = __importDefault(require("react"));
 function useIsMounted() {
-    var mounted = react_1.default.useRef(false);
-    react_1.default.useLayoutEffect(function () {
+    const mounted = react_1.default.useRef(false);
+    react_1.default.useLayoutEffect(() => {
         mounted.current = true;
-        return function () {
+        return () => {
             mounted.current = false;
         };
     }, []);

package/lib/cjs/hooks/useLRUCache.js

@@ -1,27 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useLRUCache = void 0;
-var utils_1 = require("@rh-support/utils");
-var react_1 = require("react");
-var useForceUpdate_1 = require("./useForceUpdate");
+const utils_1 = require("@rh-support/utils");
+const react_1 = require("react");
+const useForceUpdate_1 = require("./useForceUpdate");
 function useLRUCache(maxSize) {
-    var lruCacheRef = react_1.useRef(new utils_1.LRUCache(maxSize));
-    var forceUpdate = useForceUpdate_1.useForceUpdate();
-    var setInCache = function (key, value) {
+    const lruCacheRef = react_1.useRef(new utils_1.LRUCache(maxSize));
+    const forceUpdate = useForceUpdate_1.useForceUpdate();
+    const setInCache = (key, value) => {
         lruCacheRef.current.set(key, value);
         forceUpdate();
     };
-    var getFromCache = function (key) {
+    const getFromCache = (key) => {
         return lruCacheRef.current.get(key);
     };
-    var clearCache = function () {
+    const clearCache = () => {
         lruCacheRef.current.clear();
         forceUpdate();
     };
     return {
-        setInCache: setInCache,
-        getFromCache: getFromCache,
-        clearCache: clearCache,
+        setInCache,
+        getFromCache,
+        clearCache,
         cache: lruCacheRef.current,
     };
 }

package/lib/cjs/hooks/useLocalStorage.js

@@ -1,29 +1,13 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useLocalStorage = void 0;
-var react_1 = require("react");
+const react_1 = require("react");
 // For usage please refer
 // https://github.com/streamich/react-use/blob/master/docs/useLocalStorage.md
-var useLocalStorage = function (key, initialValue, raw) {
-    var _a = __read(react_1.useState(function () {
+const useLocalStorage = (key, initialValue, raw) => {
+    const [state, setState] = react_1.useState(() => {
         try {
-            var localStorageValue = localStorage.getItem(key);
+            const localStorageValue = localStorage.getItem(key);
             if (typeof localStorageValue !== 'string') {
                 localStorage.setItem(key, raw ? String(initialValue) : JSON.stringify(initialValue));
                 return initialValue;
@@ -38,10 +22,10 @@ var useLocalStorage = function (key, initialValue, raw) {
             // can throw, too.
             return initialValue;
         }
-    }), 2), state = _a[0], setState = _a[1];
-    react_1.useEffect(function () {
+    });
+    react_1.useEffect(() => {
         try {
-            var serializedState = raw ? String(state) : JSON.stringify(state);
+            const serializedState = raw ? String(state) : JSON.stringify(state);
             localStorage.setItem(key, serializedState);
         }
         catch (_a) {

package/lib/cjs/hooks/useOnScreen.js

@@ -1,33 +1,14 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useOnScreen = void 0;
-var react_1 = require("react");
+const react_1 = require("react");
 function useOnScreen(ref) {
-    var _a = __read(react_1.useState(false), 2), isIntersecting = _a[0], setIntersecting = _a[1];
-    var observer = new IntersectionObserver(function (_a) {
-        var _b = __read(_a, 1), entry = _b[0];
-        return setIntersecting(entry.isIntersecting);
-    });
-    react_1.useEffect(function () {
+    const [isIntersecting, setIntersecting] = react_1.useState(false);
+    const observer = new IntersectionObserver(([entry]) => setIntersecting(entry.isIntersecting));
+    react_1.useEffect(() => {
         observer.observe(ref.current);
         // Remove the observer as soon as the component is unmounted
-        return function () {
+        return () => {
             observer.disconnect();
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps

package/lib/cjs/hooks/usePolling.js

@@ -1,37 +1,15 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.usePolling = void 0;
-var react_1 = require("react");
-var refreshInterval = 120 * 1000;
-function usePolling(intervalCb, dependencies) {
-    if (dependencies === void 0) { dependencies = []; }
-    var depsRef = react_1.useRef(dependencies);
-    var fetch = function () { return !document.hidden && intervalCb.apply(void 0, __spreadArray([], __read(depsRef.current))); };
+const react_1 = require("react");
+const refreshInterval = 120 * 1000;
+function usePolling(intervalCb, dependencies = []) {
+    const depsRef = react_1.useRef(dependencies);
+    const fetch = () => !document.hidden && intervalCb(...depsRef.current);
     depsRef.current = dependencies;
-    react_1.useEffect(function () {
-        var id = setInterval(fetch, refreshInterval);
-        return function () {
+    react_1.useEffect(() => {
+        const id = setInterval(fetch, refreshInterval);
+        return () => {
             clearInterval(id);
         };
         // setInterval should only be called once and cleared on unmount

package/lib/cjs/hooks/usePrevious.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.usePrevious = void 0;
-var react_1 = require("react");
+const react_1 = require("react");
 function usePrevious(value) {
-    var ref = react_1.useRef();
-    react_1.useEffect(function () {
+    const ref = react_1.useRef();
+    react_1.useEffect(() => {
         ref.current = value;
     }, [value]);
     return ref.current;

package/lib/cjs/hooks/useTitle.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useDocumentTitle = void 0;
-var react_1 = require("react");
+const react_1 = require("react");
 function useDocumentTitle(title) {
-    var originalTitle = document.title;
-    react_1.useEffect(function () {
+    const originalTitle = document.title;
+    react_1.useEffect(() => {
         document.title = title;
-        return function () {
+        return () => {
             document.title = originalTitle;
         };
     }, [title, originalTitle]);

package/lib/cjs/hooks/useUndo.js

@@ -1,28 +1,7 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useUndo = exports.UndoRedoActionConstant = void 0;
-var react_1 = require("react");
+const react_1 = require("react");
 var UndoRedoActionConstant;
 (function (UndoRedoActionConstant) {
     UndoRedoActionConstant["undoPresent"] = "UNDO_PRESENT";
@@ -30,70 +9,68 @@ var UndoRedoActionConstant;
     UndoRedoActionConstant["setPresent"] = "SET_PRESENT";
     UndoRedoActionConstant["resetPresent"] = "RESET_PRESENT";
 })(UndoRedoActionConstant = exports.UndoRedoActionConstant || (exports.UndoRedoActionConstant = {}));
-var undoRedoReducer = function () {
-    return function (state, action) {
-        var past = state.past, present = state.present, future = state.future;
-        switch (action.type) {
-            case UndoRedoActionConstant.undoPresent: {
-                var previous = past[past.length - 1];
-                var newPast = past.slice(0, past.length - 1);
-                var t = {
-                    past: newPast,
-                    present: previous,
-                    future: __spreadArray([present], __read(future)),
-                };
-                return t;
-            }
-            case UndoRedoActionConstant.redoPresent: {
-                var next = future[0];
-                var newFuture = future.slice(1);
-                var t1 = {
-                    past: __spreadArray(__spreadArray([], __read(past)), [present]),
-                    present: next,
-                    future: newFuture,
-                };
-                return t1;
-            }
-            case UndoRedoActionConstant.setPresent: {
-                if (action.payload.present === present) {
-                    return state;
-                }
-                return {
-                    past: __spreadArray(__spreadArray([], __read(past)), [present]),
-                    present: action.payload.present,
-                    future: [],
-                };
-            }
-            case UndoRedoActionConstant.resetPresent: {
-                return {
-                    past: [],
-                    present: action.payload.present,
-                    future: [],
-                };
+const undoRedoReducer = () => (state, action) => {
+    const { past, present, future } = state;
+    switch (action.type) {
+        case UndoRedoActionConstant.undoPresent: {
+            const previous = past[past.length - 1];
+            const newPast = past.slice(0, past.length - 1);
+            const t = {
+                past: newPast,
+                present: previous,
+                future: [present, ...future],
+            };
+            return t;
+        }
+        case UndoRedoActionConstant.redoPresent: {
+            const next = future[0];
+            const newFuture = future.slice(1);
+            const t1 = {
+                past: [...past, present],
+                present: next,
+                future: newFuture,
+            };
+            return t1;
+        }
+        case UndoRedoActionConstant.setPresent: {
+            if (action.payload.present === present) {
+                return state;
             }
+            return {
+                past: [...past, present],
+                present: action.payload.present,
+                future: [],
+            };
+        }
+        case UndoRedoActionConstant.resetPresent: {
+            return {
+                past: [],
+                present: action.payload.present,
+                future: [],
+            };
         }
-    };
+    }
 };
 function useUndo(initialPresent) {
-    var _a = __read(react_1.useReducer(undoRedoReducer(), {
+    const [state, dispatch] = react_1.useReducer(undoRedoReducer(), {
         past: [],
         present: initialPresent,
         future: [],
-    }), 2), state = _a[0], dispatch = _a[1];
-    var canUndo = state.past.length !== 0;
-    var canRedo = state.future.length !== 0;
-    var undo = react_1.useCallback(function () {
+    });
+    const canUndo = state.past.length !== 0;
+    const canRedo = state.future.length !== 0;
+    const undo = react_1.useCallback(() => {
         if (canUndo) {
             dispatch({ type: UndoRedoActionConstant.undoPresent });
         }
     }, [canUndo]);
-    var redo = react_1.useCallback(function () {
+    const redo = react_1.useCallback(() => {
         if (canRedo) {
             dispatch({ type: UndoRedoActionConstant.redoPresent });
         }
     }, [canRedo]);
-    var setURValue = react_1.useCallback(function (present) { return dispatch({ type: UndoRedoActionConstant.setPresent, payload: { present: present } }); }, []);
-    var resetURValue = react_1.useCallback(function (present) { return dispatch({ type: UndoRedoActionConstant.resetPresent, payload: { present: present } }); }, []);
-    return { state: state, setURValue: setURValue, resetURValue: resetURValue, undo: undo, redo: redo, canUndo: canUndo, canRedo: canRedo };
+    const setURValue = react_1.useCallback((present) => dispatch({ type: UndoRedoActionConstant.setPresent, payload: { present } }), []);
+    const resetURValue = react_1.useCallback((present) => dispatch({ type: UndoRedoActionConstant.resetPresent, payload: { present } }), []);
+    return { state, setURValue, resetURValue, undo, redo, canUndo, canRedo };
 }
 exports.useUndo = useUndo;