# How the Node Type to Treatment Matrix Is Defined in Diagram-Design

> Discover how the Node Type to Treatment Matrix is defined in cathrynlavery/diagram-design. Learn about the centralized constant NODE_TYPE_TREATMENT_MATRIX for consistent rendering logic.

- Repository: [Cathryn Lavery/diagram-design](https://github.com/cathrynlavery/diagram-design)
- Tags: internals
- Published: 2026-08-23

---

**The Node Type to Treatment Matrix in cathrynlavery/diagram-design is defined as a centralized read-only constant `NODE_TYPE_TREATMENT_MATRIX` located in [`src/constants/nodeTypeTreatmentMatrix.ts`](https://github.com/cathrynlavery/diagram-design/blob/main/src/constants/nodeTypeTreatmentMatrix.ts) that maps diagram node type strings to `Treatment` enum values, enabling consistent rendering logic across the application.**

The cathrynlavery/diagram-design repository uses a declarative mapping system to control how different diagram nodes are rendered and processed. This system centers on the **Node Type to Treatment Matrix**, a single source of truth that associates each node type with a specific visual or behavioral treatment. By externalizing this mapping from the rendering logic, the codebase achieves a clean separation between node classification and presentation concerns.

## How the Node Type to Treatment Matrix Is Structured

The matrix implementation relies on two core files: an enum that defines valid treatments and a constant that stores the actual mappings.

### The Treatment Enum Definition

The values used in the matrix are defined in [`src/enums/treatment.ts`](https://github.com/cathrynlavery/diagram-design/blob/main/src/enums/treatment.ts) as members of the **Treatment** enum. This enum declares how a node should be handled by the rendering engine, such as highlighting, dimming, or grouping.

### The NODE_TYPE_TREATMENT_MATRIX Constant

In [`src/constants/nodeTypeTreatmentMatrix.ts`](https://github.com/cathrynlavery/diagram-design/blob/main/src/constants/nodeTypeTreatmentMatrix.ts), the matrix is declared as a `Record<string, Treatment>` that maps node type strings to their corresponding treatments. The definition follows this pattern:

```typescript
import { Treatment } from '../enums/treatment';

export const NODE_TYPE_TREATMENT_MATRIX: Record<string, Treatment> = {
  process: Treatment.Highlight,
  decision: Treatment.Dim,
  dataStore: Treatment.Group,
  externalSystem: Treatment.Highlight,
  // …more node‑type entries
};

```

Each key represents a node type identifier (e.g., `"process"`, `"decision"`), while the value is a treatment identifier drawn from the `Treatment` enum.

## Implementing Lookup Logic with the Matrix

Utility functions in [`src/utils/nodeTreatment.ts`](https://github.com/cathrynlavery/diagram-design/blob/main/src/utils/nodeTreatment.ts) consume the matrix to resolve treatments at runtime. The lookup implements a fallback strategy using the nullish coalescing operator to ensure every node receives a valid treatment even if its type is not explicitly registered.

```typescript
import { NODE_TYPE_TREATMENT_MATRIX } from './constants/nodeTypeTreatmentMatrix';
import { Treatment } from './enums/treatment';

function getTreatmentForNode(nodeType: string): Treatment {
  return NODE_TYPE_TREATMENT_MATRIX[nodeType] ?? Treatment.Default;
}

// Usage
const treatment = getTreatmentForNode('decision'); // → Treatment.Dim

```

If a node type is missing from the **Node Type to Treatment Matrix**, the engine falls back to `Treatment.Default`, preventing rendering failures.

## Rendering Nodes Using the Treatment Matrix

The rendering pipeline in [`src/render/renderer.ts`](https://github.com/cathrynlavery/diagram-design/blob/main/src/render/renderer.ts) relies on the matrix to determine drawing strategies. By querying the matrix during the render loop, the engine applies the correct visual treatment without hardcoding node-specific logic.

```typescript
function renderNode(node) {
  const treatment = getTreatmentForNode(node.type);
  switch (treatment) {
    case Treatment.Highlight:
      drawHighlighted(node);
      break;
    case Treatment.Dim:
      drawDimmed(node);
      break;
    case Treatment.Group:
      drawGrouped(node);
      break;
    default:
      drawStandard(node);
  }
}

```

This design centralizes treatment logic, allowing the rendering code to remain generic while the **Node Type to Treatment Matrix** controls node-specific behavior.

## Extending the Node Type to Treatment Matrix

You can extend the matrix with custom node types by importing the constant and adding new key-value pairs. This pattern is useful for project-specific extensions that introduce new node classifications without modifying core library files.

```typescript
// In a project‑specific extension file
import { NODE_TYPE_TREATMENT_MATRIX } from '../constants/nodeTypeTreatmentMatrix';
import { Treatment } from '../enums/treatment';

NODE_TYPE_TREATMENT_MATRIX['customAnalytics'] = Treatment.Highlight;

```

## Summary

- The **Node Type to Treatment Matrix** is defined in [`src/constants/nodeTypeTreatmentMatrix.ts`](https://github.com/cathrynlavery/diagram-design/blob/main/src/constants/nodeTypeTreatmentMatrix.ts) as the exported constant `NODE_TYPE_TREATMENT_MATRIX` of type `Record<string, Treatment>`.
- Valid treatment values are declared in the **Treatment** enum located in [`src/enums/treatment.ts`](https://github.com/cathrynlavery/diagram-design/blob/main/src/enums/treatment.ts).
- The helper function `getTreatmentForNode` in [`src/utils/nodeTreatment.ts`](https://github.com/cathrynlavery/diagram-design/blob/main/src/utils/nodeTreatment.ts) performs lookups with a fallback to `Treatment.Default`.
- The rendering engine in [`src/render/renderer.ts`](https://github.com/cathrynlavery/diagram-design/blob/main/src/render/renderer.ts) consumes this matrix to apply visual treatments without coupling rendering code to specific node types.

## Frequently Asked Questions

### Where is the Node Type to Treatment Matrix stored?

The matrix is stored in [`src/constants/nodeTypeTreatmentMatrix.ts`](https://github.com/cathrynlavery/diagram-design/blob/main/src/constants/nodeTypeTreatmentMatrix.ts) as a TypeScript constant that exports a `Record<string, Treatment>` mapping node type strings to treatment enum values.

### What happens if a node type is not found in the matrix?

The lookup utility returns `Treatment.Default` as a fallback, ensuring the node still renders using standard styling rather than throwing a runtime error.

### Can I add custom node types to the matrix?

Yes, you can import `NODE_TYPE_TREATMENT_MATRIX` from its constants file and assign new key-value pairs where the key is your custom node type string and the value is a valid `Treatment` enum member, such as `Treatment.Highlight` or `Treatment.Group`.

### How does the renderer use the Treatment enum values?

The renderer calls helper functions like `getTreatmentForNode` to retrieve the treatment for a given node, then uses a switch statement to execute drawing logic specific to that treatment, such as calling `drawHighlighted()` for `Treatment.Highlight` or `drawDimmed()` for `Treatment.Dim`.