@reteps/tree-sitter-htmlmustache 0.8.1 → 0.9.0

package/src/core/configSchema.ts

@@ -0,0 +1,273 @@
+/**
+ * Pure, browser-safe configuration schema: types, JSONC parsing, validation.
+ *
+ * No Node built-ins. File-system config discovery lives in
+ * `lsp/server/src/configFile.ts` and imports from this module.
+ */
+
+import type { CustomCodeTagConfig, CustomCodeTagIndentMode } from './customCodeTags.js';
+import type { CSSDisplay } from './formatting/classifier.js';
+import { KNOWN_RULE_NAMES } from './ruleMetadata.js';
+
+const VALID_CSS_DISPLAY_VALUES = new Set<string>([
+  'block', 'inline', 'inline-block', 'table-row', 'table-cell', 'table',
+  'table-row-group', 'table-header-group', 'table-footer-group', 'table-column',
+  'table-column-group', 'table-caption', 'list-item', 'ruby', 'ruby-base',
+  'ruby-text', 'none',
+]);
+
+export type RuleSeverity = 'error' | 'warning' | 'off';
+
+export interface ElementContentTooLongOptions {
+  elements: Array<{ tag: string; maxBytes: number }>;
+}
+
+export type RuleEntry = RuleSeverity | { severity: RuleSeverity };
+export type RuleEntryWithOptions<TOptions> = RuleSeverity | ({ severity: RuleSeverity } & TOptions);
+
+export interface RulesConfig {
+  nestedDuplicateSections?: RuleEntry;
+  unquotedMustacheAttributes?: RuleEntry;
+  consecutiveDuplicateSections?: RuleEntry;
+  selfClosingNonVoidTags?: RuleEntry;
+  duplicateAttributes?: RuleEntry;
+  unescapedEntities?: RuleEntry;
+  preferMustacheComments?: RuleEntry;
+  unrecognizedHtmlTags?: RuleEntry;
+  elementContentTooLong?: RuleEntryWithOptions<ElementContentTooLongOptions>;
+}
+
+const VALID_RULE_SEVERITIES = new Set<string>(['error', 'warning', 'off']);
+
+function parseElementContentTooLongOptions(raw: Record<string, unknown>): ElementContentTooLongOptions | null {
+  if (!Array.isArray(raw.elements)) return null;
+  const elements: ElementContentTooLongOptions['elements'] = [];
+  for (const entry of raw.elements) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue;
+    const e = entry as Record<string, unknown>;
+    if (typeof e.tag !== 'string' || e.tag.length === 0) continue;
+    if (typeof e.maxBytes !== 'number' || !Number.isFinite(e.maxBytes) || e.maxBytes < 0) continue;
+    elements.push({ tag: e.tag, maxBytes: e.maxBytes });
+  }
+  return { elements };
+}
+
+const OPTION_PARSERS: Partial<Record<keyof RulesConfig, (raw: Record<string, unknown>) => object | null>> = {
+  elementContentTooLong: parseElementContentTooLongOptions,
+};
+
+function parseRuleEntry(
+  key: keyof RulesConfig,
+  value: unknown,
+): RuleSeverity | { severity: RuleSeverity; [k: string]: unknown } | null {
+  if (typeof value === 'string') {
+    return VALID_RULE_SEVERITIES.has(value) ? (value as RuleSeverity) : null;
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const obj = value as Record<string, unknown>;
+  if (typeof obj.severity !== 'string' || !VALID_RULE_SEVERITIES.has(obj.severity)) return null;
+  const severity = obj.severity as RuleSeverity;
+  const parser = OPTION_PARSERS[key];
+  if (!parser) return { severity };
+  const options = parser(obj);
+  if (!options) return { severity };
+  return { severity, ...options };
+}
+
+export interface CustomRule {
+  id: string;
+  selector: string;
+  message: string;
+  severity?: RuleSeverity;
+}
+
+export interface NoBreakDelimiter {
+  start: string;
+  end: string;
+}
+
+export interface HtmlMustacheConfig {
+  printWidth?: number;
+  indentSize?: number;
+  mustacheSpaces?: boolean;
+  noBreakDelimiters?: NoBreakDelimiter[];
+  customTags?: CustomCodeTagConfig[];
+  include?: string[];
+  exclude?: string[];
+  rules?: RulesConfig;
+  customRules?: CustomRule[];
+}
+
+/**
+ * Strip // line comments, block comments, and trailing commas from JSONC text,
+ * then JSON.parse(). Preserves comments inside strings.
+ */
+export function parseJsonc(text: string): unknown {
+  let result = '';
+  let i = 0;
+  while (i < text.length) {
+    // String literal — copy verbatim
+    if (text[i] === '"') {
+      result += '"';
+      i++;
+      while (i < text.length && text[i] !== '"') {
+        if (text[i] === '\\') {
+          result += text[i] + (text[i + 1] ?? '');
+          i += 2;
+        } else {
+          result += text[i];
+          i++;
+        }
+      }
+      if (i < text.length) {
+        result += '"';
+        i++;
+      }
+      continue;
+    }
+    // Line comment
+    if (text[i] === '/' && text[i + 1] === '/') {
+      while (i < text.length && text[i] !== '\n') i++;
+      continue;
+    }
+    // Block comment
+    if (text[i] === '/' && text[i + 1] === '*') {
+      i += 2;
+      while (i < text.length && !(text[i] === '*' && text[i + 1] === '/')) i++;
+      i += 2; // skip */
+      continue;
+    }
+    result += text[i];
+    i++;
+  }
+
+  // Remove trailing commas before } or ]
+  result = result.replace(/,\s*([}\]])/g, '$1');
+
+  return JSON.parse(result);
+}
+
+const VALID_INDENT_MODES = new Set<string>(['never', 'always', 'attribute']);
+
+/**
+ * Parse an array of custom tag entries from raw config.
+ */
+function parseCustomTagArray(arr: unknown): CustomCodeTagConfig[] {
+  if (!Array.isArray(arr)) return [];
+  const tags: CustomCodeTagConfig[] = [];
+  for (const entry of arr) {
+    if (entry && typeof entry === 'object' && 'name' in entry) {
+      const e = entry as Record<string, unknown>;
+      if (typeof e.name !== 'string' || e.name.length === 0) continue;
+      const tag: CustomCodeTagConfig = { name: e.name };
+      if (typeof e.display === 'string' && VALID_CSS_DISPLAY_VALUES.has(e.display)) {
+        tag.display = e.display as CSSDisplay;
+      }
+      if (typeof e.languageAttribute === 'string') tag.languageAttribute = e.languageAttribute;
+      if (e.languageMap && typeof e.languageMap === 'object' && !Array.isArray(e.languageMap)) {
+        tag.languageMap = e.languageMap as Record<string, string>;
+      }
+      if (typeof e.languageDefault === 'string') tag.languageDefault = e.languageDefault;
+      if (typeof e.indent === 'string' && VALID_INDENT_MODES.has(e.indent)) {
+        tag.indent = e.indent as CustomCodeTagIndentMode;
+      }
+      if (typeof e.indentAttribute === 'string') tag.indentAttribute = e.indentAttribute;
+      tags.push(tag);
+    }
+  }
+  return tags;
+}
+
+/**
+ * Validate a raw parsed config object and return a typed HtmlMustacheConfig.
+ * Ignores unknown keys and invalid values.
+ */
+export function validateConfig(raw: unknown): HtmlMustacheConfig {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+  const obj = raw as Record<string, unknown>;
+  const config: HtmlMustacheConfig = {};
+
+  if (typeof obj.printWidth === 'number' && obj.printWidth > 0) {
+    config.printWidth = obj.printWidth;
+  }
+  if (typeof obj.indentSize === 'number' && obj.indentSize > 0) {
+    config.indentSize = obj.indentSize;
+  }
+  if (typeof obj.mustacheSpaces === 'boolean') {
+    config.mustacheSpaces = obj.mustacheSpaces;
+  }
+
+  if (Array.isArray(obj.noBreakDelimiters)) {
+    const items: NoBreakDelimiter[] = [];
+    for (const entry of obj.noBreakDelimiters) {
+      if (
+        entry && typeof entry === 'object' && !Array.isArray(entry) &&
+        typeof (entry as Record<string, unknown>).start === 'string' &&
+        (entry as Record<string, unknown>).start !== '' &&
+        typeof (entry as Record<string, unknown>).end === 'string' &&
+        (entry as Record<string, unknown>).end !== ''
+      ) {
+        items.push({ start: (entry as Record<string, unknown>).start as string, end: (entry as Record<string, unknown>).end as string });
+      }
+    }
+    if (items.length > 0) config.noBreakDelimiters = items;
+  }
+
+  if (Array.isArray(obj.include)) {
+    const items = obj.include.filter((s: unknown) => typeof s === 'string' && s.length > 0);
+    if (items.length > 0) config.include = items as string[];
+  }
+  if (Array.isArray(obj.exclude)) {
+    const items = obj.exclude.filter((s: unknown) => typeof s === 'string' && s.length > 0);
+    if (items.length > 0) config.exclude = items as string[];
+  }
+
+  // Parse both customCodeTags (legacy key) and customTags, merge into customTags.
+  // customTags entries override customCodeTags entries by name.
+  const parsedCodeTags = parseCustomTagArray(obj.customCodeTags);
+  const parsedCustomTags = parseCustomTagArray(obj.customTags);
+
+  if (parsedCodeTags.length > 0 || parsedCustomTags.length > 0) {
+    const mergedMap = new Map<string, CustomCodeTagConfig>();
+    for (const tag of parsedCodeTags) {
+      mergedMap.set(tag.name.toLowerCase(), tag);
+    }
+    for (const tag of parsedCustomTags) {
+      mergedMap.set(tag.name.toLowerCase(), tag);
+    }
+    config.customTags = Array.from(mergedMap.values());
+  }
+
+  if (obj.rules && typeof obj.rules === 'object' && !Array.isArray(obj.rules)) {
+    const rawRules = obj.rules as Record<string, unknown>;
+    const rules: RulesConfig = {};
+    let hasRules = false;
+    for (const [key, value] of Object.entries(rawRules)) {
+      if (!KNOWN_RULE_NAMES.has(key)) continue;
+      const entry = parseRuleEntry(key as keyof RulesConfig, value);
+      if (entry === null) continue;
+      (rules as Record<string, unknown>)[key] = entry;
+      hasRules = true;
+    }
+    if (hasRules) config.rules = rules;
+  }
+
+  if (Array.isArray(obj.customRules)) {
+    const rules: CustomRule[] = [];
+    for (const entry of obj.customRules) {
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue;
+      const e = entry as Record<string, unknown>;
+      if (typeof e.id !== 'string' || e.id.length === 0) continue;
+      if (typeof e.selector !== 'string' || e.selector.length === 0) continue;
+      if (typeof e.message !== 'string' || e.message.length === 0) continue;
+      const rule: CustomRule = { id: e.id, selector: e.selector, message: e.message };
+      if (typeof e.severity === 'string' && VALID_RULE_SEVERITIES.has(e.severity)) {
+        rule.severity = e.severity as RuleSeverity;
+      }
+      rules.push(rule);
+    }
+    if (rules.length > 0) config.customRules = rules;
+  }
+
+  return config;
+}

package/src/core/customCodeTags.ts

@@ -0,0 +1,159 @@
+import type { Node as SyntaxNode } from 'web-tree-sitter';
+import type { CSSDisplay } from './formatting/classifier.js';
+
+export type CustomCodeTagIndentMode = 'never' | 'always' | 'attribute';
+
+export interface CustomCodeTagConfig {
+  name: string;
+  display?: CSSDisplay;
+  languageAttribute?: string;
+  languageMap?: Record<string, string>;
+  languageDefault?: string;
+  indent?: CustomCodeTagIndentMode;
+  indentAttribute?: string;
+}
+
+/** Alias for CustomCodeTagConfig (unified name). */
+export type CustomTagConfig = CustomCodeTagConfig;
+
+/**
+ * Check if a custom tag config represents a code tag (has language settings).
+ * Code tags get preserved content and default to block display.
+ */
+export function isCodeTag(config: CustomCodeTagConfig): boolean {
+  return !!(config.languageAttribute || config.languageDefault);
+}
+
+export interface CustomCodeTagContent {
+  text: string;
+  languageId: string;
+  startRow: number;
+  startCol: number;
+}
+
+/**
+ * Get the attribute value for a given attribute name from an element's start tag.
+ */
+export function getAttributeValue(node: SyntaxNode, attrName: string): string | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child?.type === 'html_start_tag') {
+      for (let j = 0; j < child.childCount; j++) {
+        const attr = child.child(j);
+        if (attr?.type === 'html_attribute') {
+          let name = '';
+          let value = '';
+          for (let k = 0; k < attr.childCount; k++) {
+            const part = attr.child(k);
+            if (part?.type === 'html_attribute_name') name = part.text.toLowerCase();
+            if (part?.type === 'html_quoted_attribute_value') value = part.text.replace(/^["']|["']$/g, '');
+            if (part?.type === 'html_attribute_value') value = part.text;
+          }
+          if (name === attrName.toLowerCase()) {
+            return value;
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Resolve the language ID for a custom code tag element.
+ */
+function resolveCustomCodeLanguage(node: SyntaxNode, config: CustomCodeTagConfig): string | null {
+  if (config.languageAttribute) {
+    const attrValue = getAttributeValue(node, config.languageAttribute);
+    if (attrValue) {
+      if (config.languageMap && config.languageMap[attrValue]) {
+        return config.languageMap[attrValue];
+      }
+      return attrValue.toLowerCase();
+    }
+  }
+  return config.languageDefault?.toLowerCase() ?? null;
+}
+
+/**
+ * Walk the tree to find custom code tag elements and extract their content + language.
+ */
+export function findCustomCodeTagContent(
+  rootNode: SyntaxNode,
+  configs: CustomCodeTagConfig[],
+): CustomCodeTagContent[] {
+  if (configs.length === 0) return [];
+
+  const configsByName = new Map<string, CustomCodeTagConfig>();
+  for (const config of configs) {
+    if (config.languageAttribute || config.languageDefault) {
+      configsByName.set(config.name.toLowerCase(), config);
+    }
+  }
+  if (configsByName.size === 0) return [];
+
+  const results: CustomCodeTagContent[] = [];
+
+  const walk = (node: SyntaxNode) => {
+    if (node.type === 'html_element' || node.type === 'html_raw_element') {
+      let tagName = '';
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child?.type === 'html_start_tag') {
+          for (let j = 0; j < child.childCount; j++) {
+            const nameNode = child.child(j);
+            if (nameNode?.type === 'html_tag_name') {
+              tagName = nameNode.text.toLowerCase();
+              break;
+            }
+          }
+          break;
+        }
+      }
+
+      const config = configsByName.get(tagName);
+      if (config) {
+        const languageId = resolveCustomCodeLanguage(node, config);
+        if (languageId) {
+          let startTag: SyntaxNode | null = null;
+          let endTag: SyntaxNode | null = null;
+          for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child?.type === 'html_start_tag') startTag = child;
+            if (child?.type === 'html_end_tag') endTag = child;
+            if (child?.type === 'html_raw_text') {
+              results.push({
+                text: child.text,
+                languageId,
+                startRow: child.startPosition.row,
+                startCol: child.startPosition.column,
+              });
+            }
+          }
+
+          if (startTag && node.type === 'html_element') {
+            const contentStartIndex = startTag.endIndex;
+            const contentEndIndex = endTag ? endTag.startIndex : node.endIndex;
+            const contentText = node.tree.rootNode.text.slice(contentStartIndex, contentEndIndex);
+            if (contentText.length > 0) {
+              results.push({
+                text: contentText,
+                languageId,
+                startRow: startTag.endPosition.row,
+                startCol: startTag.endPosition.column,
+              });
+            }
+          }
+        }
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) walk(child);
+    }
+  };
+
+  walk(rootNode);
+  return results;
+}

package/src/core/diagnostic.ts

@@ -0,0 +1,45 @@
+/**
+ * Shared CheckError → public `Diagnostic` projection used by the browser
+ * entry and the CLI wrapper. 1-based line/column per the public contract;
+ * multi-edit fix array; severity defaults to `'error'` when the source
+ * checker didn't set one (parse errors, balance errors).
+ */
+
+import type { CheckError } from './collectErrors.js';
+import type { TextReplacement } from './mustacheChecks.js';
+
+export interface DiagnosticFix {
+  range: [number, number];
+  newText: string;
+}
+
+export interface Diagnostic {
+  line: number;
+  column: number;
+  endLine: number;
+  endColumn: number;
+  message: string;
+  severity: 'error' | 'warning';
+  ruleName?: string;
+  fix?: DiagnosticFix[];
+  fixDescription?: string;
+}
+
+function toFix(r: TextReplacement): DiagnosticFix {
+  return { range: [r.startIndex, r.endIndex], newText: r.newText };
+}
+
+export function toDiagnostic(err: CheckError): Diagnostic {
+  const { node } = err;
+  return {
+    line: node.startPosition.row + 1,
+    column: node.startPosition.column + 1,
+    endLine: node.endPosition.row + 1,
+    endColumn: node.endPosition.column + 1,
+    message: err.message,
+    severity: err.severity ?? 'error',
+    ruleName: err.ruleName,
+    fix: err.fix && err.fix.length > 0 ? err.fix.map(toFix) : undefined,
+    fixDescription: err.fixDescription,
+  };
+}

package/src/core/embeddedRegions.ts

@@ -0,0 +1,70 @@
+import type { Node as SyntaxNode } from 'web-tree-sitter';
+
+export interface EmbeddedRegion {
+  startIndex: number;
+  content: string;
+  languageId: string;
+}
+
+/**
+ * Get the language ID for a script or style element.
+ * Returns "javascript" for script (or "typescript" if type="text/typescript"),
+ * "css" for style.
+ */
+function getEmbeddedLanguageId(node: SyntaxNode): string {
+  if (node.type === 'html_style_element') {
+    return 'css';
+  }
+  // Check for type attribute on script elements
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child?.type === 'html_start_tag') {
+      for (let j = 0; j < child.childCount; j++) {
+        const attr = child.child(j);
+        if (attr?.type === 'html_attribute') {
+          let name = '';
+          let value = '';
+          for (let k = 0; k < attr.childCount; k++) {
+            const part = attr.child(k);
+            if (part?.type === 'html_attribute_name') name = part.text.toLowerCase();
+            if (part?.type === 'html_quoted_attribute_value') value = part.text.replace(/^["']|["']$/g, '').toLowerCase();
+            if (part?.type === 'html_attribute_value') value = part.text.toLowerCase();
+          }
+          if (name === 'type' && (value === 'text/typescript' || value === 'ts')) {
+            return 'typescript';
+          }
+        }
+      }
+    }
+  }
+  return 'javascript';
+}
+
+/**
+ * Walk the tree to collect embedded script/style regions.
+ * Skips html_raw_element (custom raw tags).
+ */
+export function collectEmbeddedRegions(rootNode: SyntaxNode): EmbeddedRegion[] {
+  const regions: EmbeddedRegion[] = [];
+  const walk = (node: SyntaxNode) => {
+    if (node.type === 'html_script_element' || node.type === 'html_style_element') {
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child?.type === 'html_raw_text') {
+          regions.push({
+            startIndex: child.startIndex,
+            content: child.text,
+            languageId: getEmbeddedLanguageId(node),
+          });
+        }
+      }
+      return;
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) walk(child);
+    }
+  };
+  walk(rootNode);
+  return regions;
+}