cloudmr-ux 2.0.6 → 3.0.1

package/dist/core/common/components/NiivueTools/util.js

@@ -0,0 +1,309 @@
+import { mat4, vec3, vec4 } from 'gl-matrix'
+
+
+// rotate image to match right-anterior-superior voxel order
+export function img2ras16(volume) {
+    // return image oriented to RAS space as int16
+    const dims = volume.hdr.dims // reverse to original
+    const perm = volume.permRAS
+    const vx = dims[1] * dims[2] * dims[3]
+    // this.drawBitmap = new Uint8Array(vx);
+    const img16 = new Int16Array(vx)
+    const layout = [0, 0, 0]
+    for (let i = 0; i < 3; i++) {
+        for (let j = 0; j < 3; j++) {
+            if (Math.abs(perm[i]) - 1 !== j) {
+                continue
+            }
+            layout[j] = i * Math.sign(perm[i])
+        }
+    }
+    let stride = 1
+    const instride = [1, 1, 1]
+    const inflip = [false, false, false]
+    for (let i = 0; i < layout.length; i++) {
+        for (let j = 0; j < layout.length; j++) {
+            const a = Math.abs(layout[j])
+            if (a !== i) {
+                continue
+            }
+            instride[j] = stride
+            // detect -0: https://medium.com/coding-at-dawn/is-negative-zero-0-a-number-in-javascript-c62739f80114
+            if (layout[j] < 0 || Object.is(layout[j], -0)) {
+                inflip[j] = true
+            }
+            stride *= dims[j + 1]
+        }
+    }
+    // lookup table for flips and stride offsets:
+    const range = (start, stop, step) => Array.from({ length: (stop - start) / step + 1 }, (_, i) => start + i * step)
+    let xlut = range(0, dims[1] - 1, 1)
+    if (inflip[0]) {
+        xlut = range(dims[1] - 1, 0, -1)
+    }
+    for (let i = 0; i < dims[1]; i++) {
+        xlut[i] *= instride[0]
+    }
+    let ylut = range(0, dims[2] - 1, 1)
+    if (inflip[1]) {
+        ylut = range(dims[2] - 1, 0, -1)
+    }
+    for (let i = 0; i < dims[2]; i++) {
+        ylut[i] *= instride[1]
+    }
+    let zlut = range(0, dims[3] - 1, 1)
+    if (inflip[2]) {
+        zlut = range(dims[3] - 1, 0, -1)
+    }
+    for (let i = 0; i < dims[3]; i++) {
+        zlut[i] *= instride[2]
+    }
+    // convert data
+    let j = 0
+    for (let z = 0; z < dims[3]; z++) {
+        for (let y = 0; y < dims[2]; y++) {
+            for (let x = 0; x < dims[1]; x++) {
+                img16[xlut[x] + ylut[y] + zlut[z]] = volume.img[j]
+                j++
+            }
+        }
+    }
+    return img16
+}
+
+function nice(x, round) {
+    const exp = Math.floor(Math.log(x) / Math.log(10))
+    const f = x / Math.pow(10, exp)
+    let nf
+    if (round) {
+        if (f < 1.5) {
+            nf = 1
+        } else if (f < 3) {
+            nf = 2
+        } else if (f < 7) {
+            nf = 5
+        } else {
+            nf = 10
+        }
+    } else {
+        if (f <= 1) {
+            nf = 1
+        } else if (f <= 2) {
+            nf = 2
+        } else if (f <= 5) {
+            nf = 5
+        } else {
+            nf = 10
+        }
+    }
+    return nf * Math.pow(10, exp)
+}
+
+function loose_label(min, max, ntick = 4) {
+    const range = nice(max - min, false)
+    const d = nice(range / (ntick - 1), true)
+    const graphmin = Math.floor(min / d) * d
+    const graphmax = Math.ceil(max / d) * d
+    const perfect = graphmin === min && graphmax === max
+    return [d, graphmin, graphmax, perfect]
+}
+
+// "Nice Numbers for Graph Labels", Graphics Gems, pp 61-63
+// https://github.com/cenfun/nice-ticks/blob/master/docs/Nice-Numbers-for-Graph-Labels.pdf
+export function tickSpacing(mn, mx) {
+    let v = loose_label(mn, mx, 3)
+    if (!v[3]) {
+        v = loose_label(mn, mx, 5)
+    }
+    if (!v[3]) {
+        v = loose_label(mn, mx, 4)
+    }
+    if (!v[3]) {
+        v = loose_label(mn, mx, 3)
+    }
+    if (!v[3]) {
+        v = loose_label(mn, mx, 5)
+    }
+    return [v[0], v[1], v[2]]
+}
+
+// convert degrees to radians
+export function deg2rad(deg) {
+    return deg * (Math.PI / 180.0)
+}
+
+export function negMinMax(min, max, minNeg, maxNeg) {
+    let mn = -min
+    let mx = -max
+    if (isFinite(minNeg) && isFinite(maxNeg)) {
+        mn = minNeg
+        mx = maxNeg
+    }
+    if (mn > mx) {
+        ;[mn, mx] = [mx, mn]
+    }
+    return [mn, mx]
+}
+
+export function swizzleVec3(vec, order = [0, 1, 2]) {
+    const vout = vec3.create()
+    vout[0] = vec[order[0]]
+    vout[1] = vec[order[1]]
+    vout[2] = vec[order[2]]
+    return vout
+}
+
+// return boolean is 2D slice view is radiological
+// n.b. ambiguous for pure sagittal views
+export function isRadiological(mtx) {
+    const vRight = vec4.fromValues(1, 0, 0, 0) // pure right vector
+    const vRotated = vec4.create()
+    vec4.transformMat4(vRotated, vRight, mtx)
+    return vRotated[0]
+}
+
+export function unProject(winX, winY, winZ, mvpMatrix) {
+    // https://github.com/bringhurst/webgl-unproject
+    const inp = vec4.fromValues(winX, winY, winZ, 1.0)
+    const finalMatrix = mat4.clone(mvpMatrix)
+    // mat.mat4.multiply(finalMatrix, model, proj);
+    mat4.invert(finalMatrix, finalMatrix)
+    // view is leftTopWidthHeight
+    /* Map to range -1 to 1 */
+    inp[0] = inp[0] * 2 - 1
+    inp[1] = inp[1] * 2 - 1
+    inp[2] = inp[2] * 2 - 1
+    const out = vec4.create()
+    vec4.transformMat4(out, inp, finalMatrix)
+    if (out[3] === 0.0) {
+        return out
+    } // error
+    out[0] /= out[3]
+    out[1] /= out[3]
+    out[2] /= out[3]
+    return out
+}
+
+export function unpackFloatFromVec4i(val) {
+    // Convert 32-bit rgba to float32
+    // https://github.com/rii-mango/Papaya/blob/782a19341af77a510d674c777b6da46afb8c65f1/src/js/viewer/screensurface.js#L552
+    const bitSh = [1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0]
+    return (val[0] * bitSh[0] + val[1] * bitSh[1] + val[2] * bitSh[2] + val[3] * bitSh[3]) / 255.0
+}
+
+// https://stackoverflow.com/questions/11409895/whats-the-most-elegant-way-to-cap-a-number-to-a-segment
+export function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max)
+}
+
+// Internal function to compress drawing using run length encoding
+// inputs
+// data: Uint8Array to compress
+// output
+// returns rle compressed Uint8Array
+export function encodeRLE(data) {
+    // https://en.wikipedia.org/wiki/PackBits
+    // run length encoding
+    // input and output are Uint8Array
+    // Will compress data with long runs up to x64
+    // Worst case encoded size is ~1% larger than input
+    const dl = data.length // input length
+    let dp = 0 // input position
+    // worst case: run length encoding (1+1/127) times larger than input
+    const r = new Uint8Array(dl + Math.ceil(0.01 * dl))
+    const rI = new Int8Array(r.buffer) // typecast as header can be negative
+    let rp = 0 // run length position
+    while (dp < dl) {
+        // for each byte in input
+        let v = data[dp]
+        dp++
+        let rl = 1 // run length
+        while (rl < 129 && dp < dl && data[dp] === v) {
+            dp++
+            rl++
+        }
+        if (rl > 1) {
+            // header
+            rI[rp] = -rl + 1
+            rp++
+            r[rp] = v
+            rp++
+            continue
+        }
+        // count literal length
+        while (dp < dl) {
+            if (rl > 127) {
+                break
+            }
+            if (dp + 2 < dl) {
+                // console.log(':', v, data[dp], data[dp+1]);
+                if (v !== data[dp] && data[dp + 2] === data[dp] && data[dp + 1] === data[dp]) {
+                    break
+                }
+            }
+            v = data[dp]
+            dp++
+            rl++
+        }
+        // write header
+        r[rp] = rl - 1
+        rp++
+        for (let i = 0; i < rl; i++) {
+            r[rp] = data[dp - rl + i]
+            rp++
+        }
+    }
+    console.log('PackBits ' + dl + ' -> ' + rp + ' bytes (x' + dl / rp + ')')
+    return r.slice(0, rp)
+}
+
+// Internal function to decompress drawing using run length encoding
+// inputs
+// rle: packbits compressed stream
+// decodedlen: size of uncompressed data
+// output
+// returns Uint8Array of decodedlen bytes
+export function decodeRLE(rle, decodedlen) {
+    const r = new Uint8Array(rle.buffer)
+    const rI = new Int8Array(r.buffer) // typecast as header can be negative
+    let rp = 0 // input position in rle array
+    // d: output uncompressed data array
+    const d = new Uint8Array(decodedlen)
+    let dp = 0 // output position in decoded array
+    while (rp < r.length) {
+        // read header
+        const hdr = rI[rp]
+        rp++
+        if (hdr < 0) {
+            // write run
+            const v = rI[rp]
+            rp++
+            for (let i = 0; i < 1 - hdr; i++) {
+                d[dp] = v
+                dp++
+            }
+        } else {
+            // write literal
+            for (let i = 0; i < hdr + 1; i++) {
+                d[dp] = rI[rp]
+                rp++
+                dp++
+            }
+        }
+    }
+    return d
+}
+
+/**
+ * scale the raw intensity values by the header scale slope and intercept
+ * @param {object} hdr the header object
+ * @param {Array} raw the raw intensity values
+ * @returns {Array} the scaled intensity values
+ * @private
+ */
+export function intensityRaw2Scaled(hdr, raw) {
+    if (hdr.scl_slope === 0) {
+        hdr.scl_slope = 1.0
+    }
+    return raw * hdr.scl_slope + hdr.scl_inter
+}

package/dist/core/common/components/footer/Footer.d.ts

@@ -0,0 +1,3 @@
+import './Footer.scss';
+declare const FooterBar: () => import("react/jsx-runtime").JSX.Element;
+export default FooterBar;

package/dist/core/common/components/footer/Footer.js

@@ -0,0 +1,20 @@
+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 { jsxs as _jsxs } from "react/jsx-runtime";
+import './Footer.scss';
+import { Layout } from 'antd';
+var Footer = Layout.Footer;
+var FooterBar = function () {
+    var currentYear = new Date().getFullYear();
+    return (_jsxs(Footer, __assign({ className: 'cmr-footer', style: { textAlign: 'center', background: '#f8fafc' } }, { children: ["@ ", currentYear, " Copyright: NYU Center for Biomedical Imaging. All rights reserved."] })));
+};
+export default FooterBar;

package/dist/core/common/components/footer/Footer.scss

@@ -0,0 +1,5 @@
+.cmr-footer{
+  position: absolute;
+  bottom: 0;
+  width: 100%;
+}

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

@@ -0,0 +1,16 @@
+import { type AxiosRequestConfig, type AxiosResponse } from 'axios';
+import { AuthenticateState, AuthenticateToken } from '../../features/authenticate/authenticateSlice';
+type TokenGetter = () => AuthenticateState;
+export declare class AuthenticatedHttpClient {
+    private static authGetter;
+    private static dispatch;
+    static setAuthenticateStateGetter(getter: TokenGetter): void;
+    static setDispatch(dispatch: any): void;
+    static refreshToken(tk: AuthenticateToken): any;
+    static request<T = any>(config: AxiosRequestConfig): Promise<AxiosResponse<T>>;
+    static get<T = any>(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
+    static post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
+    static put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
+    static delete<T = any>(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
+}
+export {};

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

@@ -0,0 +1,158 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __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 { refreshAccessToken } from '../../features/authenticate/authenticateActionCreation';
+import { getAppConfig } from '../../config/AppConfig';
+var AuthenticatedHttpClient = /** @class */ (function () {
+    function AuthenticatedHttpClient() {
+    }
+    AuthenticatedHttpClient.setAuthenticateStateGetter = function (getter) {
+        this.authGetter = getter;
+    };
+    AuthenticatedHttpClient.setDispatch = function (dispatch) {
+        this.dispatch = dispatch;
+    };
+    AuthenticatedHttpClient.refreshToken = function (tk) {
+        return this.dispatch(refreshAccessToken(tk.refreshToken)).unwrap();
+    };
+    AuthenticatedHttpClient.request = function (config) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var appConfig, logged_in_token, requestConfig, error_1, error_2;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        appConfig = getAppConfig();
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 12, , 13]);
+                        logged_in_token = this.authGetter().logged_in_token;
+                        if (!logged_in_token) {
+                            throw Error("Not logged in!");
+                        }
+                        if (!((logged_in_token.parsedToken.exp - Math.floor(Date.now() / 1000)) < (60 * 15))) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.refreshToken(logged_in_token)];
+                    case 2:
+                        logged_in_token = _c.sent();
+                        _c.label = 3;
+                    case 3:
+                        if (!logged_in_token) {
+                            throw Error("Not logged in!");
+                        }
+                        requestConfig = __assign(__assign({ timeout: appConfig.REQUESTS_TIMEOUT }, config), { headers: __assign(__assign({}, config.headers), { 'Authorization': "Bearer ".concat(logged_in_token.idToken) }) });
+                        _c.label = 4;
+                    case 4:
+                        _c.trys.push([4, 6, , 11]);
+                        return [4 /*yield*/, axios.request(requestConfig)];
+                    case 5: return [2 /*return*/, _c.sent()];
+                    case 6:
+                        error_1 = _c.sent();
+                        if (!(((_a = error_1.response) === null || _a === void 0 ? void 0 : _a.status) === 401 || ((_b = error_1.response) === null || _b === void 0 ? void 0 : _b.status) === 403)) return [3 /*break*/, 9];
+                        return [4 /*yield*/, this.refreshToken(logged_in_token)];
+                    case 7:
+                        logged_in_token = _c.sent();
+                        if (!logged_in_token) {
+                            throw Error("Not logged in!");
+                        }
+                        // Retry the original request with the new token
+                        if (!requestConfig.headers)
+                            requestConfig.headers = {};
+                        requestConfig.headers['Authorization'] = "Bearer ".concat(logged_in_token.idToken);
+                        return [4 /*yield*/, axios.request(requestConfig)];
+                    case 8: return [2 /*return*/, _c.sent()];
+                    case 9: throw error_1;
+                    case 10: return [3 /*break*/, 11];
+                    case 11: return [3 /*break*/, 13];
+                    case 12:
+                        error_2 = _c.sent();
+                        console.error('Authenticated request failed:', error_2);
+                        throw error_2;
+                    case 13: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AuthenticatedHttpClient.get = function (url, config) {
+        if (config === void 0) { config = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var appConfig, requestConfig;
+            return __generator(this, function (_a) {
+                appConfig = getAppConfig();
+                requestConfig = __assign(__assign({}, config), { params: __assign(__assign({}, config.params), { "cloudapp_name": appConfig.APP_NAME }), method: 'GET', url: url });
+                return [2 /*return*/, this.request(requestConfig)];
+            });
+        });
+    };
+    AuthenticatedHttpClient.post = function (url, data, config) {
+        if (config === void 0) { config = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var appConfig, requestConfig;
+            return __generator(this, function (_a) {
+                appConfig = getAppConfig();
+                requestConfig = __assign(__assign({}, config), { method: 'post', url: url, data: __assign(__assign({}, data), { "cloudapp_name": appConfig.APP_NAME }) });
+                return [2 /*return*/, this.request(requestConfig)];
+            });
+        });
+    };
+    AuthenticatedHttpClient.put = function (url, data, config) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request(__assign(__assign({}, config), { method: 'PUT', url: url, data: data }))];
+            });
+        });
+    };
+    AuthenticatedHttpClient["delete"] = function (url, config) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request(__assign(__assign({}, config), { method: 'DELETE', url: url }))];
+            });
+        });
+    };
+    return AuthenticatedHttpClient;
+}());
+export { AuthenticatedHttpClient };

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

@@ -0,0 +1,5 @@
+/**
+ * Convert timestamp in ISO 8601 to local time
+ * @param timestamp
+ */
+export declare function convertTimestamp(timestamp: string): string;

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

@@ -0,0 +1,27 @@
+/**
+ * Convert timestamp in ISO 8601 to local time
+ * @param timestamp
+ */
+export function convertTimestamp(timestamp) {
+    try {
+        // Create a new Date object from the timestamp
+        var date = new Date(timestamp);
+        // Check if date is valid
+        if (isNaN(date.getTime())) {
+            return timestamp; // Return original if invalid
+        }
+        // Format the date and time
+        var year = date.getFullYear();
+        var month = String(date.getMonth() + 1).padStart(2, '0'); // Months are 0-indexed in JavaScript
+        var day = String(date.getDate()).padStart(2, '0');
+        var hours = String(date.getHours()).padStart(2, '0');
+        var minutes = String(date.getMinutes()).padStart(2, '0');
+        var seconds = String(date.getSeconds()).padStart(2, '0');
+        // Return the formatted string
+        return "".concat(year, "-").concat(month, "-").concat(day, " ").concat(hours, ":").concat(minutes, ":").concat(seconds);
+    }
+    catch (e) {
+        console.error('Error converting timestamp:', e);
+        return timestamp;
+    }
+}

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

@@ -0,0 +1,3 @@
+declare function downloadStringAsFile(content: string, fileName: string): void;
+export { downloadStringAsFile };
+export default downloadStringAsFile;

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

@@ -0,0 +1,20 @@
+function downloadStringAsFile(content, fileName) {
+    // Step 1: Create a Blob from the string
+    var blob = new Blob([content], { type: 'text/plain' });
+    // Step 2: Create a URL for the Blob
+    var url = URL.createObjectURL(blob);
+    // Step 3: Use an anchor element to initiate the download
+    var a = document.createElement('a');
+    a.href = url;
+    // Step 4: Set the download attribute of the anchor element
+    a.download = fileName;
+    // Append the anchor to the body (this is necessary for Firefox)
+    document.body.appendChild(a);
+    // Step 5: Simulate a click on the anchor element
+    a.click();
+    // Cleanup: Remove the anchor from the body and revoke the Blob URL
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+}
+export { downloadStringAsFile };
+export default downloadStringAsFile;

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

@@ -0,0 +1 @@
+export declare function createRequest(state: any): string;

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

@@ -0,0 +1,4 @@
+// This will be updated to work with the shared store type
+export function createRequest(state) {
+    return "{}";
+}

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

@@ -0,0 +1,4 @@
+import type { AxiosResponse } from "axios";
+export declare function getFileExtension(filename: string): string;
+export declare function formatBytes(bytes: number, decimals?: number): string;
+export declare const uploadHandlerFactory: (uploadToken: string, dispatch: any, uploader: any, uploadTarget?: string) => (file: File, fileAlias: string, fileDatabase?: string, onProgress?: ((progress: number) => void) | undefined, onUploaded?: ((res: AxiosResponse, file: File) => void) | undefined) => Promise<any>;

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

@@ -0,0 +1,79 @@
+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 };
+    }
+};
+// 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];
+}
+export var uploadHandlerFactory = function (uploadToken, dispatch, uploader, uploadTarget) {
+    return function (file, fileAlias, fileDatabase, onProgress, onUploaded) { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, dispatch(uploader({
+                        file: file,
+                        fileAlias: fileAlias,
+                        uploadToken: uploadToken,
+                        onProgress: onProgress,
+                        onUploaded: onUploaded,
+                        uploadTarget: uploadTarget
+                    }))];
+                case 1:
+                    result = _a.sent();
+                    return [2 /*return*/, result.payload.code];
+            }
+        });
+    }); };
+};

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

@@ -0,0 +1 @@
+export declare const is_safe_twix: (file: File) => Promise<boolean>;