Passing tests

packages/parser/src/language/treemap/index.ts

@@ -0,0 +1 @@
+export * from './module.js';

packages/parser/src/language/treemap/module.ts

@@ -0,0 +1,88 @@
+import type {
+  DefaultSharedCoreModuleContext,
+  LangiumCoreServices,
+  LangiumSharedCoreServices,
+  Module,
+  PartialLangiumCoreServices,
+} from 'langium';
+import {
+  EmptyFileSystem,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject,
+} from 'langium';
+
+import { MermaidGeneratedSharedModule, TreemapGeneratedModule } from '../generated/module.js';
+import { TreemapTokenBuilder } from './tokenBuilder.js';
+import { TreemapValueConverter } from './valueConverter.js';
+import { TreemapValidator, registerValidationChecks } from './treemap-validator.js';
+
+/**
+ * Declaration of `Treemap` services.
+ */
+interface TreemapAddedServices {
+  parser: {
+    TokenBuilder: TreemapTokenBuilder;
+    ValueConverter: TreemapValueConverter;
+  };
+  validation: {
+    TreemapValidator: TreemapValidator;
+  };
+}
+
+/**
+ * Union of Langium default services and `Treemap` services.
+ */
+export type TreemapServices = LangiumCoreServices & TreemapAddedServices;
+
+/**
+ * Dependency injection module that overrides Langium default services and
+ * contributes the declared `Treemap` services.
+ */
+export const TreemapModule: Module<
+  TreemapServices,
+  PartialLangiumCoreServices & TreemapAddedServices
+> = {
+  parser: {
+    TokenBuilder: () => new TreemapTokenBuilder(),
+    ValueConverter: () => new TreemapValueConverter(),
+  },
+  validation: {
+    TreemapValidator: () => new TreemapValidator(),
+  },
+};
+
+/**
+ * Create the full set of services required by Langium.
+ *
+ * First inject the shared services by merging two modules:
+ *  - Langium default shared services
+ *  - Services generated by langium-cli
+ *
+ * Then inject the language-specific services by merging three modules:
+ *  - Langium default language-specific services
+ *  - Services generated by langium-cli
+ *  - Services specified in this file
+ * @param context - Optional module context with the LSP connection
+ * @returns An object wrapping the shared services and the language-specific services
+ */
+export function createTreemapServices(context: DefaultSharedCoreModuleContext = EmptyFileSystem): {
+  shared: LangiumSharedCoreServices;
+  Treemap: TreemapServices;
+} {
+  const shared: LangiumSharedCoreServices = inject(
+    createDefaultSharedCoreModule(context),
+    MermaidGeneratedSharedModule
+  );
+  const Treemap: TreemapServices = inject(
+    createDefaultCoreModule({ shared }),
+    TreemapGeneratedModule,
+    TreemapModule
+  );
+  shared.ServiceRegistry.register(Treemap);
+
+  // Register validation checks
+  registerValidationChecks(Treemap);
+
+  return { shared, Treemap };
+}

packages/parser/src/language/treemap/tokenBuilder.ts

@@ -0,0 +1,7 @@
+import { AbstractMermaidTokenBuilder } from '../common/index.js';
+
+export class TreemapTokenBuilder extends AbstractMermaidTokenBuilder {
+  public constructor() {
+    super(['treemap']);
+  }
+}

packages/parser/src/language/treemap/treemap-validator.ts

@@ -0,0 +1,77 @@
+import type { ValidationAcceptor, ValidationChecks } from 'langium';
+import type { MermaidAstType, TreemapDoc, TreemapRow } from '../generated/ast.js';
+import type { TreemapServices } from './module.js';
+
+/**
+ * Register custom validation checks.
+ */
+export function registerValidationChecks(services: TreemapServices) {
+  const validator = services.validation.TreemapValidator;
+  const registry = services.validation.ValidationRegistry;
+  if (registry) {
+    // Use any to bypass type checking since we know TreemapDoc is part of the AST
+    // but the type system is having trouble with it
+    const checks: ValidationChecks<MermaidAstType> = {
+      TreemapDoc: validator.checkSingleRoot.bind(validator),
+      TreemapRow: (node: TreemapRow, accept: ValidationAcceptor) => {
+        validator.checkSingleRootRow(node, accept);
+      },
+    };
+    registry.register(checks, validator);
+  }
+}
+
+/**
+ * Implementation of custom validations.
+ */
+export class TreemapValidator {
+  constructor() {
+    // eslint-disable-next-line no-console
+    console.debug('TreemapValidator constructor');
+  }
+  checkSingleRootRow(_node: TreemapRow, _accept: ValidationAcceptor): void {
+    // eslint-disable-next-line no-console
+    console.debug('CHECKING SINGLE ROOT Row');
+  }
+
+  /**
+   * Validates that a treemap has only one root node.
+   * A root node is defined as a node that has no indentation.
+   */
+  checkSingleRoot(doc: TreemapDoc, accept: ValidationAcceptor): void {
+    // eslint-disable-next-line no-console
+    console.debug('CHECKING SINGLE ROOT');
+    let rootNodeIndentation;
+
+    for (const row of doc.TreemapRows) {
+      // Skip non-node items (e.g., class decorations, icon decorations)
+      if (
+        !row.item ||
+        row.item.$type === 'ClassDecoration' ||
+        row.item.$type === 'IconDecoration'
+      ) {
+        continue;
+      }
+      if (
+        rootNodeIndentation === undefined && // Check if this is a root node (no indentation)
+        row.indent === undefined
+      ) {
+        rootNodeIndentation = 0;
+      } else if (row.indent === undefined) {
+        // If we've already found a root node, report an error
+        accept('error', 'Multiple root nodes are not allowed in a treemap.', {
+          node: row,
+          property: 'item',
+        });
+      } else if (
+        rootNodeIndentation !== undefined &&
+        rootNodeIndentation >= parseInt(row.indent, 10)
+      ) {
+        accept('error', 'Multiple root nodes are not allowed in a treemap.', {
+          node: row,
+          property: 'item',
+        });
+      }
+    }
+  }
+}

packages/parser/src/language/treemap/treemap.langium

@@ -0,0 +1,58 @@
+/**
+ * Treemap grammar for Langium
+ * Converted from mindmap grammar
+ *
+ * The ML_COMMENT and NL hidden terminals handle whitespace, comments, and newlines
+ * before the treemap keyword, allowing for empty lines and comments before the
+ * treemap declaration.
+ */
+grammar Treemap
+
+// Interface declarations for data types
+interface Item {}
+interface Section extends Item {
+    name: string
+}
+interface Leaf extends Item {
+    name: string
+    value: number
+}
+
+entry TreemapDoc:
+    TREEMAP_KEYWORD
+    (TreemapRows+=TreemapRow)*;
+
+terminal SEPARATOR: ':';
+terminal COMMA: ',';
+
+hidden terminal WS: /[ \t]+/;  // One or more spaces or tabs for hidden whitespace
+hidden terminal ML_COMMENT: /\%\%[^\n]*/;
+hidden terminal NL: /\r?\n/;
+
+TreemapRow:
+    indent=INDENTATION? item=Item;
+
+Item returns Item:
+    Leaf | Section;
+
+// Use a special rule order to handle the parsing precedence
+Section returns Section:
+    name=STRING;
+
+Leaf returns Leaf:
+    name=STRING INDENTATION? (SEPARATOR | COMMA) INDENTATION? value=MyNumber;
+
+// This should be processed before whitespace is ignored
+terminal INDENTATION: /[ \t]{1,}/;  // One or more spaces/tabs for indentation
+
+// Keywords with fixed text patterns
+terminal TREEMAP_KEYWORD:  'treemap';
+
+// Define as a terminal rule
+terminal NUMBER: /[0-9_\.\,]+/;
+
+// Then create a data type rule that uses it
+MyNumber returns number: NUMBER;
+
+terminal STRING: /"[^"]*"|'[^']*'/;
+// Modified indentation rule to have higher priority than WS

packages/parser/src/language/treemap/valueConverter.ts

@@ -0,0 +1,28 @@
+import type { CstNode, GrammarAST, ValueType } from 'langium';
+import { AbstractMermaidValueConverter } from '../common/index.js';
+
+export class TreemapValueConverter extends AbstractMermaidValueConverter {
+  protected runCustomConverter(
+    rule: GrammarAST.AbstractRule,
+    input: string,
+    _cstNode: CstNode
+  ): ValueType | undefined {
+    if (rule.name === 'NUMBER') {
+      // console.debug('NUMBER', input);
+      // Convert to a number by removing any commas and converting to float
+      return parseFloat(input.replace(/,/g, ''));
+    } else if (rule.name === 'SEPARATOR') {
+      // console.debug('SEPARATOR', input);
+      // Remove quotes
+      return input.substring(1, input.length - 1);
+    } else if (rule.name === 'STRING') {
+      // console.debug('STRING', input);
+      // Remove quotes
+      return input.substring(1, input.length - 1);
+    } else if (rule.name === 'INDENTATION') {
+      // console.debug('INDENTATION', input);
+      return input.length;
+    }
+    return undefined;
+  }
+}