@bgord/bun 1.12.4 → 1.12.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.12.4",
+  "version": "1.12.5",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -30,8 +30,8 @@
     "better-auth": "1.5.4",
     "cspell": "9.7.0",
     "csv": "6.4.1",
-    "knip": "5.85.0",
-    "lefthook": "2.1.2",
+    "knip": "5.86.0",
+    "lefthook": "2.1.3",
     "lockfile-lint": "5.0.0",
     "nodemailer": "8.0.1",
     "only-allow": "1.2.2",
@@ -43,7 +43,7 @@
     "zod": "4.3.6"
   },
   "dependencies": {
-    "@bgord/tools": "1.3.22",
+    "@bgord/tools": "1.3.24",
     "emittery": "2.0.0",
     "hono": "4.12.5",
     "node-cache": "5.1.2"

package/readme.md

@@ -230,6 +230,13 @@ src/
 ├── job-handler-with-logger.strategy.ts
 ├── job-handler.strategy.ts
 ├── jobs.service.ts
+├── language-detector-cookie.strategy.ts
+├── language-detector-header.strategy.ts
+├── language-detector-hono.middleware.ts
+├── language-detector-query.strategy.ts
+├── language-detector.middleware.ts
+├── language-detector.strategy.ts
+├── languages.vo.ts
 ├── logger-collecting.adapter.ts
 ├── logger-noop.adapter.ts
 ├── logger-stats-provider-noop.adapter.ts
@@ -280,11 +287,9 @@ src/
 │   │   │   └── user-language-has-changed.ts
 │   │   ├── open-host-queries
 │   │   │   └── user-language.ts
-│   │   ├── ports
-│   │   │   ├── user-language-query.ts
-│   │   │   └── user-language-resolver.ts
-│   │   └── value-objects
-│   │       └── supported-languages-set.ts
+│   │   └── ports
+│   │       ├── user-language-query.ts
+│   │       └── user-language-resolver.ts
 │   └── system
 │       ├── events
 │       │   ├── HOUR_HAS_PASSED_EVENT.ts

package/src/i18n.service.ts

@@ -9,14 +9,6 @@ export type TranslationPlaceholderType = string;
 export type TranslationPlaceholderValueType = string | number;
 export type TranslationVariableType = Record<TranslationPlaceholderType, TranslationPlaceholderValueType>;
 
-export type TranslationsSupportedLanguagesType = Record<string, string>;
-
-export type I18nConfig = {
-  supportedLanguages: TranslationsSupportedLanguagesType;
-  translationsPath?: tools.DirectoryPathRelativeType;
-  defaultLanguage?: string;
-};
-
 type Dependencies = { FileReaderJson: FileReaderJsonPort; Logger: LoggerPort };
 
 export class I18n {

package/src/index.ts

@@ -199,6 +199,13 @@ export * from "./job-handler-bare.strategy";
 export * from "./job-handler-noop.strategy";
 export * from "./job-handler-with-logger.strategy";
 export * from "./jobs.service";
+export * from "./language-detector.middleware";
+export * from "./language-detector.strategy";
+export * from "./language-detector-cookie.strategy";
+export * from "./language-detector-header.strategy";
+export * from "./language-detector-hono.middleware";
+export * from "./language-detector-query.strategy";
+export * from "./languages.vo";
 export * from "./logger.port";
 export * from "./logger-collecting.adapter";
 export * from "./logger-noop.adapter";

package/src/language-detector-cookie.strategy.ts

@@ -0,0 +1,16 @@
+import type * as tools from "@bgord/tools";
+import type { LanguageDetectorStrategy } from "./language-detector.strategy";
+import type { Languages } from "./languages.vo";
+import type { HasRequestCookie } from "./request-context.port";
+
+export class LanguageDetectorCookieStrategy<T extends tools.LanguageType>
+  implements LanguageDetectorStrategy<T>
+{
+  constructor(private readonly name: string) {}
+
+  detect(context: HasRequestCookie, languages: Languages<T>): T | null {
+    const detected = context.request.cookie(this.name);
+
+    return languages.isSupported(detected) ? detected : null;
+  }
+}

package/src/language-detector-header.strategy.ts

@@ -0,0 +1,23 @@
+import type * as tools from "@bgord/tools";
+import type { LanguageDetectorStrategy } from "./language-detector.strategy";
+import type { Languages } from "./languages.vo";
+import type { HasRequestHeaders } from "./request-context.port";
+
+export class LanguageDetectorHeaderStrategy<T extends tools.LanguageType>
+  implements LanguageDetectorStrategy<T>
+{
+  detect(context: HasRequestHeaders, languages: Languages<T>): T | null {
+    const header = context.request.headers().get("Accept-Language");
+
+    if (!header) return null;
+
+    // Example Accept-Language header: en-US,en;q=0.9,pl;q=0.8
+    // Stryker disable all
+    const incoming = header
+      .split(",")
+      .map((language) => language.split(";")[0]?.trim().toLowerCase().split("-")[0]);
+    // Stryker restore all
+
+    return incoming.find((language) => languages.isSupported(language)) ?? null;
+  }
+}

package/src/language-detector-hono.middleware.ts

@@ -0,0 +1,29 @@
+import type * as tools from "@bgord/tools";
+import type { MiddlewareHandler } from "hono";
+import {
+  LanguageDetectorMiddleware,
+  type LanguageDetectorMiddlewareConfig,
+} from "./language-detector.middleware";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+
+export type LanguageDetectorVariables = { language: tools.LanguageType };
+
+export class LanguageDetectorHonoMiddleware<T extends tools.LanguageType> implements MiddlewareHonoPort {
+  private readonly middleware: LanguageDetectorMiddleware<T>;
+
+  constructor(config: LanguageDetectorMiddlewareConfig<T>) {
+    this.middleware = new LanguageDetectorMiddleware(config);
+  }
+
+  handle(): MiddlewareHandler {
+    return async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+
+      const language = this.middleware.evaluate(context);
+      c.set("language", language);
+
+      await next();
+    };
+  }
+}

package/src/language-detector-query.strategy.ts

@@ -0,0 +1,16 @@
+import type * as tools from "@bgord/tools";
+import type { LanguageDetectorStrategy } from "./language-detector.strategy";
+import type { Languages } from "./languages.vo";
+import type { HasRequestQuery } from "./request-context.port";
+
+export class LanguageDetectorQueryStrategy<T extends tools.LanguageType>
+  implements LanguageDetectorStrategy<T>
+{
+  constructor(private readonly name: string) {}
+
+  detect(context: HasRequestQuery, languages: Languages<T>): T | null {
+    const detected = context.request.query()[this.name];
+
+    return languages.isSupported(detected) ? detected : null;
+  }
+}

package/src/language-detector.middleware.ts

@@ -0,0 +1,28 @@
+import type * as tools from "@bgord/tools";
+import type { LanguageDetectorStrategy } from "./language-detector.strategy";
+import type { Languages } from "./languages.vo";
+import type { RequestContext } from "./request-context.port";
+
+export const LanguageDetectorMiddlewareError = {
+  MaxStrategies: "language.detector.middleware.max.strategies",
+};
+
+export type LanguageDetectorMiddlewareConfig<T extends tools.LanguageType> = {
+  languages: Languages<T>;
+  strategies: Array<LanguageDetectorStrategy<T>>;
+};
+
+export class LanguageDetectorMiddleware<T extends tools.LanguageType> {
+  constructor(private readonly config: LanguageDetectorMiddlewareConfig<T>) {
+    if (config.strategies.length > 5) throw new Error(LanguageDetectorMiddlewareError.MaxStrategies);
+  }
+
+  evaluate(context: RequestContext): T {
+    for (const strategy of this.config.strategies) {
+      const detected = strategy.detect(context, this.config.languages);
+      if (detected !== null) return detected;
+    }
+
+    return this.config.languages.fallback;
+  }
+}

package/src/language-detector.strategy.ts

@@ -0,0 +1,7 @@
+import type * as tools from "@bgord/tools";
+import type { Languages } from "./languages.vo";
+import type { RequestContext } from "./request-context.port";
+
+export interface LanguageDetectorStrategy<T extends tools.LanguageType> {
+  detect(context: RequestContext, languages: Languages<T>): T | null;
+}

package/src/languages.vo.ts

@@ -0,0 +1,27 @@
+import type * as tools from "@bgord/tools";
+
+export const LanguagesError = {
+  Empty: "languages.empty",
+  FallbackNotSupported: "languages.fallback.not.supported",
+};
+
+export class Languages<T extends tools.LanguageType> {
+  constructor(
+    readonly values: ReadonlyArray<T>,
+    readonly fallback: T,
+  ) {
+    if (values.length === 0) throw new Error(LanguagesError.Empty);
+    if (!values.includes(fallback)) throw new Error(LanguagesError.FallbackNotSupported);
+  }
+
+  get supported(): Record<T, T> {
+    return this.values.reduce(
+      (result, language) => ({ ...result, [language]: language }),
+      {} as Record<T, T>,
+    );
+  }
+
+  isSupported(value: unknown): value is T {
+    return this.values.includes(value as T);
+  }
+}

package/src/modules/preferences/command-handlers/handleSetUserLanguageCommand.ts

@@ -3,11 +3,15 @@ import type { ClockPort } from "../../../clock.port";
 import { createEventEnvelope } from "../../../event-envelope";
 import type { EventStoreLike } from "../../../event-store-like.types";
 import type { IdProviderPort } from "../../../id-provider.port";
+import type { Languages } from "../../../languages.vo";
 import type * as Commands from "../commands";
 import * as Events from "../events";
 import * as Invariants from "../invariants";
 import type * as Ports from "../ports";
-import type * as VO from "../value-objects";
+
+export const HandleSetUserLanguageCommandError = {
+  Missing: "handle.set.user.language.command.error.missing",
+};
 
 type Dependencies = {
   EventStore: EventStoreLike<AcceptedEvent>;
@@ -19,12 +23,15 @@ type Dependencies = {
 type AcceptedEvent = Events.UserLanguageSetEventType;
 
 export const handleSetUserLanguageCommand =
-  <L extends ReadonlyArray<tools.LanguageType>>(supported: VO.SupportedLanguagesSet<L>, deps: Dependencies) =>
+  <T extends tools.LanguageType>(languages: Languages<T>, deps: Dependencies) =>
   async (command: Commands.SetUserLanguageCommandType) => {
-    const candidate = supported.ensure(command.payload.language);
+    const candidate = command.payload.language;
+
+    if (!languages.isSupported(candidate)) throw new Error(HandleSetUserLanguageCommandError.Missing);
+
     const current = await deps.UserLanguageQuery.get(command.payload.userId);
 
-    if (!Invariants.UserLanguageHasChanged.passes({ current, candidate: command.payload.language })) return;
+    if (!Invariants.UserLanguageHasChanged.passes({ current, candidate })) return;
 
     const event = Events.UserLanguageSetEvent.parse({
       ...createEventEnvelope(`preferences_${command.payload.userId}`, deps),

package/src/modules/preferences/index.ts

@@ -4,4 +4,3 @@ export * as Events from "./events";
 export * as Invariants from "./invariants";
 export * as OHQ from "./open-host-queries";
 export * as Ports from "./ports";
-export * as VO from "./value-objects";

package/src/modules/preferences/open-host-queries/user-language.ts

@@ -1,23 +1,26 @@
 import type * as tools from "@bgord/tools";
+import type { Languages } from "../../../languages.vo";
 import type { UUIDType } from "../../../uuid.vo";
 import type * as Ports from "../ports";
-import type * as VO from "../value-objects";
 
-export interface UserLanguagePort<L extends ReadonlyArray<tools.LanguageType>> {
-  get(userId: UUIDType): Promise<L[number]>;
+export const UserLanguageAdapterError = { Missing: "user.language.ohq.error.missing" };
+
+export interface UserLanguagePort<T extends tools.LanguageType> {
+  get(userId: UUIDType): Promise<T>;
 }
 
-export class UserLanguageAdapter<L extends ReadonlyArray<tools.LanguageType>> implements UserLanguagePort<L> {
+export class UserLanguageAdapter<T extends tools.LanguageType> implements UserLanguagePort<T> {
   constructor(
+    private readonly languages: Languages<T>,
     private readonly query: Ports.UserLanguageQueryPort,
-    private readonly validator: VO.SupportedLanguagesSet<L>,
     private readonly resolver: Ports.UserLanguageResolverPort,
   ) {}
 
-  async get(userId: UUIDType): Promise<L[number]> {
+  async get(userId: UUIDType): Promise<T> {
     const stored = await this.query.get(userId);
     const candidate = await this.resolver.resolve(stored);
 
-    return this.validator.ensure(candidate);
+    if (!this.languages.isSupported(candidate)) throw new Error(UserLanguageAdapterError.Missing);
+    return candidate;
   }
 }

package/src/modules/preferences/ports/user-language-query.ts

@@ -1,5 +1,5 @@
 import type * as tools from "@bgord/tools";
 
 export interface UserLanguageQueryPort {
-  get(userId: tools.LanguageType): Promise<tools.LanguageType | null>;
+  get(userId: string): Promise<tools.LanguageType | null>;
 }

package/src/modules/preferences/ports/user-language-resolver.ts

@@ -1,4 +1,5 @@
 import type * as tools from "@bgord/tools";
+import type { Languages } from "../../../languages.vo";
 
 export interface UserLanguageResolverPort {
   resolve(input: tools.LanguageType | null): tools.LanguageType | Promise<tools.LanguageType>;
@@ -13,10 +14,12 @@ export class UserLanguageResolverThrowIfMissing implements UserLanguageResolverP
   }
 }
 
-export class UserLanguageResolverSystemDefaultFallback implements UserLanguageResolverPort {
-  constructor(private readonly systemDefaultLanguage: tools.LanguageType) {}
+export class UserLanguageResolverSystemDefaultFallback<T extends tools.LanguageType>
+  implements UserLanguageResolverPort
+{
+  constructor(private readonly languages: Languages<T>) {}
 
   resolve(stored: tools.LanguageType | null) {
-    return stored ?? this.systemDefaultLanguage;
+    return stored ?? this.languages.fallback;
   }
 }

package/src/prerequisite-verifier-translations.adapter.ts

@@ -2,6 +2,7 @@ import type * as tools from "@bgord/tools";
 import type { FileReaderJsonPort } from "./file-reader-json.port";
 import type * as types from "./i18n.service";
 import { I18n } from "./i18n.service";
+import type { Languages } from "./languages.vo";
 import type { LoggerPort } from "./logger.port";
 import {
   PrerequisiteVerification,
@@ -16,21 +17,22 @@ type PrerequisiteTranslationsProblemType = {
 };
 
 type Dependencies = { Logger: LoggerPort; FileReaderJson: FileReaderJsonPort };
-type Config = { supportedLanguages: types.I18nConfig["supportedLanguages"] };
 
-export class PrerequisiteVerifierTranslationsAdapter implements PrerequisiteVerifierPort {
+export class PrerequisiteVerifierTranslationsAdapter<T extends tools.LanguageType>
+  implements PrerequisiteVerifierPort
+{
   constructor(
-    private readonly config: Config,
+    private readonly config: Languages<T>,
     private readonly deps: Dependencies,
   ) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
-    const supportedLanguages = Object.keys(this.config.supportedLanguages);
     const i18n = new I18n(this.deps);
+    const languages = this.config.values;
 
-    const dictionary: Partial<Record<tools.LanguageType, ReadonlyArray<types.TranslationsKeyType>>> = {};
+    const dictionary: Partial<Record<T, ReadonlyArray<types.TranslationsKeyType>>> = {};
 
-    for (const language of supportedLanguages) {
+    for (const language of languages) {
       try {
         const translations = await i18n.getTranslations(language);
         dictionary[language] = Object.keys(translations);
@@ -47,7 +49,7 @@ export class PrerequisiteVerifierTranslationsAdapter implements PrerequisiteVeri
       // Stryker restore all
 
       for (const phrase of phrases) {
-        for (const supportedLanguage of supportedLanguages) {
+        for (const supportedLanguage of languages) {
           const phraseExists = new Set(dictionary[supportedLanguage]).has(phrase);
 
           if (!phraseExists) problems.push({ key: phrase, existsIn: language, missingIn: supportedLanguage });

package/src/setup-hono.service.ts

@@ -1,6 +1,6 @@
 import * as tools from "@bgord/tools";
+import type { MiddlewareHandler } from "hono";
 import { cors } from "hono/cors";
-import { languageDetector } from "hono/language";
 import { secureHeaders } from "hono/secure-headers";
 import { ApiVersionHonoMiddleware } from "./api-version-hono.middleware";
 import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
@@ -11,8 +11,9 @@ import { ETagExtractorHonoMiddleware } from "./etag-extractor-hono.middleware";
 import type { HashContentStrategy } from "./hash-content.strategy";
 import type { HttpLoggerConfig } from "./http-logger.middleware";
 import { HttpLoggerHonoMiddleware } from "./http-logger-hono.middleware";
-import type { I18nConfig } from "./i18n.service";
 import type { IdProviderPort } from "./id-provider.port";
+import type { LanguageDetectorMiddlewareConfig } from "./language-detector.middleware";
+import { LanguageDetectorHonoMiddleware } from "./language-detector-hono.middleware";
 import type { LoggerPort } from "./logger.port";
 import type { ShieldCsrfConfig } from "./shield-csrf.strategy";
 import { ShieldCsrfHonoStrategy } from "./shield-csrf-hono.strategy";
@@ -26,15 +27,15 @@ import { WeakETagExtractorHonoMiddleware } from "./weak-etag-extractor-hono.midd
 type Dependencies = {
   Logger: LoggerPort;
   IdProvider: IdProviderPort;
-  I18n: I18nConfig;
   Clock: ClockPort;
   CacheResolver: CacheResolverStrategy;
   HashContent: HashContentStrategy;
   BuildInfoRepository: BuildInfoRepositoryStrategy;
 };
 
-type Config = {
+type Config<T extends tools.LanguageType> = {
   csrf: ShieldCsrfConfig;
+  I18n: LanguageDetectorMiddlewareConfig<T>;
   cors?: Parameters<typeof cors>[0];
   httpLogger?: HttpLoggerConfig;
   maintenanceMode?: ShieldMaintenanceConfig;
@@ -44,7 +45,10 @@ export class SetupHono {
   // Configure body size limit at the framework level
   // - Bun: maxRequestBodySize in Bun.serve()
   // - Express: limit in express.json()
-  static essentials(config: Config, deps: Dependencies) {
+  static essentials<T extends tools.LanguageType>(
+    config: Config<T>,
+    deps: Dependencies,
+  ): Array<MiddlewareHandler> {
     return [
       new ShieldMaintenanceHonoStrategy(config.maintenanceMode).handle(),
       new TrailingSlashHonoMiddleware().handle(),
@@ -80,13 +84,7 @@ export class SetupHono {
         maxAge: tools.Duration.Minutes(10).seconds,
         ...config.cors,
       }),
-      languageDetector({
-        supportedLanguages: Object.keys(deps.I18n.supportedLanguages),
-        fallbackLanguage: deps.I18n.defaultLanguage,
-        // Stryker disable all
-        caches: false,
-        // Stryker restore all
-      }),
+      new LanguageDetectorHonoMiddleware(config.I18n).handle(),
       new TimeZoneOffsetHonoMiddleware().handle(),
       new WeakETagExtractorHonoMiddleware().handle(),
       new ETagExtractorHonoMiddleware().handle(),

package/src/translations-hono.handler.ts

@@ -1,22 +1,25 @@
+import type * as tools from "@bgord/tools";
 import { createFactory } from "hono/factory";
 import type { FileReaderJsonPort } from "./file-reader-json.port";
 import type { HandlerHonoPort } from "./handler-hono.port";
+import type { LanguageDetectorVariables } from "./language-detector-hono.middleware";
+import type { Languages } from "./languages.vo";
 import type { LoggerPort } from "./logger.port";
-import { type TranslationsConfig, TranslationsHandler } from "./translations.handler";
+import { TranslationsHandler } from "./translations.handler";
 
 type Dependencies = { FileReaderJson: FileReaderJsonPort; Logger: LoggerPort };
 
 const factory = createFactory();
 
-export class TranslationsHonoHandler implements HandlerHonoPort {
-  private readonly handler: TranslationsHandler;
+export class TranslationsHonoHandler<T extends tools.LanguageType> implements HandlerHonoPort {
+  private readonly handler: TranslationsHandler<T>;
 
-  constructor(config: TranslationsConfig, deps: Dependencies) {
+  constructor(config: Languages<T>, deps: Dependencies) {
     this.handler = new TranslationsHandler(config, deps);
   }
 
   handle() {
-    return factory.createHandlers(async (c) => {
+    return factory.createHandlers<{}, any, { Variables: LanguageDetectorVariables }>(async (c) => {
       const language = c.get("language");
       const result = await this.handler.execute(language);
 

package/src/translations.handler.ts

@@ -1,31 +1,30 @@
 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 { I18n, type TranslationsType } from "./i18n.service";
+import type { Languages } from "./languages.vo";
 import type { LoggerPort } from "./logger.port";
 
-export type TranslationsConfig = TranslationsSupportedLanguagesType;
-
 type Dependencies = { FileReaderJson: FileReaderJsonPort; Logger: LoggerPort };
 
-export type TranslationsResult = {
+export type TranslationsResult<T extends tools.LanguageType> = {
   translations: TranslationsType;
   language: tools.LanguageType;
-  supportedLanguages: TranslationsSupportedLanguagesType;
+  supportedLanguages: Languages<T>["supported"];
 };
 
-export class TranslationsHandler {
+export class TranslationsHandler<T extends tools.LanguageType> {
   constructor(
-    private readonly config: TranslationsConfig,
+    private readonly config: Languages<T>,
     private readonly deps: Dependencies,
   ) {}
 
-  async execute(language: string): Promise<TranslationsResult> {
+  async execute(language: tools.LanguageType): Promise<TranslationsResult<T>> {
     const translations = await new I18n(this.deps).getTranslations(language);
 
     return {
       translations,
       language,
-      supportedLanguages: this.config,
+      supportedLanguages: this.config.supported,
     };
   }
 }

package/dist/modules/preferences/value-objects/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./supported-languages-set";
-//# sourceMappingURL=index.d.ts.map

package/dist/modules/preferences/value-objects/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/preferences/value-objects/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/dist/modules/preferences/value-objects/index.js

@@ -1,2 +0,0 @@
-export * from "./supported-languages-set";
-//# sourceMappingURL=index.js.map

package/dist/modules/preferences/value-objects/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/modules/preferences/value-objects/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/dist/modules/preferences/value-objects/supported-languages-set.d.ts

@@ -1,10 +0,0 @@
-import type * as tools from "@bgord/tools";
-export declare const SupportedLanguagesSetError: {
-    Missing: string;
-};
-export declare class SupportedLanguagesSet<L extends ReadonlyArray<tools.LanguageType>> {
-    private readonly index;
-    constructor(allowed: L);
-    ensure(language: tools.LanguageType): L[number];
-}
-//# sourceMappingURL=supported-languages-set.d.ts.map

package/dist/modules/preferences/value-objects/supported-languages-set.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"supported-languages-set.d.ts","sourceRoot":"","sources":["../../../../src/modules/preferences/value-objects/supported-languages-set.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAE3C,eAAO,MAAM,0BAA0B;;CAAuD,CAAC;AAE/F,qBAAa,qBAAqB,CAAC,CAAC,SAAS,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC;IAC5E,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA0B;gBAEpC,OAAO,EAAE,CAAC;IAKtB,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;CAIhD"}

package/dist/modules/preferences/value-objects/supported-languages-set.js

@@ -1,14 +0,0 @@
-export const SupportedLanguagesSetError = { Missing: "supported.languages.set.error.missing" };
-export class SupportedLanguagesSet {
-    index;
-    constructor(allowed) {
-        this.index = new Set(allowed);
-        Object.freeze(this);
-    }
-    ensure(language) {
-        if (!this.index.has(language))
-            throw new Error(SupportedLanguagesSetError.Missing);
-        return language;
-    }
-}
-//# sourceMappingURL=supported-languages-set.js.map

package/dist/modules/preferences/value-objects/supported-languages-set.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"supported-languages-set.js","sourceRoot":"","sources":["../../../../src/modules/preferences/value-objects/supported-languages-set.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,OAAO,EAAE,uCAAuC,EAAE,CAAC;AAE/F,MAAM,OAAO,qBAAqB;IACf,KAAK,CAA0B;IAEhD,YAAY,OAAU;QACpB,IAAI,CAAC,KAAK,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC;QAC9B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACtB,CAAC;IAED,MAAM,CAAC,QAA4B;QACjC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,OAAO,CAAC,CAAC;QACnF,OAAO,QAAqB,CAAC;IAC/B,CAAC;CACF"}

package/src/modules/preferences/value-objects/index.ts

@@ -1 +0,0 @@
-export * from "./supported-languages-set";

package/src/modules/preferences/value-objects/supported-languages-set.ts

@@ -1,17 +0,0 @@
-import type * as tools from "@bgord/tools";
-
-export const SupportedLanguagesSetError = { Missing: "supported.languages.set.error.missing" };
-
-export class SupportedLanguagesSet<L extends ReadonlyArray<tools.LanguageType>> {
-  private readonly index: Set<tools.LanguageType>;
-
-  constructor(allowed: L) {
-    this.index = new Set(allowed);
-    Object.freeze(this);
-  }
-
-  ensure(language: tools.LanguageType): L[number] {
-    if (!this.index.has(language)) throw new Error(SupportedLanguagesSetError.Missing);
-    return language as L[number];
-  }
-}