docs(operators): update examples

src/assets/doc/operators/combination/forkJoin.md

@@ -60,31 +60,32 @@ Opcionalmente, `forkJoin` recibe una función de proyección, que se llamará co
 <a target="_blank" href="https://stackblitz.com/edit/docu-rxjs-forkjoin?file=index.ts">StackBlitz</a>
 
 ```javascript
-import { forkJoin, of } from "rxjs";
+import { forkJoin, from, of } from "rxjs";
 
-const pokemon$ = forkJoin([
-  of("Bulbasaur", "Charmander", "Squirtle"),
-  of("Grass", "Fire", "Water"),
+const language$ = forkJoin([
+  of("Java", "Ruby", "Haskell"),
+  from(["Orientado a objetos", "Multiparadigma", "Funcional"]),
 ]);
 
-pokemon$.subscribe(console.log);
-// Salida: [ 'Squirtle', 'Water' ]
+// Combinar la última emisión de dos Observables distintos
+language$.subscribe(console.log);
+// Salida: ["Haskell", "Funcional"]
 ```
 
 **Combinar la última emisión de dos Observables distintos, contenidos en un diccionario de datos**
 
 <a target="_blank" href="https://stackblitz.com/edit/docu-rxjs-forkjoin-2?file=index.ts">StackBlitz</a>
 
 ```javascript
-import { forkJoin, of } from "rxjs";
+import { forkJoin, from, of } from "rxjs";
 
-const pokemonDictionary$ = forkJoin({
-  name: of("Bulbasaur", "Charmander", "Squirtle"),
-  type: of("Grass", "Fire", "Water"),
+const languageDictionary$ = forkJoin({
+  language: of("Java", "Ruby", "Haskell"),
+  type: from(["Orientado a objetos", "Multiparadigma", "Funcional"]),
 });
 
-pokemonDictionary$.subscribe(console.log);
-// Salida: { name: Squirtle, type: Water }
+languageDictionary$.subscribe(console.log);
+// Salida: { language: Haskell, type: Funcional }
 ```
 
 **Si alguno de los Observables de entrada lanza un error, el Observable resultante lanzará un error inmediatamente, y el flujo se terminará**

src/assets/doc/operators/combination/zip.md

@@ -61,13 +61,12 @@ zip(hello$, world$).subscribe(console.log);
 import { from, interval, zip } from "rxjs";
 import { map } from "rxjs/operators";
 
-const pokemon$ = zip(
-  from(["Charmander", "Squirtle", "Bulbasaur"]),
-  interval(1000)
-).pipe(map(([pokemon]) => pokemon));
+const framework$ = zip(from(["Angular", "React", "Vue"]), interval(1000)).pipe(
+  map(([framework]) => framework)
+);
 
-pokemon$.subscribe(console.log);
-// Salida: (1s) Charmander (1s) Squirtle (1s) Bulbasaur
+framework$.subscribe(console.log);
+// Salida: (1s) Angular (1s) React (1s) Vue
 ```
 
 ### Ejemplo de la documentación oficial

src/assets/doc/operators/conditional/find.md

@@ -55,23 +55,27 @@ key$.pipe(find(({ code }) => code === "KeyX")).subscribe(console.log);
 // Salida: KeyboardEvent {}
 ```
 
-**Emitir el primer Pokémon de tipo _Water_**
+**Emitir el primer lenguaje de tipo Multiparadigma**
+
+Aunque haya más de un lenguaje de tipo multiparadigma, find emite únicamente el primero que encuentra.
 
 <a target="_blank" href="https://stackblitz.com/edit/docu-rxjs-find-2?file=index.ts">StackBlitz</a>
 
 ```javascript
 import { find } from "rxjs/operators";
 import { from } from "rxjs";
 
-// Aunque haya más de un Pokémon de tipo agua, find emite únicamente el primero que encuentra
-const pokemon$ = from([
-  { name: "Charmander", type: "Fire" },
-  { name: "Squirtle", type: "Water" },
-  { name: "Gyarados", type: "Water" },
+const language$ = from([
+  { name: "Java", type: "Orientado a objetos" },
+  { name: "Ruby", type: "Multiparadigma" },
+  { name: "Haskell", type: "Funcional" },
+  { name: "Rust", type: "Multiparadigma" },
 ]);
 
-pokemon$.pipe(find(({ type }) => type === "Water")).subscribe(console.log);
-// Salida: { name: "Squirtle", type: "Water" }
+language$
+  .pipe(find(({ type }) => type === "Multiparadigma"))
+  .subscribe(console.log);
+// Salida: { name: "Ruby", type: "Multiparadigma" }
 ```
 
 **Si ningún elemento cumple la condición, se emite undefined**

src/assets/doc/operators/conditional/findIndex.md

@@ -43,22 +43,24 @@ findIndex searches for the first item in the source Observable that matches the
 
 ## Ejemplos
 
-**Emite el índice del primer Pokémon de tipo fuego**
+**Emitir el índice del primer lenguaje de tipo Multiparadigma**
 
 <a target="_blank" href="https://stackblitz.com/edit/rxjs-findindex-1?file=index.ts">StackBlitz</a>
 
 ```javascript
 import { findIndex } from "rxjs/operators";
 import { from } from "rxjs";
 
-const pokemon$ = from([
-  { name: "Squirtle", type: "Water" },
-  { name: "Charmander", type: "Fire" },
-  { name: "Bulbasaur", type: "Grass" },
-  { name: "Cyndaquil", type: "Fire" },
+const language$ = from([
+  { name: "Java", type: "Orientado a objetos" },
+  { name: "Ruby", type: "Multiparadigma" },
+  { name: "Haskell", type: "Funcional" },
+  { name: "Rust", type: "Multiparadigma" },
 ]);
 
-pokemon$.pipe(findIndex(({ type }) => type === "Fire")).subscribe(console.log);
+language$
+  .pipe(findIndex(({ type }) => type === "Multiparadigma"))
+  .subscribe(console.log);
 // Salida: 1
 ```
 

src/assets/doc/operators/creation/defer.md

@@ -59,7 +59,7 @@ deferredTime$.subscribe(console.log);
 // Salida: La fecha en el momento de la suscripción
 ```
 
-**Crear un Observable que emita un Pokemon distinto cada vez que un observador se suscribe a él**
+**Crear un Observable que emita una fruta distinta cada vez que un observador se suscribe a él**
 
 <a target="_blank" href="https://stackblitz.com/edit/docu-rxjs-defer-2?file=index.ts">StackBlitz</a>
 
@@ -72,7 +72,7 @@ function getRandomFruit() {
   return fruits[Math.floor(Math.random() * 3)];
 }
 
-// Cada suscriptor a este Observable recibirá SIEMPRE la misma fruta, ya que la función getRandomPokemon se ejecuta solo una vez, en el momento en el que se crea el Observable
+// Cada suscriptor a este Observable recibirá SIEMPRE la misma fruta, ya que la función getRandomFruit se ejecuta solo una vez, en el momento en el que se crea el Observable
 const randomFruit$ = of(getRandomFruit());
 
 // Cada suscriptor a este Observable recibirá una fruta DISTINTA cada vez, ya que la función getRandomFruit se ejecuta cada vez que nos suscribimos

src/assets/doc/operators/creation/from.md

@@ -75,16 +75,16 @@ fruit$.subscribe((fruit) => console.log(fruit));
 ```javascript
 import { from } from "rxjs";
 
-const pokemon$ = from(
+const language$ = from(
   new Map([
-    ["Squirtle", "Water"],
-    ["Charmander", "Fire"],
-    ["Bulbasur", "Grass"],
+    ["Java", "Orientado a objetos"],
+    ["Ruby", "Multiparadigma"],
+    ["Haskell", "Funcional"],
   ])
 );
 
-pokemon$.subscribe(console.log);
-// Salida: ["Squirtle", "Water"], ["Charmander", "Fire"], ["Bulbasur", "Grass"]
+language$.subscribe(console.log);
+// Salida: ["Java", "Orientado a objetos"], ["Ruby", "Multiparadigma"], ["Haskell", "Funcional"]
 ```
 
 **Crear un Observable a partir de una promesa**

src/assets/doc/operators/creation/of.md

@@ -61,10 +61,10 @@ number$.subscribe((number) => console.log(number));
 ```javascript
 import { of } from "rxjs";
 
-const pokemon$ = of("Squirtle", "Charmander", "Bulbasaur");
+const framework$ = of("Angular", "React", "Vue");
 
-pokemon$.subscribe((pokemon) => console.log(pokemon));
-// Salida: Squirtle, Charmander, Bulbasaur
+framework$.subscribe(console.log);
+// Salida: Angular, React, Vue
 ```
 
 **Emitir una secuencia de arrays**

src/assets/doc/operators/filtering/distinct.md

@@ -74,18 +74,22 @@ fruit$.pipe(distinct()).subscribe(console.log);
 import { distinct } from "rxjs/operators";
 import { of } from "rxjs";
 
-const pokemon$ = of(
-  { name: "Squirtle", type: "Water" },
-  { name: "Bulbasaur", type: "Grass" },
-  { name: "Bulbasaur", type: "Grass" },
-  { name: "Charmander", type: "Fire" },
-  { name: "Charmander", type: "Fire" },
-  { name: "Squirtle", type: "Water" },
-  { name: "Bulbasaur", type: "Grass" }
+const language$ = of(
+  { name: "Java", type: "Orientado a objetos" },
+  { name: "Ruby", type: "Multiparadigma" },
+  { name: "Ruby", type: "Multiparadigma" },
+  { name: "Haskell", type: "Funcional" },
+  { name: "Haskell", type: "Funcional" },
+  { name: "Java", type: "Orientado a objetos" },
+  { name: "Ruby", type: "Multiparadigma" }
 );
 
-pokemon$.pipe(distinct(({ name }) => name)).subscribe(console.log);
-// Salida: { name: "Squirtle", type: "Water" } { name: "Bulbasaur", type: "Grass" } { name: "Charmander", type: "Fire" }
+language$.pipe(distinct(({ name }) => name)).subscribe(console.log);
+/* Salida: 
+{ name: "Java", type: "Orientado a objetos" }, 
+{ name: "Ruby", type: "Multiparadigma" }, 
+{ name: "Haskell", type: "Funcional" }
+*/
 ```
 
 ### Ejemplos de la documentación oficial

src/assets/doc/operators/filtering/distinctUntilChanged.md

@@ -63,30 +63,30 @@ fruit$.pipe(distinctUntilChanged()).subscribe(console.log);
 import { distinctUntilChanged } from "rxjs/operators";
 import { of } from "rxjs";
 
-const pokemon$ = of(
-  { name: "Squirtle", type: "Water" },
-  { name: "Bulbasaur", type: "Grass" },
-  { name: "Bulbasaur", type: "Grass" },
-  { name: "Charmander", type: "Fire" },
-  { name: "Charmander", type: "Fire" },
-  { name: "Squirtle", type: "Water" },
-  { name: "Bulbasaur", type: "Grass" }
+const language$ = of(
+  { name: "Java", type: "Orientado a objetos" },
+  { name: "Ruby", type: "Multiparadigma" },
+  { name: "Ruby", type: "Multiparadigma" },
+  { name: "Haskell", type: "Funcional" },
+  { name: "Haskell", type: "Funcional" },
+  { name: "Java", type: "Orientado a objetos" },
+  { name: "Ruby", type: "Multiparadigma" }
 );
 
-pokemon$
+language$
   .pipe(
     distinctUntilChanged(
       ({ name: previousName }, { name }) => previousName === name
     )
   )
   .subscribe(console.log);
 /* Salida: 
-  { name: "Squirtle", type: "Water" },
-  { name: "Bulbasaur", type: "Grass" },
-  { name: "Charmander", type: "Fire" }
-  { name: "Squirtle", type: "Water" },
-  { name: "Bulbasaur", type: "Grass" }
- */
+  { name: "Java", type: "Orientado a objetos" },
+  { name: "Ruby", type: "Multiparadigma" },
+  { name: "Haskell", type: "Funcional" },
+  { name: "Java", type: "Orientado a objetos" },
+  { name: "Ruby", type: "Multiparadigma" }
+*/
 ```
 
 ### Ejemplos de la documentación oficial

src/assets/doc/operators/filtering/distinctUntilKeyChanged.md

@@ -59,25 +59,32 @@ key$.subscribe(console.log);
 // Salida: (Pulsar tecla y) (Pulsar tecla x) 'KeyX'
 ```
 
-**Emitir el objeto Pokémon si su propiedad `name` es distinta a la del objeto anterior**
+**Emitir el objeto lenguaje si su propiedad name es distinta a la del objeto anterior**
 
 <a target="_blank" href="https://stackblitz.com/edit/rxjs-distinctuntilkeychanged-2?file=index.ts">StackBlitz</a>
 
 ```javascript
 import { distinctUntilKeyChanged } from "rxjs/operators";
 import { of } from "rxjs";
 
-const pokemon$ = of(
-  { name: "Squirtle", type: "Water" },
-  { name: "Bulbasaur", type: "Grass" },
-  { name: "Bulbasaur", type: "Grass" },
-  { name: "Charmander", type: "Fire" },
-  { name: "Charmander", type: "Fire" },
-  { name: "squirtle", type: "Water" }
+const language$ = of(
+  { name: "Java", type: "Orientado a objetos" },
+  { name: "Ruby", type: "Multiparadigma" },
+  { name: "Ruby", type: "Multiparadigma" },
+  { name: "Haskell", type: "Funcional" },
+  { name: "Haskell", type: "Funcional" },
+  { name: "Java", type: "Orientado a objetos" },
+  { name: "Ruby", type: "Multiparadigma" }
 );
 
-pokemon$.pipe(distinctUntilKeyChanged("name")).subscribe(console.log);
-// Salida: { name: "Squirtle", type: "Water" } { name: "Bulbasaur", type: "Grass" } { name: "Charmander", type: "Fire" }
+language$.pipe(distinctUntilKeyChanged("name")).subscribe(console.log);
+/* Salida:
+  { name: "Java", type: "Orientado a objetos" },
+  { name: "Ruby", type: "Multiparadigma" },
+  { name: "Haskell", type: "Funcional" },
+  { name: "Java", type: "Orientado a objetos" },
+  { name: "Ruby", type: "Multiparadigma" }
+*/
 ```
 
 **Utilizar una función de comparación para ignorar las diferencias de mayúsculas/minúsculas**

src/assets/doc/operators/filtering/filter.md

@@ -78,23 +78,28 @@ key$
 // Salida: KeyX, KeyO...
 ```
 
-**Filtrar los Pokémon de tipo agua**
+**Filtrar los lenguages de tipo Multiparadigma**
 
 <a target="_blank" href="https://stackblitz.com/edit/rxjs-filter-3?file=index.ts">StackBlitz</a>
 
 ```javascript
 import { filter } from "rxjs/operators";
 import { from } from "rxjs";
 
-const pokemon$ = from([
-  { name: "Gyarados", type: "Water" },
-  { name: "Bulbasaur", type: "Grass" },
-  { name: "Charmander", type: "Fire" },
-  { name: "Squirtle", type: "Water" },
+const language$ = from([
+  { name: "Java", type: "Orientado a objetos" },
+  { name: "Ruby", type: "Multiparadigma" },
+  { name: "Haskell", type: "Funcional" },
+  { name: "Rust", type: "Multiparadigma" },
 ]);
 
-pokemon$.pipe(filter(({ type }) => type !== "Water")).subscribe(console.log);
-// Salida: { name: "Bulbasaur", type: "Grass" }, { name: "Charmander", type: "Fire" }
+language$
+  .pipe(filter(({ type }) => type !== "Multiparadigma"))
+  .subscribe(console.log);
+/* Salida: 
+{ name: "Java", type: "Orientado a objetos" },
+{ name: "Haskell", type: "Funcional" }
+*/
 ```
 
 ### Ejemplos de la documentación oficial

src/assets/doc/operators/filtering/first.md

@@ -108,18 +108,21 @@ user$.pipe(first(({ age }) => age === 21)).subscribe(console.log);
 import { first } from "rxjs/operators";
 import { from } from "rxjs";
 
-const pokemon$ = from([
-  { name: "Charmander", type: "Fire" },
-  { name: "Squirtle", type: "Water" },
-  { name: "Gyarados", type: "Water" },
+const language$ = from([
+  { name: "Ruby", type: "Multiparadigma" },
+  { name: "Haskell", type: "Funcional" },
+  { name: "Rust", type: "Multiparadigma" },
 ]);
 
-pokemon$
+language$
   .pipe(
-    first(({ type }) => type === "Grass", { name: "Bulbasaur", type: "Grass" })
+    first(({ type }) => type === "Orientado a objetos", {
+      name: "Java",
+      type: "Orientado a objetos",
+    })
   )
   .subscribe(console.log);
-// Salida: { name: "Bulbasaur", type: "Grass" }
+// Salida: { name: "Java", type: "Orientado a objetos" }
 ```
 
 ### Ejemplos de la documentación oficial