nexus-shared 1.1.19 → 1.1.21

package/src/sso-config/provider-complete-route.tsx

@@ -1,6 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
-import { SetSsoSessionCookie } from "./cookie-helpers";
-import { SSO_CONFIG } from "./sso-config";
+import { AUTH_COOKIES, ResolvePostLoginRedirectUrl, SetSsoSessionCookie } from "./cookie-helpers";
+import { DecodeRedirectContext } from "./redirect-context-helpers";
+import { GetClientConfiguration } from "./sso-backend-flow";
 
 /** GET — complete provider OAuth by persisting the backend SSO session cookie. */
 export async function ProviderCompleteRoute(req: NextRequest) {
@@ -8,8 +9,10 @@ export async function ProviderCompleteRoute(req: NextRequest) {
   const ssoSession = req.nextUrl.searchParams.get("ssoSession");
 
   if (!ssoSession) return NextResponse.redirect(signInUrl);
+  const ssoConfiguration = await GetClientConfiguration();
 
-  const response = NextResponse.redirect(new URL(SSO_CONFIG.FRONTEND_ENDPOINTS.SSO_COMPLETE, req.url));
-  SetSsoSessionCookie(response, ssoSession, SSO_CONFIG.BACKEND_CONFIG.SSO_SESSION_MAX_AGE);
+  const redirectContext = DecodeRedirectContext(req.cookies.get(AUTH_COOKIES.redirectContext)?.value);
+  const response = NextResponse.redirect(new URL(ResolvePostLoginRedirectUrl(!!redirectContext?.redirectUri), req.url));
+  SetSsoSessionCookie(response, ssoSession, ssoConfiguration.ssoSessionLifetime);
   return response;
 }

package/src/sso-config/redirect-context-actions.tsx

@@ -3,7 +3,7 @@
 import { cookies } from "next/headers";
 import { AUTH_COOKIES } from "./cookie-helpers";
 import { CreatePkcePair } from "./pkce-helpers";
-import { CreateOAuthNonce, DecodeRedirectContext, EncodeRedirectContext, GetRedirectContextCookieOptions, IsAllowedRedirectUri, SanitizeReturnPath } from "./redirect-context-helpers";
+import { ClearRedirectContextStore, CreateOAuthNonce, DecodeRedirectContext, EncodeRedirectContext, GetRedirectContextCookieOptions, IsAllowedRedirectUri, SanitizeReturnPath } from "./redirect-context-helpers";
 import { IRedirectContext } from "./sso-interfaces";
 
 function ReadRedirectContextFromStore(cookieStore: Awaited<ReturnType<typeof cookies>>): IRedirectContext | null {
@@ -41,6 +41,5 @@ export async function PersistRedirectContext(redirectUri?: string | null, state?
 
 /** Server Action — clears the redirect context cookie after SSO completes. */
 export async function ClearRedirectContext() {
-  const cookieStore = await cookies();
-  cookieStore.delete(AUTH_COOKIES.redirectContext);
+  await ClearRedirectContextStore();
 }

package/src/sso-config/redirect-context-helpers.tsx

@@ -1,12 +1,14 @@
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
 import { cookies } from "next/headers";
 import { NextResponse } from "next/server";
-import { URLS } from "../nexus.environments";
+import { NEXUS_INFO, URLS } from "../nexus.environments";
 import { AUTH_COOKIES } from "./cookie-helpers";
-import { CreatePkcePair, PKCE_METHOD_S256 } from "./pkce-helpers";
+import { CreatePkcePair } from "./pkce-helpers";
 import { SSO_CONFIG } from "./sso-config";
-import { IRedirectContext } from "./sso-interfaces";
+import { IRedirectContext, PKCE_METHOD_S256 } from "./sso-interfaces";
 
+// @ts-ignore
+const processEnv = process.env;
 const CALLBACK_SUFFIX = "/api/auth/callback";
 
 type EncodedRedirectContext = {
@@ -126,7 +128,7 @@ export function GetAuthCookieOptions(maxAge: number | string) {
     path: "/",
     sameSite: "lax" as const,
     maxAge: Number(maxAge),
-    secure: process.env.NODE_ENV === "production",
+    secure: NEXUS_INFO.IS_PRODUCTION,
   };
 }
 
@@ -139,6 +141,19 @@ export function SetRedirectContextCookie(response: NextResponse, context: IRedir
   response.cookies.set(AUTH_COOKIES.redirectContext, EncodeRedirectContext(context), GetRedirectContextCookieOptions());
 }
 
+const redirectContextClearOptions = () => ({
+  ...GetRedirectContextCookieOptions(),
+  maxAge: 0,
+  expires: new Date(0),
+});
+
+/** Route Handler / middleware — clears redirect context on the outgoing response. */
 export function ClearRedirectContextCookie(response: NextResponse) {
-  response.cookies.set(AUTH_COOKIES.redirectContext, "", { ...GetRedirectContextCookieOptions(), maxAge: 0 });
+  response.cookies.set(AUTH_COOKIES.redirectContext, "", redirectContextClearOptions());
+}
+
+/** Server Components / Server Actions — clears redirect context in the current request store. */
+export async function ClearRedirectContextStore() {
+  const cookieStore = await cookies();
+  cookieStore.set(AUTH_COOKIES.redirectContext, "", redirectContextClearOptions());
 }

package/src/sso-config/refresh-route.tsx

@@ -1,4 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
+import { GetResponse } from "nexus-shared/interface";
 import { HttpPost } from "../services/http-services";
 import { AUTH_COOKIES, GetDecryptedRequestCookie, SetAuthCookies } from "./cookie-helpers";
 import { SSO_CONFIG } from "./sso-config";
@@ -6,17 +7,17 @@ import { SSOAuthResponse } from "./sso-interfaces";
 
 export async function RefreshRoute(req: NextRequest) {
   const refreshToken = GetDecryptedRequestCookie(req, AUTH_COOKIES.refreshToken);
-  if (!refreshToken) return NextResponse.json({ error: "No refresh token" }, { status: 401 });
+  if (!refreshToken) return NextResponse.json(GetResponse.ERROR("No refresh token", "NJS_X1003"), { status: 401 });
 
   try {
     const refreshRes = await HttpPost(SSO_CONFIG.BACKEND_ENDPOINTS.REFRESH, { refreshToken, clientSystemName: SSO_CONFIG.BACKEND_CONFIG.CLIENT_SYSTEM_NAME });
-    if (!refreshRes.isSuccess) return NextResponse.json({ error: "Refresh failed" }, { status: 401 });
+    if (!refreshRes.isSuccess) return NextResponse.json(GetResponse.ERROR("Refresh failed", "NJS_X1001"), { status: 401 });
 
     const newTokens = refreshRes.result as SSOAuthResponse;
-    const response = NextResponse.json({ ok: true });
+    const response = NextResponse.json(GetResponse.SUCCESS(null, "Refresh successful"));
     SetAuthCookies(response, newTokens);
     return response;
   } catch {
-    return NextResponse.json({ error: "Auth service unavailable" }, { status: 500 });
+    return NextResponse.json(GetResponse.ERROR("Auth service unavailable", "NJS_X1002"), { status: 500 });
   }
 }

package/src/sso-config/sign-in-route.tsx

@@ -3,10 +3,11 @@ import { EErrorCodes, EExceptionCategories } from "../interfaces/exception-inter
 import { GetResponse } from "../interfaces/http-interfaces";
 import { URLS } from "../nexus.environments";
 import { HttpPost } from "../services/http-services";
-import { AUTH_COOKIES, GetDecryptedRequestCookie, SetAuthCookies, SetSsoSessionCookie } from "./cookie-helpers";
+import { AUTH_COOKIES, GetDecryptedRequestCookie, ResolvePostLoginRedirectUrl, SetAuthCookies, SetSsoSessionCookie } from "./cookie-helpers";
+import { DecodeRedirectContext } from "./redirect-context-helpers";
 import { CreatePkcePair } from "./pkce-helpers";
 import { ClearRedirectContextCookie } from "./redirect-context-helpers";
-import { ExchangeAuthorizationCode, RequestAuthorizationCode } from "./sso-backend-flow";
+import { ExchangeAuthorizationCode, GetClientConfiguration, RequestAuthorizationCode } from "./sso-backend-flow";
 import { BuildAuthenticationSignInUrl, SSO_CONFIG } from "./sso-config";
 import { ILoginRequest, ILoginResponse } from "./sso-interfaces";
 
@@ -58,12 +59,16 @@ export async function SignInPostRoute(req: NextRequest) {
 
   const signInResult = signInRes?.result as ILoginResponse;
 
-  if (signInResult?.ssoSession) signInResult.redirectUrl = SSO_CONFIG.FRONTEND_ENDPOINTS.SSO_COMPLETE;
+  if (signInResult?.ssoSession) {
+    const redirectContext = DecodeRedirectContext(req.cookies.get(AUTH_COOKIES.redirectContext)?.value);
+    signInResult.redirectUrl = ResolvePostLoginRedirectUrl(!!redirectContext?.redirectUri);
+  }
 
   if (!signInRes.isSuccess || !signInResult?.ssoSession) return NextResponse.json(signInRes, { status: signInRes.code ?? 401 });
 
+  const ssoConfiguration = await GetClientConfiguration();
   const response = NextResponse.json(signInRes);
 
-  SetSsoSessionCookie(response, signInResult.ssoSession, SSO_CONFIG.BACKEND_CONFIG.SSO_SESSION_MAX_AGE);
+  SetSsoSessionCookie(response, signInResult.ssoSession, ssoConfiguration.ssoSessionLifetime);
   return response;
 }

package/src/sso-config/sign-out-route.tsx

@@ -1,7 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { NEXUS_INFO, URLS } from "../nexus.environments";
 import { HttpPost } from "../services/http-services";
-import { AUTH_COOKIES, ClearAllAuthCookies, GetDecryptedRequestCookie } from "./cookie-helpers";
+import { AUTH_COOKIES, ClearAuthCookies, GetDecryptedRequestCookie } from "./cookie-helpers";
 import { SanitizeReturnPath } from "./redirect-context-helpers";
 import { SSO_CONFIG } from "./sso-config";
 
@@ -20,6 +20,10 @@ function resolveReturnUrl(req: NextRequest): URL {
     return new URL(SanitizeReturnPath(returnPath), appBase);
   }
 
+  if (NEXUS_INFO.IS_ADMIN_MODULE) {
+    return new URL(URLS.SIGN_IN);
+  }
+
   return new URL(appBase);
 }
 
@@ -36,7 +40,7 @@ async function revokeServerSession(req: NextRequest) {
 export async function SignOutGetRoute(req: NextRequest) {
   await revokeServerSession(req);
   const response = NextResponse.redirect(resolveReturnUrl(req));
-  ClearAllAuthCookies(response);
+  ClearAuthCookies(response);
   return response;
 }
 
@@ -48,6 +52,6 @@ export async function SignOutPostRoute(req: NextRequest) {
 
   await revokeServerSession(req);
   const response = NextResponse.json({ ok: true });
-  ClearAllAuthCookies(response);
+  ClearAuthCookies(response);
   return response;
 }

package/src/sso-config/sign-up-route.tsx

@@ -1,6 +1,8 @@
 import { NextRequest, NextResponse } from "next/server";
 import { HttpPost } from "../services/http-services";
-import { SetSsoSessionCookie } from "./cookie-helpers";
+import { AUTH_COOKIES, ResolvePostLoginRedirectUrl, SetSsoSessionCookie } from "./cookie-helpers";
+import { DecodeRedirectContext } from "./redirect-context-helpers";
+import { GetClientConfiguration } from "./sso-backend-flow";
 import { SSO_CONFIG } from "./sso-config";
 import { ISignUpRequest } from "./sso-interfaces";
 import { ParseWrappedResult } from "./sso-response-helpers";
@@ -40,7 +42,16 @@ export async function SignUpPostRoute(req: NextRequest) {
     return NextResponse.json(signUpRes, { status: signUpRes.code ?? 400 });
   }
 
-  const response = NextResponse.json(signUpRes);
-  SetSsoSessionCookie(response, signUpResult.ssoSession, SSO_CONFIG.BACKEND_CONFIG.SSO_SESSION_MAX_AGE);
+  const ssoConfiguration = await GetClientConfiguration();
+  const redirectContext = DecodeRedirectContext(req.cookies.get(AUTH_COOKIES.redirectContext)?.value);
+
+  const response = NextResponse.json({
+    ...signUpRes,
+    result: {
+      ...signUpResult,
+      redirectUrl: ResolvePostLoginRedirectUrl(!!redirectContext?.redirectUri),
+    },
+  });
+  SetSsoSessionCookie(response, signUpResult.ssoSession, ssoConfiguration.ssoSessionLifetime);
   return response;
 }

package/src/sso-config/sso-backend-flow.ts

@@ -1,23 +1,9 @@
-import { HttpPost } from "../services/http-services";
-import { PKCE_METHOD_S256, PkcePair } from "./pkce-helpers";
+import { NEXUS_CONFIG } from "../nexus.environments";
+import { HttpGet, HttpPost } from "../services/http-services";
 import { SSO_CONFIG } from "./sso-config";
-import { SSOAuthResponse } from "./sso-interfaces";
+import { IClientApplication, PKCE_METHOD_S256, SSOAuthResponse, SsoExchangeInput, TokenExchangeInput } from "./sso-interfaces";
 import { ParseSsoCodeResponse, ParseTokenResponse } from "./sso-response-helpers";
 
-export type SsoExchangeInput = {
-  ssoSession: string;
-  redirectUri: string;
-  state?: string;
-  returnPath?: string;
-  pkce: PkcePair;
-};
-
-export type TokenExchangeInput = {
-  code: string;
-  redirectUri: string;
-  codeVerifier: string;
-};
-
 /** Server-only: request an authorization code using client policy + PKCE. */
 export async function RequestAuthorizationCode(input: SsoExchangeInput): Promise<string | null> {
   const ssoRes = await HttpPost(SSO_CONFIG.BACKEND_ENDPOINTS.SSO, {
@@ -43,3 +29,10 @@ export async function ExchangeAuthorizationCode(input: TokenExchangeInput): Prom
 
   return ParseTokenResponse(tokenRes);
 }
+
+/** Server-only: get client configuration from the backend. */
+export async function GetClientConfiguration(): Promise<IClientApplication> {
+  const clientConfigRes = await HttpGet(SSO_CONFIG.BACKEND_ENDPOINTS.CLIENT_CONFIG, null, NEXUS_CONFIG.DEFAULT_REVALIDATE_TIME_ONE_DAY);
+  if (!clientConfigRes.isSuccess) throw new Error("Failed to get client configuration");
+  return clientConfigRes.result;
+}

package/src/sso-config/sso-complete-route.tsx

@@ -1,10 +1,10 @@
 import { NextRequest, NextResponse } from "next/server";
 import { AUTH_COOKIES, GetDecryptedRequestCookie } from "./cookie-helpers";
 import { EncodeOAuthCallbackState } from "./oauth-callback-state";
-import { BuildAuthenticationSignInUrl } from "./sso-config";
 import { ClearRedirectContextCookie, DecodeRedirectContext } from "./redirect-context-helpers";
-import { PKCE_METHOD_S256, PkcePair } from "./pkce-helpers";
 import { RequestAuthorizationCode } from "./sso-backend-flow";
+import { BuildAuthenticationSignInUrl, SSO_CONFIG } from "./sso-config";
+import { PKCE_METHOD_S256, PkcePair } from "./sso-interfaces";
 
 function buildSignInRedirect(redirectContext: ReturnType<typeof DecodeRedirectContext>) {
   return new URL(BuildAuthenticationSignInUrl(redirectContext?.returnPath));
@@ -15,10 +15,14 @@ export async function SsoCompleteRoute(req: NextRequest) {
   const ssoSession = GetDecryptedRequestCookie(req, AUTH_COOKIES.ssoSession);
   const redirectContext = DecodeRedirectContext(req.cookies.get(AUTH_COOKIES.redirectContext)?.value);
 
-  if (!ssoSession || !redirectContext?.redirectUri) {
+  if (!ssoSession) {
     return NextResponse.redirect(buildSignInRedirect(redirectContext));
   }
 
+  if (!redirectContext?.redirectUri) {
+    return NextResponse.redirect(new URL(SSO_CONFIG.FRONTEND_ENDPOINTS.SIGN_IN, req.url));
+  }
+
   const pkce: PkcePair = {
     verifier: redirectContext.pkceVerifier,
     challenge: redirectContext.codeChallenge,

package/src/sso-config/sso-config.ts

@@ -2,9 +2,12 @@ import { APIS, URLS } from "nexus-shared";
 
 const _callbackPath = `${URLS.CURRENT}/api/auth/callback`;
 
+// @ts-ignore
+const processEnv = process.env;
+
 export const SSO_CONFIG = {
   COOKIE_CONFIG: {
-    COOKIE_SECRET: process.env.SSO_COOKIE_SECRET as string,
+    COOKIE_SECRET: processEnv.SSO_COOKIE_SECRET as string,
   },
   BACKEND_ENDPOINTS: {
     SIGN_IN: `${APIS.AUTHENTICATION}/Authentication/SignIn`,
@@ -14,6 +17,7 @@ export const SSO_CONFIG = {
     REFRESH: `${APIS.AUTHENTICATION}/Authentication/Refresh`,
     SIGN_OUT: `${APIS.AUTHENTICATION}/Authentication/SignOut`,
     PROVIDERS: `${APIS.AUTHENTICATION}/Authentication/Providers`,
+    CLIENT_CONFIG: `${APIS.AUTHENTICATION}/Authentication/ClientConfig/${processEnv.AUTH_CLIENT_SYSTEM_NAME}`,
     FORGOT_PASSWORD: `${APIS.AUTHENTICATION}/Authentication/ForgotPassword`,
     RESET_PASSWORD: `${APIS.AUTHENTICATION}/Authentication/ResetPassword`,
     /** Used by VerifyAccessToken — returns 200 for a valid Bearer token, 401 otherwise. */
@@ -22,11 +26,9 @@ export const SSO_CONFIG = {
   },
   BACKEND_CONFIG: {
     /** Matches AuthenticationOptions.DefaultClientSystemName (NEXUS_WEB_APPLICATION_API). */
-    CLIENT_SYSTEM_NAME: process.env.AUTH_CLIENT_SYSTEM_NAME as string,
-    /** Matches ClientApplications.SsoSessionLifetime (30 minutes). */
-    SSO_SESSION_MAX_AGE: process.env.SSO_SESSION_MAX_AGE as string,
+    CLIENT_SYSTEM_NAME: processEnv.AUTH_CLIENT_SYSTEM_NAME as string,
     /** How long redirect_uri/state survive in a secure httpOnly cookie on the auth app (seconds). */
-    REDIRECT_CONTEXT_MAX_AGE: process.env.REDIRECT_CONTEXT_MAX_AGE as string,
+    REDIRECT_CONTEXT_MAX_AGE: processEnv.REDIRECT_CONTEXT_MAX_AGE as string,
   },
   FRONTEND_ENDPOINTS: {
     CALLBACK: _callbackPath,

package/src/sso-config/sso-interfaces.tsx

@@ -1,4 +1,7 @@
 import { UN } from "../interfaces/type-interfaces";
+
+export const PKCE_METHOD_S256 = "S256";
+
 export interface SSOAuthResponse {
   accessToken: string;
   refreshToken: string;
@@ -8,9 +11,9 @@ export interface SSOAuthResponse {
 }
 
 export interface CookieInfo {
-  ssoSession: string;
-  accessToken: string | UN;
-  refreshToken: string | UN;
+  ssoSession?: string;
+  accessToken?: string | UN;
+  refreshToken?: string;
 }
 
 export interface IRedirectContext {
@@ -66,3 +69,31 @@ export interface IDemoUserInfo {
   role: string;
   passwordHint: string;
 }
+
+export type SsoExchangeInput = {
+  ssoSession: string;
+  redirectUri: string;
+  state?: string;
+  returnPath?: string;
+  pkce: PkcePair;
+};
+
+export type TokenExchangeInput = {
+  code: string;
+  redirectUri: string;
+  codeVerifier: string;
+};
+export type PkcePair = {
+  verifier: string;
+  challenge: string;
+  method: typeof PKCE_METHOD_S256;
+};
+
+export interface IClientApplication {
+  requirePkce: boolean;
+  accessTokenLifetime: number;
+  refreshTokenLifetime: number;
+  authorizationCodeLifetime: number;
+  ssoSessionLifetime: number;
+  allowOfflineAccess: boolean;
+}

package/src/styles/nexus.grid-view.css

@@ -0,0 +1,42 @@
+:root {
+  --Border-Size: 0.03rem;
+}
+
+#inch-grid,
+#cm-grid,
+#mm-grid,
+#half-mm-grid,
+#quarter-mm-grid {
+  position: fixed;
+  top: 0;
+  left: 0;
+  z-index: 1000000;
+  width: 100%;
+  height: 100vh;
+  pointer-events: none;
+}
+
+#inch-grid {
+  background-image: repeating-linear-gradient(0deg, rgb(200, 200, 200), rgb(200, 200, 200) var(--Border-Size), transparent var(--Border-Size), transparent 1in), repeating-linear-gradient(90deg, rgb(200, 200, 200), rgb(200, 200, 200) var(--Border-Size), transparent var(--Border-Size), transparent 1in);
+  background-size: 100% 1in, 1in 1in;
+  display: none;
+}
+
+#cm-grid {
+  background-image: repeating-linear-gradient(0deg, rgb(70, 70, 70), rgb(70, 70, 700) var(--Border-Size), transparent var(--Border-Size), transparent 1cm), repeating-linear-gradient(90deg, rgb(70, 70, 700), rgb(700, 700, 700) var(--Border-Size), transparent var(--Border-Size), transparent 1cm);
+  background-size: 100% 1cm, 1cm 1cm;
+}
+
+#mm-grid {
+  background-image: repeating-linear-gradient(0deg, rgb(200, 200, 200), rgb(200, 200, 200) var(--Border-Size), transparent var(--Border-Size), transparent 1cm), repeating-linear-gradient(90deg, rgb(200, 200, 200), rgb(200, 200, 200) var(--Border-Size), transparent var(--Border-Size), transparent 5mm);
+  background-size: 100% 5mm, 5mm 5mm;
+}
+#half-mm-grid {
+  background-image: repeating-linear-gradient(0deg, rgb(200, 200, 200), rgb(200, 200, 200) var(--Border-Size), transparent var(--Border-Size), transparent 1cm), repeating-linear-gradient(90deg, rgb(200, 200, 200), rgb(200, 200, 200) var(--Border-Size), transparent var(--Border-Size), transparent 2.5mm);
+  background-size: 100% 2.5mm, 2.5mm 2.5mm;
+}
+
+#quarter-mm-grid {
+  background-image: repeating-linear-gradient(0deg, rgb(200, 200, 200), rgb(200, 200, 200) var(--Border-Size), transparent var(--Border-Size), transparent 1cm), repeating-linear-gradient(90deg, rgb(200, 200, 200), rgb(200, 200, 200) var(--Border-Size), transparent var(--Border-Size), transparent 1.25mm);
+  background-size: 100% 1.25mm, 1.25mm 1.25mm;
+}

package/src/styles/nexus.icon.css

@@ -22,6 +22,7 @@
   transition: var(--ANIM);
   font-size: var(--IS);
   pointer-events: none !important;
+  --ionicon-stroke-width: 2rem;
 }
 
 .ib.h:hover > .icon {

package/src/styles/nexus.logic.css

@@ -1,18 +1,47 @@
+:root {
+  --ACTIVE_BACKGROUND_COLOR: var(--B1);
+  --ACTIVE_BORDER_COLOR: var(--B20);
+  --ACTIVE_TEXT_COLOR: var(--T1);
+}
+.item .ho1 {
+  opacity: 0;
+}
+
 .ho1:hover {
   opacity: 1;
 }
-.btn.active {
-  font-weight: 500;
-}
-.btn.active {
+.btn.active,
+.btn.left-active {
   background-color: var(--ACTIVE_BACKGROUND_COLOR) !important;
   pointer-events: none;
+  border-radius: 0 !important;
+  opacity: 1 !important;
 }
-.btn.active::after {
+.btn.active::after,
+.btn.left-active::after {
   content: " ";
   position: absolute;
   width: 100%;
   height: var(--BRD2);
   bottom: 0;
+  left: 0;
   background-color: var(--ACTIVE_BORDER_COLOR);
 }
+
+.btn.left-active::after {
+  width: calc(var(--BRD2) * 3) !important;
+  height: 100% !important;
+  bottom: unset;
+  top: 0;
+}
+
+.btn.active,
+.btn.left-active,
+.btn.active span,
+.btn.active .icon,
+.btn.left-active .icon,
+.btn.left-active span {
+  color: var(--ACTIVE_TEXT_COLOR) !important;
+  font-weight: 600 !important;
+  opacity: 1 !important;
+}