@steroidsjs/core 2.2.2 → 2.2.3

package/hooks/useScreen.d.ts

@@ -0,0 +1,2 @@
+import { IScreen } from '../providers/ScreenProvider';
+export default function useScreen(): IScreen;

package/hooks/useScreen.js

@@ -0,0 +1,8 @@
+"use strict";
+exports.__esModule = true;
+var react_1 = require("react");
+var ScreenProvider_1 = require("../providers/ScreenProvider");
+function useScreen() {
+    return react_1.useContext(ScreenProvider_1.ScreenContext);
+}
+exports["default"] = useScreen;

package/hooks/useSelector.d.ts

@@ -0,0 +1 @@
+export default function useSelector<TState = any, TSelected = any>(selector: (state: TState) => TSelected): TSelected;

package/hooks/useSelector.js

@@ -0,0 +1,7 @@
+"use strict";
+exports.__esModule = true;
+var react_redux_1 = require("react-redux");
+function useSelector(selector) {
+    return react_redux_1.useSelector(selector, react_redux_1.shallowEqual);
+}
+exports["default"] = useSelector;

package/hooks/useSsr.d.ts

@@ -0,0 +1,2 @@
+import { ISsr } from '../providers/SsrProvider';
+export default function useSsr(): ISsr;

package/hooks/useSsr.js

@@ -0,0 +1,8 @@
+"use strict";
+exports.__esModule = true;
+var react_1 = require("react");
+var SsrProvider_1 = require("../providers/SsrProvider");
+function useSsr() {
+    return react_1.useContext(SsrProvider_1.SsrProviderContext) || {};
+}
+exports["default"] = useSsr;

package/hooks/useUniqueId.d.ts

@@ -0,0 +1 @@
+export default function useUniqueId(prefix: string): undefined;

package/hooks/useUniqueId.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var react_1 = require("react");
+var uniqueId_1 = __importDefault(require("lodash-es/uniqueId"));
+function useUniqueId(prefix) {
+    var idRef = react_1.useRef();
+    if (!idRef.current) {
+        idRef.current = uniqueId_1["default"](prefix);
+    }
+    return idRef.current;
+}
+exports["default"] = useUniqueId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steroidsjs/core",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "description": "",
   "author": "Vladimir Kozhin <hello@kozhindev.com>",
   "repository": {

package/providers/ComponentsProvider.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import { PropsWithChildren } from 'react';
+declare global {
+    interface Window {
+        SteroidsComponents: IComponents;
+    }
+}
+export interface IComponents {
+    api?: any;
+    clientStorage?: any;
+    html?: any;
+    http?: any;
+    locale?: any;
+    store?: any;
+    ui?: any;
+    resource?: any;
+    ws?: any;
+    pushNotification?: any;
+    meta?: any;
+    [key: string]: any;
+}
+export interface IComponentsProviderProps extends PropsWithChildren<any> {
+    components: IComponents;
+}
+export declare const ComponentsContext: React.Context<IComponents>;
+export default function ComponentsProvider(props: IComponentsProviderProps): JSX.Element;

package/providers/ComponentsProvider.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+exports.__esModule = true;
+exports.ComponentsContext = void 0;
+var React = __importStar(require("react"));
+exports.ComponentsContext = React.createContext({});
+function ComponentsProvider(props) {
+    return (React.createElement(exports.ComponentsContext.Provider, { value: props.components }, props.children));
+}
+exports["default"] = ComponentsProvider;

package/providers/ScreenProvider.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { PropsWithChildren } from 'react';
+export interface IScreen {
+    width: number;
+    media: Record<string, any>;
+    setMedia: any;
+    isPhone: () => boolean;
+    isTablet: () => boolean;
+    isDesktop: () => boolean;
+    getDeviceType: () => string;
+}
+export declare const ScreenContext: React.Context<IScreen>;
+export interface IScreenProviderProps extends PropsWithChildren<any> {
+    media?: Record<string, any>;
+    skipTimeout?: boolean;
+}
+export declare const SCREEN_PHONE = "phone";
+export declare const SCREEN_TABLET = "tablet";
+export declare const SCREEN_DESKTOP = "desktop";
+export default function ScreenProvider(props: IScreenProviderProps): JSX.Element;

package/providers/ScreenProvider.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+exports.__esModule = true;
+exports.SCREEN_DESKTOP = exports.SCREEN_TABLET = exports.SCREEN_PHONE = exports.ScreenContext = void 0;
+var React = __importStar(require("react"));
+var react_1 = require("react");
+var react_use_1 = require("react-use");
+exports.ScreenContext = React.createContext({});
+exports.SCREEN_PHONE = 'phone';
+exports.SCREEN_TABLET = 'tablet';
+exports.SCREEN_DESKTOP = 'desktop';
+function ScreenProvider(props) {
+    var _a;
+    var _b = react_1.useState(!process.env.IS_SSR ? window.innerWidth : 1280), width = _b[0], setWidth = _b[1];
+    var _c = react_1.useState(props.media || (_a = {},
+        _a[exports.SCREEN_PHONE] = 320,
+        _a[exports.SCREEN_TABLET] = 768,
+        _a[exports.SCREEN_DESKTOP] = 1024,
+        _a)), media = _c[0], setMedia = _c[1];
+    var timer = null;
+    var onResize = function () {
+        if (timer) {
+            clearTimeout(timer);
+        }
+        if (props.skipTimeout) {
+            setWidth(window.innerWidth);
+        }
+        else {
+            timer = setTimeout(function () { return setWidth(window.innerWidth); }, 100);
+        }
+    };
+    react_use_1.useMount(function () {
+        window.addEventListener('resize', onResize, false);
+    });
+    react_use_1.useUnmount(function () {
+        window.removeEventListener('resize', onResize);
+    });
+    var getDeviceType = react_1.useCallback(function () {
+        if (width < media[exports.SCREEN_TABLET]) {
+            return exports.SCREEN_PHONE;
+        }
+        if (width < media[exports.SCREEN_DESKTOP]) {
+            return exports.SCREEN_TABLET;
+        }
+        return exports.SCREEN_DESKTOP;
+    }, [width, media]);
+    var isPhone = react_1.useCallback(function () { return getDeviceType() === exports.SCREEN_PHONE; }, [getDeviceType]);
+    var isTablet = react_1.useCallback(function () { return getDeviceType() === exports.SCREEN_TABLET; }, [getDeviceType]);
+    var isDesktop = react_1.useCallback(function () { return getDeviceType() === exports.SCREEN_DESKTOP; }, [getDeviceType]);
+    var value = react_1.useMemo(function () { return ({
+        width: width,
+        media: media,
+        setMedia: setMedia,
+        isPhone: isPhone,
+        isTablet: isTablet,
+        isDesktop: isDesktop,
+        getDeviceType: getDeviceType
+    }); }, [
+        width,
+        media,
+        setMedia,
+        isPhone,
+        isTablet,
+        isDesktop,
+        getDeviceType,
+    ]);
+    return (React.createElement(exports.ScreenContext.Provider, { value: value }, props.children));
+}
+exports["default"] = ScreenProvider;

package/providers/SsrProvider.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { PropsWithChildren } from 'react';
+import { StaticRouterContext } from 'react-router';
+export interface IPreloadedData {
+    [configId: string]: any;
+}
+export interface ISsr {
+    history?: {
+        initialEntries: string[];
+    };
+    staticContext?: StaticRouterContext;
+    preloadedData?: IPreloadedData;
+}
+export declare const SsrProviderContext: React.Context<ISsr>;
+export interface ISsrProviderProps extends ISsr, PropsWithChildren<any> {
+}
+export default function SsrProvider(props: ISsrProviderProps): JSX.Element;

package/providers/SsrProvider.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+exports.__esModule = true;
+exports.SsrProviderContext = void 0;
+var React = __importStar(require("react"));
+exports.SsrProviderContext = React.createContext(null);
+function SsrProvider(props) {
+    return (React.createElement(exports.SsrProviderContext.Provider, { value: {
+            history: props.history,
+            staticContext: props.staticContext,
+            preloadedData: props.preloadedData
+        } }, props.children));
+}
+exports["default"] = SsrProvider;

package/providers/index.d.ts

@@ -0,0 +1,4 @@
+import SsrProvider from '@steroidsjs/core/providers/SsrProvider';
+import ScreenProvider from '@steroidsjs/core/providers/ScreenProvider';
+import ComponentsProvider from '@steroidsjs/core/providers/ComponentsProvider';
+export { SsrProvider, ScreenProvider, ComponentsProvider };

package/providers/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.ComponentsProvider = exports.ScreenProvider = exports.SsrProvider = void 0;
+var SsrProvider_1 = __importDefault(require("@steroidsjs/core/providers/SsrProvider"));
+exports.SsrProvider = SsrProvider_1["default"];
+var ScreenProvider_1 = __importDefault(require("@steroidsjs/core/providers/ScreenProvider"));
+exports.ScreenProvider = ScreenProvider_1["default"];
+var ComponentsProvider_1 = __importDefault(require("@steroidsjs/core/providers/ComponentsProvider"));
+exports.ComponentsProvider = ComponentsProvider_1["default"];

package/reducers/auth.d.ts

@@ -0,0 +1,21 @@
+declare const _default: (state: {
+    isInitialized: boolean;
+    initializeCounter: number;
+    redirectPageId: any;
+    user: any;
+    data: any;
+}, action: any) => {
+    isInitialized: boolean;
+    initializeCounter: number;
+    redirectPageId: any;
+    user: any;
+    data: any;
+};
+export default _default;
+export declare const isInitialized: (state: any) => any;
+export declare const getInitializeCounter: (state: any) => any;
+export declare const isAuthorized: (state: any) => boolean;
+export declare const getUser: (state: any) => any;
+export declare const getUserId: (state: any) => any;
+export declare const getUserRole: (state: any) => any;
+export declare const getData: (state: any) => any;

package/reducers/auth.js

@@ -0,0 +1,61 @@
+"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 __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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.getData = exports.getUserRole = exports.getUserId = exports.getUser = exports.isAuthorized = exports.getInitializeCounter = exports.isInitialized = void 0;
+var merge_1 = __importDefault(require("lodash-es/merge"));
+var auth_1 = require("../actions/auth");
+var initialState = {
+    isInitialized: false,
+    initializeCounter: 0,
+    redirectPageId: null,
+    user: null,
+    data: null
+};
+exports["default"] = (function (state, action) {
+    var _a;
+    if (state === void 0) { state = initialState; }
+    switch (action.type) {
+        case auth_1.AUTH_INIT:
+            return __assign(__assign({}, state), { initializeCounter: state.initializeCounter + 1, redirectPageId: action.redirectPageId || null });
+        case auth_1.AUTH_INIT_USER:
+            return __assign(__assign({}, state), { isInitialized: true, user: action.user });
+        case auth_1.AUTH_SET_DATA:
+            return __assign(__assign({}, state), { data: merge_1["default"]({}, state.data, action.data) });
+        case auth_1.AUTH_ADD_SOCIAL:
+            return __assign(__assign({}, state), { user: __assign(__assign({}, state.user), { socials: __spreadArray(__spreadArray([], (((_a = state.user) === null || _a === void 0 ? void 0 : _a.socials) || [])), (action.social || [])) }) });
+        default:
+            return state;
+    }
+});
+var isInitialized = function (state) { return state.auth.isInitialized; };
+exports.isInitialized = isInitialized;
+var getInitializeCounter = function (state) { return state.auth.initializeCounter; };
+exports.getInitializeCounter = getInitializeCounter;
+var isAuthorized = function (state) { return !!state.auth.user; };
+exports.isAuthorized = isAuthorized;
+var getUser = function (state) { return state.auth.user; };
+exports.getUser = getUser;
+var getUserId = function (state) { return (state.auth.user && state.auth.user.id) || null; };
+exports.getUserId = getUserId;
+var getUserRole = function (state) { return (state.auth.user && state.auth.user.role) || null; };
+exports.getUserRole = getUserRole;
+var getData = function (state) { return state.auth.data; };
+exports.getData = getData;

package/reducers/fields.d.ts

@@ -0,0 +1,11 @@
+declare const _default: (state: {
+    props: {};
+    meta: any;
+}, action: any) => {
+    props: {};
+    meta: any;
+};
+export default _default;
+export declare const isMetaFetched: (state: any) => boolean;
+export declare const getEnumLabels: (state: any, name: any) => any;
+export declare const getModel: (state: any, name: any) => any;

package/reducers/fields.js

@@ -0,0 +1,55 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.getModel = exports.getEnumLabels = exports.isMetaFetched = void 0;
+var isString_1 = __importDefault(require("lodash-es/isString"));
+var get_1 = __importDefault(require("lodash-es/get"));
+var fields_1 = require("../actions/fields");
+var initialState = {
+    props: {},
+    meta: null
+};
+var normalizeName = function (name) { return name.replace(/\\/g, '.').replace(/^\./, ''); };
+exports["default"] = (function (state, action) {
+    if (state === void 0) { state = initialState; }
+    switch (action.type) {
+        case fields_1.FIELDS_SET_META:
+            Object.keys(action.meta).forEach(function (name) {
+                action.meta[name].className = name;
+            });
+            return __assign(__assign({}, state), { meta: __assign(__assign({}, state.meta), action.meta) });
+        default:
+            return state;
+    }
+});
+var isMetaFetched = function (state) { return get_1["default"](state, ['fields', 'meta']) !== null; };
+exports.isMetaFetched = isMetaFetched;
+var getEnumLabels = function (state, name) { return get_1["default"](state, ['fields', 'meta', name, 'labels']) || null; };
+exports.getEnumLabels = getEnumLabels;
+var warnings = {};
+var getModel = function (state, name) {
+    if (isString_1["default"](name)) {
+        name = normalizeName(name);
+        var meta = get_1["default"](state, ['fields', 'meta', name]) || null;
+        if (!meta && exports.isMetaFetched(state) && !warnings[name]) {
+            warnings[name] = true;
+            console.warn('Steroids: Not found model meta:', name); // eslint-disable-line no-console
+        }
+        return meta;
+    }
+    return name || null;
+};
+exports.getModel = getModel;

package/reducers/form.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Редьюрес для одной формы. Используется как для Redux, так и для React Reducer
+ * @param state
+ * @param action
+ */
+export declare function reducerItem(state: any, action: any): any;
+declare const _default: (state: {}, action: any) => any;
+export default _default;
+export declare const formSelector: (state: any, formId: any, selector: any) => any;
+export declare const getFormValues: (state: any, formId: any) => any;

package/reducers/form.js

@@ -0,0 +1,79 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.getFormValues = exports.formSelector = exports.reducerItem = void 0;
+var get_1 = __importDefault(require("lodash-es/get"));
+var isEqual_1 = __importDefault(require("lodash-es/isEqual"));
+var cloneDeep_1 = __importDefault(require("lodash-es/cloneDeep"));
+var isObject_1 = __importDefault(require("lodash-es/isObject"));
+var dot_prop_immutable_1 = require("dot-prop-immutable");
+var form_1 = require("../actions/form");
+/**
+ * Редьюрес для одной формы. Используется как для Redux, так и для React Reducer
+ * @param state
+ * @param action
+ */
+function reducerItem(state, action) {
+    if (!state && action.type !== form_1.FORM_INITIALIZE) {
+        state = reducerItem(state, {
+            type: form_1.FORM_INITIALIZE,
+            formId: action.formId
+        });
+    }
+    switch (action.type) {
+        case form_1.FORM_INITIALIZE:
+            return __assign(__assign({ errors: {}, isInvalid: false, isSubmitting: false }, state), { values: (state === null || state === void 0 ? void 0 : state.values) || cloneDeep_1["default"](action.values || {}), initialValues: action.values || (state === null || state === void 0 ? void 0 : state.values) || null });
+        case form_1.FORM_CHANGE:
+            if (isObject_1["default"](action.nameOrObject)) {
+                var newValues = __assign(__assign({}, state.values), action.nameOrObject);
+                if (!isEqual_1["default"](state.values, newValues)) {
+                    return __assign(__assign({}, state), { values: __assign(__assign({}, state.values), action.nameOrObject) });
+                }
+                return state;
+            }
+            return dot_prop_immutable_1.set(state, 'values.' + action.nameOrObject, action.value);
+        case form_1.FORM_SET_ERRORS:
+            return dot_prop_immutable_1.set(state, 'errors', action.errors);
+        case form_1.FORM_SUBMIT:
+            return dot_prop_immutable_1.set(state, 'submitCounter', (state.submitCounter || 0) + 1);
+        case form_1.FORM_RESET:
+            return dot_prop_immutable_1.set(state, 'values', cloneDeep_1["default"](state.initialValues || {}));
+        case form_1.FORM_ARRAY_ADD:
+            // eslint-disable-next-line no-case-declarations
+            var newValue = [].concat(get_1["default"](state, 'values.' + action.name) || []);
+            for (var i = 0; i < action.rowsCount; i += 1) {
+                newValue.push(cloneDeep_1["default"](action.initialValues || {}));
+            }
+            return dot_prop_immutable_1.set(state, 'values.' + action.name, newValue);
+        case form_1.FORM_ARRAY_REMOVE:
+            return dot_prop_immutable_1["delete"](state, 'values.' + action.name + '.' + action.index);
+        default:
+            return state;
+    }
+}
+exports.reducerItem = reducerItem;
+var initialState = {};
+exports["default"] = (function (state, action) {
+    if (state === void 0) { state = initialState; }
+    if (action.formId) {
+        return dot_prop_immutable_1.set(state, action.formId, reducerItem(state[action.formId], action));
+    }
+    return state;
+});
+var formSelector = function (state, formId, selector) { var _a; return selector(((_a = state.form) === null || _a === void 0 ? void 0 : _a[formId]) || {}); };
+exports.formSelector = formSelector;
+var getFormValues = function (state, formId) { var _a, _b; return ((_b = (_a = state.form) === null || _a === void 0 ? void 0 : _a[formId]) === null || _b === void 0 ? void 0 : _b.values) || null; };
+exports.getFormValues = getFormValues;

package/reducers/index.d.ts

@@ -0,0 +1,13 @@
+import auth from './auth';
+import fields from './fields';
+import form from './form';
+import list from './list';
+import notifications from './notifications';
+import modal from './modal';
+import router from './router';
+import screen from './screen';
+export { form, auth, fields, list, notifications, modal, router, screen, };
+declare const _default: (asyncReducers: any) => import("redux").Reducer<import("redux").CombinedState<{
+    [x: string]: unknown;
+}>, never>;
+export default _default;

package/reducers/index.js

@@ -0,0 +1,41 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.screen = exports.router = exports.modal = exports.notifications = exports.list = exports.fields = exports.auth = exports.form = void 0;
+var redux_1 = require("redux");
+var auth_1 = __importDefault(require("./auth"));
+exports.auth = auth_1["default"];
+var fields_1 = __importDefault(require("./fields"));
+exports.fields = fields_1["default"];
+var form_1 = __importDefault(require("./form"));
+exports.form = form_1["default"];
+var list_1 = __importDefault(require("./list"));
+exports.list = list_1["default"];
+var notifications_1 = __importDefault(require("./notifications"));
+exports.notifications = notifications_1["default"];
+var modal_1 = __importDefault(require("./modal"));
+exports.modal = modal_1["default"];
+var router_1 = __importDefault(require("./router"));
+exports.router = router_1["default"];
+var screen_1 = __importDefault(require("./screen"));
+exports.screen = screen_1["default"];
+exports["default"] = (function (asyncReducers) { return redux_1.combineReducers(__assign(__assign({ form: form_1["default"],
+    auth: auth_1["default"],
+    fields: fields_1["default"],
+    list: list_1["default"],
+    notifications: notifications_1["default"],
+    modal: modal_1["default"],
+    screen: screen_1["default"] }, asyncReducers), { router: function (state, action) { return router_1["default"](asyncReducers.router ? asyncReducers.router(state, action) : {}, action); } })); });

package/reducers/list.d.ts

@@ -0,0 +1,12 @@
+declare const _default: (state: {
+    lists: {};
+    selectedIds: {};
+}, action: any) => any;
+export default _default;
+export declare const isListInitialized: (state: any, listId: any) => boolean;
+export declare const getList: (state: any, listId: any) => any;
+export declare const getIds: (state: any, listId: any) => any;
+export declare const getListItems: (state: any, listId: any) => any;
+export declare const getCheckedIds: (state: any, listId: any) => any;
+export declare const isChecked: (state: any, listId: any, itemId: any) => any;
+export declare const isCheckedAll: (state: any, listId: any) => any;