cloudmr-ux 2.0.6 → 3.0.1

package/dist/core/features/authenticate/authenticateActionCreation.js

@@ -0,0 +1,326 @@
+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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
+    }
+};
+import axios from "axios";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { getAppConfig, getEndpoints } from "../../config/AppConfig";
+import { AuthenticatedHttpClient } from "../../common/utilities/AuthenticatedRequests";
+export var registerUser = createAsyncThunk("REGISTER", function (registerData, thunkAPI) { return __awaiter(void 0, void 0, void 0, function () {
+    var endpoints, response, error_1;
+    var _a, _b, _c, _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                endpoints = getEndpoints();
+                _e.label = 1;
+            case 1:
+                _e.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, axios.post(endpoints.REGISTER, registerData)];
+            case 2:
+                response = _e.sent();
+                return [2 /*return*/, response.data];
+            case 3:
+                error_1 = _e.sent();
+                console.error(error_1);
+                return [2 /*return*/, thunkAPI.rejectWithValue({
+                        message: ((_b = (_a = error_1.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || error_1.message,
+                        status: (_c = error_1.response) === null || _c === void 0 ? void 0 : _c.status,
+                        data: (_d = error_1.response) === null || _d === void 0 ? void 0 : _d.data
+                    })];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); });
+export var changePassword = createAsyncThunk("CHANGE_PASSWORD", function (passwordData, thunkAPI) { return __awaiter(void 0, void 0, void 0, function () {
+    var endpoints, response, error_2;
+    var _a, _b, _c, _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                endpoints = getEndpoints();
+                _e.label = 1;
+            case 1:
+                _e.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, AuthenticatedHttpClient.request({
+                        method: "POST",
+                        url: endpoints.CHANGE_PASSWORD,
+                        data: passwordData
+                    })];
+            case 2:
+                response = _e.sent();
+                return [2 /*return*/, response.data];
+            case 3:
+                error_2 = _e.sent();
+                console.error(error_2);
+                return [2 /*return*/, thunkAPI.rejectWithValue({
+                        message: ((_b = (_a = error_2.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || error_2.message,
+                        status: (_c = error_2.response) === null || _c === void 0 ? void 0 : _c.status,
+                        data: (_d = error_2.response) === null || _d === void 0 ? void 0 : _d.data
+                    })];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); });
+export var forgotPassword = createAsyncThunk("FORGOT_PASSWORD", function (forgotData, thunkAPI) { return __awaiter(void 0, void 0, void 0, function () {
+    var endpoints, response, error_3;
+    var _a, _b, _c, _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                endpoints = getEndpoints();
+                _e.label = 1;
+            case 1:
+                _e.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, axios.post(endpoints.FORGOT_PASSWORD, forgotData)];
+            case 2:
+                response = _e.sent();
+                return [2 /*return*/, response.data];
+            case 3:
+                error_3 = _e.sent();
+                console.error(error_3);
+                return [2 /*return*/, thunkAPI.rejectWithValue({
+                        message: ((_b = (_a = error_3.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || error_3.message,
+                        status: (_c = error_3.response) === null || _c === void 0 ? void 0 : _c.status,
+                        data: (_d = error_3.response) === null || _d === void 0 ? void 0 : _d.data
+                    })];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); });
+export var resetPassword = createAsyncThunk("RESET_PASSWORD", function (resetData, thunkAPI) { return __awaiter(void 0, void 0, void 0, function () {
+    var endpoints, response, error_4;
+    var _a, _b, _c, _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                endpoints = getEndpoints();
+                _e.label = 1;
+            case 1:
+                _e.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, axios.post(endpoints.RESET_PASSWORD, resetData)];
+            case 2:
+                response = _e.sent();
+                return [2 /*return*/, response.data];
+            case 3:
+                error_4 = _e.sent();
+                console.error(error_4);
+                return [2 /*return*/, thunkAPI.rejectWithValue({
+                        message: ((_b = (_a = error_4.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || error_4.message,
+                        status: (_c = error_4.response) === null || _c === void 0 ? void 0 : _c.status,
+                        data: (_d = error_4.response) === null || _d === void 0 ? void 0 : _d.data
+                    })];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); });
+export var getLoggedInToken = createAsyncThunk("SIGN_IN", function (signinData, thunkAPI) { return __awaiter(void 0, void 0, void 0, function () {
+    var endpoints, response, error_5, result;
+    var _a, _b, _c, _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                endpoints = getEndpoints();
+                _e.label = 1;
+            case 1:
+                _e.trys.push([1, 3, , 4]);
+                if (!axios.post) {
+                    console.error("Axios.post does not exist, axios is", axios);
+                    console.error("axios keys:", Object.keys(axios));
+                    console.error("axios.default?", axios["default"]);
+                    console.error("axios.default keys?", axios["default"] ? Object.keys(axios["default"]) : "N/A");
+                }
+                return [4 /*yield*/, axios.post(endpoints.SIGNIN, signinData)];
+            case 2:
+                response = _e.sent();
+                return [3 /*break*/, 4];
+            case 3:
+                error_5 = _e.sent();
+                console.error(error_5);
+                return [2 /*return*/, thunkAPI.rejectWithValue({
+                        message: ((_b = (_a = error_5.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || error_5.message,
+                        status: (_c = error_5.response) === null || _c === void 0 ? void 0 : _c.status,
+                        data: (_d = error_5.response) === null || _d === void 0 ? void 0 : _d.data
+                    })];
+            case 4:
+                result = Object.assign(signinData, response.data);
+                thunkAPI.dispatch(getProfile(result.access_token));
+                return [2 /*return*/, result];
+        }
+    });
+}); });
+export var signOut = createAsyncThunk("SIGN_OUT", function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        // const endpoints = getEndpoints();
+        // const response = await axios.post(endpoints.SIGNOUT, null, config);
+        // return response.data;
+        return [2 /*return*/, { message: "Successfully logged out" }];
+    });
+}); });
+export var getFineGrainToken = createAsyncThunk("FINE_GRAIN", function (_a) {
+    var accessToken = _a.accessToken, categories = _a.categories;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var config, endpoints, defaultCategories, response, e_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    config = getAppConfig();
+                    endpoints = getEndpoints();
+                    defaultCategories = {
+                        app: config.APP_NAME,
+                        activities: ["queue", "upload"]
+                    };
+                    if (!config.API_URL)
+                        return [2 /*return*/];
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, axios.post(config.API_URL, categories || defaultCategories, {
+                            headers: {
+                                Authorization: "Bearer ".concat(accessToken)
+                            }
+                        })];
+                case 2:
+                    response = _b.sent();
+                    return [2 /*return*/, response.data];
+                case 3:
+                    e_1 = _b.sent();
+                    return [2 /*return*/, undefined];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+});
+export var webSignin = createAsyncThunk("WEB_SIGN_IN", function (accessToken, thunkAPI) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        // Import getUpstreamJobs dynamically to avoid circular dependency
+        // thunkAPI.dispatch(getUpstreamJobs());
+        if (accessToken !== undefined) {
+            thunkAPI.dispatch(getProfile(accessToken));
+        }
+        return [2 /*return*/, {
+                access_token: accessToken,
+                token_type: "bearer",
+                expires_in: "1440"
+            }];
+    });
+}); });
+export var getProfile = createAsyncThunk("GET_PROFILE", function (accessToken) { return __awaiter(void 0, void 0, void 0, function () {
+    var endpoints, config, response, e_2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                endpoints = getEndpoints();
+                config = getAppConfig();
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, axios.get(endpoints.PROFILE, {
+                        headers: {
+                            Authorization: "Bearer ".concat(accessToken)
+                        },
+                        timeout: config.REQUESTS_TIMEOUT || 5000
+                    })];
+            case 2:
+                response = _a.sent();
+                if (response.data[0] === "<") {
+                    return [2 /*return*/, { error: "user not recognized" }];
+                }
+                return [2 /*return*/, response.data];
+            case 3:
+                e_2 = _a.sent();
+                return [2 /*return*/, undefined];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); });
+var runningPromise = null;
+export var refreshAccessToken = createAsyncThunk("REFRESH_ACCESS_TOKEN", function (refresh_token) { return __awaiter(void 0, void 0, void 0, function () {
+    var endpoints, parseResult, _a, data, _b, error_6;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                endpoints = getEndpoints();
+                parseResult = function (response) {
+                    return {
+                        refreshToken: response.data.refresh_token || refresh_token,
+                        accessToken: response.data.access_token,
+                        idToken: response.data.id_token,
+                        tokenType: "bearer",
+                        expiresIn: response.data.expires_in,
+                        parsedToken: parseJwt(response.data.id_token)
+                    };
+                };
+                if (!runningPromise) return [3 /*break*/, 2];
+                _a = parseResult;
+                return [4 /*yield*/, runningPromise];
+            case 1: return [2 /*return*/, _a.apply(void 0, [_d.sent()])];
+            case 2:
+                data = {
+                    refresh_token: refresh_token
+                };
+                if (!endpoints.REFRESH_TOKEN) {
+                    throw new Error("Refresh token endpoint not configured");
+                }
+                runningPromise = axios.post(endpoints.REFRESH_TOKEN, data);
+                _d.label = 3;
+            case 3:
+                _d.trys.push([3, 5, 6, 7]);
+                _b = parseResult;
+                return [4 /*yield*/, runningPromise];
+            case 4: return [2 /*return*/, _b.apply(void 0, [_d.sent()])];
+            case 5:
+                error_6 = _d.sent();
+                if (axios.isAxiosError(error_6)) {
+                    console.error("Token refresh failed:", ((_c = error_6.response) === null || _c === void 0 ? void 0 : _c.data) || error_6.message);
+                }
+                throw error_6;
+            case 6:
+                runningPromise = null;
+                return [7 /*endfinally*/];
+            case 7: return [2 /*return*/];
+        }
+    });
+}); });
+// Helper function for JWT parsing
+function parseJwt(token) {
+    try {
+        return JSON.parse(atob(token.split(".")[1]));
+    }
+    catch (e) {
+        return null;
+    }
+}

package/dist/core/features/authenticate/authenticateSlice.d.ts

@@ -0,0 +1,45 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+export interface AuthenticateToken {
+    idToken: string;
+    accessToken: string;
+    refreshToken: string;
+    tokenType: string;
+    expiresIn: number;
+    parsedToken: any;
+}
+export interface AuthenticateState {
+    id?: string;
+    email: string;
+    username?: string;
+    status?: string;
+    level?: string;
+    isAdmin?: boolean;
+    logged_in_token?: AuthenticateToken;
+    loading: boolean;
+    uploadToken: string;
+    queueToken: string;
+    accessToken: string;
+    error?: string;
+    registerSuccess?: boolean;
+    changePasswordSuccess?: boolean;
+    forgotPasswordSuccess?: boolean;
+    resetPasswordSuccess?: boolean;
+}
+export declare const authenticateSlice: import("@reduxjs/toolkit").Slice<AuthenticateState, {
+    setInitialTokens: (state: import("immer").WritableDraft<AuthenticateState>, action: PayloadAction<{
+        uploadToken: string;
+        queueToken: string;
+    }>) => void;
+    resetAuth: (state: import("immer").WritableDraft<AuthenticateState>) => void;
+    clearError: (state: import("immer").WritableDraft<AuthenticateState>) => void;
+    clearRegisterSuccess: (state: import("immer").WritableDraft<AuthenticateState>) => void;
+    clearChangePasswordSuccess: (state: import("immer").WritableDraft<AuthenticateState>) => void;
+    clearForgotPasswordSuccess: (state: import("immer").WritableDraft<AuthenticateState>) => void;
+    clearResetPasswordSuccess: (state: import("immer").WritableDraft<AuthenticateState>) => void;
+}, "authenticate", "authenticate", import("@reduxjs/toolkit").SliceSelectors<AuthenticateState>>;
+export declare const setInitialTokens: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    uploadToken: string;
+    queueToken: string;
+}, "authenticate/setInitialTokens">, resetAuth: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"authenticate/resetAuth">, clearError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"authenticate/clearError">, clearRegisterSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"authenticate/clearRegisterSuccess">, clearChangePasswordSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"authenticate/clearChangePasswordSuccess">, clearForgotPasswordSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"authenticate/clearForgotPasswordSuccess">, clearResetPasswordSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"authenticate/clearResetPasswordSuccess">;
+declare const _default: import("redux").Reducer<AuthenticateState, import("redux").UnknownAction, AuthenticateState>;
+export default _default;

package/dist/core/features/authenticate/authenticateSlice.js

@@ -0,0 +1,203 @@
+var _a;
+import { createSlice } from '@reduxjs/toolkit';
+import { getLoggedInToken, refreshAccessToken, getProfile, signOut, registerUser, changePassword, forgotPassword, resetPassword } from './authenticateActionCreation';
+import { getUploadedData } from '../data/dataActionCreation';
+var initialState = {
+    email: '',
+    loading: false,
+    uploadToken: '',
+    queueToken: '',
+    accessToken: ''
+};
+export var authenticateSlice = createSlice({
+    name: 'authenticate',
+    initialState: initialState,
+    reducers: {
+        // Add action to set initial tokens from config
+        setInitialTokens: function (state, action) {
+            state.uploadToken = action.payload.uploadToken;
+            state.queueToken = action.payload.queueToken;
+        },
+        resetAuth: function (state) {
+            state.email = "";
+            state.logged_in_token = undefined;
+            state.accessToken = "";
+            state.loading = false;
+            state.error = undefined;
+            state.registerSuccess = undefined;
+        },
+        clearError: function (state) {
+            state.error = undefined;
+        },
+        clearRegisterSuccess: function (state) {
+            state.registerSuccess = undefined;
+        },
+        clearChangePasswordSuccess: function (state) {
+            state.changePasswordSuccess = undefined;
+        },
+        clearForgotPasswordSuccess: function (state) {
+            state.forgotPasswordSuccess = undefined;
+        },
+        clearResetPasswordSuccess: function (state) {
+            state.resetPasswordSuccess = undefined;
+        }
+    },
+    extraReducers: function (builder) { return (builder.addCase('persist/REHYDRATE', function (state, action) {
+        var _a, _b;
+        var authenticate = (_a = action.payload) === null || _a === void 0 ? void 0 : _a.authenticate;
+        if (authenticate) {
+            state.email = authenticate.email;
+            state.logged_in_token = authenticate.logged_in_token;
+            state.accessToken = ((_b = authenticate.logged_in_token) === null || _b === void 0 ? void 0 : _b.accessToken) || "";
+        }
+    }),
+        builder.addCase(registerUser.pending, function (state, action) {
+            state.loading = true;
+            state.error = undefined;
+            state.registerSuccess = undefined;
+        }),
+        builder.addCase(registerUser.fulfilled, function (state, action) {
+            state.loading = false;
+            state.registerSuccess = true;
+            state.error = undefined;
+        }),
+        builder.addCase(registerUser.rejected, function (state, action) {
+            state.loading = false;
+            state.registerSuccess = false;
+            var payload = action.payload;
+            state.error = (payload === null || payload === void 0 ? void 0 : payload.message) || "Registration failed";
+        }),
+        builder.addCase(getLoggedInToken.pending, function (state, action) {
+            state.loading = true;
+            state.error = undefined;
+        }),
+        builder.addCase(getLoggedInToken.fulfilled, function (state, action) {
+            var _a = action.payload, email = _a.email, id_token = _a.id_token, access_token = _a.access_token, refresh_token = _a.refresh_token, token_type = _a.token_type, expires_in = _a.expires_in;
+            state.logged_in_token = {
+                idToken: id_token,
+                accessToken: access_token,
+                refreshToken: refresh_token,
+                tokenType: token_type,
+                expiresIn: expires_in,
+                parsedToken: parseJwt(id_token)
+            };
+            console.log("logged in token", parseJwt(id_token));
+            state.email = email;
+            state.accessToken = access_token;
+            state.loading = false;
+            state.error = undefined;
+        }),
+        builder.addCase(getLoggedInToken.rejected, function (state, action) {
+            state.loading = false;
+            var payload = action.payload;
+            state.error = (payload === null || payload === void 0 ? void 0 : payload.message) || "Sign in failed";
+        }),
+        builder.addCase(refreshAccessToken.fulfilled, function (state, action) {
+            console.log("refreshed token", action.payload.parsedToken);
+            state.logged_in_token = action.payload;
+            state.accessToken = action.payload.accessToken;
+        }),
+        builder.addCase(signOut.pending, function (state, action) {
+            state.loading = true;
+        }),
+        builder.addCase(signOut.fulfilled, function (state, action) {
+            var message = action.payload.message;
+            if (message === "Successfully logged out") {
+                state.email = "";
+                state.logged_in_token = undefined;
+                state.accessToken = "";
+                state.loading = false;
+            }
+        }),
+        builder.addCase(getUploadedData.pending, function (state, action) {
+            state.loading = true;
+        }),
+        builder.addCase(getUploadedData.fulfilled, function (state, action) {
+            var payloadData = action.payload;
+            if (payloadData === undefined || payloadData.error === 'user not recognized') {
+                state.logged_in_token = undefined;
+                state.accessToken = "";
+                state.loading = false;
+            }
+            state.loading = false;
+        }),
+        builder.addCase(getProfile.fulfilled, function (state, action) {
+            var payloadData = action.payload;
+            if (payloadData === undefined || payloadData.error === 'user not recognized') {
+                state.logged_in_token = undefined;
+                state.accessToken = "";
+                state.loading = false;
+                // Reset to default tokens
+                state.uploadToken = '';
+                state.queueToken = '';
+            }
+            else {
+                state.email = payloadData.email;
+                state.level = payloadData.level;
+                state.status = payloadData.status;
+                state.username = payloadData.username;
+                state.isAdmin = payloadData.isAdmin;
+            }
+            state.loading = false;
+        }),
+        builder.addCase(changePassword.pending, function (state, action) {
+            state.loading = true;
+            state.error = undefined;
+            state.changePasswordSuccess = undefined;
+        }),
+        builder.addCase(changePassword.fulfilled, function (state, action) {
+            state.loading = false;
+            state.changePasswordSuccess = true;
+            state.error = undefined;
+        }),
+        builder.addCase(changePassword.rejected, function (state, action) {
+            state.loading = false;
+            state.changePasswordSuccess = false;
+            var payload = action.payload;
+            state.error = (payload === null || payload === void 0 ? void 0 : payload.message) || "Failed to change password";
+        }),
+        builder.addCase(forgotPassword.pending, function (state, action) {
+            state.loading = true;
+            state.error = undefined;
+            state.forgotPasswordSuccess = undefined;
+        }),
+        builder.addCase(forgotPassword.fulfilled, function (state, action) {
+            state.loading = false;
+            state.forgotPasswordSuccess = true;
+            state.error = undefined;
+        }),
+        builder.addCase(forgotPassword.rejected, function (state, action) {
+            state.loading = false;
+            state.forgotPasswordSuccess = false;
+            var payload = action.payload;
+            state.error = (payload === null || payload === void 0 ? void 0 : payload.message) || "Failed to send reset code";
+        }),
+        builder.addCase(resetPassword.pending, function (state, action) {
+            state.loading = true;
+            state.error = undefined;
+            state.resetPasswordSuccess = undefined;
+        }),
+        builder.addCase(resetPassword.fulfilled, function (state, action) {
+            state.loading = false;
+            state.resetPasswordSuccess = true;
+            state.error = undefined;
+        }),
+        builder.addCase(resetPassword.rejected, function (state, action) {
+            state.loading = false;
+            state.resetPasswordSuccess = false;
+            var payload = action.payload;
+            state.error = (payload === null || payload === void 0 ? void 0 : payload.message) || "Failed to reset password";
+        })); }
+});
+// Export actions
+export var setInitialTokens = (_a = authenticateSlice.actions, _a.setInitialTokens), resetAuth = _a.resetAuth, clearError = _a.clearError, clearRegisterSuccess = _a.clearRegisterSuccess, clearChangePasswordSuccess = _a.clearChangePasswordSuccess, clearForgotPasswordSuccess = _a.clearForgotPasswordSuccess, clearResetPasswordSuccess = _a.clearResetPasswordSuccess;
+// Helper function for JWT parsing
+function parseJwt(token) {
+    try {
+        return JSON.parse(atob(token.split('.')[1]));
+    }
+    catch (e) {
+        return null;
+    }
+}
+export default authenticateSlice.reducer;

package/dist/core/features/data/dataActionCreation.d.ts

@@ -0,0 +1,40 @@
+import { AxiosResponse } from "axios";
+export interface LambdaFile {
+    filename: string;
+    filetype: string;
+    filesize: string;
+    filemd5: string;
+    file: {
+        lastModified: number;
+        name: string;
+        size: number;
+        type: string;
+    };
+}
+export declare const getUploadedData: import("@reduxjs/toolkit").AsyncThunk<any, void, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const renameUploadedData: import("@reduxjs/toolkit").AsyncThunk<any, {
+    fileId: number;
+    newName: string;
+    is_demo_data?: boolean | undefined;
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const deleteUploadedData: import("@reduxjs/toolkit").AsyncThunk<any, {
+    fileId: number;
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const uploadData: import("@reduxjs/toolkit").AsyncThunk<{
+    code: number;
+    response: any;
+    file: LambdaFile;
+    uploadTarget: string | undefined;
+} | {
+    code: number;
+    response: any;
+    file: undefined;
+    uploadTarget: string | undefined;
+}, {
+    uploadToken: string;
+    file: File;
+    fileAlias: string;
+    onProgress?: ((progress: number) => void) | undefined;
+    uploadTarget?: string | undefined;
+    onUploaded?: ((res: AxiosResponse, file: File) => void) | undefined;
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;