@teachinglab/omd 0.7.6 → 0.7.8

package/canvas/tools/SelectTool.js

@@ -127,6 +127,11 @@ export class SelectTool extends Tool {
                 this.draggedOMDElement = omdElement; // Primary drag target
                 this.startPoint = { x: event.x, y: event.y };
                 
+                // Show resize handles if this is the only selected element
+                if (this.selectedOMDElements.size === 1) {
+                    this.resizeHandleManager.selectElement(omdElement);
+                }
+                
                 if (this.canvas.eventManager) {
                     this.canvas.eventManager.isDrawing = true;
                 }
@@ -903,11 +908,7 @@ export class SelectTool extends Tool {
         }
         
         // Update resize handles
-        if (this.selectedOMDElements.size === 1 && this.selectedSegments.size === 0) {
-             this.resizeHandleManager.selectElement(this.selectedOMDElements.values().next().value);
-        } else {
-             this.resizeHandleManager.clearSelection();
-        }
+        this.resizeHandleManager.clearSelection();
 
         this._updateSegmentSelectionVisuals();
     }

package/omd/nodes/omdEquationNode.js

@@ -1064,16 +1064,29 @@ _propagateBackgroundStyle(style, visited = new Set()) {
         const rightExpr = this._normalizeExpressionString(this.getRight().toString());
 
         let graphEquations = [];
+        
+        // Helper to check if expression is just 'y' (case-insensitive)
+        const isY = (expr) => expr.trim().toLowerCase() === 'y';
+
         if (options.side === 'left') {
-            graphEquations = [{ equation: `y = ${leftExpr}`, domain: { min: options.xMin, max: options.xMax }, color: 'blue', strokeWidth: 2 }];
+            if (!isY(leftExpr)) {
+                graphEquations.push({ equation: `y = ${leftExpr}`, domain: { min: options.xMin, max: options.xMax }, color: 'blue', strokeWidth: 2 });
+            }
         } else if (options.side === 'right') {
-            graphEquations = [{ equation: `y = ${rightExpr}`, domain: { min: options.xMin, max: options.xMax }, color: 'red', strokeWidth: 2 }];
+            if (!isY(rightExpr)) {
+                graphEquations.push({ equation: `y = ${rightExpr}`, domain: { min: options.xMin, max: options.xMax }, color: 'red', strokeWidth: 2 });
+            }
         } else {
             // both: plot left and right as two functions; intersection corresponds to equality
-            graphEquations = [
-                { equation: `y = ${leftExpr}`, domain: { min: options.xMin, max: options.xMax }, color: 'blue', strokeWidth: 2 },
-                { equation: `y = ${rightExpr}`, domain: { min: options.xMin, max: options.xMax }, color: 'red', strokeWidth: 2 }
-            ];
+            // Skip 'y' sides to avoid plotting "y=y"
+            if (!isY(leftExpr)) {
+                graphEquations.push({ equation: `y = ${leftExpr}`, domain: { min: options.xMin, max: options.xMax }, color: 'blue', strokeWidth: 2 });
+            }
+            if (!isY(rightExpr)) {
+                // If we skipped left because it was y, use blue for right side (primary function color)
+                const color = isY(leftExpr) ? 'blue' : 'red';
+                graphEquations.push({ equation: `y = ${rightExpr}`, domain: { min: options.xMin, max: options.xMax }, color: color, strokeWidth: 2 });
+            }
         }
 
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teachinglab/omd",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "description": "omd",
   "main": "./index.js",
   "module": "./index.js",

package/src/omdCoordinatePlane.js

@@ -363,25 +363,34 @@ export class omdCoordinatePlane extends jsvgGroup {
 
     graphMultipleFunctions(holder) {
         for (const functionConfig of this.graphEquations) {
-            const path = new jsvgPath();
-            path.setStrokeColor(this.getAllowedColor(functionConfig.color));
-            path.setStrokeWidth(functionConfig.strokeWidth);
-            this.graphFunctionWithDomain(path, functionConfig.equation, functionConfig.domain);
-            holder.addChild(path);
-
-            if (functionConfig.label) {
-                this.addFunctionLabel(holder, functionConfig);
+            try {
+                const path = new jsvgPath();
+                path.setStrokeColor(this.getAllowedColor(functionConfig.color));
+                path.setStrokeWidth(functionConfig.strokeWidth);
+                this.graphFunctionWithDomain(path, functionConfig.equation, functionConfig.domain);
+                holder.addChild(path);
+
+                if (functionConfig.label) {
+                    this.addFunctionLabel(holder, functionConfig);
+                }
+            } catch (e) {
+                console.warn(`Failed to graph equation: ${functionConfig.equation}`, e);
             }
         }
     }
 
+    _extractExpression(equationString) {
+        let expression = String(equationString).trim();
+        // Remove "y=" from start or "=y" from end, case insensitive, handling spaces
+        // This converts "y = 3x+2" or "3x+2 = y" into "3x+2"
+        expression = expression.replace(/^\s*y\s*=\s*/i, '').replace(/\s*=\s*y\s*$/i, '');
+        return expression;
+    }
+
     graphFunctionWithDomain(pathObject, functionString, domain) {
         pathObject.clearPoints();
 
-        let expression = functionString;
-        if (expression.toLowerCase().startsWith("y=")) {
-            expression = expression.substring(2).trim();
-        }
+        const expression = this._extractExpression(functionString);
 
         const compiledExpression = math.compile(expression);
 
@@ -417,10 +426,8 @@ export class omdCoordinatePlane extends jsvgGroup {
             : this.xMin + (this.xMax - this.xMin) * 0.1;
 
         let anchorY = this.yMin + (this.yMax - this.yMin) * 0.1;
-        let equationBody = functionConfig.equation;
-        if (equationBody.toLowerCase().startsWith("y=")) {
-            equationBody = equationBody.substring(2).trim();
-        }
+        const equationBody = this._extractExpression(functionConfig.equation);
+        
         const compiled = math.compile(equationBody);
         const yVal = compiled.evaluate({ x: anchorX });
         anchorY = yVal;

package/src/omdUtils.js

@@ -22,12 +22,32 @@ export function parseExpressionString(str) {
         // term or number/variable
         const m = tok.match(/^([+-]?)(\d*\.?\d*)([a-zA-Z]?)(?:\^(\d+))?$/);
         if (m) {
-            const sign = m[1] === '-' ? -1 : 1;
+            const signStr = m[1];
+            let sign = signStr === '-' ? -1 : 1;
             const coefRaw = m[2];
             const varChar = m[3] || '';
             const exp = m[4] ? Number(m[4]) : 1;
             let coef = 1;
             if (coefRaw && coefRaw.length > 0) coef = Number(coefRaw);
+
+            // Logic to split sign into operator if needed
+            // If we have a sign (+ or -), and we are NOT at the start and NOT following an operator,
+            // we should split it into an operator and a positive term.
+            let splitSign = false;
+            if (signStr) {
+                const isStart = out.length === 0;
+                const prevIsOperator = !isStart && out[out.length-1].omdType === 'operator';
+                
+                if (!isStart && !prevIsOperator) {
+                    splitSign = true;
+                }
+            }
+
+            if (splitSign) {
+                out.push({ omdType: 'operator', operator: signStr });
+                sign = 1; // Term becomes positive
+            }
+
             if (!varChar && coefRaw) {
                 // pure number
                 out.push({ omdType: 'number', value: sign * coef });
@@ -41,21 +61,27 @@ export function parseExpressionString(str) {
     }
 
     // If first token is an operator like '+' or '-', and followed by a term/number, fold it
+    // ONLY if it is a unary operator (at start or after another operator)
     const folded = [];
     for (let i = 0; i < out.length; i++) {
         const t = out[i];
         if (t.omdType === 'operator' && (t.operator === '+' || t.operator === '-')) {
-            // If it's a leading sign attached to next term, merge
-            const next = out[i+1];
-            if (next && (next.omdType === 'term' || next.omdType === 'number')) {
-                if (next.omdType === 'number') {
-                    next.value = (t.operator === '-') ? -next.value : next.value;
-                } else if (next.omdType === 'term') {
-                    next.coefficient = (t.operator === '-') ? -next.coefficient : next.coefficient;
+            const isStart = folded.length === 0;
+            const prevIsOperator = !isStart && folded[folded.length-1].omdType === 'operator';
+
+            // Only fold if it's unary
+            if (isStart || prevIsOperator) {
+                const next = out[i+1];
+                if (next && (next.omdType === 'term' || next.omdType === 'number')) {
+                    if (next.omdType === 'number') {
+                        next.value = (t.operator === '-') ? -next.value : next.value;
+                    } else if (next.omdType === 'term') {
+                        next.coefficient = (t.operator === '-') ? -next.coefficient : next.coefficient;
+                    }
+                    i++; // skip next because we've merged
+                    folded.push(next);
+                    continue;
                 }
-                i++; // skip next because we've merged
-                folded.push(next);
-                continue;
             }
         }
         folded.push(t);