coffeehaml 0.7.3 → 0.7.5

package/dist/coffeescript-formatter.js

@@ -0,0 +1,309 @@
+// Generated by CoffeeScript 2.7.0
+// coffeescript-formatter.coffee — CoffeeScript token-based expression formatter
+var DEFAULT_OPTS, EXPR_STARTERS, FOR_KEYWORDS, KEYWORD_SPACE_AFTER, NO_SPACE_AFTER, NO_SPACE_BEFORE, SPACE_AFTER, SPACE_BOTH, _require, getTokenText, hasImplicitTokens, hasMethodChain, isUnaryOp, lineWrap, loadCoffeeScript, needsSpaceBetween, normalizeSpacing, wrapMethodChain;
+
+import {
+  createRequire
+} from 'module';
+
+_require = createRequire(import.meta.url);
+
+loadCoffeeScript = function() {
+  try {
+    return _require('coffeescript');
+  } catch (error) {
+    return null;
+  }
+};
+
+// ─── Token types ──────────────────────────────────────────
+// CSToken: { type, value, range, generated?, originalText? }
+
+// ─── Spacing categories ───────────────────────────────────
+NO_SPACE_BEFORE = new Set([',', ':', ';', '.', '?.', '::', ')', ']', '}', 'CALL_END', 'PARAM_END', 'INDEX_END', 'POST_IF', 'POST_FOR', 'POST_WHILE', 'TERMINATOR']);
+
+NO_SPACE_AFTER = new Set(['.', '?.', '::', '...', '..', '(', '[', '{', 'CALL_START', 'PARAM_START', 'INDEX_START', 'STRING_START', 'INTERPOLATION_START', 'INDENT', '@']);
+
+SPACE_AFTER = new Set([',', ':']);
+
+SPACE_BOTH = new Set(['=', '?=', '+', '-', 'MATH', '**', 'SHIFT', '&', '|', '^', '&&', '||', '?', '=>', '->', 'COMPARE', 'COMPOUND_ASSIGN', 'RELATION', 'FOR', 'ELSE', 'IF', 'WHILE']);
+
+KEYWORD_SPACE_AFTER = new Set(['RETURN', 'THROW', 'NEW', 'TYPEOF', 'INSTANCEOF', 'DELETE', 'CLASS', 'EXTENDS', 'DEFAULT', 'IMPORT', 'EXPORT', 'AWAIT', 'YIELD', 'BREAK', 'CONTINUE', 'SWITCH']);
+
+FOR_KEYWORDS = new Set(['FORIN', 'FOROF', 'WHEN', 'BY']);
+
+EXPR_STARTERS = new Set(['(', '[', '{', ',', ':', '=', '?=', '+', '-', 'MATH', '**', 'SHIFT', '&', '|', '^', '&&', '||', '?', '=>', '->', 'COMPARE', 'COMPOUND_ASSIGN', 'RETURN', 'INDENT', 'OUTDENT', 'TERMINATOR', 'FOR', 'FORIN', 'FOROF', 'WHILE', 'IF', 'ELSE', 'THROW', 'NEW', 'TYPEOF', 'INSTANCEOF', 'DELETE', 'EXTENDS', 'DEFAULT', 'CALL_START', 'PARAM_START', 'INDEX_START', 'UNARY']);
+
+DEFAULT_OPTS = {
+  printWidth: 80,
+  methodChainAlign: true,
+  enabled: true
+};
+
+// ─── Public API ───────────────────────────────────────────
+export var formatCoffeeScript = function(source, options = {}) {
+  var cs, normalized, opts, rawTokens, tokens;
+  opts = {...DEFAULT_OPTS, ...options};
+  if (!opts.enabled) {
+    return source;
+  }
+  if (!(source && source.trim() !== '')) {
+    return source;
+  }
+  try {
+    cs = loadCoffeeScript();
+    if (!(cs && typeof cs.tokens === 'function')) {
+      return source;
+    }
+    rawTokens = cs.tokens(source);
+    if (!(rawTokens && rawTokens.length > 0)) {
+      return source;
+    }
+    tokens = rawTokens.map(function(t) {
+      var ref, ref1, ref2, ref3;
+      return {
+        type: t[0],
+        value: t[1],
+        range: (ref = (ref1 = t[2]) != null ? ref1.range : void 0) != null ? ref : [0, 0],
+        generated: !!((ref2 = t[2]) != null ? ref2.generated : void 0),
+        originalText: ((ref3 = t[2]) != null ? ref3.range : void 0) && t[2].range[0] < t[2].range[1] ? source.slice(t[2].range[0], t[2].range[1]) : t[1]
+      };
+    });
+    if (hasImplicitTokens(tokens)) {
+      return source;
+    }
+    normalized = normalizeSpacing(tokens, source);
+    if (normalized.length > opts.printWidth) {
+      return lineWrap(normalized, opts, source);
+    }
+    return normalized;
+  } catch (error) {
+    return source;
+  }
+};
+
+// ─── Block formatting ─────────────────────────────────────
+export var formatCoffeeScriptBlock = function(source, options = {}) {
+  var formatted, lines, opts;
+  opts = {...DEFAULT_OPTS, ...options};
+  if (!opts.enabled) {
+    return source;
+  }
+  if (!(source && source.trim() !== '')) {
+    return source;
+  }
+  lines = source.split('\n');
+  formatted = lines.map(function(line) {
+    var formattedExpr, leading, ref, ref1, trimmed;
+    trimmed = line.trim();
+    if (!trimmed) {
+      return '';
+    }
+    leading = (ref = (ref1 = line.match(/^(\s*)/)) != null ? ref1[1] : void 0) != null ? ref : '';
+    try {
+      formattedExpr = formatCoffeeScript(trimmed, options);
+      return leading + formattedExpr;
+    } catch (error) {
+      return line;
+    }
+  });
+  return formatted.join('\n');
+};
+
+// ─── Implicit token detection ─────────────────────────────
+hasImplicitTokens = function(tokens) {
+  var j, len, ref, t;
+  for (j = 0, len = tokens.length; j < len; j++) {
+    t = tokens[j];
+    if ((ref = t.type) === 'INDENT' || ref === 'OUTDENT' || ref === 'TERMINATOR') {
+      continue;
+    }
+    if (t.generated) {
+      return true;
+    }
+    if (t.range && t.range[0] >= t.range[1]) {
+      return true;
+    }
+  }
+  return false;
+};
+
+// ─── Spacing normalization ────────────────────────────────
+normalizeSpacing = function(tokens, originalSource = null) {
+  var afterPrevIsExprStart, cur, j, len, parts, prevVisible, prevWasAtExprStart, ref, ref1, ref2, text, trimmed;
+  parts = [];
+  prevVisible = null;
+  prevWasAtExprStart = true;
+  afterPrevIsExprStart = true;
+  for (j = 0, len = tokens.length; j < len; j++) {
+    cur = tokens[j];
+    // Skip implicit CALL/PARAM tokens
+    if ((ref = cur.type) === 'CALL_START' || ref === 'CALL_END') {
+      if (cur.generated) {
+        continue;
+      }
+      if (cur.range && cur.range[0] >= cur.range[1]) {
+        continue;
+      }
+    }
+    if ((ref1 = cur.type) === 'PARAM_START' || ref1 === 'PARAM_END') {
+      if (cur.generated) {
+        continue;
+      }
+      if (cur.range && cur.range[0] >= cur.range[1]) {
+        continue;
+      }
+    }
+    // Handle INDENT — represents inline then/when/else/etc from CoffeeScript
+    if (cur.type === 'INDENT') {
+      text = getTokenText(cur, originalSource);
+      trimmed = text != null ? text.trim() : void 0;
+      if (trimmed && trimmed !== '') {
+        parts.push(' ' + trimmed + ' ');
+        prevWasAtExprStart = false;
+        afterPrevIsExprStart = true;
+        prevVisible = cur;
+      }
+      continue;
+    }
+    if (cur.type === 'OUTDENT') {
+      continue;
+    }
+    // Skip TERMINATOR
+    if (cur.type === 'TERMINATOR') {
+      continue;
+    }
+    // Space before this token
+    if (prevVisible && ((ref2 = prevVisible.type) !== 'INDENT' && ref2 !== 'OUTDENT')) {
+      if (needsSpaceBetween(prevVisible, cur, prevWasAtExprStart)) {
+        parts.push(' ');
+      }
+    }
+    parts.push(getTokenText(cur, originalSource));
+    prevWasAtExprStart = afterPrevIsExprStart;
+    afterPrevIsExprStart = EXPR_STARTERS.has(cur.type);
+    prevVisible = cur;
+  }
+  return parts.join('');
+};
+
+getTokenText = function(token, originalSource = null) {
+  if (token.generated) {
+    return token.value;
+  }
+  if (!(token.range && token.range[0] < token.range[1])) {
+    return token.value;
+  }
+  if (originalSource) {
+    return originalSource.slice(token.range[0], token.range[1]);
+  }
+  return token.value;
+};
+
+needsSpaceBetween = function(prev, cur, prevAtExprStart) {
+  var text;
+  if (NO_SPACE_AFTER.has(prev.type)) {
+    return false;
+  }
+  if (NO_SPACE_BEFORE.has(cur.type)) {
+    return false;
+  }
+  if (prev.type === '@') {
+    return false;
+  }
+  if (SPACE_AFTER.has(prev.type)) {
+    return true;
+  }
+  if (FOR_KEYWORDS.has(prev.type) || FOR_KEYWORDS.has(cur.type)) {
+    return true;
+  }
+  if (KEYWORD_SPACE_AFTER.has(prev.type)) {
+    return true;
+  }
+  if (prev.type === 'UNARY') {
+    text = prev.originalText || prev.value;
+    if (text === '!' || text === '!!') {
+      return false;
+    }
+    return true;
+  }
+  if (SPACE_BOTH.has(prev.type) || SPACE_BOTH.has(cur.type)) {
+    if (isUnaryOp(prev, prevAtExprStart)) {
+      return false;
+    }
+    return true;
+  }
+  if (prev.type === 'IDENTIFIER' && cur.type === 'IDENTIFIER') {
+    return true;
+  }
+  return false;
+};
+
+isUnaryOp = function(prev, prevAtExprStart) {
+  var ref;
+  if ((ref = prev.type) !== '+' && ref !== '-') {
+    return false;
+  }
+  if (prevAtExprStart) {
+    return true;
+  }
+  if (prev.range && prev.range[0] === 0) {
+    return true;
+  }
+  return false;
+};
+
+// ─── Line wrapping ────────────────────────────────────────
+lineWrap = function(source, opts, fallback) {
+  if (opts.methodChainAlign && hasMethodChain(source)) {
+    return wrapMethodChain(source, opts);
+  }
+  return fallback;
+};
+
+hasMethodChain = function(source) {
+  return (source.match(/\.[a-zA-Z_$]/g) || []).length >= 2;
+};
+
+wrapMethodChain = function(source, _opts) {
+  var ch, chars, current, depth, i, indent, result;
+  indent = '  ';
+  result = [];
+  chars = [...source];
+  depth = 0;
+  current = '';
+  i = 0;
+  while (i < chars.length) {
+    ch = chars[i];
+    if (ch === '(' || ch === '[' || ch === '{') {
+      depth++;
+    }
+    if (ch === ')' || ch === ']' || ch === '}') {
+      depth--;
+    }
+    if (ch === '.' && depth === 0 && i > 0 && chars[i - 1] !== '?' && current.trim().length > 0) {
+      if (result.length === 0) {
+        result.push(current.trimEnd());
+      } else {
+        result.push(indent + current.trimEnd());
+      }
+      current = ch;
+      i++;
+      continue;
+    }
+    current += ch;
+    i++;
+  }
+  if (current.trim().length > 0) {
+    if (result.length === 0) {
+      result.push(current.trim());
+    } else {
+      result.push(indent + current.trim());
+    }
+  }
+  if (result.length > 1) {
+    return result.join('\n');
+  } else {
+    return source;
+  }
+};

package/dist/lexer.js

@@ -1,7 +1,7 @@
 // Generated by CoffeeScript 2.7.0
 // lexer.coffee — CoffeeHaml tokenizer
 // Converts raw .chaml source into a token stream with INDENT/DEDENT
-var countIndent, dedentToken, extractBracketed, indentToken, isHamlConstruct, parseModifiersAndAttrs, preMergeBracketLines, tokenizeLine;
+var countIndent, dedentToken, extractBracketed, indentToken, isHamlConstruct, looksLikeBareAttributes, parseModifiersAndAttrs, preMergeBracketLines, tokenizeLine;
 
 import {
   SourceLocation
@@ -14,6 +14,7 @@ export var TokenType = {
   ID: 'ID',
   ATTRS_PAREN: 'ATTRS_PAREN',
   ATTRS_BRACE: 'ATTRS_BRACE',
+  ATTRS_BARE: 'ATTRS_BARE',
   OUTPUT: 'OUTPUT',
   OUTPUT_UNESC: 'OUTPUT_UNESC',
   CONTROL: 'CONTROL',
@@ -222,6 +223,12 @@ tokenizeLine = function(content, lineStartOffset, _lineLength, filename = null,
           value: remaining.slice(2).trimStart(),
           location: loc(trimmedOffset + 2, content.length)
         });
+      } else if (looksLikeBareAttributes(remaining)) {
+        tokens.push({
+          type: TokenType.ATTRS_BARE,
+          value: remaining,
+          location: loc(trimmedOffset, content.length)
+        });
       } else if (!(remaining.startsWith('{') || remaining.startsWith('('))) {
         tokens.push({
           type: TokenType.TEXT,
@@ -261,6 +268,12 @@ tokenizeLine = function(content, lineStartOffset, _lineLength, filename = null,
           value: remaining.slice(2).trimStart(),
           location: loc(trimmedOffset + 2, content.length)
         });
+      } else if (looksLikeBareAttributes(remaining)) {
+        tokens.push({
+          type: TokenType.ATTRS_BARE,
+          value: remaining,
+          location: loc(trimmedOffset, content.length)
+        });
       } else if (!(remaining.startsWith('{') || remaining.startsWith('('))) {
         tokens.push({
           type: TokenType.TEXT,
@@ -468,6 +481,38 @@ parseModifiersAndAttrs = function(content, startPos, lineStartOffset, filename =
 };
 
 // ─── Helpers ───────────────────────────────────────────────
+
+// Detects bare HTML-style attributes: key="val", key='val', key={expr}
+looksLikeBareAttributes = function(text) {
+  var j, len, part, parts, ref;
+  if (!(text && text.length > 0)) {
+    return false;
+  }
+  if (!text.includes('=')) {
+    // Must contain at least one = sign
+    return false;
+  }
+  // Split on whitespace, skip empty
+  parts = (ref = text.match(/\S+/g)) != null ? ref : [];
+  if (parts.length === 0) {
+    return false;
+  }
+// At least one part must look like key=value or be {expr}
+  for (j = 0, len = parts.length; j < len; j++) {
+    part = parts[j];
+    if (/^[\w-]+=/.test(part)) { // key="val" or key='val' or key={expr}
+      return true;
+    }
+    if (/^[\w-]+\{/.test(part)) { // key{...}  alternative
+      return true;
+    }
+    if (/^=\{/.test(part)) { // ={expr}
+      return true;
+    }
+  }
+  return false;
+};
+
 isHamlConstruct = function(content) {
   var fc;
   fc = content[0];

package/dist/options.js

@@ -0,0 +1,232 @@
+// Generated by CoffeeScript 2.7.0
+// options.coffee — CoffeeHaml Prettier formatting options
+export var CAT = {
+  STRUCTURE: 'CoffeeHaml: Structure',
+  ATTRIBUTES: 'CoffeeHaml: Attributes',
+  COFFEESCRIPT: 'CoffeeHaml: CoffeeScript',
+  WHITESPACE: 'CoffeeHaml: Whitespace',
+  CONTROL_FLOW: 'CoffeeHaml: Control Flow',
+  COMMENTS: 'CoffeeHaml: Comments'
+};
+
+export var options = {
+  tagCase: {
+    category: CAT.STRUCTURE,
+    type: 'choice',
+    description: 'Normalize HTML tag casing. Component tags (%MyComponent) never affected.',
+    choices: [
+      {
+        value: 'preserve',
+        description: 'Leave tag case as written'
+      },
+      {
+        value: 'lowercase',
+        description: '%DIV to %div (HTML tags only)'
+      }
+    ]
+  },
+  implicitDivExpansion: {
+    category: CAT.STRUCTURE,
+    type: 'boolean',
+    description: 'Expand .class to %div.class (anti-idiomatic in HAML).'
+  },
+  maxChainLength: {
+    category: CAT.STRUCTURE,
+    type: 'int',
+    description: 'Max .class chain length before breaking into indented hierarchy. 0 = always break.'
+  },
+  inlineThreshold: {
+    category: CAT.STRUCTURE,
+    type: 'int',
+    description: 'Try single-line if estimated width <= this. -1 = never inline children.'
+  },
+  voidElementStyle: {
+    category: CAT.STRUCTURE,
+    type: 'choice',
+    description: 'How void elements (%br, %img, etc.) are formatted.',
+    choices: [
+      {
+        value: 'self-closing',
+        description: 'Self-closing (no children)'
+      },
+      {
+        value: 'explicit',
+        description: 'Preserve %br/ syntax, otherwise self-close'
+      }
+    ]
+  },
+  attributeStyle: {
+    category: CAT.ATTRIBUTES,
+    type: 'choice',
+    description: 'Enforce attribute syntax: {braces}, (parens), bare, or preserve.',
+    choices: [
+      {
+        value: 'preserve',
+        description: 'Keep as written'
+      },
+      {
+        value: 'braces',
+        description: 'Convert to {CoffeeScript} style'
+      },
+      {
+        value: 'parens',
+        description: 'Convert to HTML (parens) style'
+      },
+      {
+        value: 'bare',
+        description: 'Convert to bare HAML style'
+      }
+    ]
+  },
+  attributeMultilineThreshold: {
+    category: CAT.ATTRIBUTES,
+    type: 'int',
+    description: 'Break attributes across lines when count >= this. 0 = always multiline.'
+  },
+  attributeSort: {
+    category: CAT.ATTRIBUTES,
+    type: 'choice',
+    description: 'Sort attribute keys (spread attributes always last).',
+    choices: [
+      {
+        value: 'none',
+        description: 'Preserve author order'
+      },
+      {
+        value: 'alphabetical',
+        description: 'Sort A to Z'
+      },
+      {
+        value: 'idiomatic',
+        description: 'id first, class second, rest A to Z'
+      }
+    ]
+  },
+  quoteStyle: {
+    category: CAT.ATTRIBUTES,
+    type: 'choice',
+    description: 'Quote style for bare/HAML attributes.',
+    choices: [
+      {
+        value: 'preserve',
+        description: 'Keep as written'
+      },
+      {
+        value: 'double',
+        description: 'Force double quotes'
+      },
+      {
+        value: 'single',
+        description: 'Force single quotes'
+      }
+    ]
+  },
+  coffeeScriptFormat: {
+    category: CAT.COFFEESCRIPT,
+    type: 'boolean',
+    description: 'Format CoffeeScript expressions using prettier/plugins/coffeescript.'
+  },
+  methodChainAlign: {
+    category: CAT.COFFEESCRIPT,
+    type: 'boolean',
+    description: 'Align .method chains on newlines for = expressions.'
+  },
+  blankLineHandling: {
+    category: CAT.WHITESPACE,
+    type: 'choice',
+    description: 'How blank lines between sibling elements are treated.',
+    choices: [
+      {
+        value: 'preserve',
+        description: 'Keep single; collapse multiples'
+      },
+      {
+        value: 'collapse',
+        description: 'Remove all blank lines between siblings'
+      },
+      {
+        value: 'respect',
+        description: 'Keep exactly as written'
+      }
+    ]
+  },
+  trailingWhitespace: {
+    category: CAT.WHITESPACE,
+    type: 'choice',
+    description: 'Handle trailing whitespace.',
+    choices: [
+      {
+        value: 'remove',
+        description: 'Strip trailing whitespace'
+      },
+      {
+        value: 'preserve',
+        description: 'Leave as written'
+      }
+    ]
+  },
+  continuationStyle: {
+    category: CAT.CONTROL_FLOW,
+    type: 'choice',
+    description: 'How \\ continuations are formatted.',
+    choices: [
+      {
+        value: 'preserve',
+        description: 'Keep as written'
+      },
+      {
+        value: 'indent',
+        description: 'Always use indented continuation'
+      },
+      {
+        value: 'backslash',
+        description: 'Always use \\ continuation'
+      }
+    ]
+  },
+  controlFlowInline: {
+    category: CAT.CONTROL_FLOW,
+    type: 'boolean',
+    description: 'Allow - if x then .ok one-liners (anti-Prettier by default).'
+  },
+  statementMerging: {
+    category: CAT.CONTROL_FLOW,
+    type: 'choice',
+    description: 'Merge consecutive - lines into a single indented block. Only childless statements.',
+    choices: [
+      {
+        value: 'preserve',
+        description: 'Keep each - line separate'
+      },
+      {
+        value: 'merge',
+        description: 'Merge consecutive childless statements into one indented block'
+      }
+    ]
+  },
+  commentFormat: {
+    category: CAT.COMMENTS,
+    type: 'boolean',
+    description: 'Reflow/word-wrap comment text (experimental).'
+  }
+};
+
+export var defaultOptions = {
+  tagCase: 'preserve',
+  implicitDivExpansion: false,
+  maxChainLength: 4,
+  inlineThreshold: -1,
+  voidElementStyle: 'self-closing',
+  attributeStyle: 'preserve',
+  attributeMultilineThreshold: 1,
+  attributeSort: 'none',
+  quoteStyle: 'preserve',
+  coffeeScriptFormat: true,
+  methodChainAlign: true,
+  blankLineHandling: 'preserve',
+  trailingWhitespace: 'remove',
+  continuationStyle: 'indent',
+  controlFlowInline: false,
+  statementMerging: 'preserve',
+  commentFormat: false
+};