@zombie-mermaid/mermaid-parser 3.2.0 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zombie-mermaid/mermaid-parser",
-  "version": "3.2.0",
+  "version": "4.0.0",
   "license": "MIT",
   "description": "Parsers for class, ER, sequence, and XY chart diagrams — the per-type parse functions both svg-renderer and ascii-renderer import directly.",
   "repository": {
@@ -35,6 +35,6 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@zombie-mermaid/core": "3.2.0"
+    "@zombie-mermaid/core": "4.0.0"
   }
 }

package/src/__tests__/xychart-colors.test.ts

@@ -117,6 +117,40 @@ describe('getSeriesColor', () => {
   })
 })
 
+describe('first-three-series separation (#1244)', () => {
+  // CIE76 ΔE between two sRGB hex colors.
+  function lab(hex: string): [number, number, number] {
+    const lin = (i: number) => {
+      const v = parseInt(hex.slice(i, i + 2), 16) / 255
+      return v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4
+    }
+    const [r, g, b] = [lin(1), lin(3), lin(5)] as const
+    const x = (0.4124 * r + 0.3576 * g + 0.1805 * b) / 0.95047
+    const y = 0.2126 * r + 0.7152 * g + 0.0722 * b
+    const z = (0.0193 * r + 0.1192 * g + 0.9505 * b) / 1.08883
+    const f = (t: number) =>
+      t > 0.008856 ? Math.cbrt(t) : 7.787 * t + 16 / 116
+    return [116 * f(y) - 16, 500 * (f(x) - f(y)), 200 * (f(y) - f(z))]
+  }
+  const deltaE = (a: string, b: string) => {
+    const [l1, a1, b1] = lab(a)
+    const [l2, a2, b2] = lab(b)
+    return Math.hypot(l1 - l2, a1 - a2, b1 - b2)
+  }
+
+  // The pre-fix palette had ΔE 9 between series 0 and 2 (two similar blues).
+  for (const bg of ['#ffffff', '#1a1b26']) {
+    it(`keeps series 0, 1 and 2 at least 25 ΔE apart on ${bg}`, () => {
+      const c0 = getSeriesColor(0, '#3b82f6', bg)
+      const c1 = getSeriesColor(1, '#3b82f6', bg)
+      const c2 = getSeriesColor(2, '#3b82f6', bg)
+      expect(deltaE(c0, c1)).toBeGreaterThanOrEqual(25)
+      expect(deltaE(c0, c2)).toBeGreaterThanOrEqual(25)
+      expect(deltaE(c1, c2)).toBeGreaterThanOrEqual(25)
+    })
+  }
+})
+
 /** Minimal hex→HSL helper for assertions (mirrors colors.ts's private hexToHsl). */
 function hexLightness(hex: string): [number, number, number] {
   const h = hex.replace('#', '')

package/src/class/parser.ts

@@ -478,19 +478,14 @@ function parseMember(
     }
   }
 
-  // It's an attribute: [Type] name or name Type
-  // Common patterns: "String name", "+int age", "name"
-  const parts = parseGenericTypes(rest).split(/\s+/)
-  let name: string
-  let type: string | undefined
-
-  if (parts.length >= 2) {
-    // "Type name" pattern
-    type = parts[0]
-    name = parts.slice(1).join(' ')
-  } else {
-    name = parts[0] ?? rest
-  }
+  // It's an attribute. Mermaid renders attribute text verbatim (its
+  // ClassMember keeps everything after the visibility marker as one id and
+  // only splits methods into name/params/return type), so `String name`,
+  // `name Type` and `name: Type` all display as written. Splitting two
+  // tokens into Type + name guessed the order and flipped `-data Map` into
+  // `- Map: data` (#1265).
+  const name = parseGenericTypes(rest)
+  const type: string | undefined = undefined
 
   const isStatic = name.endsWith('$')
   const isAbstract = name.endsWith('*')

package/src/class/types.ts

@@ -110,6 +110,19 @@ export interface PositionedClassDiagram {
   classes: PositionedClassNode[]
   relationships: PositionedClassRelationship[]
   notes: PositionedClassNote[]
+  /** Namespace frames, drawn behind their member classes */
+  namespaces: PositionedClassNamespace[]
+}
+
+/** A `namespace Name { ... }` block's frame, in diagram coordinates */
+export interface PositionedClassNamespace {
+  name: string
+  /** Ids of the member classes the frame encloses */
+  classIds: string[]
+  x: number
+  y: number
+  width: number
+  height: number
 }
 
 export interface PositionedClassNote {

package/src/sequence/types.ts

@@ -216,6 +216,8 @@ export interface Activation {
   topY: number
   bottomY: number
   width: number
+  /** Nesting level on this actor's lifeline: 0 for the outermost bar, 1 for a bar opened while one is already active, and so on */
+  depth: number
 }
 
 export interface PositionedBlock {

package/src/xychart/colors.ts

@@ -4,7 +4,9 @@
 // Generates monochromatic shades from the theme accent color.
 // Series 0 = accent (or blue fallback). Series 1+ are darker/lighter
 // shades of the same hue with subtle hue drift to stay in the same
-// color family (like navy ↔ cyan from blue).
+// color family (like navy ↔ cyan from blue). Hue drifts toward navy for
+// darker shades and toward cyan for lighter ones, so neighbouring series
+// do not collapse into two near-identical blues (#1244).
 //
 // Used by both the SVG and ASCII renderers.
 // ============================================================================
@@ -101,7 +103,7 @@ export function isDarkBackground(bgHex: string): boolean {
  * Get the hex color for a series index.
  * Index 0 returns the accent color as-is.
  * Index 1+ alternate between darker and lighter shades of the same hue
- * with subtle hue drift (±8-12° per tier) to stay in the same family.
+ * with subtle hue drift (-8° per tier for darker, -12° for lighter) to stay in the same family.
  *
  * When `bgColor` is provided, shade direction adapts to the background:
  *   - Light bg: odd = darker, even = lighter (default)
@@ -128,8 +130,12 @@ export function getSeriesColor(
   const dark = safeBg && isDarkBackground(safeBg) ? !oddIndex : oddIndex
   const l = dark ? Math.max(25, 48 - tier * 13) : Math.min(78, 55 + tier * 11)
 
-  // Subtle hue drift: darker shades shift slightly negative, lighter shift positive
-  const hShift = (dark ? -8 : 12) * tier
+  // Subtle hue drift: darker shades shift slightly negative (toward navy),
+  // lighter shades shift negative too (toward sky/cyan). The lighter shade
+  // used to drift positive (toward indigo), which landed series 2 within a
+  // few ΔE of series 0 (#1244); drifting the other way keeps the three first
+  // series distinct in hue as well as lightness.
+  const hShift = (dark ? -8 : -12) * tier
   const newH = (((h + hShift) % 360) + 360) % 360
 
   return hslToHex(newH, chartS, l)