Duplex y Transforms streams

No es mucho pero es trabajo honesto

const { Transform } = require('stream');


const camelStream = new Transform({
    transform(chunk, callback) {
        const data = chunk.toString();
        data.split(" ").map((word) => {
            this.push(word.charAt(0).toUpperCase() + word.slice(1));
        });
    }
});

process.stdin.pipe(camelStream).pipe(process.stdout);```

El propósito de tener distintos tipos de streams no solo es simplificar el código, tienen pequeñas diferencias en su objetivo.

Tipos de streams
Hay cuatro tipos fundamentales de streams en Node.js

• Writable: streams en los que los datos pueden ser escritos.
• Readable: streams en los que los datos pueden ser leídos.
• Duplex: streams que pueden ser leídos y escritos.
• Transform: Duplex streams que pueden modificar o transformar los datos cuando son escritos o leídos.

Mi Reto desglosado

const { Transform } = require('stream')

/** ingresa un string y convierte el primer
 * carácter a mayúscula
 */
const upperFirst = text => {
  //obtiene primer letra y convierte a mayúscula
  let first = text.charAt(0).toUpperCase()
  //el string a partir de la segunda letra
  let rest = text.slice(1)
  //unión primer letra + resto
  return first + rest
}

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    //la cadena de entrada en string
    const strChunk = chunk.toString()
    //cadena en minúsculas
    const lowerChunk = strChunk.toLowerCase()
    //array separado por espacio en blanco
    const arrayChunk = lowerChunk.split(' ')
    /**
     * creación de un nuevo array con camelCase
     * si  i (index) es 0 se retorna la primer
     * palabra sin cambios, si no se cambia la
     * primer letra de la palabra a mayúscula
     */
    const arrayCamel = arrayChunk.map((word,i)=>{
      return i === 0 ? word : upperFirst(word)
    })
    //se junta el array anterior y listo
    const camelCase = arrayCamel.join('')
    this.push(camelCase)
    //finaliza la el flujo para esta chunk
    callback()
  }
})
process.stdin.pipe(transformStream)
.pipe(process.stdout)

Mi reto simplificado

const { Transform } = require('stream')

const upperFirst = text => {
  return text.charAt(0)
    .toUpperCase()
    .concat(text.slice(1))
}

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    const camelCase = 
    chunk
    .toString()
    .toLowerCase()
    .split(' ')
    .map((word, index) => {
      return index === 0 ? word : upperFirst(word)
    })
    .join('')
    this.push(camelCase)
    callback()
  }
})

process.stdin.pipe(transformStream)
.pipe(process.stdout)

se puede optimizar más pero no se vería bien en este cuadrito de los aportes, esto lo hago con la finalidad de ayudar un poco a entender el código a los que no entienden muy bien 😃.

Aquí está mi solución, nada extraño y haciendo uso de código normal:

Evidencia:

Challenge: utilizando el codigo visto en clase.

const { Transform } = require("stream");

String.prototype.capitalize = function () {
  return this.replace(/(?:^|\s)\S/g, (input) => { return input.toUpperCase(); });
};

const transformStream = new Transform({
  transform(chunk, enconding, callback) {
    this.push(chunk.toString().capitalize());
    callback();
  }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

En mi opinión, es un poco confusa la explicación pues parece que se dice que se dice que Duplex y Transform sirven para lo mismo, sólo que el último tiene una sintaxis más sencilla. A mí me gustó esta explicación:
.
“It’s important to understand that the readable and writable sides of a duplex stream operate completely independently from one another. This is merely a grouping of two features into an object.
.
A transform stream is the more interesting duplex stream because its output is computed from its input.”
.
Fuente: https://www.freecodecamp.org/news/node-js-streams-everything-you-need-to-know-c9141306be93/

Here we go…

const {Transform} = require("stream");

const tranformStream = new Transform({
	transform(chunk, encoding, callback) {
		this.push(chunk.toString().split(" ").map((word) => {
			return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
		}).join(""));
		callback();
	}
})

process.stdin.pipe(tranformStream).pipe(process.stdout);

Un poco de información extra que me ayudo a comprender mejor los Streams node-js-streams-everything-you-need-to-know

Muchacho ahi dejo mi solución al reto y me lógica en un comentario !!!
Escucho aportes

/*
Challenge

Usando Streams crea una función en Node que reciba una cadena de texto y la convierta en camel case usando streams.

"hola como estas"
"holaComoEstas"

¿Que quiero?

Una función stringToCamelCase() que cuando reciba un string cualquiera lo convierta en CameCase, usando Streams.

El proceso para hacerlo realidad.

1. Recibo una cadena de texto.
2. Detecto los separadores: espacios en blanco o guiones que separan las palabras.
3. A la primera letra de la palabra que está a la derecha del separador la paso a mayusculas.
4. Creo un nuevo string donde elimino el separador.
5. Retorno la nueva cadena de texto.

Una vez hecho esto creare un WritableStream desde donde consumire los datos y los devolveré transformados.

*/

const {Writable} = require("stream");

function stringToCamelCase(string) {

	//"Hola-soy-una-persona-chevere"
	const whiteSpaceAndLetter = /(?<=[\-. ])\w/g;
	const separatorString = /[\-. ]/g;

	const upperCaseCharacterFound = (characterFound) => characterFound.toUpperCase();

	let stringTransformed = string.replace(whiteSpaceAndLetter, upperCaseCharacterFound);
	stringTransformed = stringTransformed.replace(separatorString, "");
	
	return stringTransformed
}


const writableStream = new Writable({
	write(chunk,encoding, callback) {
		const stringChunk = chunk.toString()
		console.log( stringToCamelCase(stringChunk) );
		callback();
	}
});

process.stdin.pipe(writableStream);

const {Transform} = require('stream');

const transformStream = new Transform({
    transform(chunk, encoding, callback) {

        let arrayToTransform = chunk.toString().split(' ');
        let stringToCamelCase = '';
        arrayToTransform.forEach(function (element) {
                stringToCamelCase += element.charAt(0).toUpperCase() + element.slice(1)
            }
        )

        this.push(stringToCamelCase);

        callback();
    }

});

process.stdin.pipe(transformStream).pipe(process.stdout);

const { Transform } = require("stream");

const transformStream = new Transform({
  transform(chunk, enconding, callback) {
    
    let camel = chunk.toString().toLowerCase()
    let tr_camel = camel.split(' ')

    let CamelCase = ''

    for (let index = 0; index < tr_camel.length; index++) {
      CamelCase = CamelCase.concat( tr_camel[index].charAt(0).toUpperCase() + tr_camel[index].slice(1))
    }

    this.push(CamelCase);
    callback();
  }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

const CamelCaseChallenge = new Transform({
    transform(chunk, encoding, cb){
        this.push(Camel(chunk.toString()));
        cb();
    }
});

//uso del callback
function Camel(str){
    let camelcase = str.split(" ").map((word) => {
        return word.charAt(0).toUpperCase() + word.slice(1);
    });

    return camelcase.join('');
};


process.stdin.pipe(CamelCaseChallenge).pipe(process.stdout);

/**
 * en una nueva funcion realizar lo siguiente:
 * 
 * 1ero = split me guarda por el caracter que detecte y me crea 
 * un array que luego map recorre cada espacio de dicho array de strings
 * donde el chatAt(0) leera en la posicion 0 de cada string 
 * por cada espacio en el array donde en dicha posicion convertira 
 * la letra 0 en mayuscula con toUpperCase(). 
 * 
 * (0 porque se empieza desde 0 en programacion).
 * 
 * 2do = luego se le concatena con slice que toma el valor que va a
 * retirar de la cadena, como split convierte el texto en un slot
 * el slice elimina el slot creado dejandolo void.
 * 
 * 3ero = se retorna todo el proceso con join que unifica los espacios
 * creados en un array que en este caso el array lo creo el split.
 * 
 * OJO>>el join solo combina strings, no se si numeros. 
 * 
 * proceso paso a paso:
 * 
 * parte-1 el texto=
 * hola mundo
 * 
 * ////////////////////////////////////////////////////////////
 * 
 * parte-2 el split trabajando = 
 * split(" ");
 * [hola], [ ], [mundo];
 * 
 *  resultado = ["hola"," ","mundo"] array con un nuevo slot.
 * 
 * ////////////////////////////////////////////////////////////
 * 
 * parte-3 el slice eliminando el espacio del array:
 * slice(1)
 * ["hola"," ","mundo"]
 *    0     1     2
 * ["hola","mundo"]                ["hola","mundo"]
 *     0      2  => termina siendo    0       1
 * 
 * ////////////////////////////////////////////////////////////
 * 
 * parte-4 el join combinando el array de strings :
 * el array:
 * ["hola","mundo"]
 * 
 * join("") => ojo en la documentacion del metodo join el aparece
 * asi join(), lo que significa que unira con todo y
 * "las comas invisibles del array",
 * 
 * el join que contenga algo tipo => join ("/") me va a unir
 * los slot o espacios con el slash.
 * 
 * en este caso:
 * 
 * join("") >> sin separar para que no los una asi sin mas
 * 
 * join("")
 * ["hola","mundo"]
 * 
 * RESULTADO = HolaMundo
 *  
 * 
 * 
 * 
 */

Esta es mi solución, tambien pudedo recalcar que el formato de texto donde la primera letra de la primera palabra tambien es mayúscula se llama PascalCase y esta es camelCase

const { Transform } = require('stream');
let data = '';
const transformStream = new Transform( {
  transform(chunk, encoding,callback) {
    data = chunk.toString().trim().split(' ');
    data = data.reduce((total, word) => {
      return total + word.charAt(0).toUpperCase() + word.slice(1)
    }, data[0].toLowerCase())
    console.log(data);
    callback();
  }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

El reto…

const { Transform } = require("stream");

String.prototype.camalize = function camalize() {
  return this.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) =>
    chr.toUpperCase()
  );
};

const toCamelCaseStream = new Transform({
  transform(chunk, _, callback) {
    this.push(chunk.toString().camalize());
    callback();
  }
});

process.stdin.pipe(toCamelCaseStream).pipe(process.stdout);

My code!

const { Transform } = require('stream');

const capitalizeStream = new Transform({
    transform(chunk, encoding, cb) {
        let string =  chunk
            .toString()
            .trim()
            .split(' ')
            .map( res =>  {
                return typeof res === 'string' ? res.charAt(0).toUpperCase() + res.slice(1) : ''
            })
            .join('');
            
        this.push(string)
        cb();
        
    }
})

process.stdin.pipe(capitalizeStream).pipe(process.stdout);

😃 un poco noobster pero ahi vamos

<'use strict'

const { Transform } = require('stream')

const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        this.push(chunk.toString().charAt(0).toUpperCase() + chunk.slice(1).toString().replace(/\s/g, ''))
        callback
    }
})

process.stdin.pipe(transformStream).pipe(process.stdout)>

mi solucion:

const { Transform } = require('stream')

const toCamelCase = new Transform({
    transform (chunk, encoding, callback) {
        let words = chunk.toString().split(' ')
        let camelWords = ''
        words.forEach(element => {
            let newWord = element.slice(0,1).toUpperCase() + element.slice(1)
            camelWords += newWord
        })
        this.push(camelWords)
        callback()
    }
})


process.stdin.pipe(toCamelCase).pipe(process.stdout)

Reto: convertir texto cualquiera a CamelCase
Resultado: hola amigos como estan => HolaAmigosComoEstan

const { Transform } = require("stream");

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    const newChunk = chunk.toString();
    const initChar = newChunk.slice(0,1);
    const otherChars = newChunk.slice(1, newChunk.length);
    this.push(initChar.toUpperCase() + otherChars);
    callback();
  }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Mi solución al reto

const { Transform } = require("stream")

function toCamelCase(str) {
  return str
    .split(" ")
    .map(function(word, index) {
      if (index == 0) {
        return word.toLowerCase()
      }
      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
    })
    .join("")
}

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    this.push(toCamelCase(chunk.toString()))
    callback()
  }
})

process.stdin.pipe(transformStream).pipe(process.stdout)

Mi solución

const { Transform } = require('stream');

String.prototype.toCamelCase = function() {
  return this.toLowerCase()
    .replace(/\b(\w)/g, function(match, capture) {
      return capture.toUpperCase();
    })
    .replace(/\s+/g, '');
};

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    this.push(chunk.toString().toCamelCase());
    callback();
  }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Mi solucion al reto:

const { Transform } = require('stream');

function camelText(str) {
	return str
		.toLowerCase()
		.replace(/[^a-zA-Z0-9]+(.)/g, (m, chr) => chr.toUpperCase());
}

const transfromStream = new Transform({
	transform(chunk, encoding, callback) {
		this.push(camelText(chunk.toString()));
		callback();
	}
});
process.stdin.pipe(transfromStream).pipe(process.stdout);

Challenge:

const { Transform } = require('stream');

const camelize = (str) => {
    return str.replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => {
        return index == 0 ? 
            word.toLowerCase(): 
            word.toUpperCase();
    }).replace(/\s+/g, '');
}

const transformStream = new Transform({
    transform(chuck, enc, callback) {
        this.push(camelize(chuck.toString()));
        callback();
    }
});


process.stdin.pipe(transformStream).pipe(process.stdout);

Mi solucionn:

const { Transform } = require('stream');

const toCamel = new Transform({
    transform(chunk, encoding, callback){
        const data = chunk.toString();
        const wordsArray = data.split(' ');
        const camelString = wordsArray.reduce((prev, curr) => {
            return prev + curr[0].toUpperCase() + curr.slice(1);
        }, '');
        this.push(camelString);
        callback();
    }
});

process.stdin.pipe(toCamel).pipe(process.stdout);

const { Transform } = require("stream");

const transformStream = new Transform({
    transform(chunk, enconding, callback) {
        let first = chunk.toString().replace(/ /g, '')
        this.push(chunk.toString().charAt(0).toUpperCase()+first.slice(1));
        callback();
    }
});

process.stdin.pipe(transformStream).pipe(process.stdout);```

Reto hecho:

const { Transform } = require('stream');

String.prototype.replaceAt=function(index, replacement) {
    return this.substr(0, index) + replacement+ this.substr(index + replacement.length);
};

const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        this.push(toCamelCase(chunk));
        callback();
    }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

const toCamelCase = typeChar => {
    const arrayWord = typeChar.toString().split(' ');
    arrayWord[0] = arrayWord[0].toLowerCase();
    for (let i = 1; i < arrayWord.length; i++){
        arrayWord[i] = arrayWord[i].replaceAt(0, arrayWord[i][0].toUpperCase());
        console.log(arrayWord[i][0].toUpperCase());
    }

    return arrayWord.join('');
};

el reto:

const { Transform } = require("stream");

const transformStream = new Transform({
    transform(chunk, enconding, callback) {
        this.push(ucwords(chunk.toString()));
        callback();
    }
});

process.stdin.pipe(transformStream).pipe(process.stdout);


const ucwords = (word) => {
    return word.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g,
        (_, s) => s.toUpperCase());
};

const { Transform } = require('stream');

const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        const camel = chunk
            .toString()
            .trim()
            .split(' ')
            .map(item => cadenaTexto(item))
            .join('');
        this.push(camel)
        callback()
    }
})


function cadenaTexto(cadena) {
    let primeraLetra = cadena.charAt(0).toUpperCase()
    cadena = cadena.slice(1)
    return primeraLetra.concat(cadena)
}

process.stdin.pipe(transformStream).pipe(process.stdout)

Solución al Reto:

const { Transform } = require('stream');

const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        this.push(chunk
            .toString()
            .toLowerCase()
            .split(' ')
            .map(item => item[0].toUpperCase() + item.slice(1, item.length))
            .join(''));
        callback();
    }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Les comparto mi implementación. Sencilla y práctica

const {Transform } = require(‘stream’);

const transformStream = new Transform({
transform(chunk, encoding, callback){
const data = chunk.toString().split(" ").map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(’’)
; this.push(data)
callback();
}
})

process.stdin.pipe(transformStream).pipe(process.stdout);

Mi solución aunque no aporte nada nuevo T_T.

const { stdout } = require("process");
const { Transform } = require("stream");

const transformStream = new Transform({
  transform(chunk, encoding, cb) {
    const strArray = chunk.toString().split(" ");
    let result = "";
    for (let i = 0; i < strArray.length; i++) {
      result += strArray[i].charAt(0).toUpperCase();
      result += strArray[i].slice(1);
    }
    this.push(result);
    cb();
  },
});

process.stdin.pipe(transformStream).pipe(stdout);

Escelente reto para hacer operaciones con los Streams!

Mi solución:

El reto fasilito dirian por ahi en la comunidad de League of legends

const {Transform} = require("stream");

const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        let camelCase = chunk.toString().split(" ");
        camelCase = camelCase.map(chunk => {
            return chunk[0].toUpperCase() + chunk.substr(1);
        })
        this.push(camelCase.join(""));
        callback();
    }
});


process.stdin.pipe(transformStream).pipe(process.stdout);

Más código pero ya quedó el CamelCase

//convertir una frase en CamelCase
const { Transform } = require('stream');

var cadena = [];
var tempUppper = "";
var tempLower = "";
var temp = "";
var cadenaTemp = "";

const camelCase = new Transform({
    
    transform(chunk, cb) {
        const data = chunk.toString();
        
        cadena = data.split(" ");

        for(let i = 0; i < cadena.length; i++){
            
            cadenaTemp = cadena[i];
            for(let j = 0; j < cadenaTemp.length; j++){
                
               if( j === 0){
                    tempUppper = cadenaTemp[j].toUpperCase();
               }else{
                   tempLower = tempLower + cadenaTemp[j];
               }
            }
            temp = temp + tempUppper + tempLower;
            tempLower = "";
            tempUppper = "";
        }
        
        this.push(temp);
        this.push(null);
        return;
    }
});

process.stdin.pipe(camelCase).pipe(process.stdout);

Aún se puede mejorar, por lo pronto reto cumplido 😄

JS Challenge 2021 (04/Oct/2021)

Mi solución al reto:

const { Transform } = require("stream");

const transformStream = new Transform({
	transform(chunk, encoding, callback) {
		//Convertir el chunk a string
		let data = chunk.toString();
		/*Separa cada palabra por espacio. Crea un array con cada cadena
    de la palabra*/
		data = data.split(" ");
		/*Recorre cada elemento del array y reemplaza la primer letra 
    por la misma pero en mayúscula*/
		data = data.map((str) =>
			str.replace(str.charAt(0), str.charAt(0).toUpperCase())
		);
		//Reducimos el array a una sola cadena
		const reducer = (accumulator, currentValue) => accumulator + currentValue;
		const camelCase = data.reduce(reducer, "");
		//Push del chunk ya transformado
		this.push(camelCase);
		callback();
	},
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Aqui un ejemplo desglosado usando const identifatorios

const { Transform } = require('stream');

const cameCaseTransform = new Transform({
    transform(chunk, encoding, callback) {

        const toCamelCase = (chunkParameter) => {

            const chunkString = chunkParameter.toString(); // Se convierte a string
            const primeraLetra = chunkString.charAt(0);
            const primeraLetraMayuscula = primeraLetra.toUpperCase();

            const restoDelChunk = chunkString.slice(1);
            const restoDelChunkMinuscula = restoDelChunk.toLowerCase();

            const concat = primeraLetraMayuscula + restoDelChunkMinuscula;

            const stringSinEspacios = concat.replace(/ /g, "");
            return stringSinEspacios;
        }

        this.push(toCamelCase(chunk));

        callback();
    }
})

process.stdin.pipe(cameCaseTransform).pipe(process.stdout);

Aqui un gist

Aquí mi solución al reto:

Prueba del código:

amigos… intenté enviar la cadena desde postman ( ya habiendo creado un server de escucha ) y al final no logré regresar el camelCase como respuesta.

const { Transform } = require('stream')

const stringToCapitalize = str => {
  const eachWord = str.split(' ')
  let joinWords = ''
  eachWord.slice(1, eachWord.length).map(item => (
    joinWords += item[0].toUpperCase() + item.slice(1)
  ))

  return `${eachWord[0]}${joinWords}`
}

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    this.push(stringToCapitalize(chunk.toString()))
    callback()
  }
})

process.stdin.pipe(transformStream).pipe(process.stdout)

Para este reto lo único que hice fue obtener el paquete de npm camelCase aquí les dejo el código:

const { Transform } = require('stream');
const { camelCase } = require('camel-case');
// Use el paquete de NPM camel case para hacer el reto
const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        this.push(camelCase(chunk.toString()))
        callback();
    }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Mi humilde aporte:

const { Transform } = require("stream");

function conversor(texto) {
  const cajita = [];

  const separar = texto.split(" ");

  separar.forEach((palabra) => {
    const primeraLetra = palabra[0].toUpperCase();

    palabra = palabra.slice(1)
    const palabraCompleta = primeraLetra.concat(palabra)
    cajita.push(palabraCompleta);
  });
  return cajita.join('');
}

const transformStream = new Transform({
  transform(chunk, encoding, cb) {
  
    this.push(conversor(chunk.toString()));
    cb();
  },
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Listo, utilicé un regex para detectar la primer letra de cada palabra.

const { Transform } = require("stream");

const tStream = new Transform({
  transform(chunk, encoding, callback) {
    //convertir el chunk a texto
    const data = chunk.toString();
    //Separar la cadena de texto por espacios
    data.split(" ").map((word) => {
      this.push(
        word
          .toLowerCase()
          .replace(/\w/, (firstLetter) => firstLetter.toUpperCase())
      );
    });
    
    //callback para finalizar el estream
    callback();
  },
});

process.stdin.pipe(tStream).pipe(process.stdout);

La información la obtuve de aqui:

Este es mi solución al reto lo más simple que pude:

const { Transform } = require('stream');

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    const data = chunk.toString();
    const camelCase = data.split(' ').map((word, index) => {
      if(index === 0){ 
        return word.toLowerCase()
      }
      
      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
      
    })

    this.push(camelCase.join(''))
    callback()
  }
})

process.stdin
  .pipe(transformStream)
  .pipe(process.stdout)

tha’s my code

const { Transform } = require('stream');

const camelStream = new Transform({
  transform(chunk, encoding, callback) {
    const data = chunk.toString();
    data.split(' ').map((word, item) =>
      this.push(
        (item == 0 ?
          word.charAt(0).toLowerCase() + word.slice(1).toLowerCase() : "") +
        (item !== 0 ?
          word.charAt(0).toUpperCase() + word.slice(1).toLowerCase() : "")));
    callback();
  }
});

process.stdin.pipe(camelStream).pipe(process.stdout);

I did it by this way.

Les comparto mi solución:

const { Transform } = require('stream')

const toCamelCase = string => {
  return string
    .split(' ')
    .map((s, index) => {
      if (index > 0) return s[0].toUpperCase() + s.slice(1).toLowerCase()

      return s.toLowerCase()
    })
    .join('')
}

const transformStream = new Transform({
  transform(chunk, enconding, cb) {
    this.push(toCamelCase(chunk.toString()))
    cb()
  }
})

process.stdin.pipe(transformStream).pipe(process.stdout)

const { Transform } = require('stream');

function toCamelCase(frase){
    let fraseModificada = frase.toString().split(' ');
    const upperWords = fraseModificada.map((palabra) => {
        return palabra.charAt(0).toUpperCase() + palabra.slice(1);
    });
    return upperWords.join("");
}

const tranformStream = new Transform({
    transform(chunk, encoding, callback){
        this.push(toCamelCase(chunk));
        callback()
    }
})

process.stdin.pipe(tranformStream).pipe(process.stdout);

camel case: hola mundo => holaMundo

function camalcase(str) {
  let arr = str.split(" ");
  return arr
    .splice(0, 1)
    .concat(arr.splice(0).map((word) => word[0].toUpperCase() + word.slice(1)))
    .join("");
}

Challenge:

const { Transform } = require('stream');

const transformStream = new Transform ({
    transform(chunck, encoding, callback) {
         this.push(toCamelCase(chunck.toString()));
        callback();
    }
});

process.stdin.pipe(transformStream).pipe(process.stdout);


function toCamelCase (string) {
    let str = string.toLowerCase() //Convierte toda la cadena en minúsculas
        .split(" ") //convierte la cadena en un array por cada palabra
        .map(word => word.replace(word[0], word[0].toString().toUpperCase())) //Convierte la 1ra letra de cada palabra en mayúscula
        .join(''); //converite el array en cadena

        return str.replace(str[0], str[0].toLowerCase()); //convierte la 1ra letra de la cadena en minúscula
};

Dure mil años para corregir un error que al final ni apareció.

Solución del Challenge

No me acordaba de los métodos de String, pero aquí usé: split(), charAt() y slice().

Sabiendo que split() me regresaría un array, le hice un map() para luego hacer toda la magia dentro y luego el resultado del nuevo array unirlo con Join()

Mi solución al reto

const { Writable } = require("stream");

const miWritableStream = new Writable ({
	write(chunk,encoding,callback) {
		console.log(
			toCamelCase(chunk.toString())
		);
		callback()
	},
})
	


process.stdin.pipe(miWritableStream)

// Función auxiliar para convertir frases en camel case
function toCamelCase(frase){
	return frase
		.split(" ")
		.map((palabra) => palabra[0].toUpperCase() + palabra.slice(1))
		.join("")
}

const { Transform } = require("stream");

/**
 * Capitaliza palabras
 * @param {string} cadena texto a modificar
 * @returns texto Capitalizado
 */
const capitalizar = (cadena) => {
    return cadena.charAt(0).toUpperCase() + cadena.toLowerCase().slice(1)
}

/**
 * Función que quita espacios, guiones y letras mayusculas entre medio, dejando toda la cadena en formato lowerCase.
 * @param {string} cadena Texto a modificar
 * @returns texto con formato lowerCase
 */
const camelCase = (cadena) => {
    let string = cadena.toLowerCase()
                .replace(/[^A-Za-z0-9]/g, ' ')
                .split(' ')
                .reduce((res, palabra) => res + capitalizar(palabra.toLowerCase()))
    return string.charAt(0).toLowerCase() + string.slice(1);
}

 const cadenaCamelCase = new Transform({
     transform(chunk, enconding, callback){
         this.push(camelCase(chunk.toString()));
         callback();
     }
 });

 process.stdin.pipe(cadenaCamelCase).pipe(process.stdout);

Solución implementada con REGEX

const { Transform } = require('stream')
const regex = /( \w)/g;

const transformStream = new Transform({
    transform(chuck, encoding, callback) {
        const chuckCamel = chuck.toString().replace(regex, match => match.toUpperCase().charAt(1))

        this.push(chuckCamel);
        callback();
    }
})

process.stdin.pipe(transformStream).pipe(process.stdout);

Complete el reto

const { Transform } = require('stream');

const transformStream = new Transform( {
  transform(chunk, encoding,callback) {
    const data = chunk.toString().trim().split(' ');
    let camelCase = data[0].toLowerCase();
	/* el ciclo for cambia las palabras restante con el formato adecuado */. //
    for (let i = 1; i < data.length; i++) {
      camelCase += data[i].charAt(0).toUpperCase() + data[i].slice(1).toLowerCase();
    }
    console.log(camelCase);
    callback();
  }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Creo que falto mucha mas explicación conceptual antes de ir al codigo … Igual es la primera vez que me enfrento a este concepto asi que a la documentación 📖🏃🏻‍♂️

Hecho con una expresión regular, no me gusta mucho la forma que resolví el primer caracter que al no tener un espacio se lo agregué y luego lo limpié con trim()

const { Transform } = require('stream');

const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        const data = (' '+chunk.toString()).replace(/ \S/g, x =>  ' '+x[1].toUpperCase());
        this.push(data.trim());
        callback();
    }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Duplex y Transforms streams

Ambos sirven para simplificar nuestro código:

• Duplex: implementa los métodos write y read a la vez.

const { Duplex } = require('stream')

const duplexStream = new Duplex({
    write(chunk, encoding, cb) {
        console.log(chunk.toString())
        cb()
    },

    read(size) {
        if (this.currentCharCode > 90) {
            this.push(null)
            return
        }

        this.push(String.fromCharCode(this.currentCharCode++))
    }
})

duplexStream.currentCharCode = 65
process.stdin.pipe(duplexStream).pipe(process.stdout)

• Transform: es similar a Duplex pero con una sintaxis más corta.

const { Transform } = require('stream')

const transformStream = new Transform({
    transform(chunk, encoding, cb) {
        this.push(chunk.toString().toUpperCase())

        cb()
    }
})

process.stdin.pipe(transformStream).pipe(process.stdout)

aquí mi solución al reto

const { Transform } = require("stream");

const transformStream = Transform({
    transform(chunk, encoding, callback){
        let fragment = chunk.toString().split(' ')

        let arr = []
        for(let i = 0; i < fragment.length; i++){
            if(i < 1){
                arr.push(fragment[i].toLowerCase())
            }else{
                arr.push(fragment[i].replace(fragment[i].charAt(0),fragment[i].charAt(0).toUpperCase()))
            }
        }

        this.push(arr.join(''))
        callback()
    }
})

process.stdin.pipe(transformStream).pipe(process.stdout)

En el ejemplo de duplex, no me quedó claro cual era la utilidad de implementar el método write(), porque si no lo implementamos, tenemos el mismo resultado.

donde me percato que toma sentido la implementación write() es cuando ya termina de pinta el abecedario ahi recién entra a tallar este método,

¿si quiero acceder a los valores que esta emitiendo el método read() desde `write(), como podría hacerlo ?

Trate de simplificar el código al máximo, espero que les ayude 😁

const {Transform} = require("stream")
const transformString = new Transform({
    transform(chunk, encoding, cb){
        let a = chunk.toString().replace("\r\n", "")
        let b = a.split(" ").map(word => word.charAt(0).toUpperCase() + word.slice(1))
        this.push(b.join(''))
        cb()
    }
})
process.stdin.pipe(transformString).pipe(process.stdout)

Les dejo mi solucion al challenge!

const { Transform } = require("stream");

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    this.push(
      chunk
        .toString()
        .split(" ")
        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
        .join("")
    );
    callback();
  },
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Mi solucion:

const { Transform } = require('stream')
const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    let text = chunk.toString().toLowerCase()
    text = text.split(' ')
    text = text.map((word) => {
      return word.charAt(0).toUpperCase() + word.slice(1)
    })
    text = text.join('')
    this.push(text)
    callback()
  },
})
process.stdin.pipe(transformStream).pipe(process.stdout)

Aqui va

const { Transform } = require('stream');

const transformStream = new Transform({
    transform(chunk, encoding, cb){
        let message = chunk.toString().split(" ");
        let newMessage = [];
        message.forEach((val, ind, arr) => {
            if(ind > 0){
                newMessage.push(message[ind].replace(message[ind][0], message[ind][0].toUpperCase()));
            } else {
                newMessage.push(message[ind]);
            }
        })

        let total = newMessage.join("");
        this.push(total);
        cb();

    }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Mi solucion

const { Transform } = require("stream");

const transformStream = new Transform({
   transform(chunk, encoding, callbak) {
      // this.push(chunk.toString().toUpperCase());

      //reto
      let dataString = chunk.toString()
      this.push(dataString.slice(0, 1).toUpperCase() + dataString.slice(1));
      callbak();
   }
});

// le pasamos despues de recibir en la linea de comandos a transform que instanciamos despues de la damos salida utilizando de nuevo el pipe pero con la salida
process.stdin.pipe(transformStream).pipe(process.stdout);

Les comparto mi codigo, en este caso utilice un reducer para poder modificar la oracion completa al momento de pasarla a la salida

const { Transform } = require('stream');

const transformStream = new Transform({
   transform(chunk, encoding, callback) {
      this.push(chunk.toString().split(" ").reduce((str,curr) => str+curr.charAt(0).toUpperCase()+curr.slice(1)));
      callback();
   }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Esta es mi solución

const { Transform } = require('stream');

const transformStream = new Transform({
  transform(chunk, encoding, callback){
    const words = chunk.toString().toLowerCase().split(' ');
    const newWords = words.map((word, index) => {
      return index === 0 ? word : word.replace(word[0], word[0].toUpperCase());
    });
    let finalWord = newWords.join('');
    this.push(finalWord);
    callback();
  }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Mi solucion: npm install camelCase (pasa de esnake a camelcase)
y optienes esto

Estas clases son geniales!

Mi solución:

Les dejo esta lectura para comprender más sobre los streams
https://desarrolloweb.com/articulos/streams-nodejs.html

script del tranforms

Resolvi el challenge de esta manera 😃

const { Transform } = require('stream');

const transformStream = new Transform({
    transform(chunk, encoding, callback){
        wordsArray = chunk.toString().split(' ');
        camelCaseString = "";
        for(let i=0; i<wordsArray.length; i++){
            //String.charAt(n): devuelve el caracter en la posicion n
            //String.slice(n): devuelve la cadena desde la posicion n
            //String.toUpperCase: devuelve la cadena en mayusculas
            //String.toLowerCase: devuelve la cadena en minisculas
            camelCaseString += wordsArray[i].charAt(0).toUpperCase() + wordsArray[i].slice(1).toLowerCase()
        }
        this.push(camelCaseString);
        callback();
    }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

const {
    Transform
} = require('stream');

const camelcaseTransform = new Transform({
    transform(chunk, encoding, callback) {
        const string = chunk.toString().trim().split(' ');
        string.forEach(element => {
            this.push(element.charAt(0).toUpperCase() + element.slice(1));
        });
        callback();
    }
});

process.stdin.pipe(camelcaseTransform).pipe(process.stdout);

Mi solucion al reto!

const { Transform } = require('stream');

const transformStream = new Transform({
    transform(chunck, encoding, callback) {
        this.push(textToCamelCase(chunck.toString()));
        callback();
    }
})

function textToCamelCase(string) {
    let stringArray = string.split(' ');
    let finalString = '';

    stringArray.forEach(element => {
        let currentString = element.charAt(0).toUpperCase() + element.toLowerCase().slice(1);
        finalString += currentString;
    })

    return finalString;
}

process.stdin.pipe(transformStream).pipe(process.stdout);```

creo que la ultima linea deberia ser asi:

duplexStream.pipe(duplexStream);

para que se ejecute el metodo write del mismo duplex 😃

Recuerden usar el metodo toLowerCase(), de javascript para convertir el resto de la palabra en minuscula, ya que si colocas toda la palabra en letras mayusculas, retornara todas las letras de la palabra en cuestion en mayusculas.

Esto lo acoto por el hecho de que he visto en los retos colocados por los compañeros, que algunos no lo aplicaron, es una recomendacion 😄!! Excelente curso hasta ahora!

Implementación parto el string por espacio, - y _ para soportar palabras como hello-world hello world y hello_world

const { Transform } = require("stream");
const tx = new Transform({
    transform(chunk, enconding, cb) {
        var str = chunk.toString();
        var strUpper = str.trim().split(/[\s-_]+/).map(itm => itm.charAt(0).toUpperCase() + itm.substring(1)).join("");
        this.push(strUpper);
    }
});

process.stdin.pipe(tx).pipe(process.stdout)

Es de mucha ayuda repasar la clase de Streams del curso de terminal y linea de comandos del profesor Beco

Repositorio de la clase:
https://github.com/glrodasz/platzi-backend-node/tree/duplex-y-transforms-streams

Aqui mi solucion, un poco larga pero funciona

const {Transform} = require('stream')

const transform = new Transform({
    transform(chunck, encoding, callback){
        // this.push(chunck.toString())
        var texto = chunck.toString()
        this.push("texto original:\n" + texto)

        //realmente no se por que, pero no importa el texto que escriba
        //siempre le suma dos espacios en blanco y pos...
        var textoLength = texto.length - 2;
        this.push("tamaño:\n" + textoLength + "\n")

        var newText = "";
        var letterToUpperCase = false;
        for(let i = 0; i <= textoLength; i++){
            // this.push(texto.charAt(i) + "\n")
            if(texto.charAt(i) != " "){
                if(letterToUpperCase){
                    newText += texto.charAt(i).toUpperCase();
                    letterToUpperCase = false;
                }else{
                    newText += texto.charAt(i)
                }
            }else{
                //en caso de que la letra leida sea un espacio, la variable
                //letterToUpperCase pasara a ser verdadera para que la
                //siguiente letra sea mayuscula
                letterToUpperCase = true;
            }
        }

        this.push(newText)
        callback()
    }
})

process.stdin.pipe(transform).pipe(process.stdout)
// process.stdin.pipe()```

const { Transform } = require('stream');

const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        this.push(chunk.toString().replace(/(?:^\w|[A-Z]|\b\w)/g, function (word, index) {
            return index == 0 ? word.toLowerCase() : word.toUpperCase();
        }).replace(/\s+/g, ''));
    }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Les dejo mis notas que me apoyaron en el aprendizaje del curso 😄
https://github.com/JasanHdz/backendnodejs/tree/master/notes
No se rindan, éxito 💪
Mis mejores notas ⭐⭐⭐⭐⭐

Mi solución usando reduce

const { Transform } = require('stream')

/*
* Recibe una cadena de texto y la traduce a
* camelCase usando streams
* @param {array} - Array of words
* @return {string} - textoEnCamelCase
*/
function toCamelCase (arrayOfWords) {
  return arrayOfWords.reduce((accum, word) => {
    const firstLetter = word.charAt(0).toUpperCase()
    accum.push(firstLetter + word.slice(1))
    return accum
  }, []).join('')
}

const transformStream = new Transform({
  transform (chunk, encoding, callback) {
    this.push(toCamelCase(chunk.toString().split(' ')))
    callback()
  }
})

process.stdin.pipe(transformStream).pipe(process.stdout)

Mi reto

const { Transform } = require("stream");

const camelCase = new Transform({
  transform(chunk, encoding, callback) {
    this.push(
      chunk
        .toString()
        .split(" ")
        .map(word => {
          return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
        })
        .join("")
    );
    callback();
  }
});

process.stdin.pipe(camelCase).pipe(process.stdout);

Mi Solucion

const { Transform } = require('stream');

const camelize = word => {
    const camelized = (word.charAt(0).toUpperCase() + word.slice(1));
    return camelized;
}

const normalize = text => {
    const words = text.split(' ');
    return words.map(word => camelize(word)).join('');
}

const transformStream = new Transform({
    transform(chunk, encoding, cb) {
        this.push(normalize(chunk.toString()));
        cb();
    }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Mi solución

const { Transform } = require("stream");

const camelCase = new Transform({
  transform(chunk, encoding, callback) {
    let text = chunk.toString();
    let elements = text.split(" ");
    let capitalize = elements.map(
      element =>
        element.charAt(0).toUpperCase() + element.slice(1).toLowerCase()
    );
    this.push(capitalize.join(""));
    callback();
  }
});

process.stdin.pipe(camelCase).pipe(process.stdout);

No tan elegante como por palabras pero divertida igual jajaja

const {Transform}=require('stream');

const transformStream=new Transform({
    transform(chunk,encoding,callback){
        let flag=true;
        let camelCase=[].map.call(chunk.toString(),(char)=>{
            if(flag){
                flag=false;
                return(char.toUpperCase());
            }else{
                if(char==' '){
                    flag=true;
                    return
                }else{
                    return(char.toLowerCase());
                }
            }     
        }).join('');
        this.push(camelCase);
        callback();
    }
})

process.stdin.pipe(transformStream).pipe(process.stdout);```

Respuesta al reto

const { Writable } = require('stream')

const writableStream = new Writable({
    write(chunk, encoding, callback) {
        let text = chunk.toString()
        text= text.split(' ')

        text = text.map(item => {
            let result
            result = item.substr(1, item.length+1).toLowerCase()
            result = item.charAt(0).toUpperCase() + result
            return result
        })

        console.log(text.join(''))
        callback()
    }
})

process.stdin.pipe(writableStream)

Un reto muy divertido, Coool!!

const { Transform } = require('stream');

const transformStream = new Transform({
  transform(chunk, uncoding, callback) {
    let array = chunk.toString().split(' ');
    let camelCase = '';

    for (let index = 0; index < array.length; index++) {
      let element = array[index];
      let firstLetter = element.charAt(0);
      let complement = element.substring(1);
      if (index === 0) {
        firstLetter = firstLetter.toLowerCase();
        
      } else {
        firstLetter = firstLetter.toUpperCase();
      }

      element.replace()

      camelCase += firstLetter + complement;
    }

    this.push(camelCase);
    callback();
  }
})

process.stdin.pipe(transformStream).pipe(process.stdout);

Hola, esta es mi solución al reto:

const { Transform } = require('stream');

const transformStream = new Transform({
  transform(chunk, encoding, callback){
    const input = chunk.toString();
    let first = input.substring(0,1);
    let body = input.substring(1);
    body = body.toLowerCase();
    let sizeBody = body.length
    let bodyCleanSpace = ""
    for(let i=0; i < sizeBody; i++){
      const character = body.substring(i,i+1)
      if(character != ' '){
        bodyCleanSpace += character;
      }else{
        bodyCleanSpace += body.substring(i+1, i+2).toUpperCase()
        i++
      }
    }
    const codeFirst = first.charCodeAt(0);
    if( !(codeFirst > 65 && codeFirst < 90)){
      first = first.toUpperCase();
    }
    this.push(`${first}${bodyCleanSpace}`)
    callback()
  }
})

process.stdin.pipe(transformStream).pipe(process.stdout)```