How daroncin/peonanny works
Tipo y propósito del proyecto (según file tree + README)
PeoNanny es un sitio web estático cuyo propósito es mostrar flores peonias “en carrusel”. El árbol de archivos indica que:
• Hay un index.html (punto de entrada web).
• Hay varios assets 3D en formato .glb (peony.glb, pink_peony.glb, peony_scan.glb, peony_point_cloud.glb), lo que sugiere un visor 3D (WebGL) y/o un componente tipo carousel que cambia el modelo mostrado.
• No hay backend (no hay server/, api/, package.json, etc.). La arquitectura más probable es Browser + Static Hosting + Assets.
Tu diagrama debe reflejar que el “sistema” es, esencialmente, una aplicación front-end estática que carga modelos 3D y los renderiza.
Cómo leer la estructura y mapearla a arquitectura
Con este árbol tan pequeño, la regla es: cada archivo importante = un componente o artefacto.
• index.html ⇒ UI / App shell (y probablemente contiene el JS embebido o referencias a librerías externas).
• *.glb ⇒ 3D Model Assets (recursos estáticos servidos por HTTP).
• README.md ⇒ documentación (no es runtime).
Como no vemos otros archivos JS/CSS, es posible que:
el JS esté inline en index.html, y/o
2) se use una librería via CDN (p.ej., <script src="...">) como three.js o <model-viewer>.
Esto es importante para el diagrama: incluye dependencias externas “CDN / third-party libs” aunque no existan como archivos locales.
Componentes principales que debe contener el diagrama (para este proyecto)
A un nivel “system design” (tipo C4-Container / deployment conceptual) usa estos bloques:
Usuario / Cliente
• User
• Browser (Web App runtime): donde corre HTML/JS, WebGL, event loop, etc.
Hosting / Entrega
• Static Web Host (GitHub Pages / Netlify / S3+CloudFront / servidor HTTP simple; no se especifica cuál, pero el patrón es el mismo):
• Sirve index.html
• Sirve los .glb
Frontend (en el browser)
• UI Layer / Carousel Controller
Responsable de:
• Interacciones (next/prev, autoplay, thumbnails, etc.)
• Decidir qué modelo .glb se carga
• 3D Viewer / Renderer (WebGL)
Puede ser:
• Three.js (scene/camera/light/loader/renderer), o
• <model-viewer> (Web Component con backend WebGL interno)
• Asset Loader
• Descarga .glb via HTTP(s)
• Cache del navegador (opcional, pero vale la pena mostrar como “Browser Cache” si quieres más detalle)
Recursos estáticos
• GLB Assets Repository (static files)
Representa el set:
• peony.glb
• pink_peony.glb
• peony_scan.glb
• peony_point_cloud.glb
Dependencias externas (probables)
• CDN / Third-party libraries (si index.html referencia scripts externos)
• Librería 3D
• CSS frameworks (si aplica)
• (Opcional) fuentes/íconos
Relaciones e interacciones (flechas obligatorias)
Para que sea “accurate”, muestra flujos concretos:
User → Browser
• “Clicks / swipe / keyboard” para mover el carrusel
Browser → Static Host
• GET /index.html
• GET /peony.glb, etc.
Browser UI/Carousel → Asset Loader
• “select model” / “load model X”
Asset Loader → GLB Assets (via Host)
• Descarga binaria .glb
Asset Loader → 3D Viewer
• Entrega “parsed GLTF/GLB scene” o “model resource”
(Si hay CDN) Browser → CDN
• “GET three.js / model-viewer.js”
Con esto queda claro: no hay API, no hay DB, no hay autenticación, no hay colas.
Patrones/decisiones arquitectónicas a resaltar (específicas a este proyecto)
• Static-site architecture: hosting simple, sin servidor de aplicación.
• Client-side rendering: todo el render 3D ocurre en el cliente.
• Asset-driven app: la “data principal” son los .glb.
• Carousel as state machine (implícito): estado = modelo actual, transiciones = next/prev/autoplay.
• (Si usas three.js) Render loop y separación conceptual: Scene/Camera/Lights/Controls/Loader.
Diagrama de contexto/containers (alto nivel)
• Usuario, Browser, Static Host, CDN, Assets.
Diagrama de componentes dentro del Browser (detalle)
• UI/Carousel, Viewer, Loader, Cache, WebGL/GPU.
Esto te da precisión sin mezclar niveles.
Paso 2: Nombra componentes con base en artefactos reales
• “index.html (App Shell + UI)” como componente
• “GLB Assets (*.glb)” como componente
• Si confirmas librería al abrir index.html, nómbrala literalmente:
• “Three.js (GLTFLoader, WebGLRenderer)” o “<model-viewer>”
Paso 3: Señala dónde vive cada cosa (deployment)
• Client (Browser) boundary
• Static Hosting boundary
• Internet/CDN boundary
Diagrama 1 (alto nivel)
• [User]
→ [Browser: PeoNanny Web App (index.html)]
→ (HTTP GET) [Static Web Host]
→ serves: [index.html] y [GLB assets: peony*.glb]
• [Browser] → (optional HTTP GET) [CDN: three.js / model-viewer]
Diagrama 2 (interno del Browser)
Dentro de un boundary “Browser”:
• [UI / Carousel Controller]
→ triggers → [Asset Loader (GLB/GLTF)]
→ feeds → [3D Viewer / Renderer]
→ renders via → [WebGL / GPU]
• [Asset Loader] ↔ [Browser Cache] (opcional)
• Fuera del boundary:
• [Static Host / Assets] como fuente de descarga
Qué verificar rápidamente en index.html para aumentar exactitud
Antes de finalizar el diagrama, abre index.html y busca:
• Referencias a CDN (three.min.js, model-viewer, babylon.js, etc.)
• Nombres de funciones/IDs que indiquen “carousel”, “model list”, “autoplay”
• Rutas exactas a .glb (para etiquetar “Model list / manifest” si existe inline)
Si encuentras que el carousel usa, por ejemplo, un array de modelos, puedes agregar un componente:
• Model Registry (inline config in index.html) → lista de .glb
Enfoque: “separar en tantos componentes como sea posible”
Para este repo minimalista, “detallado” no significa inventar microservicios; significa:
• Separar UI, loader, renderer, assets, hosting, CDN, GPU/WebGL,
• y dibujar flujos HTTP y de render.
Eso produce un diagrama preciso, útil para performance (tamaño de assets), caching, y dependencias externas.