@open-tender/cloud 0.4.26 → 0.4.28

package/dist/esm/slices/orderFulfillment.d.ts

@@ -1,37 +1,37 @@
-import { AppState } from '../app';
-import { OrderFulfillment, RequestError, RequestStatus } from '@open-tender/types';
-export interface OrderFulfillmentState {
-    orderFulfillment: OrderFulfillment | null;
-    error: RequestError;
-    loading: RequestStatus;
-}
-export declare enum OrderFulfillmentActionType {
-    FetchOrderFulfillment = "orderFulfillment/fetchOrderFulfillment",
-    UpdateOrderFulfillment = "orderFulfillment/updateOrderFulfillment"
-}
-export declare const fetchOrderFulfillment: import("@reduxjs/toolkit").AsyncThunk<OrderFulfillment, number, {
-    state: AppState;
-    rejectValue: RequestError;
-    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
-    extra?: unknown;
-    serializedErrorType?: unknown;
-    pendingMeta?: unknown;
-    fulfilledMeta?: unknown;
-    rejectedMeta?: unknown;
-}>;
-export declare const updateOrderFulfillment: import("@reduxjs/toolkit").AsyncThunk<OrderFulfillment, {
-    orderId: number;
-    data: OrderFulfillment;
-}, {
-    state: AppState;
-    rejectValue: RequestError;
-    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
-    extra?: unknown;
-    serializedErrorType?: unknown;
-    pendingMeta?: unknown;
-    fulfilledMeta?: unknown;
-    rejectedMeta?: unknown;
-}>;
-export declare const resetOrderFulfillment: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"orderFulfillment/resetOrderFulfillment">;
-export declare const selectOrderFulfillment: (state: AppState) => OrderFulfillmentState;
-export declare const orderFulfillmentReducer: import("redux").Reducer<OrderFulfillmentState, import("redux").AnyAction>;
+import { AppState } from '../app';
+import { OrderFulfillment, RequestError, RequestStatus } from '@open-tender/types';
+export interface OrderFulfillmentState {
+    orderFulfillment: OrderFulfillment | null;
+    error: RequestError;
+    loading: RequestStatus;
+}
+export declare enum OrderFulfillmentActionType {
+    FetchOrderFulfillment = "orderFulfillment/fetchOrderFulfillment",
+    UpdateOrderFulfillment = "orderFulfillment/updateOrderFulfillment"
+}
+export declare const fetchOrderFulfillment: import("@reduxjs/toolkit").AsyncThunk<OrderFulfillment, number, {
+    state: AppState;
+    rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const updateOrderFulfillment: import("@reduxjs/toolkit").AsyncThunk<OrderFulfillment, {
+    orderId: number;
+    data: OrderFulfillment;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const resetOrderFulfillment: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"orderFulfillment/resetOrderFulfillment">;
+export declare const selectOrderFulfillment: (state: AppState) => OrderFulfillmentState;
+export declare const orderFulfillmentReducer: import("redux").Reducer<OrderFulfillmentState, import("redux").AnyAction>;

package/dist/esm/slices/orderFulfillment.js

@@ -1,73 +1,73 @@
-import { __awaiter } from "tslib";
-import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
-import { ReducerType } from './types';
-const initialState = {
-    orderFulfillment: null,
-    loading: 'idle',
-    error: null
-};
-export var OrderFulfillmentActionType;
-(function (OrderFulfillmentActionType) {
-    OrderFulfillmentActionType["FetchOrderFulfillment"] = "orderFulfillment/fetchOrderFulfillment";
-    OrderFulfillmentActionType["UpdateOrderFulfillment"] = "orderFulfillment/updateOrderFulfillment";
-})(OrderFulfillmentActionType || (OrderFulfillmentActionType = {}));
-export const fetchOrderFulfillment = createAsyncThunk(OrderFulfillmentActionType.FetchOrderFulfillment, (orderId, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
-    const { api } = getState().config;
-    if (!api)
-        return;
-    try {
-        const response = yield api.getOrderFulfillment(orderId);
-        return response;
-    }
-    catch (err) {
-        return rejectWithValue(err);
-    }
-}));
-export const updateOrderFulfillment = createAsyncThunk(OrderFulfillmentActionType.UpdateOrderFulfillment, ({ orderId, data }, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
-    const { api } = getState().config;
-    if (!api)
-        return;
-    try {
-        return yield api.putOrderFulfillment(orderId, data);
-    }
-    catch (err) {
-        return rejectWithValue(err);
-    }
-}));
-const orderFulfillmentSlice = createSlice({
-    name: ReducerType.OrderFulfillment,
-    initialState,
-    reducers: {
-        resetOrderFulfillment: () => initialState
-    },
-    extraReducers: builder => {
-        builder
-            .addCase(fetchOrderFulfillment.fulfilled, (state, action) => {
-            state.orderFulfillment = action.payload;
-            state.loading = 'idle';
-            state.error = null;
-        })
-            .addCase(fetchOrderFulfillment.pending, state => {
-            state.loading = 'pending';
-        })
-            .addCase(fetchOrderFulfillment.rejected, (state, action) => {
-            state.error = action.payload;
-            state.loading = 'idle';
-        })
-            .addCase(updateOrderFulfillment.fulfilled, (state, action) => {
-            state.orderFulfillment = action.payload;
-            state.loading = 'idle';
-            state.error = null;
-        })
-            .addCase(updateOrderFulfillment.pending, state => {
-            state.loading = 'pending';
-        })
-            .addCase(updateOrderFulfillment.rejected, (state, action) => {
-            state.error = action.payload;
-            state.loading = 'idle';
-        });
-    }
-});
-export const { resetOrderFulfillment } = orderFulfillmentSlice.actions;
-export const selectOrderFulfillment = (state) => state.orderFulfillment;
-export const orderFulfillmentReducer = orderFulfillmentSlice.reducer;
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+const initialState = {
+    orderFulfillment: null,
+    loading: 'idle',
+    error: null
+};
+export var OrderFulfillmentActionType;
+(function (OrderFulfillmentActionType) {
+    OrderFulfillmentActionType["FetchOrderFulfillment"] = "orderFulfillment/fetchOrderFulfillment";
+    OrderFulfillmentActionType["UpdateOrderFulfillment"] = "orderFulfillment/updateOrderFulfillment";
+})(OrderFulfillmentActionType || (OrderFulfillmentActionType = {}));
+export const fetchOrderFulfillment = createAsyncThunk(OrderFulfillmentActionType.FetchOrderFulfillment, (orderId, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const response = yield api.getOrderFulfillment(orderId);
+        return response;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+export const updateOrderFulfillment = createAsyncThunk(OrderFulfillmentActionType.UpdateOrderFulfillment, ({ orderId, data }, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        return yield api.putOrderFulfillment(orderId, data);
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const orderFulfillmentSlice = createSlice({
+    name: ReducerType.OrderFulfillment,
+    initialState,
+    reducers: {
+        resetOrderFulfillment: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchOrderFulfillment.fulfilled, (state, action) => {
+            state.orderFulfillment = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchOrderFulfillment.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchOrderFulfillment.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(updateOrderFulfillment.fulfilled, (state, action) => {
+            state.orderFulfillment = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(updateOrderFulfillment.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateOrderFulfillment.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetOrderFulfillment } = orderFulfillmentSlice.actions;
+export const selectOrderFulfillment = (state) => state.orderFulfillment;
+export const orderFulfillmentReducer = orderFulfillmentSlice.reducer;

package/dist/esm/slices/orderRating.d.ts

@@ -1,52 +1,52 @@
-import { AppState } from '../app';
-import { OrderRating, OrderRatingWithOrder, RequestError, RequestStatus } from '@open-tender/types';
-export interface OrderRatingState {
-    orderRating: OrderRatingWithOrder | null;
-    error: RequestError;
-    loading: RequestStatus;
-}
-export declare enum OrderRatingActionType {
-    FetchOrderRating = "orderRating/fetchOrderRating",
-    UpdateOrderRating = "orderRating/updateOrderRating",
-    UnsubscribeOrderRating = "orderRating/unsubscribeOrderRating"
-}
-export declare const fetchOrderRating: import("@reduxjs/toolkit").AsyncThunk<OrderRatingWithOrder, string, {
-    state: AppState;
-    rejectValue: RequestError;
-    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
-    extra?: unknown;
-    serializedErrorType?: unknown;
-    pendingMeta?: unknown;
-    fulfilledMeta?: unknown;
-    rejectedMeta?: unknown;
-}>;
-export declare const updateOrderRating: import("@reduxjs/toolkit").AsyncThunk<OrderRatingWithOrder, {
-    orderUuid: string;
-    data: OrderRating;
-}, {
-    state: AppState;
-    rejectValue: RequestError;
-    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
-    extra?: unknown;
-    serializedErrorType?: unknown;
-    pendingMeta?: unknown;
-    fulfilledMeta?: unknown;
-    rejectedMeta?: unknown;
-}>;
-export declare const unsubscribeOrderRating: import("@reduxjs/toolkit").AsyncThunk<void, string, {
-    state: AppState;
-    rejectValue: RequestError;
-    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
-    extra?: unknown;
-    serializedErrorType?: unknown;
-    pendingMeta?: unknown;
-    fulfilledMeta?: unknown;
-    rejectedMeta?: unknown;
-}>;
-export declare const resetOrderRating: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"orderRating/resetOrderRating">;
-export declare const selectOrderRating: (state: AppState) => {
-    orderRating: OrderRatingWithOrder | null;
-    loading: RequestStatus;
-    error: RequestError;
-};
-export declare const orderRatingReducer: import("redux").Reducer<OrderRatingState, import("redux").AnyAction>;
+import { AppState } from '../app';
+import { OrderRating, OrderRatingWithOrder, RequestError, RequestStatus } from '@open-tender/types';
+export interface OrderRatingState {
+    orderRating: OrderRatingWithOrder | null;
+    error: RequestError;
+    loading: RequestStatus;
+}
+export declare enum OrderRatingActionType {
+    FetchOrderRating = "orderRating/fetchOrderRating",
+    UpdateOrderRating = "orderRating/updateOrderRating",
+    UnsubscribeOrderRating = "orderRating/unsubscribeOrderRating"
+}
+export declare const fetchOrderRating: import("@reduxjs/toolkit").AsyncThunk<OrderRatingWithOrder, string, {
+    state: AppState;
+    rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const updateOrderRating: import("@reduxjs/toolkit").AsyncThunk<OrderRatingWithOrder, {
+    orderUuid: string;
+    data: OrderRating;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const unsubscribeOrderRating: import("@reduxjs/toolkit").AsyncThunk<void, string, {
+    state: AppState;
+    rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const resetOrderRating: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"orderRating/resetOrderRating">;
+export declare const selectOrderRating: (state: AppState) => {
+    orderRating: OrderRatingWithOrder | null;
+    loading: RequestStatus;
+    error: RequestError;
+};
+export declare const orderRatingReducer: import("redux").Reducer<OrderRatingState, import("redux").AnyAction>;

package/dist/esm/slices/orderRating.js

@@ -1,101 +1,101 @@
-import { __awaiter } from "tslib";
-import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
-import { ReducerType } from './types';
-const initialState = {
-    orderRating: null,
-    loading: 'idle',
-    error: null
-};
-export var OrderRatingActionType;
-(function (OrderRatingActionType) {
-    OrderRatingActionType["FetchOrderRating"] = "orderRating/fetchOrderRating";
-    OrderRatingActionType["UpdateOrderRating"] = "orderRating/updateOrderRating";
-    OrderRatingActionType["UnsubscribeOrderRating"] = "orderRating/unsubscribeOrderRating";
-})(OrderRatingActionType || (OrderRatingActionType = {}));
-export const fetchOrderRating = createAsyncThunk(OrderRatingActionType.FetchOrderRating, (orderUuid, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
-    const { api } = getState().config;
-    if (!api)
-        return;
-    try {
-        return yield api.getOrderRating(orderUuid);
-    }
-    catch (err) {
-        return rejectWithValue(err);
-    }
-}));
-export const updateOrderRating = createAsyncThunk(OrderRatingActionType.UpdateOrderRating, ({ orderUuid, data }, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
-    const { api } = getState().config;
-    if (!api)
-        return;
-    try {
-        const response = yield api.putOrderRating(orderUuid, data);
-        return response;
-    }
-    catch (err) {
-        return rejectWithValue(err);
-    }
-}));
-export const unsubscribeOrderRating = createAsyncThunk(OrderRatingActionType.UnsubscribeOrderRating, (orderUuid, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
-    const { api } = getState().config;
-    if (!api)
-        return;
-    try {
-        yield api.postOrderRatingUnsubscribe(orderUuid);
-        return;
-    }
-    catch (err) {
-        return rejectWithValue(err);
-    }
-}));
-const orderRatingSlice = createSlice({
-    name: ReducerType.OrderRating,
-    initialState,
-    reducers: {
-        resetOrderRating: () => initialState
-    },
-    extraReducers: builder => {
-        builder
-            .addCase(fetchOrderRating.fulfilled, (state, action) => {
-            state.orderRating = action.payload;
-            state.loading = 'idle';
-            state.error = null;
-        })
-            .addCase(fetchOrderRating.pending, state => {
-            state.loading = 'pending';
-        })
-            .addCase(fetchOrderRating.rejected, (state, action) => {
-            state.error = action.payload;
-            state.loading = 'idle';
-        })
-            .addCase(updateOrderRating.fulfilled, (state, action) => {
-            state.orderRating = action.payload;
-            state.loading = 'idle';
-            state.error = null;
-        })
-            .addCase(updateOrderRating.pending, state => {
-            state.loading = 'pending';
-        })
-            .addCase(updateOrderRating.rejected, (state, action) => {
-            state.error = action.payload;
-            state.loading = 'idle';
-        })
-            .addCase(unsubscribeOrderRating.fulfilled, state => {
-            state.orderRating = null;
-            state.loading = 'idle';
-            state.error = null;
-        })
-            .addCase(unsubscribeOrderRating.pending, state => {
-            state.loading = 'pending';
-        })
-            .addCase(unsubscribeOrderRating.rejected, (state, action) => {
-            state.error = action.payload;
-            state.loading = 'idle';
-        });
-    }
-});
-export const { resetOrderRating } = orderRatingSlice.actions;
-export const selectOrderRating = (state) => {
-    const { orderRating, loading, error } = state.orderRating;
-    return { orderRating, loading, error };
-};
-export const orderRatingReducer = orderRatingSlice.reducer;
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+const initialState = {
+    orderRating: null,
+    loading: 'idle',
+    error: null
+};
+export var OrderRatingActionType;
+(function (OrderRatingActionType) {
+    OrderRatingActionType["FetchOrderRating"] = "orderRating/fetchOrderRating";
+    OrderRatingActionType["UpdateOrderRating"] = "orderRating/updateOrderRating";
+    OrderRatingActionType["UnsubscribeOrderRating"] = "orderRating/unsubscribeOrderRating";
+})(OrderRatingActionType || (OrderRatingActionType = {}));
+export const fetchOrderRating = createAsyncThunk(OrderRatingActionType.FetchOrderRating, (orderUuid, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        return yield api.getOrderRating(orderUuid);
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+export const updateOrderRating = createAsyncThunk(OrderRatingActionType.UpdateOrderRating, ({ orderUuid, data }, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const response = yield api.putOrderRating(orderUuid, data);
+        return response;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+export const unsubscribeOrderRating = createAsyncThunk(OrderRatingActionType.UnsubscribeOrderRating, (orderUuid, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        yield api.postOrderRatingUnsubscribe(orderUuid);
+        return;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const orderRatingSlice = createSlice({
+    name: ReducerType.OrderRating,
+    initialState,
+    reducers: {
+        resetOrderRating: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchOrderRating.fulfilled, (state, action) => {
+            state.orderRating = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchOrderRating.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchOrderRating.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(updateOrderRating.fulfilled, (state, action) => {
+            state.orderRating = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(updateOrderRating.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateOrderRating.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(unsubscribeOrderRating.fulfilled, state => {
+            state.orderRating = null;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(unsubscribeOrderRating.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(unsubscribeOrderRating.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetOrderRating } = orderRatingSlice.actions;
+export const selectOrderRating = (state) => {
+    const { orderRating, loading, error } = state.orderRating;
+    return { orderRating, loading, error };
+};
+export const orderRatingReducer = orderRatingSlice.reducer;

package/dist/esm/slices/posts.d.ts

@@ -1,24 +1,24 @@
-import { RequestError, RequestStatus } from '@open-tender/types';
-import { AppState } from '../app';
-export interface PostsSlice {
-    posts: any[];
-    loading: RequestStatus;
-    error: RequestError;
-}
-export declare const fetchPosts: import("@reduxjs/toolkit").AsyncThunk<any, string, {
-    state: AppState;
-    rejectValue: RequestError;
-    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
-    extra?: unknown;
-    serializedErrorType?: unknown;
-    pendingMeta?: unknown;
-    fulfilledMeta?: unknown;
-    rejectedMeta?: unknown;
-}>;
-export declare const resetPosts: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"posts/resetPosts">;
-export declare const selectPosts: (state: AppState) => {
-    posts: any[];
-    loading: RequestStatus;
-    error: RequestError;
-};
-export declare const postsReducer: import("redux").Reducer<PostsSlice, import("redux").AnyAction>;
+import { RequestError, RequestStatus } from '@open-tender/types';
+import { AppState } from '../app';
+export interface PostsSlice {
+    posts: any[];
+    loading: RequestStatus;
+    error: RequestError;
+}
+export declare const fetchPosts: import("@reduxjs/toolkit").AsyncThunk<any, string, {
+    state: AppState;
+    rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const resetPosts: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"posts/resetPosts">;
+export declare const selectPosts: (state: AppState) => {
+    posts: any[];
+    loading: RequestStatus;
+    error: RequestError;
+};
+export declare const postsReducer: import("redux").Reducer<PostsSlice, import("redux").AnyAction>;