@bgord/bun 1.10.23 → 1.11.0

package/src/shield-timeout.strategy.ts

@@ -1,19 +1,9 @@
 import type * as tools from "@bgord/tools";
-import { createMiddleware } from "hono/factory";
-import { HTTPException } from "hono/http-exception";
-import { timeout } from "hono/timeout";
-import type { ShieldStrategy } from "./shield.strategy";
 
-export const ShieldTimeoutError = new HTTPException(408, { message: "shield.timeout" });
+export type ShieldTimeoutConfig = { duration: tools.Duration };
 
-type ShieldTimeoutConfigType = { duration: tools.Duration };
+export const ShieldTimeoutStrategyError = { Rejected: "shield.timeout.rejected" };
 
-export class ShieldTimeoutStrategy implements ShieldStrategy {
-  private readonly timeout;
-
-  constructor(config: ShieldTimeoutConfigType) {
-    this.timeout = timeout(config.duration.ms, ShieldTimeoutError);
-  }
-
-  verify = createMiddleware(async (context, next) => this.timeout(context, next));
+export class ShieldTimeoutStrategy {
+  constructor(readonly config: ShieldTimeoutConfig) {}
 }

package/src/simulated-error-hono.middleware.ts

@@ -0,0 +1,17 @@
+import type { MiddlewareHandler } from "hono";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { SimulatedErrorMiddleware } from "./simulated-error.middleware";
+
+export class SimulatedErrorHonoMiddleware implements MiddlewareHonoPort {
+  private readonly middleware: SimulatedErrorMiddleware;
+
+  constructor() {
+    this.middleware = new SimulatedErrorMiddleware();
+  }
+
+  handle(): MiddlewareHandler {
+    return async (_c, _next) => {
+      this.middleware.evaluate();
+    };
+  }
+}

package/src/simulated-error.middleware.ts

@@ -1,8 +1,5 @@
-import { createMiddleware } from "hono/factory";
-
-export class SimulatedError {
-  static handle = () =>
-    createMiddleware(async (_, _next) => {
-      throw new Error("Simulated error");
-    });
+export class SimulatedErrorMiddleware {
+  evaluate(): never {
+    throw new Error("Simulated error");
+  }
 }

package/src/slower-hono.middleware.ts

@@ -0,0 +1,23 @@
+import type * as tools from "@bgord/tools";
+import type { MiddlewareHandler } from "hono";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import type { SleeperPort } from "./sleeper.port";
+import { SlowerMiddleware } from "./slower.middleware";
+
+type Dependencies = { Sleeper: SleeperPort };
+
+export class SlowerHonoMiddleware implements MiddlewareHonoPort {
+  private readonly middleware: SlowerMiddleware;
+
+  constructor(offset: tools.Duration, deps: Dependencies) {
+    this.middleware = new SlowerMiddleware(offset, deps);
+  }
+
+  handle(): MiddlewareHandler {
+    return async (_c, next) => {
+      await this.middleware.evaluate();
+
+      return next();
+    };
+  }
+}

package/src/slower.middleware.ts

@@ -1,14 +1,15 @@
 import type * as tools from "@bgord/tools";
-import { createMiddleware } from "hono/factory";
 import type { SleeperPort } from "./sleeper.port";
 
 type Dependencies = { Sleeper: SleeperPort };
 
-export class Slower {
-  static handle = (offset: tools.Duration, deps: Dependencies) =>
-    createMiddleware(async (_, next) => {
-      await deps.Sleeper.wait(offset);
+export class SlowerMiddleware {
+  constructor(
+    private readonly offset: tools.Duration,
+    private readonly deps: Dependencies,
+  ) {}
 
-      return next();
-    });
+  async evaluate(): Promise<void> {
+    await this.deps.Sleeper.wait(this.offset);
+  }
 }

package/src/ssr-bun.service.ts

@@ -0,0 +1,25 @@
+import type { NonceProviderPort } from "./nonce-provider.port";
+import type { NonceValueType } from "./nonce-value.vo";
+import { SSRService } from "./ssr.service";
+
+type Dependencies = { NonceProvider: NonceProviderPort };
+
+export class SSRBun {
+  static essentials(
+    handler: (request: Request, nonce: NonceValueType) => Promise<Response>,
+    deps: Dependencies,
+  ) {
+    const service = new SSRService(deps);
+
+    return async (request: Request): Promise<Response> => {
+      const nonce = service.nonce;
+
+      const response = await handler(request, nonce);
+
+      const headers = service.secure(nonce);
+      Object.entries(headers).forEach(([name, value]) => response.headers.set(name, value));
+
+      return response;
+    };
+  }
+}

package/src/ssr.service.ts

@@ -0,0 +1,66 @@
+import type { NonceProviderPort } from "./nonce-provider.port";
+import type { NonceValueType } from "./nonce-value.vo";
+
+type Dependencies = { NonceProvider: NonceProviderPort };
+
+export type SSRSecurityHeaders = {
+  "Content-Security-Policy": string;
+  "Permissions-Policy": string;
+  "Cross-Origin-Opener-Policy": string;
+  "Cross-Origin-Resource-Policy": string;
+  "Referrer-Policy": string;
+  "Strict-Transport-Security": string;
+  "X-Content-Type-Options": string;
+  "X-DNS-Prefetch-Control": string;
+  "X-Download-Options": string;
+  "X-Permitted-Cross-Domain-Policies": string;
+  "X-XSS-Protection": string;
+};
+
+export class SSRService {
+  constructor(private readonly deps: Dependencies) {}
+
+  get nonce(): NonceValueType {
+    return this.deps.NonceProvider.generate();
+  }
+
+  secure(nonce: NonceValueType): SSRSecurityHeaders {
+    return {
+      "Content-Security-Policy": [
+        "default-src 'none'",
+        "base-uri 'none'",
+        "object-src 'none'",
+        "frame-ancestors 'none'",
+        `script-src 'self' 'nonce-${nonce}'`,
+        `script-src-elem 'self' 'nonce-${nonce}'`,
+        `style-src 'self' 'nonce-${nonce}'`,
+        "style-src-attr 'unsafe-inline'",
+        "img-src 'self'",
+        "font-src 'self'",
+        "connect-src 'self'",
+        "form-action 'self'",
+      ].join("; "),
+      "Permissions-Policy": [
+        "accelerometer=()",
+        "autoplay=()",
+        "camera=()",
+        "fullscreen=(self)",
+        "geolocation=()",
+        "gyroscope=()",
+        "magnetometer=()",
+        "microphone=()",
+        "payment=()",
+        "usb=()",
+      ].join(", "),
+      "Cross-Origin-Opener-Policy": "same-origin",
+      "Cross-Origin-Resource-Policy": "same-origin",
+      "Referrer-Policy": "no-referrer",
+      "Strict-Transport-Security": "max-age=15552000; includeSubDomains",
+      "X-Content-Type-Options": "nosniff",
+      "X-DNS-Prefetch-Control": "off",
+      "X-Download-Options": "noopen",
+      "X-Permitted-Cross-Domain-Policies": "none",
+      "X-XSS-Protection": "0",
+    };
+  }
+}

package/src/{static-files.service.ts → static-files-hono.service.ts}

@@ -58,7 +58,7 @@ const staticDocumentHeaders = secureHeaders({
 
 type StaticFilesOptions = { root?: string };
 
-export class StaticFiles {
+export class StaticFilesHono {
   static handle(path: string, strategy: StaticFilesStrategy, options?: StaticFilesOptions) {
     // Stryker disable all
     const root = options?.root ?? "./";

package/src/subject-application-resolver.vo.ts

@@ -0,0 +1,34 @@
+import type { Hash } from "./hash.vo";
+import type { HashContentStrategy } from "./hash-content.strategy";
+import type { SubjectSegmentApplicationStrategy } from "./subject-segment-application.strategy";
+import type { SubjectSegmentType } from "./subject-segment-request.strategy";
+
+type Dependencies = { HashContent: HashContentStrategy };
+
+export const SubjectApplicationResolverError = {
+  NoSegments: "subject.application.no.segments",
+  TooManySegments: "subject.application.too.many.segments",
+};
+
+export class SubjectApplicationResolver {
+  private readonly SEPARATOR = "|";
+
+  constructor(
+    private readonly segments: ReadonlyArray<SubjectSegmentApplicationStrategy>,
+    private readonly deps: Dependencies,
+  ) {
+    if (this.segments.length === 0) throw new Error(SubjectApplicationResolverError.NoSegments);
+    if (this.segments.length > 10) throw new Error(SubjectApplicationResolverError.TooManySegments);
+  }
+
+  async resolve(): Promise<{ hex: Hash; raw: ReadonlyArray<SubjectSegmentType> }> {
+    const segments = this.segments.map((segment) =>
+      segment.create().replaceAll(this.SEPARATOR, encodeURIComponent(this.SEPARATOR)),
+    );
+    const subject = segments.join(this.SEPARATOR);
+
+    const hex = await this.deps.HashContent.hash(subject);
+
+    return { hex, raw: segments };
+  }
+}

package/src/subject-request-resolver.vo.ts

@@ -0,0 +1,34 @@
+import type { Hash } from "./hash.vo";
+import type { HashContentStrategy } from "./hash-content.strategy";
+import type { RequestContext } from "./request-context.port";
+import type { SubjectSegmentRequestStrategy, SubjectSegmentType } from "./subject-segment-request.strategy";
+
+type Dependencies = { HashContent: HashContentStrategy };
+
+export const SubjectRequestResolverError = {
+  NoSegments: "subject.request.no.segments",
+  TooManySegments: "subject.request.too.many.segments",
+};
+
+export class SubjectRequestResolver {
+  private readonly SEPARATOR = "|";
+
+  constructor(
+    private readonly segments: ReadonlyArray<SubjectSegmentRequestStrategy>,
+    private readonly deps: Dependencies,
+  ) {
+    if (this.segments.length === 0) throw new Error(SubjectRequestResolverError.NoSegments);
+    if (this.segments.length > 10) throw new Error(SubjectRequestResolverError.TooManySegments);
+  }
+
+  async resolve(context: RequestContext): Promise<{ hex: Hash; raw: ReadonlyArray<SubjectSegmentType> }> {
+    const segments = this.segments.map((segment) =>
+      segment.create(context).replaceAll(this.SEPARATOR, encodeURIComponent(this.SEPARATOR)),
+    );
+    const subject = segments.join(this.SEPARATOR);
+
+    const hex = await this.deps.HashContent.hash(subject);
+
+    return { hex, raw: segments };
+  }
+}

package/src/subject-segment-application.strategy.ts

@@ -0,0 +1,7 @@
+import type { SubjectSegmentType } from "./subject-segment-request.strategy";
+
+export const SubjectSegmentApplicationEmpty: SubjectSegmentType = "__absent__";
+
+export interface SubjectSegmentApplicationStrategy {
+  create(): SubjectSegmentType;
+}

package/src/subject-segment-build.strategy.ts

@@ -0,0 +1,15 @@
+import type * as tools from "@bgord/tools";
+import {
+  SubjectSegmentApplicationEmpty,
+  type SubjectSegmentApplicationStrategy,
+} from "./subject-segment-application.strategy";
+import type { SubjectSegmentType } from "./subject-segment-request.strategy";
+
+export class SubjectSegmentBuildStrategy implements SubjectSegmentApplicationStrategy {
+  constructor(private readonly build?: tools.PackageVersion) {}
+
+  create(): SubjectSegmentType {
+    if (!this.build) return SubjectSegmentApplicationEmpty;
+    return this.build.toString();
+  }
+}

package/src/subject-segment-cookie.strategy.ts

@@ -0,0 +1,14 @@
+import type { HasRequestCookie } from "./request-context.port";
+import type { SubjectSegmentType } from "./subject-segment-request.strategy";
+import {
+  SubjectSegmentRequestEmpty,
+  type SubjectSegmentRequestStrategy,
+} from "./subject-segment-request.strategy";
+
+export class SubjectSegmentCookieStrategy implements SubjectSegmentRequestStrategy {
+  constructor(private readonly name: string) {}
+
+  create(context: HasRequestCookie): SubjectSegmentType {
+    return context.request.cookie(this.name) ?? SubjectSegmentRequestEmpty;
+  }
+}

package/src/subject-segment-env.strategy.ts

@@ -0,0 +1,11 @@
+import type { NodeEnvironmentEnum } from "./node-env.vo";
+import type { SubjectSegmentApplicationStrategy } from "./subject-segment-application.strategy";
+import type { SubjectSegmentType } from "./subject-segment-request.strategy";
+
+export class SubjectSegmentEnvStrategy implements SubjectSegmentApplicationStrategy {
+  constructor(private readonly type: NodeEnvironmentEnum) {}
+
+  create(): SubjectSegmentType {
+    return this.type;
+  }
+}

package/src/subject-segment-fixed.strategy.ts

@@ -0,0 +1,12 @@
+import type { SubjectSegmentApplicationStrategy } from "./subject-segment-application.strategy";
+import type { SubjectSegmentRequestStrategy, SubjectSegmentType } from "./subject-segment-request.strategy";
+
+export class SubjectSegmentFixedStrategy
+  implements SubjectSegmentRequestStrategy, SubjectSegmentApplicationStrategy
+{
+  constructor(private readonly value: string) {}
+
+  create(): SubjectSegmentType {
+    return this.value;
+  }
+}

package/src/subject-segment-header.strategy.ts

@@ -0,0 +1,14 @@
+import type { HasRequestHeader } from "./request-context.port";
+import type { SubjectSegmentType } from "./subject-segment-request.strategy";
+import {
+  SubjectSegmentRequestEmpty,
+  type SubjectSegmentRequestStrategy,
+} from "./subject-segment-request.strategy";
+
+export class SubjectSegmentHeaderStrategy implements SubjectSegmentRequestStrategy {
+  constructor(private readonly name: string) {}
+
+  create(context: HasRequestHeader): SubjectSegmentType {
+    return context.request.header(this.name) ?? SubjectSegmentRequestEmpty;
+  }
+}

package/src/subject-segment-ip.strategy.ts

@@ -0,0 +1,12 @@
+import type { HasIdentityIp } from "./request-context.port";
+import {
+  SubjectSegmentRequestEmpty,
+  type SubjectSegmentRequestStrategy,
+  type SubjectSegmentType,
+} from "./subject-segment-request.strategy";
+
+export class SubjectSegmentIpStrategy implements SubjectSegmentRequestStrategy {
+  create(context: HasIdentityIp): SubjectSegmentType {
+    return context.identity.ip() ?? SubjectSegmentRequestEmpty;
+  }
+}

package/src/subject-segment-path.strategy.ts

@@ -0,0 +1,8 @@
+import type { HasRequestPath } from "./request-context.port";
+import type { SubjectSegmentRequestStrategy, SubjectSegmentType } from "./subject-segment-request.strategy";
+
+export class SubjectSegmentPathStrategy implements SubjectSegmentRequestStrategy {
+  create(context: HasRequestPath): SubjectSegmentType {
+    return context.request.path;
+  }
+}

package/src/subject-segment-query.strategy.ts

@@ -0,0 +1,19 @@
+import type { HasRequestQuery } from "./request-context.port";
+import type { SubjectSegmentType } from "./subject-segment-request.strategy";
+import {
+  SubjectSegmentRequestEmpty,
+  type SubjectSegmentRequestStrategy,
+} from "./subject-segment-request.strategy";
+
+export class SubjectSegmentQueryStrategy implements SubjectSegmentRequestStrategy {
+  create(context: HasRequestQuery): SubjectSegmentType {
+    const query = context.request.query();
+
+    const keys = Object.keys(query).toSorted();
+
+    const result = keys.map((key) => `${key}=${query[key]}`).join("&");
+
+    if (!result) return SubjectSegmentRequestEmpty;
+    return result;
+  }
+}

package/src/{cache-subject-segment-request.strategy.ts → subject-segment-request.strategy.ts}

@@ -7,9 +7,9 @@ import type {
   HasRequestQuery,
 } from "./request-context.port";
 
-export const CacheSubjectSegmentRequestEmpty: CacheSubjectSegmentType = "__absent__";
+export type SubjectSegmentType = string;
 
-export type CacheSubjectSegmentType = string;
+export const SubjectSegmentRequestEmpty: SubjectSegmentType = "__absent__";
 
 type RequestContextCapabilities = HasRequestCookie &
   HasRequestHeader &
@@ -18,6 +18,6 @@ type RequestContextCapabilities = HasRequestCookie &
   HasIdentityIp &
   HasIdentityUserId;
 
-export interface CacheSubjectSegmentRequestStrategy {
-  create(context: RequestContextCapabilities): CacheSubjectSegmentType;
+export interface SubjectSegmentRequestStrategy {
+  create(context: RequestContextCapabilities): SubjectSegmentType;
 }

package/src/subject-segment-user.strategy.ts

@@ -0,0 +1,12 @@
+import type { HasIdentityUserId } from "./request-context.port";
+import {
+  SubjectSegmentRequestEmpty,
+  type SubjectSegmentRequestStrategy,
+  type SubjectSegmentType,
+} from "./subject-segment-request.strategy";
+
+export class SubjectSegmentUserStrategy implements SubjectSegmentRequestStrategy {
+  create(context: HasIdentityUserId): SubjectSegmentType {
+    return context.identity.userId() ?? SubjectSegmentRequestEmpty;
+  }
+}

package/src/time-zone-offset-hono.middleware.ts

@@ -0,0 +1,26 @@
+import type * as tools from "@bgord/tools";
+import type { MiddlewareHandler } from "hono";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+import { TimeZoneOffsetMiddleware } from "./time-zone-offset.middleware";
+
+export type TimeZoneOffsetVariables = { timeZoneOffset: tools.Duration };
+
+export class TimeZoneOffsetHonoMiddleware implements MiddlewareHonoPort {
+  private readonly middleware: TimeZoneOffsetMiddleware;
+
+  constructor() {
+    this.middleware = new TimeZoneOffsetMiddleware();
+  }
+
+  handle(): MiddlewareHandler {
+    return async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+      const offset = this.middleware.evaluate(context);
+
+      c.set("timeZoneOffset", offset);
+
+      await next();
+    };
+  }
+}

package/src/time-zone-offset.middleware.ts

@@ -1,27 +1,15 @@
 import * as tools from "@bgord/tools";
-import { createMiddleware } from "hono/factory";
-import { RequestContextAdapterHono } from "./request-context-hono.adapter";
+import type { RequestContext } from "./request-context.port";
 
-export type TimeZoneOffsetVariables = { timeZoneOffset: tools.Duration };
-
-export class TimeZoneOffset {
+export class TimeZoneOffsetMiddleware {
   static readonly TIME_ZONE_OFFSET_HEADER_NAME = "time-zone-offset";
-
   static readonly DEFAULT = tools.Duration.Minutes(0);
 
-  static attach = createMiddleware(async (c, next) => {
-    const context = new RequestContextAdapterHono(c);
-
-    const header = context.request.header(TimeZoneOffset.TIME_ZONE_OFFSET_HEADER_NAME);
+  evaluate(context: RequestContext): tools.Duration {
+    const header = context.request.header(TimeZoneOffsetMiddleware.TIME_ZONE_OFFSET_HEADER_NAME);
     const offset = tools.TimeZoneOffsetValue.safeParse(header);
 
-    if (offset.success) c.set("timeZoneOffset", tools.Duration.Minutes(offset.data));
-    else c.set("timeZoneOffset", TimeZoneOffset.DEFAULT);
-
-    await next();
-  });
-
-  static adjustDate(timestamp: tools.Timestamp, offset: tools.Duration): Date {
-    return new Date(timestamp.subtract(offset).ms);
+    if (offset.success) return tools.Duration.Minutes(offset.data);
+    return TimeZoneOffsetMiddleware.DEFAULT;
   }
 }

package/src/timing-hono.middleware.ts

@@ -0,0 +1,22 @@
+import { createMiddleware } from "hono/factory";
+import type { ClockPort } from "./clock.port";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { TimingMiddleware } from "./timing.middleware";
+
+type Dependencies = { Clock: ClockPort };
+
+export class TimingHonoMiddleware implements MiddlewareHonoPort {
+  private readonly middleware: TimingMiddleware;
+
+  constructor(deps: Dependencies) {
+    this.middleware = new TimingMiddleware(deps);
+  }
+
+  handle() {
+    return createMiddleware(async (c, next) => {
+      const result = await this.middleware.measure(() => next());
+
+      c.header(TimingMiddleware.HEADER_NAME, result);
+    });
+  }
+}

package/src/timing.middleware.ts

@@ -0,0 +1,18 @@
+import type { ClockPort } from "./clock.port";
+import { Stopwatch } from "./stopwatch.service";
+
+type Dependencies = { Clock: ClockPort };
+
+export class TimingMiddleware {
+  static readonly HEADER_NAME = "Server-Timing";
+
+  constructor(private readonly deps: Dependencies) {}
+
+  async measure(action: () => void | Promise<void>): Promise<string> {
+    const stopwatch = new Stopwatch(this.deps);
+
+    await action();
+
+    return `total;dur=${stopwatch.stop().ms}`;
+  }
+}

package/src/trailing-slash-hono.middleware.ts

@@ -0,0 +1,27 @@
+import { createMiddleware } from "hono/factory";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+import { TrailingSlashMiddleware } from "./trailing-slash.middleware";
+
+export class TrailingSlashHonoMiddleware implements MiddlewareHonoPort {
+  private readonly middleware: TrailingSlashMiddleware;
+
+  constructor() {
+    this.middleware = new TrailingSlashMiddleware();
+  }
+
+  handle() {
+    return createMiddleware(async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+
+      const result = this.middleware.evaluate(context);
+
+      if (!result.redirect) return next();
+
+      const url = new URL(context.request.url());
+      url.pathname = result.pathname;
+
+      return c.redirect(url.toString(), 301);
+    });
+  }
+}

package/src/trailing-slash.middleware.ts

@@ -0,0 +1,11 @@
+import type { HasRequestPath } from "./request-context.port";
+
+export type TrailingSlashResult = { redirect: false } | { redirect: true; pathname: string };
+
+export class TrailingSlashMiddleware {
+  evaluate(context: HasRequestPath): TrailingSlashResult {
+    if (!context.request.path.endsWith("/")) return { redirect: false };
+    if (context.request.path === "/") return { redirect: false };
+    return { redirect: true, pathname: context.request.path.slice(0, -1) };
+  }
+}

package/src/translations-hono.handler.ts

@@ -0,0 +1,26 @@
+import { createFactory } from "hono/factory";
+import type { FileReaderJsonPort } from "./file-reader-json.port";
+import type { HandlerHonoPort } from "./handler-hono.port";
+import type { LoggerPort } from "./logger.port";
+import { type TranslationsConfig, TranslationsHandler } from "./translations.handler";
+
+type Dependencies = { FileReaderJson: FileReaderJsonPort; Logger: LoggerPort };
+
+const factory = createFactory();
+
+export class TranslationsHonoHandler implements HandlerHonoPort {
+  private readonly handler: TranslationsHandler;
+
+  constructor(config: TranslationsConfig, deps: Dependencies) {
+    this.handler = new TranslationsHandler(config, deps);
+  }
+
+  handle() {
+    return factory.createHandlers(async (c) => {
+      const language = c.get("language");
+      const result = await this.handler.execute(language);
+
+      return c.json(result);
+    });
+  }
+}

package/src/translations.handler.ts

@@ -0,0 +1,31 @@
+import type * as tools from "@bgord/tools";
+import type { FileReaderJsonPort } from "./file-reader-json.port";
+import { I18n, type TranslationsSupportedLanguagesType, type TranslationsType } from "./i18n.service";
+import type { LoggerPort } from "./logger.port";
+
+export type TranslationsConfig = TranslationsSupportedLanguagesType;
+
+type Dependencies = { FileReaderJson: FileReaderJsonPort; Logger: LoggerPort };
+
+export type TranslationsResult = {
+  translations: TranslationsType;
+  language: tools.LanguageType;
+  supportedLanguages: TranslationsSupportedLanguagesType;
+};
+
+export class TranslationsHandler {
+  constructor(
+    private readonly config: TranslationsConfig,
+    private readonly deps: Dependencies,
+  ) {}
+
+  async execute(language: string): Promise<TranslationsResult> {
+    const translations = await new I18n(this.deps).getTranslations(language);
+
+    return {
+      translations,
+      language,
+      supportedLanguages: this.config,
+    };
+  }
+}