@teachinglab/omd 0.6.1 → 0.6.3

package/npm-docs/api/omdStepVisualizerHighlighting.md

@@ -1,66 +1,66 @@
-# omdStepVisualizerHighlighting
-
-Manages the highlighting of nodes within mathematical expressions displayed by the `omdStepVisualizer`. It uses a robust tree differencing algorithm to identify changes between consecutive steps and highlights affected nodes, providing visual feedback on transformations.
-
-## Class Definition
-
-```javascript
-export class omdStepVisualizerHighlighting
-```
-
-## Constructor
-
-### `new omdStepVisualizerHighlighting(stepVisualizer)`
-
-Creates a new `omdStepVisualizerHighlighting` instance.
-
--   **`stepVisualizer`** (`omdStepVisualizer`): The step visualizer instance this highlighting manager is associated with.
-
-During construction, it initializes a `Set` to track `highlightedNodes` and sets `educationalMode` to `true` by default.
-
-## Public Properties
-
--   **`stepVisualizer`** (`omdStepVisualizer`): The associated step visualizer instance.
--   **`highlightedNodes`** (`Set<omdNode>`): A set of `omdNode` instances that are currently highlighted by this manager.
--   **`educationalMode`** (`boolean`): If `true`, enables highlighting of pedagogical simplifications (e.g., intermediate steps that might be skipped in a final solution). Default: `true`.
-
-## Public Methods
-
-### `highlightAffectedNodes(dotIndex, isOperation = false)`
-
-This is the main method to trigger highlighting. It compares the equation at `dotIndex` with the previous visible equation in the sequence to identify changes and then applies appropriate highlighting.
-
--   **`dotIndex`** (`number`): The index of the dot (step) for which to highlight affected nodes.
--   **`isOperation`** (`boolean`, optional): If `true`, indicates that the step is an operation (e.g., adding to both sides), which affects how provenance is highlighted. Default: `false`.
-
-**How it Works:**
-
-1.  **Clear Existing Highlights**: First, any previously active highlights are cleared.
-2.  **Identify Equations**: It determines the `currentEquation` (associated with `dotIndex`) and finds the `previousEquation` (the nearest visible equation before the current one).
-3.  **Tree Differencing**: It uses `omdTreeDiff.findChangedNodes` to perform a robust comparison between the `previousEquation` and `currentEquation`. This algorithm identifies nodes that have been added, removed, or modified.
-4.  **Direct Highlighting**: Nodes identified as directly changed by the diff algorithm are highlighted with a primary explanation color (`omdColor.explainColor`).
-5.  **Provenance Highlighting**: For non-operation steps, the system traces the `provenance` (history) of the directly changed nodes back to their origins in the `previousEquation`. These originating nodes are then highlighted with a secondary provenance color (`omdColor.provenanceColor`), visually connecting the transformation.
-
-### `clearHighlights()`
-
-Removes all active highlights managed by this class from the expression tree. It iterates through all `highlightedNodes` and calls `setExplainHighlight(false)` on them, then clears its internal `highlightedNodes` set.
-
-## Internal Methods
-
--   **`_highlightNode(node)`**: Applies the standard explanation highlight color (`omdColor.explainColor`) to a single `omdNode` by calling its `setExplainHighlight(true)` method and adds the node to `highlightedNodes`.
--   **`_findNearestVisibleEquationAbove(currentIndex)`**: Searches backward from `currentIndex` in the `stepVisualizer.steps` array to find the closest `omdEquationNode` that is currently visible.
--   **`_highlightProvenanceNodes(changedNodes, previousEquation)`**: Iterates through `changedNodes` and their `provenance` chains to identify and highlight corresponding nodes in the `previousEquation` with `omdColor.provenanceColor`. It uses `rootNode.nodeMap` for efficient node lookup and a `visited` set to prevent redundant processing.
--   **`_belongsToEquation(node, targetEquation)`**: Checks if a given `omdNode` is part of the subtree of a `targetEquation` by traversing up its parent chain.
--   **`_highlightProvenanceNode(node)`**: Applies the secondary provenance highlighting style (`omdColor.provenanceColor`) to a single `omdNode` by calling its `setExplainHighlight(true, omdColor.provenanceColor)` method.
-
-## Example
-
-This class is typically used internally by `omdStepVisualizer` when a step dot is clicked:
-
-```javascript
-// Inside omdStepVisualizer's _handleDotClick method:
-this.highlighting.highlightAffectedNodes(dotIndex, isOperation);
-
-// Inside omdStepVisualizer's _clearActiveDot method:
-this.highlighting.clearHighlights();
+# omdStepVisualizerHighlighting
+
+Manages the highlighting of nodes within mathematical expressions displayed by the `omdStepVisualizer`. It uses a robust tree differencing algorithm to identify changes between consecutive steps and highlights affected nodes, providing visual feedback on transformations.
+
+## Class Definition
+
+```javascript
+export class omdStepVisualizerHighlighting
+```
+
+## Constructor
+
+### `new omdStepVisualizerHighlighting(stepVisualizer)`
+
+Creates a new `omdStepVisualizerHighlighting` instance.
+
+-   **`stepVisualizer`** (`omdStepVisualizer`): The step visualizer instance this highlighting manager is associated with.
+
+During construction, it initializes a `Set` to track `highlightedNodes` and sets `educationalMode` to `true` by default.
+
+## Public Properties
+
+-   **`stepVisualizer`** (`omdStepVisualizer`): The associated step visualizer instance.
+-   **`highlightedNodes`** (`Set<omdNode>`): A set of `omdNode` instances that are currently highlighted by this manager.
+-   **`educationalMode`** (`boolean`): If `true`, enables highlighting of pedagogical simplifications (e.g., intermediate steps that might be skipped in a final solution). Default: `true`.
+
+## Public Methods
+
+### `highlightAffectedNodes(dotIndex, isOperation = false)`
+
+This is the main method to trigger highlighting. It compares the equation at `dotIndex` with the previous visible equation in the sequence to identify changes and then applies appropriate highlighting.
+
+-   **`dotIndex`** (`number`): The index of the dot (step) for which to highlight affected nodes.
+-   **`isOperation`** (`boolean`, optional): If `true`, indicates that the step is an operation (e.g., adding to both sides), which affects how provenance is highlighted. Default: `false`.
+
+**How it Works:**
+
+1.  **Clear Existing Highlights**: First, any previously active highlights are cleared.
+2.  **Identify Equations**: It determines the `currentEquation` (associated with `dotIndex`) and finds the `previousEquation` (the nearest visible equation before the current one).
+3.  **Tree Differencing**: It uses `omdTreeDiff.findChangedNodes` to perform a robust comparison between the `previousEquation` and `currentEquation`. This algorithm identifies nodes that have been added, removed, or modified.
+4.  **Direct Highlighting**: Nodes identified as directly changed by the diff algorithm are highlighted with a primary explanation color (`omdColor.explainColor`).
+5.  **Provenance Highlighting**: For non-operation steps, the system traces the `provenance` (history) of the directly changed nodes back to their origins in the `previousEquation`. These originating nodes are then highlighted with a secondary provenance color (`omdColor.provenanceColor`), visually connecting the transformation.
+
+### `clearHighlights()`
+
+Removes all active highlights managed by this class from the expression tree. It iterates through all `highlightedNodes` and calls `setExplainHighlight(false)` on them, then clears its internal `highlightedNodes` set.
+
+## Internal Methods
+
+-   **`_highlightNode(node)`**: Applies the standard explanation highlight color (`omdColor.explainColor`) to a single `omdNode` by calling its `setExplainHighlight(true)` method and adds the node to `highlightedNodes`.
+-   **`_findNearestVisibleEquationAbove(currentIndex)`**: Searches backward from `currentIndex` in the `stepVisualizer.steps` array to find the closest `omdEquationNode` that is currently visible.
+-   **`_highlightProvenanceNodes(changedNodes, previousEquation)`**: Iterates through `changedNodes` and their `provenance` chains to identify and highlight corresponding nodes in the `previousEquation` with `omdColor.provenanceColor`. It uses `rootNode.nodeMap` for efficient node lookup and a `visited` set to prevent redundant processing.
+-   **`_belongsToEquation(node, targetEquation)`**: Checks if a given `omdNode` is part of the subtree of a `targetEquation` by traversing up its parent chain.
+-   **`_highlightProvenanceNode(node)`**: Applies the secondary provenance highlighting style (`omdColor.provenanceColor`) to a single `omdNode` by calling its `setExplainHighlight(true, omdColor.provenanceColor)` method.
+
+## Example
+
+This class is typically used internally by `omdStepVisualizer` when a step dot is clicked:
+
+```javascript
+// Inside omdStepVisualizer's _handleDotClick method:
+this.highlighting.highlightAffectedNodes(dotIndex, isOperation);
+
+// Inside omdStepVisualizer's _clearActiveDot method:
+this.highlighting.clearHighlights();
 ```

package/npm-docs/api/omdStepVisualizerInteractiveSteps.md

@@ -1,109 +1,109 @@
-# omdStepVisualizerInteractiveSteps
-
-This class creates and manages the interactive text boxes that display detailed explanations for simplification steps within the `omdStepVisualizer`. It formats the messages, handles styling, and sets up hover and click interactions, allowing users to explore the mathematical transformations.
-
-## Class Definition
-
-```javascript
-export class omdStepVisualizerInteractiveSteps
-```
-
-## Constructor
-
-### `new omdStepVisualizerInteractiveSteps(stepVisualizer, simplificationData)`
-
-Creates a new `omdStepVisualizerInteractiveSteps` instance.
-
--   **`stepVisualizer`** (`omdStepVisualizer`): A reference to the `omdStepVisualizer` instance this component is associated with.
--   **`simplificationData`** (`object`): An object containing the simplification details for the step, typically including `message`, `rawMessages`, `ruleNames`, and potentially `operationValueNode`.
-
-During construction, it extracts and cleans messages and rule names from the `simplificationData`, initializes layout properties (like `stepWidth`, `fontSize`), sets up the main `layoutGroup`, and creates the individual step elements.
-
-## Public Properties
-
--   **`stepVisualizer`** (`omdStepVisualizer`): A reference to the associated `omdStepVisualizer` instance.
--   **`simplificationData`** (`object`): The raw data describing the simplification step.
--   **`messages`** (`Array<string>`): Cleaned and extracted messages for each sub-step.
--   **`ruleNames`** (`Array<string>`): Extracted names of the simplification rules applied.
--   **`stepElements`** (`Array<jsvgTextBox>`): An array of `jsvgTextBox` instances, each representing a line of explanation.
--   **`layoutGroup`** (`jsvgLayoutGroup`): The main `jsvgLayoutGroup` that contains all the visual elements of the interactive steps, including the background and individual step messages.
--   **`stepWidth`** (`number`): The fixed width for each step explanation box.
--   **`baseStepHeight`** (`number`): The minimum height for a single step explanation box.
--   **`headerHeight`** (`number`): The height reserved for the header text box.
--   **`fontSize`** (`number`): The base font size for the explanation text.
--   **`smallFontSize`** (`number`): A smaller font size used for secondary text (e.g., step numbers).
--   **`backgroundRect`** (`jsvgRect`): The background rectangle for the entire group of interactive steps.
--   **`contentGroup`** (`jsvgLayoutGroup`): An internal layout group that holds the header and individual step messages.
--   **`onStepHover`** (`Function`): Callback function for hover events on step explanations.
--   **`onStepClick`** (`Function`): Callback function for click events on step explanations.
-
-## Public Methods
-
-### `setOnStepHover(callback)`
-
-Sets a callback function to be executed when the user hovers over a step explanation.
-
--   **`callback`** (`Function`): A function that receives `(stepIndex, message, isEntering)` as arguments.
-
-### `setOnStepClick(callback)`
-
-Sets a callback function to be executed when the user clicks on a step explanation.
-
--   **`callback`** (`Function`): A function that receives `(stepIndex, message)` as arguments.
-
-### `getLayoutGroup()`
-
-Returns the main `jsvgLayoutGroup` containing all the interactive step elements. This group should be added to the parent container (e.g., `omdStepVisualizer`'s `visualContainer`).
-
--   **Returns**: `jsvgLayoutGroup`.
-
-### `setPosition(x, y)`
-
-Sets the position of the entire interactive step group within its parent container.
-
--   **`x`** (`number`): The X-coordinate.
--   **`y`** (`number`): The Y-coordinate.
-
-### `getDimensions()`
-
-Returns the calculated width and height of the interactive step group, including its background.
-
--   **Returns**: `object` - An object with `width` and `height` properties.
-
-### `destroy()`
-
-Cleans up the component by removing all its children, clearing references, and unsetting callbacks.
-
-## Internal Methods
-
--   **`_extractMessages(data)`**: Extracts and cleans messages from the `simplificationData`, removing HTML tags and bullet points.
--   **`_extractRuleNames(data)`**: Extracts rule names from the `simplificationData`, providing default values if not present.
--   **`setupLayoutGroup()`**: Initializes the main `layoutGroup` and creates its `backgroundRect`, setting initial styling.
--   **`createStepElements()`**: Orchestrates the creation of individual step explanation elements. It decides whether to create a single step element or multiple, based on the number of messages.
--   **`createSingleStepElement(message, index)`**: Creates a header and a single `jsvgTextBox` for a step explanation when there's only one message.
--   **`createMultipleStepElements()`**: Creates a header and multiple `jsvgTextBox` elements for step explanations when there are multiple messages, optionally including step numbers.
--   **`createHeaderBox(headerText)`**: Creates a styled `jsvgTextBox` to serve as a header for the explanation group.
--   **`createStepTextBox(message, index, isMultiple)`**: Creates an individual styled `jsvgTextBox` for a step message, calculates its height, and stores relevant step data.
--   **`formatStepContent(message, index, isMultiple)`**: Formats the raw message content into HTML, adding styling for step numbers, bullets, and highlighting operation details (action, value).
--   **`applyStepStyling(stepBox, content, isMultiple)`**: Applies CSS styling to the `jsvgTextBox`'s underlying DOM element and sets its `innerHTML` with the formatted content.
--   **`setupStepInteractions(stepBox)`**: Sets up `mouseenter`, `mouseleave`, and `click` event listeners for a step box, triggering hover and click callbacks.
--   **`calculateStepHeight(message)`**: Dynamically calculates the required height for a step box based on its content, using a temporary DOM element for accurate measurement.
--   **`updateBackgroundSize()`**: Adjusts the size of the `backgroundRect` to fit the dynamically calculated content height and width.
--   **`isOperationMessage(message)`**: Checks if a message string indicates an operation (e.g., "Added X to both sides").
--   **`extractOperationAction(message)`**: Extracts the action verb (e.g., "Added", "Subtracted") from an operation message.
--   **`extractOperationValue(message)`**: Extracts the value (e.g., "3", "x") from an operation message.
--   **`extractOperationValueNode(message)`**: Attempts to extract the `omdNode` representing the value from an operation message, if available in the `simplificationData`.
-
-## How it Works
-
-This class takes simplification data and renders it as a series of interactive text boxes. Each box represents a sub-step or a part of the explanation. It dynamically calculates sizes and positions to ensure the text boxes are readable and visually appealing. Hover and click events on these boxes can be used to trigger further actions, such as highlighting specific nodes in the main equation display.
-
-## Example
-
-This class is typically used internally by `omdStepVisualizerTextBoxes`.
-
-```javascript
-// Example of internal usage within omdStepVisualizerTextBoxes:
-// const interactiveSteps = new omdStepVisualizerInteractiveSteps(this.stepVisualizer, simplificationData);
-// this.stepVisualizer.visualContainer.addChild(interactiveSteps.getLayoutGroup());
+# omdStepVisualizerInteractiveSteps
+
+This class creates and manages the interactive text boxes that display detailed explanations for simplification steps within the `omdStepVisualizer`. It formats the messages, handles styling, and sets up hover and click interactions, allowing users to explore the mathematical transformations.
+
+## Class Definition
+
+```javascript
+export class omdStepVisualizerInteractiveSteps
+```
+
+## Constructor
+
+### `new omdStepVisualizerInteractiveSteps(stepVisualizer, simplificationData)`
+
+Creates a new `omdStepVisualizerInteractiveSteps` instance.
+
+-   **`stepVisualizer`** (`omdStepVisualizer`): A reference to the `omdStepVisualizer` instance this component is associated with.
+-   **`simplificationData`** (`object`): An object containing the simplification details for the step, typically including `message`, `rawMessages`, `ruleNames`, and potentially `operationValueNode`.
+
+During construction, it extracts and cleans messages and rule names from the `simplificationData`, initializes layout properties (like `stepWidth`, `fontSize`), sets up the main `layoutGroup`, and creates the individual step elements.
+
+## Public Properties
+
+-   **`stepVisualizer`** (`omdStepVisualizer`): A reference to the associated `omdStepVisualizer` instance.
+-   **`simplificationData`** (`object`): The raw data describing the simplification step.
+-   **`messages`** (`Array<string>`): Cleaned and extracted messages for each sub-step.
+-   **`ruleNames`** (`Array<string>`): Extracted names of the simplification rules applied.
+-   **`stepElements`** (`Array<jsvgTextBox>`): An array of `jsvgTextBox` instances, each representing a line of explanation.
+-   **`layoutGroup`** (`jsvgLayoutGroup`): The main `jsvgLayoutGroup` that contains all the visual elements of the interactive steps, including the background and individual step messages.
+-   **`stepWidth`** (`number`): The fixed width for each step explanation box.
+-   **`baseStepHeight`** (`number`): The minimum height for a single step explanation box.
+-   **`headerHeight`** (`number`): The height reserved for the header text box.
+-   **`fontSize`** (`number`): The base font size for the explanation text.
+-   **`smallFontSize`** (`number`): A smaller font size used for secondary text (e.g., step numbers).
+-   **`backgroundRect`** (`jsvgRect`): The background rectangle for the entire group of interactive steps.
+-   **`contentGroup`** (`jsvgLayoutGroup`): An internal layout group that holds the header and individual step messages.
+-   **`onStepHover`** (`Function`): Callback function for hover events on step explanations.
+-   **`onStepClick`** (`Function`): Callback function for click events on step explanations.
+
+## Public Methods
+
+### `setOnStepHover(callback)`
+
+Sets a callback function to be executed when the user hovers over a step explanation.
+
+-   **`callback`** (`Function`): A function that receives `(stepIndex, message, isEntering)` as arguments.
+
+### `setOnStepClick(callback)`
+
+Sets a callback function to be executed when the user clicks on a step explanation.
+
+-   **`callback`** (`Function`): A function that receives `(stepIndex, message)` as arguments.
+
+### `getLayoutGroup()`
+
+Returns the main `jsvgLayoutGroup` containing all the interactive step elements. This group should be added to the parent container (e.g., `omdStepVisualizer`'s `visualContainer`).
+
+-   **Returns**: `jsvgLayoutGroup`.
+
+### `setPosition(x, y)`
+
+Sets the position of the entire interactive step group within its parent container.
+
+-   **`x`** (`number`): The X-coordinate.
+-   **`y`** (`number`): The Y-coordinate.
+
+### `getDimensions()`
+
+Returns the calculated width and height of the interactive step group, including its background.
+
+-   **Returns**: `object` - An object with `width` and `height` properties.
+
+### `destroy()`
+
+Cleans up the component by removing all its children, clearing references, and unsetting callbacks.
+
+## Internal Methods
+
+-   **`_extractMessages(data)`**: Extracts and cleans messages from the `simplificationData`, removing HTML tags and bullet points.
+-   **`_extractRuleNames(data)`**: Extracts rule names from the `simplificationData`, providing default values if not present.
+-   **`setupLayoutGroup()`**: Initializes the main `layoutGroup` and creates its `backgroundRect`, setting initial styling.
+-   **`createStepElements()`**: Orchestrates the creation of individual step explanation elements. It decides whether to create a single step element or multiple, based on the number of messages.
+-   **`createSingleStepElement(message, index)`**: Creates a header and a single `jsvgTextBox` for a step explanation when there's only one message.
+-   **`createMultipleStepElements()`**: Creates a header and multiple `jsvgTextBox` elements for step explanations when there are multiple messages, optionally including step numbers.
+-   **`createHeaderBox(headerText)`**: Creates a styled `jsvgTextBox` to serve as a header for the explanation group.
+-   **`createStepTextBox(message, index, isMultiple)`**: Creates an individual styled `jsvgTextBox` for a step message, calculates its height, and stores relevant step data.
+-   **`formatStepContent(message, index, isMultiple)`**: Formats the raw message content into HTML, adding styling for step numbers, bullets, and highlighting operation details (action, value).
+-   **`applyStepStyling(stepBox, content, isMultiple)`**: Applies CSS styling to the `jsvgTextBox`'s underlying DOM element and sets its `innerHTML` with the formatted content.
+-   **`setupStepInteractions(stepBox)`**: Sets up `mouseenter`, `mouseleave`, and `click` event listeners for a step box, triggering hover and click callbacks.
+-   **`calculateStepHeight(message)`**: Dynamically calculates the required height for a step box based on its content, using a temporary DOM element for accurate measurement.
+-   **`updateBackgroundSize()`**: Adjusts the size of the `backgroundRect` to fit the dynamically calculated content height and width.
+-   **`isOperationMessage(message)`**: Checks if a message string indicates an operation (e.g., "Added X to both sides").
+-   **`extractOperationAction(message)`**: Extracts the action verb (e.g., "Added", "Subtracted") from an operation message.
+-   **`extractOperationValue(message)`**: Extracts the value (e.g., "3", "x") from an operation message.
+-   **`extractOperationValueNode(message)`**: Attempts to extract the `omdNode` representing the value from an operation message, if available in the `simplificationData`.
+
+## How it Works
+
+This class takes simplification data and renders it as a series of interactive text boxes. Each box represents a sub-step or a part of the explanation. It dynamically calculates sizes and positions to ensure the text boxes are readable and visually appealing. Hover and click events on these boxes can be used to trigger further actions, such as highlighting specific nodes in the main equation display.
+
+## Example
+
+This class is typically used internally by `omdStepVisualizerTextBoxes`.
+
+```javascript
+// Example of internal usage within omdStepVisualizerTextBoxes:
+// const interactiveSteps = new omdStepVisualizerInteractiveSteps(this.stepVisualizer, simplificationData);
+// this.stepVisualizer.visualContainer.addChild(interactiveSteps.getLayoutGroup());
 ```

package/npm-docs/api/omdStepVisualizerLayout.md

@@ -1,71 +1,71 @@
-# omdStepVisualizerLayout
-
-Manages the visual layout, positioning, and visibility of elements within the `omdStepVisualizer`. It ensures that step dots, connecting lines, and associated text boxes are correctly positioned relative to the mathematical equations, maintaining a clean and interactive display.
-
-## Class Definition
-
-```javascript
-export class omdStepVisualizerLayout
-```
-
-## Constructor
-
-### `new omdStepVisualizerLayout(stepVisualizer)`
-
-Creates a new `omdStepVisualizerLayout` instance.
-
--   **`stepVisualizer`** (`omdStepVisualizer`): A reference to the `omdStepVisualizer` instance this layout manager will control.
-
-## Public Properties
-
--   **`stepVisualizer`** (`omdStepVisualizer`): The associated `omdStepVisualizer` instance.
-
-## Public Methods
-
-### `updateVisualLayout()`
-
-Calculates and applies the positions of all visual elements (dots, lines, text boxes) relative to the mathematical equations in the sequence. It ensures proper alignment and spacing, accounting for factors like equation background padding and the dynamic size of text boxes.
-
-### `findDotIndexForEquation(equation)`
-
-Finds the index of the step dot associated with a given `omdEquationNode` within the `stepVisualizer.stepDots` array.
-
--   **`equation`** (`omdEquationNode`): The equation node to find the corresponding dot for.
--   **Returns**: `number` - The 0-based index of the dot, or `-1` if not found.
-
-### `updateVisualZOrder()`
-
-Manages the z-order (stacking order) of the visual elements to ensure they are rendered correctly. Lines are placed behind dots, and text boxes are placed on top of everything else.
-
-### `updateAllLinePositions()`
-
-Recalculates and updates the start and end points of all connecting lines between the step dots. This ensures lines accurately connect the centers of the dots, even after layout changes.
-
-### `updateVisualVisibility()`
-
-Adjusts the visibility of the step dots and lines based on the visibility of their corresponding equations. It also dynamically re-creates line segments only between currently visible dots, ensuring no lines are drawn to hidden steps.
-
-### `updateDotClickability(dot)`
-
-Enables or disables the click functionality for a specific step dot. It sets the cursor style to `"pointer"` when clickable and `"default"` otherwise, and attaches/detaches the `onclick` event handler.
-
--   **`dot`** (`jsvgEllipse`): The `jsvgEllipse` element representing the dot.
-
-## Internal Methods
-
--   **`_getMaxEquationEffectivePaddingX()`**: Computes the maximum effective horizontal padding (x) among all visible `omdEquationNode` steps. This value is used to offset the visual tracker, preventing overlap with equation backgrounds.
-
-## How it Works
-
-This class works in conjunction with `omdStepVisualizer` to dynamically arrange the visual components. When the sequence of equations changes (e.g., steps are added or hidden), `omdStepVisualizer` calls methods on this layout manager to re-calculate and apply the new visual arrangement.
-
-## Example
-
-This class is primarily used internally by `omdStepVisualizer`:
-
-```javascript
-// Inside omdStepVisualizer's updateLayout method:
-this.layoutManager.updateVisualLayout();
-this.layoutManager.updateVisualVisibility();
-this.layoutManager.updateAllLinePositions();
+# omdStepVisualizerLayout
+
+Manages the visual layout, positioning, and visibility of elements within the `omdStepVisualizer`. It ensures that step dots, connecting lines, and associated text boxes are correctly positioned relative to the mathematical equations, maintaining a clean and interactive display.
+
+## Class Definition
+
+```javascript
+export class omdStepVisualizerLayout
+```
+
+## Constructor
+
+### `new omdStepVisualizerLayout(stepVisualizer)`
+
+Creates a new `omdStepVisualizerLayout` instance.
+
+-   **`stepVisualizer`** (`omdStepVisualizer`): A reference to the `omdStepVisualizer` instance this layout manager will control.
+
+## Public Properties
+
+-   **`stepVisualizer`** (`omdStepVisualizer`): The associated `omdStepVisualizer` instance.
+
+## Public Methods
+
+### `updateVisualLayout()`
+
+Calculates and applies the positions of all visual elements (dots, lines, text boxes) relative to the mathematical equations in the sequence. It ensures proper alignment and spacing, accounting for factors like equation background padding and the dynamic size of text boxes.
+
+### `findDotIndexForEquation(equation)`
+
+Finds the index of the step dot associated with a given `omdEquationNode` within the `stepVisualizer.stepDots` array.
+
+-   **`equation`** (`omdEquationNode`): The equation node to find the corresponding dot for.
+-   **Returns**: `number` - The 0-based index of the dot, or `-1` if not found.
+
+### `updateVisualZOrder()`
+
+Manages the z-order (stacking order) of the visual elements to ensure they are rendered correctly. Lines are placed behind dots, and text boxes are placed on top of everything else.
+
+### `updateAllLinePositions()`
+
+Recalculates and updates the start and end points of all connecting lines between the step dots. This ensures lines accurately connect the centers of the dots, even after layout changes.
+
+### `updateVisualVisibility()`
+
+Adjusts the visibility of the step dots and lines based on the visibility of their corresponding equations. It also dynamically re-creates line segments only between currently visible dots, ensuring no lines are drawn to hidden steps.
+
+### `updateDotClickability(dot)`
+
+Enables or disables the click functionality for a specific step dot. It sets the cursor style to `"pointer"` when clickable and `"default"` otherwise, and attaches/detaches the `onclick` event handler.
+
+-   **`dot`** (`jsvgEllipse`): The `jsvgEllipse` element representing the dot.
+
+## Internal Methods
+
+-   **`_getMaxEquationEffectivePaddingX()`**: Computes the maximum effective horizontal padding (x) among all visible `omdEquationNode` steps. This value is used to offset the visual tracker, preventing overlap with equation backgrounds.
+
+## How it Works
+
+This class works in conjunction with `omdStepVisualizer` to dynamically arrange the visual components. When the sequence of equations changes (e.g., steps are added or hidden), `omdStepVisualizer` calls methods on this layout manager to re-calculate and apply the new visual arrangement.
+
+## Example
+
+This class is primarily used internally by `omdStepVisualizer`:
+
+```javascript
+// Inside omdStepVisualizer's updateLayout method:
+this.layoutManager.updateVisualLayout();
+this.layoutManager.updateVisualVisibility();
+this.layoutManager.updateAllLinePositions();
 ```