@lithent/lithent-template-parser 0.1.0

package/src/transform/directives.ts

@@ -0,0 +1,160 @@
+import {
+  RootNode,
+  TemplateNode,
+  ElementNode,
+  NodeType,
+  DirectiveIfNode,
+  DirectiveElseIfNode,
+  DirectiveElseNode,
+} from '../parser/ast';
+
+/**
+ * Group conditional elements (l-if/l-else-if/l-else chain)
+ * This transform marks related conditional elements for easier codegen
+ */
+export interface ConditionalGroup {
+  if: ElementNode;
+  elseIfs: ElementNode[];
+  else?: ElementNode;
+}
+
+/**
+ * Transform directives in the AST
+ * Currently handles:
+ * - Grouping l-if/l-else-if/l-else chains
+ */
+export function transformDirectives(ast: RootNode): RootNode {
+  return {
+    ...ast,
+    children: transformNodeList(ast.children),
+  };
+}
+
+/**
+ * Transform a list of nodes, handling conditional grouping
+ */
+function transformNodeList(nodes: TemplateNode[]): TemplateNode[] {
+  const result: TemplateNode[] = [];
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    if (node.type === NodeType.ELEMENT) {
+      // Process element's children recursively
+      const transformedElement: ElementNode = {
+        ...node,
+        children: transformNodeList(node.children),
+      };
+
+      // Check if this starts a conditional chain
+      const ifDirective = node.directives.find(
+        d => d.type === NodeType.DIRECTIVE_IF
+      ) as DirectiveIfNode | undefined;
+
+      if (ifDirective) {
+        // This starts a conditional chain, look ahead for else-if/else
+        const conditionalGroup: ConditionalGroup = {
+          if: transformedElement,
+          elseIfs: [],
+        };
+
+        // Look ahead for else-if and else
+        let j = i + 1;
+        while (j < nodes.length) {
+          const nextNode = nodes[j];
+
+          if (nextNode.type === NodeType.ELEMENT) {
+            const elseIfDirective = nextNode.directives.find(
+              d => d.type === NodeType.DIRECTIVE_ELSE_IF
+            ) as DirectiveElseIfNode | undefined;
+
+            const elseDirective = nextNode.directives.find(
+              d => d.type === NodeType.DIRECTIVE_ELSE
+            ) as DirectiveElseNode | undefined;
+
+            if (elseIfDirective) {
+              conditionalGroup.elseIfs.push({
+                ...nextNode,
+                children: transformNodeList(nextNode.children),
+              });
+              j++;
+              continue;
+            }
+
+            if (elseDirective) {
+              conditionalGroup.else = {
+                ...nextNode,
+                children: transformNodeList(nextNode.children),
+              };
+              j++;
+              break;
+            }
+          }
+
+          // Not part of the conditional chain
+          break;
+        }
+
+        // Mark the conditional group metadata (for codegen)
+        // We'll store this in a symbol property that codegen can check
+        (transformedElement as any).__conditionalGroup = conditionalGroup;
+
+        // Skip the else-if/else nodes we've processed
+        i = j - 1;
+      }
+
+      result.push(transformedElement);
+    } else if (node.type === NodeType.FRAGMENT) {
+      result.push({
+        ...node,
+        children: transformNodeList(node.children),
+      });
+    } else {
+      // Non-element nodes pass through
+      result.push(node);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Get conditional group if element is part of one
+ */
+export function getConditionalGroup(
+  element: ElementNode
+): ConditionalGroup | undefined {
+  return (element as any).__conditionalGroup;
+}
+
+/**
+ * Check if element has a specific directive type
+ */
+export function hasDirective(
+  element: ElementNode,
+  directiveType: NodeType
+): boolean {
+  return element.directives.some(d => d.type === directiveType);
+}
+
+/**
+ * Get directive of specific type from element
+ */
+export function getDirective(
+  element: ElementNode,
+  directiveType: NodeType.DIRECTIVE_IF
+): DirectiveIfNode | undefined;
+export function getDirective(
+  element: ElementNode,
+  directiveType: NodeType.DIRECTIVE_ELSE_IF
+): DirectiveElseIfNode | undefined;
+export function getDirective(
+  element: ElementNode,
+  directiveType: NodeType.DIRECTIVE_ELSE
+): DirectiveElseNode | undefined;
+export function getDirective(
+  element: ElementNode,
+  directiveType: NodeType
+): DirectiveIfNode | DirectiveElseIfNode | DirectiveElseNode | undefined {
+  return element.directives.find(d => d.type === directiveType) as any;
+}

package/src/transform/index.ts

@@ -0,0 +1,29 @@
+import { RootNode } from '../parser/ast';
+import { transformDirectives } from './directives';
+import { optimize, OptimizeOptions } from './optimize';
+
+/**
+ * Apply all transformations to the AST
+ */
+export function transform(ast: RootNode, options?: TransformOptions): RootNode {
+  let result = ast;
+
+  // Transform directives (group conditionals)
+  result = transformDirectives(result);
+
+  // Optimize AST
+  if (options?.optimize !== false) {
+    result = optimize(result, options?.optimizeOptions);
+  }
+
+  return result;
+}
+
+export interface TransformOptions {
+  optimize?: boolean;
+  optimizeOptions?: OptimizeOptions;
+}
+
+export { transformDirectives, optimize };
+export * from './directives';
+export * from './optimize';

package/src/transform/optimize.ts

@@ -0,0 +1,203 @@
+import {
+  RootNode,
+  TemplateNode,
+  ElementNode,
+  FragmentNode,
+  TextNode,
+  NodeType,
+  createTextNode,
+} from '../parser/ast';
+
+/**
+ * Optimize the AST
+ * - Merge consecutive text nodes
+ * - Remove empty text nodes (whitespace-only)
+ * - Trim text nodes at boundaries
+ */
+export function optimize(ast: RootNode, options?: OptimizeOptions): RootNode {
+  const opts: Required<OptimizeOptions> = {
+    mergeTextNodes: true,
+    removeWhitespace: true,
+    trimText: true,
+    ...options,
+  };
+
+  return {
+    ...ast,
+    children: optimizeNodeList(ast.children, opts),
+  };
+}
+
+export interface OptimizeOptions {
+  mergeTextNodes?: boolean;
+  removeWhitespace?: boolean;
+  trimText?: boolean;
+}
+
+/**
+ * Optimize a list of nodes
+ */
+function optimizeNodeList(
+  nodes: TemplateNode[],
+  options: Required<OptimizeOptions>
+): TemplateNode[] {
+  let result: TemplateNode[] = nodes.map(node => optimizeNode(node, options));
+
+  // Merge consecutive text nodes
+  if (options.mergeTextNodes) {
+    result = mergeTextNodes(result);
+  }
+
+  // Remove whitespace-only text nodes
+  if (options.removeWhitespace) {
+    result = removeWhitespaceNodes(result);
+  }
+
+  return result;
+}
+
+/**
+ * Optimize a single node
+ */
+function optimizeNode(
+  node: TemplateNode,
+  options: Required<OptimizeOptions>
+): TemplateNode {
+  if (node.type === NodeType.ELEMENT) {
+    return optimizeElementNode(node, options);
+  }
+
+  if (node.type === NodeType.FRAGMENT) {
+    return optimizeFragmentNode(node, options);
+  }
+
+  if (node.type === NodeType.TEXT) {
+    return optimizeTextNode(node, options);
+  }
+
+  return node;
+}
+
+/**
+ * Optimize an element node
+ */
+function optimizeElementNode(
+  node: ElementNode,
+  options: Required<OptimizeOptions>
+): ElementNode {
+  return {
+    ...node,
+    children: optimizeNodeList(node.children, options),
+  };
+}
+
+/**
+ * Optimize a fragment node
+ */
+function optimizeFragmentNode(
+  node: FragmentNode,
+  options: Required<OptimizeOptions>
+): FragmentNode {
+  return {
+    ...node,
+    children: optimizeNodeList(node.children, options),
+  };
+}
+
+/**
+ * Optimize a text node
+ */
+function optimizeTextNode(
+  node: TextNode,
+  options: Required<OptimizeOptions>
+): TextNode {
+  let content = node.content;
+
+  // Trim text if enabled
+  if (options.trimText) {
+    content = content.trim();
+  }
+
+  return {
+    ...node,
+    content,
+  };
+}
+
+/**
+ * Merge consecutive text nodes
+ */
+function mergeTextNodes(nodes: TemplateNode[]): TemplateNode[] {
+  const result: TemplateNode[] = [];
+  let currentText: TextNode | null = null;
+
+  for (const node of nodes) {
+    if (node.type === NodeType.TEXT) {
+      if (currentText) {
+        // Merge with previous text node
+        currentText = createTextNode(
+          currentText.content + node.content,
+          currentText.start,
+          node.end
+        );
+      } else {
+        currentText = node;
+      }
+    } else {
+      // Push accumulated text node if any
+      if (currentText) {
+        result.push(currentText);
+        currentText = null;
+      }
+      result.push(node);
+    }
+  }
+
+  // Don't forget the last text node
+  if (currentText) {
+    result.push(currentText);
+  }
+
+  return result;
+}
+
+/**
+ * Remove whitespace-only text nodes
+ */
+function removeWhitespaceNodes(nodes: TemplateNode[]): TemplateNode[] {
+  return nodes.filter(node => {
+    if (node.type === NodeType.TEXT) {
+      return node.content.trim().length > 0;
+    }
+    return true;
+  });
+}
+
+/**
+ * Check if a text node is whitespace-only
+ */
+export function isWhitespaceOnly(node: TextNode): boolean {
+  return node.content.trim().length === 0;
+}
+
+/**
+ * Count nodes in the tree
+ */
+export function countNodes(node: RootNode | TemplateNode): number {
+  let count = 1;
+
+  if (node.type === NodeType.ROOT) {
+    node.children.forEach(child => {
+      count += countNodes(child);
+    });
+  } else if (
+    node.type === NodeType.ELEMENT ||
+    node.type === NodeType.FRAGMENT
+  ) {
+    node.children.forEach(child => {
+      count += countNodes(child);
+    });
+  }
+
+  return count;
+}