robbyson-frontend-library 0.0.1-rc1

package/src/states/main-container/app.state.interface.ts

@@ -0,0 +1,7 @@
+import { IRootApp } from "./root-app.state.interface";
+import { persistReducer } from 'redux-persist';
+import { PersistPartial } from 'redux-persist/es/persistReducer';
+
+export interface IAppState {
+    RootApp: IRootApp & PersistPartial;
+};

package/src/states/main-container/plataform.state.interface.ts

@@ -0,0 +1,5 @@
+import { IAppState } from "./app.state.interface";
+
+export interface IPlatformState {
+    Global: IAppState
+}

package/src/states/main-container/root-app.state.interface.ts

@@ -0,0 +1,15 @@
+import { ThemeBase, UserSessionModel } from "../../models";
+import { BrowserHistory } from "history"
+
+export interface IRootApp {
+    userSession?: UserSessionModel,
+    angelFriendData?: any,
+    ipWhiteList: boolean,
+    currentLocale?: any,
+    currentTheme: ThemeBase,
+    apisUrls: {
+        private: string
+    },
+    history: BrowserHistory,
+    createGlobalImplementations: () => void,
+}

package/src/utils/build-error/buildError.util.interface.ts

@@ -0,0 +1,5 @@
+import { RobbysonResponseError } from "../../factories";
+
+export interface IBuildError {
+    buildError(error: RobbysonResponseError): void;
+}

package/src/utils/build-error/buildError.util.ts

@@ -0,0 +1,13 @@
+import { toast } from "react-toastify";
+import { ResponseStatusLogMessages, RobbysonResponseError } from "../../factories";
+
+export class BuildError {    
+
+    public static buildError(error: RobbysonResponseError): RobbysonResponseError {
+        error.data.map((err: ResponseStatusLogMessages) => {
+            return toast.error(err.text);
+        });
+
+        return error;
+    }
+}

package/src/utils/cache-control.tsx

@@ -0,0 +1,92 @@
+import { AxiosRequestConfig } from 'axios';
+import { LOCALSTORAGE, config, createInstance } from 'localforage';
+import moment, { DurationInputArg1, DurationInputArg2 } from 'moment';
+
+export type MaxAge = [DurationInputArg1, DurationInputArg2];
+export interface CacheConfig extends AxiosRequestConfig {
+    cache?: boolean;
+    maxAge?: MaxAge;
+    delayOnCache?: number;
+    type?: string;
+};
+export type Cache = {
+    expire: string;
+    value: any
+};
+
+export class CacheControl {
+
+    private static dbInstance: LocalForage;
+
+    static getDbInstance(): LocalForage {
+        if (!CacheControl.dbInstance) {
+            config({
+                driver: LOCALSTORAGE,
+                name: 'Robbyson',
+                version: 1,
+                storeName: 'CacheControl',
+            });
+            const userAuth = JSON.parse(sessionStorage.getItem('persist:auth') || '{}').data;
+            const user = JSON.parse(userAuth || '{}');
+
+            CacheControl.dbInstance = createInstance({
+                name: `cache-${user._id.toString()}`,
+            });
+        }
+        return CacheControl.dbInstance;
+    }
+
+    static getCache(key: string): Promise<Cache> {
+        //@ts-ignore
+        return this.getDbInstance().getItem(key);
+    }
+
+    static setCache(key: string, value: any, maxAge: MaxAge, type = ''): void {
+        const now = moment();
+        const data: any = {
+            value,
+            type,
+            cratedAt: now.toDate().toISOString(),
+            expire: now
+                .add(maxAge[0], maxAge[1])
+                .toDate()
+                .toISOString(),
+        };
+        this.getDbInstance().setItem(key, data);
+    }
+
+    static async hasCache(): Promise<number> {
+        let length: number;
+        try {
+            length = await this.getDbInstance().length();
+        } catch (error) {
+            console.log(error);
+            length = 0;
+        }
+        return length;
+    }
+
+    static clearCache(): void {
+        this.getDbInstance()
+            .clear()
+            .then(() => console.log('Cache purged.'));
+    }
+
+    static clearExpiredCache(): void {
+        this.getDbInstance()
+            .iterate((value: any, key: string, _) => {
+                if (
+                    value &&
+                    moment(value.expire).isSameOrBefore(moment.now())
+                ) {
+                    this.getDbInstance().removeItem(key, () =>
+                        console.log(`Key ${key} is cleared!`),
+                    );
+                }
+            })
+            .then(() =>
+                console.log('Iteration has completed, expired cache purged.'),
+            )
+            .catch(err => err);
+    }
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+export * from './build-error/buildError.util.interface';
+export * from './build-error/buildError.util';
+export * from './query-params'
+export * from './cache-control'
+export * from "./robbyson-navigate";

package/src/utils/query-params/index.ts

@@ -0,0 +1,38 @@
+export class QueryParams {
+    public static set(
+        filter?: {},
+        sort?: {},
+        projection?: {},
+        limit?: number | string,
+        skip?: number | string
+    ): string {
+        let queryParams = "";
+        if (filter && Object.keys(filter).length) {
+            for (const [key, value] of Object.entries(filter)) {
+                queryParams = queryParams + `&$filter.${key}=${value}`;
+            }
+        }
+
+        if (sort && Object.keys(sort).length) {
+            for (const [key, value] of Object.entries(sort)) {
+                queryParams = queryParams + `&$sort=${value}${key}`;
+            }
+        }
+
+        if (projection && Object.keys(projection).length) {
+            for (const [key, value] of Object.entries(projection)) {
+                queryParams = queryParams + `&$fields=${value}${key}`;
+            }
+        }
+
+        if (limit) {
+            queryParams = queryParams + `&$limit=${limit}`;
+        }
+
+        if (skip) {
+            queryParams = queryParams + `&$skip=${skip}`;
+        }
+
+        return queryParams;
+    }
+}

package/src/utils/robbyson-navigate.ts

@@ -0,0 +1,76 @@
+import { GlobalStore, IGlobalStore } from "redux-micro-frontend";
+import { IPlatformState } from "../states";
+import { To } from "history";
+import queryString from "query-string";
+
+export class RobbysonNavigate {
+    private static _globalStore: IGlobalStore;
+    private static _globalState: IPlatformState;
+
+    static to(url: string) {
+        RobbysonNavigate._globalStore = GlobalStore.Get();
+        RobbysonNavigate._globalState =
+            RobbysonNavigate._globalStore.GetGlobalState();
+
+        const { history } = RobbysonNavigate._globalState.Global.RootApp;
+
+        // TODO: Usar a LIB PATH para concatenar a URL
+        history.push(`/operacao${url}`);
+    }
+
+    static back() {
+        RobbysonNavigate._globalStore = GlobalStore.Get();
+        RobbysonNavigate._globalState =
+            RobbysonNavigate._globalStore.GetGlobalState();
+
+        const { history } = RobbysonNavigate._globalState.Global.RootApp;
+
+        history.back();
+    }
+
+    static replace(replace: To, state?: any) {
+        RobbysonNavigate._globalStore = GlobalStore.Get();
+        RobbysonNavigate._globalState =
+            RobbysonNavigate._globalStore.GetGlobalState();
+
+        const { history } = RobbysonNavigate._globalState.Global.RootApp;
+
+        history.replace(replace, state);
+    }
+
+    static getQueryParams<T>(): T {
+        RobbysonNavigate._globalStore = GlobalStore.Get();
+        RobbysonNavigate._globalState =
+            RobbysonNavigate._globalStore.GetGlobalState();
+
+        const { history } = RobbysonNavigate._globalState.Global.RootApp;
+
+        return queryString.parse(history.location.search, {
+            sort: false,
+        }) as T;
+    }
+
+    static setQueryParams(key: string, value: string): void {
+        const queryString = new URLSearchParams(
+            RobbysonNavigate.getQueryParams<URLSearchParams>()
+        );
+
+        queryString.set(key, value);
+
+        RobbysonNavigate.replace({
+            search: queryString.toString(),
+        });
+    }
+
+    static removeQueryParams(key: string): void {
+        const queryString = new URLSearchParams(
+            RobbysonNavigate.getQueryParams<URLSearchParams>()
+        );
+
+        queryString.delete(key);
+
+        RobbysonNavigate.replace({
+            search: queryString.toString(),
+        });
+    }
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+    "compilerOptions": {
+        "target": "es5",
+        "lib": [
+            "dom",
+            "dom.iterable",
+            "esnext"
+        ],
+        "baseUrl": "./",
+        "allowJs": true,
+        "skipLibCheck": true,
+        "esModuleInterop": true,
+        "allowSyntheticDefaultImports": true,
+        "strict": true,
+        "forceConsistentCasingInFileNames": true,
+        "noFallthroughCasesInSwitch": true,
+        "module": "esnext",
+        "moduleResolution": "node",
+        "resolveJsonModule": true,
+        "isolatedModules": true,
+        "noEmit": false,
+        "strictPropertyInitialization": false,
+        "outDir": "./dist",
+        "jsx": "react"
+    },
+    "include": [
+        "src",
+        "index.d.ts"
+    ]
+}