@nest-arch/tui 0.4.6 → 0.5.1

package/dist/templates/single-project/architecture/nest-microservice/.env.hbs

@@ -1,22 +1,51 @@
 PORT=3000
+NODE_ENV=development
+TRUSTED_PROXY_IPS={{#each trustedProxyIps}}{{#unless @first}},{{/unless}}{{this}}{{/each}}
 MICROSERVICE_PORT=3001
-CORS_ORIGIN=http://localhost:3001
+CORS_ORIGIN=http://localhost:3000
+{{#if hasPostgres}}
+POSTGRES_URL=postgresql://postgres:postgres@localhost:5432/{{projectNameKebab}}_db?schema=public
+{{/if}}
+{{#if hasMysql}}
+MYSQL_URL=mysql://root:mysql@localhost:3306/{{projectNameKebab}}_db
+{{/if}}
+{{#if hasSqlite}}
+SQLITE_PATH=./src/database/dev.db
+{{/if}}
+{{#if hasSqlserver}}
+SQLSERVER_HOST=localhost
+SQLSERVER_PORT=1433
+SQLSERVER_DATABASE={{projectNameKebab}}_db
+SQLSERVER_USER=sa
+SQLSERVER_PASSWORD=DevOnly_Strong_Password_2026!X9
+SQLSERVER_ENCRYPT=true
+SQLSERVER_TRUST_SERVER_CERTIFICATE=true
+{{/if}}
+{{#if hasMongodb}}
+MONGODB_URL=mongodb://localhost:27017/{{projectNameKebab}}_db
+{{/if}}
 {{#if (includes microservices "redis")}}
+REDIS_PORT=6379
 REDIS_URL=redis://127.0.0.1:6379
 {{/if}}
 {{#if (includes microservices "mqtt")}}
+MQTT_PORT=1883
 MQTT_URL=mqtt://127.0.0.1:1883
 {{/if}}
 {{#if (includes microservices "nats")}}
+NATS_PORT=4222
 NATS_URL=nats://127.0.0.1:4222
 {{/if}}
 {{#if (includes microservices "rabbitmq")}}
+RABBITMQ_PORT=5672
 RABBITMQ_URL=amqp://127.0.0.1:5672
 {{/if}}
 {{#if (includes microservices "kafka")}}
+KAFKA_PORT=9092
 KAFKA_BROKER=127.0.0.1:9092
 {{/if}}
 {{#if (includes microservices "grpc")}}
+GRPC_PORT=5000
 GRPC_URL=0.0.0.0:5000
 {{/if}}
 {{#if hasGraphql}}

package/dist/templates/single-project/architecture/nest-microservice/proto/app.proto.hbs

@@ -5,9 +5,22 @@ package app;
 service AppService {
   rpc Ping (PingRequest) returns (PingResponse);
   rpc Log (LogRequest) returns (LogResponse);
+  {{#if (and hasDatabase hasTodoExample)}}
+  rpc CreateTodo (CreateTodoRequest) returns (StorageResponse);
+  rpc ListTodos (PingRequest) returns (StorageResponse);
+  {{/if}}
 }
 
 message PingRequest {}
+{{#if (and hasDatabase hasTodoExample)}}
+message CreateTodoRequest {
+  string title = 1;
+}
+
+message StorageResponse {
+  string json = 1;
+}
+{{/if}}
 
 message PingResponse {
   string message = 1;

package/dist/templates/single-project/architecture/nest-microservice/src/app.controller.ts.hbs

@@ -9,11 +9,11 @@ import { EventPattern, MessagePattern } from "@nestjs/microservices";
 import { AppService } from "./app.service.js";
 
 {{#unless (includes microservices "grpc")}}
-type AuditEvent = {
+interface AuditEvent {
   id: string;
   payload: Record<string, unknown>;
   source: string;
-};
+}
 
 const isAuditEvent = (value: unknown): value is AuditEvent => {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -40,6 +40,30 @@ export class AppController {
 
   constructor(private readonly appService: AppService) {}
 
+  {{#if (and hasDatabase hasTodoExample)}}
+  {{#if (includes microservices "grpc")}}
+  @GrpcMethod("AppService", "CreateTodo")
+  async createTodo(data: { title: string }): Promise<{ json: string }> {
+    return { json: JSON.stringify(await this.appService.createTodo(data)) };
+  }
+
+  @GrpcMethod("AppService", "ListTodos")
+  async listTodos(): Promise<{ json: string }> {
+    return { json: JSON.stringify(await this.appService.findTodos()) };
+  }
+  {{else}}
+  @MessagePattern("todo.create")
+  createTodo(data: { title: string }) {
+    return this.appService.createTodo(data);
+  }
+
+  @MessagePattern("todo.list")
+  listTodos() {
+    return this.appService.findTodos();
+  }
+  {{/if}}
+  {{/if}}
+
   @Get()
   getHello(): string {
     return this.appService.getHello();

package/dist/templates/single-project/architecture/nest-microservice/src/app.module.ts.hbs

@@ -1,4 +1,8 @@
 import { Module } from "@nestjs/common";
+{{#if hasRateLimiting}}
+import { APP_GUARD } from "@nestjs/core";
+import { ThrottlerModule } from "@nestjs/throttler";
+{{/if}}
 {{#if (or hasDatabase hasOrm)}}
 import { DbModule } from "./database/db.module.js";
 import { env } from "./config/env.js";
@@ -9,6 +13,27 @@ import { AuthModule } from "./auth/auth.module.js";
 
 import { AppController } from "./app.controller.js";
 import { AppService } from "./app.service.js";
+{{#if hasTrpc}}
+import { TRPCModule } from "nestjs-trpc";
+import { AppRouterClass as AppRouter } from "./app.router.js";
+import { AppContext } from "./libs/trpc/context.js";
+import { AppErrorHandler } from "./libs/trpc/error.handler.js";
+{{#if hasRateLimiting}}
+import { RateLimitTRPCMiddleware } from "./libs/middlewares/rate-limit.trpc.middleware.js";
+{{/if}}
+{{#if hasTodoExample}}
+import { TodoRouter } from "./api/todo/todo.router.js";
+{{/if}}
+{{/if}}
+{{#if hasRateLimiting}}
+import { HttpThrottlerGuard } from "./http-throttler.guard.js";
+{{/if}}
+{{#if (and hasRest hasTodoExample)}}
+import { TodoModule } from "./api/todo/todo.module.js";
+{{/if}}
+{{#if hasHealthCheck}}
+import { HealthModule } from "./health/health.module.js";
+{{/if}}
 
 @Module({
   controllers: [AppController],
@@ -18,13 +43,48 @@ import { AppService } from "./app.service.js";
       {{#if hasPostgres}}postgresUrl: env.POSTGRES_URL,{{/if}}
       {{#if hasMysql}}mysqlUrl: env.MYSQL_URL,{{/if}}
       {{#if hasSqlite}}sqlitePath: env.SQLITE_PATH,{{/if}}
+      {{#if hasSqlserver}}sqlserver: { database: env.SQLSERVER_DATABASE, options: { encrypt: env.SQLSERVER_ENCRYPT, trustServerCertificate: env.SQLSERVER_TRUST_SERVER_CERTIFICATE }, password: env.SQLSERVER_PASSWORD, port: env.SQLSERVER_PORT, server: env.SQLSERVER_HOST, user: env.SQLSERVER_USER },{{/if}}
       {{#if hasMongodb}}mongodbUrl: env.MONGODB_URL,{{/if}}
     }),
     {{/if}}
     {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
     AuthModule,
     {{/if}}
+    {{#if hasTrpc}}
+    TRPCModule.forRoot({
+      context: AppContext,
+      {{#if hasRateLimiting}}
+      globalMiddlewares: [RateLimitTRPCMiddleware],
+      {{/if}}
+      onError: AppErrorHandler,
+    }),
+    {{/if}}
+    {{#if hasRateLimiting}}
+    ThrottlerModule.forRoot([{ limit: 60, ttl: 60_000 }]),
+    {{/if}}
+    {{#if (and hasRest hasTodoExample)}}
+    TodoModule,
+    {{/if}}
+    {{#if hasHealthCheck}}
+    HealthModule,
+    {{/if}}
+  ],
+  providers: [
+    AppService,
+    {{#if hasTrpc}}
+    AppContext,
+    AppErrorHandler,
+    AppRouter,
+    {{#if hasRateLimiting}}
+    RateLimitTRPCMiddleware,
+    {{/if}}
+    {{#if hasTodoExample}}
+    TodoRouter,
+    {{/if}}
+    {{/if}}
+    {{#if hasRateLimiting}}
+    { provide: APP_GUARD, useClass: HttpThrottlerGuard },
+    {{/if}}
   ],
-  providers: [AppService],
 })
 export class AppModule {}

package/dist/templates/single-project/architecture/nest-microservice/src/app.service.ts.hbs

@@ -1,6 +1,7 @@
 import { Injectable } from "@nestjs/common";
-{{#if (or hasDatabase hasOrm)}}
-import { DbService } from "./database/db.service.js";
+{{#if (and hasDatabase hasTodoExample)}}
+import { RpcException } from "@nestjs/microservices";
+import { TodoService } from "./api/todo/todo.service.js";
 {{/if}}
 
 @Injectable()
@@ -26,8 +27,19 @@ export class AppService {
   }
 
   {{/unless}}
-  {{#if (or hasDatabase hasOrm)}}
-  constructor(private readonly db: DbService) {}
+  {{#if (and hasDatabase hasTodoExample)}}
+  constructor(private readonly todos: TodoService) {}
+
+  createTodo(data: { title: string }) {
+    if (typeof data?.title !== "string" || data.title.trim().length === 0) {
+      throw new RpcException({ code: 3, message: "A non-empty title is required" });
+    }
+    return this.todos.create({ completed: false, title: data.title });
+  }
+
+  findTodos() {
+    return this.todos.findAll();
+  }
 
   {{/if}}
   getHello(): string {

package/dist/templates/single-project/architecture/nest-microservice/src/http-throttler.guard.ts.hbs

@@ -0,0 +1,13 @@
+import { Injectable } from "@nestjs/common";
+import type { ExecutionContext } from "@nestjs/common";
+import { ThrottlerGuard } from "@nestjs/throttler";
+
+@Injectable()
+export class HttpThrottlerGuard extends ThrottlerGuard {
+  canActivate(context: ExecutionContext): Promise<boolean> {
+    if (context.getType() !== "http") {
+      return Promise.resolve(true);
+    }
+    return super.canActivate(context);
+  }
+}

package/dist/templates/single-project/architecture/nest-microservice/src/main.ts.hbs

@@ -1,7 +1,15 @@
+{{#if (includes microservices "grpc")}}
+import { fileURLToPath } from "node:url";
+{{/if}}
 {{#if (eq httpProvider "fastify")}}
 import { FastifyAdapter, NestFastifyApplication } from "@nestjs/platform-fastify";
 {{/if}}
+{{#if (includes addons "nestjs-zod")}}
 import { Logger } from "@nestjs/common";
+import { ZodValidationPipe } from "nestjs-zod";
+{{else}}
+import { Logger, StandardSchemaValidationPipe } from "@nestjs/common";
+{{/if}}
 import { NestFactory } from "@nestjs/core";
 import { Transport } from "@nestjs/microservices";
 import type { MicroserviceOptions } from "@nestjs/microservices";
@@ -22,9 +30,20 @@ import { AuthService } from "@thallesp/nestjs-better-auth";
 {{/if}}
 
 async function bootstrap() {
-  const app = await NestFactory.create{{#if (eq httpProvider "fastify")}}<NestFastifyApplication>(AppModule, new FastifyAdapter()){{else}}(AppModule){{/if}};
+  const trustedProxyIps = env.TRUSTED_PROXY_IPS.split(",").map((ip) => ip.trim()).filter(Boolean);
+  const app = await NestFactory.create{{#if (eq httpProvider "fastify")}}<NestFastifyApplication>(AppModule, new FastifyAdapter({ trustProxy: trustedProxyIps })){{else}}(AppModule){{/if}};
+  {{#unless (eq httpProvider "fastify")}}
+  if (trustedProxyIps.length > 0) {
+    app.getHttpAdapter().getInstance().set("trust proxy", trustedProxyIps);
+  }
+  {{/unless}}
   app.enableCors({ origin: env.CORS_ORIGIN });
   app.setGlobalPrefix("api");
+  {{#if (includes addons "nestjs-zod")}}
+  app.useGlobalPipes(new ZodValidationPipe());
+  {{else}}
+  app.useGlobalPipes(new StandardSchemaValidationPipe());
+  {{/if}}
   app.enableShutdownHooks();
 
   app.connectMicroservice<MicroserviceOptions>({
@@ -34,7 +53,7 @@ async function bootstrap() {
       {{/if}}
       {{#if (includes microservices "grpc")}}
       package: "app",
-      protoPath: "proto/app.proto",
+      protoPath: fileURLToPath(new URL("proto/app.proto", import.meta.url)),
       url: env.GRPC_URL ?? "0.0.0.0:5000",
       {{/if}}
       {{#if (includes microservices "rabbitmq")}}
@@ -78,8 +97,8 @@ async function bootstrap() {
             {{/if}}
             {{#if (includes apis "trpc")}}
             trpc: {
-              routerFilePath: "./src/trpc/router.ts",
               pathPrefix: "/trpc",
+              routerFilePath: "./{{trpcGeneratePath}}/server.ts",
             },
             {{/if}}
             zod: {
@@ -88,10 +107,10 @@ async function bootstrap() {
           },
           title: "{{projectNamePascalCase}} API",
           version: "1.0.0",
-      }),
-      {{#if (eq httpProvider "fastify")}}withFastify: true,{{/if}}
-      pageTitle: "{{projectNamePascalCase}} API Docs",
+        }),
+        pageTitle: "{{projectNamePascalCase}} API Docs",
         theme: "default",
+        {{#if (eq httpProvider "fastify")}}withFastify: true,{{/if}}
       }),
     );
     {{else}}
@@ -106,7 +125,7 @@ async function bootstrap() {
         {{/if}}
         {{#if (includes apis "trpc")}}
         trpc: {
-          routerFilePath: "./src/trpc/router.ts",
+          routerFilePath: "./{{trpcGeneratePath}}/server.ts",
           pathPrefix: "/trpc",
         },
         {{/if}}

package/dist/templates/single-project/architecture/nest-microservice/test/microservice.e2e-spec.ts.hbs

@@ -1,102 +1,22 @@
 import type { INestApplication } from "@nestjs/common";
-import { ClientProxyFactory, Transport } from "@nestjs/microservices";
-import type { {{#if (includes microservices "grpc")}}ClientGrpc{{else if (includes microservices "kafka")}}ClientKafka{{else}}ClientProxy{{/if}}, MicroserviceOptions } from "@nestjs/microservices";
-import { Test } from "@nestjs/testing";
-{{#unless (includes microservices "grpc")}}
-import { setTimeout as delay } from "node:timers/promises";
-import request from "supertest";
-{{/unless}}
-import { firstValueFrom } from "rxjs";
-{{#if (includes microservices "grpc")}}
-import type { Observable } from "rxjs";
+{{#if (eq httpProvider "fastify")}}
+import { FastifyAdapter, NestFastifyApplication } from "@nestjs/platform-fastify";
 {{/if}}
+import { Test } from "@nestjs/testing";
 import { afterAll, expect, it } from "vitest";
 
 import { AppModule } from "../src/app.module.js";
-import { env } from "../src/config/env.js";
-
-const transport = {{#if (includes microservices "redis")}}Transport.REDIS{{else if (includes microservices "mqtt")}}Transport.MQTT{{else if (includes microservices "nats")}}Transport.NATS{{else if (includes microservices "rabbitmq")}}Transport.RMQ{{else if (includes microservices "kafka")}}Transport.KAFKA{{else if (includes microservices "grpc")}}Transport.GRPC{{else}}Transport.TCP{{/if}};
-
-const options = {
-  {{#if (includes microservices "kafka")}}
-  client: { brokers: [env.KAFKA_BROKER] },
-  consumer: { groupId: "ping-consumer" },
-  {{/if}}
-  {{#if (includes microservices "grpc")}}
-  package: "app",
-  protoPath: "proto/app.proto",
-  url: env.GRPC_URL,
-  {{/if}}
-  {{#if (includes microservices "rabbitmq")}}
-  queue: "ping",
-  queueOptions: { durable: false },
-  urls: [env.RABBITMQ_URL],
-  {{/if}}
-  {{#if (includes microservices "redis")}}
-  host: new URL(env.REDIS_URL).hostname,
-  port: Number(new URL(env.REDIS_URL).port || 6379),
-  {{/if}}
-  {{#if (includes microservices "nats")}}
-  servers: [env.NATS_URL],
-  {{/if}}
-  {{#if (includes microservices "mqtt")}}
-  url: env.MQTT_URL,
-  {{/if}}
-};
 
 let app: INestApplication;
-const client{{#if (includes microservices "grpc")}}: ClientGrpc = ClientProxyFactory.create({ options, transport } as MicroserviceOptions) as unknown as ClientGrpc;{{else if (includes microservices "kafka")}}: ClientKafka = ClientProxyFactory.create({ options, transport } as MicroserviceOptions) as ClientKafka;{{else}}: ClientProxy = ClientProxyFactory.create({ options, transport } as MicroserviceOptions);{{/if}}
 
-it("sends ping through the selected message transport", async () => {
+it("serves the generated HTTP application", async () => {
   const module = await Test.createTestingModule({ imports: [AppModule] }).compile();
-  app = module.createNestApplication();
-  app.connectMicroservice<MicroserviceOptions>({ options, transport } as MicroserviceOptions);
+  app = module.createNestApplication{{#if (eq httpProvider "fastify")}}<NestFastifyApplication>(new FastifyAdapter()){{else}}(){{/if}};
   app.setGlobalPrefix("api");
-  await app.startAllMicroservices();
   await app.init();
-  {{#if (includes microservices "kafka")}}
-  client.subscribeToResponseOf("ping");
-  client.subscribeToResponseOf("log");
-  {{/if}}
-  {{#unless (includes microservices "grpc")}}
-  {{#if (includes microservices "kafka")}}
-  try {
-    await client.connect();
-  } catch {
-    await delay(1000);
-    await client.connect();
-  }
-  {{else}}
-  await client.connect();
-  {{/if}}
-  {{/unless}}
-  {{#if (includes microservices "grpc")}}
-  const service = client.getService<{
-    ping: (request: Record<string, never>) => Observable<{ message: string }>;
-    log: (request: { id: string; source: string; payload: string }) => Observable<{ id: string; source: string; payload: string }>;
-  }>("AppService");
-  await expect(firstValueFrom(service.ping({}))).resolves.toEqual({ message: "pong" });
-  const event = { id: "event-1", payload: "healthy", source: "scenario" };
-  await expect(firstValueFrom(service.log(event))).resolves.toEqual(event);
-  {{else}}
-  await expect(firstValueFrom(client.send<string, Record<string, never>>("ping", {}))).resolves.toBe("pong");
-  const event = { id: "event-1", payload: { healthy: true }, source: "scenario" };
-  await expect(firstValueFrom(client.send("log", event))).resolves.toEqual({ received: event });
-  const auditEvent = {
-    id: "audit-1",
-    payload: { healthy: true },
-    source: "scenario",
-  };
-  await firstValueFrom(client.emit("audit", auditEvent));
-  await delay(250);
-  const auditResponse = await request(app.getHttpServer())
-    .get(`/api/events/${auditEvent.id}`)
-    .expect(200);
-  expect(auditResponse.body).toEqual(auditEvent);
-  {{/if}}
-}, 60_000);
+  expect(app.getHttpServer()).toBeDefined();
+});
 
 afterAll(async () => {
   await app?.close();
-  client.close();
 });

package/dist/templates/single-project/shared/config/env.ts.hbs

@@ -35,9 +35,15 @@ export const env = createEnv({
     {{#if (or (includes microservices "redis") (includes microservices "mqtt") (includes microservices "nats") (includes microservices "rabbitmq") (includes microservices "kafka") (includes microservices "grpc"))}}
     MICROSERVICE_PORT: z.string().transform(Number).default(3001),
     {{/if}}
+    {{#if hasMongodb}}
+    MONGODB_URL: z.url(),
+    {{/if}}
     {{#if (includes microservices "mqtt")}}
     MQTT_URL: z.url().default("mqtt://127.0.0.1:1883"),
     {{/if}}
+    {{#if hasMysql}}
+    MYSQL_URL: z.url(),
+    {{/if}}
     {{#if (includes microservices "nats")}}
     NATS_URL: z.url().default("nats://127.0.0.1:4222"),
     {{/if}}
@@ -48,34 +54,28 @@ export const env = createEnv({
       .string()
       .transform(Number)
       .default(3000),
+    {{#if hasPostgres}}
+    POSTGRES_URL: z.url(),
+    {{/if}}
     {{#if (includes microservices "rabbitmq")}}
     RABBITMQ_URL: z.url().default("amqp://127.0.0.1:5672"),
     {{/if}}
     {{#if (includes microservices "redis")}}
     REDIS_URL: z.url().default("redis://127.0.0.1:6379"),
     {{/if}}
-    TRUSTED_PROXY_IPS: z.string().default("{{#each trustedProxyIps}}{{#unless @first}},{{/unless}}{{this}}{{/each}}"),
-    {{#if hasPostgres}}
-    POSTGRES_URL: z.url(),
-    {{/if}}
-    {{#if hasMysql}}
-    MYSQL_URL: z.url(),
-    {{/if}}
     {{#if hasSqlite}}
     SQLITE_PATH: z.string().default("sqlite.db"),
     {{/if}}
     {{#if hasSqlserver}}
-    SQLSERVER_HOST: z.string().default("localhost"),
-    SQLSERVER_PORT: z.string().transform(Number).default(1433),
     SQLSERVER_DATABASE: z.string().default("{{projectNameKebab}}_db"),
-    SQLSERVER_USER: z.string(),
-    SQLSERVER_PASSWORD: z.string(),
     SQLSERVER_ENCRYPT: z.string().transform((value) => value !== "false").default(true),
+    SQLSERVER_HOST: z.string().default("localhost"),
+    SQLSERVER_PASSWORD: z.string(),
+    SQLSERVER_PORT: z.string().transform(Number).default(1433),
     SQLSERVER_TRUST_SERVER_CERTIFICATE: z.string().transform((value) => value === "true").default(false),
+    SQLSERVER_USER: z.string(),
     {{/if}}
-    {{#if hasMongodb}}
-    MONGODB_URL: z.url(),
-    {{/if}}
+    TRUSTED_PROXY_IPS: z.string().default("{{#each trustedProxyIps}}{{#unless @first}},{{/unless}}{{this}}{{/each}}"),
     {{#if hasGraphql}}
     GRAPHQL_PLAYGROUND: z
       .string()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-arch/tui",
-  "version": "0.4.6",
+  "version": "0.5.1",
   "private": false,
   "description": "Interactive terminal UI for generating NestJS projects",
   "keywords": [
@@ -38,6 +38,7 @@
     "handlebars": "^4.7.8",
     "ink": "^5.0.1",
     "ink-text-input": "^6.0.0",
+    "jsonc-parser": "^3.3.1",
     "open": "^11.0.0",
     "react": "^18.3.1",
     "semver": "^7.8.5",
@@ -45,15 +46,15 @@
     "zod": "^4.1.13"
   },
   "devDependencies": {
+    "@nest-arch/core": "0.4.3",
+    "@nest-arch/env": "0.0.0",
+    "@nest-arch/shared": "0.0.0",
     "@types/react": "^18.3.12",
     "@types/semver": "^7.8.0",
     "ink-testing-library": "^4.0.0",
     "pkgroll": "^2.5.2",
     "tsx": "^4.19.2",
-    "vitest": "^4.1.7",
-    "@nest-arch/env": "0.0.0",
-    "@nest-arch/core": "0.4.3",
-    "@nest-arch/shared": "0.0.0"
+    "vitest": "^4.1.7"
   },
   "peerDependencies": {
     "typescript": "^5"

package/dist/constants-DVhgS48N.js

@@ -1 +0,0 @@
-var o="0.4.6",O={version:o};const s="Nest Arch",A=`v${O.version}`,n="Build production-ready NestJS projects.",t="#e54545",c="#A0A0A0",R="#6B6B6B",C="#E5E5E5",E="#61AFEF",_="#3A3A3A",e="#7FD99A",r="#E8C468",L="#e96142ff";export{s as APP_NAME,n as APP_TAGLINE,A as APP_VERSION,E as COLOR_ACCENT,c as COLOR_DIM,R as COLOR_DIMMER,_ as COLOR_DIVIDER,C as COLOR_FG,t as COLOR_RED,e as COLOR_SUCCESS,r as COLOR_WARM,L as COLOR_WARM_SECONDARY};