Busca el código de un programa de fuerza bruta o generador de diccionarios. Es más difícil de hacer de lo que parece xD.

No es tan complicado...

En primer lugar puesto que se quiere devolver en un array hay que precalcular el tamaño que él mismo tendrá.

Dado que cada carácter tiene 2 variaciones (mayúscula minúscula), que no hay permutaciones de lugar y el tamaño del string...
cantidad = 2^size(delString)
Siendo la cadena: 'string' size=6; 2^6=64. Luego el array tendrá 64 ítems.

La segunda parte, se resuelve en un bucle recursivo... usando grafos. Básicamente es un árbol binario. Nota que no es preciso usar ni construir ninguna estructura especial, más allá del array. Aunque tirando por un árbol binario, te sería más sencillo.

La palabra tendrá un nodo raíz (pongamos '*'), que accede a la primera letra, es decir 's' y 'S' son sus dos nodos hijo.
A su vez cada una de ellas tiene como nodos hijos a la siguiente letra en las dos versiones (mayúscula y minúscula).
Te pongo la jerarquía, de nodos, el de la izquierda es un nodo ya añadido al árbol, los de la derecha son los hijos que se le añaden como hijos:

Nota que los dos últimos nodos no tienen hijos...

Ahora si se recorre todas las posibilidades del árbol obtendrás las 64 combinaciones distintas (desprecia el nodo raíz para formar la combinación a la hora de pasarlo al array de destino).
El problema de usar una estructura de árbol, es que empleará más espacio del strictamente necesario, ya que por ejemplo, al llegar al último nodo, n y N, cada uno de ellos tendrán por nodos finales 'g' y 'G', es decir se habrá añadido 32 nodos 'g' y 32 nodos 'G'.
Estrictamente basta un array de una estructura simple con cada uno de esos nodos:

Luego se puede pasar como una cadena de texto, o un array de texto, el contenido de más arriba '*= s|S, s= t|T, S= t|T ..." , el caso es una función recibe y parsea dicho contenido al array Nodos() que se compone de la estructura nodo.
Rellenando dicho array quedaría así:

Ahora con dciho array una función recorre recursivamente, tomando en cada ciclo el 'nombre' del nodo visitado, que se usa para ir concatenando la variación adecuada. La recursión finaliza cuando el nodo es terminal...
Como cada nodo tiene 2 hijos (podrían tener 1 o más), se precisa tambén un bucle interno para dicho recorrido de hijos.

La función de recorrido se invoca desde la que parsea la entrada,  sería más o menos así:

Esta función (así de simple), recorre todas las combinaciones posibles.

La función que parsea el texto de entrada, lo dejo a tu esfuezo, pués se trata de 'desguazar' dicha cadena en sus nodos, y cada nodos en sus elementos, para generar el array de nodos. Se requieren dos bucles, en el primero se crea el array con los 13 nodos (0 a 12, el 0 es el raíz), aplicando nombre, indice (el mismo del contador del bucle), número de hijos y si es o no terminal. Es terminal si no tiene hijos (caso de 'g' y 'G'). En el segundo bucle, se rellenan los datos que no se conocían , esto es, los hijos, requiere una búsqueda. Por ejemplo: Sabiendo que 't' tiene como hijos a 'r' y a 'R', precisa buscar que posicón ocupan esos nodos 'r' y 'R', para terminar de rellenar los datos (es decir busca rel índice de ?????:

La funcion principal, invoca a dos, una para generar los nodos y luego para realizar el recorrido.


La función que construye el array de la estructura 'nodo'...
Nota que aquí tomamos la palabra entrada, sin generar las producciones comentadas al principio (dada la simplicidad de dichas producciones, es todo muy deducible).

Una captura:
(nota que yo he dejado el 'nombre' de la raíz  '*', con cada uno)




La salida completa sería:
La opción de resolverlo con un árbol, es también adecuada, como te describí más arriba... pero elige el modelo que mejor veas factible de entender e implementar...

Hay 1 modo más sencillo basado en un método que hice hace tiempo.
-   Crear una matriz m * n, donde m = nro de combinaciones y n = nro de letras.
-   Separar la palabra en 2 filas (sea matriz bidimensional o 2 unidimensionales) separando cada letra en una columna de cada fila, la 1era con sus letras en mayúscula y la 2da con sus letras en minúscula.
-   Llenar la matriz m*n con la fila de letras minúsculas.
-   Reemplazar de derecha a izquierda las columnas de la matriz m*n con la fila de las letras mayúsculas intercalando cada columna empezando con el valor de 1 e incrementando este valor para las siguientes columnas con el doble del valor anterior (dejo unas imágenes en Excel para ilustrar).



-   Dejo un código de prueba en c++ para demostrar lo que menciono que se puede hacer en javascript similar.

#include <iostream>
 
int main()
{
	char mat01[6][6] = { {'S','T','R','I','N','G'}, {'s','t','r','i','n','g'} };
	char mat02[64][6];
 
	int filMax = 64;
	int colMax = 6;
 
	for (int fil = 0; fil < filMax; fil++)
	{
		for (int col = 0; col < colMax; col++)
		{
			mat02[fil][col] = mat01[1][col];
		}
	}
	int iRep = 1;
	for (int col = colMax - 1; col >= 0; col--)
	{
		int iFlag = 0;
		int iCont = 0;
		for (int fil = 0; fil < filMax; fil++)
		{
			if (iCont == 0)iFlag = 0;
			if (iCont == iRep)iFlag = 1;
 
			if (iFlag == 1)mat02[fil][col] = mat01[0][col];
 
			if (iCont < iRep && iFlag == 0)
			{
				iCont++;
			}
 
			if (iCont > 0 && iFlag == 1)
			{
				iCont--;
			}
		}
		iRep = iRep * 2;
	}
	for (int fil = 0; fil < filMax; fil++)
	{
		std::cout << "Combinacion: " << fil + 1 << " ";
		for (int col = 0; col < colMax; col++)
		{
			std::cout << mat02[fil][col];
		}
		std::cout << std::endl;
	}
}