@xaendar/compiler 0.0.4 → 0.1.6

package/package.json

@@ -1,11 +1,21 @@
-{
-  "name": "@xaendar/compiler",
-  "version": "0.0.4",
-  "type": "module",
-  "author": "Kaitenjo",
-  "license": "MIT",
-  "description": "A library containing compiler engine",
-  "dependencies": {
-    "@xaendar/common": "0.0.3"
-  }
-}
+{
+  "name": "@xaendar/compiler",
+  "version": "0.1.6",
+  "description": "A library containing compiler engine",
+  "type": "module",
+  "main": "./xaendar-compiler.es.js",
+  "module": "./xaendar-compiler.es.js",
+  "types": "./xaendar-compiler.es.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./xaendar-compiler.es.d.ts",
+        "default": "./xaendar-compiler.es.js"
+      }
+    }
+  },
+  "peerDependencies": {},
+  "dependencies": {
+    "@xaendar/common": "0.1.6"
+  }
+}

package/xaendar-compiler.es.d.ts

@@ -0,0 +1,199 @@
+declare type ASTNode = ElementNode | TextNode | InterpolationNode;
+
+declare enum ASTNodeType {
+    Element = 0,
+    Text = 1,
+    Interpolation = 2
+}
+
+declare type AttributeNode = {
+    name: string;
+    value: string | InterpolationNode;
+};
+
+declare type AttributeToken = {
+    type: TokenType.ATTRIBUTE;
+    parts: [string];
+};
+
+declare type ElementNode = {
+    type: ASTNodeType.Element;
+    tagName: string;
+    attributes: AttributeNode[];
+    events: EventNode[];
+    children: ASTNode[];
+};
+
+declare type EOFToken = {
+    type: TokenType.EOF;
+};
+
+declare type EventNode = {
+    name: string;
+    handler: string | InterpolationNode;
+};
+
+declare type EventToken = {
+    type: TokenType.EVENT;
+    parts: [string];
+};
+
+/**
+ * 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 declare function generateRenderFunction(ast: ASTNode[], componentVar?: string): string;
+
+declare type InterpolationExpressionToken = {
+    type: TokenType.INTERPOLATION_EXPRESSION;
+    parts: [string];
+};
+
+declare type InterpolationLiteralToken = {
+    type: TokenType.INTERPOLATION_LITERAL;
+    parts: [string];
+};
+
+declare type InterpolationNode = {
+    type: ASTNodeType.Interpolation;
+    expression: string;
+};
+
+/**
+ * Utility class that emulates a cursor navigating through a template string.
+ *
+ * The cursor keeps track of the current character, its absolute position
+ * within the text, and its logical position expressed as row and column.
+ * This is useful when parsing or analyzing template content character by character.
+ */
+export declare class Lexer {
+    input: string;
+    private readonly _cursor;
+    private _state;
+    private _stack;
+    private readonly _tokens;
+    private readonly _states;
+    /**
+     * Creates a new Cursor instance for the given template content.
+     *
+     * @param input The full template text that the cursor will navigate.
+     */
+    constructor(input: string);
+    tokenize(): Token[];
+}
+
+/**
+ * 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 declare class Parser {
+    private readonly tokens;
+    /** Internal cursor for navigating tokens */
+    private readonly _cursor;
+    /**
+     * Creates a new Parser instance.
+     *
+     * @param tokens Array of tokens produced by the Lexer
+     */
+    constructor(tokens: Token[]);
+    /**
+     * Entry point for parsing the token stream into AST nodes.
+     *
+     * @returns Array of top-level AST nodes
+     */
+    parse(): ASTNode[];
+    /**
+     * Parses the next AST node based on the current token.
+     *
+     * @returns Parsed AST node
+     * @throws Error if an unexpected token is encountered
+     */
+    private parseNode;
+    /**
+     * Parses a text token into a TextNode.
+     */
+    private parseText;
+    /**
+     * Parses an interpolation token into an InterpolationNode.
+     */
+    private parseInterpolation;
+    /**
+     * Parses an element starting from a TAG_OPEN_NAME token.
+     * Handles attributes, events, children, and tag closure.
+     */
+    private parseElement;
+    /**
+     * Parses an attribute token into an AttributeNode.
+     * Supports literal values and interpolations as attribute values.
+     */
+    private parseAttribute;
+    /**
+     * Parses an event token into an EventNode.
+     */
+    private parseEvent;
+    /**
+     * Checks whether the next token is a closing tag matching the given name.
+     */
+    private isTagClose;
+    /**
+     * Creates a parser error with a consistent prefix.
+     */
+    private error;
+}
+
+declare type TagCloseNameToken = {
+    type: TokenType.TAG_CLOSE_NAME;
+    parts: [string];
+};
+
+declare type TagCloseToken = {
+    type: TokenType.TAG_OPEN_END;
+    parts: [];
+};
+
+declare type TagOpenNameToken = {
+    type: TokenType.TAG_OPEN_NAME;
+    parts: [string];
+};
+
+declare type TagSelfCloseToken = {
+    type: TokenType.TAG_SELF_CLOSE;
+    parts: [];
+};
+
+declare type TextNode = {
+    type: ASTNodeType.Text;
+    value: string;
+};
+
+declare type TextToken = {
+    type: TokenType.TEXT;
+    parts: [string];
+};
+
+declare type Token = TagOpenNameToken | TagSelfCloseToken | TagCloseToken | TagCloseNameToken | AttributeToken | EventToken | TextToken | InterpolationExpressionToken | InterpolationLiteralToken | EOFToken;
+
+declare enum TokenType {
+    TEXT = 0,
+    TAG_OPEN_NAME = 1,// <div
+    TAG_SELF_CLOSE = 2,// />
+    TAG_OPEN_END = 3,
+    TAG_CLOSE_NAME = 4,// </div
+    ATTRIBUTE = 5,
+    EVENT = 6,
+    INTERPOLATION_LITERAL = 7,
+    INTERPOLATION_EXPRESSION = 8,
+    EOF = 9
+}
+
+export { }