cloudmr-ux 2.0.6 → 3.0.1

package/dist/core/common/utilities/file-transformation/anonymize.js

@@ -0,0 +1,114 @@
+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 };
+    }
+};
+var hasAnonymizedFields = function (text) {
+    // Detect long sequences of zeros, X's, or hexadecimal strings
+    var anonymizedPatterns = [
+        /\b0{10,}\b/,
+        /\b[xX]{4,}\b/,
+        /"[\da-fA-F]{16,}"/ // Hexadecimal strings (common in IDs)
+    ];
+    return anonymizedPatterns.some(function (pattern) { return pattern.test(text); });
+};
+var detectPHI = function (text) {
+    var patterns = {
+        ssn: /\b\d{3}-\d{2}-\d{4}\b/,
+        address: /\b\d+ [A-Z][a-z]+ [A-Z][a-z]+, [A-Z]{2} \d{5}\b/,
+        patientname: /<ParamString\.["']PatientName["']>\s*{\s*["']([^"^]+)\^([^"^]+)["']\s*}/i
+    };
+    var detected = {};
+    for (var _i = 0, _a = Object.entries(patterns); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], regex = _b[1];
+        var matches = text.match(regex);
+        if (matches) {
+            detected[key] = matches; // Store matches
+        }
+    }
+    var hasAnonymized = hasAnonymizedFields(text);
+    // If anonymized fields are found and no PHI is detected, return false (safe)
+    if (hasAnonymized) {
+        return false; // File is safe and anonymized
+    }
+    else {
+        return Object.keys(detected).length > 0; // File is not safe if PHI is detected
+    }
+};
+export var is_safe_twix = function (file) { return __awaiter(void 0, void 0, void 0, function () {
+    var ssnRegex, addressRegex, nameRegex, anonymizedRegex, reader, decoder, _a, chunk, done, tail, text, finalText;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                ssnRegex = /\b\d{3}-\d{2}-\d{4}\b/;
+                addressRegex = /\b\d+ [A-Z][a-z]+ [A-Z][a-z]+, [A-Z]{2} \d{5}\b/;
+                nameRegex = /<ParamString\.["']PatientName["']>\s*{\s*["']([^"^]+)\^([^"^]+)["']\s*}/i;
+                anonymizedRegex = /\b0{10,}\b|\b[xX]{4,}\b|["'][\da-fA-F]{16,}["']/g;
+                reader = file.stream().getReader();
+                decoder = new TextDecoder("utf-8");
+                return [4 /*yield*/, reader.read()];
+            case 1:
+                _a = _c.sent(), chunk = _a.value, done = _a.done;
+                tail = "";
+                _c.label = 2;
+            case 2:
+                if (!!done) return [3 /*break*/, 4];
+                text = tail + decoder.decode(chunk, { stream: true });
+                // keep a little tail in case pattern crosses chunk boundary
+                tail = text.slice(-50);
+                // check for anonymized fields first
+                if (anonymizedRegex.test(text)) {
+                    return [2 /*return*/, true]; // safe
+                }
+                // check for any PHI
+                if (ssnRegex.test(text) || addressRegex.test(text) || nameRegex.test(text)) {
+                    return [2 /*return*/, false]; // unsafe
+                }
+                return [4 /*yield*/, reader.read()];
+            case 3:
+                // read next chunk
+                (_b = _c.sent(), chunk = _b.value, done = _b.done);
+                return [3 /*break*/, 2];
+            case 4:
+                finalText = tail + decoder.decode();
+                if (anonymizedRegex.test(finalText))
+                    return [2 /*return*/, true];
+                if (ssnRegex.test(finalText) || addressRegex.test(finalText) || nameRegex.test(finalText)) {
+                    return [2 /*return*/, false];
+                }
+                return [2 /*return*/, true]; // no PHI found, no anonymized-fields found
+        }
+    });
+}); };

package/dist/core/common/utilities/file-transformation/utilities.d.ts

@@ -0,0 +1,2 @@
+export declare function getFileExtension(filename: string): string;
+export declare function formatBytes(bytes: number, decimals?: number): string;

package/dist/core/common/utilities/file-transformation/utilities.js

@@ -0,0 +1,23 @@
+// File extension utility functions
+export function getFileExtension(filename) {
+    var parts = filename.split('.');
+    if (parts.length === 1)
+        return '';
+    if (parts.length === 2)
+        return parts[1];
+    // Handle .nii.gz case
+    if (parts[parts.length - 2] === 'nii' && parts[parts.length - 1] === 'gz') {
+        return 'nii.gz';
+    }
+    return parts[parts.length - 1];
+}
+export function formatBytes(bytes, decimals) {
+    if (decimals === void 0) { decimals = 2; }
+    if (bytes === 0)
+        return '0 Bytes';
+    var k = 1024;
+    var dm = decimals < 0 ? 0 : decimals;
+    var sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+    var i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+}

package/dist/core/common/utilities/index.d.ts

@@ -0,0 +1,25 @@
+export declare const isUndefined: (value: any) => boolean;
+export declare const complexToPolarR: (re: Array<number>, im: Array<number>) => number[];
+export declare const complexToPolarP: (re: Array<number>, im: Array<number>) => number[];
+declare global {
+    interface Array<T> {
+        GetMaxMin(): any;
+    }
+}
+export declare const getUIID: () => string;
+export declare const linearFit2pts: (p0: any, p1: any) => {
+    q: any;
+    m: number;
+};
+export declare const purgenan: (array: any) => any;
+export declare const average: (param: any) => number;
+export declare const median: (numbers: any) => number;
+export declare const formatBytes: (bytes: number, decimals?: number) => string;
+export declare const getFileExtension: (fileName: string) => string;
+/**
+ * Use get max and get min on voxels instead of using
+ * spread operators to prevent call stack exceptions
+ * @param array
+ */
+export declare function getMax(array: number[]): number;
+export declare function getMin(array: number[]): number;

package/dist/core/common/utilities/index.js

@@ -0,0 +1,118 @@
+import { complex, random } from "mathjs";
+export var isUndefined = function (value) {
+    return typeof value === "undefined";
+};
+export var complexToPolarR = function (re, im) {
+    var result = [];
+    for (var i = 0; i < (re === null || re === void 0 ? void 0 : re.length); i++) {
+        var a = complex(re[i], im[i]);
+        var p = a.toPolar();
+        result[i] = p.r;
+    }
+    return result;
+};
+export var complexToPolarP = function (re, im) {
+    var result = [];
+    for (var i = 0; i < (re === null || re === void 0 ? void 0 : re.length); i++) {
+        var a = complex(re[i], im[i]);
+        var p = a.toPolar();
+        result[i] = p.phi;
+    }
+    return result;
+};
+Array.prototype.GetMaxMin = function () {
+    var max = Number.MIN_VALUE;
+    var min = Number.MAX_VALUE;
+    for (var i = 0, len = this.length; i < len; i++) {
+        if (isNaN(this[i])) {
+        }
+        else {
+            if (this[i] > max)
+                max = this[i];
+            if (this[i] < min)
+                min = this[i];
+        }
+    }
+    return { Max: max, Min: min };
+};
+export var getUIID = function () {
+    return (random().toString(36).substring(2, 15) +
+        random().toString(36).substring(2, 15));
+};
+export var linearFit2pts = function (p0, p1) {
+    var slope = (p1.y - p0.y) / (p1.x - p0.x);
+    var intercept = -slope * p0.x + p0.y;
+    return {
+        q: intercept,
+        m: slope
+    };
+};
+export var purgenan = function (array) {
+    var par = [];
+    for (var i = 0; i < array.length; i++) {
+        if (!isNaN(array[i])) {
+            par.push(array[i]);
+        }
+    }
+    return par;
+};
+export var average = function (param) {
+    var sum = 0;
+    for (var i = 0; i < param.length; i++) {
+        sum += param[i];
+    }
+    return sum / param.length;
+};
+export var median = function (numbers) {
+    var median = 0, numsLen = numbers.length;
+    numbers.sort();
+    if (numsLen % 2 === 0) {
+        // average of two middle numbers
+        median = (numbers[numsLen / 2 - 1] + numbers[numsLen / 2]) / 2;
+    }
+    else {
+        // middle number only
+        median = numbers[(numsLen - 1) / 2];
+    }
+    return median;
+};
+export var formatBytes = function (bytes, decimals) {
+    if (decimals === void 0) { decimals = 2; }
+    if (bytes === 0)
+        return "0 Bytes";
+    var k = 1024;
+    var dm = decimals < 0 ? 0 : decimals;
+    var sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    var i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + " " + sizes[i];
+};
+export var getFileExtension = function (fileName) {
+    var lower = fileName.toLowerCase();
+    if (lower.endsWith(".nii.gz"))
+        return "nii.gz";
+    var lastDot = lower.lastIndexOf(".");
+    return lastDot !== -1 ? lower.slice(lastDot + 1) : "";
+};
+/**
+ * Use get max and get min on voxels instead of using
+ * spread operators to prevent call stack exceptions
+ * @param array
+ */
+export function getMax(array) {
+    var max = array.length > 0 ? array[0] : 0;
+    for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
+        var element = array_1[_i];
+        if (element > max)
+            max = element;
+    }
+    return max;
+}
+export function getMin(array) {
+    var min = array.length > 0 ? array[0] : 0;
+    for (var _i = 0, array_2 = array; _i < array_2.length; _i++) {
+        var element = array_2[_i];
+        if (element < min)
+            min = element;
+    }
+    return min;
+}

package/dist/core/common/utilities/parse-jwt.d.ts

@@ -0,0 +1 @@
+export declare function parseJwt(token: string): any;

package/dist/core/common/utilities/parse-jwt.js

@@ -0,0 +1,14 @@
+export function parseJwt(token) {
+    try {
+        var base64Url = token.split('.')[1];
+        var base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+        var jsonPayload = decodeURIComponent(atob(base64).split('').map(function (c) {
+            return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+        }).join(''));
+        return JSON.parse(jsonPayload);
+    }
+    catch (e) {
+        console.error('Error parsing JWT:', e);
+        return null;
+    }
+}

package/dist/core/components/PasswordRequirements.d.ts

@@ -0,0 +1,7 @@
+import { PasswordValidation } from "../utils/passwordValidation";
+interface PasswordRequirementsProps {
+    validation: PasswordValidation;
+    show: boolean;
+}
+export default function PasswordRequirements({ validation, show, }: PasswordRequirementsProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/core/components/PasswordRequirements.js

@@ -0,0 +1,30 @@
+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);
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import Box from "@mui/material/Box";
+import Typography from "@mui/material/Typography";
+import CheckCircleIcon from "@mui/icons-material/CheckCircle";
+import CancelIcon from "@mui/icons-material/Cancel";
+import { getPasswordRequirements, } from "../utils/passwordValidation";
+export default function PasswordRequirements(_a) {
+    var validation = _a.validation, show = _a.show;
+    if (!show)
+        return null;
+    var requirements = getPasswordRequirements();
+    return (_jsxs(Box, __assign({ sx: { mt: 1, mb: 1 } }, { children: [_jsx(Typography, __assign({ variant: "caption", display: "block", sx: { mb: 0.5, fontWeight: "bold" } }, { children: "Password Requirements:" })), requirements.map(function (_a) {
+                var key = _a.key, label = _a.label;
+                var isValid = validation[key];
+                return (_jsxs(Typography, __assign({ variant: "caption", display: "flex", alignItems: "center", sx: {
+                        color: isValid ? "success.main" : "error.main"
+                    } }, { children: [isValid ? (_jsx(CheckCircleIcon, { sx: { fontSize: 16, mr: 0.5 } })) : (_jsx(CancelIcon, { sx: { fontSize: 16, mr: 0.5 } })), label] }), key));
+            })] })));
+}

package/dist/core/config/AppConfig.d.ts

@@ -0,0 +1,5 @@
+import { CloudMRCoreConfig, AppConfig, AppEndpoints } from './types';
+export declare function initializeCloudMRCore(config: CloudMRCoreConfig): void;
+export declare function getAppConfig(): AppConfig;
+export declare function getEndpoints(): AppEndpoints;
+export declare function createEndpoints(baseServer: string): AppEndpoints;

package/dist/core/config/AppConfig.js

@@ -0,0 +1,42 @@
+var globalConfig = null;
+export function initializeCloudMRCore(config) {
+    globalConfig = config;
+}
+export function getAppConfig() {
+    if (!globalConfig) {
+        throw new Error('CloudMR Core not initialized. Call initializeCloudMRCore() first.');
+    }
+    return globalConfig.appConfig;
+}
+export function getEndpoints() {
+    if (!globalConfig) {
+        throw new Error('CloudMR Core not initialized. Call initializeCloudMRCore() first.');
+    }
+    return globalConfig.endpoints;
+}
+export function createEndpoints(baseServer) {
+    return {
+        SIGNIN: "".concat(baseServer, "/auth/login"),
+        SIGNOUT: "".concat(baseServer, "/auth/logout"),
+        REGISTER: "".concat(baseServer, "/auth/register"),
+        CHANGE_PASSWORD: "".concat(baseServer, "/auth/change-password"),
+        FORGOT_PASSWORD: "".concat(baseServer, "/auth/forgot-password"),
+        RESET_PASSWORD: "".concat(baseServer, "/auth/reset-password"),
+        PROFILE: "".concat(baseServer, "/profile"),
+        REFRESH_TOKEN: "".concat(baseServer, "/auth/refresh"),
+        DATA_API: "".concat(baseServer, "/data/read"),
+        DATA_DELETE_API: "".concat(baseServer, "/data/delete"),
+        DATA_RENAME_API: "".concat(baseServer, "/data/update"),
+        DATA_UPLOAD_INIT: "".concat(baseServer, "/upload_initiate"),
+        DATA_UPLOAD_FINALIZE: "".concat(baseServer, "/upload_finalize"),
+        JOBS_API: "".concat(baseServer, "/pipeline/queue_job"),
+        JOBS_RETRIEVE_API: "".concat(baseServer, "/pipeline/list"),
+        JOBS_DELETE_API: "".concat(baseServer, "/pipeline/delete"),
+        JOBS_RENAME_API: "".concat(baseServer, "/pipeline/update"),
+        JOB_UPLOAD_INIT: "".concat(baseServer, "/upload_initiate/results"),
+        JOB_UPLOAD_FINALIZE: "".concat(baseServer, "/upload_finalize/results"),
+        ROI_GET: "".concat(baseServer, "/roi/list"),
+        ROI_UPLOAD: "".concat(baseServer, "/roi/upload"),
+        UNZIP: "".concat(baseServer, "/unzip")
+    };
+}

package/dist/core/config/types.d.ts

@@ -0,0 +1,40 @@
+export interface AppEndpoints {
+    SIGNIN: string;
+    SIGNOUT: string;
+    REGISTER: string;
+    CHANGE_PASSWORD: string;
+    FORGOT_PASSWORD: string;
+    RESET_PASSWORD: string;
+    PROFILE: string;
+    REFRESH_TOKEN?: string;
+    FINEGRAIN?: string;
+    DATA_API: string;
+    DATA_DELETE_API: string;
+    DATA_RENAME_API: string;
+    DATA_UPLOAD_INIT: string;
+    DATA_UPLOAD_FINALIZE: string;
+    JOBS_API: string;
+    JOBS_RETRIEVE_API: string;
+    JOBS_DELETE_API: string;
+    JOBS_RENAME_API: string;
+    JOB_UPLOAD_INIT: string;
+    JOB_UPLOAD_FINALIZE: string;
+    ROI_GET: string;
+    ROI_UPLOAD: string;
+    UNZIP: string;
+}
+export interface AppConfig {
+    APP_NAME: string;
+    CLOUDMR_SERVER: string;
+    API_TOKEN: string;
+    API_URL?: string;
+    COGNITO_CLIENT_ID?: string;
+    USER_POOL_ID?: string;
+    REQUESTS_TIMEOUT?: number;
+    FILE_CHUNK_SIZE?: number;
+    APP_BUG_REPORT?: string;
+}
+export interface CloudMRCoreConfig {
+    appConfig: AppConfig;
+    endpoints: AppEndpoints;
+}

package/dist/core/config/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,46 @@
+import { AuthenticateToken } from "./authenticateSlice";
+export interface SigninDataType {
+    email: string;
+    password: string;
+}
+export interface RegisterDataType {
+    email: string;
+    password: string;
+    firstname: string;
+    lastname: string;
+    username: string;
+}
+export interface ChangePasswordDataType {
+    oldPassword: string;
+    newPassword: string;
+}
+export interface ForgotPasswordDataType {
+    email: string;
+}
+export interface ResetPasswordDataType {
+    email: string;
+    code: string;
+    newPassword: string;
+}
+export declare const registerUser: import("@reduxjs/toolkit").AsyncThunk<any, RegisterDataType, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const changePassword: import("@reduxjs/toolkit").AsyncThunk<any, ChangePasswordDataType, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const forgotPassword: import("@reduxjs/toolkit").AsyncThunk<any, ForgotPasswordDataType, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const resetPassword: import("@reduxjs/toolkit").AsyncThunk<any, ResetPasswordDataType, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const getLoggedInToken: import("@reduxjs/toolkit").AsyncThunk<any, SigninDataType, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const signOut: import("@reduxjs/toolkit").AsyncThunk<{
+    message: string;
+}, void, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const getFineGrainToken: import("@reduxjs/toolkit").AsyncThunk<any, {
+    accessToken: string;
+    categories?: {
+        app: string;
+        activities: string[];
+    } | undefined;
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const webSignin: import("@reduxjs/toolkit").AsyncThunk<{
+    access_token: string;
+    token_type: string;
+    expires_in: string;
+}, string, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const getProfile: import("@reduxjs/toolkit").AsyncThunk<any, string, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const refreshAccessToken: import("@reduxjs/toolkit").AsyncThunk<AuthenticateToken, string, import("@reduxjs/toolkit").AsyncThunkConfig>;