x25 17.3.24 → 17.3.26

package/Loader/CreateLoad.d.ts

@@ -0,0 +1,13 @@
+declare type PropTypes = {
+    readonly children: any;
+};
+export declare type CreateGenericOptions = {
+    url: string;
+    normalizeResult: (response: any) => any;
+    reducerName: string;
+};
+export declare type LoadGenericDataOptions = CreateGenericOptions & {
+    selectors: any;
+};
+declare const createLoadGenericData: ({ reducerName, url, selectors, normalizeResult }: LoadGenericDataOptions) => (props: PropTypes) => any;
+export default createLoadGenericData;

package/Loader/CreateLoad.js

@@ -0,0 +1,82 @@
+"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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = __importDefault(require("react"));
+var react_redux_1 = require("react-redux");
+var toolkit_1 = require("@reduxjs/toolkit");
+var superagent_1 = __importDefault(require("superagent"));
+var utility_1 = require("../utility");
+var Messages_1 = require("../Messages");
+var createLoadGenericData = function (_a) {
+    var reducerName = _a.reducerName, url = _a.url, selectors = _a.selectors, normalizeResult = _a.normalizeResult;
+    var createAction = (0, toolkit_1.createAsyncThunk)(reducerName, function () { return __awaiter(void 0, void 0, void 0, function () {
+        var response;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, superagent_1.default.
+                        get(url).
+                        type("json")];
+                case 1:
+                    response = _a.sent();
+                    return [2 /*return*/, normalizeResult(response)];
+            }
+        });
+    }); }), Worker = function (props) {
+        var children = props.children, shouldFetch = (0, react_redux_1.useSelector)(selectors.shouldFetch), isFetching = (0, react_redux_1.useSelector)(selectors.isFetching), hasError = (0, react_redux_1.useSelector)(selectors.hasError), dispatch = (0, react_redux_1.useDispatch)(), performFetch = function () {
+            dispatch(createAction());
+        };
+        react_1.default.useEffect(function () {
+            if (shouldFetch) {
+                performFetch();
+            }
+        }, [shouldFetch, hasError, isFetching]);
+        if (hasError) {
+            return react_1.default.createElement(Messages_1.LargeErrorMessage, { message: utility_1.words.ThereWasAProblem, onRetry: performFetch });
+        }
+        if (isFetching) {
+            return react_1.default.createElement(Messages_1.LoadingMessage, { message: utility_1.words.LoadingData });
+        }
+        return children;
+    };
+    return Worker;
+};
+exports.default = createLoadGenericData;
+//# sourceMappingURL=CreateLoad.js.map

package/Loader/CreateLoad.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateLoad.js","sourceRoot":"","sources":["../../src/Loader/CreateLoad.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,gDAA0B;AAM1B,2CAAuD;AACvD,4CAAoD;AACpD,0DAAoC;AACpC,sCAAmC;AACnC,wCAAgE;AAYhE,IACE,qBAAqB,GAAG,UAAC,EAAwE;QAAtE,WAAW,iBAAA,EAAE,GAAG,SAAA,EAAE,SAAS,eAAA,EAAE,eAAe,qBAAA;IACrE,IACE,YAAY,GAAG,IAAA,0BAAgB,EAAC,WAAW,EAAE;;;;wBAE9B,qBAAM,oBAAU;wBACzB,GAAG,CAAC,GAAG,CAAC;wBACR,IAAI,CAAC,MAAM,CAAC,EAAA;;oBAFd,QAAQ,GAAG,SAEG;oBAEhB,sBAAO,eAAe,CAAC,QAAQ,CAAC,EAAC;;;SAClC,CACO,EACR,MAAM,GAAG,UAAC,KAAgB;QAEpB,IAAA,QAAQ,GAAK,KAAK,SAAV,EACV,WAAW,GAAG,IAAA,yBAAW,EAAC,SAAS,CAAC,WAAW,CAAC,EAChD,UAAU,GAAG,IAAA,yBAAW,EAAC,SAAS,CAAC,UAAU,CAAC,EAC9C,QAAQ,GAAG,IAAA,yBAAW,EAAC,SAAS,CAAC,QAAQ,CAAC,EAE1C,QAAQ,GAAG,IAAA,yBAAW,GAAE,EACxB,YAAY,GAAG;YACb,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAC;QAC3B,CAAC,CAAC;QAEJ,eAAK,CAAC,SAAS,CAAC;YACd,IAAI,WAAW,EAAE;gBACf,YAAY,EAAE,CAAC;aAChB;QACH,CAAC,EAAE,CAAC,WAAW,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC;QAExC,IAAI,QAAQ,EAAE;YACZ,OAAO,8BAAC,4BAAiB,IAAC,OAAO,EAAE,eAAK,CAAC,gBAAgB,EAAE,OAAO,EAAE,YAAY,GAAI,CAAC;SACtF;QAED,IAAI,UAAU,EAAE;YACd,OAAO,8BAAC,yBAAc,IAAC,OAAO,EAAE,eAAK,CAAC,WAAW,GAAI,CAAC;SACvD;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC,CAAC;IAEJ,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEJ,kBAAe,qBAAqB,CAAC"}

package/Loader/index.d.ts

@@ -0,0 +1,476 @@
+import Immutable from "immutable";
+import { CreateGenericOptions as LoaderOptions } from "./CreateLoad";
+declare type State = Immutable.Map<string, any>;
+export declare const statusReducer = "status", initialState: Immutable.Map<string, Immutable.Map<string, string | boolean>>, pending: (state: State) => State, rejected: (state: State) => State, fulfilled: (state: State, { payload }: any) => State, createGenericLoader: ({ reducerName, url, normalizeResult }: LoaderOptions) => {
+    stateSelectors: {
+        shouldFetch: ((state: {
+            readonly size: number;
+            set: (key: string, value: any) => State;
+            delete: (key: string) => State;
+            remove: (key: string) => State;
+            deleteAll: (keys: Iterable<string>) => State;
+            removeAll: (keys: Iterable<string>) => State;
+            clear: () => State;
+            update: {
+                (key: string, notSetValue: any, updater: (value: any) => any): State;
+                (key: string, updater: (value: any) => any): State;
+                <R>(updater: (value: State) => R): R;
+            };
+            merge: {
+                <KC, VC>(...collections: Iterable<[KC, VC]>[]): Immutable.Map<string | KC, any>;
+                <C>(...collections: {
+                    [key: string]: C;
+                }[]): Immutable.Map<string, any>;
+            };
+            concat: {
+                <KC_1, VC_1>(...collections: Iterable<[KC_1, VC_1]>[]): Immutable.Map<string | KC_1, any>;
+                <C_1>(...collections: {
+                    [key: string]: C_1;
+                }[]): Immutable.Map<string, any>;
+            };
+            mergeWith: (merger: (oldVal: any, newVal: any, key: string) => any, ...collections: (Iterable<[string, any]> | {
+                [key: string]: any;
+            })[]) => State;
+            mergeDeep: (...collections: (Iterable<[string, any]> | {
+                [key: string]: any;
+            })[]) => State;
+            mergeDeepWith: (merger: (oldVal: unknown, newVal: unknown, key: unknown) => unknown, ...collections: (Iterable<[string, any]> | {
+                [key: string]: any;
+            })[]) => State;
+            setIn: (keyPath: Iterable<unknown>, value: unknown) => State;
+            deleteIn: (keyPath: Iterable<unknown>) => State;
+            removeIn: (keyPath: Iterable<unknown>) => State;
+            updateIn: {
+                (keyPath: Iterable<unknown>, notSetValue: unknown, updater: (value: unknown) => unknown): State;
+                (keyPath: Iterable<unknown>, updater: (value: unknown) => unknown): State;
+            };
+            mergeIn: (keyPath: Iterable<unknown>, ...collections: unknown[]) => State;
+            mergeDeepIn: (keyPath: Iterable<unknown>, ...collections: unknown[]) => State;
+            withMutations: (mutator: (mutable: State) => unknown) => State;
+            asMutable: () => State;
+            wasAltered: () => boolean;
+            asImmutable: () => State;
+            map: <M>(mapper: (value: any, key: string, iter: State) => M, context?: unknown) => Immutable.Map<string, M>;
+            mapKeys: <M_1>(mapper: (key: string, value: any, iter: State) => M_1, context?: unknown) => Immutable.Map<M_1, any>;
+            mapEntries: <KM, VM>(mapper: (entry: [string, any], index: number, iter: State) => [KM, VM] | undefined, context?: unknown) => Immutable.Map<KM, VM>;
+            flatMap: <KM_1, VM_1>(mapper: (value: any, key: string, iter: State) => Iterable<[KM_1, VM_1]>, context?: unknown) => Immutable.Map<KM_1, VM_1>;
+            filter: {
+                <F extends any>(predicate: (value: any, key: string, iter: State) => value is F, context?: unknown): Immutable.Map<string, F>;
+                (predicate: (value: any, key: string, iter: State) => unknown, context?: unknown): State;
+            };
+            flip: () => Immutable.Map<any, string>;
+            toJS: () => {
+                [key: string]: unknown;
+            };
+            toJSON: () => {
+                [key: string]: any;
+            };
+            toArray: () => [string, any][];
+            toSeq: () => Immutable.Seq.Keyed<string, any>;
+            [Symbol.iterator]: () => IterableIterator<[string, any]>;
+            equals: (other: unknown) => boolean;
+            hashCode: () => number;
+            get: {
+                <NSV>(key: string, notSetValue: NSV): any;
+                (key: string): any;
+            };
+            has: (key: string) => boolean;
+            includes: (value: any) => boolean;
+            contains: (value: any) => boolean;
+            first: <NSV_1 = undefined>(notSetValue?: NSV_1 | undefined) => any;
+            last: <NSV_2 = undefined>(notSetValue?: NSV_2 | undefined) => any;
+            getIn: (searchKeyPath: Iterable<unknown>, notSetValue?: unknown) => unknown;
+            hasIn: (searchKeyPath: Iterable<unknown>) => boolean;
+            toObject: () => {
+                [key: string]: any;
+            };
+            toMap: () => Immutable.Map<string, any>;
+            toOrderedMap: () => Immutable.OrderedMap<string, any>;
+            toSet: () => Immutable.Set<any>;
+            toOrderedSet: () => Immutable.OrderedSet<any>;
+            toList: () => Immutable.List<any>;
+            toStack: () => Immutable.Stack<any>;
+            toKeyedSeq: () => Immutable.Seq.Keyed<string, any>;
+            toIndexedSeq: () => Immutable.Seq.Indexed<any>;
+            toSetSeq: () => Immutable.Seq.Set<any>;
+            keys: () => IterableIterator<string>;
+            values: () => IterableIterator<any>;
+            entries: () => IterableIterator<[string, any]>;
+            keySeq: () => Immutable.Seq.Indexed<string>;
+            valueSeq: () => Immutable.Seq.Indexed<any>;
+            entrySeq: () => Immutable.Seq.Indexed<[string, any]>;
+            filterNot: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            reverse: () => State;
+            sort: (comparator?: ((valueA: any, valueB: any) => number) | undefined) => State;
+            sortBy: <C_2>(comparatorValueMapper: (value: any, key: string, iter: State) => C_2, comparator?: ((valueA: C_2, valueB: C_2) => number) | undefined) => State;
+            groupBy: <G>(grouper: (value: any, key: string, iter: State) => G, context?: unknown) => Immutable.Seq.Keyed<G, Immutable.Collection<string, any>>;
+            forEach: (sideEffect: (value: any, key: string, iter: State) => unknown, context?: unknown) => number;
+            slice: (begin?: number | undefined, end?: number | undefined) => State;
+            rest: () => State;
+            butLast: () => State;
+            skip: (amount: number) => State;
+            skipLast: (amount: number) => State;
+            skipWhile: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            skipUntil: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            take: (amount: number) => State;
+            takeLast: (amount: number) => State;
+            takeWhile: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            takeUntil: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            flatten: {
+                (depth?: number | undefined): Immutable.Collection<unknown, unknown>;
+                (shallow?: boolean | undefined): Immutable.Collection<unknown, unknown>;
+            };
+            reduce: {
+                <R_1>(reducer: (reduction: R_1, value: any, key: string, iter: State) => R_1, initialReduction: R_1, context?: unknown): R_1;
+                <R_2>(reducer: (reduction: any, value: any, key: string, iter: State) => R_2): R_2;
+            };
+            reduceRight: {
+                <R_3>(reducer: (reduction: R_3, value: any, key: string, iter: State) => R_3, initialReduction: R_3, context?: unknown): R_3;
+                <R_4>(reducer: (reduction: any, value: any, key: string, iter: State) => R_4): R_4;
+            };
+            every: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => boolean;
+            some: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => boolean;
+            join: (separator?: string | undefined) => string;
+            isEmpty: () => boolean;
+            count: {
+                (): number;
+                (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown): number;
+            };
+            countBy: <G_1>(grouper: (value: any, key: string, iter: State) => G_1, context?: unknown) => Immutable.Map<G_1, number>;
+            find: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown, notSetValue?: any) => any;
+            findLast: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown, notSetValue?: any) => any;
+            findEntry: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown, notSetValue?: any) => [string, any] | undefined;
+            findLastEntry: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown, notSetValue?: any) => [string, any] | undefined;
+            findKey: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => string | undefined;
+            findLastKey: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => string | undefined;
+            keyOf: (searchValue: any) => string | undefined;
+            lastKeyOf: (searchValue: any) => string | undefined;
+            max: (comparator?: ((valueA: any, valueB: any) => number) | undefined) => any;
+            maxBy: <C_3>(comparatorValueMapper: (value: any, key: string, iter: State) => C_3, comparator?: ((valueA: C_3, valueB: C_3) => number) | undefined) => any;
+            min: (comparator?: ((valueA: any, valueB: any) => number) | undefined) => any;
+            minBy: <C_4>(comparatorValueMapper: (value: any, key: string, iter: State) => C_4, comparator?: ((valueA: C_4, valueB: C_4) => number) | undefined) => any;
+            isSubset: (iter: Iterable<any>) => boolean;
+            isSuperset: (iter: Iterable<any>) => boolean;
+        }) => boolean) & import("reselect").OutputSelectorFields<(args_0: boolean, args_1: boolean, args_2: string) => boolean & {
+            clearCache: () => void;
+        }> & {
+            clearCache: () => void;
+        };
+        isFetched: ((state: {
+            readonly size: number;
+            set: (key: string, value: any) => State;
+            delete: (key: string) => State;
+            remove: (key: string) => State;
+            deleteAll: (keys: Iterable<string>) => State;
+            removeAll: (keys: Iterable<string>) => State;
+            clear: () => State;
+            update: {
+                (key: string, notSetValue: any, updater: (value: any) => any): State;
+                (key: string, updater: (value: any) => any): State;
+                <R>(updater: (value: State) => R): R;
+            };
+            merge: {
+                <KC, VC>(...collections: Iterable<[KC, VC]>[]): Immutable.Map<string | KC, any>;
+                <C>(...collections: {
+                    [key: string]: C;
+                }[]): Immutable.Map<string, any>;
+            };
+            concat: {
+                <KC_1, VC_1>(...collections: Iterable<[KC_1, VC_1]>[]): Immutable.Map<string | KC_1, any>;
+                <C_1>(...collections: {
+                    [key: string]: C_1;
+                }[]): Immutable.Map<string, any>;
+            };
+            mergeWith: (merger: (oldVal: any, newVal: any, key: string) => any, ...collections: (Iterable<[string, any]> | {
+                [key: string]: any;
+            })[]) => State;
+            mergeDeep: (...collections: (Iterable<[string, any]> | {
+                [key: string]: any;
+            })[]) => State;
+            mergeDeepWith: (merger: (oldVal: unknown, newVal: unknown, key: unknown) => unknown, ...collections: (Iterable<[string, any]> | {
+                [key: string]: any;
+            })[]) => State;
+            setIn: (keyPath: Iterable<unknown>, value: unknown) => State;
+            deleteIn: (keyPath: Iterable<unknown>) => State;
+            removeIn: (keyPath: Iterable<unknown>) => State;
+            updateIn: {
+                (keyPath: Iterable<unknown>, notSetValue: unknown, updater: (value: unknown) => unknown): State;
+                (keyPath: Iterable<unknown>, updater: (value: unknown) => unknown): State;
+            };
+            mergeIn: (keyPath: Iterable<unknown>, ...collections: unknown[]) => State;
+            mergeDeepIn: (keyPath: Iterable<unknown>, ...collections: unknown[]) => State;
+            withMutations: (mutator: (mutable: State) => unknown) => State;
+            asMutable: () => State;
+            wasAltered: () => boolean;
+            asImmutable: () => State;
+            map: <M>(mapper: (value: any, key: string, iter: State) => M, context?: unknown) => Immutable.Map<string, M>;
+            mapKeys: <M_1>(mapper: (key: string, value: any, iter: State) => M_1, context?: unknown) => Immutable.Map<M_1, any>;
+            mapEntries: <KM, VM>(mapper: (entry: [string, any], index: number, iter: State) => [KM, VM] | undefined, context?: unknown) => Immutable.Map<KM, VM>;
+            flatMap: <KM_1, VM_1>(mapper: (value: any, key: string, iter: State) => Iterable<[KM_1, VM_1]>, context?: unknown) => Immutable.Map<KM_1, VM_1>;
+            filter: {
+                <F extends any>(predicate: (value: any, key: string, iter: State) => value is F, context?: unknown): Immutable.Map<string, F>;
+                (predicate: (value: any, key: string, iter: State) => unknown, context?: unknown): State;
+            };
+            flip: () => Immutable.Map<any, string>;
+            toJS: () => {
+                [key: string]: unknown;
+            };
+            toJSON: () => {
+                [key: string]: any;
+            };
+            toArray: () => [string, any][];
+            toSeq: () => Immutable.Seq.Keyed<string, any>;
+            [Symbol.iterator]: () => IterableIterator<[string, any]>;
+            equals: (other: unknown) => boolean;
+            hashCode: () => number;
+            get: {
+                <NSV>(key: string, notSetValue: NSV): any;
+                (key: string): any;
+            };
+            has: (key: string) => boolean;
+            includes: (value: any) => boolean;
+            contains: (value: any) => boolean;
+            first: <NSV_1 = undefined>(notSetValue?: NSV_1 | undefined) => any;
+            last: <NSV_2 = undefined>(notSetValue?: NSV_2 | undefined) => any;
+            getIn: (searchKeyPath: Iterable<unknown>, notSetValue?: unknown) => unknown;
+            hasIn: (searchKeyPath: Iterable<unknown>) => boolean;
+            toObject: () => {
+                [key: string]: any;
+            };
+            toMap: () => Immutable.Map<string, any>;
+            toOrderedMap: () => Immutable.OrderedMap<string, any>;
+            toSet: () => Immutable.Set<any>;
+            toOrderedSet: () => Immutable.OrderedSet<any>;
+            toList: () => Immutable.List<any>;
+            toStack: () => Immutable.Stack<any>;
+            toKeyedSeq: () => Immutable.Seq.Keyed<string, any>;
+            toIndexedSeq: () => Immutable.Seq.Indexed<any>;
+            toSetSeq: () => Immutable.Seq.Set<any>;
+            keys: () => IterableIterator<string>;
+            values: () => IterableIterator<any>;
+            entries: () => IterableIterator<[string, any]>;
+            keySeq: () => Immutable.Seq.Indexed<string>;
+            valueSeq: () => Immutable.Seq.Indexed<any>;
+            entrySeq: () => Immutable.Seq.Indexed<[string, any]>;
+            filterNot: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            reverse: () => State;
+            sort: (comparator?: ((valueA: any, valueB: any) => number) | undefined) => State;
+            sortBy: <C_2>(comparatorValueMapper: (value: any, key: string, iter: State) => C_2, comparator?: ((valueA: C_2, valueB: C_2) => number) | undefined) => State;
+            groupBy: <G>(grouper: (value: any, key: string, iter: State) => G, context?: unknown) => Immutable.Seq.Keyed<G, Immutable.Collection<string, any>>;
+            forEach: (sideEffect: (value: any, key: string, iter: State) => unknown, context?: unknown) => number;
+            slice: (begin?: number | undefined, end?: number | undefined) => State;
+            rest: () => State;
+            butLast: () => State;
+            skip: (amount: number) => State;
+            skipLast: (amount: number) => State;
+            skipWhile: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            skipUntil: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            take: (amount: number) => State;
+            takeLast: (amount: number) => State;
+            takeWhile: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            takeUntil: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            flatten: {
+                (depth?: number | undefined): Immutable.Collection<unknown, unknown>;
+                (shallow?: boolean | undefined): Immutable.Collection<unknown, unknown>;
+            };
+            reduce: {
+                <R_1>(reducer: (reduction: R_1, value: any, key: string, iter: State) => R_1, initialReduction: R_1, context?: unknown): R_1;
+                <R_2>(reducer: (reduction: any, value: any, key: string, iter: State) => R_2): R_2;
+            };
+            reduceRight: {
+                <R_3>(reducer: (reduction: R_3, value: any, key: string, iter: State) => R_3, initialReduction: R_3, context?: unknown): R_3;
+                <R_4>(reducer: (reduction: any, value: any, key: string, iter: State) => R_4): R_4;
+            };
+            every: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => boolean;
+            some: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => boolean;
+            join: (separator?: string | undefined) => string;
+            isEmpty: () => boolean;
+            count: {
+                (): number;
+                (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown): number;
+            };
+            countBy: <G_1>(grouper: (value: any, key: string, iter: State) => G_1, context?: unknown) => Immutable.Map<G_1, number>;
+            find: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown, notSetValue?: any) => any;
+            findLast: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown, notSetValue?: any) => any;
+            findEntry: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown, notSetValue?: any) => [string, any] | undefined;
+            findLastEntry: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown, notSetValue?: any) => [string, any] | undefined;
+            findKey: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => string | undefined;
+            findLastKey: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => string | undefined;
+            keyOf: (searchValue: any) => string | undefined;
+            lastKeyOf: (searchValue: any) => string | undefined;
+            max: (comparator?: ((valueA: any, valueB: any) => number) | undefined) => any;
+            maxBy: <C_3>(comparatorValueMapper: (value: any, key: string, iter: State) => C_3, comparator?: ((valueA: C_3, valueB: C_3) => number) | undefined) => any;
+            min: (comparator?: ((valueA: any, valueB: any) => number) | undefined) => any;
+            minBy: <C_4>(comparatorValueMapper: (value: any, key: string, iter: State) => C_4, comparator?: ((valueA: C_4, valueB: C_4) => number) | undefined) => any;
+            isSubset: (iter: Iterable<any>) => boolean;
+            isSuperset: (iter: Iterable<any>) => boolean;
+        }) => boolean) & import("reselect").OutputSelectorFields<(args_0: boolean, args_1: string) => boolean & {
+            clearCache: () => void;
+        }> & {
+            clearCache: () => void;
+        };
+        hasError: ((state: {
+            readonly size: number;
+            set: (key: string, value: any) => State;
+            delete: (key: string) => State;
+            remove: (key: string) => State;
+            deleteAll: (keys: Iterable<string>) => State;
+            removeAll: (keys: Iterable<string>) => State;
+            clear: () => State;
+            update: {
+                (key: string, notSetValue: any, updater: (value: any) => any): State;
+                (key: string, updater: (value: any) => any): State;
+                <R>(updater: (value: State) => R): R;
+            };
+            merge: {
+                <KC, VC>(...collections: Iterable<[KC, VC]>[]): Immutable.Map<string | KC, any>;
+                <C>(...collections: {
+                    [key: string]: C;
+                }[]): Immutable.Map<string, any>;
+            };
+            concat: {
+                <KC_1, VC_1>(...collections: Iterable<[KC_1, VC_1]>[]): Immutable.Map<string | KC_1, any>;
+                <C_1>(...collections: {
+                    [key: string]: C_1;
+                }[]): Immutable.Map<string, any>;
+            };
+            mergeWith: (merger: (oldVal: any, newVal: any, key: string) => any, ...collections: (Iterable<[string, any]> | {
+                [key: string]: any;
+            })[]) => State;
+            mergeDeep: (...collections: (Iterable<[string, any]> | {
+                [key: string]: any;
+            })[]) => State;
+            mergeDeepWith: (merger: (oldVal: unknown, newVal: unknown, key: unknown) => unknown, ...collections: (Iterable<[string, any]> | {
+                [key: string]: any;
+            })[]) => State;
+            setIn: (keyPath: Iterable<unknown>, value: unknown) => State;
+            deleteIn: (keyPath: Iterable<unknown>) => State;
+            removeIn: (keyPath: Iterable<unknown>) => State;
+            updateIn: {
+                (keyPath: Iterable<unknown>, notSetValue: unknown, updater: (value: unknown) => unknown): State;
+                (keyPath: Iterable<unknown>, updater: (value: unknown) => unknown): State;
+            };
+            mergeIn: (keyPath: Iterable<unknown>, ...collections: unknown[]) => State;
+            mergeDeepIn: (keyPath: Iterable<unknown>, ...collections: unknown[]) => State;
+            withMutations: (mutator: (mutable: State) => unknown) => State;
+            asMutable: () => State;
+            wasAltered: () => boolean;
+            asImmutable: () => State;
+            map: <M>(mapper: (value: any, key: string, iter: State) => M, context?: unknown) => Immutable.Map<string, M>;
+            mapKeys: <M_1>(mapper: (key: string, value: any, iter: State) => M_1, context?: unknown) => Immutable.Map<M_1, any>;
+            mapEntries: <KM, VM>(mapper: (entry: [string, any], index: number, iter: State) => [KM, VM] | undefined, context?: unknown) => Immutable.Map<KM, VM>;
+            flatMap: <KM_1, VM_1>(mapper: (value: any, key: string, iter: State) => Iterable<[KM_1, VM_1]>, context?: unknown) => Immutable.Map<KM_1, VM_1>;
+            filter: {
+                <F extends any>(predicate: (value: any, key: string, iter: State) => value is F, context?: unknown): Immutable.Map<string, F>;
+                (predicate: (value: any, key: string, iter: State) => unknown, context?: unknown): State;
+            };
+            flip: () => Immutable.Map<any, string>;
+            toJS: () => {
+                [key: string]: unknown;
+            };
+            toJSON: () => {
+                [key: string]: any;
+            };
+            toArray: () => [string, any][];
+            toSeq: () => Immutable.Seq.Keyed<string, any>;
+            [Symbol.iterator]: () => IterableIterator<[string, any]>;
+            equals: (other: unknown) => boolean;
+            hashCode: () => number;
+            get: {
+                <NSV>(key: string, notSetValue: NSV): any;
+                (key: string): any;
+            };
+            has: (key: string) => boolean;
+            includes: (value: any) => boolean;
+            contains: (value: any) => boolean;
+            first: <NSV_1 = undefined>(notSetValue?: NSV_1 | undefined) => any;
+            last: <NSV_2 = undefined>(notSetValue?: NSV_2 | undefined) => any;
+            getIn: (searchKeyPath: Iterable<unknown>, notSetValue?: unknown) => unknown;
+            hasIn: (searchKeyPath: Iterable<unknown>) => boolean;
+            toObject: () => {
+                [key: string]: any;
+            };
+            toMap: () => Immutable.Map<string, any>;
+            toOrderedMap: () => Immutable.OrderedMap<string, any>;
+            toSet: () => Immutable.Set<any>;
+            toOrderedSet: () => Immutable.OrderedSet<any>;
+            toList: () => Immutable.List<any>;
+            toStack: () => Immutable.Stack<any>;
+            toKeyedSeq: () => Immutable.Seq.Keyed<string, any>;
+            toIndexedSeq: () => Immutable.Seq.Indexed<any>;
+            toSetSeq: () => Immutable.Seq.Set<any>;
+            keys: () => IterableIterator<string>;
+            values: () => IterableIterator<any>;
+            entries: () => IterableIterator<[string, any]>;
+            keySeq: () => Immutable.Seq.Indexed<string>;
+            valueSeq: () => Immutable.Seq.Indexed<any>;
+            entrySeq: () => Immutable.Seq.Indexed<[string, any]>;
+            filterNot: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            reverse: () => State;
+            sort: (comparator?: ((valueA: any, valueB: any) => number) | undefined) => State;
+            sortBy: <C_2>(comparatorValueMapper: (value: any, key: string, iter: State) => C_2, comparator?: ((valueA: C_2, valueB: C_2) => number) | undefined) => State;
+            groupBy: <G>(grouper: (value: any, key: string, iter: State) => G, context?: unknown) => Immutable.Seq.Keyed<G, Immutable.Collection<string, any>>;
+            forEach: (sideEffect: (value: any, key: string, iter: State) => unknown, context?: unknown) => number;
+            slice: (begin?: number | undefined, end?: number | undefined) => State;
+            rest: () => State;
+            butLast: () => State;
+            skip: (amount: number) => State;
+            skipLast: (amount: number) => State;
+            skipWhile: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            skipUntil: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            take: (amount: number) => State;
+            takeLast: (amount: number) => State;
+            takeWhile: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            takeUntil: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => State;
+            flatten: {
+                (depth?: number | undefined): Immutable.Collection<unknown, unknown>;
+                (shallow?: boolean | undefined): Immutable.Collection<unknown, unknown>;
+            };
+            reduce: {
+                <R_1>(reducer: (reduction: R_1, value: any, key: string, iter: State) => R_1, initialReduction: R_1, context?: unknown): R_1;
+                <R_2>(reducer: (reduction: any, value: any, key: string, iter: State) => R_2): R_2;
+            };
+            reduceRight: {
+                <R_3>(reducer: (reduction: R_3, value: any, key: string, iter: State) => R_3, initialReduction: R_3, context?: unknown): R_3;
+                <R_4>(reducer: (reduction: any, value: any, key: string, iter: State) => R_4): R_4;
+            };
+            every: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => boolean;
+            some: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => boolean;
+            join: (separator?: string | undefined) => string;
+            isEmpty: () => boolean;
+            count: {
+                (): number;
+                (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown): number;
+            };
+            countBy: <G_1>(grouper: (value: any, key: string, iter: State) => G_1, context?: unknown) => Immutable.Map<G_1, number>;
+            find: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown, notSetValue?: any) => any;
+            findLast: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown, notSetValue?: any) => any;
+            findEntry: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown, notSetValue?: any) => [string, any] | undefined;
+            findLastEntry: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown, notSetValue?: any) => [string, any] | undefined;
+            findKey: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => string | undefined;
+            findLastKey: (predicate: (value: any, key: string, iter: State) => boolean, context?: unknown) => string | undefined;
+            keyOf: (searchValue: any) => string | undefined;
+            lastKeyOf: (searchValue: any) => string | undefined;
+            max: (comparator?: ((valueA: any, valueB: any) => number) | undefined) => any;
+            maxBy: <C_3>(comparatorValueMapper: (value: any, key: string, iter: State) => C_3, comparator?: ((valueA: C_3, valueB: C_3) => number) | undefined) => any;
+            min: (comparator?: ((valueA: any, valueB: any) => number) | undefined) => any;
+            minBy: <C_4>(comparatorValueMapper: (value: any, key: string, iter: State) => C_4, comparator?: ((valueA: C_4, valueB: C_4) => number) | undefined) => any;
+            isSubset: (iter: Iterable<any>) => boolean;
+            isSuperset: (iter: Iterable<any>) => boolean;
+        }) => boolean) & import("reselect").OutputSelectorFields<(args_0: string) => boolean & {
+            clearCache: () => void;
+        }> & {
+            clearCache: () => void;
+        };
+        getError: (state: State) => string;
+        isFetching: (state: State) => boolean;
+    };
+    actions: {
+        clear: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<`${string}/clear`>;
+    };
+    Load: (props: {
+        readonly children: any;
+    }) => any;
+    reducer: (state: any, action: any) => any;
+};
+export {};

package/Loader/index.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGenericLoader = exports.fulfilled = exports.rejected = exports.pending = exports.initialState = exports.statusReducer = void 0;
+/* eslint-disable import/no-named-as-default-member */
+/* eslint-disable max-len */
+var toolkit_1 = require("@reduxjs/toolkit");
+var immutable_1 = __importDefault(require("immutable"));
+var reselect_1 = require("reselect");
+var utility_1 = require("../utility");
+var CreateLoad_1 = __importDefault(require("./CreateLoad"));
+var pending = function (state) { return (state.mergeIn([exports.statusReducer], immutable_1.default.Map({
+    errorMessage: utility_1.noError,
+    fetched: false,
+    fetching: true,
+}))); }, rejected = function (state) { return (state.mergeDeepIn([exports.statusReducer], immutable_1.default.Map({
+    errorMessage: "Error",
+    fetching: false,
+}))); }, fulfilled = function (state, _a) {
+    var _b;
+    var payload = _a.payload;
+    return (state.mergeDeepIn(immutable_1.default.Map((_b = {
+            data: payload
+        },
+        _b[exports.statusReducer] = immutable_1.default.Map({
+            errorMessage: utility_1.noError,
+            fetching: false,
+            fetched: true,
+        }),
+        _b))));
+}, createGenericLoader = function (_a) {
+    var reducerName = _a.reducerName, url = _a.url, normalizeResult = _a.normalizeResult;
+    var reducer = function (state, action) {
+        var _a;
+        if (state === void 0) { state = exports.initialState; }
+        switch (action.type) {
+            case "".concat(reducerName, "/pending"):
+                return (0, exports.pending)(state);
+            case "".concat(reducerName, "/rejected"):
+                return (0, exports.rejected)(state);
+            case "".concat(reducerName, "/fulfilled"):
+                return state.mergeDeep(immutable_1.default.Map((_a = {},
+                    _a[exports.statusReducer] = immutable_1.default.Map({
+                        fetched: true,
+                        fetching: false,
+                        error: utility_1.noError,
+                    }),
+                    _a["data"] = action.payload,
+                    _a)));
+            case "".concat(reducerName, "/clear"):
+                return exports.initialState;
+            default:
+                return state;
+        }
+    }, isFetching = function (state) { return (state.getIn([reducerName, exports.statusReducer, "fetching"]) || false); }, getFetchedSelector = function (state) { return (state.getIn([reducerName, exports.statusReducer, "fetched"]) || false); }, getError = function (state) { return (state.getIn([reducerName, exports.statusReducer, "errorMessage"]) || utility_1.noError); }, shouldFetch = (0, reselect_1.createSelector)(isFetching, getFetchedSelector, getError, function (isFetchingValue, isFetched, error) { return (!isFetchingValue &&
+        !isFetched &&
+        error === utility_1.noError); }), isFetched = (0, reselect_1.createSelector)(getFetchedSelector, getError, function (isFetchedState, error) { return isFetchedState && error === utility_1.noError; }), hasError = (0, reselect_1.createSelector)(getError, function (error) { return error !== utility_1.noError; }), clearAction = (0, toolkit_1.createAction)("".concat(reducerName, "/clear")), selectors = {
+        shouldFetch: shouldFetch,
+        isFetched: isFetched,
+        hasError: hasError,
+        getError: getError,
+        isFetching: isFetching,
+    };
+    return {
+        stateSelectors: selectors,
+        actions: {
+            clear: clearAction,
+        },
+        Load: (0, CreateLoad_1.default)({
+            url: url,
+            normalizeResult: normalizeResult,
+            selectors: selectors,
+            reducerName: reducerName,
+        }),
+        reducer: reducer,
+    };
+};
+exports.statusReducer = "status", exports.initialState = immutable_1.default.Map((_a = {},
+    _a[exports.statusReducer] = immutable_1.default.Map({
+        errorMessage: utility_1.noError,
+        fetched: false,
+        fetching: false,
+    }),
+    _a)), exports.pending = pending, exports.rejected = rejected, exports.fulfilled = fulfilled, exports.createGenericLoader = createGenericLoader;
+//# sourceMappingURL=index.js.map

package/Loader/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Loader/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "17.3.24",
+  "version": "17.3.26",
   "name": "x25",
   "description": "x25",
   "types": "./dist/index.d.ts",
@@ -106,6 +106,7 @@
     "@docusaurus/react-loadable": "^5.5.2",
     "@reduxjs/toolkit": "^1.8.6",
     "classnames": "^2.3.2",
+    "final-form": "^4.20.9",
     "immutable": "^4.1.0",
     "jest": "^27.5.1",
     "moment": "^2.29.4",

package/utility/index.d.ts

@@ -9,3 +9,6 @@ export * from "./mql";
 export * from "./validation";
 export * from "./words";
 export * from "./hooks";
+export declare const formError: (message: string) => {
+    "FINAL_FORM/form-error": string;
+}, toNumeric: (raw: any) => number;

package/utility/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.toNumeric = exports.formError = void 0;
 __exportStar(require("./calendar"), exports);
 __exportStar(require("./date"), exports);
 __exportStar(require("./normalize"), exports);
@@ -25,4 +26,12 @@ __exportStar(require("./mql"), exports);
 __exportStar(require("./validation"), exports);
 __exportStar(require("./words"), exports);
 __exportStar(require("./hooks"), exports);
+var final_form_1 = require("final-form");
+var formError = function (message) {
+    var _a;
+    return (_a = {},
+        _a[final_form_1.FORM_ERROR] = message,
+        _a);
+}, toNumeric = function (raw) { return Number(String(raw)); };
+exports.formError = formError, exports.toNumeric = toNumeric;
 //# sourceMappingURL=index.js.map

package/utility/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utility/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B;AAC3B,yCAAuB;AACvB,8CAA4B;AAC5B,4CAA0B;AAC1B,4CAA0B;AAC1B,2CAAyB;AACzB,4CAA0B;AAC1B,wCAAsB;AACtB,+CAA6B;AAC7B,0CAAwB;AACxB,0CAAwB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utility/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,6CAA2B;AAC3B,yCAAuB;AACvB,8CAA4B;AAC5B,4CAA0B;AAC1B,4CAA0B;AAC1B,2CAAyB;AACzB,4CAA0B;AAC1B,wCAAsB;AACtB,+CAA6B;AAC7B,0CAAwB;AACxB,0CAAwB;AAExB,yCAAwC;AAEjC,IACL,SAAS,GAAG,UAAC,OAAgB;;IAAK,OAAA;QAChC,GAAC,uBAAU,IAAG,OAAO;WACrB;AAFgC,CAEhC,EACF,SAAS,GAAG,UAAC,GAAS,IAAK,OAAA,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAnB,CAAmB,CAAC;AAH/C,QAAA,SAAS,cAGT,QAAA,SAAS,aAAsC"}

package/UI/style/index.css

@@ -1 +0,0 @@
-.delay-input{position:relative}.delay-input input{padding-right:27px}.delay-input .loading-spinner{position:absolute;right:4px;top:5px;transition:all .2s ease-in-out}.delay-input .clear-value{position:absolute;right:6px;top:11px;transition:all .2s ease-in-out}.digits-3{width:52px !important}.text-fancy,.fancy-text,.fancy-text-sm{-webkit-user-select:none;box-sizing:border-box;color:#b1b2b3;cursor:default;font-family:"Lucida Grande","Segoe UI",Ubuntu,Cantarell,sans-serif;font-weight:bold;list-style-image:none;list-style-position:outside;list-style-type:none;opacity:1;text-align:center}.text-fancy{margin-top:5px;color:gray;font-size:20px;font-weight:500}.fancy-text{font-size:31px;line-height:34px}.fancy-text-sm{font-size:16px;line-height:23.5px}.navbar .nav-toggler{background:#292b2c}.main{padding:20px}.main .page-header{margin-top:0}@media (min-width: 768px){.main{padding-right:40px;padding-left:40px}}.sidework-logo .first-char{color:#ff007b;font-size:32px;font-weight:500}.sidework-logo .color{color:#ff007b}input::-webkit-outer-spin-button,input::-webkit-inner-spin-button{-webkit-appearance:none;margin:0}.no-hover{text-decoration:none !important}.cursor-pointer{cursor:pointer}.no-wrap{white-space:nowrap}.content{margin-bottom:3rem;margin-top:10px;margin-left:10px}.hr-sm{margin-top:.5rem;margin-bottom:.5rem}.text-fancy,.fancy-text,.fancy-text-sm{-webkit-user-select:none;box-sizing:border-box;color:#b1b2b3;cursor:default;font-family:"Lucida Grande","Segoe UI",Ubuntu,Cantarell,sans-serif;font-weight:bold;list-style-image:none;list-style-position:outside;list-style-type:none;opacity:1;text-align:center}.fancy-text{font-size:31px;line-height:34px}.fancy-text-sm{font-size:16px;line-height:23.5px}.invalid-feedback{display:block !important}.truncate{display:inline-block;width:100%;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}@media screen and (min-width: 1201px){.brand-wrapper{width:500px}}@media screen and (min-width: 980px) and (max-width: 1200px){.brand-wrapper{width:350px}}@media screen and (min-width: 850px) and (max-width: 979px){.brand-wrapper{width:200px}}@media screen and (min-width: 798px) and (max-width: 849px){.brand-wrapper{width:100px}}@media screen and (min-width: 765px) and (max-width: 797px){.brand-wrapper{width:200px}}@media screen and (min-width: 580px) and (max-width: 764px){.brand-wrapper{width:400px}}@media screen and (min-width: 401px) and (max-width: 579px){.brand-wrapper{width:240px}}@media screen and (min-width: 350px) and (max-width: 400px){.brand-wrapper{width:230px}}@media screen and (max-width: 349px){.brand-wrapper{width:100px}}@media only screen and (min-device-width: 770px){.search-bar{width:220px !important}}::-webkit-input-placeholder{color:#e0e0e0 !important}::-moz-placeholder{color:#e0e0e0 !important}:-ms-input-placeholder{color:#e0e0e0 !important}:-moz-placeholder{color:#e0e0e0 !important}.collapsible-content-edonec{transition:height 0.2s ease-in-out}.collapsible-card-edonec{transition:0.3s}

package/UI/style/sidebar.css

@@ -1 +0,0 @@
-.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-brand .sidework,.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu ul li a i,.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu .sidebar-dropdown>a::after,.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu .sidebar-dropdown .sidebar-submenu li a::before{-webkit-transition:all 0.3s ease;-moz-transition:all 0.3s ease;-ms-transition:all 0.3s ease;-o-transition:all 0.3s ease;transition:all 0.3s ease}@keyframes swing{0%{transform:rotate(0deg)}10%{transform:rotate(10deg)}30%{transform:rotate(0deg)}40%{transform:rotate(-10deg)}50%{transform:rotate(0deg)}60%{transform:rotate(5deg)}70%{transform:rotate(0deg)}80%{transform:rotate(-5deg)}100%{transform:rotate(0deg)}}@keyframes sonar{0%{transform:scale(0.9);opacity:1}100%{transform:scale(2);opacity:0}}.page-wrapper{height:100vh}.page-wrapper .theme{width:40px;height:40px;display:inline-block;border-radius:4px;margin:2px}.page-wrapper .theme.dark-theme{background:#1e2229}.page-wrapper .sidebar-wrapper{width:240px;height:100%;max-height:100%;position:fixed;top:0;z-index:999}.page-wrapper .sidebar-wrapper .sidebar-footer{position:absolute;width:100%;bottom:0;display:flex}.page-wrapper .sidebar-wrapper .sidebar-footer>a{flex-grow:1;text-align:center;height:30px;line-height:30px;position:relative}.page-wrapper .sidebar-wrapper .sidebar-footer>a .notification{position:absolute;top:0}.page-wrapper .sidebar-wrapper .sidebar-content{max-height:calc(100% - 30px);height:calc(100% - 30px);overflow-y:auto;position:relative;-webkit-transition:all 0.3s ease;-moz-transition:all 0.3s ease;-ms-transition:all 0.3s ease;-o-transition:all 0.3s ease;transition:all 0.3s ease}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-brand{padding:10px 20px;display:flex;align-items:center}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-brand .sidework{text-transform:uppercase;font-weight:bold;flex-grow:1}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-brand #close-sidebar{cursor:pointer;font-size:20px}.page-wrapper .sidebar-wrapper .sidebar-content ul{list-style-type:none;padding:0;margin:0}.page-wrapper .sidebar-wrapper .sidebar-content a{text-decoration:none}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu{padding-bottom:10px}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu ul li a{font-size:15px;font-weight:500;-webkit-transition:all 0.3s ease;-moz-transition:all 0.3s ease;-ms-transition:all 0.3s ease;-o-transition:all 0.3s ease;transition:all 0.3s ease;display:inline-block;width:100%;text-decoration:none;position:relative;padding:8px 30px 8px 20px}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu ul li a span.label,.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu ul li a span.badge{float:right;margin-top:8px;margin-left:5px}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu ul li a i{margin-right:10px;font-size:12px;width:30px;height:30px;line-height:30px;text-align:center;border-radius:4px}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu ul li a:hover>i::before{display:inline-block;animation:swing ease-in-out 0.5s 1 alternate}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu ul li a .badge-sonar{display:inline-block;background:#980303;border-radius:50%;height:8px;width:8px;position:absolute;top:0}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu ul li a .badge-sonar::after{content:"";position:absolute;top:0;left:0;border:2px solid #980303;opacity:0;border-radius:50%;width:100%;height:100%;animation:sonar 1.5s infinite}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu .header-menu span{font-weight:bold;font-size:14px;padding:15px 20px 5px 20px;display:inline-block}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu .sidebar-dropdown{font-weight:500;font-size:15px}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu .sidebar-dropdown>a::after{font-family:"FontAwesome", sans-serif;font-weight:900;content:"\f105";font-style:normal;display:inline-block;font-variant:normal;text-rendering:auto;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;text-align:center;background:0 0;position:absolute;right:15px;top:14px}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu .sidebar-dropdown .sidebar-submenu{display:none}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu .sidebar-dropdown .sidebar-submenu li a .badge,.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu .sidebar-dropdown .sidebar-submenu li a .label{float:right;margin-top:0}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu .sidebar-dropdown .sidebar-submenu ul{padding:5px 0}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu .sidebar-dropdown .sidebar-submenu li{padding-left:25px;font-size:12px}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu .sidebar-dropdown .sidebar-submenu li a::before{content:"\f1db";font-family:"FontAwesome", sans-serif;font-weight:400;font-style:normal;display:inline-block;text-align:center;text-decoration:none;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;margin-right:10px;font-size:10px}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu .sidebar-dropdown .sidebar-submenu li a.active::before{content:"\f111";font-family:"FontAwesome", sans-serif;font-weight:400;font-style:normal;display:inline-block;text-align:center;text-decoration:none;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;margin-right:10px;font-size:10px}.page-wrapper .sidebar-wrapper .sidebar-content .sidebar-menu .sidebar-dropdown.active>a::after{transform:rotate(90deg);right:17px}.sidebar-item-enter{opacity:0.01;height:10px}.sidebar-item-enter.sidebar-item-enter-active{opacity:1;height:100%;transition:all 350ms ease}.sidebar-item-leave{opacity:0;height:0}.sidebar-item-leave.sidebar-item-leave-active{opacity:0.01;height:0;transition:all 200ms ease}::-webkit-scrollbar{width:5px;height:7px}::-webkit-scrollbar-corner{background:transparent}::-webkit-scrollbar-button{width:0;height:0}::-webkit-scrollbar-thumb{background:#c7c7c7;border:0 none #fff;border-radius:10px}::-webkit-scrollbar-thumb:hover,::-webkit-scrollbar-thumb:active{background:#525965}::-webkit-scrollbar-track{background:transparent;border:0 none #fff;border-radius:50px;border-radius:10px}::-webkit-scrollbar-track:hover,::-webkit-scrollbar-track:active{background:transparent}.dark-theme .sidebar-wrapper{background:#31353d}.dark-theme .sidebar-wrapper .sidebar-brand i{color:#b8bfce}.dark-theme .sidebar-wrapper .sidebar-footer{background:#3a3f48;box-shadow:0 -1px 5px #282c33;border-top:1px solid #464a52}.dark-theme .sidebar-wrapper .sidebar-footer a{color:#818896}.dark-theme .sidebar-wrapper .sidebar-footer a i{color:#b8bfce}.dark-theme .sidebar-wrapper .sidebar-menu{border-top:1px solid #3a3f48}.dark-theme .sidebar-wrapper .sidebar-menu ul li a{color:#818896}.dark-theme .sidebar-wrapper .sidebar-menu ul li a i{background:#3a3f48}.dark-theme .sidebar-wrapper .sidebar-menu ul li:hover>a{color:#b8bfce}.dark-theme .sidebar-wrapper .sidebar-menu ul li:hover>a i{color:#16c7ff;text-shadow:0 0 10px rgba(22,199,255,0.5)}.dark-theme .sidebar-wrapper .sidebar-menu .one-page a.active i,.dark-theme .sidebar-wrapper .sidebar-menu .sidebar-dropdown.active a i{color:#16c7ff;text-shadow:0 0 10px rgba(22,199,255,0.5)}.dark-theme .sidebar-wrapper .sidebar-menu .sidebar-dropdown div{background:#3a3f48}.dark-theme .sidebar-wrapper .sidebar-menu .header-menu span{color:#6c7b88}.dark-theme .sidebar-wrapper .sidebar-menu .sidebar-dropdown.active>a{color:#b8bfce}.dark-theme .sidebar-wrapper .sidebar-dropdown .sidebar-submenu li a:hover::before{color:#16c7ff;text-shadow:0 0 10px rgba(22,199,255,0.5)}.dark-theme .sidebar-wrapper .one-page a.active,.dark-theme .sidebar-wrapper .sidebar-dropdown .sidebar-submenu li a.active{color:#bdbdbd}