@lithent/lithent-template-parser 0.1.0

package/dist/parser/ast.d.ts

@@ -0,0 +1,207 @@
+import { Position } from './tokens';
+/**
+ * Base AST Node interface
+ */
+export interface BaseNode {
+    type: string;
+    start: Position;
+    end: Position;
+}
+/**
+ * Node types
+ */
+export declare enum NodeType {
+    ROOT = "Root",
+    ELEMENT = "Element",
+    FRAGMENT = "Fragment",
+    TEXT = "Text",
+    INTERPOLATION = "Interpolation",
+    COMMENT = "Comment",
+    ATTRIBUTE = "Attribute",
+    DIRECTIVE_IF = "DirectiveIf",
+    DIRECTIVE_ELSE_IF = "DirectiveElseIf",
+    DIRECTIVE_ELSE = "DirectiveElse",
+    DIRECTIVE_FOR = "DirectiveFor"
+}
+/**
+ * Root node - represents the entire template
+ */
+export interface RootNode extends BaseNode {
+    type: NodeType.ROOT;
+    children: TemplateNode[];
+}
+/**
+ * Element node - represents HTML element or component
+ */
+export interface ElementNode extends BaseNode {
+    type: NodeType.ELEMENT;
+    tag: string;
+    isComponent: boolean;
+    isSelfClosing: boolean;
+    attributes: AttributeNode[];
+    directives: DirectiveNode[];
+    children: TemplateNode[];
+    ref?: string;
+}
+/**
+ * Fragment node - represents <></>
+ */
+export interface FragmentNode extends BaseNode {
+    type: NodeType.FRAGMENT;
+    children: TemplateNode[];
+}
+/**
+ * Text node - represents plain text content
+ */
+export interface TextNode extends BaseNode {
+    type: NodeType.TEXT;
+    content: string;
+}
+/**
+ * Interpolation node - represents {expression}
+ */
+export interface InterpolationNode extends BaseNode {
+    type: NodeType.INTERPOLATION;
+    expression: string;
+}
+/**
+ * Comment node - represents HTML comments
+ */
+export interface CommentNode extends BaseNode {
+    type: NodeType.COMMENT;
+    content: string;
+}
+/**
+ * Attribute node - represents element attributes
+ */
+export interface AttributeNode extends BaseNode {
+    type: NodeType.ATTRIBUTE;
+    name: string;
+    value: AttributeValue | null;
+    isDynamic: boolean;
+}
+/**
+ * Attribute value can be static string or expression
+ */
+export type AttributeValue = string | {
+    expression: string;
+};
+/**
+ * Base directive node
+ */
+export interface BaseDirectiveNode extends BaseNode {
+    type: NodeType.DIRECTIVE_IF | NodeType.DIRECTIVE_ELSE_IF | NodeType.DIRECTIVE_ELSE | NodeType.DIRECTIVE_FOR;
+}
+/**
+ * l-if directive
+ */
+export interface DirectiveIfNode extends BaseDirectiveNode {
+    type: NodeType.DIRECTIVE_IF;
+    condition: string;
+}
+/**
+ * l-else-if directive
+ */
+export interface DirectiveElseIfNode extends BaseDirectiveNode {
+    type: NodeType.DIRECTIVE_ELSE_IF;
+    condition: string;
+}
+/**
+ * l-else directive
+ */
+export interface DirectiveElseNode extends BaseDirectiveNode {
+    type: NodeType.DIRECTIVE_ELSE;
+}
+/**
+ * l-for directive
+ */
+export interface DirectiveForNode extends BaseDirectiveNode {
+    type: NodeType.DIRECTIVE_FOR;
+    item: string;
+    index?: string;
+    list: string;
+}
+/**
+ * Union type for all directive nodes
+ */
+export type DirectiveNode = DirectiveIfNode | DirectiveElseIfNode | DirectiveElseNode | DirectiveForNode;
+/**
+ * Union type for all template nodes (excluding Root)
+ */
+export type TemplateNode = ElementNode | FragmentNode | TextNode | InterpolationNode | CommentNode;
+/**
+ * Type guard for Element nodes
+ */
+export declare function isElementNode(node: TemplateNode): node is ElementNode;
+/**
+ * Type guard for Fragment nodes
+ */
+export declare function isFragmentNode(node: TemplateNode): node is FragmentNode;
+/**
+ * Type guard for Text nodes
+ */
+export declare function isTextNode(node: TemplateNode): node is TextNode;
+/**
+ * Type guard for Interpolation nodes
+ */
+export declare function isInterpolationNode(node: TemplateNode): node is InterpolationNode;
+/**
+ * Type guard for Comment nodes
+ */
+export declare function isCommentNode(node: TemplateNode): node is CommentNode;
+/**
+ * Type guard for directive nodes
+ */
+export declare function isDirective(node: AttributeNode | DirectiveNode): node is DirectiveNode;
+/**
+ * Create a root node
+ */
+export declare function createRootNode(children: TemplateNode[], start: Position, end: Position): RootNode;
+/**
+ * Create an element node
+ */
+export declare function createElementNode(tag: string, attributes: AttributeNode[], directives: DirectiveNode[], children: TemplateNode[], isSelfClosing: boolean, start: Position, end: Position): ElementNode;
+/**
+ * Create a fragment node
+ */
+export declare function createFragmentNode(children: TemplateNode[], start: Position, end: Position): FragmentNode;
+/**
+ * Create a text node
+ */
+export declare function createTextNode(content: string, start: Position, end: Position): TextNode;
+/**
+ * Create an interpolation node
+ */
+export declare function createInterpolationNode(expression: string, start: Position, end: Position): InterpolationNode;
+/**
+ * Create a comment node
+ */
+export declare function createCommentNode(content: string, start: Position, end: Position): CommentNode;
+/**
+ * Create an attribute node
+ */
+export declare function createAttributeNode(name: string, value: AttributeValue | null, isDynamic: boolean, start: Position, end: Position): AttributeNode;
+/**
+ * Create a l-if directive node
+ */
+export declare function createDirectiveIfNode(condition: string, start: Position, end: Position): DirectiveIfNode;
+/**
+ * Create a l-else-if directive node
+ */
+export declare function createDirectiveElseIfNode(condition: string, start: Position, end: Position): DirectiveElseIfNode;
+/**
+ * Create a l-else directive node
+ */
+export declare function createDirectiveElseNode(start: Position, end: Position): DirectiveElseNode;
+/**
+ * Create a l-for directive node
+ */
+export declare function createDirectiveForNode(item: string, list: string, index: string | undefined, start: Position, end: Position): DirectiveForNode;
+/**
+ * Walk through AST and call visitor function for each node
+ */
+export declare function walk(node: RootNode | TemplateNode, visitor: (node: TemplateNode) => void): void;
+/**
+ * Transform AST by applying a transformer function to each node
+ */
+export declare function transformTree(node: RootNode | TemplateNode, transformer: (node: TemplateNode) => TemplateNode): RootNode | TemplateNode;

package/dist/parser/lexer.d.ts

@@ -0,0 +1,109 @@
+import { Token } from './tokens';
+/**
+ * Lexer for Lithent templates
+ * Converts template string into a stream of tokens
+ */
+export declare class Lexer {
+    private input;
+    private position;
+    private line;
+    private column;
+    private tokens;
+    constructor(input: string);
+    /**
+     * Tokenize the entire input
+     */
+    tokenize(): Token[];
+    /**
+     * Get current position
+     */
+    private getCurrentPosition;
+    /**
+     * Peek at character without consuming
+     */
+    private peek;
+    /**
+     * Consume and return current character
+     */
+    private advance;
+    /**
+     * Check if we've reached the end
+     */
+    private isEOF;
+    /**
+     * Read next token
+     */
+    private readToken;
+    /**
+     * Read HTML comment
+     */
+    private readComment;
+    /**
+     * Read opening tag <
+     */
+    private readOpenTag;
+    /**
+     * Read closing tag </
+     */
+    private readCloseTag;
+    /**
+     * Read tag content (tag name and attributes)
+     */
+    private readTagContent;
+    /**
+     * Read an attribute (name and optional value)
+     */
+    private readAttribute;
+    /**
+     * Read identifier (tag name or attribute name)
+     */
+    private readIdentifier;
+    /**
+     * Determine token type for identifier
+     */
+    private getIdentifierTokenType;
+    /**
+     * Read string literal
+     */
+    private readStringLiteral;
+    /**
+     * Read fragment open <>
+     */
+    private readFragmentOpen;
+    /**
+     * Read fragment close </>
+     */
+    private readFragmentClose;
+    /**
+     * Read expression content inside {}
+     */
+    private readExpression;
+    /**
+     * Read text content
+     */
+    private readText;
+    /**
+     * Read whitespace
+     */
+    private readWhitespace;
+    /**
+     * Skip whitespace without creating tokens
+     */
+    private skipWhitespace;
+    /**
+     * Check if character is whitespace
+     */
+    private isWhitespace;
+    /**
+     * Check if character can start an identifier
+     */
+    private isIdentifierStart;
+    /**
+     * Check if character can be part of an identifier
+     */
+    private isIdentifierPart;
+}
+/**
+ * Tokenize a template string
+ */
+export declare function tokenize(input: string): Token[];

package/dist/parser/parser.d.ts

@@ -0,0 +1,79 @@
+import { Token } from './tokens';
+import { RootNode } from './ast';
+/**
+ * Parser for Lithent templates
+ * Converts token stream into AST
+ */
+export declare class Parser {
+    private tokens;
+    private position;
+    constructor(tokens: Token[]);
+    /**
+     * Parse tokens into AST
+     */
+    parse(): RootNode;
+    /**
+     * Parse a single template node
+     */
+    private parseTemplateNode;
+    /**
+     * Parse fragment node
+     */
+    private parseFragment;
+    /**
+     * Parse element
+     */
+    private parseElement;
+    /**
+     * Parse attributes and directives
+     */
+    private parseAttributesAndDirectives;
+    /**
+     * Parse attribute
+     */
+    private parseAttribute;
+    /**
+     * Parse directive
+     */
+    private parseDirective;
+    /**
+     * Parse l-for expression
+     */
+    private parseForExpression;
+    /**
+     * Parse text node
+     */
+    private parseText;
+    /**
+     * Parse interpolation node
+     */
+    private parseInterpolation;
+    /**
+     * Parse comment node
+     */
+    private parseComment;
+    /**
+     * Peek at current token without consuming
+     */
+    private peek;
+    /**
+     * Advance to next token and return current
+     */
+    private advance;
+    /**
+     * Check if current token matches type
+     */
+    private check;
+    /**
+     * Expect a token of specific type, throw error if not found
+     */
+    private expect;
+    /**
+     * Check if we've reached EOF
+     */
+    private isEOF;
+}
+/**
+ * Parse template string into AST
+ */
+export declare function parse(tokens: Token[]): RootNode;

package/dist/parser/tokens.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Token types for Lithent template lexer
+ */
+export declare enum TokenType {
+    TAG_OPEN_START = "TAG_OPEN_START",
+    TAG_OPEN_END = "TAG_OPEN_END",
+    TAG_CLOSE_START = "TAG_CLOSE_START",
+    TAG_SELF_CLOSE = "TAG_SELF_CLOSE",
+    IDENTIFIER = "IDENTIFIER",
+    ATTRIBUTE_EQUALS = "ATTRIBUTE_EQUALS",
+    STRING_LITERAL = "STRING_LITERAL",
+    EXPRESSION_START = "EXPRESSION_START",
+    EXPRESSION_END = "EXPRESSION_END",
+    EXPRESSION_CONTENT = "EXPRESSION_CONTENT",
+    DIRECTIVE_IF = "DIRECTIVE_IF",
+    DIRECTIVE_ELSE_IF = "DIRECTIVE_ELSE_IF",
+    DIRECTIVE_ELSE = "DIRECTIVE_ELSE",
+    DIRECTIVE_FOR = "DIRECTIVE_FOR",
+    FRAGMENT_OPEN = "FRAGMENT_OPEN",
+    FRAGMENT_CLOSE = "FRAGMENT_CLOSE",
+    KEYWORD_REF = "KEYWORD_REF",
+    TEXT = "TEXT",
+    COMMENT = "COMMENT",
+    WHITESPACE = "WHITESPACE",
+    EOF = "EOF"
+}
+/**
+ * Position information for error reporting
+ */
+export interface Position {
+    line: number;
+    column: number;
+    offset: number;
+}
+/**
+ * Token interface
+ */
+export interface Token {
+    type: TokenType;
+    value: string;
+    start: Position;
+    end: Position;
+}
+/**
+ * Create a position object
+ */
+export declare function createPosition(line: number, column: number, offset: number): Position;
+/**
+ * Create a token
+ */
+export declare function createToken(type: TokenType, value: string, start: Position, end: Position): Token;

package/dist/transform/directives.d.ts

@@ -0,0 +1,30 @@
+import { RootNode, 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 declare function transformDirectives(ast: RootNode): RootNode;
+/**
+ * Get conditional group if element is part of one
+ */
+export declare function getConditionalGroup(element: ElementNode): ConditionalGroup | undefined;
+/**
+ * Check if element has a specific directive type
+ */
+export declare function hasDirective(element: ElementNode, directiveType: NodeType): boolean;
+/**
+ * Get directive of specific type from element
+ */
+export declare function getDirective(element: ElementNode, directiveType: NodeType.DIRECTIVE_IF): DirectiveIfNode | undefined;
+export declare function getDirective(element: ElementNode, directiveType: NodeType.DIRECTIVE_ELSE_IF): DirectiveElseIfNode | undefined;
+export declare function getDirective(element: ElementNode, directiveType: NodeType.DIRECTIVE_ELSE): DirectiveElseNode | undefined;

package/dist/transform/index.d.ts

@@ -0,0 +1,14 @@
+import { RootNode } from '../parser/ast';
+import { transformDirectives } from './directives';
+import { optimize, OptimizeOptions } from './optimize';
+/**
+ * Apply all transformations to the AST
+ */
+export declare function transform(ast: RootNode, options?: TransformOptions): RootNode;
+export interface TransformOptions {
+    optimize?: boolean;
+    optimizeOptions?: OptimizeOptions;
+}
+export { transformDirectives, optimize };
+export * from './directives';
+export * from './optimize';

package/dist/transform/optimize.d.ts

@@ -0,0 +1,21 @@
+import { RootNode, TemplateNode, TextNode } from '../parser/ast';
+/**
+ * Optimize the AST
+ * - Merge consecutive text nodes
+ * - Remove empty text nodes (whitespace-only)
+ * - Trim text nodes at boundaries
+ */
+export declare function optimize(ast: RootNode, options?: OptimizeOptions): RootNode;
+export interface OptimizeOptions {
+    mergeTextNodes?: boolean;
+    removeWhitespace?: boolean;
+    trimText?: boolean;
+}
+/**
+ * Check if a text node is whitespace-only
+ */
+export declare function isWhitespaceOnly(node: TextNode): boolean;
+/**
+ * Count nodes in the tree
+ */
+export declare function countNodes(node: RootNode | TemplateNode): number;

package/package.json

@@ -0,0 +1,53 @@
+{
+  "type": "module",
+  "name": "@lithent/lithent-template-parser",
+  "version": "0.1.0",
+  "description": "Lithent Template Parser",
+  "main": "./dist/index.umd.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.umd.cjs",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "magic-string": "^0.30.11"
+  },
+  "devDependencies": {
+    "lithent": "1.20.1"
+  },
+  "keywords": [
+    "lithent",
+    "vite",
+    "hmr"
+  ],
+  "author": "superlucky84",
+  "license": "MIT",
+  "homepage": "https://github.com/superlucky84/lithent",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/superlucky84/lithent.git"
+  },
+  "peerDependencies": {},
+  "files": [
+    "dist",
+    "src"
+  ],
+  "volta": {
+    "node": "20.3.0",
+    "pnpm": "9.12.3"
+  },
+  "scripts": {
+    "dev": "vite",
+    "dev:plugin": "vite --config vite.config.plugin.ts",
+    "build": "vite build",
+    "watch": "vite build --watch",
+    "test": "vitest run --reporter verbose",
+    "test:dev": "vitest"
+  }
+}