@datagrok-libraries/statistics 1.7.0 → 1.8.0

package/package.json

@@ -4,24 +4,27 @@
     "access": "public"
   },
   "friendlyName": "statistics",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Statistics utilities",
   "author": {
     "name": "Dmytro Kovalyov",
     "email": "dkovalyov@datagrok.ai"
   },
   "dependencies": {
-    "@datagrok-libraries/utils": "^4.3.0",
+    "@datagrok-libraries/utils": "^4.5.7",
+    "@types/seedrandom": "^3.0.8",
     "cash-dom": "^8.0.0",
     "datagrok-api": "^1.20.0",
     "dayjs": "^1.11.7",
     "jstat": "^1.9.6",
-    "seedrandom": "^3.0.5",
-    "@types/seedrandom": "^3.0.8"
+    "konva": "^9.3.20",
+    "rxjs": "^6.5.5",
+    "seedrandom": "^3.0.5"
   },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^8.8.1",
     "@typescript-eslint/parser": "^8.8.1",
+    "datagrok-tools": "^4.14.20",
     "eslint": "^8.57.1",
     "eslint-config-google": "^0.14.0",
     "ts-loader": "^9.2.6",
@@ -35,9 +38,9 @@
     "debug-statistics": "grok publish",
     "release-statistics": "grok publish --release",
     "build-statistics": "tsc",
-    "build": "tsc",
+    "build": "grok check --soft && tsc",
     "lint": "eslint src --ext .ts",
     "lint-fix": "eslint src --ext .ts --fix",
     "build-all": "npm --prefix ./../../js-api run build && npm --prefix ./../../libraries/utils run build && npm run build"
   }
-}
+}

package/src/mpo/mpo-line-editor.d.ts

@@ -0,0 +1,10 @@
+import { DesirabilityLine, PropertyDesirability } from './mpo';
+import { Subject } from 'rxjs';
+export declare class MpoDesirabilityLineEditor {
+    root: HTMLDivElement;
+    onChanged: Subject<unknown>;
+    private _prop;
+    constructor(prop: PropertyDesirability, width: number, height: number);
+    get line(): DesirabilityLine;
+}
+//# sourceMappingURL=mpo-line-editor.d.ts.map

package/src/mpo/mpo-line-editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mpo-line-editor.d.ts","sourceRoot":"","sources":["mpo-line-editor.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,gBAAgB,EAAE,oBAAoB,EAAC,MAAM,OAAO,CAAC;AAC7D,OAAO,EAAC,OAAO,EAAC,MAAM,MAAM,CAAC;AAO7B,qBAAa,yBAAyB;IACpC,IAAI,iBAAY;IAChB,SAAS,mBAAiB;IAC1B,OAAO,CAAC,KAAK,CAAuB;gBAExB,IAAI,EAAE,oBAAoB,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IA6PrE,IAAI,IAAI,IAAI,gBAAgB,CAE3B;CACF"}

package/src/mpo/mpo-line-editor.js

@@ -0,0 +1,258 @@
+/* eslint-disable max-len */
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import Konva from 'konva';
+import { Subject } from 'rxjs'; // Import type from mpo.ts
+// Constants for the editor layout
+const EDITOR_PADDING = { top: 10, right: 10, bottom: 20, left: 30 };
+const POINT_RADIUS = 3;
+export class MpoDesirabilityLineEditor {
+    constructor(prop, width, height) {
+        this.root = ui.div();
+        this.onChanged = new Subject();
+        this._prop = prop;
+        this.root.style.width = `${width}px`;
+        this.root.style.height = `${height}px`;
+        this.root.style.position = 'relative'; // Needed for absolute positioning of Konva stage
+        const that = this;
+        // Delay Konva initialization slightly to ensure this.container is in DOM
+        setTimeout(() => {
+            var _a, _b;
+            if (!this.root.parentElement) {
+                console.warn('Konva this.container not attached to DOM yet.');
+                // Optionally, retry or handle error
+                return;
+            }
+            const stage = new Konva.Stage({
+                container: this.root,
+                width: width,
+                height: height,
+            });
+            const layer = new Konva.Layer();
+            stage.add(layer);
+            const minX = (_a = prop.min) !== null && _a !== void 0 ? _a : Math.min(...prop.line.map((p) => p[0]));
+            const maxX = (_b = prop.max) !== null && _b !== void 0 ? _b : Math.max(...prop.line.map((p) => p[0]));
+            // --- Draw Axes ---
+            const xAxis = new Konva.Line({
+                points: [EDITOR_PADDING.left, height - EDITOR_PADDING.bottom, width - EDITOR_PADDING.right, height - EDITOR_PADDING.bottom],
+                stroke: 'grey',
+                strokeWidth: 1,
+            });
+            const yAxis = new Konva.Line({
+                points: [EDITOR_PADDING.left, EDITOR_PADDING.top, EDITOR_PADDING.left, height - EDITOR_PADDING.bottom],
+                stroke: 'grey',
+                strokeWidth: 1,
+            });
+            layer.add(xAxis, yAxis);
+            // --- Draw Axis Labels/Ticks (Simplified) ---
+            const minXLabel = new Konva.Text({
+                x: EDITOR_PADDING.left,
+                y: height - EDITOR_PADDING.bottom + 3,
+                text: minX.toFixed(1),
+                fontSize: 9,
+                fill: 'grey',
+            });
+            const maxXLabel = new Konva.Text({
+                x: width - EDITOR_PADDING.right - 15,
+                y: height - EDITOR_PADDING.bottom + 3,
+                text: maxX.toFixed(1),
+                fontSize: 9,
+                align: 'right',
+                fill: 'grey',
+            });
+            const zeroYLabel = new Konva.Text({
+                x: EDITOR_PADDING.left - 20,
+                y: height - EDITOR_PADDING.bottom - 5,
+                text: '0.0',
+                fontSize: 9,
+                fill: 'grey',
+            });
+            const oneYLabel = new Konva.Text({
+                x: EDITOR_PADDING.left - 20,
+                y: EDITOR_PADDING.top - 5,
+                text: '1.0',
+                fontSize: 9,
+                fill: 'grey',
+            });
+            layer.add(minXLabel, maxXLabel, zeroYLabel, oneYLabel);
+            // --- Draw Line and Points ---
+            const konvaLine = new Konva.Line({
+                points: [],
+                stroke: '#2077b4',
+                strokeWidth: 2,
+                lineCap: 'round',
+                lineJoin: 'round',
+            });
+            layer.add(konvaLine);
+            const pointsGroup = new Konva.Group(); // Group for draggable points
+            layer.add(pointsGroup);
+            // Function to redraw everything based on prop.line
+            function redraw(notify = true) {
+                pointsGroup.destroyChildren(); // Clear old points
+                const konvaPoints = [];
+                prop.line.sort((a, b) => a[0] - b[0]); // Ensure sorted
+                prop.line.forEach((p, index) => {
+                    const coords = toCanvasCoords(p[0], p[1], minX, maxX, width, height);
+                    konvaPoints.push(coords.x, coords.y);
+                    const pointCircle = new Konva.Circle({
+                        x: coords.x,
+                        y: coords.y,
+                        radius: POINT_RADIUS,
+                        fill: '#d72f30',
+                        stroke: 'black',
+                        strokeWidth: 1,
+                        draggable: true,
+                        hitStrokeWidth: 5, // Easier to hit for dragging/clicking
+                    });
+                    // Store index directly on the node for easy access
+                    pointCircle.setAttr('_pointIndex', index);
+                    // --- Dragging Logic ---
+                    pointCircle.on('dragmove', (evt) => {
+                        const circle = evt.target;
+                        const pos = circle.position();
+                        const currentPointIndex = circle.getAttr('_pointIndex');
+                        // Constrain dragging horizontally between neighbors (or bounds)
+                        const prevX = currentPointIndex > 0 ? prop.line[currentPointIndex - 1][0] : minX;
+                        const nextX = currentPointIndex < prop.line.length - 1 ? prop.line[currentPointIndex + 1][0] : maxX;
+                        // Add a small buffer to avoid points overlapping exactly
+                        const buffer = (maxX - minX === 0) ? 0 : 0.001 * (maxX - minX); // Avoid NaN if minX === maxX
+                        const minCanvasX = toCanvasCoords(prevX + (currentPointIndex > 0 ? buffer : 0), 0, minX, maxX, width, height).x;
+                        const maxCanvasX = toCanvasCoords(nextX - (currentPointIndex < prop.line.length - 1 ? buffer : 0), 0, minX, maxX, width, height).x;
+                        pos.x = Math.max(minCanvasX, Math.min(maxCanvasX, pos.x));
+                        // Constrain dragging vertically
+                        const plotTop = EDITOR_PADDING.top;
+                        const plotBottom = height - EDITOR_PADDING.bottom;
+                        pos.y = Math.max(plotTop, Math.min(plotBottom, pos.y));
+                        circle.position(pos); // Update position after constraints
+                        // Update data array
+                        const dataCoords = toDataCoords(pos.x, pos.y, minX, maxX, width, height);
+                        prop.line[currentPointIndex][0] = dataCoords.x;
+                        prop.line[currentPointIndex][1] = dataCoords.y;
+                        // Update the connecting line during drag
+                        const currentKonvaPoints = prop.line.map((pData, idx) => {
+                            // Use dragged circle position directly for the point being dragged
+                            if (idx === currentPointIndex)
+                                return [pos.x, pos.y];
+                            else {
+                                const c = toCanvasCoords(pData[0], pData[1], minX, maxX, width, height);
+                                return [c.x, c.y];
+                            }
+                        }).flat();
+                        konvaLine.points(currentKonvaPoints);
+                        layer.batchDraw(); // More efficient redraw
+                    });
+                    pointCircle.on('dragend', (evt) => {
+                        // Ensure data is sorted after drag, although constraints should handle it
+                        prop.line.sort((a, b) => a[0] - b[0]);
+                        redraw(); // Full redraw on drag end to fix indices and line path
+                    });
+                    // --- Right-click to Remove ---
+                    pointCircle.on('contextmenu', (evt) => {
+                        evt.evt.preventDefault(); // Prevent browser context menu
+                        // Keep at least 2 points for a line segment
+                        if (prop.line.length <= 2) {
+                            // Use DG tooltip or simple alert/warning
+                            grok.shell.warning('Cannot remove points, minimum of 2 required.');
+                            return;
+                        }
+                        const circle = evt.target;
+                        const indexToRemove = circle.getAttr('_pointIndex');
+                        prop.line.splice(indexToRemove, 1);
+                        redraw(); // Redraw after removal
+                    });
+                    // Enhance usability: change cursor on hover and show tooltip
+                    pointCircle.on('mouseenter', (evt) => {
+                        stage.container().style.cursor = 'pointer';
+                        const circle = evt.target;
+                        const pos = circle.position();
+                        const dataCoords = toDataCoords(pos.x, pos.y, minX, maxX, width, height);
+                        const tooltipText = `X: ${dataCoords.x.toFixed(2)}, Y: ${dataCoords.y.toFixed(2)}<br><br>Drag to move, right-click to delete`;
+                        ui.tooltip.show(tooltipText, evt.evt.clientX, evt.evt.clientY);
+                    });
+                    pointCircle.on('mouseleave', (evt) => {
+                        stage.container().style.cursor = 'default';
+                        ui.tooltip.hide();
+                    });
+                    pointsGroup.add(pointCircle);
+                });
+                konvaLine.points(konvaPoints);
+                layer.batchDraw();
+                if (notify)
+                    that.onChanged.next();
+            }
+            // --- Left-click to Add Point ---
+            stage.on('click tap', (evt) => {
+                // Ignore clicks on existing points (circles) or non-left clicks
+                if (evt.target instanceof Konva.Circle || evt.evt.button !== 0)
+                    return;
+                const pos = stage.getPointerPosition();
+                if (!pos)
+                    return;
+                // Ensure click is within the plot area boundaries
+                if (pos.x < EDITOR_PADDING.left || pos.x > width - EDITOR_PADDING.right ||
+                    pos.y < EDITOR_PADDING.top || pos.y > height - EDITOR_PADDING.bottom)
+                    return;
+                const dataCoords = toDataCoords(pos.x, pos.y, minX, maxX, width, height);
+                // Add the new point
+                prop.line.push([dataCoords.x, dataCoords.y]);
+                // No need to sort here, redraw() handles sorting
+                redraw();
+            });
+            // Change cursor when over the stage plot area for adding points
+            stage.on('mouseenter', (evt) => {
+                if (!(evt.target instanceof Konva.Circle)) {
+                    const pos = stage.getPointerPosition();
+                    if (pos && pos.x >= EDITOR_PADDING.left && pos.x <= width - EDITOR_PADDING.right &&
+                        pos.y >= EDITOR_PADDING.top && pos.y <= height - EDITOR_PADDING.bottom)
+                        stage.container().style.cursor = 'crosshair';
+                }
+            });
+            stage.on('mouseleave', (evt) => {
+                if (!(evt.target instanceof Konva.Circle))
+                    stage.container().style.cursor = 'default';
+            });
+            stage.on('mousemove', (evt) => {
+                if (!(evt.target instanceof Konva.Circle)) {
+                    const pos = stage.getPointerPosition();
+                    if (pos && pos.x >= EDITOR_PADDING.left && pos.x <= width - EDITOR_PADDING.right &&
+                        pos.y >= EDITOR_PADDING.top && pos.y <= height - EDITOR_PADDING.bottom)
+                        stage.container().style.cursor = 'crosshair';
+                    else
+                        stage.container().style.cursor = 'default';
+                }
+            });
+            stage.on('mouseout', (_) => ui.tooltip.hide());
+            // Initial draw
+            redraw(false);
+        }, 0);
+    }
+    get line() {
+        return this._prop.line;
+    }
+}
+// Function to transform data coordinates to canvas coordinates
+function toCanvasCoords(x, y, minX, maxX, width, height) {
+    const plotWidth = width - EDITOR_PADDING.left - EDITOR_PADDING.right;
+    const plotHeight = height - EDITOR_PADDING.top - EDITOR_PADDING.bottom;
+    // Handle case where minX === maxX to avoid division by zero
+    const scaleX = (maxX - minX === 0) ? 1 : plotWidth / (maxX - minX);
+    const scaleY = plotHeight; // y data is 0-1
+    const canvasX = EDITOR_PADDING.left + (x - minX) * scaleX;
+    const canvasY = EDITOR_PADDING.top + plotHeight - (y * scaleY); // Flip y-axis
+    return { x: canvasX, y: canvasY };
+}
+// Function to transform canvas coordinates to data coordinates
+function toDataCoords(canvasX, canvasY, minX, maxX, width, height) {
+    const plotWidth = width - EDITOR_PADDING.left - EDITOR_PADDING.right;
+    const plotHeight = height - EDITOR_PADDING.top - EDITOR_PADDING.bottom;
+    // Handle case where minX === maxX
+    const scaleX = (maxX - minX === 0) ? 1 : plotWidth / (maxX - minX);
+    const scaleY = plotHeight;
+    let dataX = minX + (canvasX - EDITOR_PADDING.left) / scaleX;
+    let dataY = (EDITOR_PADDING.top + plotHeight - canvasY) / scaleY;
+    // Clamp values
+    dataX = Math.max(minX, Math.min(maxX, dataX));
+    dataY = Math.max(0, Math.min(1, dataY));
+    return { x: dataX, y: dataY };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mpo-line-editor.js","sourceRoot":"","sources":["mpo-line-editor.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\n\nimport Konva from 'konva';\nimport {DesirabilityLine, PropertyDesirability} from './mpo';\nimport {Subject} from 'rxjs'; // Import type from mpo.ts\n\n// Constants for the editor layout\nconst EDITOR_PADDING = {top: 10, right: 10, bottom: 20, left: 30};\nconst POINT_RADIUS = 3;\n\n\nexport class MpoDesirabilityLineEditor {\n  root = ui.div();\n  onChanged = new Subject();\n  private _prop: PropertyDesirability;\n\n  constructor(prop: PropertyDesirability, width: number, height: number) {\n    this._prop = prop;\n    this.root.style.width = `${width}px`;\n    this.root.style.height = `${height}px`;\n    this.root.style.position = 'relative'; // Needed for absolute positioning of Konva stage\n    const that = this;\n\n    // Delay Konva initialization slightly to ensure this.container is in DOM\n    setTimeout(() => {\n      if (!this.root.parentElement) {\n        console.warn('Konva this.container not attached to DOM yet.');\n        // Optionally, retry or handle error\n        return;\n      }\n\n      const stage = new Konva.Stage({\n        container: this.root, // Use the this.container div\n        width: width,\n        height: height,\n      });\n\n      const layer = new Konva.Layer();\n      stage.add(layer);\n\n      const minX = prop.min ?? Math.min(...prop.line.map((p) => p[0]));\n      const maxX = prop.max ?? Math.max(...prop.line.map((p) => p[0]));\n\n      // --- Draw Axes ---\n      const xAxis = new Konva.Line({\n        points: [EDITOR_PADDING.left, height - EDITOR_PADDING.bottom, width - EDITOR_PADDING.right, height - EDITOR_PADDING.bottom],\n        stroke: 'grey', // Lighter color for axes\n        strokeWidth: 1,\n      });\n      const yAxis = new Konva.Line({\n        points: [EDITOR_PADDING.left, EDITOR_PADDING.top, EDITOR_PADDING.left, height - EDITOR_PADDING.bottom],\n        stroke: 'grey', // Lighter color for axes\n        strokeWidth: 1,\n      });\n      layer.add(xAxis, yAxis);\n\n      // --- Draw Axis Labels/Ticks (Simplified) ---\n      const minXLabel = new Konva.Text({\n        x: EDITOR_PADDING.left,\n        y: height - EDITOR_PADDING.bottom + 3, // Below axis\n        text: minX.toFixed(1), // Fewer decimals for smaller space\n        fontSize: 9,\n        fill: 'grey',\n      });\n      const maxXLabel = new Konva.Text({\n        x: width - EDITOR_PADDING.right - 15, // Adjust position\n        y: height - EDITOR_PADDING.bottom + 3, // Below axis\n        text: maxX.toFixed(1), // Fewer decimals\n        fontSize: 9,\n        align: 'right',\n        fill: 'grey',\n      });\n      const zeroYLabel = new Konva.Text({\n        x: EDITOR_PADDING.left - 20, // Left of axis\n        y: height - EDITOR_PADDING.bottom - 5, // Align with axis bottom\n        text: '0.0',\n        fontSize: 9,\n        fill: 'grey',\n      });\n      const oneYLabel = new Konva.Text({\n        x: EDITOR_PADDING.left - 20, // Left of axis\n        y: EDITOR_PADDING.top - 5, // Align with axis top\n        text: '1.0',\n        fontSize: 9,\n        fill: 'grey',\n      });\n      layer.add(minXLabel, maxXLabel, zeroYLabel, oneYLabel);\n\n\n      // --- Draw Line and Points ---\n      const konvaLine = new Konva.Line({\n        points: [], // Will be populated by points\n        stroke: '#2077b4',\n        strokeWidth: 2,\n        lineCap: 'round',\n        lineJoin: 'round',\n      });\n      layer.add(konvaLine);\n\n      const pointsGroup = new Konva.Group(); // Group for draggable points\n      layer.add(pointsGroup);\n\n      // Function to redraw everything based on prop.line\n      function redraw(notify: boolean = true) {\n        pointsGroup.destroyChildren(); // Clear old points\n        const konvaPoints: number[] = [];\n\n        prop.line.sort((a, b) => a[0] - b[0]); // Ensure sorted\n\n        prop.line.forEach((p, index) => {\n          const coords = toCanvasCoords(p[0], p[1], minX, maxX, width, height);\n          konvaPoints.push(coords.x, coords.y);\n\n          const pointCircle = new Konva.Circle({\n            x: coords.x,\n            y: coords.y,\n            radius: POINT_RADIUS,\n            fill: '#d72f30',\n            stroke: 'black',\n            strokeWidth: 1,\n            draggable: true, // Make points draggable\n            hitStrokeWidth: 5, // Easier to hit for dragging/clicking\n          });\n          // Store index directly on the node for easy access\n          pointCircle.setAttr('_pointIndex', index);\n\n          // --- Dragging Logic ---\n          pointCircle.on('dragmove', (evt: Konva.KonvaEventObject<DragEvent>) => {\n            const circle = evt.target as Konva.Circle;\n            const pos = circle.position();\n            const currentPointIndex = circle.getAttr('_pointIndex');\n\n            // Constrain dragging horizontally between neighbors (or bounds)\n            const prevX = currentPointIndex > 0 ? prop.line[currentPointIndex - 1][0] : minX;\n            const nextX = currentPointIndex < prop.line.length - 1 ? prop.line[currentPointIndex + 1][0] : maxX;\n            // Add a small buffer to avoid points overlapping exactly\n            const buffer = (maxX - minX === 0) ? 0 : 0.001 * (maxX - minX); // Avoid NaN if minX === maxX\n            const minCanvasX = toCanvasCoords(prevX + (currentPointIndex > 0 ? buffer : 0), 0, minX, maxX, width, height).x;\n            const maxCanvasX = toCanvasCoords(nextX - (currentPointIndex < prop.line.length - 1 ? buffer : 0), 0, minX, maxX, width, height).x;\n\n            pos.x = Math.max(minCanvasX, Math.min(maxCanvasX, pos.x));\n\n            // Constrain dragging vertically\n            const plotTop = EDITOR_PADDING.top;\n            const plotBottom = height - EDITOR_PADDING.bottom;\n            pos.y = Math.max(plotTop, Math.min(plotBottom, pos.y));\n\n            circle.position(pos); // Update position after constraints\n\n            // Update data array\n            const dataCoords = toDataCoords(pos.x, pos.y, minX, maxX, width, height);\n            prop.line[currentPointIndex][0] = dataCoords.x;\n            prop.line[currentPointIndex][1] = dataCoords.y;\n\n            // Update the connecting line during drag\n            const currentKonvaPoints = prop.line.map((pData, idx) => {\n              // Use dragged circle position directly for the point being dragged\n              if (idx === currentPointIndex)\n                return [pos.x, pos.y];\n              else {\n                const c = toCanvasCoords(pData[0], pData[1], minX, maxX, width, height);\n                return [c.x, c.y];\n              }\n            }).flat();\n            konvaLine.points(currentKonvaPoints);\n            layer.batchDraw(); // More efficient redraw\n          });\n\n          pointCircle.on('dragend', (evt: Konva.KonvaEventObject<DragEvent>) => {\n            // Ensure data is sorted after drag, although constraints should handle it\n            prop.line.sort((a, b) => a[0] - b[0]);\n            redraw(); // Full redraw on drag end to fix indices and line path\n          });\n\n          // --- Right-click to Remove ---\n          pointCircle.on('contextmenu', (evt: Konva.KonvaEventObject<MouseEvent>) => {\n            evt.evt.preventDefault(); // Prevent browser context menu\n            // Keep at least 2 points for a line segment\n            if (prop.line.length <= 2) {\n              // Use DG tooltip or simple alert/warning\n              grok.shell.warning('Cannot remove points, minimum of 2 required.');\n              return;\n            }\n\n            const circle = evt.target as Konva.Circle;\n            const indexToRemove = circle.getAttr('_pointIndex');\n            prop.line.splice(indexToRemove, 1);\n            redraw(); // Redraw after removal\n          });\n\n          // Enhance usability: change cursor on hover and show tooltip\n          pointCircle.on('mouseenter', (evt: Konva.KonvaEventObject<MouseEvent>) => {\n            stage.container().style.cursor = 'pointer';\n            const circle = evt.target as Konva.Circle;\n            const pos = circle.position();\n            const dataCoords = toDataCoords(pos.x, pos.y, minX, maxX, width, height);\n            const tooltipText = `X: ${dataCoords.x.toFixed(2)}, Y: ${dataCoords.y.toFixed(2)}<br><br>Drag to move, right-click to delete`;\n            ui.tooltip.show(tooltipText, evt.evt.clientX, evt.evt.clientY);\n          });\n          pointCircle.on('mouseleave', (evt: Konva.KonvaEventObject<MouseEvent>) => {\n            stage.container().style.cursor = 'default';\n            ui.tooltip.hide();\n          });\n\n          pointsGroup.add(pointCircle);\n        });\n\n        konvaLine.points(konvaPoints);\n        layer.batchDraw();\n\n        if (notify)\n          that.onChanged.next();\n      }\n\n      // --- Left-click to Add Point ---\n      stage.on('click tap', (evt: Konva.KonvaEventObject<PointerEvent>) => {\n        // Ignore clicks on existing points (circles) or non-left clicks\n        if (evt.target instanceof Konva.Circle || evt.evt.button !== 0) return;\n\n        const pos = stage.getPointerPosition();\n        if (!pos) return;\n\n        // Ensure click is within the plot area boundaries\n        if (pos.x < EDITOR_PADDING.left || pos.x > width - EDITOR_PADDING.right ||\n          pos.y < EDITOR_PADDING.top || pos.y > height - EDITOR_PADDING.bottom)\n          return;\n\n        const dataCoords = toDataCoords(pos.x, pos.y, minX, maxX, width, height);\n        // Add the new point\n        prop.line.push([dataCoords.x, dataCoords.y]);\n\n        // No need to sort here, redraw() handles sorting\n        redraw();\n      });\n\n      // Change cursor when over the stage plot area for adding points\n      stage.on('mouseenter', (evt: Konva.KonvaEventObject<MouseEvent>) => {\n        if (!(evt.target instanceof Konva.Circle)) {\n          const pos = stage.getPointerPosition();\n          if (pos && pos.x >= EDITOR_PADDING.left && pos.x <= width - EDITOR_PADDING.right &&\n            pos.y >= EDITOR_PADDING.top && pos.y <= height - EDITOR_PADDING.bottom)\n            stage.container().style.cursor = 'crosshair';\n        }\n      });\n\n      stage.on('mouseleave', (evt: Konva.KonvaEventObject<MouseEvent>) => {\n        if (!(evt.target instanceof Konva.Circle))\n          stage.container().style.cursor = 'default';\n      });\n\n      stage.on('mousemove', (evt: Konva.KonvaEventObject<MouseEvent>) => {\n        if (!(evt.target instanceof Konva.Circle)) {\n          const pos = stage.getPointerPosition();\n          if (pos && pos.x >= EDITOR_PADDING.left && pos.x <= width - EDITOR_PADDING.right &&\n            pos.y >= EDITOR_PADDING.top && pos.y <= height - EDITOR_PADDING.bottom)\n            stage.container().style.cursor = 'crosshair';\n\n          else\n            stage.container().style.cursor = 'default';\n        }\n      });\n\n      stage.on('mouseout', (_) => ui.tooltip.hide());\n\n      // Initial draw\n      redraw(false);\n    }, 0);\n  }\n\n  get line(): DesirabilityLine {\n    return this._prop.line;\n  }\n}\n\n\n// Function to transform data coordinates to canvas coordinates\nfunction toCanvasCoords(x: number, y: number, minX: number, maxX: number, width: number, height: number): { x: number, y: number } {\n  const plotWidth = width - EDITOR_PADDING.left - EDITOR_PADDING.right;\n  const plotHeight = height - EDITOR_PADDING.top - EDITOR_PADDING.bottom;\n  // Handle case where minX === maxX to avoid division by zero\n  const scaleX = (maxX - minX === 0) ? 1 : plotWidth / (maxX - minX);\n  const scaleY = plotHeight; // y data is 0-1\n\n  const canvasX = EDITOR_PADDING.left + (x - minX) * scaleX;\n  const canvasY = EDITOR_PADDING.top + plotHeight - (y * scaleY); // Flip y-axis\n\n  return {x: canvasX, y: canvasY};\n}\n\n// Function to transform canvas coordinates to data coordinates\nfunction toDataCoords(canvasX: number, canvasY: number, minX: number, maxX: number, width: number, height: number): { x: number, y: number } {\n  const plotWidth = width - EDITOR_PADDING.left - EDITOR_PADDING.right;\n  const plotHeight = height - EDITOR_PADDING.top - EDITOR_PADDING.bottom;\n  // Handle case where minX === maxX\n  const scaleX = (maxX - minX === 0) ? 1 : plotWidth / (maxX - minX);\n  const scaleY = plotHeight;\n\n  let dataX = minX + (canvasX - EDITOR_PADDING.left) / scaleX;\n  let dataY = (EDITOR_PADDING.top + plotHeight - canvasY) / scaleY;\n\n  // Clamp values\n  dataX = Math.max(minX, Math.min(maxX, dataX));\n  dataY = Math.max(0, Math.min(1, dataY));\n\n  return {x: dataX, y: dataY};\n}\n"]}

package/src/mpo/mpo-profile-editor.d.ts

@@ -0,0 +1,13 @@
+import * as DG from 'datagrok-api/dg';
+import { DesirabilityProfile } from './mpo';
+import { Subject } from 'rxjs';
+export declare class MpoProfileEditor {
+    root: HTMLDivElement;
+    dataFrame?: DG.DataFrame;
+    onChanged: Subject<unknown>;
+    profile?: DesirabilityProfile;
+    constructor(dataFrame?: DG.DataFrame);
+    getProfile(): DesirabilityProfile | undefined;
+    setProfile(profile?: DesirabilityProfile): void;
+}
+//# sourceMappingURL=mpo-profile-editor.d.ts.map

package/src/mpo/mpo-profile-editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mpo-profile-editor.d.ts","sourceRoot":"","sources":["mpo-profile-editor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAGtC,OAAO,EAAC,mBAAmB,EAAC,MAAM,OAAO,CAAC;AAE1C,OAAO,EAAC,OAAO,EAAC,MAAM,MAAM,CAAC;AAG7B,qBAAa,gBAAgB;IAC3B,IAAI,iBAAc;IAClB,SAAS,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC;IACzB,SAAS,mBAAiB;IAC1B,OAAO,CAAC,EAAE,mBAAmB,CAAC;gBAElB,SAAS,CAAC,EAAE,EAAE,CAAC,SAAS;IAKpC,UAAU,IAAI,mBAAmB,GAAG,SAAS;IAI7C,UAAU,CAAC,OAAO,CAAC,EAAE,mBAAmB;CAsEzC"}

package/src/mpo/mpo-profile-editor.js

@@ -0,0 +1,79 @@
+import * as ui from 'datagrok-api/ui';
+import { MpoDesirabilityLineEditor } from './mpo-line-editor';
+import { Subject } from 'rxjs';
+export class MpoProfileEditor {
+    constructor(dataFrame) {
+        this.root = ui.div([]);
+        this.onChanged = new Subject();
+        this.dataFrame = dataFrame;
+        this.setProfile();
+    }
+    getProfile() {
+        return this.profile;
+    }
+    setProfile(profile) {
+        this.profile = profile;
+        ui.empty(this.root);
+        if (!profile) {
+            this.root.append(ui.divText('No profile specified.'));
+            return;
+        }
+        // Create header row for the table
+        const header = ui.divH([
+            ui.divText('Property', { style: { fontWeight: 'bold', width: '150px' } }),
+            ui.divText('Weight', { style: { fontWeight: 'bold', width: '60px' } }),
+            ui.divText('Desirability', { style: { fontWeight: 'bold', flexGrow: '1' } }), // Let editor take space
+        ], { style: {
+                marginTop: '10px',
+                paddingBottom: '5px',
+                borderBottom: '1px solid #ccc',
+            },
+        });
+        const propertyRows = Object.entries(profile.properties).map(([propertyName, prop]) => {
+            var _a, _b, _c;
+            const lineEditor = new MpoDesirabilityLineEditor(prop, 300, 80);
+            lineEditor.onChanged.subscribe((_) => this.onChanged.next());
+            // Input for weight - updates the *copy* of the template data
+            const weightInput = ui.input.float('', {
+                value: prop.weight, min: 0, max: 1,
+                onValueChanged: (newValue) => {
+                    if (profile && profile.properties[propertyName]) {
+                        // Update the weight in the temporary template object
+                        let clampedWeight = newValue !== null && newValue !== void 0 ? newValue : 0;
+                        clampedWeight = Math.max(0, Math.min(1, clampedWeight)); // Clamp 0-1
+                        profile.properties[propertyName].weight = clampedWeight;
+                    }
+                },
+            });
+            weightInput.root.style.width = '60px';
+            weightInput.root.style.marginTop = '21px';
+            const matchedColumnName = this.dataFrame ?
+                this.dataFrame.columns.names().find((name) => name.toLowerCase() == propertyName.toLowerCase()) :
+                null;
+            const columnInput = ui.input.choice('', {
+                nullable: true,
+                items: (_c = (_b = (_a = this.dataFrame) === null || _a === void 0 ? void 0 : _a.columns) === null || _b === void 0 ? void 0 : _b.names()) !== null && _c !== void 0 ? _c : [''],
+                value: matchedColumnName !== null && matchedColumnName !== void 0 ? matchedColumnName : ''
+            });
+            const rowDiv = ui.divH([
+                ui.divV([
+                    ui.divText(propertyName, { style: { width: '150px', paddingTop: '5px', marginLeft: '4px' } }),
+                    this.dataFrame ? columnInput.root : null,
+                ]),
+                weightInput.root,
+                lineEditor.root, // Add the Konva container div
+            ]);
+            rowDiv.style.alignItems = 'center'; // Vertically align items in the row
+            rowDiv.style.marginBottom = '5px'; // Space between rows
+            rowDiv.style.minHeight = '70px'; // Ensure consistent row height even if editor takes time
+            return rowDiv;
+        }).filter((el) => el !== null); // Filter out skipped properties
+        if (propertyRows.length > 0) {
+            this.root.append(header);
+            this.root.append(ui.divV(propertyRows)); // Cast needed after filter
+        }
+        else
+            this.root.append(ui.divText('No matching properties found in the table for this template.'));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mpo-profile-editor.js","sourceRoot":"","sources":["mpo-profile-editor.ts"],"names":[],"mappings":"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","sourcesContent":["import * as DG from 'datagrok-api/dg';\nimport * as ui from 'datagrok-api/ui';\n\nimport {DesirabilityProfile} from './mpo';\nimport {MpoDesirabilityLineEditor} from './mpo-line-editor';\nimport {Subject} from 'rxjs';\n\n\nexport class MpoProfileEditor {\n  root = ui.div([]);\n  dataFrame?: DG.DataFrame;\n  onChanged = new Subject();\n  profile?: DesirabilityProfile;\n\n  constructor(dataFrame?: DG.DataFrame) {\n    this.dataFrame = dataFrame;\n    this.setProfile();\n  }\n\n  getProfile(): DesirabilityProfile | undefined {\n    return this.profile;\n  }\n\n  setProfile(profile?: DesirabilityProfile) {\n    this.profile = profile;\n    ui.empty(this.root);\n    if (!profile) {\n      this.root.append(ui.divText('No profile specified.'));\n      return;\n    }\n\n    // Create header row for the table\n    const header = ui.divH([\n      ui.divText('Property', {style: {fontWeight: 'bold', width: '150px'}}),\n      ui.divText('Weight', {style: {fontWeight: 'bold', width: '60px'}}),\n      ui.divText('Desirability', {style: {fontWeight: 'bold', flexGrow: '1'}}), // Let editor take space\n    ], {style: {\n      marginTop: '10px',\n      paddingBottom: '5px',\n      borderBottom: '1px solid #ccc',\n    },\n    });\n\n    const propertyRows = Object.entries(profile.properties).map(([propertyName, prop]) => {\n      const lineEditor = new MpoDesirabilityLineEditor(prop, 300, 80);\n      lineEditor.onChanged.subscribe((_) => this.onChanged.next());\n\n      // Input for weight - updates the *copy* of the template data\n      const weightInput = ui.input.float('', { // No label needed here\n        value: prop.weight, min: 0, max: 1,\n        onValueChanged: (newValue) => { // Changed parameter name for clarity\n          if (profile && profile.properties[propertyName]) {\n            // Update the weight in the temporary template object\n            let clampedWeight = newValue ?? 0;\n            clampedWeight = Math.max(0, Math.min(1, clampedWeight)); // Clamp 0-1\n            profile.properties[propertyName].weight = clampedWeight;\n          }\n        },\n      });\n\n      weightInput.root.style.width = '60px';\n      weightInput.root.style.marginTop = '21px';\n\n      const matchedColumnName = this.dataFrame ?\n        this.dataFrame.columns.names().find((name) => name.toLowerCase() == propertyName.toLowerCase()) :\n        null;\n\n      const columnInput = ui.input.choice('', {\n        nullable: true,\n        items: this.dataFrame?.columns?.names() ?? [''],\n        value: matchedColumnName ?? ''});\n\n      const rowDiv = ui.divH([\n        ui.divV([\n          ui.divText(propertyName, {style: {width: '150px', paddingTop: '5px', marginLeft: '4px'}}),\n          this.dataFrame ? columnInput.root : null,\n        ]),\n        weightInput.root,\n        lineEditor.root, // Add the Konva container div\n      ]);\n      rowDiv.style.alignItems = 'center'; // Vertically align items in the row\n      rowDiv.style.marginBottom = '5px'; // Space between rows\n      rowDiv.style.minHeight = '70px'; // Ensure consistent row height even if editor takes time\n\n      return rowDiv;\n    }).filter((el) => el !== null); // Filter out skipped properties\n\n    if (propertyRows.length > 0) {\n      this.root.append(header);\n      this.root.append(ui.divV(propertyRows as HTMLElement[])); // Cast needed after filter\n    } else\n      this.root.append(ui.divText('No matching properties found in the table for this template.'));\n  }\n}\n"]}

package/src/mpo/mpo.d.ts

@@ -0,0 +1,19 @@
+import * as DG from 'datagrok-api/dg';
+export type DesirabilityLine = number[][];
+export type PropertyDesirability = {
+    line: DesirabilityLine;
+    min?: number;
+    max?: number;
+    weight: number;
+};
+export type DesirabilityProfile = {
+    name: string;
+    description: string;
+    properties: {
+        [key: string]: PropertyDesirability;
+    };
+};
+export declare function desirabilityScore(x: number, desirabilityLine: DesirabilityLine): number;
+/** Calculates the multi parameter optimization score, 0-100, 100 is the maximum */
+export declare function mpo(dataFrame: DG.DataFrame, columns: DG.Column[]): DG.Column;
+//# sourceMappingURL=mpo.d.ts.map

package/src/mpo/mpo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mpo.d.ts","sourceRoot":"","sources":["mpo.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAItC,MAAM,MAAM,gBAAgB,GAAG,MAAM,EAAE,EAAE,CAAC;AAG1C,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,gBAAgB,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAA;AAGD,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,CAAA;KAAE,CAAC;CACrD,CAAA;AAKD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,GAAG,MAAM,CAoBvF;AAED,mFAAmF;AACnF,wBAAgB,GAAG,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,CA8B5E"}

package/src/mpo/mpo.js

@@ -0,0 +1,52 @@
+/* eslint-disable guard-for-in */
+/* eslint-disable max-len */
+import * as DG from 'datagrok-api/dg';
+/// Calculates the desirability score for a given x value
+/// Returns 0 if x is outside the range of the desirability line
+/// Otherwise, returns the y value of the desirability line at x
+export function desirabilityScore(x, desirabilityLine) {
+    // If the line is empty or x is outside the range, return 0
+    if (desirabilityLine.length === 0 || x < desirabilityLine[0][0] || x > desirabilityLine[desirabilityLine.length - 1][0])
+        return 0;
+    // Find the two points that x lies between
+    for (let i = 0; i < desirabilityLine.length - 1; i++) {
+        const [x1, y1] = desirabilityLine[i];
+        const [x2, y2] = desirabilityLine[i + 1];
+        if (x >= x1 && x <= x2) {
+            // Linear interpolation between the two points
+            if (x1 === x2)
+                return y1;
+            const slope = (y2 - y1) / (x2 - x1);
+            return y1 + slope * (x - x1);
+        }
+    }
+    // Should not happen if x is within bounds, but return 0 as fallback
+    return 0;
+}
+/** Calculates the multi parameter optimization score, 0-100, 100 is the maximum */
+export function mpo(dataFrame, columns) {
+    if (columns.length === 0)
+        throw new Error('No columns provided for MPO calculation.');
+    const resultColumnName = dataFrame.columns.getUnusedName('MPO'); // Ensure unique name
+    const resultColumn = DG.Column.float(resultColumnName, columns[0].length);
+    const desirabilityTemplates = columns.map((column) => {
+        const tag = column.getTag('desirabilityTemplate');
+        return JSON.parse(tag);
+    });
+    resultColumn.init((i) => {
+        let totalScore = 0;
+        let maxScore = 0;
+        for (let j = 0; j < columns.length; j++) {
+            const desirability = desirabilityTemplates[j];
+            const value = columns[j].get(i);
+            const score = desirabilityScore(value, desirability.line);
+            totalScore += desirability.weight * score;
+            maxScore += desirability.weight;
+        }
+        return 100 * (totalScore / maxScore);
+    });
+    // Add the column to the table
+    dataFrame.columns.add(resultColumn);
+    return resultColumn;
+}
+//# sourceMappingURL=data:application/json;base64,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