@xaendar/compiler 0.0.4 → 0.1.0

package/src/lexer/models/token.type.ts

@@ -1,62 +0,0 @@
-import { TokenType } from './token-type.enum';
-
-export type Token =
-  | TagOpenNameToken
-  | TagSelfCloseToken
-  | TagCloseToken
-  | TagCloseNameToken
-  | AttributeToken
-  | EventToken
-  | TextToken
-  | InterpolationExpressionToken
-  | InterpolationLiteralToken
-  | EOFToken
-
-export type TagOpenNameToken = {
-  type: TokenType.TAG_OPEN_NAME;
-  parts: [string];
-}
-
-export type EventToken = {
-  type: TokenType.EVENT
-  parts: [string]
-}
-
-export type AttributeToken = {
-  type: TokenType.ATTRIBUTE
-  parts: [string]
-}
-
-export type TextToken = {
-  type: TokenType.TEXT,
-  parts: [string]
-}
-
-export type InterpolationExpressionToken = {
-  type: TokenType.INTERPOLATION_EXPRESSION;
-  parts: [string];
-}
-
-export type InterpolationLiteralToken = {
-  type: TokenType.INTERPOLATION_LITERAL;
-  parts: [string];
-}
-
-export type TagSelfCloseToken = {
-  type: TokenType.TAG_SELF_CLOSE,
-  parts: []
-}
-
-export type TagCloseNameToken = {
-  type: TokenType.TAG_CLOSE_NAME,
-  parts: [string]
-}
-
-export type TagCloseToken = {
-  type: TokenType.TAG_OPEN_END,
-  parts: []
-}
-
-export type EOFToken = {
-  type: TokenType.EOF
-}

package/src/lexer/models/transition-function/transition-function-context.type.ts

@@ -1,27 +0,0 @@
-import { LexerState } from '../lexer-state.enum'
-
-/**
- * Context object passed by the Lexer engine to each
- * lexer transition function.
- *
- * This context exposes read-only information about the
- * internal execution state of the lexer, without allowing
- * direct mutation of the engine.
- */
-export type LexerTransitionFunctionContext = {
-  /**
-   * Read-only view of the lexer state stack.
-   *
-   * The stack represents the execution history of the lexer
-   * and is used to support nested or temporary states
-   * (e.g. interpolations, embedded expressions, attribute values).
-   *
-   * Conceptually, the lexer behaves as a Pushdown Automaton (PDA),
-   * where this stack allows the engine to return to a previous
-   * state after completing a nested transition.
-   *
-   * The array is ordered from bottom (oldest state)
-   * to top (most recent state).
-   */
-  history: Array<LexerState>
-}

package/src/lexer/models/transition-function/transition-function-return-type.type.ts

@@ -1,48 +0,0 @@
-import { LexerState } from '../lexer-state.enum'
-import { Token } from '../token.type'
-
-/**
- * Result returned by a lexer state transition function.
- *
- * Each lexer state is implemented as a pure function that:
- * - consumes characters from the cursor
- * - optionally emits tokens
- * - decides the next lexer state
- * - optionally manipulates the lexer state stack
- */
-export type LexerTransitionFunctionReturnType = {
-
-  /**
-   * The next state the lexer should transition to.
-   *
-   * This is always required and represents the logical continuation
-   * of the lexing process after the current state has finished consuming input.
-   */
-  state: LexerState
-  /**
-   * Tokens produced while consuming input in the current state.
-   *
-   * This field is optional because some state transitions
-   * may only advance the cursor or change state without
-   * emitting any tokens.
-   */
-  tokens?: Token[]
-  /**
-   * Whether the lexer should pop the previous state from the state stack
-   * after this transition.
-   *
-   * This is typically used for temporary or nested states
-   * such as interpolations, where the lexer needs to return
-   * to the state it was in before entering the nested context.
-   */
-  popState?: boolean
-  /**
-   * Whether the lexer should push the current state onto the state stack
-   * before transitioning to the next state.
-   *
-   * This is useful when entering a nested or contextual state
-   * (e.g. interpolations or embedded expressions) where the lexer
-   * must remember where it came from in order to resume correctly.
-   */
-  pushState?: boolean
-}

package/src/lexer/models/transition-function/transition-function.type.ts

@@ -1,36 +0,0 @@
-import { LexerCursor } from '../lexer-cursor.model';
-import { LexerTransitionFunctionContext } from './transition-function-context.type';
-import { LexerTransitionFunctionReturnType } from './transition-function-return-type.type';
-
-/**
- * A lexer transition function.
- *
- * A transition function is responsible for:
- * - Reading characters from the input stream via the {@link LexerCursor}
- * - Emitting zero or more tokens
- * - Deciding the next lexer state
- *
- * Transition functions must be **pure with respect to the lexer engine**:
- * they must not mutate the engine state directly, but instead communicate
- * their intent through the returned {@link LexerTransitionFunctionReturnType}.
- *
- * The lexer engine executes transition functions as part of a
- * Pushdown Automaton (PDA), allowing nested states such as interpolations
- * or embedded expressions.
- *
- * @param cursor
- * Cursor used to inspect and consume characters from the input stream.
- * The cursor encapsulates all low-level navigation logic (peek, advance,
- * position tracking, EOF handling).
- *
- * @param context
- * Read-only contextual information provided by the lexer engine,
- * including the current state stack and execution history.
- *
- * @returns
- * An object describing the outcome of the transition:
- * - the next lexer state
- * - any emitted tokens
- * - optional stack operations (push / pop)
- */
-export type LexerTransitionFunction = (cursor: LexerCursor, context: LexerTransitionFunctionContext) => LexerTransitionFunctionReturnType;

package/src/lexer/states/attribute.state.ts

@@ -1,47 +0,0 @@
-import { GREATER_THEN, LEFT_BRACE, SLASH, SPACE } from '../../costants/chars.constants';
-import { LexerCursor } from '../models/lexer-cursor.model';
-import { LexerState } from '../models/lexer-state.enum';
-import { TokenType } from '../models/token-type.enum';
-import { LexerTransitionFunctionContext } from '../models/transition-function/transition-function-context.type';
-import { LexerTransitionFunctionReturnType } from '../models/transition-function/transition-function-return-type.type';
-
-export function consumeAttribute(cursor: LexerCursor, _context: LexerTransitionFunctionContext): LexerTransitionFunctionReturnType {
-  let read = true;
-  let attribute = '';
-  let retVal!: LexerTransitionFunctionReturnType;
-
-  while (read) {
-    switch (cursor.peek()) {
-      case SPACE:
-      case SLASH:
-      case GREATER_THEN:
-        retVal = {
-          state: LexerState.TAG_BODY,
-          tokens: [{
-            type: TokenType.ATTRIBUTE,
-            parts: [attribute]
-          }] 
-        };
-        read = false;
-        break;
-
-      case LEFT_BRACE:
-        retVal = {
-          state: LexerState.INTERPOLATION,
-          tokens: [{
-            type: TokenType.ATTRIBUTE,
-            parts: [attribute]
-          }],
-          pushState: true 
-        };
-        read = false;
-        break;
-
-      default:
-        cursor.advance();
-        attribute = `${attribute}${cursor.currentChar.value}`
-    }
-  }
-
-  return retVal;
-}

package/src/lexer/states/event.state.ts

@@ -1,38 +0,0 @@
-import { GREATER_THEN, SLASH, SPACE } from '../../costants/chars.constants';
-import { LexerCursor } from '../models/lexer-cursor.model';
-import { LexerState } from '../models/lexer-state.enum';
-import { TokenType } from '../models/token-type.enum';
-import { LexerTransitionFunctionContext } from '../models/transition-function/transition-function-context.type';
-import { LexerTransitionFunctionReturnType } from '../models/transition-function/transition-function-return-type.type';
-
-export function consumeEvent(cursor: LexerCursor, _context: LexerTransitionFunctionContext): LexerTransitionFunctionReturnType {
-  let read = true;
-  let event = '';
-  let retVal!: LexerTransitionFunctionReturnType;
-
-  // Consume '@' character
-  cursor.advance();
-
-  while (read) {
-    switch (cursor.peek()) {
-      case SPACE:
-      case SLASH:
-      case GREATER_THEN:
-        retVal = {
-          state: LexerState.TAG_BODY,
-          tokens: [{ 
-            type: TokenType.EVENT, 
-            parts: [event] 
-          }]
-        };
-        read = false;
-        break;
-
-      default:
-        cursor.advance();
-        event = `${event}${cursor.currentChar.value}`
-    }
-  }
-
-  return retVal;
-}

package/src/lexer/states/interpolation-expression.state.ts

@@ -1,68 +0,0 @@
-import { LEFT_BRACE, RIGHT_BRACE, SPACE } from '../../costants/chars.constants';
-import { LexerCursor } from '../models/lexer-cursor.model';
-import { LexerState } from '../models/lexer-state.enum';
-import { TokenType } from '../models/token-type.enum';
-import { LexerTransitionFunctionContext } from '../models/transition-function/transition-function-context.type';
-import { LexerTransitionFunctionReturnType } from '../models/transition-function/transition-function-return-type.type';
-
-export function consumeInterpolationExpression(cursor: LexerCursor, context: LexerTransitionFunctionContext): LexerTransitionFunctionReturnType {
-  let read = true;
-  let interpolation = '';
-  let deep = 1
-  let retVal!: LexerTransitionFunctionReturnType;
-
-  while (read) {
-    switch (cursor.peek()) {
-      case LEFT_BRACE:
-        deep++;
-        interpolation = addCharacter(cursor, interpolation);
-        break;
-
-      case RIGHT_BRACE:
-        deep--;
-        
-        if (deep === 0) {
-          cursor.advance();
-          /*
-            After an interpolation we have to understanad where to transite
-            The next state depends from the previous state
-          */
-          const previousState = context.history.pop();
-          let state!: LexerState;
-
-          switch (previousState) {
-            case LexerState.ATTRIBUTE:
-              state = LexerState.TAG_BODY
-              break;
-
-            case LexerState.TEXT:
-              state = LexerState.TEXT
-          };
-
-          retVal = {
-            state,
-            tokens: [{ 
-              type: TokenType.INTERPOLATION_EXPRESSION, 
-              parts: [interpolation] 
-            }],
-            popState: true
-          }
-          read = false;
-        } else {
-          interpolation = addCharacter(cursor, interpolation);
-        }
-
-        break;
-
-      default:
-        interpolation = addCharacter(cursor, interpolation);
-    }
-  }
-
-  return retVal;
-}
-
-function addCharacter(cursor: LexerCursor, interpolation: string): string {
-  cursor.advance(1);
-  return `${interpolation}${cursor.currentChar.value}`;
-}

package/src/lexer/states/interpolation-literal.state.ts

@@ -1,71 +0,0 @@
-import { GRAVE_ACCENT, RIGHT_BRACE } from '../../costants/chars.constants';
-import { LexerCursor } from '../models/lexer-cursor.model';
-import { LexerState } from '../models/lexer-state.enum';
-import { TokenType } from '../models/token-type.enum';
-import { LexerTransitionFunctionContext } from '../models/transition-function/transition-function-context.type';
-import { LexerTransitionFunctionReturnType } from '../models/transition-function/transition-function-return-type.type';
-
-export function consumeInterpolationliteral(cursor: LexerCursor, context: LexerTransitionFunctionContext): LexerTransitionFunctionReturnType {
-  let read = true;
-  let interpolation = '';
-  let retVal!: LexerTransitionFunctionReturnType;
-
-  // Consume '`' character
-  cursor.advance();
-
-  while (read) {
-    switch (cursor.peek()) {
-      case GRAVE_ACCENT:
-        cursor.advance();
-
-        if (cursor.peek() === RIGHT_BRACE) {
-          cursor.advance();
-          /*
-            After an interpolation we have to understanad where to transite
-            The next state depends from the previous state
-          */
-          const previousState = context.history.pop();
-          let state!: LexerState;
-
-          switch (previousState) {
-            case LexerState.ATTRIBUTE:
-              state = LexerState.TAG_BODY
-              break;
-
-            case LexerState.TEXT:
-              state = LexerState.TEXT
-          };
-
-          retVal = {
-            state,
-            tokens: [{
-              type: TokenType.INTERPOLATION_LITERAL,
-              parts: [interpolation]
-            }],
-            popState: true
-          }
-          read = false;
-        } else {
-          /*
-            If ` is not followed by }, it means the interpolation is not closed
-            and ` is part of the interpolated string
-                                   |
-                                   ˅
-            Example: {`text ${var} ` text`}
-          */
-          interpolation = `${interpolation}${cursor.currentChar.value}`
-        }
-        break;
-
-      default:
-        interpolation = addCharacter(cursor, interpolation);
-    }
-  }
-
-  return retVal;
-}
-
-function addCharacter(cursor: LexerCursor, interpolation: string): string {
-  cursor.advance(1);
-  return `${interpolation}${cursor.currentChar.value}`;
-}

package/src/lexer/states/interpolation.state.ts

@@ -1,31 +0,0 @@
-import { GRAVE_ACCENT, SPACE } from '../../costants/chars.constants';
-import { isJSIdentifierStart } from '../../utils/chars.utils';
-import { LexerCursor } from '../models/lexer-cursor.model';
-import { LexerState } from '../models/lexer-state.enum';
-import { LexerTransitionFunctionContext } from '../models/transition-function/transition-function-context.type';
-import { LexerTransitionFunctionReturnType } from '../models/transition-function/transition-function-return-type.type';
-
-export function consumeInterpolation(cursor: LexerCursor, _context: LexerTransitionFunctionContext): LexerTransitionFunctionReturnType {
-  let retVal!: LexerTransitionFunctionReturnType;
-
-  // Consume '{' characters
-  cursor.advance();
-
-  /*
-    Skip all the spaces between '{' and the actual interpolation content
-    Ex: '{         label}
-  */
-  cursor.skipSpaces();
-  
-  const nextChar = cursor.peek();
-
-  if (nextChar === GRAVE_ACCENT) {
-    retVal = { state: LexerState.INTERPOLATION_LITERAL };
-  } else if (isJSIdentifierStart(nextChar)) {
-    retVal = { state: LexerState.INTERPOLATION_EXPRESSION };
-  } else {
-    throw new Error(`Unrecognized First Character ${String.fromCharCode(nextChar)} in interpolation`);
-  }
-
-  return retVal;
-}

package/src/lexer/states/tag-body.state.ts

@@ -1,43 +0,0 @@
-import { AT_SIGN, GREATER_THEN, SLASH, SPACE } from '../../costants/chars.constants';
-import { LexerCursor } from '../models/lexer-cursor.model';
-import { LexerState } from '../models/lexer-state.enum';
-import { LexerTransitionFunctionContext } from '../models/transition-function/transition-function-context.type';
-import { LexerTransitionFunctionReturnType } from '../models/transition-function/transition-function-return-type.type';
-
-export function consumeTagBody(cursor: LexerCursor, _context: LexerTransitionFunctionContext): LexerTransitionFunctionReturnType {
-  let read = true;
-  let retVal!: LexerTransitionFunctionReturnType;
-
-  while (read) {
-    const nextChar = cursor.peek();
-
-    switch (nextChar) {
-      case AT_SIGN:
-        retVal = {
-          state: LexerState.EVENT
-        }
-        read = false;
-        break;
-
-      case SPACE:
-        cursor.advance();
-        break;
-
-      case GREATER_THEN:
-      case SLASH:
-        retVal = {
-          state: LexerState.TAG_OPEN_END
-        }
-        read = false;
-        break;
-
-      default:
-        retVal = {
-          state: LexerState.ATTRIBUTE
-        }
-        read = false;
-    }
-  }
-
-  return retVal
-}

package/src/lexer/states/tag-close.state.ts

@@ -1,46 +0,0 @@
-import { GREATER_THEN, SPACE } from '../../costants/chars.constants';
-import { LexerCursor } from '../models/lexer-cursor.model';
-import { LexerState } from '../models/lexer-state.enum';
-import { TokenType } from '../models/token-type.enum';
-import { LexerTransitionFunctionContext } from '../models/transition-function/transition-function-context.type';
-import { LexerTransitionFunctionReturnType } from '../models/transition-function/transition-function-return-type.type';
-
-export function consumeTagClose(cursor: LexerCursor, _context: LexerTransitionFunctionContext): LexerTransitionFunctionReturnType {
-  let read = true;
-  let tagName = '';
-  let retVal!: LexerTransitionFunctionReturnType;
-
-  // Skip '</'
-  cursor.advance(2);
-
-  /*
-    Skip all the spaces between '</' and the actual tag name
-    Ex: '</         div>
-  */
-  cursor.skipSpaces();
-
-  while (read) {
-    switch (cursor.peek()) {
-      case GREATER_THEN:
-        cursor.advance();
-        retVal = {
-          state: LexerState.TEXT,
-          tokens: [{
-            type: TokenType.TAG_CLOSE_NAME, 
-            parts: [tagName]
-          }]
-        };
-        read = false;
-        break;
-
-      case SPACE:
-        throw new Error('Tag Close Name cannot contains spaces');
-
-      default:
-        cursor.advance();
-        tagName = `${tagName}${cursor.currentChar.value}`;
-    }
-  }
-
-  return retVal;
-}

package/src/lexer/states/tag-open-end.state.ts

@@ -1,40 +0,0 @@
-import { GREATER_THEN } from '../../costants/chars.constants';
-import { LexerCursor } from '../models/lexer-cursor.model';
-import { LexerState } from '../models/lexer-state.enum';
-import { TokenType } from '../models/token-type.enum';
-import { LexerTransitionFunctionContext } from '../models/transition-function/transition-function-context.type';
-import { LexerTransitionFunctionReturnType } from '../models/transition-function/transition-function-return-type.type';
-
-export function consumeTagOpenEnd(cursor: LexerCursor, _context: LexerTransitionFunctionContext): LexerTransitionFunctionReturnType {
-  let retVal!: LexerTransitionFunctionReturnType
-
-  // We arrive in this point by reading '>' or '/' at the end of a Open Tag 
-  if (cursor.peek() === GREATER_THEN) {
-    cursor.advance();
-    retVal = { 
-      state: LexerState.TEXT,
-      tokens: [{
-        type: TokenType.TAG_OPEN_END,
-        parts: []
-      }] 
-    };
-  } else {
-    cursor.advance();
-    const nextChar = cursor.peek();
-
-    if (nextChar === GREATER_THEN) {
-      cursor.advance();
-      retVal = {
-        state: LexerState.TEXT,
-        tokens: [{
-          type: TokenType.TAG_SELF_CLOSE,
-          parts: []
-        }]
-      };
-    } else {
-      throw new Error(`Unexpected character ${nextChar} for closing tag.\nExpected />\nRead of /${String.fromCharCode(nextChar)}\nAt line ${cursor.position.row + 1} col ${cursor.position.column + 1}`)
-    }
-  }
-
-  return retVal
-}

package/src/lexer/states/tag-open-name.state.ts

@@ -1,50 +0,0 @@
-import { GREATER_THEN, SLASH, SPACE } from '../../costants/chars.constants';
-import { LexerCursor } from '../models/lexer-cursor.model';
-import { LexerState } from '../models/lexer-state.enum';
-import { TokenType } from '../models/token-type.enum';
-import { LexerTransitionFunctionContext } from '../models/transition-function/transition-function-context.type';
-import { LexerTransitionFunctionReturnType } from '../models/transition-function/transition-function-return-type.type';
-
-export function consumeTagOpenName(cursor: LexerCursor, _context: LexerTransitionFunctionContext): LexerTransitionFunctionReturnType {
-  let read = true;
-  let tagName = '';
-  let retVal!: LexerTransitionFunctionReturnType
-
-  // Consume '<' character
-  cursor.advance();
-
-  /*
-    Skip all the spaces between '<' and the actual tag name
-    Ex: '<         div>
-  */
-  cursor.skipSpaces();
-
-  /*
-    Keep read input until:
-    - Space: <span 
-    - GT: <span>
-    - Slash (Self Closing tag) <span / or <span/
-  */
-  while (read) {
-    switch (cursor.peek()) {
-      case SPACE:
-      case SLASH:
-      case GREATER_THEN:
-        retVal = {
-          state: LexerState.TAG_BODY,
-          tokens: [{ 
-            type: TokenType.TAG_OPEN_NAME, 
-            parts: [tagName] 
-          }]
-        }
-        read = false;
-        break;
-
-      default:
-        cursor.advance();
-        tagName = `${tagName}${cursor.currentChar.value}`
-    }
-  }
-
-  return retVal
-}

package/src/lexer/states/text.state.ts

@@ -1,61 +0,0 @@
-import { CR, LEFT_BRACE, LESS_THAN, LF, SLASH, SPACE } from '../../costants/chars.constants';
-import { isNotBlank } from '../../utils/chars.utils';
-import { LexerCursor } from '../models/lexer-cursor.model';
-import { LexerState } from '../models/lexer-state.enum';
-import { TokenType } from '../models/token-type.enum';
-import { LexerTransitionFunctionContext } from '../models/transition-function/transition-function-context.type';
-import { LexerTransitionFunctionReturnType } from '../models/transition-function/transition-function-return-type.type';
-
-export function consumeText(cursor: LexerCursor, _context: LexerTransitionFunctionContext): LexerTransitionFunctionReturnType {
-  let read = true;
-  let text = '';
-  let retVal!: LexerTransitionFunctionReturnType
-
-  while (read) {
-    switch (cursor.peek()) {
-      case LESS_THAN:
-        // If after '<' we read a '/', we suppose we're approaching a ClosureTag, otherwise an OpenTag
-        const nextState = cursor.peek(1, { offset: 1 }) === SLASH ? LexerState.TAG_CLOSE : LexerState.TAG_OPEN_NAME;
-        retVal = { state: nextState }
-        read = false;
-        break;
-
-      case LEFT_BRACE:
-        retVal = { 
-          state: LexerState.INTERPOLATION,
-          pushState: true
-        };
-        read = false;
-        break;
-
-      case SPACE:
-      case LF:
-      case CR:
-        cursor.advance();
-        break;
-
-      default:
-        cursor.advance();
-        text = `${text}${cursor.currentChar.value}`;
-    }
-  }
-
-
-  /*
-    If the first read character trigger a StateChange
-    The cumulative `text` variable will be empty
-
-    In this case we must NOT add any token
-
-    Ex:
-    Template starts with a tag:
-      `<div ...`
-    Or an interpolation:
-      `{ myVariable }`
-  */
-  retVal.tokens = isNotBlank(text)
-    ? [{ type: TokenType.TEXT, parts: [text] }]
-    : undefined;
-
-  return retVal
-}