@jbrowse/plugin-linear-comparative-view 3.6.4 → 3.7.0

package/esm/LinearSyntenyDisplay/drawSynteny.js

@@ -1,5 +1,7 @@
+import { category10 } from '@jbrowse/core/ui/colors';
 import { doesIntersect2, getContainingView } from '@jbrowse/core/util';
-import { draw, drawMatchSimple } from './components/util';
+import { colord } from '@jbrowse/core/util/colord';
+import { draw, drawLocationMarkers, drawMatchSimple } from './components/util';
 export const MAX_COLOR_RANGE = 255 * 255 * 255;
 function makeColor(idx) {
     const r = Math.floor(idx / (255 * 255)) % 255;
@@ -7,7 +9,20 @@ function makeColor(idx) {
     const b = idx % 255;
     return `rgb(${r},${g},${b})`;
 }
-const colorMap = {
+function hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash;
+    }
+    return Math.abs(hash);
+}
+function getQueryColor(queryName) {
+    const hash = hashString(queryName);
+    return category10[hash % category10.length];
+}
+const defaultCigarColors = {
     I: '#ff03',
     N: '#0a03',
     D: '#00f3',
@@ -15,13 +30,39 @@ const colorMap = {
     M: '#f003',
     '=': '#f003',
 };
+const strandCigarColors = {
+    I: '#ff03',
+    N: '#a020f0',
+    D: '#a020f0',
+    X: 'brown',
+    M: '#f003',
+    '=': '#f003',
+};
+const colorSchemes = {
+    default: {
+        cigarColors: defaultCigarColors,
+    },
+    strand: {
+        posColor: 'red',
+        negColor: 'blue',
+        cigarColors: strandCigarColors,
+    },
+    query: {
+        cigarColors: defaultCigarColors,
+    },
+};
+function applyAlpha(color, alpha) {
+    if (alpha === 1) {
+        return color;
+    }
+    return colord(color).alpha(alpha).toHex();
+}
 const lineLimit = 3;
 const oobLimit = 1600;
 export function getId(r, g, b, unitMultiplier) {
     return Math.floor((r * 255 * 255 + g * 255 + b - 1) / unitMultiplier);
 }
-export function drawRef(model, ctx1, ctx3) {
-    var _a;
+export function drawCigarClickMap(model, cigarClickMapCanvas) {
     const view = getContainingView(model);
     const drawCurves = view.drawCurves;
     const drawCIGAR = view.drawCIGAR;
@@ -29,55 +70,226 @@ export function drawRef(model, ctx1, ctx3) {
     const { level, height, featPositions } = model;
     const width = view.width;
     const bpPerPxs = view.views.map(v => v.bpPerPx);
-    if (ctx3) {
-        ctx3.imageSmoothingEnabled = false;
-    }
-    ctx1.beginPath();
+    cigarClickMapCanvas.imageSmoothingEnabled = false;
+    cigarClickMapCanvas.clearRect(0, 0, width, height);
     const offsets = view.views.map(v => v.offsetPx);
-    const unitMultiplier = Math.floor(MAX_COLOR_RANGE / featPositions.length);
-    ctx1.fillStyle = colorMap.M;
-    ctx1.strokeStyle = colorMap.M;
-    for (const { p11, p12, p21, p22 } of featPositions) {
+    const bpPerPxInv0 = 1 / bpPerPxs[level];
+    const bpPerPxInv1 = 1 / bpPerPxs[level + 1];
+    for (const { p11, p12, p21, p22, f, cigar } of featPositions) {
         const x11 = p11.offsetPx - offsets[level];
         const x12 = p12.offsetPx - offsets[level];
         const x21 = p21.offsetPx - offsets[level + 1];
         const x22 = p22.offsetPx - offsets[level + 1];
         const l1 = Math.abs(x12 - x11);
         const l2 = Math.abs(x22 - x21);
+        const minX = Math.min(x21, x22);
+        const maxX = Math.max(x21, x22);
         const y1 = 0;
         const y2 = height;
         const mid = (y2 - y1) / 2;
+        if (!(l1 <= lineLimit && l2 <= lineLimit) &&
+            doesIntersect2(minX, maxX, -oobLimit, view.width + oobLimit)) {
+            const s1 = f.get('strand');
+            const k1 = s1 === -1 ? x12 : x11;
+            const k2 = s1 === -1 ? x11 : x12;
+            const rev1 = k1 < k2 ? 1 : -1;
+            const rev2 = (x21 < x22 ? 1 : -1) * s1;
+            let cx1 = k1;
+            let cx2 = s1 === -1 ? x22 : x21;
+            if (cigar.length && drawCIGAR) {
+                let continuingFlag = false;
+                let px1 = 0;
+                let px2 = 0;
+                const unitMultiplier2 = Math.floor(MAX_COLOR_RANGE / cigar.length);
+                for (let j = 0; j < cigar.length; j += 2) {
+                    const len = +cigar[j];
+                    const op = cigar[j + 1];
+                    if (!continuingFlag) {
+                        px1 = cx1;
+                        px2 = cx2;
+                    }
+                    const d1 = len * bpPerPxInv0;
+                    const d2 = len * bpPerPxInv1;
+                    if (op === 'M' || op === '=' || op === 'X') {
+                        cx1 += d1 * rev1;
+                        cx2 += d2 * rev2;
+                    }
+                    else if (op === 'D' || op === 'N') {
+                        cx1 += d1 * rev1;
+                    }
+                    else if (op === 'I') {
+                        cx2 += d2 * rev2;
+                    }
+                    if (!(Math.max(px1, px2, cx1, cx2) < 0 ||
+                        Math.min(px1, px2, cx1, cx2) > width)) {
+                        const isNotLast = j < cigar.length - 2;
+                        if (Math.abs(cx1 - px1) <= 1 &&
+                            Math.abs(cx2 - px2) <= 1 &&
+                            isNotLast) {
+                            continuingFlag = true;
+                        }
+                        else {
+                            continuingFlag = false;
+                            const shouldDraw = !drawCIGARMatchesOnly ||
+                                ((op === 'M' || op === '=' || op === 'X') &&
+                                    Math.abs(cx1 - px1) > 1 &&
+                                    Math.abs(cx2 - px2) > 1);
+                            if (shouldDraw) {
+                                const idx = j * unitMultiplier2 + 1;
+                                cigarClickMapCanvas.fillStyle = makeColor(idx);
+                                draw(cigarClickMapCanvas, px1, cx1, y1, cx2, px2, y2, mid, drawCurves);
+                                cigarClickMapCanvas.fill();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+export function drawRef(model, mainCanvas) {
+    var _a;
+    const view = getContainingView(model);
+    const drawCurves = view.drawCurves;
+    const drawCIGAR = view.drawCIGAR;
+    const drawCIGARMatchesOnly = view.drawCIGARMatchesOnly;
+    const drawLocationMarkersEnabled = view.drawLocationMarkers;
+    const { level, height, featPositions, alpha, minAlignmentLength, colorBy } = model;
+    const width = view.width;
+    const bpPerPxs = view.views.map(v => v.bpPerPx);
+    const queryTotalLengths = new Map();
+    if (minAlignmentLength > 0) {
+        for (const { f } of featPositions) {
+            const queryName = f.get('name') || f.get('id') || f.id();
+            const alignmentLength = Math.abs(f.get('end') - f.get('start'));
+            const currentTotal = queryTotalLengths.get(queryName) || 0;
+            queryTotalLengths.set(queryName, currentTotal + alignmentLength);
+        }
+    }
+    const schemeConfig = colorSchemes[colorBy] || colorSchemes.default;
+    const activeColorMap = schemeConfig.cigarColors;
+    const posColor = colorBy === 'strand' ? colorSchemes.strand.posColor : 'red';
+    const negColor = colorBy === 'strand' ? colorSchemes.strand.negColor : 'blue';
+    const colorMapWithAlpha = {
+        I: applyAlpha(activeColorMap.I, alpha),
+        N: applyAlpha(activeColorMap.N, alpha),
+        D: applyAlpha(activeColorMap.D, alpha),
+        X: applyAlpha(activeColorMap.X, alpha),
+        M: applyAlpha(activeColorMap.M, alpha),
+        '=': applyAlpha(activeColorMap['='], alpha),
+    };
+    const posColorWithAlpha = applyAlpha(posColor, alpha);
+    const negColorWithAlpha = applyAlpha(negColor, alpha);
+    const queryColorCache = new Map();
+    const getQueryColorWithAlpha = (queryName) => {
+        if (!queryColorCache.has(queryName)) {
+            const color = getQueryColor(queryName);
+            queryColorCache.set(queryName, applyAlpha(color, alpha));
+        }
+        return queryColorCache.get(queryName);
+    };
+    mainCanvas.beginPath();
+    const offsets = view.views.map(v => v.offsetPx);
+    const offsetsL0 = offsets[level];
+    const offsetsL1 = offsets[level + 1];
+    const unitMultiplier = Math.floor(MAX_COLOR_RANGE / featPositions.length);
+    const y1 = 0;
+    const y2 = height;
+    const mid = (y2 - y1) / 2;
+    const useStrandColorThin = colorBy === 'strand';
+    const useQueryColorThin = colorBy === 'query';
+    mainCanvas.fillStyle = colorMapWithAlpha.M;
+    mainCanvas.strokeStyle = colorMapWithAlpha.M;
+    const thinLinesByColor = new Map();
+    for (const { p11, p12, p21, p22, f } of featPositions) {
+        if (minAlignmentLength > 0) {
+            const queryName = f.get('name') || f.get('id') || f.id();
+            const totalLength = queryTotalLengths.get(queryName) || 0;
+            if (totalLength < minAlignmentLength) {
+                continue;
+            }
+        }
+        const x11 = p11.offsetPx - offsetsL0;
+        const x12 = p12.offsetPx - offsetsL0;
+        const x21 = p21.offsetPx - offsetsL1;
+        const x22 = p22.offsetPx - offsetsL1;
+        const l1 = Math.abs(x12 - x11);
+        const l2 = Math.abs(x22 - x21);
         if (l1 <= lineLimit &&
             l2 <= lineLimit &&
             x21 < width + oobLimit &&
             x21 > -oobLimit) {
-            ctx1.moveTo(x11, y1);
-            if (drawCurves) {
-                ctx1.bezierCurveTo(x11, mid, x21, mid, x21, y2);
+            let colorKey = 'default';
+            if (useStrandColorThin) {
+                const strand = f.get('strand');
+                colorKey = strand === -1 ? 'neg' : 'pos';
             }
-            else {
-                ctx1.lineTo(x21, y2);
+            else if (useQueryColorThin) {
+                colorKey = f.get('refName');
+            }
+            if (!thinLinesByColor.has(colorKey)) {
+                thinLinesByColor.set(colorKey, []);
             }
+            thinLinesByColor.get(colorKey).push({ x11, x21, y1, y2, mid });
         }
     }
-    ctx1.stroke();
-    ctx1.fillStyle = colorMap.M;
-    ctx1.strokeStyle = colorMap.M;
+    for (const [colorKey, lines] of thinLinesByColor) {
+        if (colorKey === 'pos') {
+            mainCanvas.strokeStyle = posColorWithAlpha;
+        }
+        else if (colorKey === 'neg') {
+            mainCanvas.strokeStyle = negColorWithAlpha;
+        }
+        else if (colorKey !== 'default') {
+            mainCanvas.strokeStyle = getQueryColorWithAlpha(colorKey);
+        }
+        else {
+            mainCanvas.strokeStyle = colorMapWithAlpha.M;
+        }
+        mainCanvas.beginPath();
+        if (drawCurves) {
+            for (const { x11, x21, y1, y2, mid } of lines) {
+                mainCanvas.moveTo(x11, y1);
+                mainCanvas.bezierCurveTo(x11, mid, x21, mid, x21, y2);
+            }
+        }
+        else {
+            for (const { x11, x21, y1, y2 } of lines) {
+                mainCanvas.moveTo(x11, y1);
+                mainCanvas.lineTo(x21, y2);
+            }
+        }
+        mainCanvas.stroke();
+    }
+    const bpPerPx0 = bpPerPxs[level];
+    const bpPerPx1 = bpPerPxs[level + 1];
+    const bpPerPxInv0 = 1 / bpPerPx0;
+    const bpPerPxInv1 = 1 / bpPerPx1;
+    const useStrandColor = colorBy === 'strand';
+    const useQueryColor = colorBy === 'query';
+    mainCanvas.fillStyle = colorMapWithAlpha.M;
+    mainCanvas.strokeStyle = colorMapWithAlpha.M;
     for (const { p11, p12, p21, p22, f, cigar } of featPositions) {
-        const x11 = p11.offsetPx - offsets[level];
-        const x12 = p12.offsetPx - offsets[level];
-        const x21 = p21.offsetPx - offsets[level + 1];
-        const x22 = p22.offsetPx - offsets[level + 1];
+        const strand = f.get('strand');
+        const refName = f.get('refName');
+        if (minAlignmentLength > 0) {
+            const queryName = f.get('name') || f.get('id') || f.id();
+            const totalLength = queryTotalLengths.get(queryName) || 0;
+            if (totalLength < minAlignmentLength) {
+                continue;
+            }
+        }
+        const x11 = p11.offsetPx - offsetsL0;
+        const x12 = p12.offsetPx - offsetsL0;
+        const x21 = p21.offsetPx - offsetsL1;
+        const x22 = p22.offsetPx - offsetsL1;
         const l1 = Math.abs(x12 - x11);
         const l2 = Math.abs(x22 - x21);
         const minX = Math.min(x21, x22);
         const maxX = Math.max(x21, x22);
-        const y1 = 0;
-        const y2 = height;
-        const mid = (y2 - y1) / 2;
         if (!(l1 <= lineLimit && l2 <= lineLimit) &&
             doesIntersect2(minX, maxX, -oobLimit, view.width + oobLimit)) {
-            const s1 = f.get('strand');
+            const s1 = strand;
             const k1 = s1 === -1 ? x12 : x11;
             const k2 = s1 === -1 ? x11 : x12;
             const rev1 = k1 < k2 ? 1 : -1;
@@ -88,17 +300,15 @@ export function drawRef(model, ctx1, ctx3) {
                 let continuingFlag = false;
                 let px1 = 0;
                 let px2 = 0;
-                const unitMultiplier2 = Math.floor(MAX_COLOR_RANGE / cigar.length);
                 for (let j = 0; j < cigar.length; j += 2) {
-                    const idx = j * unitMultiplier2 + 1;
                     const len = +cigar[j];
                     const op = cigar[j + 1];
                     if (!continuingFlag) {
                         px1 = cx1;
                         px2 = cx2;
                     }
-                    const d1 = len / bpPerPxs[level];
-                    const d2 = len / bpPerPxs[level + 1];
+                    const d1 = len * bpPerPxInv0;
+                    const d2 = len * bpPerPxInv1;
                     if (op === 'M' || op === '=' || op === 'X') {
                         cx1 += d1 * rev1;
                         cx2 += d2 * rev2;
@@ -119,30 +329,51 @@ export function drawRef(model, ctx1, ctx3) {
                         }
                         else {
                             const letter = (continuingFlag && d1 > 1) || d2 > 1 ? op : 'M';
-                            ctx1.fillStyle = colorMap[letter];
+                            const isInsertionOrDeletion = letter === 'I' || letter === 'D' || letter === 'N';
+                            if (useStrandColor && !isInsertionOrDeletion) {
+                                mainCanvas.fillStyle =
+                                    strand === -1 ? negColorWithAlpha : posColorWithAlpha;
+                            }
+                            else if (useQueryColor && !isInsertionOrDeletion) {
+                                mainCanvas.fillStyle = getQueryColorWithAlpha(refName);
+                            }
+                            else {
+                                mainCanvas.fillStyle = colorMapWithAlpha[letter];
+                            }
                             continuingFlag = false;
                             if (drawCIGARMatchesOnly) {
                                 if (letter === 'M') {
-                                    draw(ctx1, px1, cx1, y1, cx2, px2, y2, mid, drawCurves);
-                                    ctx1.fill();
+                                    draw(mainCanvas, px1, cx1, y1, cx2, px2, y2, mid, drawCurves);
+                                    mainCanvas.fill();
+                                    if (drawLocationMarkersEnabled) {
+                                        drawLocationMarkers(mainCanvas, px1, cx1, y1, cx2, px2, y2, mid, bpPerPx0, bpPerPx1, drawCurves);
+                                    }
                                 }
                             }
                             else {
-                                draw(ctx1, px1, cx1, y1, cx2, px2, y2, mid, drawCurves);
-                                ctx1.fill();
-                            }
-                            if (ctx3) {
-                                ctx3.fillStyle = makeColor(idx);
-                                draw(ctx3, px1, cx1, y1, cx2, px2, y2, mid, drawCurves);
-                                ctx3.fill();
+                                draw(mainCanvas, px1, cx1, y1, cx2, px2, y2, mid, drawCurves);
+                                mainCanvas.fill();
+                                if (drawLocationMarkersEnabled) {
+                                    drawLocationMarkers(mainCanvas, px1, cx1, y1, cx2, px2, y2, mid, bpPerPx0, bpPerPx1, drawCurves);
+                                }
                             }
                         }
                     }
                 }
             }
             else {
-                draw(ctx1, x11, x12, y1, x22, x21, y2, mid, drawCurves);
-                ctx1.fill();
+                if (useStrandColor) {
+                    mainCanvas.fillStyle =
+                        strand === -1 ? negColorWithAlpha : posColorWithAlpha;
+                }
+                else if (useQueryColor) {
+                    mainCanvas.fillStyle = getQueryColorWithAlpha(refName);
+                }
+                draw(mainCanvas, x11, x12, y1, x22, x21, y2, mid, drawCurves);
+                mainCanvas.fill();
+                if (useStrandColor || useQueryColor) {
+                    mainCanvas.fillStyle = colorMapWithAlpha.M;
+                }
             }
         }
     }
@@ -154,6 +385,13 @@ export function drawRef(model, ctx1, ctx3) {
     ctx2.clearRect(0, 0, width, height);
     for (let i = 0; i < featPositions.length; i++) {
         const feature = featPositions[i];
+        if (minAlignmentLength > 0) {
+            const queryName = feature.f.get('name') || feature.f.get('id') || feature.f.id();
+            const totalLength = queryTotalLengths.get(queryName) || 0;
+            if (totalLength < minAlignmentLength) {
+                continue;
+            }
+        }
         const idx = i * unitMultiplier + 1;
         ctx2.fillStyle = makeColor(idx);
         drawMatchSimple({
@@ -172,7 +410,7 @@ export function drawRef(model, ctx1, ctx3) {
         });
     }
 }
-export function drawMouseoverSynteny(model) {
+export function drawMouseoverClickMap(model) {
     var _a;
     const { level, clickId, mouseoverId } = model;
     const highResolutionScaling = 1;

package/esm/LinearSyntenyDisplay/model.d.ts

@@ -22,6 +22,7 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
 } & {
     type: import("mobx-state-tree").ISimpleType<"LinearSyntenyDisplay">;
     configuration: AnyConfigurationSchemaType;
+    colorBy: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
 }, {
     rendererTypeName: string;
     error: unknown;
@@ -260,6 +261,8 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
     mouseoverId: string | undefined;
     clickId: string | undefined;
     cigarMouseoverId: number;
+    alpha: number;
+    minAlignmentLength: number;
 } & {
     setFeatPositions(arg: FeatPos[]): void;
     setMainCanvasRef(ref: HTMLCanvasElement | null): void;
@@ -269,6 +272,9 @@ declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): im
     setMouseoverId(arg?: string): void;
     setCigarMouseoverId(arg: number): void;
     setClickId(arg?: string): void;
+    setAlpha(value: number): void;
+    setMinAlignmentLength(value: number): void;
+    setColorBy(value: string): void;
 } & {
     readonly adapterConfig: any;
     readonly trackIds: string[];

package/esm/LinearSyntenyDisplay/model.js

@@ -6,6 +6,7 @@ function stateModelFactory(configSchema) {
         .compose('LinearSyntenyDisplay', baseModelFactory(configSchema), types.model({
         type: types.literal('LinearSyntenyDisplay'),
         configuration: ConfigurationReference(configSchema),
+        colorBy: types.optional(types.string, 'default'),
     }))
         .volatile(() => ({
         mainCanvas: null,
@@ -16,6 +17,8 @@ function stateModelFactory(configSchema) {
         mouseoverId: undefined,
         clickId: undefined,
         cigarMouseoverId: -1,
+        alpha: 0.2,
+        minAlignmentLength: 0,
     }))
         .actions(self => ({
         setFeatPositions(arg) {
@@ -42,6 +45,15 @@ function stateModelFactory(configSchema) {
         setClickId(arg) {
             self.clickId = arg;
         },
+        setAlpha(value) {
+            self.alpha = value;
+        },
+        setMinAlignmentLength(value) {
+            self.minAlignmentLength = value;
+        },
+        setColorBy(value) {
+            self.colorBy = value;
+        },
     }))
         .views(self => ({
         get adapterConfig() {

package/esm/LinearSyntenyView/components/DiagonalizationProgressDialog.d.ts

@@ -0,0 +1,6 @@
+import type { LinearSyntenyViewModel } from '../model';
+declare const DiagonalizationProgressDialog: ({ handleClose, model, }: {
+    handleClose: () => void;
+    model: LinearSyntenyViewModel;
+}) => import("react/jsx-runtime").JSX.Element;
+export default DiagonalizationProgressDialog;

package/esm/LinearSyntenyView/components/DiagonalizationProgressDialog.js

@@ -0,0 +1,85 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Dialog } from '@jbrowse/core/ui';
+import { getSession } from '@jbrowse/core/util';
+import { Button, DialogActions, DialogContent, LinearProgress, Typography, } from '@mui/material';
+import { transaction } from 'mobx';
+import { observer } from 'mobx-react';
+import { diagonalizeRegions } from '../util/diagonalize';
+const DiagonalizationProgressDialog = observer(function ({ handleClose, model, }) {
+    const [progress, setProgress] = useState(0);
+    const [message, setMessage] = useState('Initializing...');
+    const [error, setError] = useState();
+    useEffect(() => {
+        const runDiagonalization = async () => {
+            const session = getSession(model);
+            try {
+                if (model.views.length !== 2) {
+                    setError('Diagonalization requires exactly 2 views');
+                    setProgress(100);
+                    session.notify('Diagonalization requires exactly 2 views', 'warning');
+                    return;
+                }
+                const queryView = model.views[1];
+                setProgress(5);
+                setMessage('Collecting alignment data...');
+                const alignments = [];
+                for (const level of model.levels) {
+                    for (const track of level.tracks) {
+                        for (const display of track.displays) {
+                            const { featPositions } = display;
+                            for (const { f } of featPositions) {
+                                const mate = f.get('mate');
+                                alignments.push({
+                                    queryRefName: f.get('refName'),
+                                    refRefName: mate.refName,
+                                    queryStart: f.get('start'),
+                                    queryEnd: f.get('end'),
+                                    refStart: mate.start,
+                                    refEnd: mate.end,
+                                    strand: f.get('strand') || 1,
+                                });
+                            }
+                        }
+                    }
+                }
+                if (alignments.length === 0) {
+                    setError('No alignments found');
+                    setProgress(100);
+                    session.notify('No alignments found to diagonalize', 'warning');
+                    return;
+                }
+                const result = await diagonalizeRegions(alignments, queryView.displayedRegions, async (prog, msg) => {
+                    setProgress(prog);
+                    setMessage(msg);
+                });
+                if (result.newRegions.length > 0) {
+                    setProgress(95);
+                    setMessage('Applying new layout...');
+                    transaction(() => {
+                        queryView.setDisplayedRegions(result.newRegions);
+                    });
+                    setProgress(100);
+                    setMessage('Diagonalization complete');
+                    setTimeout(() => {
+                        handleClose();
+                    }, 1500);
+                }
+                else {
+                    setError('No regions to reorder');
+                    setProgress(100);
+                    session.notify('No query regions found to reorder', 'warning');
+                }
+            }
+            catch (err) {
+                console.error('Diagonalization error:', err);
+                setError(`Error: ${err}`);
+                setProgress(100);
+                session.notify(`Diagonalization failed: ${err}`, 'error');
+            }
+        };
+        runDiagonalization();
+    }, [model, handleClose]);
+    return (_jsxs(Dialog, { open: true, title: "Diagonalizing", onClose: handleClose, children: [_jsxs(DialogContent, { style: { minWidth: 400 }, children: [_jsx(Typography, { variant: "body1", gutterBottom: true, color: error ? 'error' : 'inherit', children: error || message }), _jsx(LinearProgress, { variant: "determinate", value: progress, style: { marginTop: 16 }, color: error ? 'error' : 'primary' }), _jsxs(Typography, { variant: "caption", color: "textSecondary", style: { marginTop: 8, display: 'block' }, children: [Math.round(progress), "% complete"] })] }), _jsx(DialogActions, { children: _jsx(Button, { onClick: handleClose, color: "primary", disabled: progress < 100, children: progress < 100 ? 'Processing...' : 'Done' }) })] }));
+});
+export default DiagonalizationProgressDialog;