@uxf/cms 11.74.0 → 11.74.1

package/context/cms-provider.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CmsProvider = CmsProvider;
+const react_1 = __importDefault(require("react"));
+const swr_1 = require("swr");
+const fetcher = (input) => fetch(input).then((res) => res.json());
+function CmsProvider(props) {
+    var _a, _b, _c, _d;
+    const swrConfig = {
+        ...props.swrConfig,
+        provider: (_b = (_a = props.swrConfig) === null || _a === void 0 ? void 0 : _a.provider) !== null && _b !== void 0 ? _b : (() => new Map()),
+        fetcher: (_d = (_c = props.swrConfig) === null || _c === void 0 ? void 0 : _c.fetcher) !== null && _d !== void 0 ? _d : fetcher,
+    };
+    return react_1.default.createElement(swr_1.SWRConfig, { value: swrConfig }, props.children);
+}

package/deprecated/api/api-client.d.ts

@@ -0,0 +1,15 @@
+import { AxiosRequestConfig } from "axios";
+import { NextPageContext } from "next";
+export type ContextType = NextPageContext | null;
+/** @deprecated */
+export default class ApiClient {
+    private client;
+    constructor(basePath?: string, baseUrl?: string);
+    private request;
+    get<RESPONSE = any>(ctx: ContextType, url: string, config?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<RESPONSE, any>>;
+    delete<RESPONSE = any>(ctx: ContextType, url: string, config?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<RESPONSE, any>>;
+    head<RESPONSE = any>(ctx: ContextType, url: string, config?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<RESPONSE, any>>;
+    post<REQUEST extends object = Record<string, any>, RESPONSE = any>(ctx: ContextType, url: string, data: REQUEST, config?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<RESPONSE, any>>;
+    put<REQUEST extends object = Record<string, any>, RESPONSE = any>(ctx: ContextType, url: string, data: REQUEST, config?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<RESPONSE, any>>;
+    patch<REQUEST extends object = Record<string, any>, RESPONSE = any>(ctx: ContextType, url: string, data: REQUEST, config?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<RESPONSE, any>>;
+}

package/deprecated/api/api-client.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const ForbiddenError_1 = require("../../errors/ForbiddenError");
+const NetworkError_1 = require("../../errors/NetworkError");
+const UnauthorizedError_1 = require("../../errors/UnauthorizedError");
+const getClient = (options = {}) => {
+    const client = axios_1.default.create(options);
+    // Add a request interceptor
+    client.interceptors.request.use((requestConfig) => requestConfig, (requestError) => {
+        // eslint-disable-next-line no-console
+        console.error(requestError);
+        return Promise.reject(requestError);
+    });
+    // Add a response interceptor
+    client.interceptors.response.use((response) => response, (error) => {
+        if (error.response && error.response.status >= 500) {
+            // eslint-disable-next-line no-console
+            console.error(error);
+        }
+        return Promise.reject(error);
+    });
+    return client;
+};
+const addCookiesToHeader = (ctx, headers = {}) => {
+    var _a;
+    return ((_a = ctx === null || ctx === void 0 ? void 0 : ctx.req) === null || _a === void 0 ? void 0 : _a.headers.cookie) ? { ...headers, cookie: ctx.req.headers.cookie } : headers;
+};
+const handleError = (error) => {
+    if (error.response) {
+        if (error.response.status === 401) {
+            throw new UnauthorizedError_1.UnauthorizedError();
+        }
+        else if (error.response.status === 403) {
+            throw new ForbiddenError_1.ForbiddenError();
+        }
+        else {
+            throw error;
+        }
+    }
+    else if (error.request) {
+        throw new NetworkError_1.NetworkError();
+    }
+    else {
+        throw error;
+    }
+};
+/** @deprecated */
+class ApiClient {
+    constructor(basePath = "", baseUrl = "") {
+        this.client = getClient({
+            baseURL: `${baseUrl}${basePath}`,
+        });
+    }
+    request(ctx, config) {
+        return this.client
+            .request({
+            ...config,
+            headers: addCookiesToHeader(ctx, config.headers),
+        })
+            .then((response) => Promise.resolve(response))
+            .catch((error) => handleError(error));
+    }
+    get(ctx, url, config = {}) {
+        return this.request(ctx, { ...config, url, method: "GET" });
+    }
+    delete(ctx, url, config = {}) {
+        return this.request(ctx, { ...config, url, method: "DELETE" });
+    }
+    head(ctx, url, config = {}) {
+        return this.request(ctx, { ...config, url, method: "HEAD" });
+    }
+    post(ctx, url, data, config = {}) {
+        return this.request(ctx, { ...config, url, method: "POST", data });
+    }
+    put(ctx, url, data, config = {}) {
+        return this.request(ctx, { ...config, url, method: "PUT", data });
+    }
+    patch(ctx, url, data, config = {}) {
+        return this.request(ctx, { ...config, url, method: "PATCH", data });
+    }
+}
+exports.default = ApiClient;

package/deprecated/hoc/with-authenticate.d.ts

@@ -0,0 +1,6 @@
+import { NextComponentType } from "next";
+import { IAppContext } from "../types/app";
+export interface IConfig {
+    allowedRoles?: string[];
+}
+export declare const withAuthenticate: <PROPS extends object, INITIAL_PROPS extends object>(config: IConfig) => (Component: any) => NextComponentType<IAppContext, INITIAL_PROPS, PROPS>;

package/deprecated/hoc/with-authenticate.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAuthenticate = void 0;
+const react_1 = __importStar(require("react"));
+const api_1 = require("../../api");
+const config_1 = require("../../config");
+const UnauthorizedError_1 = require("../../errors/UnauthorizedError");
+const user_1 = require("../redux/user");
+const cms_authorizator_1 = __importDefault(require("../security/cms-authorizator"));
+// TODO component any
+const withAuthenticate = (config) => (Component) => {
+    var _a;
+    // eslint-disable-next-line import/no-named-as-default-member
+    return (_a = class extends react_1.Component {
+            static async getInitialProps(ctx) {
+                let user = ctx.reduxStore.getState().user.user;
+                if (!user) {
+                    user = config_1.container.has("api.getLoggedUser")
+                        ? await config_1.container.get("api.getLoggedUser")(ctx)
+                        : await (0, api_1.getLoggedUser)(ctx);
+                    ctx.reduxStore.dispatch((0, user_1.onUserPersist)(user));
+                }
+                if (config.allowedRoles && !cms_authorizator_1.default.isGranted(config.allowedRoles, user.roles)) {
+                    throw new UnauthorizedError_1.UnauthorizedError();
+                }
+                return typeof Component.getInitialProps === "function" ? await Component.getInitialProps(ctx) : {};
+            }
+            render() {
+                return react_1.default.createElement(Component, { ...this.props });
+            }
+        },
+        _a.displayName = "withAuthenticateHOC",
+        _a);
+}; // TODO!
+exports.withAuthenticate = withAuthenticate;

package/deprecated/redux/configure-store.d.ts

@@ -0,0 +1,3 @@
+import { Store } from "redux";
+import { IReduxState } from "./types";
+export declare const initializeStore: (initialState?: Partial<IReduxState>) => Store<IReduxState>;

package/deprecated/redux/configure-store.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeStore = void 0;
+const extension_1 = require("@redux-devtools/extension");
+const redux_1 = require("redux");
+const reducer_1 = __importDefault(require("../redux/entities/reducer"));
+const reducer_2 = __importDefault(require("../redux/user/reducer"));
+// TODO: create root reducer to have possibility reset store on logout...
+const initializeStore = (initialState = {}) => (0, redux_1.createStore)((0, redux_1.combineReducers)({
+    entities: reducer_1.default,
+    user: reducer_2.default,
+}), initialState, (0, extension_1.composeWithDevTools)((0, redux_1.applyMiddleware)()));
+exports.initializeStore = initializeStore;

package/deprecated/redux/entities/actions.d.ts

@@ -0,0 +1,30 @@
+import { Schema } from "@uxf/data-grid";
+import { EntityMetaSchema } from "../../../api";
+import { EntityFormSchema } from "../../types/form";
+import { ActionsUnion } from "../redux-helper";
+export interface IState {
+    meta: Record<string, EntityMetaSchema>;
+    form: Record<string, EntityFormSchema>;
+    grid: Record<string, Schema<any>>;
+}
+export declare const onSetEntityMetaSchemas: (meta: Record<string, EntityMetaSchema>) => import("../redux-helper").IPayloadAction<"entities/SET_META_SCHEMAS", Record<string, EntityMetaSchema>>;
+export declare const onSetFormSchema: (entityAlias: string, form: EntityFormSchema) => import("../redux-helper").IPayloadAction<"entities/SET_FORM_SCHEMA", {
+    entityAlias: string;
+    form: EntityFormSchema;
+}>;
+export declare const onSetGridSchema: (entityAlias: string, grid: Schema<any>) => import("../redux-helper").IPayloadAction<"entities/SET_GRID_SCHEMA", {
+    entityAlias: string;
+    grid: Schema<any>;
+}>;
+export declare const Actions: {
+    onSetEntityMetaSchemas: (meta: Record<string, EntityMetaSchema>) => import("../redux-helper").IPayloadAction<"entities/SET_META_SCHEMAS", Record<string, EntityMetaSchema>>;
+    onSetFormSchema: (entityAlias: string, form: EntityFormSchema) => import("../redux-helper").IPayloadAction<"entities/SET_FORM_SCHEMA", {
+        entityAlias: string;
+        form: EntityFormSchema;
+    }>;
+    onSetGridSchema: (entityAlias: string, grid: Schema<any>) => import("../redux-helper").IPayloadAction<"entities/SET_GRID_SCHEMA", {
+        entityAlias: string;
+        grid: Schema<any>;
+    }>;
+};
+export type ActionTypes = ActionsUnion<typeof Actions>;

package/deprecated/redux/entities/actions.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Actions = exports.onSetGridSchema = exports.onSetFormSchema = exports.onSetEntityMetaSchemas = void 0;
+const redux_helper_1 = require("../redux-helper");
+const onSetEntityMetaSchemas = (meta) => (0, redux_helper_1.createAction)("entities/SET_META_SCHEMAS", meta);
+exports.onSetEntityMetaSchemas = onSetEntityMetaSchemas;
+const onSetFormSchema = (entityAlias, form) => (0, redux_helper_1.createAction)("entities/SET_FORM_SCHEMA", { entityAlias, form });
+exports.onSetFormSchema = onSetFormSchema;
+const onSetGridSchema = (entityAlias, grid) => (0, redux_helper_1.createAction)("entities/SET_GRID_SCHEMA", { entityAlias, grid });
+exports.onSetGridSchema = onSetGridSchema;
+exports.Actions = {
+    onSetEntityMetaSchemas: exports.onSetEntityMetaSchemas,
+    onSetFormSchema: exports.onSetFormSchema,
+    onSetGridSchema: exports.onSetGridSchema,
+};

package/deprecated/redux/entities/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./actions";
+export * from "./selectors";

package/deprecated/redux/entities/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./actions"), exports);
+__exportStar(require("./selectors"), exports);

package/deprecated/redux/entities/reducer.d.ts

@@ -0,0 +1,3 @@
+import { ActionTypes, IState } from "./actions";
+declare const entitiesReducer: (state: IState | undefined, action: ActionTypes) => IState;
+export default entitiesReducer;

package/deprecated/redux/entities/reducer.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const initialState = {
+    meta: {},
+    form: {},
+    grid: {},
+};
+const entitiesReducer = (state = initialState, action) => {
+    // tslint:disable-next-line:no-small-switch
+    switch (action.type) {
+        case "entities/SET_META_SCHEMAS":
+            return {
+                ...state,
+                meta: action.payload,
+            };
+        case "entities/SET_FORM_SCHEMA":
+            return {
+                ...state,
+                form: {
+                    ...state.form,
+                    [action.payload.entityAlias]: action.payload.form,
+                },
+            };
+        case "entities/SET_GRID_SCHEMA":
+            return {
+                ...state,
+                grid: {
+                    ...state.grid,
+                    [action.payload.entityAlias]: action.payload.grid,
+                },
+            };
+        default:
+            return state;
+    }
+};
+exports.default = entitiesReducer;

package/deprecated/redux/entities/selectors.d.ts

@@ -0,0 +1,10 @@
+import { Schema } from "@uxf/data-grid";
+import { EntityMetaSchema } from "../../../api";
+import { EntityFormSchema } from "../../types/form";
+import { IReduxState } from "../types";
+export declare const metaSchemaExistsSelector: (state: IReduxState) => boolean;
+export declare const metaSchemaSelector: (entityAlias: string) => (state: IReduxState) => EntityMetaSchema;
+export declare const gridSchemaExistsSelector: (entityAlias: string) => (state: IReduxState) => boolean;
+export declare const gridSchemaSelector: (entityAlias: string) => (state: IReduxState) => Schema<any>;
+export declare const formSchemaExistsSelector: (entityAlias: string) => (state: IReduxState) => boolean;
+export declare const formSchemaSelector: (entityAlias: string) => (state: IReduxState) => EntityFormSchema;

package/deprecated/redux/entities/selectors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formSchemaSelector = exports.formSchemaExistsSelector = exports.gridSchemaSelector = exports.gridSchemaExistsSelector = exports.metaSchemaSelector = exports.metaSchemaExistsSelector = void 0;
+const is_not_nil_1 = require("@uxf/core/utils/is-not-nil");
+const metaSchemaExistsSelector = (state) => Object.keys(state.entities.meta).length > 0;
+exports.metaSchemaExistsSelector = metaSchemaExistsSelector;
+const metaSchemaSelector = (entityAlias) => (state) => state.entities.meta[entityAlias];
+exports.metaSchemaSelector = metaSchemaSelector;
+const gridSchemaExistsSelector = (entityAlias) => (state) => (0, is_not_nil_1.isNotNil)(state.entities.grid[entityAlias]);
+exports.gridSchemaExistsSelector = gridSchemaExistsSelector;
+const gridSchemaSelector = (entityAlias) => (state) => state.entities.grid[entityAlias];
+exports.gridSchemaSelector = gridSchemaSelector;
+const formSchemaExistsSelector = (entityAlias) => (state) => (0, is_not_nil_1.isNotNil)(state.entities.form[entityAlias]);
+exports.formSchemaExistsSelector = formSchemaExistsSelector;
+const formSchemaSelector = (entityAlias) => (state) => state.entities.form[entityAlias];
+exports.formSchemaSelector = formSchemaSelector;

package/deprecated/redux/index.d.ts

@@ -0,0 +1,3 @@
+export { useSelector } from "react-redux";
+export * from "./types";
+export { withReduxStore } from "./with-redux-store";

package/deprecated/redux/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.withReduxStore = exports.useSelector = void 0;
+var react_redux_1 = require("react-redux");
+Object.defineProperty(exports, "useSelector", { enumerable: true, get: function () { return react_redux_1.useSelector; } });
+__exportStar(require("./types"), exports);
+var with_redux_store_1 = require("./with-redux-store");
+Object.defineProperty(exports, "withReduxStore", { enumerable: true, get: function () { return with_redux_store_1.withReduxStore; } });

package/deprecated/redux/redux-helper.d.ts

@@ -0,0 +1,15 @@
+import { Action as ReduxAction } from "redux";
+export interface IAction<T extends string> extends ReduxAction {
+    type: T;
+}
+export interface IPayloadAction<T extends string, P> extends IAction<T> {
+    payload: P;
+}
+export declare function createAction<T extends string>(type: T): IAction<T>;
+export declare function createAction<T extends string, P>(type: T, payload: P): IPayloadAction<T, P>;
+type FunctionType = (...args: any[]) => any;
+interface IActionCreatorsMapObject {
+    [actionCreator: string]: FunctionType;
+}
+export type ActionsUnion<A extends IActionCreatorsMapObject> = ReturnType<A[keyof A]>;
+export {};

package/deprecated/redux/redux-helper.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAction = createAction;
+function createAction(type, payload) {
+    return payload === undefined ? { type } : { type, payload };
+}

package/deprecated/redux/types.d.ts

@@ -0,0 +1,7 @@
+import { ActionTypes as EntitiesActionTypes, IState as IEntitiesState } from "../redux/entities/actions";
+import { IState as IUserState, ActionTypes as UserActionTypes } from "../redux/user/actions";
+export interface IReduxState {
+    entities: IEntitiesState;
+    user: IUserState;
+}
+export type ActionTypes = EntitiesActionTypes | UserActionTypes;

package/deprecated/redux/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/deprecated/redux/user/actions.d.ts

@@ -0,0 +1,19 @@
+import UserResponse from "../../../api";
+import { ActionsUnion } from "../redux-helper";
+export declare const USER_LOGOUT = "user/LOGOUT";
+export declare const USER_PERSIST = "user/PERSIST";
+export declare const onUserPersist: (user: UserResponse) => import("../redux-helper").IPayloadAction<"user/PERSIST", {
+    user: UserResponse;
+}>;
+export declare const onUserLogout: () => import("../redux-helper").IAction<"user/LOGOUT">;
+export interface IState {
+    user?: UserResponse;
+    loginLoading?: boolean;
+}
+export declare const Actions: {
+    onUserPersist: (user: UserResponse) => import("../redux-helper").IPayloadAction<"user/PERSIST", {
+        user: UserResponse;
+    }>;
+    onUserLogout: () => import("../redux-helper").IAction<"user/LOGOUT">;
+};
+export type ActionTypes = ActionsUnion<typeof Actions>;

package/deprecated/redux/user/actions.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Actions = exports.onUserLogout = exports.onUserPersist = exports.USER_PERSIST = exports.USER_LOGOUT = void 0;
+const redux_helper_1 = require("../redux-helper");
+exports.USER_LOGOUT = "user/LOGOUT";
+exports.USER_PERSIST = "user/PERSIST";
+const onUserPersist = (user) => (0, redux_helper_1.createAction)(exports.USER_PERSIST, { user });
+exports.onUserPersist = onUserPersist;
+const onUserLogout = () => (0, redux_helper_1.createAction)(exports.USER_LOGOUT);
+exports.onUserLogout = onUserLogout;
+exports.Actions = {
+    onUserPersist: exports.onUserPersist,
+    onUserLogout: exports.onUserLogout,
+};

package/deprecated/redux/user/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./actions";
+export * from "./selectors";

package/deprecated/redux/user/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./actions"), exports);
+__exportStar(require("./selectors"), exports);

package/deprecated/redux/user/reducer.d.ts

@@ -0,0 +1,3 @@
+import { ActionTypes, IState } from "./actions";
+declare const reducer: (state: IState | undefined, action: ActionTypes) => IState;
+export default reducer;

package/deprecated/redux/user/reducer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const initialState = {};
+const reducer = (state = initialState, action) => {
+    switch (action.type) {
+        case "user/LOGOUT":
+            return {
+                ...state,
+                loginLoading: undefined,
+                user: undefined,
+            };
+        case "user/PERSIST":
+            return {
+                ...state,
+                ...action.payload,
+            };
+        default:
+            return state;
+    }
+};
+exports.default = reducer;

package/deprecated/redux/user/selectors.d.ts

@@ -0,0 +1,3 @@
+import UserResponse from "../../../api";
+import { IReduxState } from "../types";
+export declare const getLoggedUser: (state: IReduxState) => UserResponse | null;

package/deprecated/redux/user/selectors.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLoggedUser = void 0;
+const getLoggedUser = (state) => state.user.user || null;
+exports.getLoggedUser = getLoggedUser;

package/deprecated/redux/with-redux-store.d.ts

@@ -0,0 +1 @@
+export declare const withReduxStore: (App: any) => any;

package/deprecated/redux/with-redux-store.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withReduxStore = void 0;
+const react_1 = __importStar(require("react"));
+const react_redux_1 = require("react-redux");
+const configure_store_1 = require("./configure-store");
+const isServer = typeof window === "undefined";
+const __NEXT_REDUX_STORE__ = "__NEXT_REDUX_STORE__";
+const getOrCreateStore = (initialState = {}) => {
+    // Always make a new store if server, otherwise state is shared between requests
+    if (isServer) {
+        return (0, configure_store_1.initializeStore)(initialState);
+    }
+    // Create store if unavailable on the client and set it on the window object
+    if (!window[__NEXT_REDUX_STORE__]) {
+        window[__NEXT_REDUX_STORE__] = (0, configure_store_1.initializeStore)(initialState);
+    }
+    return window[__NEXT_REDUX_STORE__];
+};
+const withReduxStore = (App) => {
+    return class AppWithRedux extends react_1.Component {
+        static async getInitialProps(appContext) {
+            // Get or Create the store with `undefined` as initialState
+            // This allows you to set a custom default initialState
+            const reduxStore = getOrCreateStore();
+            // Provide the store to getInitialProps of pages
+            appContext.ctx.reduxStore = reduxStore;
+            let appProps = {};
+            if (typeof App.getInitialProps === "function") {
+                appProps = await App.getInitialProps(appContext);
+            }
+            return {
+                ...appProps,
+                initialReduxState: reduxStore.getState(),
+            };
+        }
+        constructor(props) {
+            super(props);
+            this.reduxStore = getOrCreateStore(props.initialReduxState);
+        }
+        render() {
+            return (react_1.default.createElement(react_redux_1.Provider, { store: this.reduxStore },
+                react_1.default.createElement(App, { ...this.props })));
+        }
+    };
+};
+exports.withReduxStore = withReduxStore;

package/deprecated/security/cms-authorizator.d.ts

@@ -0,0 +1,3 @@
+export default class CmsAuthorizator {
+    static isGranted(requiredRoles: string[], userRoles: string[]): boolean;
+}

package/deprecated/security/cms-authorizator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CmsAuthorizator {
+    static isGranted(requiredRoles, userRoles) {
+        return requiredRoles.some((role) => userRoles.includes(role));
+    }
+}
+exports.default = CmsAuthorizator;

package/deprecated/types/app.d.ts

@@ -0,0 +1,6 @@
+import { NextPageContext } from "next";
+import { Store } from "redux";
+import { IReduxState } from "../redux/types";
+export interface IAppContext extends NextPageContext {
+    reduxStore: Store<IReduxState>;
+}

package/deprecated/types/app.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });