hispano-lang 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,185 @@
+/**
+ * HispanoLang - TypeScript Definitions
+ * Un lenguaje de programación educativo en español
+ */
+
+/**
+ * Resultado de la interpretación de código
+ */
+export interface InterpretationResult {
+  /** Indica si la ejecución fue exitosa */
+  success: boolean;
+  /** Array de salidas generadas durante la ejecución */
+  output: string[];
+  /** Mensaje de error si la ejecución falló */
+  error: string | null;
+}
+
+/**
+ * Token del tokenizador
+ */
+export interface Token {
+  /** Tipo del token */
+  type: string;
+  /** Lexema del token */
+  lexeme: string;
+  /** Valor literal del token */
+  literal: any;
+  /** Línea donde se encontró el token */
+  line: number;
+}
+
+/**
+ * Nodo del AST (Abstract Syntax Tree)
+ */
+export interface ASTNode {
+  /** Tipo del nodo */
+  type: string;
+  /** Propiedades específicas del nodo */
+  [key: string]: any;
+}
+
+/**
+ * Entorno de variables
+ */
+export interface Environment {
+  /** Valores de las variables */
+  values: { [key: string]: any };
+  /** Entorno padre (para scope) */
+  enclosing?: Environment;
+}
+
+/**
+ * Clase principal del intérprete HispanoLang
+ */
+export class Interpreter {
+  /** Tokenizador del intérprete */
+  tokenizer: Tokenizer;
+  /** Evaluador del intérprete */
+  evaluator: Evaluator;
+
+  /**
+   * Crea una nueva instancia del intérprete
+   */
+  constructor();
+
+  /**
+   * Interpreta código fuente en español
+   * @param source - Código fuente a interpretar
+   * @returns Resultado de la interpretación
+   */
+  interpret(source: string): InterpretationResult;
+
+  /**
+   * Ejecuta código y retorna solo las salidas
+   * @param source - Código fuente a ejecutar
+   * @returns Array de salidas
+   */
+  run(source: string): string[];
+
+  /**
+   * Obtiene el entorno de variables actual
+   * @returns Entorno de variables
+   */
+  getEnvironment(): { [key: string]: any };
+
+  /**
+   * Limpia el entorno de variables
+   */
+  clearEnvironment(): void;
+}
+
+/**
+ * Tokenizador para HispanoLang
+ */
+export class Tokenizer {
+  /**
+   * Tokeniza código fuente y retorna una lista de tokens
+   * @param source - Código fuente a tokenizar
+   * @returns Lista de tokens
+   */
+  tokenize(source: string): Token[];
+}
+
+/**
+ * Parser para HispanoLang
+ */
+export class Parser {
+  /**
+   * Crea una nueva instancia del parser
+   * @param tokens - Lista de tokens a parsear
+   */
+  constructor(tokens: Token[]);
+
+  /**
+   * Parsea tokens y retorna una lista de declaraciones
+   * @returns Lista de declaraciones (AST)
+   */
+  parse(): ASTNode[];
+}
+
+/**
+ * Evaluador para HispanoLang
+ */
+export class Evaluator {
+  /** Entorno de variables */
+  environment: Environment;
+  /** Array de salidas */
+  output: string[];
+
+  /**
+   * Crea una nueva instancia del evaluador
+   */
+  constructor();
+
+  /**
+   * Evalúa una lista de declaraciones
+   * @param statements - Lista de declaraciones AST
+   * @returns Resultado de la ejecución
+   */
+  evaluate(statements: ASTNode[]): string[];
+}
+
+/**
+ * Función principal para interpretar código
+ * @param code - Código fuente en español
+ * @returns Resultado de la interpretación
+ */
+export function interpret(code: string): InterpretationResult;
+
+/**
+ * Ejecuta código y retorna solo las salidas
+ * @param code - Código fuente en español
+ * @returns Lista de salidas
+ */
+export function run(code: string): string[];
+
+/**
+ * Obtiene las variables definidas
+ * @returns Variables en el entorno actual
+ */
+export function getVariables(): { [key: string]: any };
+
+/**
+ * Limpia el entorno de variables
+ */
+export function clearVariables(): void;
+
+/**
+ * Clase del intérprete (para uso directo)
+ */
+export { Interpreter };
+
+// Re-export everything as default for CommonJS compatibility
+declare const _default: {
+  interpret: typeof interpret;
+  run: typeof run;
+  getVariables: typeof getVariables;
+  clearVariables: typeof clearVariables;
+  Interpreter: typeof Interpreter;
+  Tokenizer: typeof Tokenizer;
+  Parser: typeof Parser;
+  Evaluator: typeof Evaluator;
+};
+
+export = _default;

package/dist/index.js

@@ -0,0 +1,74 @@
+/**
+ * HispanoLang
+ * A simple interpreter to teach programming without language barriers
+ *
+ * Features:
+ * - Variables: variable nombre = valor
+ * - Show: mostrar "texto" o mostrar variable
+ */
+
+const Interpreter = require('./src/interpreter');
+
+// Create an interpreter instance
+const interpreter = new Interpreter();
+
+/**
+ * Main function to interpret code
+ * @param {string} code - Source code in Spanish
+ * @returns {Object} Interpretation result
+ */
+function interpret(code) {
+  return interpreter.interpret(code);
+}
+
+/**
+ * Executes code and returns only the output
+ * @param {string} code - Source code in Spanish
+ * @returns {Array} List of outputs
+ */
+function run(code) {
+  return interpreter.run(code);
+}
+
+/**
+ * Gets the defined variables
+ * @returns {Object} Variables in the current environment
+ */
+function getVariables() {
+  return interpreter.getEnvironment();
+}
+
+/**
+ * Clears the variable environment
+ */
+function clearVariables() {
+  interpreter.clearEnvironment();
+}
+
+// Example usage
+
+const exampleCode = `
+mostrar "Hola mundo"
+`;
+
+console.log('Code to execute:');
+console.log(exampleCode);
+console.log('Result:');
+
+const result = interpret(exampleCode);
+
+if (result.success) {
+  console.log('✓ Execution successful');
+  console.log('Defined variables:', getVariables());
+} else {
+  console.log('✗ Error:', result.error);
+}
+
+// Export functions for use in other modules
+module.exports = {
+  interpret,
+  run,
+  getVariables,
+  clearVariables,
+  Interpreter,
+};

package/dist/interpreter.js

@@ -0,0 +1,73 @@
+/**
+ * Main interpreter for HispanoLang
+ * Coordinates tokenizer, parser and evaluator
+ */
+
+const Tokenizer = require("./tokenizer");
+const Parser = require("./parser");
+const Evaluator = require("./evaluator");
+
+class Interpreter {
+  constructor() {
+    this.tokenizer = new Tokenizer();
+    this.evaluator = new Evaluator();
+  }
+
+  /**
+   * Interprets source code
+   * @param {string} source - Source code to interpret
+   * @returns {Object} Interpretation result
+   */
+  interpret(source) {
+    try {
+      // 1. Tokenize source code
+      const tokens = this.tokenizer.tokenize(source);
+
+      // 2. Parse tokens into AST
+      const parser = new Parser(tokens);
+      const statements = parser.parse();
+
+      // 3. Evaluate statements
+      const output = this.evaluator.evaluate(statements);
+
+      return {
+        success: true,
+        output: output,
+        error: null,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: [],
+        error: error.message,
+      };
+    }
+  }
+
+  /**
+   * Interprets source code and returns only the output
+   * @param {string} source - Source code to interpret
+   * @returns {Array} List of outputs
+   */
+  run(source) {
+    const result = this.interpret(source);
+    return result.output;
+  }
+
+  /**
+   * Gets the current variable environment
+   * @returns {Object} Variable environment
+   */
+  getEnvironment() {
+    return this.evaluator.environment.values;
+  }
+
+  /**
+   * Clears the variable environment
+   */
+  clearEnvironment() {
+    this.evaluator = new Evaluator();
+  }
+}
+
+module.exports = Interpreter;