Saltar al contenido
wandres.dev
Iniciar sesión

Build y producción

El camino a producción: pnpm, módulos, Vite y Rolldown, bundling, code splitting, lazy loading, monorepos y remote caching (Turborepo/Nx).

41 unidades · 201 temasEmpezar la ruta
  1. 00

    Nivel 0

    1 temas
    1. 01La ontología del build frontendhechoen curso
  2. 01

    Nivel 1

    5 temas
    1. 01El problema: el navegador no entiende tu códigohechoen curso
    2. 02Breve historia: de los scripts globales a Vitehechoen curso
    3. 03Qué hace una build tool por dentrohechoen curso
    4. 04El coste del build y cuándo no lo necesitashechoen curso
    5. 05El panorama en 2026: Vite y el toolchain en Rusthechoen curso
  3. 02

    Nivel 2

    5 temas
    1. 01ESM: import, export y bindings vivoshechoen curso
    2. 02CommonJS: require, module.exports y el runtimehechoen curso
    3. 03import() dinámico y top-level awaithechoen curso
    4. 04Interoperabilidad ESM y CommonJShechoen curso
    5. 05Módulos en el navegador vs en Nodehechoen curso
  4. 03

    Nivel 3

    5 temas
    1. 01npm: el registro, node_modules y el hoisting planohechoen curso
    2. 02El problema de node_modules: duplicación, fantasmas y determinismohechoen curso
    3. 03pnpm: store direccionable por contenido, hard links y symlinkshechoen curso
    4. 04yarn en breve: Berry, Plug'n'Play y por qué no se impusohechoen curso
    5. 05Elegir e instalar: pnpm, corepack y packageManagerhechoen curso
  5. 04

    Nivel 4

    5 temas
    1. 01Campos base: la identidad del paquetehechoen curso
    2. 02Las cuatro listas de dependenciashechoen curso
    3. 03scripts y los hooks de ciclo de vidahechoen curso
    4. 04semver a fondo: de un rango a una versionhechoen curso
    5. 05Campos modernos: engines, exports y companiahechoen curso
  6. 05

    Nivel 5

    5 temas
    1. 01El algoritmo de resolución de módulos de Nodehechoen curso
    2. 02El campo exports: la frontera del paquetehechoen curso
    3. 03Conditions: elegir la variante correctahechoen curso
    4. 04Subpath imports: alias privados con #hechoen curso
    5. 05Cómo los bundlers extienden la resoluciónhechoen curso
  7. 06

    Nivel 6

    5 temas
    1. 01Qué es un lockfile y por qué existehechoen curso
    2. 02La estructura de pnpm-lock.yamlhechoen curso
    3. 03Reproducibilidad en CI con frozen-lockfilehechoen curso
    4. 04Hoisting y node-linker: aislado vs planohechoen curso
    5. 05Actualizar dependencias con controlhechoen curso
  8. 07

    Nivel 7

    5 temas
    1. 01pnpm-workspace.yaml: declarar el monorepohechoen curso
    2. 02El protocolo workspace: referenciar paquetes internoshechoen curso
    3. 03--filter: ejecutar tareas en un subconjuntohechoen curso
    4. 04El grafo interno: orden topológico y compartir sin publicarhechoen curso
    5. 05Recursivo (-r), scripts y organización a escalahechoen curso
  9. 08

    Nivel 8

    5 temas
    1. 01El problema que resuelven los catalogshechoen curso
    2. 02Definir catalogs: el default y los catalogs nombradoshechoen curso
    3. 03El protocolo catalog: resolución y reescritura al publicarhechoen curso
    4. 04catalogMode: strict, prefer y manualhechoen curso
    5. 05Migrar un monorepo real a catalogshechoen curso
  10. 09

    Nivel 9

    5 temas
    1. 01Publicar: el flujo de npm publishhechoen curso
    2. 02Paquetes scoped: @org/pkg, acceso y publishConfighechoen curso
    3. 03dist-tags: latest, next y beta sin romper a nadiehechoen curso
    4. 04Provenance: procedencia firmada y SLSA desde CIhechoen curso
    5. 05Alternativas al registro npm: JSR, privados y espejoshechoen curso
  11. 10

    Nivel 10

    5 temas
    1. 01Qué es Vite: el dev server que no empaquetahechoen curso
    2. 02Por qué Vite es rápido: el coste que no pagashechoen curso
    3. 03La arquitectura de dos mitades: dev y buildhechoen curso
    4. 04Crear un proyecto Vite y entender su estructurahechoen curso
    5. 05Vite 8 en 2026: Rolldown y el motor únicohechoen curso
  12. 11

    Nivel 11

    5 temas
    1. 01Qué es el HMR: actualizar módulos sin recargar ni perder el estadohechoen curso
    2. 02El grafo de módulos y la propagación del cambiohechoen curso
    3. 03La API import.meta.hot: accept, dispose, data e invalidatehechoen curso
    4. 04Los límites de HMR y el fallback a full reloadhechoen curso
    5. 05HMR en frameworks: Fast Refresh y la preservación de estadohechoen curso
  13. 12

    Nivel 12

    5 temas
    1. 01vite.config.ts y defineConfig: la forma de la configuraciónhechoen curso
    2. 02resolve: alias, extensiones, conditions y dedupehechoen curso
    3. 03server: proxy, host y las opciones de desarrollohechoen curso
    4. 04Entorno y modos: import.meta.env, .env, envPrefix y definehechoen curso
    5. 05css y build: preprocesadores, target, outDir y salidahechoen curso
  14. 13

    Nivel 13

    5 temas
    1. 01Por qué existe el pre-bundlinghechoen curso
    2. 02Cómo funciona: escaneo, bundle y cachéhechoen curso
    3. 03include y exclude: forzar o evitar el pre-bundlinghechoen curso
    4. 04La caché de deps: node_modules/.vite y --forcehechoen curso
    5. 05Problemas comunes: monorepos, deps que cambian y CJShechoen curso
  15. 14

    Nivel 14

    5 temas
    1. 01El modelo de plugins de Vitehechoen curso
    2. 02Los hooks de Rollup: resolveId, load, transformhechoen curso
    3. 03Los hooks propios de Vitehechoen curso
    4. 04Módulos virtuales y el prefijo nulohechoen curso
    5. 05Escribir un plugin de principio a finhechoen curso
  16. 15

    Nivel 15

    5 temas
    1. 01El problema: una app moderna vive en varios entornoshechoen curso
    2. 02El concepto de environment: módulos aislados por destinohechoen curso
    3. 03La API: environments configurables, ModuleRunner y transforms por entornohechoen curso
    4. 04Cómo la usan los frameworks: SSR y edge de forma uniformehechoen curso
    5. 05Por qué unifica dev y build: el mismo grafo y el futuro con Rolldownhechoen curso
  17. 16

    Nivel 16

    5 temas
    1. 01Las dos naturalezas: ESM en dev, bundle en buildhechoen curso
    2. 02Por qué difieren: los bugs de dev que rompen en buildhechoen curso
    3. 03La transición histórica: de dos motores a Rolldownhechoen curso
    4. 04Build de cliente vs build de SSR: dos salidas del mismo códigohechoen curso
    5. 05Depurar diferencias dev/prod: reproducir el bug en localhechoen curso
  18. 17

    Nivel 17

    5 temas
    1. 01Los entry points y el grafo de móduloshechoen curso
    2. 02Las fases: resolución, carga y transformaciónhechoen curso
    3. 03Generar el output: chunks y formatoshechoen curso
    4. 04Por qué empaquetar en producciónhechoen curso
    5. 05Anatomía de un bundlehechoen curso
  19. 18

    Nivel 18

    5 temas
    1. 01Rollup: el bundler ESM-first que definió el modelohechoen curso
    2. 02Output formats: esm, cjs, iife y umdhechoen curso
    3. 03El sistema de plugins de Rollup: el estándar heredadohechoen curso
    4. 04Config de input y output: entradas, chunks y externalshechoen curso
    5. 05Por qué Vite usó Rollup en build y el salto a Rolldownhechoen curso
  20. 19

    Nivel 19

    5 temas
    1. 01Qué es Rolldown: el bundler en Rust sobre Oxchechoen curso
    2. 02Compatibilidad con Rollup: misma API, mismos pluginshechoen curso
    3. 03Rendimiento: por qué es 10-30x más rápido y unifica dos motoreshechoen curso
    4. 04Migración: el puente rolldown-vite y el salto a Vite 8hechoen curso
    5. 05El estado en 2026: Rolldown 1.0 y la API bloqueada por semverhechoen curso
  21. 20

    Nivel 20

    5 temas
    1. 01esbuild: bundler y transformador en un solo binariohechoen curso
    2. 02SWC: el transformador en Rust que vive dentro del bundlerhechoen curso
    3. 03Oxc: un toolchain entero bajo un solo ASThechoen curso
    4. 04oxlint y oxfmt: linter y formateador a velocidad de Rusthechoen curso
    5. 05Cuándo usar cada uno y la visión unificada de VoidZerohechoen curso
  22. 21

    Nivel 21

    5 temas
    1. 01Qué es el tree shaking: eliminar el código muerto del bundlehechoen curso
    2. 02Por qué ESM habilita el tree shaking y CommonJS nohechoen curso
    3. 03sideEffects en package.json: la promesa que poda módulos enteroshechoen curso
    4. 04Los límites del tree shaking: efectos ocultos y @__PURE__hechoen curso
    5. 05Verificar y depurar el tree shaking: por qué un módulo no se fuehechoen curso
  23. 22

    Nivel 22

    5 temas
    1. 01Code splitting: qué es y por quéhechoen curso
    2. 02import() dinámico como punto de cortehechoen curso
    3. 03Chunks compartidos y vendorhechoen curso
    4. 04manualChunks y chunking avanzadohechoen curso
    5. 05El coste del splitting: encontrar el equilibriohechoen curso
  24. 23

    Nivel 23

    5 temas
    1. 01Qué es el lazy loading y por qué importahechoen curso
    2. 02Splitting por ruta: el corte más rentablehechoen curso
    3. 03Splitting por componente: lazy y Suspensehechoen curso
    4. 04Prefetch y preload: adelantar sin bloquearhechoen curso
    5. 05El equilibrio: chunks, layout shift y UX de cargahechoen curso
  25. 24

    Nivel 24

    5 temas
    1. 01Qué hace un minificador por dentrohechoen curso
    2. 02terser, esbuild y oxc-minify: el trade-off velocidad/tamañohechoen curso
    3. 03Source maps: del código minificado al originalhechoen curso
    4. 04Depurar en producción sin exponer tu códigohechoen curso
    5. 05gzip y brotli: la compresión que va después del minifyhechoen curso
  26. 25

    Nivel 25

    5 temas
    1. 01Importar assets como módulos: url, raw e inlinehechoen curso
    2. 02Hashing para cache-busting: el hash del contenidohechoen curso
    3. 03Inlining de assets pequeños: el umbral y su preciohechoen curso
    4. 04CSS en el build: code splitting, extracción y ordenhechoen curso
    5. 05public vs assets procesados: pipeline o copia literalhechoen curso
  27. 26

    Nivel 26

    5 temas
    1. 01Librería vs aplicación: empaquetar para desconocidoshechoen curso
    2. 02Qué formatos ofrecer: ESM-first, CJS con criterio y el ocaso de UMDhechoen curso
    3. 03Externals: no empaquetes lo que el consumidor ya tienehechoen curso
    4. 04Publicar tipos: los .d.ts son parte del contrato, no un extrahechoen curso
    5. 05El manifiesto de una librería: exports, types, sideEffects, files y qué NO ponerhechoen curso
  28. 27

    Nivel 27

    5 temas
    1. 01Diseñar la superficie: entrada y subpathshechoen curso
    2. 02Dual package: ofrecer ESM y CommonJShechoen curso
    3. 03La condition types y el orden que importahechoen curso
    4. 04El dual package hazard: dos instanciashechoen curso
    5. 05Verificar el paquete: publint y attwhechoen curso
  29. 28

    Nivel 28

    5 temas
    1. 01Vite en lib mode: empaquetar una librería con build.libhechoen curso
    2. 02tsup sobre esbuild: configuración mínima y su reinadohechoen curso
    3. 03unbuild y tsdown: las opciones modernas y el stub modehechoen curso
    4. 04Generar tipos .d.ts: emitir, empaquetar y el futuro en Rusthechoen curso
    5. 05Elegir la herramienta y decidir: empaquetar o publicar sin bundlehechoen curso
  30. 29

    Nivel 29

    5 temas
    1. 01semver para librerías: el contrato del breaking changehechoen curso
    2. 02dist-tags para releases: publicar next y beta sin mover latesthechoen curso
    3. 03Controlar qué se publica: files, .npmignore y npm packhechoen curso
    4. 04Provenance desde CI: procedencia firmada y SLSAhechoen curso
    5. 05npm vs JSR: publicar ESM-first con tipos nativoshechoen curso
  31. 30

    Nivel 30

    5 temas
    1. 01Qué es Changesets y el flujo de la intención de publicarhechoen curso
    2. 02La anatomía de un changeset: el bump y el resumenhechoen curso
    3. 03changeset version: consumir, versionar y generar el changeloghechoen curso
    4. 04Publicar en CI: la GitHub Action de Changesetshechoen curso
    5. 05Changesets en monorepo: fixed, linked y dependencias internashechoen curso
  32. 31

    Nivel 31

    5 temas
    1. 01Qué es un monorepo y por quéhechoen curso
    2. 02La estructura típica: apps y packageshechoen curso
    3. 03Los retos: builds, CI y versionadohechoen curso
    4. 04Monorepo vs polyrepo: los trade-offshechoen curso
    5. 05El panorama de herramientas en 2026hechoen curso
  33. 32

    Nivel 32

    5 temas
    1. 01Qué es Turborepo y el task graphhechoen curso
    2. 02turbo.json: tasks, dependsOn y topologíahechoen curso
    3. 03inputs y outputs: la frontera de una tareahechoen curso
    4. 04Caching local: el hash y el replayhechoen curso
    5. 05Ejecución selectiva: --filter, --affected y paralelismohechoen curso
  34. 33

    Nivel 33

    5 temas
    1. 01El problema: la caché local no viajahechoen curso
    2. 02Cómo funciona: hash, subida y el cache hit remotohechoen curso
    3. 03Turborepo con Vercel Remote Cache: login, link y tokens en CIhechoen curso
    4. 04Self-hosted: el protocolo abierto y cuándo alojar tu cachéhechoen curso
    5. 05El impacto real: de veinte minutos a segundoshechoen curso
  35. 34

    Nivel 34

    5 temas
    1. 01Qué es Nx y el project graphhechoen curso
    2. 02Tasks, targets y executorshechoen curso
    3. 03Plugins y generadoreshechoen curso
    4. 04Nx Cloud: Replay y DTEhechoen curso
    5. 05Nx vs una configuración a manohechoen curso
  36. 35

    Nivel 35

    5 temas
    1. 01Turborepo: minimalismo y lo que no hace por tihechoen curso
    2. 02Nx: la plataforma completa y el coste de su poderhechoen curso
    3. 03Moon en Rust y el resto del panoramahechoen curso
    4. 04Criterios para elegir tu build systemhechoen curso
    5. 05Migrar entre herramientashechoen curso
  37. 36

    Nivel 36

    5 temas
    1. 01El hashing de entradas: qué compone el hash de una tareahechoen curso
    2. 02Qué invalida un cache hit: la aritmética del acierto y del fallohechoen curso
    3. 03Outputs y su restauración: la respuesta que la caché guardahechoen curso
    4. 04Seguridad de la caché: envenenamiento, CREEP y aislamiento por ramahechoen curso
    5. 05Buenas prácticas de caché: determinismo, aislamiento y disciplina de fronterashechoen curso
  38. 37

    Nivel 37

    5 temas
    1. 01Qué es Module Federation: integrar en runtimehechoen curso
    2. 02Host y remotes: exposes y remoteshechoen curso
    3. 03Dependencias compartidas: shared y singletonshechoen curso
    4. 04Microfrontends: equipos que despliegan soloshechoen curso
    5. 05Los trade-offs: acoplamiento y monolito modularhechoen curso
  39. 38

    Nivel 38

    5 temas
    1. 01Analizar el bundle: qué pesa de verdadhechoen curso
    2. 02Presupuestos de tamaño: fallar el CI si el bundle crecehechoen curso
    3. 03Vendor splitting y dedupe: dependencias cacheables sin duplicadoshechoen curso
    4. 04Core Web Vitals desde el buildhechoen curso
    5. 05Auditar en CI con Lighthouse CIhechoen curso
  40. 39

    Nivel 39

    5 temas
    1. 01El pipeline: instalar, verificar, construir, desplegarhechoen curso
    2. 02Cachear en CI: dependencias y caché remota de tareashechoen curso
    3. 03Previews por PR: una URL efímera por cada cambiohechoen curso
    4. 04Deploy: edge, CDN o contenedorhechoen curso
    5. 05Post-deploy: rollbacks y observabilidadhechoen curso
  41. 40

    Nivel 40

    5 temas
    1. 01Arquitectar el build de un producto a escalahechoen curso
    2. 02El toolchain unificado en Rust: la visión VoidZerohechoen curso
    3. 03Trade-offs de arquitectura: decidir con criteriohechoen curso
    4. 04Caso de estudio: de cero a producción al edgehechoen curso
    5. 05El futuro del tooling: hacia dónde va el buildhechoen curso