@onepercentio/one-ui 0.6.0 → 0.6.3

package/dist/hooks/useIntersection.js

@@ -1,30 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = require("react");
-function useIntersection() {
-    const { current: targetMap } = (0, react_1.useRef)([]);
-    const { current: observer } = (0, react_1.useRef)(("IntersectionObserver" in window) ? new IntersectionObserver((els) => {
-        els.forEach((e, i) => {
-            const result = targetMap.find((el) => el[0] === e.target);
-            if (result && e.isIntersecting) {
-                result[1]();
-            }
-        });
-    }) : null);
-    return (0, react_1.useMemo)(() => {
-        return {
-            observe: (e, cb) => {
-                targetMap.push([e, cb]);
-                if (observer)
-                    observer.observe(e);
-            },
-            unobserve: (e) => {
-                if (observer)
-                    observer.unobserve(e);
-                targetMap.splice(targetMap.findIndex((el) => el[0] === e), 1);
-            },
-        };
-    }, []);
-}
-exports.default = useIntersection;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+function useIntersection() {
+    const { current: targetMap } = (0, react_1.useRef)([]);
+    const { current: observer } = (0, react_1.useRef)(("IntersectionObserver" in window) ? new IntersectionObserver((els) => {
+        els.forEach((e, i) => {
+            const result = targetMap.find((el) => el[0] === e.target);
+            if (result && e.isIntersecting) {
+                result[1]();
+            }
+        });
+    }) : null);
+    return (0, react_1.useMemo)(() => {
+        return {
+            observe: (e, cb) => {
+                targetMap.push([e, cb]);
+                if (observer)
+                    observer.observe(e);
+            },
+            unobserve: (e) => {
+                if (observer)
+                    observer.unobserve(e);
+                targetMap.splice(targetMap.findIndex((el) => el[0] === e), 1);
+            },
+        };
+    }, []);
+}
+exports.default = useIntersection;
 //# sourceMappingURL=useIntersection.js.map

package/dist/hooks/useObserve.d.ts

@@ -1,2 +1,2 @@
-import "./shims/ObjectWatchShim.js";
-export default function useObserve<T extends any>(toObserve: T | T[], keysToObserve: (keyof T)[]): void;
+import "./shims/ObjectWatchShim.js";
+export default function useObserve<T extends any>(toObserve: T | T[], keysToObserve: (keyof T)[]): void;

package/dist/hooks/useObserve.js

@@ -1,18 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = require("react");
-require("./shims/ObjectWatchShim.js");
-function useObserve(toObserve, keysToObserve) {
-    const [_, ss] = (0, react_1.useState)(0);
-    (0, react_1.useLayoutEffect)(() => {
-        const arr = Array.isArray(toObserve) ? toObserve : [toObserve];
-        const unwatchers = arr.map(object => object.watch(keysToObserve, () => {
-            ss((p) => {
-                return p + 1;
-            });
-        }));
-        return () => unwatchers.forEach(unwatch => unwatch());
-    }, [toObserve]);
-}
-exports.default = useObserve;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+require("./shims/ObjectWatchShim.js");
+function useObserve(toObserve, keysToObserve) {
+    const [_, ss] = (0, react_1.useState)(0);
+    (0, react_1.useLayoutEffect)(() => {
+        const arr = Array.isArray(toObserve) ? toObserve : [toObserve];
+        const unwatchers = arr.map(object => object.watch(keysToObserve, () => {
+            ss((p) => {
+                return p + 1;
+            });
+        }));
+        return () => unwatchers.forEach(unwatch => unwatch());
+    }, [toObserve]);
+}
+exports.default = useObserve;
 //# sourceMappingURL=useObserve.js.map

package/dist/hooks/usePagination.d.ts

@@ -1,19 +1,19 @@
-import useAsyncControl from "./useAsyncControl";
-import { CommonErrorCodes } from "../types";
-declare type UpdateEvent<I extends any> = {
-    finished: boolean;
-    items: I;
-    totalItems: number;
-};
-export default function usePagination<I extends any, A extends any[]>(request: (page: number, currItems?: I, ...args: A) => Promise<UpdateEvent<I>>, paginationId?: (...args: A) => string): Paginable<I, A>;
-export declare type Paginable<I extends any, A extends any[] = []> = {
-    updateItems: (cb: (prevItems?: I) => UpdateEvent<I>["items"]) => void;
-    getNextPage: (...args: A) => void;
-    getPage: (page: number, ...args: A) => void;
-    totalItems: (...args: A) => number | undefined;
-    loading: boolean;
-    error: CommonErrorCodes | undefined;
-    items: I | undefined;
-    setError: ReturnType<typeof useAsyncControl>["setError"];
-};
-export {};
+import useAsyncControl from "./useAsyncControl";
+import { CommonErrorCodes } from "../types";
+declare type UpdateEvent<I extends any> = {
+    finished: boolean;
+    items: I;
+    totalItems: number;
+};
+export default function usePagination<I extends any, A extends any[]>(request: (page: number, currItems?: I, ...args: A) => Promise<UpdateEvent<I>>, paginationId?: (...args: A) => string): Paginable<I, A>;
+export declare type Paginable<I extends any, A extends any[] = []> = {
+    updateItems: (cb: (prevItems?: I) => UpdateEvent<I>["items"]) => void;
+    getNextPage: (...args: A) => void;
+    getPage: (page: number, ...args: A) => void;
+    totalItems: (...args: A) => number | undefined;
+    loading: boolean;
+    error: CommonErrorCodes | undefined;
+    items: I | undefined;
+    setError: ReturnType<typeof useAsyncControl>["setError"];
+};
+export {};

package/dist/hooks/usePagination.js

@@ -1,65 +1,65 @@
-"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());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = require("react");
-const useAsyncControl_1 = __importDefault(require("./useAsyncControl"));
-function usePagination(request, paginationId = () => "default") {
-    const paginationDataRef = (0, react_1.useRef)({});
-    const { current: paginationData } = paginationDataRef;
-    const currentPageRef = (0, react_1.useRef)({});
-    const { current: currentPage } = currentPageRef;
-    const [items, setItems] = (0, react_1.useState)();
-    const _a = (0, useAsyncControl_1.default)(), { process } = _a, control = __rest(_a, ["process"]);
-    function updateItems(cb) {
-        setItems(cb);
-    }
-    function _requestPage(page, ...args) {
-        var _a;
-        const id = paginationId(...args);
-        if (((_a = paginationData[id]) === null || _a === void 0 ? void 0 : _a.finished) || control.loading)
-            return;
-        process(() => __awaiter(this, void 0, void 0, function* () {
-            const result = yield request(page, items, ...args);
-            currentPage[id] = page;
-            paginationData[id] = {
-                finished: result.finished,
-                totalItems: result.totalItems,
-            };
-            setItems(result.items);
-        }));
-    }
-    return {
-        updateItems,
-        getNextPage: (...args) => _requestPage((currentPage[paginationId(...args)] || 0) + 1, ...args),
-        getPage: _requestPage,
-        totalItems: (...args) => { var _a; return (_a = paginationData[paginationId(...args)]) === null || _a === void 0 ? void 0 : _a.totalItems; },
-        loading: control.loading,
-        error: control.error,
-        items,
-        setError: control.setError
-    };
-}
-exports.default = usePagination;
+"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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const useAsyncControl_1 = __importDefault(require("./useAsyncControl"));
+function usePagination(request, paginationId = () => "default") {
+    const paginationDataRef = (0, react_1.useRef)({});
+    const { current: paginationData } = paginationDataRef;
+    const currentPageRef = (0, react_1.useRef)({});
+    const { current: currentPage } = currentPageRef;
+    const [items, setItems] = (0, react_1.useState)();
+    const _a = (0, useAsyncControl_1.default)(), { process } = _a, control = __rest(_a, ["process"]);
+    function updateItems(cb) {
+        setItems(cb);
+    }
+    function _requestPage(page, ...args) {
+        var _a;
+        const id = paginationId(...args);
+        if (((_a = paginationData[id]) === null || _a === void 0 ? void 0 : _a.finished) || control.loading)
+            return;
+        process(() => __awaiter(this, void 0, void 0, function* () {
+            const result = yield request(page, items, ...args);
+            currentPage[id] = page;
+            paginationData[id] = {
+                finished: result.finished,
+                totalItems: result.totalItems,
+            };
+            setItems(result.items);
+        }));
+    }
+    return {
+        updateItems,
+        getNextPage: (...args) => _requestPage((currentPage[paginationId(...args)] || 0) + 1, ...args),
+        getPage: _requestPage,
+        totalItems: (...args) => { var _a; return (_a = paginationData[paginationId(...args)]) === null || _a === void 0 ? void 0 : _a.totalItems; },
+        loading: control.loading,
+        error: control.error,
+        items,
+        setError: control.setError
+    };
+}
+exports.default = usePagination;
 //# sourceMappingURL=usePagination.js.map

package/dist/hooks/usePooledOperation.d.ts

@@ -1,15 +1,15 @@
-/**
- * A toolkit hook to trigger an request to start a process and execute a pooling operation to validate when the operation is finished
- */
-export default function usePooledOperation(): {
-    /** Indicates when it's loading */
-    loading: any;
-    /** Indicates error of pooling or request */
-    error: boolean;
-    /** Retries the operation based on the current failed step */
-    retry: (() => void) | undefined;
-    /** Initiates the request followed by the pooling operation */
-    start: (_requestOperation: () => Promise<void>, _poolingOperation: () => Promise<boolean>) => void;
-    /** Clear any error that is registered */
-    clearError: () => void;
-};
+/**
+ * A toolkit hook to trigger an request to start a process and execute a pooling operation to validate when the operation is finished
+ */
+export default function usePooledOperation(): {
+    /** Indicates when it's loading */
+    loading: any;
+    /** Indicates error of pooling or request */
+    error: boolean;
+    /** Retries the operation based on the current failed step */
+    retry: (() => void) | undefined;
+    /** Initiates the request followed by the pooling operation */
+    start: (_requestOperation: () => Promise<void>, _poolingOperation: () => Promise<boolean>) => void;
+    /** Clear any error that is registered */
+    clearError: () => void;
+};

package/dist/hooks/usePooledOperation.js

@@ -1,64 +1,64 @@
-"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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = require("react");
-const useAsyncControl_1 = __importDefault(require("./useAsyncControl"));
-const usePooling_1 = __importDefault(require("./usePooling"));
-/**
- * A toolkit hook to trigger an request to start a process and execute a pooling operation to validate when the operation is finished
- */
-function usePooledOperation() {
-    const requestOperation = (0, react_1.useRef)();
-    const poolingOperation = (0, react_1.useRef)();
-    const requestControl = (0, useAsyncControl_1.default)();
-    const pollingControl = (0, usePooling_1.default)();
-    function triggerRequest() {
-        requestControl.process(() => __awaiter(this, void 0, void 0, function* () {
-            yield requestOperation.current();
-            triggerPooling();
-        }));
-    }
-    function triggerPooling() {
-        pollingControl.startPolling(poolingOperation.current);
-    }
-    return {
-        /** Indicates when it's loading */
-        loading: requestControl.loading || pollingControl.isPooling,
-        /** Indicates error of pooling or request */
-        error: !!requestControl.error || !!pollingControl.failed,
-        /** Retries the operation based on the current failed step */
-        retry: requestControl.error
-            ? triggerRequest
-            : pollingControl.failed
-                ? triggerPooling
-                : undefined,
-        /** Initiates the request followed by the pooling operation */
-        start: (
-        /** An arbitrary request */
-        _requestOperation, 
-        /** Resolves to a boolean that indicated if is finished (true) or not (false) */
-        _poolingOperation) => {
-            requestOperation.current = _requestOperation;
-            poolingOperation.current = _poolingOperation;
-            triggerRequest();
-        },
-        /** Clear any error that is registered */
-        clearError: () => {
-            requestControl.setError(undefined);
-            pollingControl.setFailed(false);
-        },
-    };
-}
-exports.default = usePooledOperation;
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const useAsyncControl_1 = __importDefault(require("./useAsyncControl"));
+const usePooling_1 = __importDefault(require("./usePooling"));
+/**
+ * A toolkit hook to trigger an request to start a process and execute a pooling operation to validate when the operation is finished
+ */
+function usePooledOperation() {
+    const requestOperation = (0, react_1.useRef)();
+    const poolingOperation = (0, react_1.useRef)();
+    const requestControl = (0, useAsyncControl_1.default)();
+    const pollingControl = (0, usePooling_1.default)();
+    function triggerRequest() {
+        requestControl.process(() => __awaiter(this, void 0, void 0, function* () {
+            yield requestOperation.current();
+            triggerPooling();
+        }));
+    }
+    function triggerPooling() {
+        pollingControl.startPolling(poolingOperation.current);
+    }
+    return {
+        /** Indicates when it's loading */
+        loading: requestControl.loading || pollingControl.isPooling,
+        /** Indicates error of pooling or request */
+        error: !!requestControl.error || !!pollingControl.failed,
+        /** Retries the operation based on the current failed step */
+        retry: requestControl.error
+            ? triggerRequest
+            : pollingControl.failed
+                ? triggerPooling
+                : undefined,
+        /** Initiates the request followed by the pooling operation */
+        start: (
+        /** An arbitrary request */
+        _requestOperation, 
+        /** Resolves to a boolean that indicated if is finished (true) or not (false) */
+        _poolingOperation) => {
+            requestOperation.current = _requestOperation;
+            poolingOperation.current = _poolingOperation;
+            triggerRequest();
+        },
+        /** Clear any error that is registered */
+        clearError: () => {
+            requestControl.setError(undefined);
+            pollingControl.setFailed(false);
+        },
+    };
+}
+exports.default = usePooledOperation;
 //# sourceMappingURL=usePooledOperation.js.map

package/dist/hooks/usePooling.d.ts

@@ -1,16 +1,16 @@
-/// <reference types="react" />
-/**
- * This callback should return a boolean that indicates if the pooling has finished (true) or it should continue (false)
- */
-declare type PoolingAction = () => Promise<boolean>;
-export default function usePooling(intervalMs?: number, maxPoolingTime?: number): {
-    failed: boolean;
-    setFailed: import("react").Dispatch<import("react").SetStateAction<boolean>>;
-    isPooling: boolean;
-    /**
-     *
-     * @param cb {@link PoolingAction} - Executes and returns if has finished (true) or not (false)
-     */
-    startPolling: (cb: PoolingAction) => void;
-};
-export {};
+/// <reference types="react" />
+/**
+ * This callback should return a boolean that indicates if the pooling has finished (true) or it should continue (false)
+ */
+declare type PoolingAction = () => Promise<boolean>;
+export default function usePooling(intervalMs?: number, maxPoolingTime?: number): {
+    failed: boolean;
+    setFailed: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    isPooling: boolean;
+    /**
+     *
+     * @param cb {@link PoolingAction} - Executes and returns if has finished (true) or not (false)
+     */
+    startPolling: (cb: PoolingAction) => void;
+};
+export {};

package/dist/hooks/usePooling.js

@@ -1,47 +1,47 @@
-"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 });
-const react_1 = require("react");
-function usePooling(intervalMs = 1000, maxPoolingTime = 60000) {
-    const [intervalId, setIntervalId] = (0, react_1.useState)();
-    const [failed, setFailed] = (0, react_1.useState)(false);
-    (0, react_1.useEffect)(() => () => {
-        if (intervalId)
-            clearInterval(intervalId);
-    }, [intervalId]);
-    return {
-        failed,
-        setFailed,
-        isPooling: !!intervalId,
-        /**
-         *
-         * @param cb {@link PoolingAction} - Executes and returns if has finished (true) or not (false)
-         */
-        startPolling: (cb) => {
-            const maxPoolings = Math.ceil(maxPoolingTime / intervalMs);
-            let poolingCount = 0;
-            const intervalId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-                poolingCount++;
-                const finished = yield cb();
-                if (finished)
-                    setIntervalId(undefined);
-                else if (poolingCount === maxPoolings) {
-                    setIntervalId(undefined);
-                    setFailed(true);
-                }
-            }), intervalMs);
-            setIntervalId(intervalId);
-            setFailed(false);
-        },
-    };
-}
-exports.default = usePooling;
+"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 });
+const react_1 = require("react");
+function usePooling(intervalMs = 1000, maxPoolingTime = 60000) {
+    const [intervalId, setIntervalId] = (0, react_1.useState)();
+    const [failed, setFailed] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => () => {
+        if (intervalId)
+            clearInterval(intervalId);
+    }, [intervalId]);
+    return {
+        failed,
+        setFailed,
+        isPooling: !!intervalId,
+        /**
+         *
+         * @param cb {@link PoolingAction} - Executes and returns if has finished (true) or not (false)
+         */
+        startPolling: (cb) => {
+            const maxPoolings = Math.ceil(maxPoolingTime / intervalMs);
+            let poolingCount = 0;
+            const intervalId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                poolingCount++;
+                const finished = yield cb();
+                if (finished)
+                    setIntervalId(undefined);
+                else if (poolingCount === maxPoolings) {
+                    setIntervalId(undefined);
+                    setFailed(true);
+                }
+            }), intervalMs);
+            setIntervalId(intervalId);
+            setFailed(false);
+        },
+    };
+}
+exports.default = usePooling;
 //# sourceMappingURL=usePooling.js.map

package/dist/hooks/usePooling.test.d.ts

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