@xaendar/compiler 0.0.4 → 0.1.0

package/src/parser/models/ast.type.ts

@@ -1,34 +0,0 @@
-import { ASTNodeType } from './node.enum';
-
-export type ASTNode =
-  | ElementNode
-  | TextNode
-  | InterpolationNode;
-
-export type ElementNode = {
-  type: ASTNodeType.Element
-  tagName: string;
-  attributes: AttributeNode[];
-  events: EventNode[];
-  children: ASTNode[];
-}
-
-export type AttributeNode = {
-  name: string;
-  value: string | InterpolationNode;
-}
-
-export type EventNode = {
-  name: string;
-  handler: string | InterpolationNode;
-}
-
-export type TextNode = {
-  type: ASTNodeType.Text
-  value: string;
-}
-
-export type InterpolationNode = {
-  type: ASTNodeType.Interpolation
-  expression: string;
-}

package/src/parser/models/current-token.type.ts

@@ -1,6 +0,0 @@
-import { Token } from '../../lexer/models/token.type'
-
-export type CurrentToken = {
-  value: Token
-  index: number
-}

package/src/parser/models/node.enum.ts

@@ -1,5 +0,0 @@
-export enum ASTNodeType {
-  Element,
-  Text,
-  Interpolation
-}

package/src/parser/models/parser-cursor.model.ts

@@ -1,133 +0,0 @@
-import { PositiveInteger, TupleOfLength } from '@xaendar/common';
-import { EOF } from '../../costants/chars.constants';
-import { TokenType } from '../../lexer/models/token-type.enum';
-import { Token } from '../../lexer/models/token.type';
-import { CurrentToken } from './current-token.type';
-
-/**
- * Cursor abstraction used by the Parser to navigate
- * through a sequence of tokens produced by the Lexer.
- *
- * Responsibilities:
- * - Sequential token consumption
- * - Lookahead (peek) operations without mutating state
- * - Handling end-of-file conditions
- *
- * This class does not perform parsing itself: it only
- * manages position and access to the token stream.
- */
-export class ParserCursor {
-
-  /**
-   * Representation of the current token.
-   *
-   * - `index`: absolute index within the token array
-   * - `value`: current token object (or EOF token)
-   *
-   * An index of `-1` indicates that the cursor has not
-   * yet consumed any token or has reached EOF.
-   */
-  private readonly _currentToken: CurrentToken = {
-    value: { type: TokenType.EOF },
-    index: -1
-  };
-
-  /**
-   * Returns a read-only snapshot of the current token.
-   */
-  public get currentToken(): Readonly<CurrentToken> {
-    return this._currentToken;
-  }
-
-  /**
-   * Creates a new ParserCursor for the given token array.
-   *
-   * @param _tokens Array of tokens to navigate.
-   */
-  constructor(private readonly _tokens: Token[]) { }
-
-  /**
-   * Advances the cursor by the specified number of tokens.
-   *
-   * Updates the current token and index.
-   *
-   * @param chars Number of tokens to advance (must be >= 1)
-   *
-   * @throws Error with cause `EOF` when advancing past the end
-   */
-  public advance(chars = 1): void {
-    if (chars < 1) {
-      throw new Error(`${chars} is not a valid value. Please enter a number equal or greater than 1`);
-    }
-
-    const newIndex = this._currentToken.index + chars;
-
-    if (newIndex >= this._tokens.length) {
-      this._currentToken.value = { type: TokenType.EOF };
-      this._currentToken.index = -1;
-      this.throwEOFError();
-    } else {
-      this._currentToken.index = newIndex;
-      this._currentToken.value = this._tokens[newIndex]!;
-    }
-  }
-
-  /**
-   * Peeks ahead in the token stream without advancing the cursor.
-   *
-   * Supports:
-   * - Single-token lookahead
-   * - Multi-token lookahead
-   * - Optional offset from the current token
-   *
-   * @returns
-   * - A single Token when peeking one token
-   * - An array of Tokens when peeking multiple tokens
-   *
-   * @throws Error with cause `EOF` if the peek exceeds the token array
-   */
-  public peek(): Token;
-  public peek<OffSet extends number>(options?: { offset?: PositiveInteger<OffSet> }): Token;
-  public peek(chars: 1): Token;
-  public peek<OffSet extends number>(chars: 1, options?: { offset?: PositiveInteger<OffSet> }): Token; 
-  public peek<ReadChars extends number>(chars: PositiveInteger<ReadChars>): TupleOfLength<ReadChars, Token>; 
-  public peek<ReadChars extends number, OffSet extends number>(chars: PositiveInteger<ReadChars>, options?: { offset?: PositiveInteger<OffSet> }): TupleOfLength<ReadChars, Token>;
-  public peek(charsOrOptions?: number | { offset?: number }, options?: { offset?: number }): Token | Token[] {
-    const tokens = typeof charsOrOptions === 'number' ? charsOrOptions : 1;
-    const offset = (typeof charsOrOptions === 'object' ? charsOrOptions : options)?.offset ?? 0;
-    return tokens === 1 ? this.peekOneToken(this._currentToken.index + offset + 1) : this.peekMany(tokens + offset);
-  }
-
-  /**
-   * Peeks multiple tokens ahead.
-   */
-  private peekMany(chars: number): Token[] {
-    const peekedTokens: Token[] = [];
-    const nextTokenIndex = this._currentToken.index + 1;
-
-    for (let i = nextTokenIndex; i < nextTokenIndex + chars; i++) {
-      peekedTokens.push(this.peekOneToken(i));
-    }
-
-    return peekedTokens;
-  }
-
-  /**
-   * Peeks a single token at the given absolute index.
-   */
-  private peekOneToken(index: number): Token {
-    if (index >= this._tokens.length) {
-      this.throwEOFError();
-    }
-
-    return this._tokens[index]!;
-  }
-
-  /**
-   * Throws a standardized EOF error used by the parser
-   * to terminate token consumption.
-   */
-  private throwEOFError(): never {
-    throw new Error('', { cause: EOF });
-  }
-}

package/src/parser/parser.ts

@@ -1,225 +0,0 @@
-import { EOF } from '../costants/chars.constants';
-import { TokenType } from '../lexer/models/token-type.enum';
-import { AttributeToken, EventToken, InterpolationExpressionToken, InterpolationLiteralToken, TagOpenNameToken, TextToken, Token } from '../lexer/models/token.type';
-import { ASTNode, AttributeNode, ElementNode, EventNode, InterpolationNode, TextNode } from './models/ast.type';
-import { ASTNodeType } from './models/node.enum';
-import { ParserCursor } from './models/parser-cursor.model';
-
-/**
- * Parser class that transforms a stream of tokens (from the Lexer)
- * into an Abstract Syntax Tree (AST) representing the template structure.
- *
- * Responsibilities:
- * - Parse text nodes, elements, attributes, events, and interpolations
- * - Maintain cursor state for sequential token consumption
- * - Detect tag boundaries and nested structures
- *
- * The parser assumes that the token stream is syntactically valid according
- * to the Lexer rules. Parsing errors are thrown as exceptions.
- */
-export class Parser {
-
-  /** Internal cursor for navigating tokens */
-  private readonly _cursor: ParserCursor;
-
-  /**
-   * Creates a new Parser instance.
-   *
-   * @param tokens Array of tokens produced by the Lexer
-   */
-  constructor(private readonly tokens: Token[]) {
-    this._cursor = new ParserCursor(this.tokens);
-  }
-
-  /**
-   * Entry point for parsing the token stream into AST nodes.
-   *
-   * @returns Array of top-level AST nodes
-   */
-  public parse(): ASTNode[] {
-    let eof = false;
-    const nodes: ASTNode[] = [];
-
-    while (!eof) {
-      try {
-        nodes.push(this.parseNode());
-      } catch (err) {
-        const error = err as Error;
-        if (error.cause === EOF) {
-          eof = true;
-        } else {
-          throw err;
-        }
-      }
-    }
-
-    return nodes;
-  }
-
-  /**
-   * Parses the next AST node based on the current token.
-   *
-   * @returns Parsed AST node
-   * @throws Error if an unexpected token is encountered
-   */
-  private parseNode(): ASTNode {
-    const token = this._cursor.peek();
-
-    switch (token.type) {
-      case TokenType.TEXT:
-        return this.parseText(token);
-
-      case TokenType.INTERPOLATION_EXPRESSION:
-      case TokenType.INTERPOLATION_LITERAL:
-        return this.parseInterpolation(token);
-
-      case TokenType.TAG_OPEN_NAME:
-        return this.parseElement(token);
-
-      default:
-        throw this.error(`Unexpected token ${TokenType[token.type]}`);
-    }
-  }
-
-  /**
-   * Parses a text token into a TextNode.
-   */
-  private parseText(token: TextToken): TextNode {
-    this._cursor.advance();
-    return {
-      type: ASTNodeType.Text,
-      value: token.parts[0]
-    };
-  }
-
-  /**
-   * Parses an interpolation token into an InterpolationNode.
-   */
-  private parseInterpolation(token: InterpolationExpressionToken | InterpolationLiteralToken): InterpolationNode {
-    this._cursor.advance();
-    return {
-      type: ASTNodeType.Interpolation,
-      expression: token.parts[0]
-    };
-  }
-
-  /**
-   * Parses an element starting from a TAG_OPEN_NAME token.
-   * Handles attributes, events, children, and tag closure.
-   */
-  private parseElement(token: TagOpenNameToken): ElementNode {
-    this._cursor.advance();
-    const tagName = token.parts[0];
-
-    const attributes: AttributeNode[] = [];
-    const events: EventNode[] = [];
-
-    let read = true;
-    while (read) {
-      const token = this._cursor.peek();
-      switch (token.type) {
-        case TokenType.ATTRIBUTE:
-          attributes.push(this.parseAttribute(token));
-          break;
-
-        case TokenType.EVENT:
-          events.push(this.parseEvent(token));
-          break;
-
-        default:
-          read = false;
-      }
-    }
-
-    // Consume TAG_OPEN_END if present: <div>
-    if (this._cursor.peek().type === TokenType.TAG_OPEN_END) {
-      this._cursor.advance();
-    }
-
-    // Handle self-closing tags: <div />
-    if (this._cursor.peek().type === TokenType.TAG_SELF_CLOSE) {
-      this._cursor.advance();
-      return {
-        type: ASTNodeType.Element,
-        tagName,
-        attributes,
-        events,
-        children: []
-      };
-    }
-
-    // Parse children recursively until closing tag
-    const children: ASTNode[] = [];
-    while (!this.isTagClose(tagName)) {
-      children.push(this.parseNode());
-    }
-
-    // Consume closing tag </div>
-    this._cursor.advance();
-
-    return {
-      type: ASTNodeType.Element,
-      tagName,
-      attributes,
-      events,
-      children
-    };
-  }
-
-  /**
-   * Parses an attribute token into an AttributeNode.
-   * Supports literal values and interpolations as attribute values.
-   */
-  private parseAttribute(token: AttributeToken): AttributeNode {
-    this._cursor.advance();
-    const raw = token.parts[0];
-
-    if (!raw.includes('=')) {
-      return { name: raw, value: 'true' };
-    }
-
-    const [name, value] = raw.split('=');
-
-    const nextToken = this._cursor.peek();
-    if (nextToken.type === TokenType.INTERPOLATION_EXPRESSION || nextToken.type === TokenType.INTERPOLATION_LITERAL) {
-      return {
-        name: name!,
-        value: this.parseInterpolation(nextToken)
-      };
-    }
-
-    return {
-      name: name!,
-      value: value!.replace(/^['']|['']$/g, '')
-    };
-  }
-
-  /**
-   * Parses an event token into an EventNode.
-   */
-  private parseEvent(token: EventToken): EventNode {
-    this._cursor.advance();
-    const raw = token.parts[0];
-    const [name, value] = raw.split('=');
-
-    return {
-      name: name!,
-      handler: value!.replace(/^['']|['']$/g, '')
-    };
-  }
-
-  /**
-   * Checks whether the next token is a closing tag matching the given name.
-   */
-  private isTagClose(tagName: string): boolean {
-    const nextToken = this._cursor.peek();
-    return nextToken.type === TokenType.TAG_CLOSE_NAME && nextToken.parts[0] === tagName;
-  }
-
-  /**
-   * Creates a parser error with a consistent prefix.
-   */
-  private error(message: string): Error {
-    return new Error(`[Parser] ${message}`);
-  }
-}

package/src/public-api.ts

@@ -1,3 +0,0 @@
-export * from './lexer/lexer';
-export * from './parser/parser';
-export * from './render-generator/render-generator.model';

package/src/render-generator/render-generator.model.ts

@@ -1,73 +0,0 @@
-import { ASTNode, TextNode, InterpolationNode, ElementNode, AttributeNode, EventNode } from '../parser/models/ast.type';
-import { ASTNodeType } from '../parser/models/node.enum';
-
-/**
- * Genera il codice TypeScript della funzione render
- * @param ast L'albero AST del template
- * @param componentVar Nome della variabile 'this' del componente (di solito `this`)
- * @returns Stringa contenente il corpo della funzione render
- */
-export function generateRenderFunction(ast: ASTNode[], componentVar = 'this'): string {
-  const lines: string[] = [];
-
-  // Apertura funzione
-  lines.push(`const shadow = ${componentVar}.shadowRoot!;`);
-
-  ast.forEach((node, i) => {
-    lines.push(...processNode(node, `node${i}`, componentVar));
-    lines.push(`shadow.appendChild(node${i});`);
-  });
-
-  return lines.join('\n');
-}
-
-/**
- * Genera il codice per creare un singolo nodo
- */
-function processNode(node: ASTNode, varName: string, componentVar: string): string[] {
-  const code = new Array<string>;
-
-  switch (node.type) {
-    case ASTNodeType.Text:
-      code.push(`const ${varName} = document.createTextNode(${JSON.stringify((node as TextNode).value)});`);
-      break;
-
-    case ASTNodeType.Interpolation:
-      code.push(`const ${varName} = document.createTextNode(${componentVar}.${(node as InterpolationNode).expression});`);
-      break;
-
-    case ASTNodeType.Element:
-      const elNode = node as ElementNode;
-      code.push(`const ${varName} = document.createElement(${JSON.stringify(elNode.tagName)});`);
-
-      // Attributi
-      (elNode.attributes || []).forEach((attr: AttributeNode) => {
-        if (typeof attr.value === 'string') {
-          code.push(`${varName}.setAttribute(${JSON.stringify(attr.name)}, ${JSON.stringify(attr.value)});`);
-        } else {
-          // Interpolazione come value
-          const interp = attr.value as InterpolationNode;
-          code.push(`${varName}.setAttribute(${JSON.stringify(attr.name)}, ${componentVar}.${interp.expression});`);
-        }
-      });
-
-      // Eventi
-      (elNode.events || []).forEach((event: EventNode) => {
-        if (event.name.startsWith('@')) {
-          event.name = event.name.slice(1);
-        }
-        code.push(`${varName}.addEventListener(${JSON.stringify(event.name)}, ${componentVar}.${event.handler}.bind(${componentVar}));`);
-      });
-
-      // Children
-      (elNode.children || []).forEach((child, idx) => {
-        const childVar = `${varName}_child${idx}`;
-        code.push(...processNode(child, childVar, componentVar));
-        code.push(`${varName}.appendChild(${childVar});`);
-      });
-
-      break;
-  }
-
-  return code;
-}

package/src/utils/chars.utils.ts

@@ -1,70 +0,0 @@
-import { A, a, CR, LF, Z, z } from '../costants/chars.constants';
-
-/**
- * Check if char code is a Line Feed (\n) or Carriage Return (\r)
- * @param char Character to control
- * @returns True if character is LF or CR, false otherwise
- */
-export function isNewLine(char: number): boolean {
-  return char === LF || char === CR;
-}
-
-/**
- * Check if char code is is a lower case letter
- * @param char Character to control
- * @returns True if character is a lowercase letter, false otherwise
- */
-export function isLowerCase(char: number): boolean {
-  return char >= a && char <= z;
-}
-
-/**
- * Check if char code is is a upper  case letter
- * @param char Character to control
- * @returns True if character is a upper case letter, false otherwise
- */
-export function isUpperCase(char: number): boolean {
-  return char >= A && char <= Z;
-}
-
-/**
- * Check if the string contains at least one character different from
- * ' '
- * \n
- * \r
- * \t
- * \f
- * \v
- * @param str String to check
- * @returns True if string is not blank, false otherwise
- */
-export function isNotBlank(str: string): boolean {
-  /* 
-    Differently from the approach of the other functions
-    here we are working with string and not numbers.
-
-    Number checks are usually faster when checking a character is
-    included in a specific range.
-    For this case we are checking if the string contains at least one char
-    different from a list of non adiacent characters in the ASCII code, resulting
-    in a very long condition with multiple OR
-
-    This has been proven slower than using a regex
-  */
-  return /\S/.test(str)
-}
-
-/**
- * Check if given ascii code is a valid First Character
- * for Javasript Identifiers
- * @param code The ascii code to valuate
- * @returns True if is valid, false otherwise
- */
-export function isJSIdentifierStart(code: number): boolean {
-  return (
-    (code >= 65 && code <= 90) ||    // A-Z
-    (code >= 97 && code <= 122) ||   // a-z
-    code === 36 ||                   // $
-    code === 95                      // _
-  );
-}

package/src/utils/tags.utils.ts

@@ -1,36 +0,0 @@
-import { HTML_TAGS } from '../costants/tags/base-tags.constants';
-import { NOT_ALLOWED_TAGS } from '../costants/tags/not-alllowed-tags.constants';
-import { NOT_ALLOWED_CHARS_FOR_TAGS } from '../costants/tags/not-allowed-chars.constants';
-
-/**
- * Checks if a character is allowed in a custom element tag name.
- * 
- * @param char - The character to check.
- * @returns `true` if the character is allowed, `false` if it is forbidden.
- */
-export function isAllowedCharForTag(char: string): boolean {
-  return !NOT_ALLOWED_CHARS_FOR_TAGS.includes(char);
-}
-
-/**
- * Checks if a tag name is a native HTML tag.
- * 
- * @param tagName - The tag name to check.
- * @returns `true` if the tag name is a standard HTML tag, `false` otherwise.
- */
-export function isNativeHTMLTag(tagName: string): boolean {
-  return HTML_TAGS.includes(tagName);
-}
-
-/**
- * Checks if a tag name is reserved and cannot be used for a custom element.
- * 
- * Reserved names include certain HTML, SVG, or other names that are forbidden by the specification.
- * https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
- * 
- * @param tagName - The tag name to check.
- * @returns `true` if the tag name is reserved, `false` otherwise.
- */
-export function isReservedTagName(tagName: string): boolean {
-  return NOT_ALLOWED_TAGS.includes(tagName);
-}

package/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-}

package/vite.config.ts

@@ -1,4 +0,0 @@
-import { defineConfig } from 'vite';
-import getViteConfig from '../../vite-config';
-
-export default defineConfig(getViteConfig('@xaendar/compiler', __dirname));