@icarusmx/creta 1.3.4 → 1.3.5

package/lib/data/lessons/lesson1-system-decomposition.js

@@ -0,0 +1,312 @@
+export const LESSON_1_SYSTEM_DECOMPOSITION = {
+  id: 1,
+  title: 'LECCIÓN 1: La parte difícil del diseño orientado a objetos es descomponer un sistema como un conjunto de objetos que interactúan entre sí',
+  subtitle: 'Enfoque práctico: Dos definiciones de sistema y su descomposición en objetos',
+  flow: [
+    {
+      message: '\nPresiona Enter para comenzar...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        'Comenzaremos con dos definiciones de sistema y posteriormente',
+        'ejemplificaremos la descomposición en objetos.'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para continuar...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        'Definición 1:',
+        'El sistema es una totalidad deductiva de discurso',
+        '\nDefinición 2:',
+        'El sistema es un conjunto de cosas que relacionadas',
+        'entre sí ordenadamente contribuyen a un determinado propósito'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver un ejemplo de sistema...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🏛️ Ejemplo: Biblioteca Digital',
+        '========================================',
+        '\n📚 Definición 1 - Totalidad deductiva de discurso:',
+        "Partiendo de 'Biblioteca Digital', ¿qué se deduce naturalmente?"
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver la primera deducción...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n🔍 Primera deducción:',
+        "• De 'Biblioteca' → contiene LIBROS",
+        "• De 'Digital' → acceso remoto por USUARIOS"
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver la deducción clave...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n⚡ Deducción clave:',
+        '• Libros + Usuarios → deben interactuar',
+        '• ¿Cómo? → préstamos, búsquedas, devoluciones',
+        "\n💡 Conclusión: De 'biblioteca digital' se deduce naturalmente",
+        '   un conjunto de libros y usuarios interactuando'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para la segunda definición...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🎯 Definición 2 - Conjunto de cosas con propósito:',
+        '¿Qué elementos relacionados contribuyen al propósito?',
+        '\n📖 Elementos del sistema:',
+        '• Libros - recursos que se prestan',
+        '• Usuarios - quienes solicitan préstamos',
+        '• Préstamos - relación temporal entre libro y usuario',
+        '• Biblioteca - coordina todo el proceso',
+        '\n🎯 Propósito determinado:',
+        'Facilitar el acceso organizado a recursos bibliográficos',
+        '\n🔗 Relaciones ordenadas:',
+        '• Usuario solicita → Biblioteca evalúa → Préstamo se crea',
+        '• Libro cambia estado → Usuario recibe acceso → Plazo se establece',
+        '• Vencimiento llega → Usuario devuelve → Libro se libera'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver la descomposición en objetos...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        'Descomposición en objetos:'
+      ],
+      type: 'text'
+    },
+    {
+      code: 'class Book {\n' +
+        '  constructor(title, author, isbn) {\n' +
+        '    this.title = title\n' +
+        '    this.author = author\n' +
+        '    this.isbn = isbn\n' +
+        '    this.isLoaned = false\n' +
+        '  }\n' +
+        '\n' +
+        '  isAvailable() {\n' +
+        '    return !this.isLoaned\n' +
+        '  }\n' +
+        '\n' +
+        '  markAsLoaned() {\n' +
+        '    this.isLoaned = true\n' +
+        '  }\n' +
+        '\n' +
+        '  markAsReturned() {\n' +
+        '    this.isLoaned = false\n' +
+        '  }\n' +
+        '}',
+      title: '📄 Clase Book',
+      type: 'code'
+    },
+    {
+      message: '\nPresiona Enter para ver User...',
+      type: 'pause'
+    },
+    {
+      code: 'class User {\n' +
+        '  constructor(name, email, maxLoans = 3) {\n' +
+        '    this.name = name\n' +
+        '    this.email = email\n' +
+        '    this.maxLoans = maxLoans\n' +
+        '    this.currentLoans = []\n' +
+        '  }\n' +
+        '\n' +
+        '  canBorrow() {\n' +
+        '    return this.currentLoans.length < this.maxLoans\n' +
+        '  }\n' +
+        '\n' +
+        '  addLoan(loan) {\n' +
+        '    this.currentLoans.push(loan)\n' +
+        '  }\n' +
+        '\n' +
+        '  removeLoan(loan) {\n' +
+        '    const index = this.currentLoans.indexOf(loan)\n' +
+        '    if (index > -1) this.currentLoans.splice(index, 1)\n' +
+        '  }\n' +
+        '}',
+      title: '📄 Clase User',
+      type: 'code'
+    },
+    {
+      message: '\nPresiona Enter para ver Loan...',
+      type: 'pause'
+    },
+    {
+      code: 'class Loan {\n' +
+        '  constructor(user, book, durationDays = 14) {\n' +
+        '    this.user = user\n' +
+        '    this.book = book\n' +
+        '    this.startDate = new Date()\n' +
+        '    this.dueDate = new Date(Date.now() + durationDays * 24 * 60 * 60 * 1000)\n' +
+        '    this.returned = false\n' +
+        '  }\n' +
+        '\n' +
+        '  isOverdue() {\n' +
+        '    return !this.returned && new Date() > this.dueDate\n' +
+        '  }\n' +
+        '\n' +
+        '  calculateFine() {\n' +
+        '    if (!this.isOverdue()) return 0\n' +
+        '    const daysLate = Math.ceil((new Date() - this.dueDate) / (24 * 60 * 60 * 1000))\n' +
+        '    return daysLate * 5 // $5 por día\n' +
+        '  }\n' +
+        '\n' +
+        '  returnBook() {\n' +
+        '    this.returned = true\n' +
+        '    this.book.markAsReturned()\n' +
+        '    this.user.removeLoan(this)\n' +
+        '  }\n' +
+        '}',
+      title: '📄 Clase Loan',
+      type: 'code'
+    },
+    {
+      message: '\nPresiona Enter para ver Library...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\nclass Library {',
+        '  constructor() {',
+        '    this.books = []',
+        '    this.users = []',
+        '    this.loans = []',
+        '  }',
+        '',
+        '  lendBook(user, book) {',
+        '    if (!user.canBorrow()) return null',
+        '    if (!book.isAvailable()) return null',
+        '',
+        '    const loan = new Loan(user, book)',
+        '    book.markAsLoaned()',
+        '    user.addLoan(loan)',
+        '    this.loans.push(loan)',
+        '    return loan',
+        '  }',
+        '',
+        '  returnBook(loan) {',
+        '    loan.returnBook()',
+        '    return loan.calculateFine()',
+        '  }',
+        '',
+        '  getOverdueLoans() {',
+        '    return this.loans.filter(loan => loan.isOverdue())',
+        '  }',
+        '}'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver la interacción...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        'Ejemplo de uso:',
+        '',
+        'const library = new Library()',
+        "const book = new Book('1984', 'George Orwell', '978-0451524935')",
+        "const user = new User('Ana García', 'ana@email.com')",
+        '',
+        '// Los objetos interactúan entre sí',
+        'const loan = library.lendBook(user, book)',
+        'console.log(book.isAvailable())  // false',
+        'console.log(user.canBorrow())    // true (2 préstamos disponibles)',
+        '',
+        '// Simular libro vencido',
+        'loan.dueDate = new Date(Date.now() - 24 * 60 * 60 * 1000)',
+        'console.log(loan.isOverdue())    // true',
+        'console.log(loan.calculateFine()) // 5',
+        '',
+        '// Devolver libro',
+        'const fine = library.returnBook(loan)',
+        'console.log(book.isAvailable())  // true'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para la conclusión...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🎓 Conclusión: La Descomposición de Sistemas',
+        '==================================================',
+        '🎯 Hemos demostrado que:',
+        '\n1️⃣ Sistema como totalidad deductiva:',
+        "   • De 'biblioteca digital' se deduce naturalmente: libros + usuarios",
+        '   • Esta deducción revela la interacción fundamental del sistema',
+        '\n2️⃣ Sistema como conjunto con propósito:',
+        '   • Elementos identificados: Book, User, Loan, Library',
+        '   • Relaciones ordenadas: solicitud → evaluación → préstamo → devolución',
+        '   • Propósito determinado: acceso organizado a recursos',
+        '\n⚡ La parte difícil:',
+        '¿Cómo decidimos que necesitábamos exactamente estos 4 objetos?',
+        '¿Por qué no 3? ¿Por qué no 10? ¿Cuál es el criterio?',
+        '\n🔍 Criterio de descomposición:',
+        '• Book - responsabilidad de estado propio',
+        '• User - responsabilidad de sus límites',
+        '• Loan - responsabilidad de la relación temporal',
+        '• Library - responsabilidad de coordinación',
+        '\n📚 Conexión con lecciones siguientes:',
+        '• Lección 2: Los objetos interactúan a través de solicitudes',
+        '• Lección 3: Las solicitudes son la única forma de ejecutar operaciones',
+        '• Lección 4-6: Cómo definir esas interacciones correctamente',
+        '\n💭 Reflexión:',
+        'La descomposición en objetos es difícil porque requiere identificar',
+        'las responsabilidades naturales que se deducen del sistema.'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\n✨ ¡Lección 1 completada! Presiona Enter para continuar...',
+      type: 'pause'
+    }
+  ]
+}

package/lib/data/lessons/lesson2-object-requests.js

@@ -0,0 +1,318 @@
+export const LESSON_2_OBJECT_REQUESTS = {
+  id: 2,
+  title: 'LECCIÓN 2: Los objetos interactúan entre sí a través de solicitudes',
+  subtitle: 'Enfoque práctico: Demostrar cómo los objetos se comunican sin acceder directamente a datos internos',
+  flow: [
+    {
+      lines: [
+        '\n💡 ¿Qué significa esto exactamente?',
+        '- Los objetos NO acceden directamente a los datos de otros objetos',
+        '- En lugar de eso, hacen SOLICITUDES específicas',
+        '- Cada solicitud tiene un propósito claro y definido'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para comenzar el ejercicio práctico...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🛠️ EJERCICIO PRÁCTICO: Sistema de Mensajería',
+        '==================================================',
+        '🎯 Vamos a ver cómo los objetos se solicitan información sin acceso directo',
+        '\nSistema: Chat entre usuarios',
+        'Objetos: User, Message, ChatRoom'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver el ANTI-PATRÓN...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '❌ ANTI-PATRÓN: Acceso Directo (INCORRECTO)',
+        '=============================================',
+        'Veamos qué NO debemos hacer:',
+        '\n// ❌ MALO: Acceso directo a datos internos',
+        'class ChatRoom {\n' +
+          '  addMessage(user, text) {\n' +
+          '    // ❌ Accediendo directamente a user.name\n' +
+          '    if (user.name && user.name.length > 0) {\n' +
+          '      // ❌ Accediendo directamente a user.isActive\n' +
+          '      if (user.isActive === true) {\n' +
+          '        const message = new Message(user.name, text)\n' +
+          '        this.messages.push(message)\n' +
+          '      }\n' +
+          '    }\n' +
+          '  }\n' +
+          '}',
+        '\n🚨 Problemas del acceso directo:',
+        '• ChatRoom conoce la estructura interna de User',
+        '• Si User cambia, ChatRoom se rompe',
+        '• No hay control sobre qué se accede',
+        '• Violación de encapsulación'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver la forma CORRECTA...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '✅ PATRÓN CORRECTO: Solicitudes (CORRECTO)',
+        '=============================================',
+        'Ahora veamos cómo debe ser:',
+        '\n// ✅ BUENO: Comunicación a través de solicitudes',
+        'class User {\n' +
+          '  constructor(name) {\n' +
+          '    this.#name = name\n' +
+          '    this.#isActive = true\n' +
+          '  }\n' +
+          '\n' +
+          '  // 🔑 SOLICITUD: getName()\n' +
+          '  getName() {\n' +
+          '    return this.#name\n' +
+          '  }\n' +
+          '\n' +
+          '  // 🔑 SOLICITUD: isCurrentlyActive()\n' +
+          '  isCurrentlyActive() {\n' +
+          '    return this.#isActive\n' +
+          '  }\n' +
+          '\n' +
+          '  // 🔑 SOLICITUD: canSendMessage()\n' +
+          '  canSendMessage() {\n' +
+          '    return this.#isActive && this.#name.length > 0\n' +
+          '  }\n' +
+          '}'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver cómo ChatRoom usa las solicitudes...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n// ✅ ChatRoom usa SOLICITUDES, no acceso directo',
+        'class ChatRoom {\n' +
+          '  addMessage(user, text) {\n' +
+          '    // ✅ SOLICITUD: ¿puede enviar mensajes?\n' +
+          '    if (user.canSendMessage()) {\n' +
+          '      // ✅ SOLICITUD: dame tu nombre\n' +
+          '      const userName = user.getName()\n' +
+          '      const message = new Message(userName, text)\n' +
+          '      this.messages.push(message)\n' +
+          '    }\n' +
+          '  }\n' +
+          '\n' +
+          '  getActiveUsers() {\n' +
+          '    return this.users.filter(user =>\n' +
+          '      // ✅ SOLICITUD: ¿estás activo?\n' +
+          '      user.isCurrentlyActive()\n' +
+          '    )\n' +
+          '  }\n' +
+          '}',
+        '\n🌟 Beneficios de las solicitudes:',
+        '• ChatRoom no conoce la estructura interna de User',
+        '• User controla qué información expone',
+        '• Cambios internos en User no afectan ChatRoom',
+        '• Cada solicitud tiene un propósito específico'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver tipos de solicitudes...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🔍 TIPOS DE SOLICITUDES',
+        '==============================',
+        'Las solicitudes pueden ser de diferentes tipos:',
+        '\n1️⃣ SOLICITUDES DE CONSULTA (Query)',
+        '   • user.getName() → devuelve información',
+        '   • user.isCurrentlyActive() → devuelve estado',
+        '   • message.getTimestamp() → devuelve dato',
+        '\n2️⃣ SOLICITUDES DE ACCIÓN (Command)',
+        '   • user.setActive(false) → cambia estado',
+        '   • message.markAsRead() → ejecuta acción',
+        '   • chatRoom.addUser(user) → modifica colección',
+        '\n3️⃣ SOLICITUDES DE VALIDACIÓN (Validation)',
+        '   • user.canSendMessage() → verifica capacidad',
+        '   • message.isValid() → verifica integridad',
+        '   • chatRoom.hasPermission(user) → verifica acceso'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver una interacción compleja...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '💬 EJEMPLO: Enviar mensaje con validaciones',
+        '=============================================',
+        '\n// Los objetos colaboran solo a través de solicitudes',
+        'function sendMessage(chatRoom, user, text) {\n' +
+          '  // 🔍 SOLICITUD: ¿el usuario puede enviar?\n' +
+          '  if (!user.canSendMessage()) {\n' +
+          '    console.log("Usuario no puede enviar mensajes")\n' +
+          '    return false\n' +
+          '  }\n' +
+          '\n' +
+          '  // 🔍 SOLICITUD: ¿el usuario tiene permisos en este chat?\n' +
+          '  if (!chatRoom.hasPermission(user)) {\n' +
+          '    console.log("Sin permisos en este chat")\n' +
+          '    return false\n' +
+          '  }\n' +
+          '\n' +
+          '  // 🔍 SOLICITUD: ¿el texto es válido?\n' +
+          '  const message = new Message(user.getName(), text)\n' +
+          '  if (!message.isValid()) {\n' +
+          '    console.log("Mensaje inválido")\n' +
+          '    return false\n' +
+          '  }\n' +
+          '\n' +
+          '  // ⚡ SOLICITUD: agregar el mensaje\n' +
+          '  chatRoom.addMessage(user, text)\n' +
+          '\n' +
+          '  // 🔍 SOLICITUD: notificar a usuarios activos\n' +
+          '  const activeUsers = chatRoom.getActiveUsers()\n' +
+          '  activeUsers.forEach(activeUser => {\n' +
+          '    // 🔍 SOLICITUD: notificar\n' +
+          '    activeUser.notifyNewMessage(message)\n' +
+          '  })\n' +
+          '\n' +
+          '  return true\n' +
+          '}',
+        '\n🎯 Observa: En ningún momento accedemos directamente a',
+        '    user.#name, user.#isActive, chatRoom.#messages, etc.',
+        '    Todo pasa por SOLICITUDES específicas.'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para la demostración final...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🎭 DEMOSTRACIÓN: Interacción Completa',
+        '========================================',
+        'Veamos todos los objetos interactuando:',
+        '\n// Crear objetos',
+        "const chatRoom = new ChatRoom('Desarrollo')",
+        "const ana = new User('Ana')",
+        "const carlos = new User('Carlos')",
+        '',
+        '// Agregar usuarios al chat',
+        'chatRoom.addUser(ana)    // SOLICITUD',
+        'chatRoom.addUser(carlos) // SOLICITUD',
+        '',
+        '// Ana envía mensaje',
+        "sendMessage(chatRoom, ana, 'Hola a todos!')",
+        '',
+        '// Secuencia de SOLICITUDES que se ejecutan:',
+        '// 1. ana.canSendMessage() → true',
+        '// 2. chatRoom.hasPermission(ana) → true',
+        "// 3. ana.getName() → 'Ana'",
+        '// 4. message.isValid() → true',
+        '// 5. chatRoom.addMessage(ana, text)',
+        '// 6. chatRoom.getActiveUsers() → [ana, carlos]',
+        '// 7. carlos.notifyNewMessage(message)',
+        '\n💡 Resultado:',
+        '✅ Ana: Mensaje enviado',
+        '📬 Carlos: Notificación recibida'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver qué pasa si Carlos se desconecta...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n// Carlos se desconecta',
+        'carlos.setActive(false)  // SOLICITUD',
+        '',
+        '// Ana envía otro mensaje',
+        "sendMessage(chatRoom, ana, 'Carlos, ¿estás ahí?')",
+        '',
+        '// Secuencia de SOLICITUDES:',
+        '// 1-5. Igual que antes...',
+        '// 6. chatRoom.getActiveUsers() → [ana]  // ¡Carlos ya no aparece!',
+        '// 7. Solo ana.notifyNewMessage() se ejecuta',
+        '\n💡 Resultado:',
+        '✅ Ana: Mensaje enviado',
+        '😴 Carlos: No recibe notificación (está inactivo)',
+        '\n🎯 Observación clave:',
+        'Los objetos cambian su comportamiento interno, pero las',
+        'SOLICITUDES siguen siendo las mismas. La interacción es estable.'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para la conclusión...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🎓 CONCLUSIÓN: Interacción a través de Solicitudes',
+        '==================================================',
+        '🎯 Hemos demostrado que:',
+        '\n1️⃣ Los objetos NUNCA acceden directamente a datos internos',
+        '2️⃣ Toda comunicación ocurre a través de SOLICITUDES específicas',
+        '3️⃣ Cada solicitud tiene un propósito claro y definido',
+        '4️⃣ Los objetos controlan qué información exponen',
+        '\n🔑 Tipos de solicitudes vistas:',
+        '• CONSULTA: getName(), isCurrentlyActive()',
+        '• ACCIÓN: setActive(), addMessage()',
+        '• VALIDACIÓN: canSendMessage(), hasPermission()',
+        '\n🌟 Beneficios fundamentales:',
+        '• Encapsulación preservada',
+        '• Flexibilidad para cambios internos',
+        '• Interacciones estables y predecibles',
+        '• Control total sobre el acceso a datos',
+        '\n📚 Conexión con otras lecciones:',
+        '• Lección 1: Los objetos que identificamos ahora interactúan',
+        '• Lección 3: Las solicitudes son la ÚNICA forma de ejecutar operaciones',
+        '• Lecciones 4-6: Cómo definir formalmente estas solicitudes',
+        '\n💭 Reflexión:',
+        '¿Te imaginas un mundo donde pudieras acceder directamente',
+        'a la cuenta bancaria de cualquier persona? ¡Sería un caos!',
+        'Los objetos funcionan igual: solicitudes controladas, acceso seguro.',
+        '\n🏆 Ahora entiendes por qué los objetos interactúan a través',
+        'de solicitudes: es la base de la comunicación segura y ordenada.'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\n✨ ¡Lección 2 completada! Presiona Enter para salir...',
+      type: 'pause'
+    }
+  ]
+}